OGRE3D / CEGUI Testcode

#include "OGRE/OgreRoot.h"
#include "OGRE/OgreRenderSystem.h"
#include "OGRE/OgreRenderWindow.h"
#include "OGRE/OgreViewport.h"
#include "OGRE/OgreWindowEventUtilities.h"
#include "OGRE/OgreLogManager.h"
#include "OGRE/OgreResourceGroupManager.h"

#include "OGRE/OgreEntity.h"

#include "OGRE/OgreCamera.h"

#include "OGRE/Compositor/OgreCompositorManager2.h"

#include "OGRE/OgreArchiveManager.h"
#include "OGRE/OgreArchive.h"
#include "OGRE/OgreMeshManager.h"
#include "OGRE/OgreMeshManager2.h"
#include "OGRE/OgreMesh.h"
#include "OGRE/OgreMesh2.h"

#include "OGRE/Hlms/Unlit/OgreHlmsUnlit.h"
#include "OGRE/Hlms/Pbs/OgreHlmsPbs.h"
#include "OGRE/OgreHlmsManager.h"

#include <CEGUI/CEGUI.h>
#include <CEGUI/RendererModules/Ogre/Renderer.h>

#include <iostream>
#include <memory>
#include <exception>
#include "windows.h"

INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
{
    try
    {
        std::unique_ptr<Ogre::Root> lRoot(new Ogre::Root("", "", "ogre.log"));

        typedef std::vector<Ogre::String> Strings;


        // Load the RenderSystem
        Strings lPluginNames;
        lPluginNames.push_back("RenderSystem_GL3Plus");
        //lPluginNames.push_back("RenderSystem_Direct3D11");

        Strings::iterator lIter = lPluginNames.begin();
        Strings::iterator lIterEnd = lPluginNames.end();
        for(;lIter != lIterEnd; lIter++)
        {
            Ogre::String& lPluginName = (*lIter);
            // In debug mode, the plugins names are differents, they got a '_d' at the end.
            // So I add it. This is the main reason why I needed to put plugins names in a vector.
            // A macro or a function would have done the trick too...
            bool lIsInDebugMode = OGRE_DEBUG_MODE;
            if(lIsInDebugMode)
            {
                lPluginName.append("_d");
            }
            lRoot->loadPlugin(lPluginName);
        }

        // Set the Rendersystem
        const Ogre::RenderSystemList& lRenderSystemList = lRoot->getAvailableRenderers();
        if( lRenderSystemList.size() == 0 )
        {
            Ogre::LogManager::getSingleton().logMessage("Sorry, no rendersystem was found.");
            return 1;
        }

        // Initialize root
        Ogre::RenderSystem *lRenderSystem = lRenderSystemList[0];
        lRoot->setRenderSystem(lRenderSystem);

        bool lCreateAWindowAutomatically = false;
        // name of the automatically generated window. empty for me.
        Ogre::String lWindowTitle = "";
        // custom capabilities of the rendersystem. It's a feature for advanced use.
        Ogre::String lCustomCapacities = "";
        lRoot->initialise(lCreateAWindowAutomatically, lWindowTitle, lCustomCapacities);

        // Create Window
        Ogre::RenderWindow* lWindow = NULL;
        {
            Ogre::String lWindowTitle = "Hello  World!";
            unsigned int lSizeX = 800;
            unsigned int lSizeY = 600;

            //I don't want to use fullscreen during development.
            bool lFullscreen = false;

            // This is just an example of parameters that we can put. Check the API for more details.
            Ogre::NameValuePairList lParams;

            // fullscreen antialiasing. (check wikipedia if needed).
            lParams["FSAA"] = "0";

            // vertical synchronisation will prevent some image-tearing, but also
            // will provide smooth framerate in windowed mode.(check wikipedia if needed).
            lParams["vsync"] = "true";
            lWindow = lRoot->createRenderWindow(lWindowTitle, lSizeX, lSizeY, lFullscreen, &lParams);
        }

        // Create Scenemanager
        Ogre::SceneManager *lSceneMgr=lRoot->createSceneManager("DefaultSceneManager", 1, Ogre::INSTANCING_CULLING_SINGLETHREAD);

        // Init of Hlms
        Ogre::String dataFolder = "media/Hlms/";

        Ogre::Archive *archiveLibrary = Ogre::ArchiveManager::getSingletonPtr()->load(dataFolder + "Common/GLSL", "FileSystem", true);
        Ogre::ArchiveVec library;
        library.push_back(archiveLibrary);

        Ogre::Archive *archiveUnlit = Ogre::ArchiveManager::getSingletonPtr()->load(dataFolder + "Unlit/GLSL", "FileSystem", true);
        Ogre::HlmsUnlit *hlmsUnlit = OGRE_NEW Ogre::HlmsUnlit (archiveUnlit, &library);
        Ogre::Root::getSingleton().getHlmsManager()->registerHlms(hlmsUnlit);

        Ogre::Archive *archivePbs = Ogre::ArchiveManager::getSingletonPtr()->load(dataFolder + "Pbs/GLSL", "FileSystem", true);
        Ogre::HlmsPbs *hlmsPbs = OGRE_NEW Ogre::HlmsPbs(archivePbs, &library);

        Ogre::Root::getSingleton().getHlmsManager()->registerHlms(hlmsPbs);

        // Ressourceloader
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("media/models", "FileSystem", "Standard");

        // Resources for CEGUI
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("media/cegui/imagesets", "FileSystem", "Imagesets");
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("media/cegui/fonts", "FileSystem", "Fonts");
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("media/cegui/animations", "FileSystem", "Animations");
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("media/cegui/layouts", "FileSystem", "Layouts");
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("media/cegui/looknfeel", "FileSystem", "LookNFeel");
        Ogre::ResourceGroupManager::getSingleton().addResourceLocation("media/cegui/schemes", "FileSystem", "Schemes");

        Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();


        // Create Camera
        Ogre::Camera *lCamera;
        lCamera = lSceneMgr->createCamera("Camera");
        lCamera->setPosition(Ogre::Vector3(0, 0, 180));
        lCamera->lookAt(Ogre::Vector3(0, 0 ,0));
        lCamera->setNearClipDistance( 5 );
        lCamera->setAutoAspectRatio( true );

        // CompositorManager - something new in Ogre3D 2.1
        Ogre::CompositorManager2 *compositorManager = lRoot->getCompositorManager2();
        const Ogre::IdString workspaceName( "Workspace" );
        if( !compositorManager->hasWorkspaceDefinition( workspaceName ) )
        {
            compositorManager->createBasicWorkspaceDef( workspaceName, Ogre::ColourValue::Red );
        }
        compositorManager->addWorkspace( lSceneMgr, lWindow, lCamera, workspaceName, true );

        // Testmesh...
        /**
        Ogre::v1::Entity* atheneMesh = lSceneMgr->createEntity("athene.mesh");
        atheneMesh->setMaterialName("BaseWhite");
        Ogre::SceneNode* node1 = lSceneMgr->getRootSceneNode()->createChildSceneNode();
        node1->attachObject(atheneMesh);
        **/
        Ogre::v1::MeshPtr v1Mesh;
        Ogre::MeshPtr v2Mesh;

        v1Mesh = Ogre::v1::MeshManager::getSingleton().load("athene.mesh", Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME, Ogre::v1::HardwareBuffer::HBU_STATIC, Ogre::v1::HardwareBuffer::HBU_STATIC );
        v2Mesh = Ogre::MeshManager::getSingleton().createManual("athene.mesh Imported", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );

        bool halfPosition   = true;
        bool halfUVs        = true;
        bool useQtangents   = true;

        v2Mesh->importV1( v1Mesh.get(), halfPosition, halfUVs, useQtangents );
        v1Mesh->unload();

        Ogre::Item *item = lSceneMgr->createItem( "athene.mesh Imported", Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME, Ogre::SCENE_DYNAMIC);
        Ogre::SceneNode *sceneNode = lSceneMgr->getRootSceneNode(Ogre::SCENE_DYNAMIC)->createChildSceneNode( Ogre::SCENE_DYNAMIC );
        sceneNode->attachObject( (Ogre::MovableObject*) item );
        sceneNode->scale( 0.1f, 0.1f, 0.1f );

        lSceneMgr->setAmbientLight( Ogre::ColourValue( 0.5, 0.5, 0.5 ) );

        Ogre::SceneNode * lightNode = lSceneMgr->getRootSceneNode()->createChildSceneNode();
        lightNode->setPosition( Ogre::Vector3( 20, 80, 50 ) );
        Ogre::Light * light = lSceneMgr->createLight();
        lightNode->attachObject( light );

        // CEGUI
        Ogre::RenderTarget *mRenderTarget = lWindow;
        CEGUI::OgreRenderer& myRenderer = CEGUI::OgreRenderer::bootstrapSystem(*mRenderTarget);

        CEGUI::ImageManager::setImagesetDefaultResourceGroup("Imagesets");
        CEGUI::Font::setDefaultResourceGroup("Fonts");
        CEGUI::Scheme::setDefaultResourceGroup("Schemes");
        CEGUI::WidgetLookManager::setDefaultResourceGroup("LookNFeel");
        CEGUI::WindowManager::setDefaultResourceGroup("Layouts");

        CEGUI::SchemeManager::getSingleton().createFromFile("TaharezLook.scheme");
        CEGUI::System::getSingleton().getDefaultGUIContext().getMouseCursor().setDefaultImage("TaharezLook/MouseArrow");

        // Testbutton
        CEGUI::WindowManager &wmgr = CEGUI::WindowManager::getSingleton();
        CEGUI::Window *sheet = wmgr.createWindow("DefaultWindow", "CEGUIDemo/Sheet");
        CEGUI::Window *quit = wmgr.createWindow("TaharezLook/Button", "CEGUIDemo/QuitButton");
        quit->setText("Quit");
        quit->setSize(CEGUI::USize(CEGUI::UDim(0.15, 0), CEGUI::UDim(0.05, 0)));
        sheet->addChild(quit);
        CEGUI::System::getSingleton().getDefaultGUIContext().setRootWindow(sheet);

        bool renderWindow=CEGUI::System::getSingleton().getDefaultGUIContext().isRenderingWindow();
        bool renderEnabled=myRenderer.isRenderingEnabled();

        // Messagepump
        while(!lWindow->isClosed())
        {
            float dt = 1e-2f;

            CEGUI::GUIContext& defaultGUIContext(CEGUI::System::getSingleton().getDefaultGUIContext());
            defaultGUIContext.injectTimePulse(dt);

            CEGUI::System::getSingleton().renderAllGUIContexts();

            lRoot->renderOneFrame();
            Ogre::WindowEventUtilities::messagePump();
        }

    }
    catch(std::exception &e)
    {
        std::cout << "!!!std:exception!!!" << e.what() << std::endl;
    }

    return 1;
}