Using CEGUI with Producer and OpenGL - Revision history

Capek: Robot: Cosmetic changes

2011-02-26T16:20:54Z

Robot: Cosmetic changes

Kulik at 12:29, 26 February 2011

2011-02-26T12:29:29Z

Granx at 07:13, 24 September 2005

2005-09-24T07:13:21Z

Granx: /* Initializing the Viewer in an Application */

2005-09-24T07:06:09Z

‎Initializing the Viewer in an Application

Granx: /* Defining a Producer Viewer */

2005-09-24T06:46:29Z

‎Defining a Producer Viewer

Granx: /* Defining a Producer Viewer */

2005-09-24T06:44:25Z

‎Defining a Producer Viewer

Crazyeddie: Fixed code formatting

2005-09-03T10:00:27Z

Fixed code formatting

Show changes

Granx: /* Using it all together */

2005-08-20T23:35:43Z

‎Using it all together

Granx at 23:35, 20 August 2005

2005-08-20T23:35:10Z

Granx: Using CEGUI via Producer

2005-08-20T23:32:46Z

Using CEGUI via Producer

Show changes

@@ Line 1: / Line 1: @@
-[[category:Tutorials]]
+[http://www.andesengineering.com/Producer/ Producer] is a cross platform toolkit, best explained on its website. I use it for many things, but creating a window, or Render Surface, is the most fundamental task. CEGUI requires knowledge of the window, mouse, and keyboard interaction. I will show how you can do that with some example code.
-−
-[http://www.andesengineering.com/Producer/ Producer] is a cross platform toolkit, best explained on its website.  I use it for many things, but creating a window, or Render Surface, is the most fundamental task.  CEGUI requires knowledge of the window, mouse, and keyboard interaction.  I will show how you can do that with some example code.
 === Defining a Producer Viewer ===
-The first step is to create some sort of "viewer" with Producer, basically make a Producer::RenderSurface and a Producer::KeyboardMouse.  Both of these classes are necessary for using CEGUI correctly.  Your job is just to create these so they can be used later.  There is no CEGUI code involved at this point.  So, here is some example viewer code:
+The first step is to create some sort of "viewer" with Producer, basically make a Producer::RenderSurface and a Producer::KeyboardMouse. Both of these classes are necessary for using CEGUI correctly. Your job is just to create these so they can be used later. There is no CEGUI code involved at this point. So, here is some example viewer code:
   #include "Viewer.h"
@@ Line 39: / Line 37: @@
+  }
-The InitGL and InitCEGUI functors are both specific to using CEGUI with Producer, and are quite important steps.  Much of these initializations are OpenGL specific, and therefore must occur within a thread with the right OpenGL context.  The Producer::RenderSurface can execute one-time initializations if you add them to be called upon window realization, with the Producer::RenderSurface::addRealizeCallback function which takes an instance to a class that derives from Producer::RenderSurface::Callback.  Both InitGL and InitCEGUI are classes which derive from this Callback.  I'll show what they need to do later in the tutorial.
+The InitGL and InitCEGUI functors are both specific to using CEGUI with Producer, and are quite important steps. Much of these initializations are OpenGL specific, and therefore must occur within a thread with the right OpenGL context. The Producer::RenderSurface can execute one-time initializations if you add them to be called upon window realization, with the Producer::RenderSurface::addRealizeCallback function which takes an instance to a class that derives from Producer::RenderSurface::Callback. Both InitGL and InitCEGUI are classes which derive from this Callback. I'll show what they need to do later in the tutorial.
-Actually, a lot (more) is happening in the Application's constructor.  Much of this is specific to using Producer.  I recommend reading the examples in Producer's distribution, but this example might sumarize some things for those of you new to using it.  The Producer::Camera class needs a 'SceneHandler' to perform draw calls.  This is the heart of the application's rendering.  I am showing an application that is named 'TeapotSim'.  It is just an example showing OpenGL's famous teapot spinning.  The SceneHandler instance must be set, and that is passed as a pointer to the Producer::Camera::addSceneHandler function.  The Camera instance will call the SceneHandler::draw function as part of the render loop.
+Actually, a lot (more) is happening in the Application's constructor. Much of this is specific to using Producer. I recommend reading the examples in Producer's distribution, but this example might sumarize some things for those of you new to using it. The Producer::Camera class needs a 'SceneHandler' to perform draw calls. This is the heart of the application's rendering. I am showing an application that is named 'TeapotSim'. It is just an example showing OpenGL's famous teapot spinning. The SceneHandler instance must be set, and that is passed as a pointer to the Producer::Camera::addSceneHandler function. The Camera instance will call the SceneHandler::draw function as part of the render loop.
-Another point in the render loop is the post-draw stage.  I used this stage to do more drawing, just like what my simulation would be doing, but in this stage I will be drawing the CEGUI, so that it will always be drawn last, and on top of the other graphics.
+Another point in the render loop is the post-draw stage. I used this stage to do more drawing, just like what my simulation would be doing, but in this stage I will be drawing the CEGUI, so that it will always be drawn last, and on top of the other graphics.
 === Initializing CEGUI for Producer ===
@@ Line 74: / Line 72: @@
+  }
-Producer uses OpenGL for rendering, so that is the renderer we must choose.  Luckily, CEGUI provides this.  If you want your application to use a CEGUI::ScriptModule, you will need to provide a when initializing the CEGUI::System, but that is for another lesson.  A default font needs to be provided to the System, and during initialization is a good time to provide that, so my functor has required it.
+Producer uses OpenGL for rendering, so that is the renderer we must choose. Luckily, CEGUI provides this. If you want your application to use a CEGUI::ScriptModule, you will need to provide a when initializing the CEGUI::System, but that is for another lesson. A default font needs to be provided to the System, and during initialization is a good time to provide that, so my functor has required it.
 === Rendering CEGUI with Producer ===
