基于GLUT的CEGUI DEMO

1. #include <GL/glut.h>
2. #include <CEGUI.h>
3. #include <CEGUIDefaultResourceProvider.h>
4. #include <RendererModules/OpenGLGUIRenderer/openglrenderer.h>
5. using namespace CEGUI;
6. //#include "UIAnimationManager.h"
8. // GLUT callback prototypes
9. void drawFrame(void);
10. void mouseMotion(int x, int y);
11. void mouseButton(int button, int state, int x, int y);
12. void keyChar(unsigned char key, int x, int y);
14. // super global vars!
15. bool G_quitFlag = false;
16. CEGUI::OpenGLRenderer* G_renderer = 0;
17. //uiae::UIAnimationManager* G_animMgr = 0;
18. int G_lastFrameTime = 0;
20. // app entry point
21. int main(int argc, char* argv[])
22. {
23.         // Do GLUT init
24.         glutInit(&argc, argv);
25.         glutInitDisplayMode(GLUT_DEPTH|GLUT_DOUBLE|GLUT_RGBA);
26.         glutInitWindowSize(800, 600);
27.         glutInitWindowPosition(100, 100);
28.         glutCreateWindow("CEGUI / UIAE Test");
29.         glutSetCursor(GLUT_CURSOR_NONE);
30.         // register callbacks
31.         glutDisplayFunc(drawFrame);
32.         glutMotionFunc(mouseMotion);
33.         glutPassiveMotionFunc(mouseMotion);
34.         glutMouseFunc(mouseButton);
35.         glutKeyboardFunc(keyChar);
37.         // initialise basic CEGUI system
38.         G_renderer = new OpenGLRenderer(1024);
39.         new System(G_renderer);
41.         // initialise the required dirs for the DefaultResourceProvider
42.         DefaultResourceProvider* rp = static_cast<DefaultResourceProvider*>
43.                 (System::getSingleton().getResourceProvider());
45.         //注意：这里要修改为下载的CEGUI界面文件对应的目录
46.         rp->setResourceGroupDirectory("schemes", "../GUI/schemes/");
47.         rp->setResourceGroupDirectory("imagesets", "../GUI/imagesets/");
48.         rp->setResourceGroupDirectory("fonts", "../GUI/fonts/");
49.         rp->setResourceGroupDirectory("layouts", "../GUI/layouts/");
50.         rp->setResourceGroupDirectory("looknfeels", "../GUI/looknfeel/");
51.         rp->setResourceGroupDirectory("lua_scripts", "../GUI/lua_scripts/");
53.         // set the default resource groups to be used
54.         Imageset::setDefaultResourceGroup("imagesets");
55.         Font::setDefaultResourceGroup("fonts");
56.         Scheme::setDefaultResourceGroup("schemes");
57.         WidgetLookManager::setDefaultResourceGroup("looknfeels");
58.         WindowManager::setDefaultResourceGroup("layouts");
59.         ScriptModule::setDefaultResourceGroup("lua_scripts");
61.         // we will make use of the WindowManager.
62.         WindowManager& winMgr = WindowManager::getSingleton();
64.         // load scheme and set up defaults
65.         SchemeManager::getSingleton().loadScheme("TaharezLook.scheme");
66.         System::getSingleton().setDefaultMouseCursor("TaharezLook", "MouseArrow");
67.         if(!FontManager::getSingleton().isFontPresent("Commonwealth-10"))
68.                 FontManager::getSingleton().createFont("Commonwealth-10.font");
70.         // create root window
71.         DefaultWindow* root = (DefaultWindow*)winMgr.createWindow("DefaultWindow", "Root");
72.         // set root as the active GUI sheet
73.         System::getSingleton().setGUISheet(root);
75.         // create a FrameWindow for the test
76.         FrameWindow* wnd = (FrameWindow*)winMgr.createWindow("TaharezLook/FrameWindow", "TestWindow");
77.         // add the frame window to the root
78.         root->addChildWindow(wnd);
79.         // set window initial position and size
80.         wnd->setPosition(UVector2(cegui_reldim(0.25f), cegui_reldim( 0.25f)));
81.         wnd->setSize(UVector2(cegui_reldim(0.5f), cegui_reldim( 0.5f)));
82.         // set window text
83.         wnd->setText("UIAE Demo Window");
85.         //// initialise the uiae system
86.         //// *** Step 1 from the artice ***
87.         //G_animMgr = uiae::UIAnimationManager::instance();
89.         //// load the sample animations that came with uiae
90.         //// *** Step 2 from the artice ***
91.         //if (G_animMgr->loadAnimationsFromFile("./sample.xml"))
92.         //{
93.         //        // add the FrameWindow to be managed by uiae, using anims from the "misc" list
94.         //        // *** Step 3 from the artice ***
95.         //        if (G_animMgr->addWindow(wnd, "1", "misc"))
96.         //        {
97.         //                // set window ID "1" to use the "bounce" animation (from the "misc" list).
98.         //                // *** Step 4 from the artice ***
99.         //                G_animMgr->setAnimationState("1", "bounce");
100.         //        }
101.         //}
103.         // start loop
104.         glutMainLoop();
106.         return 0;
107. }
109. void drawFrame(void)
110. {
111.         // do time based updates
112.         int thisTime = glutGet(GLUT_ELAPSED_TIME);
113.         float elapsed = static_cast<float>(thisTime - G_lastFrameTime);
114.         G_lastFrameTime = thisTime;
115.         // inject the time pulse (CEGUI and UIAE)
116.         CEGUI::System::getSingleton().injectTimePulse(elapsed / 1000.0f);
118.         // *** Step 5 from the artice ***
119.         //G_animMgr->update(elapsed / 1000.f);
121.         // do rendering for this frame.
122.         glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
123.         glEnable(GL_DEPTH_TEST);
124.         glMatrixMode(GL_MODELVIEW);
125.         glLoadIdentity();
126.         gluLookAt(0.0, 0.0, 12, 0.0, 0.0, -100, 0.0, 1.0, 0.0);
128.         CEGUI::System::getSingleton().renderGUI();
130.         glFlush();
131.         glutPostRedisplay();
132.         glutSwapBuffers();
134.         // handle quit conditiion
135.         if (G_quitFlag)
136.         {
137.                 //G_animMgr->cleanup();
138.                 // cleanup cegui system
139.                 delete CEGUI::System::getSingletonPtr();
140.                 delete G_renderer;
142.                 // exit
143.                 exit(0);
144.         }
146. }
148. void mouseMotion(int x, int y)
149. {
150.         CEGUI::System::getSingleton().injectMousePosition(x, y);
151. }
153. void mouseButton(int button, int state, int x, int y)
154. {
155.         switch(button)
156.         {
157.         case  GLUT_LEFT_BUTTON:
158.                 if (state == GLUT_UP)
159.                 {
160.                         CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::LeftButton);
161.                 }
162.                 else
163.                 {
164.                         CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::LeftButton);
166.                 }
167.                 break;
169.         case GLUT_RIGHT_BUTTON:
170.                 if (state == GLUT_UP)
171.                 {
172.                         CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::RightButton);
173.                 }
174.                 else
175.                 {
176.                         CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::RightButton);
177.                 }
178.                 break;
180.         case GLUT_MIDDLE_BUTTON:
181.                 if (state == GLUT_UP)
182.                 {
183.                         CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::MiddleButton);
184.                 }
185.                 else
186.                 {
187.                         CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::MiddleButton);
188.                 }
189.                 break;
190.         }
192. }
194. void keyChar(unsigned char key, int x, int y)
195. {
196.         // extract some keys may be handled via key code and generate those too
197.         switch (key)
198.         {
199.         case 0x08:  // backspace
200.                 CEGUI::System::getSingleton().injectKeyDown(CEGUI::Key::Backspace);
201.                 break;
202.         case 0x7F:  // delete
203.                 CEGUI::System::getSingleton().injectKeyDown(CEGUI::Key::Delete);
204.                 break;
205.         case 0x1B:  // Escape
206.                 G_quitFlag = true;
207.                 break;
208.         case 0x0D:  // CR (Return)
209.                 CEGUI::System::getSingleton().injectKeyDown(CEGUI::Key::Return);
210.                 break;
211.         default:
212.                 // inject Character code
213.                 CEGUI::System::getSingleton().injectChar(static_cast<CEGUI::utf32>(key));
214.                 break;
215.         }
217. }