CEGUI (Crazy Eddie's GUI) Forums

Hello again

I am trying to make CEGUI render to a specific texture unit in a material.
The goal is to enable rendering of any number of GUIs into any arbitrary texture units at the same time.
But I already fail with only one

My code is the following:



It does successfully replace the texture on the material, but only with a black, transparent texture.
I assume that CEGUI never really renders into the texture, but how can I make it?
The logs do not show anything strange, so I suspect I am forgetting something here.

As an additional info, the material is on a compositor pass rendering a fullscreen quad.
Also, I am using the latest bitbucket version of 0.8.

I also read the article about general RTT ( this one ), but I do not even know where to start with that approach. How would you load and display a layout with that? When would you have to call that .draw()-function in Ogre (maybe within a RenderTargetListener?). Do you create such a context per loaded layout or per texture you want to render to?
It leaves so many open questions that I thought the above approach would be better suited.

Did you manage to have CEGUI render the GUI correctly inside Ogre in the regular way, and updating/re-rendering it every frame correctly? You should start with that.

TheSHEEEP wrote:Hello again

I am trying to make CEGUI render to a specific texture unit in a material.
The goal is to enable rendering of any number of GUIs into any arbitrary texture units at the same time.
But I already fail with only one

My code is the following:

Code: Select all

// Create CEGUI renderer
    CEGUI::OgreRenderer& renderer =
            CEGUI::OgreRenderer::bootstrapSystem(
                *static_cast<Ogre::RenderTarget*>(p_window->getOgreWindow())
            );
   
    // Set resource paths
    CEGUI::ImageManager::setImagesetDefaultResourceGroup("Gui");
    CEGUI::Font::setDefaultResourceGroup("Gui");
    CEGUI::Scheme::setDefaultResourceGroup("Gui");
    CEGUI::WidgetLookManager::setDefaultResourceGroup("Gui");
    CEGUI::WindowManager::setDefaultResourceGroup("Gui");
   
    // Init CEGUI
    CEGUI::ImageManager::getSingleton().loadImageset("TaharezLook.imageset", "Gui");
    CEGUI::SchemeManager::getSingleton().createFromFile("TaharezLook.scheme", "Gui");
   
    // Load a layout
    CEGUI::Window* window = CEGUI::WindowManager::getSingleton()
            .loadLayoutFromFile((CEGUI::utf8*)"TextSample.layout");
    window->setUsingAutoRenderingSurface( true );

    // Get the Ogre texture
    CEGUI::OgreTextureTarget& textureTarget =
            dynamic_cast<CEGUI::OgreTextureTarget&>(window->getRenderingSurface()->getRenderTarget());
    CEGUI::Texture& ceTex = textureTarget.getTexture();
    CEGUI::OgreTexture& ogreTexture = static_cast<CEGUI::OgreTexture&>(ceTex);   
    Ogre::TexturePtr ogreTexturePtr = ogreTexture.getOgreTexture();
   
    // Find the material
    Ogre::MaterialPtr matPtr = Ogre::MaterialManager::getSingleton().getByName("FullscreenOverlay");
    // Find the technique
    Ogre::Technique* technique = matPtr->getTechnique("Tech");
    // Find the pass
    Ogre::Pass* pass = technique->getPass("Pass");
    // Find the texture unit, get its original texture and replace the texture
    Ogre::TextureUnitState* textureUnit = pass->getTextureUnitState("Texture");
    Ogre::String name = ogreTexturePtr->getName();
    textureUnit->setTextureName(name);


It does successfully replace the texture on the material, but only with a black, transparent texture.
I assume that CEGUI never really renders into the texture, but how can I make it?
The logs do not show anything strange, so I suspect I am forgetting something here.

As an additional info, the material is on a compositor pass rendering a fullscreen quad.
Also, I am using the latest bitbucket version of 0.8.

I also read the article about general RTT ( this one ), but I do not even know where to start with that approach. How would you load and display a layout with that? When would you have to call that .draw()-function in Ogre (maybe within a RenderTargetListener?). Do you create such a context per loaded layout or per texture you want to render to?
It leaves so many open questions that I thought the above approach would be better suited.

I think the problem may be that main window from your layout is not being displayed either via setWindowRoot or added as a child of another windown being rendered. In your main loop try adding window->render(), this should update your texture but will also render the layout window in the CEGUI default window which I guess you don't want.

Maybe you could try the above with a context you create yourself, don't draw, just render the window. I think that since CEGUI isn't the owner of the context it won't render to the screen, just your texture.

For example (won't work for a DefaultWindow), sorry about the code code cut and paste job:

Sorry for coming back on this so late.

I actually did a lot of testing and trial and error. But I ended up with something that seems to be working.
It is a mixture of my original approach with the GuiContext one.



My first error was indeed not calling window->render(). But I also had to create a new GuiContext (after noticing it was also a RenderSurface) and assign that to the loaded window.
With that, I can now call render() whenever I want, it seems. Which is very useful as there will be GUI elements that won't need to be updated regularly.

I would honestly suggest updating the RTT wiki entry with an example of how to use it with a loaded layout. It really took me hours to figure it out.
Or at least add a hint that a GuiContext is also a RendererSurface which can be assigned to a window.

That GuiContext->draw() from the wiki entry however I do not use. It is probably called by window->render() indirectly.

TheSHEEEP wrote:I would honestly suggest updating the RTT wiki entry with an example of how to use it with a loaded layout. It really took me hours to figure it out.
Or at least add a hint that a GuiContext is also a RendererSurface which can be assigned to a window.

Do it

That's your job

But I did it anyway

I will test my implementation a bit more before I set this to SOLVED.

TheSHEEEP wrote:That's your job

What made you think so?

Did anything give you the impression this was not a community wiki? If yes, what would you suggest to change at the wiki to make it instantly be perceived as a community wiki by users?

TheSHEEEP wrote:I will test my implementation a bit more before I set this to SOLVED.

That's generally always a good idea

Well, it works almost.

The first problem is that there is no transparency outside of the rendered GUI. Everything is black.
The alpha value is 1 everywhere.

That is very strange, since the same layout rendered normally (directly to the Ogre window) works just fine.
Only if rendered the way I described above, CEGUI applies wrong transparency somehow.

The second problem is that the displayed layout has a wrong position. I am loading the console.layout from the sample, so it should display in the center bottom of the screen.
It is, however, in the upper left.

Here is a screenshot:
Link

TheSHEEEP wrote:Well, it works almost.

The problem is that there is no transparency outside of the rendered GUI. Everything is black.
The alpha value is 1 everywhere.

That is very strange, since the same layout rendered normally (directly to the Ogre window) works just fine.
Only if rendered the way I described above, CEGUI applies wrong transparency somehow.

Screenshot please.

Also could you please answer regarding the Wiki? There is relatively few people editing the Wiki and your statement hints toward that there might be a misunderstanding about what the Wiki is.

I added a screenshot to my last post.

About the wiki:
Well, my comment was more aimed at the fact that someone should put up an example who knows what he is doing. I don't really, I am just trying to understand things
And it seems that what I do is still somehow wrong. Or at least missing something.

TheSHEEEP wrote:Well, my comment was more aimed at the fact that someone should put up an example who knows what he is doing. I don't really, I am just trying to understand things
And it seems that what I do is still somehow wrong.

I didnt to what you are doing with this stuff, therefore you have more knowledge right now about this than I do. The info I put there seemed sufficient for everything I did. I didnt run into the issues you did but also i didnt use Ogre for this, so I cant write anything about it there...


Regarding the screenshot: What did you expect? I need an image for comparison to understand what is even wrong. Also post your layout's code.

Oh, yes, I probably should have said that
There is an actual 3D scene behind the GUI

Which is clearly visible before I assign the Ogre texture CEGUI created to the texture_unit of the material that serves as the gui target.
It is a material used by a full screen compositor, actually.
The standard texture (which is replaced by the Ogre texture CEGUI produces) in that material is a transparent image, so transparency definitely works on that material.

The layout's code is really just the console.layout from the samples:

In your code you never set the GUIContexts root to be the loaded layout. This is also the case in the wiki. You have to do that for the GUIContext youcreate for the RTT.

I just saw you set the GUIContext as rendertarget of the layout. Where did you get that idea from? You are supposed to set the guicontext's rendertarget and not the other way around. Also you are supposd to call the guicontexts draw function for drawing.

The wiki article doesnt cover how GUIContexts work becasue it is assumed that the user already knows this. So to clear that up:

1. create GuiContext using a RenderTarget such as a Texture (shown in the wiki article)
2. set the guicontexts root by setting the root window (remember, the root window should be a 1,1 rel sized (fully covering) DefaultWindiw, everything else can be attached to that). This is basically where your layout is added.
3. Render the GUIContext with the GUIContext-specific draw functions which will automatically render to the Texture.

For more info check out the SampleBrowser code. This is a vey specific use-case which is however a bit similar to yours so you might find some useful code. The difference is that we dont render into an Ogre Texture there. Instead we render in a way so that the resulting texture can be reused inside CEGUI again.

I'll answer your question first, then try out your suggestions

Ident wrote:I just saw you set the GUIContext as rendertarget of the layout. Where did you get that idea from? You are supposed to set the guicontext's rendertarget and not the other way around. Also you are supposd to call the guicontexts draw function for drawing.

Well, it seems to make sense, doesn't it?
The window has a RenderSurface it renders to (at least that is what I would expect a RenderSurface is for). GuiContext is a RenderSurface.
Hence, window should be able to render into a GuiContext. For someone who is new, I think that sounds logical

TheSHEEEP wrote:

Ident wrote:I just saw you set the GUIContext as rendertarget of the layout. Where did you get that idea from? You are supposed to set the guicontext's rendertarget and not the other way around. Also you are supposd to call the guicontexts draw function for drawing.

Well, it seems to make sense, doesn't it?
The window has a RenderSurface it renders to (at least that is what I would expect a RenderSurface is for). GuiContext is a RenderSurface.
Hence, window should be able to render into a GuiContext. For someone who is new, I think that sounds logical

And how do you interact with a RenderSurface? Where do the inputs go? Into the widget? It sounds logical only for the rendering part, but not for everything else. I give you that though: it sounds like it works fine for rendering. Also basically it should or could work the way you are doing it but in the end it is kind of hack-ish and afaik we do not suggest to do this this way anywhere in the docu.

If you want the full functionality you are supposed to use a GUIContext which allows RTT. What you are doing is that you use the auto-rendering-surface functionality to draw into a texture.It is indirect and could lead to issues. The auto-rendering-surface functionality is mostly meant to be used for caching of complex but barely changing window hierarchies, in most cases it is totally useless. It is also required for rotational animations I think, but this is due to sampling stuff. I guess this info could all be added to the wiki article.

So overall your approach "might work" but this is not how it should generally be done, and since we dont really anticipatesuch usage there could be issues.

Lets let you change over to GUIContexts first though. I assume you want the full pakage of interaction etc in your RTT GUI Texture, dont you? So you will definitely need a GUIContext.