// Put this to a static initialize which is called before any OgreRenderer instances are created

// Define a workspace template //

auto templatedworkspace = manager->addWorkspaceDefinition("CEGUI_workspace");


// Create a node //

auto rendernode = manager->addNodeDefinition("OverlayRenderNode");

// Use the render target passed from the workspace for rendering on top of //

rendernode->addTextureSourceName("renderwindow", 0, TextureDefinitionBase::TEXTURE_INPUT);


// Pass for it //

auto targetpasses = rendernode->addTargetPass("renderwindow");



Ogre::CompositorPassClearDef* clearpass = static_cast<Ogre::CompositorPassClearDef*>(targetpasses->addPass(Ogre::PASS_CLEAR));


// Only clear depth and stencil since we are rendering on top of existing image //

clearpass->mClearBufferFlags = Ogre::FBT_DEPTH | Ogre::FBT_STENCIL;


// Now the render scene pass during which the render queue listener should render the GUI //

Ogre::CompositorPassSceneDef* scenepass = static_cast<Ogre::CompositorPassSceneDef*>(targetpasses->addPass(Ogre::PASS_SCENE));


// Just render the overlay group since it is the only one used //

scenepass->mFirstRQ = Ogre::RENDER_QUEUE_OVERLAY;

scenepass->mLastRQ = Ogre::RENDER_QUEUE_OVERLAY;


// Connect the main render target to the node //

templatedworkspace->connectOutput("OverlayRenderNode", 0);


// Then put this into initialize method for all individual OgreRenderers (every window should have their own and they should

// have some of the functionality moved to a static class/OgreRenderMaster class

Ogre::Root& root = Ogre::Root::getSingleton();


// Set up a scene to use //

// These might not be required, but since they are empty it shouldn't matter that much

auto OverlayScene = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_INTERIOR, 1, Ogre::INSTANCING_CULLING_SINGLETHREAD,



auto OverLayCamera = OverlayScene->createCamera("empty camera");


Ogre::CompositorManager2* manager = root.getCompositorManager2();


// This is the part that replaces the ViewPorts


// Create the workspace to the render target //

// Pass this as a parameter to this function

Ogre::RenderTarget* target = NULL;

// The -1 should quarantee this to be rendered last on top of everything

manager->addWorkspace(OverlayScene, target, OverLayCamera, "CEGUI_rendering_for_window0", true, -1);


// TODO: start listening for RENDER_QUEUE_OVERLAY rendering and render during it //

// What this should accomplish is that pretty much everything else except setting up the matrices can be removed and of course the render queue listener

// needs to be added



static class OgreGUIFrameListener : public Ogre::RenderQueueListener



            OgreGUIFrameListener(OgreRenderer* owner) : Owner(Owner), d_enabled(true){};


            void setCEGUIRenderEnabled(bool enabled);

            bool isCEGUIRenderEnabled() const;


            virtual void renderQueueStarted(RenderQueue *rq, uint8 queueGroupId, const String& invocation, bool& skipThisInvocation){

                         if (d_enabled){


                                     // We should only render contexts that are on this render target //

                                     // Pass pointer to the renderer here //



                                     // Stuff from System::renderAllGUIContexts

                                     // We should get the right context from the OgreRenderer instance somehow


                                     // Maybe a vector



                                     // This probably should only be called once //

                                     // do final destruction on dead-pool windows



                                     // This wouldn't even be required //







            bool d_enabled;

            OgreRenderer* Owner;


} S_frameListener;



void OgreRenderer::beginRendering()


            // Should now be called from the render queue listener //




void OgreRenderer::endRendering()


            // Cleanup should no longer be required, at least it would be quite hard to try to restore the matrices etc //