History: BasicTutorial7Source

#include "ExampleApplication.h"
 #include <OIS/OIS.h>
 #include <CEGUI/CEGUI.h> 
 #include <CEGUI/RendererModules/Ogre/CEGUIOgreRenderer.h>
 
 CEGUI::MouseButton convertButton(OIS::MouseButtonID buttonID)
 {
     switch (buttonID)
     {
     case OIS::MB_Left:
         return CEGUI::LeftButton;
 
     case OIS::MB_Right:
         return CEGUI::RightButton;
 
     case OIS::MB_Middle:
         return CEGUI::MiddleButton;
 
     default:
         return CEGUI::LeftButton;
     }
 }
 
 class TutorialListener : public ExampleFrameListener, public OIS::MouseListener, public OIS::KeyListener
 {
 public:
     TutorialListener(RenderWindow* win, Camera* cam)
         : ExampleFrameListener(win, cam, true, true)
     {
         mContinue=true;
         mKeyboard->setEventCallback(this);
         mMouse->setEventCallback(this);
 
         CEGUI::WindowManager &wmgr = CEGUI::WindowManager::getSingleton();
         CEGUI::Window *quit = wmgr.getWindow("CEGUIDemo/QuitButton");
 
         quit->subscribeEvent(CEGUI::PushButton::EventClicked,
                              CEGUI::Event::Subscriber(&TutorialListener::quit, this));
     } // CEGUIDemoListener
 
     bool frameStarted(const FrameEvent &evt)
     {
         mKeyboard->capture();
         mMouse->capture();
 
         return mContinue && !mKeyboard->isKeyDown(OIS::KC_ESCAPE);
     }
 
     bool quit(const CEGUI::EventArgs &e)
     {
         mContinue = false;
         return true;
     }
 
     // MouseListener
     bool mouseMoved(const OIS::MouseEvent &arg)
     {
         CEGUI::System::getSingleton().injectMouseMove(arg.state.X.rel, arg.state.Y.rel);
         return true;
     }
 
     bool mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
     {
         CEGUI::System::getSingleton().injectMouseButtonDown(convertButton(id));
         return true;
     }
 
     bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
     {
         CEGUI::System::getSingleton().injectMouseButtonUp(convertButton(id));
         return true;
     }
 
     // KeyListener
     bool keyPressed(const OIS::KeyEvent &arg)
     {
         CEGUI::System &sys = CEGUI::System::getSingleton();
         sys.injectKeyDown(arg.key);
         sys.injectChar(arg.text);
         return true;
     }
 
     bool keyReleased(const OIS::KeyEvent &arg)
     {
         CEGUI::System::getSingleton().injectKeyUp(arg.key);
         return true;
     }
 
 private:
     bool mContinue;
 };
 
 
 class CEGUIDemoApplication : public ExampleApplication
 {
 public:
     CEGUIDemoApplication()
     {
     }
 
     ~CEGUIDemoApplication() 
     {
         CEGUI::OgreRenderer::destroySystem();
     }
 protected:
     CEGUI::OgreRenderer *mRenderer;
 
     void createScene(void)
     {
         mRenderer = &CEGUI::OgreRenderer::bootstrapSystem();
         CEGUI::Imageset::setDefaultResourceGroup("Imagesets");
         CEGUI::Font::setDefaultResourceGroup("Fonts");
         CEGUI::Scheme::setDefaultResourceGroup("Schemes");
         CEGUI::WidgetLookManager::setDefaultResourceGroup("LookNFeel");
         CEGUI::WindowManager::setDefaultResourceGroup("Layouts"); 

         CEGUI::SchemeManager::getSingleton().create("TaharezLook.scheme");
         CEGUI::System::getSingleton().setDefaultMouseCursor("TaharezLook", "MouseArrow");
 
         //// Do not add this to the program
         //CEGUI::Window *guiRoot = CEGUI::WindowManager::getSingleton().loadWindowLayout("TextDemo.layout"); 
         //CEGUI::System::getSingleton().setGUISheet(guiRoot);
 
         // Quit button
         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::UVector2(CEGUI::UDim(0.15, 0), CEGUI::UDim(0.05, 0)));
 
         sheet->addChildWindow(quit);
         CEGUI::System::getSingleton().setGUISheet(sheet);
 
         // Scene setup
         mSceneMgr->setAmbientLight(ColourValue(1, 1, 1));
         mSceneMgr->setSkyDome(true, "Examples/CloudySky", 5, 8);
         Entity* ogreHead = mSceneMgr->createEntity("Head", "ogrehead.mesh");
         SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(0, 0, -300));
         headNode->attachObject(ogreHead);
 
         // Texture setup
         TexturePtr tex = mRoot->getTextureManager()->createManual(
             "RTT",
             ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
             TEX_TYPE_2D,
             512,
             512,
             0,
             PF_R8G8B8,
             TU_RENDERTARGET);
         RenderTexture *rtex = tex->getBuffer()->getRenderTarget();
 
         Camera *cam = mSceneMgr->createCamera("RTTCam");
         cam->setPosition(100, -100, -400);
         cam->lookAt(0, 0, -300);
         Viewport *v = rtex->addViewport(cam);
         v->setOverlaysEnabled(false);
         v->setClearEveryFrame(true);
         v->setBackgroundColour(ColourValue::Black);
 
         // CEGUI setup
         CEGUI::Texture &guiTex = mRenderer->createTexture(tex);
 
         CEGUI::Imageset &imageSet = CEGUI::ImagesetManager::getSingleton().create("RTTImageset", guiTex);
         imageSet.defineImage("RTTImage",
                              CEGUI::Point(0.0f, 0.0f),
                              CEGUI::Size(guiTex.getSize().d_width,
                                          guiTex.getSize().d_height),
                              CEGUI::Point(0.0f, 0.0f));
 
         CEGUI::Window *si = CEGUI::WindowManager::getSingleton().createWindow("TaharezLook/StaticImage", "RTTWindow");
         si->setSize(CEGUI::UVector2(CEGUI::UDim(0.5f, 0),
                     CEGUI::UDim(0.4f, 0)));
         si->setPosition(CEGUI::UVector2(CEGUI::UDim(0.5f, 0),
                         CEGUI::UDim(0.0f, 0)));
         si->setProperty("Image", CEGUI::PropertyHelper::imageToString(&imageSet.getImage("RTTImage")));
 
         sheet->addChildWindow(si);
     }
 
     void createFrameListener(void)
     {
         mFrameListener = new TutorialListener(mWindow, mCamera);
         mFrameListener->showDebugOverlay(true);
         mRoot->addFrameListener(mFrameListener);
     }
 };
 
 #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
 #define WIN32_LEAN_AND_MEAN
 #include "windows.h"
 
 
 INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT)
 #else
 int main(int argc, char **argv)
 #endif
 {
     // Create application object
     CEGUIDemoApplication app;
 
     try {
         app.go();
     } catch(Exception& e) {
 #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
         MessageBoxA(NULL, e.getFullDescription().c_str(), "An exception has occurred!",
             MB_OK | MB_ICONERROR | MB_TASKMODAL);
 #else
         fprintf(stderr, "An exception has occurred: %s\n",
             e.getFullDescription().c_str());
 #endif
     }
 
 
     return 0;
 }