-The application code showed a post draw callback being set.  Producer will execute this little callback at the right time, within the correct OpenGL context for OpenGL calls.  Here is what needs to happen for CEGUI to appear on your screen each frame:
+The application code showed a post draw callback being set. Producer will execute this little callback at the right time, within the correct OpenGL context for OpenGL calls. Here is what needs to happen for CEGUI to appear on your screen each frame:
   void RenderCEGUI::operator ()(const Producer::Camera& c)
@@ Line 85: / Line 83: @@
 === Injecting Input to CEGUI via Producer ===
-This is where the real magic happens.  You must inject inputs into CEGUI because it does not poll the operating system for you.  That is the job of a tool like Producer.  For the most part, the following code works.  There is a small bug that is only seen when resizing the Producer::RenderSurface (window).  However, I think it provides insight into how injections need to be done for CEGUI to react to user input:
+This is where the real magic happens. You must inject inputs into CEGUI because it does not poll the operating system for you. That is the job of a tool like Producer. For the most part, the following code works. There is a small bug that is only seen when resizing the Producer::RenderSurface (window). However, I think it provides insight into how injections need to be done for CEGUI to react to user input:
   /** \author John K. Grant
@@ Line 287: / Line 285: @@
     return 0;
+  }

← Older revision		Revision as of 12:29, 26 February 2011
Line 1:		Line 1:
		+	[[category:Tutorials]]
		+
	[http://www.andesengineering.com/Producer/ Producer] is a cross platform toolkit, best explained on its website. I use it for many things, but creating a window, or Render Surface, is the most fundamental task. CEGUI requires knowledge of the window, mouse, and keyboard interaction. I will show how you can do that with some example code.		[http://www.andesengineering.com/Producer/ Producer] is a cross platform toolkit, best explained on its website. I use it for many things, but creating a window, or Render Surface, is the most fundamental task. CEGUI requires knowledge of the window, mouse, and keyboard interaction. I will show how you can do that with some example code.

@@ Line 43: / Line 43: @@
 Another point in the render loop is the post-draw stage.  I used this stage to do more drawing, just like what my simulation would be doing, but in this stage I will be drawing the CEGUI, so that it will always be drawn last, and on top of the other graphics.
-The Camera's draw callbacks are very important, but first I want to show an example of initializing CEGUI:
+=== Initializing CEGUI for Producer ===
   #include <CEGUISystem.h>
@@ Line 71: / Line 72: @@
+  }
-Producer uses OpenGL for rendering, so that is the renderer we must choose.  Luckily, CEGUI provides this.  You will need to provide a CEGUI::ScriptModule when initializing the System, but that is for another lesson.  A default font needs to be provided to the System, and during initialization is a good time to provide that, so my functor has required it.
+Producer uses OpenGL for rendering, so that is the renderer we must choose.  Luckily, CEGUI provides this.  If you want your application to use a CEGUI::ScriptModule, you will need to provide a when initializing the CEGUI::System, but that is for another lesson.  A default font needs to be provided to the System, and during initialization is a good time to provide that, so my functor has required it.
 === Rendering CEGUI with Producer ===

@@ Line 11: / Line 11: @@
+  }
-=== Using the viewer in an Application ===
+=== Initializing the Viewer in an Application ===
 And an application might use this viewer, doing some important initializations:
   Application::Application(const std::string& fontfile):
-    _status(RUNNING), _viewer(new general::Viewer()), _sim(new example::TeapotSim()),
+    _status(RUNNING), _viewer(new Viewer()), _sim(new TeapotSim()),
-    _scheme_loader_policy("MouseArrow"), _layout_loader_policy(), _script_module(new ApplicationEventHandler())
+    _scheme_loader("MouseArrow"), _layout_loader(), _script_module(new ApplicationEventHandler())
+  {
     // OpenGL context specific initializations
     Producer::ref_ptr<Producer::RenderSurface> rs = _viewer->GetRenderSurface();
-    rs->addRealizeCallback(new general::InitGL());
+    rs->addRealizeCallback(new InitGL() );
-    rs->addRealizeCallback(new prce::InitCEGUI(fontfile,_script_module));
+    rs->addRealizeCallback(new InitCEGUI(fontfile,_script_module) );
-    rs->setWindowName("Producer and CEGUI example");
+    rs->setWindowName( "Producer and CEGUI example" );
     rs->setWindowRectangle(20,50,800,600);
     // rendering stuff
-    _viewer->GetCamera()->setSceneHandler( _sim.get() );
+    _viewer->GetCamera()->setSceneHandler( _sim.get() );   // draw the simulation graphics
-   _viewer->GetCamera()->addPreDrawCallback( new SimulationDrawContext(_sim.get()) );
+    _viewer->GetCamera()->addPostDrawCallback(new RenderCEGUI() ); // renders the GUI over scene
-    _viewer->GetCamera()->addPostDrawCallback(new prce::RenderCEGUI() ); // renders the GUI over scene
     // device input stuff
@@ Line 38: / Line 37: @@
+  }
-The general::InitGL functor and prce::InitCEGUI functor are quite important.  These initializations are OpenGL specific, and must occur within a thread with the right OpenGL context.  The Producer::RenderSurface can execute one-time initializations if you add them to be called upon window realization.  Actually, a lot is happening here in the Application's constructor.  You might be able to imagine how OpenGL is initialized, so I'll skip that for now.  The Camera's draw callbacks are very important, but first I want to show an example of initializing CEGUI:
+The InitGL and InitCEGUI functors are both specific to using CEGUI with Producer, and are quite important steps.  Much of these initializations are OpenGL specific, and therefore must occur within a thread with the right OpenGL context.  The Producer::RenderSurface can execute one-time initializations if you add them to be called upon window realization, with the Producer::RenderSurface::addRealizeCallback function which takes an instance to a class that derives from Producer::RenderSurface::Callback.  Both InitGL and InitCEGUI are classes which derive from this Callback.  I'll show what they need to do later in the tutorial.
   #include <CEGUISystem.h>
@@ Line 46: / Line 51: @@
   #include "InitCEGUI.h"
   InitCEGUI::InitCEGUI(const std::string& font, CEGUI::ScriptModule* s): _sm(s), _font(font)

@@ Line 2: / Line 2: @@
 === Defining a Producer Viewer ===
-The first step is to create some sort of "viewer" with Producer, basically make a Producer::RenderSurface and a Producer::KeyboardMouse.  Both of these classes are necessary for using CEGUI correctly.  Your just is just to create these so they can be used later.  There is no CEGUI code involved at this point.  So, here is some example viewer code:
+The first step is to create some sort of "viewer" with Producer, basically make a Producer::RenderSurface and a Producer::KeyboardMouse.  Both of these classes are necessary for using CEGUI correctly.  Your job is just to create these so they can be used later.  There is no CEGUI code involved at this point.  So, here is some example viewer code:
   #include "Viewer.h"
   Viewer::Viewer() : _camera(new Producer::Camera()), _rs(0), _kbm(0)
+  {
-    _rs = _camera->getRenderSurface();
+    _rs = _camera->getRenderSurface();  // a Camera creates a RenderSurface, grab it
-    _kbm = new Producer::KeyboardMouse(_rs.get());
+    _kbm = new Producer::KeyboardMouse(_rs.get());  // make a new KeyboardMouse
+  }
 === Using the viewer in an Application ===

@@ Line 262: / Line 262: @@
 === Using it all together ===
 Here is what a simple main() will look like:
 int main(unsigned int argc, char* argv[])
+{

@@ Line 258: / Line 258: @@
        CEGUI::System::getSingleton().injectKeyUp( static_cast<CEGUI::uint>(cekey) );
+    }
+}