CEGUI Wiki - Crazy Eddie's GUI System (Open Source) - User contributions [en]

Wiki Cache problem

2015-04-06T00:09:44Z

Dermont: Test Problem with Wiki Cache

Testing Problem with Wiki Cache.

[[Category:Tutorials]]

Using CEGUI with SDL and OpenGL (0.7)

2015-04-06T00:05:11Z

Dermont:

{{VersionBadge|0.7}}

TESTING WIKI CACHE PROBLEM EDIT II.

TESTING WIKI CACHE PROBLEM.

[http://www.libsdl.org SDL (Simple DirectMedia Layer)] is an excellent library for writing portable games and other multimedia applications, but as it is a low-level library, it has no native support for GUI interfaces.

When using [http://www.opengl.org OpenGL] for rendering, using CEGUI with SDL is not hard.

I'll assume that you've read the imbiciles tutorials, and have used SDL with OpenGL.
And know C / C++ ...

=== Initialisation ===
Before we can do anything, we need to initialise our libraries.
First SDL:

<source lang="cpp">
if (SDL_Init(SDL_INIT_VIDEO)<0)
{
fprintf(stderr, "Unable to initialise SDL: %s", SDL_GetError());
exit(0);
}
</source>

Here we initialise SDL with video support. We need this for CEGUI.
O.K. now SDL is ready to go. So let's fire up OpenGL:

<source lang="cpp">
if (SDL_SetVideoMode(800,600,0,SDL_OPENGL)==NULL)
{
fprintf(stderr, "Unable to set OpenGL videomode: %s", SDL_GetError());
SDL_Quit();
exit(0);
}
</source>

Now OpenGL is ready. But we still need to set a decent configuration:

<source lang="cpp">
glEnable(GL_CULL_FACE);
glDisable(GL_FOG);
glClearColor(0.0f,0.0f,0.0f,1.0f);
glViewport(0,0, 800,600);
</source>

The OpenGL renderer that comes with CEGUI sets the matrices itself, so if you're using CEGUI for all your rendering needs this would be fine. Normally you would want the normal perspective projection setup though:

<source lang="cpp">
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, 800.0/600.0, 0.1,100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
</source>

SDL and OpenGL are now both ready for action. So it's time to initialise CEGUI.
This new "bootstrap" method in 0.7 is much simpler than the previous methods, it is one simple call

First we need the include (Usually everything you need can be found in <CEGUI/CEGUI.h> but for initialising a specific subsystem you need to do this
<source lang="cpp">
#include <CEGUI/RendererModules/OpenGL/CEGUIOpenGLRenderer.h>
</source>

This is the call to initialise everything

<source lang="cpp">
CEGUI::OpenGLRenderer::bootstrapSystem();
</source>

Remember that you have to load a widget set, set the mouse cursor and a default font before CEGUI is completely ready. This is described in the other tutorials.

By default the SDL cursor is displayed, so we'll remove that:

<source lang="cpp">
SDL_ShowCursor(SDL_DISABLE);
</source>

As keypress characters needs to be injected into CEGUI, we activate unicode translation for SDL key events:

<source lang="cpp">
SDL_EnableUNICODE(1);
</source>

This makes it alot easier as we don't have to worry about modifier keys and keyboard layouts ourselves. More about this later on...

Key repeat is a nice feature for the text input widgets in CEGUI, so we use SDL to generate them:

<source lang="cpp">
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
</source>

Everything is ready now, and we can start the main loop :)

=== The Main Loop ===
To make it all happen, we use a simple main loop that just keeps pushing on those frames:

<source lang="cpp">
void main_loop()
{
bool must_quit = false;

// get "run-time" in seconds
double last_time_pulse = 0.001*static_cast<double>(SDL_GetTicks());

while (!must_quit)
{
inject_input(must_quit);
inject_time_pulse(last_time_pulse);
render_gui();
}
}
</source>

This function will run the main loop until the ''bool'' value ''must_quit'' becomes ''true''. In this tutorial this will happen when the user clicks the close button provided by the window manager.

The ''double'' value ''last_time_pulse'' holds the time of the latest time pulse injection. More about this later.

Each function in the ''while'' loop will be described below.

There are endless ways of making your main loop. I took a simple approach to ease writing this tutorial.

=== Injecting Input and injecting change of window size ===
When the user press or release keyboard or mouse buttons, we need to tell CEGUI about it, for this we use the injection functions of ''CEGUI::System''. We also have to tell

Here is what our inject_input function looks like:

<source lang="cpp">
void inject_input(bool& must_quit)
{
SDL_Event e;

// go through all available events
while (SDL_PollEvent(&e))
{
// we use a switch to determine the event type
switch (e.type)
{
// mouse motion handler
case SDL_MOUSEMOTION:
// we inject the mouse position directly.
CEGUI::System::getSingleton().injectMousePosition(
static_cast<float>(e.motion.x),
static_cast<float>(e.motion.y)
);
break;

// mouse down handler
case SDL_MOUSEBUTTONDOWN:
// let a special function handle the mouse button down event
handle_mouse_down(e.button.button);
break;

// mouse up handler
case SDL_MOUSEBUTTONUP:
// let a special function handle the mouse button up event
handle_mouse_up(e.button.button);
break;

// key down
case SDL_KEYDOWN:
// to tell CEGUI that a key was pressed, we inject the scancode.
CEGUI::System::getSingleton().injectKeyDown(e.key.keysym.scancode);

// as for the character it's a litte more complicated. we'll use for translated unicode value.
// this is described in more detail below.
if ((e.key.keysym.unicode != 0)
{
CEGUI::System::getSingleton().injectChar(e.key.keysym.unicode);
}
break;

// key up
case SDL_KEYUP:
// like before we inject the scancode directly.
CEGUI::System::getSingleton().injectKeyUp(e.key.keysym.scancode);
break;

// WM quit event occured
case SDL_QUIT:
must_quit = true;
break;

}

}

}
</source>

First I'll explain the events that get handled directly in the ''inject_input'' function.

'''Mouse Motion''':

<source lang="cpp">
// we inject the mouse position directly.
CEGUI::System::getSingleton().injectMousePosition(
static_cast<float>(e.motion.x),
static_cast<float>(e.motion.y)
);
</source>

There is nothing special here. Like stated in the comment the mouse position is just injected directly.

There are two ways of injecting mouse motion. One where you inject how much the cursor moved, and one where you inject the mouse cursor position. The last one is failsafe.
Then first one only works correctly in fullscreen mode, or with input grabbed. The reason for this is that in regular windowed mode, the mouse can be moved outside the application window, and during this time no mouse motion event are generated. So if we enter the window at another position, the real mousecursor and CEGUI's mouse cursor will be offset, which will break mouse usage.

'''Key Down''' 
This event takes a little more work. CEGUI requires that key characters (the printable character the key represents) are injected alongside key codes.

<source lang="cpp">
// to tell CEGUI that a key was pressed, we inject the scancode.
CEGUI::System::getSingleton().injectKeyDown(e.key.keysym.scancode);
</source>

Luckily the key code is just the SDL scancode, so we inject that directly. (This only seems to be true on windows. On other platforms you will need to use a translation function. One can be found here [[SDL to CEGUI keytable]])

<source lang="cpp">
// as for the character it's a litte more complicated. we'll use for translated unicode value.
// this is described in more detail below.
if (e.key.keysym.unicode != 0)
{
CEGUI::System::getSingleton().injectChar(e.key.keysym.unicode);
}
</source>

Instead of formatting the keypress ourselves, we let SDL do it for us. We could check if we actually got a valid ASCII code, but we want support for local characters as well, so we won't do that. For more information, take a look at the SDL documentation for this feature. [http://www.libsdl.org/cgi/docwiki.cgi/SDL_5fkeysym SDL_keysym].

'''Key Up''' 
This one is simple. Only the keycode need to injected. So we just use the scancode directly (As with KeyDown you will need to use a translation function for non Windows platforms. Check KeyDown above for more info):

<source lang="cpp">
// like before we inject the scancode directly.
CEGUI::System::getSingleton().injectKeyUp(e.key.keysym.scancode);
</source>

'''Mouse Button Down and Mouse Wheel''' 
CEGUI and SDL are a little different when it comes to mouse button and mouse wheel events. So a little conversion is necessary. Here's the ''handle_mouse_down'' function that gets called when a mouse button down event occurs in SDL. It takes one parameter, a ''Uint8'' describing the mouse button that was pressed.

<source lang="cpp">
void handle_mouse_down(Uint8 button)
{
switch ( button )
{
// handle real mouse buttons
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::RightButton);
break;

// handle the mouse wheel
case SDL_BUTTON_WHEELDOWN:
CEGUI::System::getSingleton().injectMouseWheelChange( -1 );
break;
case SDL_BUTTON_WHEELUP:
CEGUI::System::getSingleton().injectMouseWheelChange( +1 );
break;
}
}
</source>

I chose a very "manual" conversion, but it works fine. Everything should be pretty self-explainatory.
As you can see mouse wheel events are emitted as mouse button down events in SDL.

'''Mouse Button Up''' 
The mouse button up event is handled very much like the mouse button down event, except there are no mousewheel release events.
Like ''handle_mouse_down'' it takes one parameter, a ''Uint8'' describing the mouse button that was released:

<source lang="cpp">
void handle_mouse_up(Uint8 button)
{
switch ( button )
{
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::RightButton);
break;
}
}
</source>

=== Time Pulses ===
SDL has a built-in millisecond counter which we will use for this example. There are other ways to use timers with SDL, but I chose this approach as it is simple to use, and provides decent precision.

Remember in the main loop where we stored the current "run-time" in seconds ? This value will be passed as a reference to ''inject_time_pulse'' function which in turn will set a new value to it.

CEGUI's interface for injecting time pulses requires that you pass the time in seconds that has passed since the last time pulse injection. Let's take a look at the function:

<source lang="cpp">
void inject_time_pulse(double& last_time_pulse)
{
// get current "run-time" in seconds
double t = 0.001*SDL_GetTicks();

// inject the time that passed since the last call
CEGUI::System::getSingleton().injectTimePulse( float(t-last_time_pulse) );

// store the new time as the last time
last_time_pulse = t;
}
</source>

* The first line gets the actual "run-time" when called.
* The second line injects the time pulse as the difference between the current time and the last time.
* The third line stores the current time as the last time a time pulse was injected.

This will work for about 47 days... After that the counter wraps to zero and it breaks (a single insanely invalid timepulse will be injected).
I'll leave it up to you to fix that if it's a problem.

=== Change of window size ===
If the window size changes (e.g. switching to fullscreen mode), we have to tell the openGlRenderer what's the new window size. Otherwise e.g. the Fonts aren't scaled properly. Therefore we add an SDL Event Handler for SDL_VIDEORESIZE and submit the new window size to the openGlRenderer of CEGUI.
If you have used previous versions you will know that you have to do some stuff here to stop textures from being skewed, but that is no longer an issue

<source lang="cpp">
...
case SDL_VIDEORESIZE:
//your resize code here, including the SDL_SetVideoMode call
CEGUI::System::getSingleton().getRenderer()->setDisplaySize(CEGUI::Size(event.resize.w, event.resize.h));
break;

...
</source>

=== Rendering ===
Now all that's left is renderingthe GUI.

<source lang="cpp">
void render_gui()
{
// clear the colour buffer
glClear( GL_COLOR_BUFFER_BIT );

// render the GUI :)
CEGUI::System::getSingleton().renderGUI();

// Update the screen
SDL_GL_SwapBuffers();
}
</source>

The line:

<source lang="cpp">
CEGUI::System::getSingleton().renderGUI();
</source>

does all the CEGUI magic and sets OpenGL state itself. As long as the viewport is setup, it will render the GUI.

=== Error Handling ===
The neat C++ architecture of CEGUI suggests that C++ exceptions are used for error handling. This is completely true.
Whenever an error occurs, a sub-class of ''CEGUI::Exception'' is thrown.

There are many scenarios where an exception can be thrown. And whether or not these should be considered fatal depends on the application. To make sure you catch the CEGUI exceptions a regular ''try'' block is used. Like so:

<source lang="cpp">
try
{
// do some cegui code
}
catch (CEGUI::Exception& e)
{
fprintf(stderr,"CEGUI Exception occured: %s", e.getMessage().c_str());
// you could quit here
}
</source>

This should provide you with the basic steps needed to get interactive with CEGUI in your SDL application.
Have fun.

=== The Code ===
To compile under linux:
<code>g++ teste.cpp -I/usr/include/CEGUI/ -lSDL -lGL -lGLU -lCEGUIBase -lCEGUIOpenGLRenderer</code>

<source lang="cpp">
/*
* Adapted by: Johnny Souza - johnnysouza.js@gmail.com
* Date: 19/01/07 17:00
* Description: Using CEGUI with SDL and OpenGL
*/

#include <stdio.h>
#include <stdlib.h>

#include <SDL/SDL.h>

#include <CEGUI.h>
#include <RendererModules/OpenGL/CEGUIOpenGLRenderer.h>

#include <GL/gl.h>
#include <GL/glu.h>

void handle_mouse_down(Uint8 button)
{
switch ( button ) {
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::RightButton);
break;

case SDL_BUTTON_WHEELDOWN:
CEGUI::System::getSingleton().injectMouseWheelChange( -1 );
break;
case SDL_BUTTON_WHEELUP:
CEGUI::System::getSingleton().injectMouseWheelChange( +1 );
break;
}
}

void handle_mouse_up(Uint8 button)
{
switch ( button )
{
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::RightButton);
break;
}
}

void inject_input (bool & must_quit)
{
SDL_Event e;
/* go through all available events */
while (SDL_PollEvent(&e)) {
/* we use a switch to determine the event type */
switch (e.type) {
/* mouse motion handler */
case SDL_MOUSEMOTION:
/* we inject the mouse position directly. */
CEGUI::System::getSingleton().injectMousePosition(static_cast<float>(e.motion.x),static_cast<float>(e.motion.y));
break;

/* mouse down handler */
case SDL_MOUSEBUTTONDOWN:
/* let a special function handle the mouse button down event */
handle_mouse_down (e.button.button);
break;

/* mouse up handler */
case SDL_MOUSEBUTTONUP:
/* let a special function handle the mouse button up event */
handle_mouse_up (e.button.button);
break;

/* key down */
case SDL_KEYDOWN:
/* to tell CEGUI that a key was pressed, we inject the scancode. */
CEGUI::System::getSingleton().injectKeyDown(e.key.keysym.scancode);
/* as for the character it's a litte more complicated.
* we'll use for translated unicode value.
* this is described in more detail below.
*/
if ((e.key.keysym.unicode & 0xFF80) == 0) {
CEGUI::System::getSingleton().injectChar(e.key.keysym.unicode & 0x7F);
}
break;

/* key up */
case SDL_KEYUP:
/* like before we inject the scancode directly. */
CEGUI::System::getSingleton().injectKeyUp(e.key.keysym.scancode);
break;

/* WM quit event occured */
case SDL_QUIT:
must_quit = true;
break;

case SDL_VIDEORESIZE:
CEGUI::System::getSingleton().notifyDisplaySizeChanged(CEGUI::Size(e.resize.w,e.resize.h));
break;
}
}
}

void inject_time_pulse(double& last_time_pulse)
{
/* get current "run-time" in seconds */
double t = 0.001*SDL_GetTicks();
/* inject the time that passed since the last call */
CEGUI::System::getSingleton().injectTimePulse( float(t-last_time_pulse) );
/* store the new time as the last time */
last_time_pulse = t;
}

void render_gui()
{
/* clear the colour buffer */
glClear( GL_COLOR_BUFFER_BIT );
/* render the GUI :) */
CEGUI::System::getSingleton().renderGUI();
/* Update the screen */
SDL_GL_SwapBuffers();
}

void main_loop ()
{
bool must_quit = false;
/* get "run-time" in seconds */
double last_time_pulse = 0.001*static_cast<double>(SDL_GetTicks());
while (!must_quit) {
inject_input (must_quit);
inject_time_pulse (last_time_pulse);
render_gui ();
}
}

int main (int argc, char **argv)
{
SDL_Surface * screen;
atexit (SDL_Quit);
SDL_Init (SDL_INIT_VIDEO);
screen = SDL_SetVideoMode (600, 480, 0, SDL_OPENGL);
if (screen == NULL) {
/* Se ainda não der, desiste! */
fprintf (stderr, "Impossível ajustar ao vídeo: %s\n", SDL_GetError ());
exit (1);
}
CEGUI::OpenGLRenderer::bootstrapSystem();
SDL_ShowCursor (SDL_DISABLE);
SDL_EnableUNICODE (1);
SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
main_loop();
}
</source>

--[[User:Lindquist]] 16:21, 8 May 2005 (BST)

[[Category:Tutorials]]

Using CEGUI with SDL and OpenGL (0.7)

2015-04-05T23:58:03Z

Dermont:

{{VersionBadge|0.7}}

TESTING WIKI CACHE PROBLEM.

[http://www.libsdl.org SDL (Simple DirectMedia Layer)] is an excellent library for writing portable games and other multimedia applications, but as it is a low-level library, it has no native support for GUI interfaces.

When using [http://www.opengl.org OpenGL] for rendering, using CEGUI with SDL is not hard.

I'll assume that you've read the imbiciles tutorials, and have used SDL with OpenGL.
And know C / C++ ...

=== Initialisation ===
Before we can do anything, we need to initialise our libraries.
First SDL:

<source lang="cpp">
if (SDL_Init(SDL_INIT_VIDEO)<0)
{
fprintf(stderr, "Unable to initialise SDL: %s", SDL_GetError());
exit(0);
}
</source>

Here we initialise SDL with video support. We need this for CEGUI.
O.K. now SDL is ready to go. So let's fire up OpenGL:

<source lang="cpp">
if (SDL_SetVideoMode(800,600,0,SDL_OPENGL)==NULL)
{
fprintf(stderr, "Unable to set OpenGL videomode: %s", SDL_GetError());
SDL_Quit();
exit(0);
}
</source>

Now OpenGL is ready. But we still need to set a decent configuration:

<source lang="cpp">
glEnable(GL_CULL_FACE);
glDisable(GL_FOG);
glClearColor(0.0f,0.0f,0.0f,1.0f);
glViewport(0,0, 800,600);
</source>

The OpenGL renderer that comes with CEGUI sets the matrices itself, so if you're using CEGUI for all your rendering needs this would be fine. Normally you would want the normal perspective projection setup though:

<source lang="cpp">
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0, 800.0/600.0, 0.1,100.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
</source>

SDL and OpenGL are now both ready for action. So it's time to initialise CEGUI.
This new "bootstrap" method in 0.7 is much simpler than the previous methods, it is one simple call

First we need the include (Usually everything you need can be found in <CEGUI/CEGUI.h> but for initialising a specific subsystem you need to do this
<source lang="cpp">
#include <CEGUI/RendererModules/OpenGL/CEGUIOpenGLRenderer.h>
</source>

This is the call to initialise everything

<source lang="cpp">
CEGUI::OpenGLRenderer::bootstrapSystem();
</source>

Remember that you have to load a widget set, set the mouse cursor and a default font before CEGUI is completely ready. This is described in the other tutorials.

By default the SDL cursor is displayed, so we'll remove that:

<source lang="cpp">
SDL_ShowCursor(SDL_DISABLE);
</source>

As keypress characters needs to be injected into CEGUI, we activate unicode translation for SDL key events:

<source lang="cpp">
SDL_EnableUNICODE(1);
</source>

This makes it alot easier as we don't have to worry about modifier keys and keyboard layouts ourselves. More about this later on...

Key repeat is a nice feature for the text input widgets in CEGUI, so we use SDL to generate them:

<source lang="cpp">
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
</source>

Everything is ready now, and we can start the main loop :)

=== The Main Loop ===
To make it all happen, we use a simple main loop that just keeps pushing on those frames:

<source lang="cpp">
void main_loop()
{
bool must_quit = false;

// get "run-time" in seconds
double last_time_pulse = 0.001*static_cast<double>(SDL_GetTicks());

while (!must_quit)
{
inject_input(must_quit);
inject_time_pulse(last_time_pulse);
render_gui();
}
}
</source>

This function will run the main loop until the ''bool'' value ''must_quit'' becomes ''true''. In this tutorial this will happen when the user clicks the close button provided by the window manager.

The ''double'' value ''last_time_pulse'' holds the time of the latest time pulse injection. More about this later.

Each function in the ''while'' loop will be described below.

There are endless ways of making your main loop. I took a simple approach to ease writing this tutorial.

=== Injecting Input and injecting change of window size ===
When the user press or release keyboard or mouse buttons, we need to tell CEGUI about it, for this we use the injection functions of ''CEGUI::System''. We also have to tell

Here is what our inject_input function looks like:

<source lang="cpp">
void inject_input(bool& must_quit)
{
SDL_Event e;

// go through all available events
while (SDL_PollEvent(&e))
{
// we use a switch to determine the event type
switch (e.type)
{
// mouse motion handler
case SDL_MOUSEMOTION:
// we inject the mouse position directly.
CEGUI::System::getSingleton().injectMousePosition(
static_cast<float>(e.motion.x),
static_cast<float>(e.motion.y)
);
break;

// mouse down handler
case SDL_MOUSEBUTTONDOWN:
// let a special function handle the mouse button down event
handle_mouse_down(e.button.button);
break;

// mouse up handler
case SDL_MOUSEBUTTONUP:
// let a special function handle the mouse button up event
handle_mouse_up(e.button.button);
break;

// key down
case SDL_KEYDOWN:
// to tell CEGUI that a key was pressed, we inject the scancode.
CEGUI::System::getSingleton().injectKeyDown(e.key.keysym.scancode);

// as for the character it's a litte more complicated. we'll use for translated unicode value.
// this is described in more detail below.
if ((e.key.keysym.unicode != 0)
{
CEGUI::System::getSingleton().injectChar(e.key.keysym.unicode);
}
break;

// key up
case SDL_KEYUP:
// like before we inject the scancode directly.
CEGUI::System::getSingleton().injectKeyUp(e.key.keysym.scancode);
break;

// WM quit event occured
case SDL_QUIT:
must_quit = true;
break;

}

}

}
</source>

First I'll explain the events that get handled directly in the ''inject_input'' function.

'''Mouse Motion''':

<source lang="cpp">
// we inject the mouse position directly.
CEGUI::System::getSingleton().injectMousePosition(
static_cast<float>(e.motion.x),
static_cast<float>(e.motion.y)
);
</source>

There is nothing special here. Like stated in the comment the mouse position is just injected directly.

There are two ways of injecting mouse motion. One where you inject how much the cursor moved, and one where you inject the mouse cursor position. The last one is failsafe.
Then first one only works correctly in fullscreen mode, or with input grabbed. The reason for this is that in regular windowed mode, the mouse can be moved outside the application window, and during this time no mouse motion event are generated. So if we enter the window at another position, the real mousecursor and CEGUI's mouse cursor will be offset, which will break mouse usage.

'''Key Down''' 
This event takes a little more work. CEGUI requires that key characters (the printable character the key represents) are injected alongside key codes.

<source lang="cpp">
// to tell CEGUI that a key was pressed, we inject the scancode.
CEGUI::System::getSingleton().injectKeyDown(e.key.keysym.scancode);
</source>

Luckily the key code is just the SDL scancode, so we inject that directly. (This only seems to be true on windows. On other platforms you will need to use a translation function. One can be found here [[SDL to CEGUI keytable]])

<source lang="cpp">
// as for the character it's a litte more complicated. we'll use for translated unicode value.
// this is described in more detail below.
if (e.key.keysym.unicode != 0)
{
CEGUI::System::getSingleton().injectChar(e.key.keysym.unicode);
}
</source>

Instead of formatting the keypress ourselves, we let SDL do it for us. We could check if we actually got a valid ASCII code, but we want support for local characters as well, so we won't do that. For more information, take a look at the SDL documentation for this feature. [http://www.libsdl.org/cgi/docwiki.cgi/SDL_5fkeysym SDL_keysym].

'''Key Up''' 
This one is simple. Only the keycode need to injected. So we just use the scancode directly (As with KeyDown you will need to use a translation function for non Windows platforms. Check KeyDown above for more info):

<source lang="cpp">
// like before we inject the scancode directly.
CEGUI::System::getSingleton().injectKeyUp(e.key.keysym.scancode);
</source>

'''Mouse Button Down and Mouse Wheel''' 
CEGUI and SDL are a little different when it comes to mouse button and mouse wheel events. So a little conversion is necessary. Here's the ''handle_mouse_down'' function that gets called when a mouse button down event occurs in SDL. It takes one parameter, a ''Uint8'' describing the mouse button that was pressed.

<source lang="cpp">
void handle_mouse_down(Uint8 button)
{
switch ( button )
{
// handle real mouse buttons
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::RightButton);
break;

// handle the mouse wheel
case SDL_BUTTON_WHEELDOWN:
CEGUI::System::getSingleton().injectMouseWheelChange( -1 );
break;
case SDL_BUTTON_WHEELUP:
CEGUI::System::getSingleton().injectMouseWheelChange( +1 );
break;
}
}
</source>

I chose a very "manual" conversion, but it works fine. Everything should be pretty self-explainatory.
As you can see mouse wheel events are emitted as mouse button down events in SDL.

'''Mouse Button Up''' 
The mouse button up event is handled very much like the mouse button down event, except there are no mousewheel release events.
Like ''handle_mouse_down'' it takes one parameter, a ''Uint8'' describing the mouse button that was released:

<source lang="cpp">
void handle_mouse_up(Uint8 button)
{
switch ( button )
{
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::RightButton);
break;
}
}
</source>

=== Time Pulses ===
SDL has a built-in millisecond counter which we will use for this example. There are other ways to use timers with SDL, but I chose this approach as it is simple to use, and provides decent precision.

Remember in the main loop where we stored the current "run-time" in seconds ? This value will be passed as a reference to ''inject_time_pulse'' function which in turn will set a new value to it.

CEGUI's interface for injecting time pulses requires that you pass the time in seconds that has passed since the last time pulse injection. Let's take a look at the function:

<source lang="cpp">
void inject_time_pulse(double& last_time_pulse)
{
// get current "run-time" in seconds
double t = 0.001*SDL_GetTicks();

// inject the time that passed since the last call
CEGUI::System::getSingleton().injectTimePulse( float(t-last_time_pulse) );

// store the new time as the last time
last_time_pulse = t;
}
</source>

* The first line gets the actual "run-time" when called.
* The second line injects the time pulse as the difference between the current time and the last time.
* The third line stores the current time as the last time a time pulse was injected.

This will work for about 47 days... After that the counter wraps to zero and it breaks (a single insanely invalid timepulse will be injected).
I'll leave it up to you to fix that if it's a problem.

=== Change of window size ===
If the window size changes (e.g. switching to fullscreen mode), we have to tell the openGlRenderer what's the new window size. Otherwise e.g. the Fonts aren't scaled properly. Therefore we add an SDL Event Handler for SDL_VIDEORESIZE and submit the new window size to the openGlRenderer of CEGUI.
If you have used previous versions you will know that you have to do some stuff here to stop textures from being skewed, but that is no longer an issue

<source lang="cpp">
...
case SDL_VIDEORESIZE:
//your resize code here, including the SDL_SetVideoMode call
CEGUI::System::getSingleton().getRenderer()->setDisplaySize(CEGUI::Size(event.resize.w, event.resize.h));
break;

...
</source>

=== Rendering ===
Now all that's left is renderingthe GUI.

<source lang="cpp">
void render_gui()
{
// clear the colour buffer
glClear( GL_COLOR_BUFFER_BIT );

// render the GUI :)
CEGUI::System::getSingleton().renderGUI();

// Update the screen
SDL_GL_SwapBuffers();
}
</source>

The line:

<source lang="cpp">
CEGUI::System::getSingleton().renderGUI();
</source>

does all the CEGUI magic and sets OpenGL state itself. As long as the viewport is setup, it will render the GUI.

=== Error Handling ===
The neat C++ architecture of CEGUI suggests that C++ exceptions are used for error handling. This is completely true.
Whenever an error occurs, a sub-class of ''CEGUI::Exception'' is thrown.

There are many scenarios where an exception can be thrown. And whether or not these should be considered fatal depends on the application. To make sure you catch the CEGUI exceptions a regular ''try'' block is used. Like so:

<source lang="cpp">
try
{
// do some cegui code
}
catch (CEGUI::Exception& e)
{
fprintf(stderr,"CEGUI Exception occured: %s", e.getMessage().c_str());
// you could quit here
}
</source>

This should provide you with the basic steps needed to get interactive with CEGUI in your SDL application.
Have fun.

=== The Code ===
To compile under linux:
<code>g++ teste.cpp -I/usr/include/CEGUI/ -lSDL -lGL -lGLU -lCEGUIBase -lCEGUIOpenGLRenderer</code>

<source lang="cpp">
/*
* Adapted by: Johnny Souza - johnnysouza.js@gmail.com
* Date: 19/01/07 17:00
* Description: Using CEGUI with SDL and OpenGL
*/

#include <stdio.h>
#include <stdlib.h>

#include <SDL/SDL.h>

#include <CEGUI.h>
#include <RendererModules/OpenGL/CEGUIOpenGLRenderer.h>

#include <GL/gl.h>
#include <GL/glu.h>

void handle_mouse_down(Uint8 button)
{
switch ( button ) {
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonDown(CEGUI::RightButton);
break;

case SDL_BUTTON_WHEELDOWN:
CEGUI::System::getSingleton().injectMouseWheelChange( -1 );
break;
case SDL_BUTTON_WHEELUP:
CEGUI::System::getSingleton().injectMouseWheelChange( +1 );
break;
}
}

void handle_mouse_up(Uint8 button)
{
switch ( button )
{
case SDL_BUTTON_LEFT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::LeftButton);
break;
case SDL_BUTTON_MIDDLE:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::MiddleButton);
break;
case SDL_BUTTON_RIGHT:
CEGUI::System::getSingleton().injectMouseButtonUp(CEGUI::RightButton);
break;
}
}

void inject_input (bool & must_quit)
{
SDL_Event e;
/* go through all available events */
while (SDL_PollEvent(&e)) {
/* we use a switch to determine the event type */
switch (e.type) {
/* mouse motion handler */
case SDL_MOUSEMOTION:
/* we inject the mouse position directly. */
CEGUI::System::getSingleton().injectMousePosition(static_cast<float>(e.motion.x),static_cast<float>(e.motion.y));
break;

/* mouse down handler */
case SDL_MOUSEBUTTONDOWN:
/* let a special function handle the mouse button down event */
handle_mouse_down (e.button.button);
break;

/* mouse up handler */
case SDL_MOUSEBUTTONUP:
/* let a special function handle the mouse button up event */
handle_mouse_up (e.button.button);
break;

/* key down */
case SDL_KEYDOWN:
/* to tell CEGUI that a key was pressed, we inject the scancode. */
CEGUI::System::getSingleton().injectKeyDown(e.key.keysym.scancode);
/* as for the character it's a litte more complicated.
* we'll use for translated unicode value.
* this is described in more detail below.
*/
if ((e.key.keysym.unicode & 0xFF80) == 0) {
CEGUI::System::getSingleton().injectChar(e.key.keysym.unicode & 0x7F);
}
break;

/* key up */
case SDL_KEYUP:
/* like before we inject the scancode directly. */
CEGUI::System::getSingleton().injectKeyUp(e.key.keysym.scancode);
break;

/* WM quit event occured */
case SDL_QUIT:
must_quit = true;
break;

case SDL_VIDEORESIZE:
CEGUI::System::getSingleton().notifyDisplaySizeChanged(CEGUI::Size(e.resize.w,e.resize.h));
break;
}
}
}

void inject_time_pulse(double& last_time_pulse)
{
/* get current "run-time" in seconds */
double t = 0.001*SDL_GetTicks();
/* inject the time that passed since the last call */
CEGUI::System::getSingleton().injectTimePulse( float(t-last_time_pulse) );
/* store the new time as the last time */
last_time_pulse = t;
}

void render_gui()
{
/* clear the colour buffer */
glClear( GL_COLOR_BUFFER_BIT );
/* render the GUI :) */
CEGUI::System::getSingleton().renderGUI();
/* Update the screen */
SDL_GL_SwapBuffers();
}

void main_loop ()
{
bool must_quit = false;
/* get "run-time" in seconds */
double last_time_pulse = 0.001*static_cast<double>(SDL_GetTicks());
while (!must_quit) {
inject_input (must_quit);
inject_time_pulse (last_time_pulse);
render_gui ();
}
}

int main (int argc, char **argv)
{
SDL_Surface * screen;
atexit (SDL_Quit);
SDL_Init (SDL_INIT_VIDEO);
screen = SDL_SetVideoMode (600, 480, 0, SDL_OPENGL);
if (screen == NULL) {
/* Se ainda não der, desiste! */
fprintf (stderr, "Impossível ajustar ao vídeo: %s\n", SDL_GetError ());
exit (1);
}
CEGUI::OpenGLRenderer::bootstrapSystem();
SDL_ShowCursor (SDL_DISABLE);
SDL_EnableUNICODE (1);
SDL_EnableKeyRepeat (SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
main_loop();
}
</source>

--[[User:Lindquist]] 16:21, 8 May 2005 (BST)

[[Category:Tutorials]]

Using PyCEGUI with glfw3 and PyOpenGL (0.8)

2015-03-27T13:15:03Z

Dermont: /* Demo Source */

{{VersionBadge|0.8}}

== Getting Started ==

For this example it is assumed that [http://www.glfw.org/download.html glfw3] and [http://www.opengl.org OpenGL] are already installed.
We will be using the bindings for [https://github.com/rougier/pyglfw.git python glfw3] from Nicolas P. Rougier. Download from git clone https://github.com/rougier/pyglfw.git and copy the file glfw.py to the directory you are running the demo from.

== Importing Modules ==
If you have trouble importing the PyCEGUI libraries you can update your python path to point to the location of the modules. For Linux you can simply point to your CEGUI build_dir/lib.

for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
#sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")

== Setting Data Path ==
Set your path to the CEGUI media dir.

CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"

== Mouse/KeyBoard Mappings==

def ConvertMouseButton(button):
##Convert Mouse Buttons to CEGUI
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton

Copy the following keyboard mappings to keymappings_glfw3.py in same directory as the demo.

import sys
import glfw
import PyCEGUI
KEYMAPPINGS = {
glfw.GLFW_KEY_UNKNOWN : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_SPACE : PyCEGUI.Key.Space,
glfw.GLFW_KEY_APOSTROPHE : PyCEGUI.Key.Apostrophe,
glfw.GLFW_KEY_COMMA : PyCEGUI.Key.Comma,
glfw.GLFW_KEY_MINUS : PyCEGUI.Key.Minus,
glfw.GLFW_KEY_PERIOD : PyCEGUI.Key.Period,
glfw.GLFW_KEY_SLASH : PyCEGUI.Key.Slash,
glfw.GLFW_KEY_0 : PyCEGUI.Key.Zero,
glfw.GLFW_KEY_1 : PyCEGUI.Key.One,
glfw.GLFW_KEY_2 : PyCEGUI.Key.Two,
glfw.GLFW_KEY_3 : PyCEGUI.Key.Three,
glfw.GLFW_KEY_4 : PyCEGUI.Key.Four,
glfw.GLFW_KEY_5 : PyCEGUI.Key.Five,
glfw.GLFW_KEY_6 : PyCEGUI.Key.Six,
glfw.GLFW_KEY_7 : PyCEGUI.Key.Seven,
glfw.GLFW_KEY_8 : PyCEGUI.Key.Eight,
glfw.GLFW_KEY_9 : PyCEGUI.Key.Nine,
glfw.GLFW_KEY_SEMICOLON : PyCEGUI.Key.Semicolon,
glfw.GLFW_KEY_EQUAL : PyCEGUI.Key.Equals,
glfw.GLFW_KEY_A : PyCEGUI.Key.A,
glfw.GLFW_KEY_B : PyCEGUI.Key.B,
glfw.GLFW_KEY_C : PyCEGUI.Key.C,
glfw.GLFW_KEY_D : PyCEGUI.Key.D,
glfw.GLFW_KEY_E : PyCEGUI.Key.E,
glfw.GLFW_KEY_F : PyCEGUI.Key.F,
glfw.GLFW_KEY_G : PyCEGUI.Key.G,
glfw.GLFW_KEY_H : PyCEGUI.Key.H,
glfw.GLFW_KEY_I : PyCEGUI.Key.I,
glfw.GLFW_KEY_J : PyCEGUI.Key.J,
glfw.GLFW_KEY_K : PyCEGUI.Key.K,
glfw.GLFW_KEY_L : PyCEGUI.Key.L,
glfw.GLFW_KEY_M : PyCEGUI.Key.M,
glfw.GLFW_KEY_N : PyCEGUI.Key.N,
glfw.GLFW_KEY_O : PyCEGUI.Key.O,
glfw.GLFW_KEY_P : PyCEGUI.Key.P,
glfw.GLFW_KEY_Q : PyCEGUI.Key.Q,
glfw.GLFW_KEY_R : PyCEGUI.Key.R,
glfw.GLFW_KEY_S : PyCEGUI.Key.S,
glfw.GLFW_KEY_T : PyCEGUI.Key.T,
glfw.GLFW_KEY_U : PyCEGUI.Key.U,
glfw.GLFW_KEY_V : PyCEGUI.Key.V,
glfw.GLFW_KEY_W : PyCEGUI.Key.W,
glfw.GLFW_KEY_X : PyCEGUI.Key.X,
glfw.GLFW_KEY_Y : PyCEGUI.Key.Y,
glfw.GLFW_KEY_Z : PyCEGUI.Key.Z,
glfw.GLFW_KEY_LEFT_BRACKET : PyCEGUI.Key.LeftBracket,
glfw.GLFW_KEY_BACKSLASH : PyCEGUI.Key.Backslash,
glfw.GLFW_KEY_RIGHT_BRACKET : PyCEGUI.Key.RightBracket,
glfw.GLFW_KEY_GRAVE_ACCENT : PyCEGUI.Key.Grave,
glfw.GLFW_KEY_WORLD_1 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_WORLD_2 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_ESCAPE : PyCEGUI.Key.Escape,
glfw.GLFW_KEY_ENTER : PyCEGUI.Key.Return,
glfw.GLFW_KEY_TAB : PyCEGUI.Key.Tab,
glfw.GLFW_KEY_BACKSPACE : PyCEGUI.Key.Backspace,
glfw.GLFW_KEY_INSERT : PyCEGUI.Key.Insert,
glfw.GLFW_KEY_DELETE : PyCEGUI.Key.Delete,
glfw.GLFW_KEY_RIGHT : PyCEGUI.Key.ArrowRight,
glfw.GLFW_KEY_LEFT : PyCEGUI.Key.ArrowLeft,
glfw.GLFW_KEY_DOWN : PyCEGUI.Key.ArrowDown,
glfw.GLFW_KEY_UP : PyCEGUI.Key.ArrowUp,
glfw.GLFW_KEY_PAGE_UP : PyCEGUI.Key.PageUp,
glfw.GLFW_KEY_PAGE_DOWN : PyCEGUI.Key.PageDown,
glfw.GLFW_KEY_HOME : PyCEGUI.Key.Home,
glfw.GLFW_KEY_END : PyCEGUI.Key.End,
glfw.GLFW_KEY_CAPS_LOCK : PyCEGUI.Key.Capital,
glfw.GLFW_KEY_SCROLL_LOCK : PyCEGUI.Key.ScrollLock,
glfw.GLFW_KEY_NUM_LOCK : PyCEGUI.Key.NumLock,
glfw.GLFW_KEY_PRINT_SCREEN : PyCEGUI.Key.SysRq,
glfw.GLFW_KEY_PAUSE : PyCEGUI.Key.Pause,
glfw.GLFW_KEY_F1 : PyCEGUI.Key.F1,
glfw.GLFW_KEY_F2 : PyCEGUI.Key.F2,
glfw.GLFW_KEY_F3 : PyCEGUI.Key.F3,
glfw.GLFW_KEY_F4 : PyCEGUI.Key.F4,
glfw.GLFW_KEY_F5 : PyCEGUI.Key.F5,
glfw.GLFW_KEY_F6 : PyCEGUI.Key.F6,
glfw.GLFW_KEY_F7 : PyCEGUI.Key.F7,
glfw.GLFW_KEY_F8 : PyCEGUI.Key.F8,
glfw.GLFW_KEY_F9 : PyCEGUI.Key.F9,
glfw.GLFW_KEY_F10 : PyCEGUI.Key.F10,
glfw.GLFW_KEY_F11 : PyCEGUI.Key.F11,
glfw.GLFW_KEY_F12 : PyCEGUI.Key.F12,
glfw.GLFW_KEY_F13 : PyCEGUI.Key.F13,
glfw.GLFW_KEY_F14 : PyCEGUI.Key.F14,
glfw.GLFW_KEY_F15 : PyCEGUI.Key.F15,
glfw.GLFW_KEY_F16 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F17 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F18 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F19 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F20 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F21 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F22 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F23 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F24 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F25 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_KP_0 : PyCEGUI.Key.Numpad0,
glfw.GLFW_KEY_KP_1 : PyCEGUI.Key.Numpad1,
glfw.GLFW_KEY_KP_2 : PyCEGUI.Key.Numpad2,
glfw.GLFW_KEY_KP_3 : PyCEGUI.Key.Numpad3,
glfw.GLFW_KEY_KP_4 : PyCEGUI.Key.Numpad4,
glfw.GLFW_KEY_KP_5 : PyCEGUI.Key.Numpad5,
glfw.GLFW_KEY_KP_6 : PyCEGUI.Key.Numpad6,
glfw.GLFW_KEY_KP_7 : PyCEGUI.Key.Numpad7,
glfw.GLFW_KEY_KP_8 : PyCEGUI.Key.Numpad8,
glfw.GLFW_KEY_KP_9 : PyCEGUI.Key.Numpad9,
glfw.GLFW_KEY_KP_DECIMAL : PyCEGUI.Key.Decimal,
glfw.GLFW_KEY_KP_DIVIDE : PyCEGUI.Key.Divide,
glfw.GLFW_KEY_KP_MULTIPLY : PyCEGUI.Key.Multiply,
glfw.GLFW_KEY_KP_SUBTRACT : PyCEGUI.Key.Subtract,
glfw.GLFW_KEY_KP_ADD : PyCEGUI.Key.Add,
glfw.GLFW_KEY_KP_ENTER : PyCEGUI.Key.NumpadEnter,
glfw.GLFW_KEY_KP_EQUAL : PyCEGUI.Key.NumpadEquals,
glfw.GLFW_KEY_LEFT_SHIFT : PyCEGUI.Key.LeftShift,
glfw.GLFW_KEY_LEFT_CONTROL : PyCEGUI.Key.LeftControl,
glfw.GLFW_KEY_LEFT_ALT : PyCEGUI.Key.LeftAlt,
glfw.GLFW_KEY_LEFT_SUPER : PyCEGUI.Key.LeftWindows,
glfw.GLFW_KEY_RIGHT_SHIFT : PyCEGUI.Key.RightShift,
glfw.GLFW_KEY_RIGHT_CONTROL : PyCEGUI.Key.RightControl,
glfw.GLFW_KEY_RIGHT_ALT : PyCEGUI.Key.RightAlt,
glfw.GLFW_KEY_RIGHT_SUPER : PyCEGUI.Key.RightWindows,
glfw.GLFW_KEY_MENU : PyCEGUI.Key.AppMenu,
glfw.GLFW_KEY_LAST : PyCEGUI.Key.AppMenu
}

== Initialization glf3==

# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)

== Window Hints==

Glfw3 allows to define window hints prior to creation and hints about your OpenGL Context (OpenGL Version). Note the MAJOR/MINOR values are the minimum API version of the window context, i.e. if you graphics card supports GL 4.4 that is what will be returned.

GLFW_OPENGL_FORWARD_COMPAT (True) indicates that functionality deprecated in the requested version of OpenGL is removed.

For the sake of testing PyCEGUI's OpenGL render set:
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(True) - OpenGL3Renderer without GL2.1
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(False) - OpenGL3Renderer with GL2.1
ceguiGL3Renderer(False) - OpenGLRenderer

ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)

== Creating Window==
If you try to create a window with a context that you graphics card does not support glfwCreateWindow will fail. We
also need to make our context current prior to creating our PyCEGUI renderer.

glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()

glfw.glfwMakeContextCurrent(glfw_window)

== VSnyc ==
This does nothing on linux and is dependent on your card settings. For example with a NVidia card change settings with NVidia X Server Settings->OpenGL Settings->Sync to VBlank.

glfw.glfwSwapInterval(0)

== Callbacks ==
See the source for each of the following callbacks where we notify CEGUI of display size changes, mouse presses/movement, key presses and glfwSetCharCallback is our callback to pass the unicode char/key pressed to CEGUI.

glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)

== PyCEGUI Renderer ==
Create our PyCEGUI renderer.

if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()

== Main Loop ==
Our main loop runs until the glfw3 window is closed updating CEGUI, swapping the buffers and handling glfw events.

def updateCEGUI(self, elapsed):
##CEGUI updates ###
if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))

while not glfw.glfwWindowShouldClose(self.glfw_window):
PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)
# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time
# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)
# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)
# Handle glfw events
glfw.glfwPollEvents()

== Demo Source ==

This is the full source code for the demo, see above saving the keyboard mappings.

# -- coding: utf-8 --
import glfw
import OpenGL.GL as PyGL
import sys, os , site
## set the path of your PyCEGUI* modules
for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")
## set the path to our resource files
CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"
## import our PyCEGUI and out glfw3 to cegui key mappings
import PyCEGUI
import PyCEGUIOpenGLRenderer
from keymappings_glfw3 import *
def ConvertMouseButton(button):
### Convert Mouse Buttons to CEGUI
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton
class Application(object):
def __init__(self):
# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)
ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)
# our window hints
## http://www.glfw.org/docs/latest/window.html
## set our framebuffer related hints
glfw.glfwWindowHint(glfw.GLFW_DEPTH_BITS, 24)
glfw.glfwWindowHint(glfw.GLFW_STENCIL_BITS, 8)
glfw.glfwWindowHint(glfw.GLFW_FOCUSED, True)
fullScreen = False
# create window
if (not fullScreen):
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
else:
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", glfw.glfwGetPrimaryMonitor(), None)
# check window created
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()
self.glfw_window = glfw_window
glfw.glfwMakeContextCurrent(glfw_window)
self.showglfwInfo()
## this does nothing on linux
glfw.glfwSwapInterval(0)
glfw.glfwSetInputMode(glfw_window, glfw.GLFW_CURSOR, glfw.GLFW_CURSOR_HIDDEN)
# call backs
glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)
# initialise our CEGUI renderer
ctx_major = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)
if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()
# initialise PyCEGUI and resources
rp = PyCEGUI.System.getSingleton().getResourceProvider()
rp.setResourceGroupDirectory("schemes", CEGUI_PATH + "schemes")
rp.setResourceGroupDirectory("imagesets", CEGUI_PATH + "imagesets")
rp.setResourceGroupDirectory("fonts", CEGUI_PATH + "fonts")
rp.setResourceGroupDirectory("layouts", CEGUI_PATH + "layouts")
rp.setResourceGroupDirectory("looknfeels", CEGUI_PATH + "looknfeel")
rp.setResourceGroupDirectory("schemas", CEGUI_PATH + "xml_schemas")
PyCEGUI.ImageManager.setImagesetDefaultResourceGroup("imagesets")
PyCEGUI.Font.setDefaultResourceGroup("fonts")
PyCEGUI.Scheme.setDefaultResourceGroup("schemes")
PyCEGUI.WidgetLookManager.setDefaultResourceGroup("looknfeels")
PyCEGUI.WindowManager.setDefaultResourceGroup("layouts")
parser = PyCEGUI.System.getSingleton().getXMLParser()
if parser.isPropertyPresent("SchemaDefaultResourceGroup"):
parser.setProperty("SchemaDefaultResourceGroup", "schemas")
# Load schemes
PyCEGUI.SchemeManager.getSingleton().createFromFile("TaharezLook.scheme")
PyCEGUI.SchemeManager.getSingleton().createFromFile("WindowsLook.scheme")
PyCEGUI.System.getSingleton().getDefaultGUIContext().getMouseCursor().setDefaultImage("TaharezLook/MouseArrow")
# set root window
root = PyCEGUI.WindowManager.getSingleton().createWindow("DefaultWindow", "background_wnd");
root.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(0.0, 0),PyCEGUI.UDim(0.0, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(1.0, 0),PyCEGUI.UDim(1.0, 0)))
PyCEGUI.System.getSingleton().getDefaultGUIContext().setRootWindow(root)
# load a layout
layout = PyCEGUI.WindowManager.getSingleton().loadLayoutFromFile("TextDemo.layout")
root.addChild(layout.getChild('TextDemo'))
self.edit = root.getChild('TextDemo/MultiLineGroup/editMulti')
# create label for our FPS
self.labelFPS = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Label", "FPSLabel")
root.addChild(self.labelFPS)
# create hello button
button = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Button", "HelloButton")
button.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(.50, 0),PyCEGUI.UDim(.92, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(0.3, 0),PyCEGUI.UDim(0.05, 0)))
button.setText("Hello")
root.addChild(button)
button.subscribeEvent(PyCEGUI.PushButton.EventClicked, self.OnbuttonClicked)
# init simple timing
self.previous_time = glfw.glfwGetTime()
self.current_time = self.previous_time
def showglfwInfo(self):
ctx_major = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)
print "Created Window for OpenGL version %d.%d " % ( ctx_major, ctx_major )
if ( ctx_major >=3 and forward_compat):
print "Context is forward compatible, you can't use OpenGL 2.x commands"
fwidth,fheight = glfw.glfwGetFramebufferSize(self.glfw_window)
width, height = glfw.glfwGetWindowSize(self.glfw_window)
print "Framebuffer size %dx%d Window size %dx%d " % (fwidth,fheight, width,height)
def OnbuttonClicked(self, args):
self.edit.setText(self.edit.getText() + "You Clicked")
return
def cleanUp(self):
### shutdown glfw and CEGUI
PyCEGUIOpenGLRenderer.OpenGLRenderer.destroySystem()
glfw.glfwTerminate()
def updateGL(self):
### glfw GL updates
pass
def updateCEGUI(self, elapsed):
### CEGUI updates
#focused = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))
def mainLoop(self):
### Loop until glfw window is closed
while not glfw.glfwWindowShouldClose(self.glfw_window):
PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)
# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time
# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)
# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)
# Handle glfw events
glfw.glfwPollEvents()
def on_framebuffer_size_callback(self,window,width,height):
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))
def on_move(self, window, x,y):
### pass glfw mouse moves to CEGUI
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectMousePosition(x, y)
def on_resize(self, window, width,height):
### resize glfw viewport and CEGUI display
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))
def on_mouse(self, window, button, action, mods):
### pass glfw mouse press events to CEGUI
if ( PyCEGUI.System.getSingleton()):
context = PyCEGUI.System.getSingleton().getDefaultGUIContext()
if (action == glfw.GLFW_PRESS):
context.injectMouseButtonDown( ConvertMouseButton(button) )
if (action == glfw.GLFW_RELEASE):
context.injectMouseButtonUp( ConvertMouseButton(button) )
def on_char_callback(self, window, code):
### Unicode character callback function to CEGUI
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectChar(code)
def on_key(self, window, key, scancode, action, mods):
### pass keypress events to CEGUI
if PyCEGUI.System.getSingleton():
cegui_key = KEYMAPPINGS[key]
if (not cegui_key==PyCEGUI.Key.Unknown):
if (action == glfw.GLFW_PRESS):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyDown(PyCEGUI.Key.Scan(cegui_key))
if (action == glfw.GLFW_RELEASE):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyUp(PyCEGUI.Key.Scan(cegui_key))
## exit
if key == glfw.GLFW_KEY_ESCAPE and action == glfw.GLFW_PRESS:
glfw.glfwSetWindowShouldClose(window,1)
if __name__ == '__main__':
app = Application()
app.mainLoop()
app.cleanUp()
del app

And here is the link for the formatted [http://pastebin.com/d8RyqvSg source]

[[Category:Tutorials]]

Using PyCEGUI with glfw3 and PyOpenGL (0.8)

2015-03-27T13:07:15Z

Dermont: /* Main Loop */

{{VersionBadge|0.8}}

== Getting Started ==

For this example it is assumed that [http://www.glfw.org/download.html glfw3] and [http://www.opengl.org OpenGL] are already installed.
We will be using the bindings for [https://github.com/rougier/pyglfw.git python glfw3] from Nicolas P. Rougier. Download from git clone https://github.com/rougier/pyglfw.git and copy the file glfw.py to the directory you are running the demo from.

== Importing Modules ==
If you have trouble importing the PyCEGUI libraries you can update your python path to point to the location of the modules. For Linux you can simply point to your CEGUI build_dir/lib.

for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
#sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")

== Setting Data Path ==
Set your path to the CEGUI media dir.

CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"

== Mouse/KeyBoard Mappings==

def ConvertMouseButton(button):
##Convert Mouse Buttons to CEGUI
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton

Copy the following keyboard mappings to keymappings_glfw3.py in same directory as the demo.

import sys
import glfw
import PyCEGUI
KEYMAPPINGS = {
glfw.GLFW_KEY_UNKNOWN : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_SPACE : PyCEGUI.Key.Space,
glfw.GLFW_KEY_APOSTROPHE : PyCEGUI.Key.Apostrophe,
glfw.GLFW_KEY_COMMA : PyCEGUI.Key.Comma,
glfw.GLFW_KEY_MINUS : PyCEGUI.Key.Minus,
glfw.GLFW_KEY_PERIOD : PyCEGUI.Key.Period,
glfw.GLFW_KEY_SLASH : PyCEGUI.Key.Slash,
glfw.GLFW_KEY_0 : PyCEGUI.Key.Zero,
glfw.GLFW_KEY_1 : PyCEGUI.Key.One,
glfw.GLFW_KEY_2 : PyCEGUI.Key.Two,
glfw.GLFW_KEY_3 : PyCEGUI.Key.Three,
glfw.GLFW_KEY_4 : PyCEGUI.Key.Four,
glfw.GLFW_KEY_5 : PyCEGUI.Key.Five,
glfw.GLFW_KEY_6 : PyCEGUI.Key.Six,
glfw.GLFW_KEY_7 : PyCEGUI.Key.Seven,
glfw.GLFW_KEY_8 : PyCEGUI.Key.Eight,
glfw.GLFW_KEY_9 : PyCEGUI.Key.Nine,
glfw.GLFW_KEY_SEMICOLON : PyCEGUI.Key.Semicolon,
glfw.GLFW_KEY_EQUAL : PyCEGUI.Key.Equals,
glfw.GLFW_KEY_A : PyCEGUI.Key.A,
glfw.GLFW_KEY_B : PyCEGUI.Key.B,
glfw.GLFW_KEY_C : PyCEGUI.Key.C,
glfw.GLFW_KEY_D : PyCEGUI.Key.D,
glfw.GLFW_KEY_E : PyCEGUI.Key.E,
glfw.GLFW_KEY_F : PyCEGUI.Key.F,
glfw.GLFW_KEY_G : PyCEGUI.Key.G,
glfw.GLFW_KEY_H : PyCEGUI.Key.H,
glfw.GLFW_KEY_I : PyCEGUI.Key.I,
glfw.GLFW_KEY_J : PyCEGUI.Key.J,
glfw.GLFW_KEY_K : PyCEGUI.Key.K,
glfw.GLFW_KEY_L : PyCEGUI.Key.L,
glfw.GLFW_KEY_M : PyCEGUI.Key.M,
glfw.GLFW_KEY_N : PyCEGUI.Key.N,
glfw.GLFW_KEY_O : PyCEGUI.Key.O,
glfw.GLFW_KEY_P : PyCEGUI.Key.P,
glfw.GLFW_KEY_Q : PyCEGUI.Key.Q,
glfw.GLFW_KEY_R : PyCEGUI.Key.R,
glfw.GLFW_KEY_S : PyCEGUI.Key.S,
glfw.GLFW_KEY_T : PyCEGUI.Key.T,
glfw.GLFW_KEY_U : PyCEGUI.Key.U,
glfw.GLFW_KEY_V : PyCEGUI.Key.V,
glfw.GLFW_KEY_W : PyCEGUI.Key.W,
glfw.GLFW_KEY_X : PyCEGUI.Key.X,
glfw.GLFW_KEY_Y : PyCEGUI.Key.Y,
glfw.GLFW_KEY_Z : PyCEGUI.Key.Z,
glfw.GLFW_KEY_LEFT_BRACKET : PyCEGUI.Key.LeftBracket,
glfw.GLFW_KEY_BACKSLASH : PyCEGUI.Key.Backslash,
glfw.GLFW_KEY_RIGHT_BRACKET : PyCEGUI.Key.RightBracket,
glfw.GLFW_KEY_GRAVE_ACCENT : PyCEGUI.Key.Grave,
glfw.GLFW_KEY_WORLD_1 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_WORLD_2 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_ESCAPE : PyCEGUI.Key.Escape,
glfw.GLFW_KEY_ENTER : PyCEGUI.Key.Return,
glfw.GLFW_KEY_TAB : PyCEGUI.Key.Tab,
glfw.GLFW_KEY_BACKSPACE : PyCEGUI.Key.Backspace,
glfw.GLFW_KEY_INSERT : PyCEGUI.Key.Insert,
glfw.GLFW_KEY_DELETE : PyCEGUI.Key.Delete,
glfw.GLFW_KEY_RIGHT : PyCEGUI.Key.ArrowRight,
glfw.GLFW_KEY_LEFT : PyCEGUI.Key.ArrowLeft,
glfw.GLFW_KEY_DOWN : PyCEGUI.Key.ArrowDown,
glfw.GLFW_KEY_UP : PyCEGUI.Key.ArrowUp,
glfw.GLFW_KEY_PAGE_UP : PyCEGUI.Key.PageUp,
glfw.GLFW_KEY_PAGE_DOWN : PyCEGUI.Key.PageDown,
glfw.GLFW_KEY_HOME : PyCEGUI.Key.Home,
glfw.GLFW_KEY_END : PyCEGUI.Key.End,
glfw.GLFW_KEY_CAPS_LOCK : PyCEGUI.Key.Capital,
glfw.GLFW_KEY_SCROLL_LOCK : PyCEGUI.Key.ScrollLock,
glfw.GLFW_KEY_NUM_LOCK : PyCEGUI.Key.NumLock,
glfw.GLFW_KEY_PRINT_SCREEN : PyCEGUI.Key.SysRq,
glfw.GLFW_KEY_PAUSE : PyCEGUI.Key.Pause,
glfw.GLFW_KEY_F1 : PyCEGUI.Key.F1,
glfw.GLFW_KEY_F2 : PyCEGUI.Key.F2,
glfw.GLFW_KEY_F3 : PyCEGUI.Key.F3,
glfw.GLFW_KEY_F4 : PyCEGUI.Key.F4,
glfw.GLFW_KEY_F5 : PyCEGUI.Key.F5,
glfw.GLFW_KEY_F6 : PyCEGUI.Key.F6,
glfw.GLFW_KEY_F7 : PyCEGUI.Key.F7,
glfw.GLFW_KEY_F8 : PyCEGUI.Key.F8,
glfw.GLFW_KEY_F9 : PyCEGUI.Key.F9,
glfw.GLFW_KEY_F10 : PyCEGUI.Key.F10,
glfw.GLFW_KEY_F11 : PyCEGUI.Key.F11,
glfw.GLFW_KEY_F12 : PyCEGUI.Key.F12,
glfw.GLFW_KEY_F13 : PyCEGUI.Key.F13,
glfw.GLFW_KEY_F14 : PyCEGUI.Key.F14,
glfw.GLFW_KEY_F15 : PyCEGUI.Key.F15,
glfw.GLFW_KEY_F16 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F17 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F18 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F19 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F20 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F21 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F22 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F23 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F24 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F25 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_KP_0 : PyCEGUI.Key.Numpad0,
glfw.GLFW_KEY_KP_1 : PyCEGUI.Key.Numpad1,
glfw.GLFW_KEY_KP_2 : PyCEGUI.Key.Numpad2,
glfw.GLFW_KEY_KP_3 : PyCEGUI.Key.Numpad3,
glfw.GLFW_KEY_KP_4 : PyCEGUI.Key.Numpad4,
glfw.GLFW_KEY_KP_5 : PyCEGUI.Key.Numpad5,
glfw.GLFW_KEY_KP_6 : PyCEGUI.Key.Numpad6,
glfw.GLFW_KEY_KP_7 : PyCEGUI.Key.Numpad7,
glfw.GLFW_KEY_KP_8 : PyCEGUI.Key.Numpad8,
glfw.GLFW_KEY_KP_9 : PyCEGUI.Key.Numpad9,
glfw.GLFW_KEY_KP_DECIMAL : PyCEGUI.Key.Decimal,
glfw.GLFW_KEY_KP_DIVIDE : PyCEGUI.Key.Divide,
glfw.GLFW_KEY_KP_MULTIPLY : PyCEGUI.Key.Multiply,
glfw.GLFW_KEY_KP_SUBTRACT : PyCEGUI.Key.Subtract,
glfw.GLFW_KEY_KP_ADD : PyCEGUI.Key.Add,
glfw.GLFW_KEY_KP_ENTER : PyCEGUI.Key.NumpadEnter,
glfw.GLFW_KEY_KP_EQUAL : PyCEGUI.Key.NumpadEquals,
glfw.GLFW_KEY_LEFT_SHIFT : PyCEGUI.Key.LeftShift,
glfw.GLFW_KEY_LEFT_CONTROL : PyCEGUI.Key.LeftControl,
glfw.GLFW_KEY_LEFT_ALT : PyCEGUI.Key.LeftAlt,
glfw.GLFW_KEY_LEFT_SUPER : PyCEGUI.Key.LeftWindows,
glfw.GLFW_KEY_RIGHT_SHIFT : PyCEGUI.Key.RightShift,
glfw.GLFW_KEY_RIGHT_CONTROL : PyCEGUI.Key.RightControl,
glfw.GLFW_KEY_RIGHT_ALT : PyCEGUI.Key.RightAlt,
glfw.GLFW_KEY_RIGHT_SUPER : PyCEGUI.Key.RightWindows,
glfw.GLFW_KEY_MENU : PyCEGUI.Key.AppMenu,
glfw.GLFW_KEY_LAST : PyCEGUI.Key.AppMenu
}

== Initialization glf3==

# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)

== Window Hints==

Glfw3 allows to define window hints prior to creation and hints about your OpenGL Context (OpenGL Version). Note the MAJOR/MINOR values are the minimum API version of the window context, i.e. if you graphics card supports GL 4.4 that is what will be returned.

GLFW_OPENGL_FORWARD_COMPAT (True) indicates that functionality deprecated in the requested version of OpenGL is removed.

For the sake of testing PyCEGUI's OpenGL render set:
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(True) - OpenGL3Renderer without GL2.1
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(False) - OpenGL3Renderer with GL2.1
ceguiGL3Renderer(False) - OpenGLRenderer

ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)

== Creating Window==
If you try to create a window with a context that you graphics card does not support glfwCreateWindow will fail. We
also need to make our context current prior to creating our PyCEGUI renderer.

glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()

glfw.glfwMakeContextCurrent(glfw_window)

== VSnyc ==
This does nothing on linux and is dependent on your card settings. For example with a NVidia card change settings with NVidia X Server Settings->OpenGL Settings->Sync to VBlank.

glfw.glfwSwapInterval(0)

== Callbacks ==
See the source for each of the following callbacks where we notify CEGUI of display size changes, mouse presses/movement, key presses and glfwSetCharCallback is our callback to pass the unicode char/key pressed to CEGUI.

glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)

== PyCEGUI Renderer ==
Create our PyCEGUI renderer.

if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()

== Main Loop ==
Our main loop runs until the glfw3 window is closed updating CEGUI, swapping the buffers and handling glfw events.

def updateCEGUI(self, elapsed):
##CEGUI updates ###
if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))

while not glfw.glfwWindowShouldClose(self.glfw_window):
PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)
# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time
# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)
# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)
# Handle glfw events
glfw.glfwPollEvents()

== Demo Source ==

This is the full source code for the demo, see above saving the keyboard mappings.

# -- coding: utf-8 --

import glfw
import OpenGL.GL as PyGL
import sys, os , site

## set the path of your PyCEGUI* modules
for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")

## set the path to our resource files
CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"

## import our PyCEGUI and out glfw3 to cegui key mappings
import PyCEGUI
import PyCEGUIOpenGLRenderer
from keymappings_glfw3 import *

def ConvertMouseButton(button):
''' Convert Mouse Buttons to CEGUI '''
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton

class Application(object):
def __init__(self):

# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)

ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)

# our window hints
## http://www.glfw.org/docs/latest/window.html
## set our framebuffer related hints
glfw.glfwWindowHint(glfw.GLFW_DEPTH_BITS, 24)
glfw.glfwWindowHint(glfw.GLFW_STENCIL_BITS, 8)

glfw.glfwWindowHint(glfw.GLFW_FOCUSED, True)

fullScreen = False
# create window
if (not fullScreen):
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
else:
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", glfw.glfwGetPrimaryMonitor(), None)

# check window created
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()
self.glfw_window = glfw_window

glfw.glfwMakeContextCurrent(glfw_window)

self.showglfwInfo()

## this does nothing on linux
glfw.glfwSwapInterval(0)

glfw.glfwSetInputMode(glfw_window, glfw.GLFW_CURSOR, glfw.GLFW_CURSOR_HIDDEN)

# call backs
glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)

# initialise our CEGUI renderer
ctx_major = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)

if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()

# initialise PyCEGUI and resources
rp = PyCEGUI.System.getSingleton().getResourceProvider()

rp.setResourceGroupDirectory("schemes", CEGUI_PATH + "schemes")
rp.setResourceGroupDirectory("imagesets", CEGUI_PATH + "imagesets")
rp.setResourceGroupDirectory("fonts", CEGUI_PATH + "fonts")
rp.setResourceGroupDirectory("layouts", CEGUI_PATH + "layouts")
rp.setResourceGroupDirectory("looknfeels", CEGUI_PATH + "looknfeel")
rp.setResourceGroupDirectory("schemas", CEGUI_PATH + "xml_schemas")

PyCEGUI.ImageManager.setImagesetDefaultResourceGroup("imagesets")
PyCEGUI.Font.setDefaultResourceGroup("fonts")
PyCEGUI.Scheme.setDefaultResourceGroup("schemes")
PyCEGUI.WidgetLookManager.setDefaultResourceGroup("looknfeels")
PyCEGUI.WindowManager.setDefaultResourceGroup("layouts")

parser = PyCEGUI.System.getSingleton().getXMLParser()
if parser.isPropertyPresent("SchemaDefaultResourceGroup"):
parser.setProperty("SchemaDefaultResourceGroup", "schemas")

# Load schemes
PyCEGUI.SchemeManager.getSingleton().createFromFile("TaharezLook.scheme")
PyCEGUI.SchemeManager.getSingleton().createFromFile("WindowsLook.scheme")
PyCEGUI.System.getSingleton().getDefaultGUIContext().getMouseCursor().setDefaultImage("TaharezLook/MouseArrow")

# set root window
root = PyCEGUI.WindowManager.getSingleton().createWindow("DefaultWindow", "background_wnd");
root.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(0.0, 0),PyCEGUI.UDim(0.0, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(1.0, 0),PyCEGUI.UDim(1.0, 0)))
PyCEGUI.System.getSingleton().getDefaultGUIContext().setRootWindow(root)

# load a layout
layout = PyCEGUI.WindowManager.getSingleton().loadLayoutFromFile("TextDemo.layout")
root.addChild(layout.getChild('TextDemo'))
self.edit = root.getChild('TextDemo/MultiLineGroup/editMulti')

# create label for our FPS
self.labelFPS = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Label", "FPSLabel")
root.addChild(self.labelFPS)

# create hello button
button = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Button", "HelloButton")
button.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(.50, 0),PyCEGUI.UDim(.92, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(0.3, 0),PyCEGUI.UDim(0.05, 0)))
button.setText("Hello")
root.addChild(button)
button.subscribeEvent(PyCEGUI.PushButton.EventClicked, self.OnbuttonClicked)

# init simple timing
self.previous_time = glfw.glfwGetTime()
self.current_time = self.previous_time

def showglfwInfo(self):
ctx_major = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)
print "Created Window for OpenGL version %d.%d " % ( ctx_major, ctx_major )
if ( ctx_major >=3 and forward_compat):
print "Context is forward compatible, you can't use OpenGL 2.x commands"
fwidth,fheight = glfw.glfwGetFramebufferSize(self.glfw_window)
width, height = glfw.glfwGetWindowSize(self.glfw_window)

print "Framebuffer size %dx%d Window size %dx%d " % (fwidth,fheight, width,height)

def OnbuttonClicked(self, args):
self.edit.setText(self.edit.getText() + "You Clicked")
return

def cleanUp(self):
''' shutdown glfw and CEGUI '''
PyCEGUIOpenGLRenderer.OpenGLRenderer.destroySystem()
glfw.glfwTerminate()

def updateGL(self):
''' glfw GL updates '''
pass

def updateCEGUI(self, elapsed):
''' CEGUI updates '''
#focused = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)

if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))

def mainLoop(self):
''' Loop until glfw window is closed '''

while not glfw.glfwWindowShouldClose(self.glfw_window):

PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)

# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time

# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)

# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)

# Handle glfw events
glfw.glfwPollEvents()

def on_framebuffer_size_callback(self,window,width,height):
''' the framebuffer on high-DPI monitors may differ from the screen co-ords, so notify display size change here '''
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))

def on_move(self, window, x,y):
''' pass glfw mouse moves to CEGUI '''
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectMousePosition(x, y)

def on_resize(self, window, width,height):
''' resize glfw viewport and CEGUI display '''
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))

def on_mouse(self, window, button, action, mods):
''' pass glfw mouse press events to CEGUI '''
if ( PyCEGUI.System.getSingleton()):
context = PyCEGUI.System.getSingleton().getDefaultGUIContext()
if (action == glfw.GLFW_PRESS):
context.injectMouseButtonDown( ConvertMouseButton(button) )
if (action == glfw.GLFW_RELEASE):
context.injectMouseButtonUp( ConvertMouseButton(button) )

def on_char_callback(self, window, code):
''' Unicode character callback function to CEGUI '''
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectChar(code)

def on_key(self, window, key, scancode, action, mods):
''' pass keypress events to CEGUI '''
if PyCEGUI.System.getSingleton():
cegui_key = KEYMAPPINGS[key]
if (not cegui_key==PyCEGUI.Key.Unknown):
if (action == glfw.GLFW_PRESS):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyDown(PyCEGUI.Key.Scan(cegui_key))
if (action == glfw.GLFW_RELEASE):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyUp(PyCEGUI.Key.Scan(cegui_key))

## exit
if key == glfw.GLFW_KEY_ESCAPE and action == glfw.GLFW_PRESS:
glfw.glfwSetWindowShouldClose(window,1)
if __name__ == '__main__':
app = Application()
app.mainLoop()
app.cleanUp()
del app

And here is the link for the formatted [http://pastebin.com/d8RyqvSg source]

[[Category:Tutorials]]

Using PyCEGUI with glfw3 and PyOpenGL (0.8)

2015-03-27T13:06:19Z

Dermont: /* Mouse/KeyBoard Mappings */

{{VersionBadge|0.8}}

== Getting Started ==

For this example it is assumed that [http://www.glfw.org/download.html glfw3] and [http://www.opengl.org OpenGL] are already installed.
We will be using the bindings for [https://github.com/rougier/pyglfw.git python glfw3] from Nicolas P. Rougier. Download from git clone https://github.com/rougier/pyglfw.git and copy the file glfw.py to the directory you are running the demo from.

== Importing Modules ==
If you have trouble importing the PyCEGUI libraries you can update your python path to point to the location of the modules. For Linux you can simply point to your CEGUI build_dir/lib.

for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
#sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")

== Setting Data Path ==
Set your path to the CEGUI media dir.

CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"

== Mouse/KeyBoard Mappings==

def ConvertMouseButton(button):
##Convert Mouse Buttons to CEGUI
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton

Copy the following keyboard mappings to keymappings_glfw3.py in same directory as the demo.

import sys
import glfw
import PyCEGUI
KEYMAPPINGS = {
glfw.GLFW_KEY_UNKNOWN : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_SPACE : PyCEGUI.Key.Space,
glfw.GLFW_KEY_APOSTROPHE : PyCEGUI.Key.Apostrophe,
glfw.GLFW_KEY_COMMA : PyCEGUI.Key.Comma,
glfw.GLFW_KEY_MINUS : PyCEGUI.Key.Minus,
glfw.GLFW_KEY_PERIOD : PyCEGUI.Key.Period,
glfw.GLFW_KEY_SLASH : PyCEGUI.Key.Slash,
glfw.GLFW_KEY_0 : PyCEGUI.Key.Zero,
glfw.GLFW_KEY_1 : PyCEGUI.Key.One,
glfw.GLFW_KEY_2 : PyCEGUI.Key.Two,
glfw.GLFW_KEY_3 : PyCEGUI.Key.Three,
glfw.GLFW_KEY_4 : PyCEGUI.Key.Four,
glfw.GLFW_KEY_5 : PyCEGUI.Key.Five,
glfw.GLFW_KEY_6 : PyCEGUI.Key.Six,
glfw.GLFW_KEY_7 : PyCEGUI.Key.Seven,
glfw.GLFW_KEY_8 : PyCEGUI.Key.Eight,
glfw.GLFW_KEY_9 : PyCEGUI.Key.Nine,
glfw.GLFW_KEY_SEMICOLON : PyCEGUI.Key.Semicolon,
glfw.GLFW_KEY_EQUAL : PyCEGUI.Key.Equals,
glfw.GLFW_KEY_A : PyCEGUI.Key.A,
glfw.GLFW_KEY_B : PyCEGUI.Key.B,
glfw.GLFW_KEY_C : PyCEGUI.Key.C,
glfw.GLFW_KEY_D : PyCEGUI.Key.D,
glfw.GLFW_KEY_E : PyCEGUI.Key.E,
glfw.GLFW_KEY_F : PyCEGUI.Key.F,
glfw.GLFW_KEY_G : PyCEGUI.Key.G,
glfw.GLFW_KEY_H : PyCEGUI.Key.H,
glfw.GLFW_KEY_I : PyCEGUI.Key.I,
glfw.GLFW_KEY_J : PyCEGUI.Key.J,
glfw.GLFW_KEY_K : PyCEGUI.Key.K,
glfw.GLFW_KEY_L : PyCEGUI.Key.L,
glfw.GLFW_KEY_M : PyCEGUI.Key.M,
glfw.GLFW_KEY_N : PyCEGUI.Key.N,
glfw.GLFW_KEY_O : PyCEGUI.Key.O,
glfw.GLFW_KEY_P : PyCEGUI.Key.P,
glfw.GLFW_KEY_Q : PyCEGUI.Key.Q,
glfw.GLFW_KEY_R : PyCEGUI.Key.R,
glfw.GLFW_KEY_S : PyCEGUI.Key.S,
glfw.GLFW_KEY_T : PyCEGUI.Key.T,
glfw.GLFW_KEY_U : PyCEGUI.Key.U,
glfw.GLFW_KEY_V : PyCEGUI.Key.V,
glfw.GLFW_KEY_W : PyCEGUI.Key.W,
glfw.GLFW_KEY_X : PyCEGUI.Key.X,
glfw.GLFW_KEY_Y : PyCEGUI.Key.Y,
glfw.GLFW_KEY_Z : PyCEGUI.Key.Z,
glfw.GLFW_KEY_LEFT_BRACKET : PyCEGUI.Key.LeftBracket,
glfw.GLFW_KEY_BACKSLASH : PyCEGUI.Key.Backslash,
glfw.GLFW_KEY_RIGHT_BRACKET : PyCEGUI.Key.RightBracket,
glfw.GLFW_KEY_GRAVE_ACCENT : PyCEGUI.Key.Grave,
glfw.GLFW_KEY_WORLD_1 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_WORLD_2 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_ESCAPE : PyCEGUI.Key.Escape,
glfw.GLFW_KEY_ENTER : PyCEGUI.Key.Return,
glfw.GLFW_KEY_TAB : PyCEGUI.Key.Tab,
glfw.GLFW_KEY_BACKSPACE : PyCEGUI.Key.Backspace,
glfw.GLFW_KEY_INSERT : PyCEGUI.Key.Insert,
glfw.GLFW_KEY_DELETE : PyCEGUI.Key.Delete,
glfw.GLFW_KEY_RIGHT : PyCEGUI.Key.ArrowRight,
glfw.GLFW_KEY_LEFT : PyCEGUI.Key.ArrowLeft,
glfw.GLFW_KEY_DOWN : PyCEGUI.Key.ArrowDown,
glfw.GLFW_KEY_UP : PyCEGUI.Key.ArrowUp,
glfw.GLFW_KEY_PAGE_UP : PyCEGUI.Key.PageUp,
glfw.GLFW_KEY_PAGE_DOWN : PyCEGUI.Key.PageDown,
glfw.GLFW_KEY_HOME : PyCEGUI.Key.Home,
glfw.GLFW_KEY_END : PyCEGUI.Key.End,
glfw.GLFW_KEY_CAPS_LOCK : PyCEGUI.Key.Capital,
glfw.GLFW_KEY_SCROLL_LOCK : PyCEGUI.Key.ScrollLock,
glfw.GLFW_KEY_NUM_LOCK : PyCEGUI.Key.NumLock,
glfw.GLFW_KEY_PRINT_SCREEN : PyCEGUI.Key.SysRq,
glfw.GLFW_KEY_PAUSE : PyCEGUI.Key.Pause,
glfw.GLFW_KEY_F1 : PyCEGUI.Key.F1,
glfw.GLFW_KEY_F2 : PyCEGUI.Key.F2,
glfw.GLFW_KEY_F3 : PyCEGUI.Key.F3,
glfw.GLFW_KEY_F4 : PyCEGUI.Key.F4,
glfw.GLFW_KEY_F5 : PyCEGUI.Key.F5,
glfw.GLFW_KEY_F6 : PyCEGUI.Key.F6,
glfw.GLFW_KEY_F7 : PyCEGUI.Key.F7,
glfw.GLFW_KEY_F8 : PyCEGUI.Key.F8,
glfw.GLFW_KEY_F9 : PyCEGUI.Key.F9,
glfw.GLFW_KEY_F10 : PyCEGUI.Key.F10,
glfw.GLFW_KEY_F11 : PyCEGUI.Key.F11,
glfw.GLFW_KEY_F12 : PyCEGUI.Key.F12,
glfw.GLFW_KEY_F13 : PyCEGUI.Key.F13,
glfw.GLFW_KEY_F14 : PyCEGUI.Key.F14,
glfw.GLFW_KEY_F15 : PyCEGUI.Key.F15,
glfw.GLFW_KEY_F16 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F17 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F18 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F19 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F20 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F21 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F22 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F23 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F24 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F25 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_KP_0 : PyCEGUI.Key.Numpad0,
glfw.GLFW_KEY_KP_1 : PyCEGUI.Key.Numpad1,
glfw.GLFW_KEY_KP_2 : PyCEGUI.Key.Numpad2,
glfw.GLFW_KEY_KP_3 : PyCEGUI.Key.Numpad3,
glfw.GLFW_KEY_KP_4 : PyCEGUI.Key.Numpad4,
glfw.GLFW_KEY_KP_5 : PyCEGUI.Key.Numpad5,
glfw.GLFW_KEY_KP_6 : PyCEGUI.Key.Numpad6,
glfw.GLFW_KEY_KP_7 : PyCEGUI.Key.Numpad7,
glfw.GLFW_KEY_KP_8 : PyCEGUI.Key.Numpad8,
glfw.GLFW_KEY_KP_9 : PyCEGUI.Key.Numpad9,
glfw.GLFW_KEY_KP_DECIMAL : PyCEGUI.Key.Decimal,
glfw.GLFW_KEY_KP_DIVIDE : PyCEGUI.Key.Divide,
glfw.GLFW_KEY_KP_MULTIPLY : PyCEGUI.Key.Multiply,
glfw.GLFW_KEY_KP_SUBTRACT : PyCEGUI.Key.Subtract,
glfw.GLFW_KEY_KP_ADD : PyCEGUI.Key.Add,
glfw.GLFW_KEY_KP_ENTER : PyCEGUI.Key.NumpadEnter,
glfw.GLFW_KEY_KP_EQUAL : PyCEGUI.Key.NumpadEquals,
glfw.GLFW_KEY_LEFT_SHIFT : PyCEGUI.Key.LeftShift,
glfw.GLFW_KEY_LEFT_CONTROL : PyCEGUI.Key.LeftControl,
glfw.GLFW_KEY_LEFT_ALT : PyCEGUI.Key.LeftAlt,
glfw.GLFW_KEY_LEFT_SUPER : PyCEGUI.Key.LeftWindows,
glfw.GLFW_KEY_RIGHT_SHIFT : PyCEGUI.Key.RightShift,
glfw.GLFW_KEY_RIGHT_CONTROL : PyCEGUI.Key.RightControl,
glfw.GLFW_KEY_RIGHT_ALT : PyCEGUI.Key.RightAlt,
glfw.GLFW_KEY_RIGHT_SUPER : PyCEGUI.Key.RightWindows,
glfw.GLFW_KEY_MENU : PyCEGUI.Key.AppMenu,
glfw.GLFW_KEY_LAST : PyCEGUI.Key.AppMenu
}

== Initialization glf3==

# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)

== Window Hints==

Glfw3 allows to define window hints prior to creation and hints about your OpenGL Context (OpenGL Version). Note the MAJOR/MINOR values are the minimum API version of the window context, i.e. if you graphics card supports GL 4.4 that is what will be returned.

GLFW_OPENGL_FORWARD_COMPAT (True) indicates that functionality deprecated in the requested version of OpenGL is removed.

For the sake of testing PyCEGUI's OpenGL render set:
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(True) - OpenGL3Renderer without GL2.1
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(False) - OpenGL3Renderer with GL2.1
ceguiGL3Renderer(False) - OpenGLRenderer

ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)

== Creating Window==
If you try to create a window with a context that you graphics card does not support glfwCreateWindow will fail. We
also need to make our context current prior to creating our PyCEGUI renderer.

glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()

glfw.glfwMakeContextCurrent(glfw_window)

== VSnyc ==
This does nothing on linux and is dependent on your card settings. For example with a NVidia card change settings with NVidia X Server Settings->OpenGL Settings->Sync to VBlank.

glfw.glfwSwapInterval(0)

== Callbacks ==
See the source for each of the following callbacks where we notify CEGUI of display size changes, mouse presses/movement, key presses and glfwSetCharCallback is our callback to pass the unicode char/key pressed to CEGUI.

glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)

== PyCEGUI Renderer ==
Create our PyCEGUI renderer.

if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()

== Main Loop ==
Our main loop runs until the glfw3 window is closed updating CEGUI, swapping the buffers and handling glfw events.

def updateCEGUI(self, elapsed):
##CEGUI updates ###
if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))

while not glfw.glfwWindowShouldClose(self.glfw_window):
PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)
# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time

# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)

# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)

# Handle glfw events
glfw.glfwPollEvents()

== Demo Source ==

This is the full source code for the demo, see above saving the keyboard mappings.

# -- coding: utf-8 --

import glfw
import OpenGL.GL as PyGL
import sys, os , site

## set the path of your PyCEGUI* modules
for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")

## set the path to our resource files
CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"

## import our PyCEGUI and out glfw3 to cegui key mappings
import PyCEGUI
import PyCEGUIOpenGLRenderer
from keymappings_glfw3 import *

def ConvertMouseButton(button):
''' Convert Mouse Buttons to CEGUI '''
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton

class Application(object):
def __init__(self):

# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)

ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)

# our window hints
## http://www.glfw.org/docs/latest/window.html
## set our framebuffer related hints
glfw.glfwWindowHint(glfw.GLFW_DEPTH_BITS, 24)
glfw.glfwWindowHint(glfw.GLFW_STENCIL_BITS, 8)

glfw.glfwWindowHint(glfw.GLFW_FOCUSED, True)

fullScreen = False
# create window
if (not fullScreen):
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
else:
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", glfw.glfwGetPrimaryMonitor(), None)

# check window created
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()
self.glfw_window = glfw_window

glfw.glfwMakeContextCurrent(glfw_window)

self.showglfwInfo()

## this does nothing on linux
glfw.glfwSwapInterval(0)

glfw.glfwSetInputMode(glfw_window, glfw.GLFW_CURSOR, glfw.GLFW_CURSOR_HIDDEN)

# call backs
glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)

# initialise our CEGUI renderer
ctx_major = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)

if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()

# initialise PyCEGUI and resources
rp = PyCEGUI.System.getSingleton().getResourceProvider()

rp.setResourceGroupDirectory("schemes", CEGUI_PATH + "schemes")
rp.setResourceGroupDirectory("imagesets", CEGUI_PATH + "imagesets")
rp.setResourceGroupDirectory("fonts", CEGUI_PATH + "fonts")
rp.setResourceGroupDirectory("layouts", CEGUI_PATH + "layouts")
rp.setResourceGroupDirectory("looknfeels", CEGUI_PATH + "looknfeel")
rp.setResourceGroupDirectory("schemas", CEGUI_PATH + "xml_schemas")

PyCEGUI.ImageManager.setImagesetDefaultResourceGroup("imagesets")
PyCEGUI.Font.setDefaultResourceGroup("fonts")
PyCEGUI.Scheme.setDefaultResourceGroup("schemes")
PyCEGUI.WidgetLookManager.setDefaultResourceGroup("looknfeels")
PyCEGUI.WindowManager.setDefaultResourceGroup("layouts")

parser = PyCEGUI.System.getSingleton().getXMLParser()
if parser.isPropertyPresent("SchemaDefaultResourceGroup"):
parser.setProperty("SchemaDefaultResourceGroup", "schemas")

# Load schemes
PyCEGUI.SchemeManager.getSingleton().createFromFile("TaharezLook.scheme")
PyCEGUI.SchemeManager.getSingleton().createFromFile("WindowsLook.scheme")
PyCEGUI.System.getSingleton().getDefaultGUIContext().getMouseCursor().setDefaultImage("TaharezLook/MouseArrow")

# set root window
root = PyCEGUI.WindowManager.getSingleton().createWindow("DefaultWindow", "background_wnd");
root.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(0.0, 0),PyCEGUI.UDim(0.0, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(1.0, 0),PyCEGUI.UDim(1.0, 0)))
PyCEGUI.System.getSingleton().getDefaultGUIContext().setRootWindow(root)

# load a layout
layout = PyCEGUI.WindowManager.getSingleton().loadLayoutFromFile("TextDemo.layout")
root.addChild(layout.getChild('TextDemo'))
self.edit = root.getChild('TextDemo/MultiLineGroup/editMulti')

# create label for our FPS
self.labelFPS = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Label", "FPSLabel")
root.addChild(self.labelFPS)

# create hello button
button = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Button", "HelloButton")
button.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(.50, 0),PyCEGUI.UDim(.92, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(0.3, 0),PyCEGUI.UDim(0.05, 0)))
button.setText("Hello")
root.addChild(button)
button.subscribeEvent(PyCEGUI.PushButton.EventClicked, self.OnbuttonClicked)

# init simple timing
self.previous_time = glfw.glfwGetTime()
self.current_time = self.previous_time

def showglfwInfo(self):
ctx_major = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)
print "Created Window for OpenGL version %d.%d " % ( ctx_major, ctx_major )
if ( ctx_major >=3 and forward_compat):
print "Context is forward compatible, you can't use OpenGL 2.x commands"
fwidth,fheight = glfw.glfwGetFramebufferSize(self.glfw_window)
width, height = glfw.glfwGetWindowSize(self.glfw_window)

print "Framebuffer size %dx%d Window size %dx%d " % (fwidth,fheight, width,height)

def OnbuttonClicked(self, args):
self.edit.setText(self.edit.getText() + "You Clicked")
return

def cleanUp(self):
''' shutdown glfw and CEGUI '''
PyCEGUIOpenGLRenderer.OpenGLRenderer.destroySystem()
glfw.glfwTerminate()

def updateGL(self):
''' glfw GL updates '''
pass

def updateCEGUI(self, elapsed):
''' CEGUI updates '''
#focused = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)

if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))

def mainLoop(self):
''' Loop until glfw window is closed '''

while not glfw.glfwWindowShouldClose(self.glfw_window):

PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)

# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time

# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)

# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)

# Handle glfw events
glfw.glfwPollEvents()

def on_framebuffer_size_callback(self,window,width,height):
''' the framebuffer on high-DPI monitors may differ from the screen co-ords, so notify display size change here '''
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))

def on_move(self, window, x,y):
''' pass glfw mouse moves to CEGUI '''
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectMousePosition(x, y)

def on_resize(self, window, width,height):
''' resize glfw viewport and CEGUI display '''
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))

def on_mouse(self, window, button, action, mods):
''' pass glfw mouse press events to CEGUI '''
if ( PyCEGUI.System.getSingleton()):
context = PyCEGUI.System.getSingleton().getDefaultGUIContext()
if (action == glfw.GLFW_PRESS):
context.injectMouseButtonDown( ConvertMouseButton(button) )
if (action == glfw.GLFW_RELEASE):
context.injectMouseButtonUp( ConvertMouseButton(button) )

def on_char_callback(self, window, code):
''' Unicode character callback function to CEGUI '''
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectChar(code)

def on_key(self, window, key, scancode, action, mods):
''' pass keypress events to CEGUI '''
if PyCEGUI.System.getSingleton():
cegui_key = KEYMAPPINGS[key]
if (not cegui_key==PyCEGUI.Key.Unknown):
if (action == glfw.GLFW_PRESS):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyDown(PyCEGUI.Key.Scan(cegui_key))
if (action == glfw.GLFW_RELEASE):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyUp(PyCEGUI.Key.Scan(cegui_key))

## exit
if key == glfw.GLFW_KEY_ESCAPE and action == glfw.GLFW_PRESS:
glfw.glfwSetWindowShouldClose(window,1)
if __name__ == '__main__':
app = Application()
app.mainLoop()
app.cleanUp()
del app

And here is the link for the formatted [http://pastebin.com/d8RyqvSg source]

[[Category:Tutorials]]

Using PyCEGUI with glfw3 and PyOpenGL (0.8)

2015-03-27T12:56:32Z

Dermont: An example of using PyCEGUI with glfw3

{{VersionBadge|0.8}}

== Getting Started ==

For this example it is assumed that [http://www.glfw.org/download.html glfw3] and [http://www.opengl.org OpenGL] are already installed.
We will be using the bindings for [https://github.com/rougier/pyglfw.git python glfw3] from Nicolas P. Rougier. Download from git clone https://github.com/rougier/pyglfw.git and copy the file glfw.py to the directory you are running the demo from.

== Importing Modules ==
If you have trouble importing the PyCEGUI libraries you can update your python path to point to the location of the modules. For Linux you can simply point to your CEGUI build_dir/lib.

for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
#sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")

== Setting Data Path ==
Set your path to the CEGUI media dir.

CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"

== Mouse/KeyBoard Mappings==

def ConvertMouseButton(button):
##Convert Mouse Buttons to CEGUI
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton

Copy the following keyboard mappings to keymappings_glfw3.py in same directory as the demo.

import sys
import glfw
import PyCEGUI

## our keyboard mappings
KEYMAPPINGS = {
glfw.GLFW_KEY_UNKNOWN : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_SPACE : PyCEGUI.Key.Space,
glfw.GLFW_KEY_APOSTROPHE : PyCEGUI.Key.Apostrophe,
glfw.GLFW_KEY_COMMA : PyCEGUI.Key.Comma,
glfw.GLFW_KEY_MINUS : PyCEGUI.Key.Minus,
glfw.GLFW_KEY_PERIOD : PyCEGUI.Key.Period,
glfw.GLFW_KEY_SLASH : PyCEGUI.Key.Slash,
glfw.GLFW_KEY_0 : PyCEGUI.Key.Zero,
glfw.GLFW_KEY_1 : PyCEGUI.Key.One,
glfw.GLFW_KEY_2 : PyCEGUI.Key.Two,
glfw.GLFW_KEY_3 : PyCEGUI.Key.Three,
glfw.GLFW_KEY_4 : PyCEGUI.Key.Four,
glfw.GLFW_KEY_5 : PyCEGUI.Key.Five,
glfw.GLFW_KEY_6 : PyCEGUI.Key.Six,
glfw.GLFW_KEY_7 : PyCEGUI.Key.Seven,
glfw.GLFW_KEY_8 : PyCEGUI.Key.Eight,
glfw.GLFW_KEY_9 : PyCEGUI.Key.Nine,
glfw.GLFW_KEY_SEMICOLON : PyCEGUI.Key.Semicolon,
glfw.GLFW_KEY_EQUAL : PyCEGUI.Key.Equals,
glfw.GLFW_KEY_A : PyCEGUI.Key.A,
glfw.GLFW_KEY_B : PyCEGUI.Key.B,
glfw.GLFW_KEY_C : PyCEGUI.Key.C,
glfw.GLFW_KEY_D : PyCEGUI.Key.D,
glfw.GLFW_KEY_E : PyCEGUI.Key.E,
glfw.GLFW_KEY_F : PyCEGUI.Key.F,
glfw.GLFW_KEY_G : PyCEGUI.Key.G,
glfw.GLFW_KEY_H : PyCEGUI.Key.H,
glfw.GLFW_KEY_I : PyCEGUI.Key.I,
glfw.GLFW_KEY_J : PyCEGUI.Key.J,
glfw.GLFW_KEY_K : PyCEGUI.Key.K,
glfw.GLFW_KEY_L : PyCEGUI.Key.L,
glfw.GLFW_KEY_M : PyCEGUI.Key.M,
glfw.GLFW_KEY_N : PyCEGUI.Key.N,
glfw.GLFW_KEY_O : PyCEGUI.Key.O,
glfw.GLFW_KEY_P : PyCEGUI.Key.P,
glfw.GLFW_KEY_Q : PyCEGUI.Key.Q,
glfw.GLFW_KEY_R : PyCEGUI.Key.R,
glfw.GLFW_KEY_S : PyCEGUI.Key.S,
glfw.GLFW_KEY_T : PyCEGUI.Key.T,
glfw.GLFW_KEY_U : PyCEGUI.Key.U,
glfw.GLFW_KEY_V : PyCEGUI.Key.V,
glfw.GLFW_KEY_W : PyCEGUI.Key.W,
glfw.GLFW_KEY_X : PyCEGUI.Key.X,
glfw.GLFW_KEY_Y : PyCEGUI.Key.Y,
glfw.GLFW_KEY_Z : PyCEGUI.Key.Z,
glfw.GLFW_KEY_LEFT_BRACKET : PyCEGUI.Key.LeftBracket,
glfw.GLFW_KEY_BACKSLASH : PyCEGUI.Key.Backslash,
glfw.GLFW_KEY_RIGHT_BRACKET : PyCEGUI.Key.RightBracket,
glfw.GLFW_KEY_GRAVE_ACCENT : PyCEGUI.Key.Grave,
glfw.GLFW_KEY_WORLD_1 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_WORLD_2 : PyCEGUI.Key.Unknown,

glfw.GLFW_KEY_ESCAPE : PyCEGUI.Key.Escape,
glfw.GLFW_KEY_ENTER : PyCEGUI.Key.Return,
glfw.GLFW_KEY_TAB : PyCEGUI.Key.Tab,
glfw.GLFW_KEY_BACKSPACE : PyCEGUI.Key.Backspace,
glfw.GLFW_KEY_INSERT : PyCEGUI.Key.Insert,
glfw.GLFW_KEY_DELETE : PyCEGUI.Key.Delete,
glfw.GLFW_KEY_RIGHT : PyCEGUI.Key.ArrowRight,
glfw.GLFW_KEY_LEFT : PyCEGUI.Key.ArrowLeft,
glfw.GLFW_KEY_DOWN : PyCEGUI.Key.ArrowDown,
glfw.GLFW_KEY_UP : PyCEGUI.Key.ArrowUp,
glfw.GLFW_KEY_PAGE_UP : PyCEGUI.Key.PageUp,
glfw.GLFW_KEY_PAGE_DOWN : PyCEGUI.Key.PageDown,
glfw.GLFW_KEY_HOME : PyCEGUI.Key.Home,
glfw.GLFW_KEY_END : PyCEGUI.Key.End,
glfw.GLFW_KEY_CAPS_LOCK : PyCEGUI.Key.Capital,
glfw.GLFW_KEY_SCROLL_LOCK : PyCEGUI.Key.ScrollLock,
glfw.GLFW_KEY_NUM_LOCK : PyCEGUI.Key.NumLock,
glfw.GLFW_KEY_PRINT_SCREEN : PyCEGUI.Key.SysRq,
glfw.GLFW_KEY_PAUSE : PyCEGUI.Key.Pause,
glfw.GLFW_KEY_F1 : PyCEGUI.Key.F1,
glfw.GLFW_KEY_F2 : PyCEGUI.Key.F2,
glfw.GLFW_KEY_F3 : PyCEGUI.Key.F3,
glfw.GLFW_KEY_F4 : PyCEGUI.Key.F4,
glfw.GLFW_KEY_F5 : PyCEGUI.Key.F5,
glfw.GLFW_KEY_F6 : PyCEGUI.Key.F6,
glfw.GLFW_KEY_F7 : PyCEGUI.Key.F7,
glfw.GLFW_KEY_F8 : PyCEGUI.Key.F8,
glfw.GLFW_KEY_F9 : PyCEGUI.Key.F9,
glfw.GLFW_KEY_F10 : PyCEGUI.Key.F10,
glfw.GLFW_KEY_F11 : PyCEGUI.Key.F11,
glfw.GLFW_KEY_F12 : PyCEGUI.Key.F12,
glfw.GLFW_KEY_F13 : PyCEGUI.Key.F13,
glfw.GLFW_KEY_F14 : PyCEGUI.Key.F14,
glfw.GLFW_KEY_F15 : PyCEGUI.Key.F15,
glfw.GLFW_KEY_F16 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F17 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F18 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F19 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F20 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F21 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F22 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F23 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F24 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_F25 : PyCEGUI.Key.Unknown,
glfw.GLFW_KEY_KP_0 : PyCEGUI.Key.Numpad0,
glfw.GLFW_KEY_KP_1 : PyCEGUI.Key.Numpad1,
glfw.GLFW_KEY_KP_2 : PyCEGUI.Key.Numpad2,
glfw.GLFW_KEY_KP_3 : PyCEGUI.Key.Numpad3,
glfw.GLFW_KEY_KP_4 : PyCEGUI.Key.Numpad4,
glfw.GLFW_KEY_KP_5 : PyCEGUI.Key.Numpad5,
glfw.GLFW_KEY_KP_6 : PyCEGUI.Key.Numpad6,
glfw.GLFW_KEY_KP_7 : PyCEGUI.Key.Numpad7,
glfw.GLFW_KEY_KP_8 : PyCEGUI.Key.Numpad8,
glfw.GLFW_KEY_KP_9 : PyCEGUI.Key.Numpad9,
glfw.GLFW_KEY_KP_DECIMAL : PyCEGUI.Key.Decimal,
glfw.GLFW_KEY_KP_DIVIDE : PyCEGUI.Key.Divide,
glfw.GLFW_KEY_KP_MULTIPLY : PyCEGUI.Key.Multiply,
glfw.GLFW_KEY_KP_SUBTRACT : PyCEGUI.Key.Subtract,
glfw.GLFW_KEY_KP_ADD : PyCEGUI.Key.Add,
glfw.GLFW_KEY_KP_ENTER : PyCEGUI.Key.NumpadEnter,
glfw.GLFW_KEY_KP_EQUAL : PyCEGUI.Key.NumpadEquals,
glfw.GLFW_KEY_LEFT_SHIFT : PyCEGUI.Key.LeftShift,
glfw.GLFW_KEY_LEFT_CONTROL : PyCEGUI.Key.LeftControl,
glfw.GLFW_KEY_LEFT_ALT : PyCEGUI.Key.LeftAlt,
glfw.GLFW_KEY_LEFT_SUPER : PyCEGUI.Key.LeftWindows,
glfw.GLFW_KEY_RIGHT_SHIFT : PyCEGUI.Key.RightShift,
glfw.GLFW_KEY_RIGHT_CONTROL : PyCEGUI.Key.RightControl,
glfw.GLFW_KEY_RIGHT_ALT : PyCEGUI.Key.RightAlt,
glfw.GLFW_KEY_RIGHT_SUPER : PyCEGUI.Key.RightWindows,
glfw.GLFW_KEY_MENU : PyCEGUI.Key.AppMenu,
glfw.GLFW_KEY_LAST : PyCEGUI.Key.AppMenu
}

== Initialization glf3==

# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)

== Window Hints==

Glfw3 allows to define window hints prior to creation and hints about your OpenGL Context (OpenGL Version). Note the MAJOR/MINOR values are the minimum API version of the window context, i.e. if you graphics card supports GL 4.4 that is what will be returned.

GLFW_OPENGL_FORWARD_COMPAT (True) indicates that functionality deprecated in the requested version of OpenGL is removed.

For the sake of testing PyCEGUI's OpenGL render set:
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(True) - OpenGL3Renderer without GL2.1
ceguiGL3Renderer(True)/ GLFW_OPENGL_FORWARD_COMPAT(False) - OpenGL3Renderer with GL2.1
ceguiGL3Renderer(False) - OpenGLRenderer

ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)

== Creating Window==
If you try to create a window with a context that you graphics card does not support glfwCreateWindow will fail. We
also need to make our context current prior to creating our PyCEGUI renderer.

glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()

glfw.glfwMakeContextCurrent(glfw_window)

== VSnyc ==
This does nothing on linux and is dependent on your card settings. For example with a NVidia card change settings with NVidia X Server Settings->OpenGL Settings->Sync to VBlank.

glfw.glfwSwapInterval(0)

== Callbacks ==
See the source for each of the following callbacks where we notify CEGUI of display size changes, mouse presses/movement, key presses and glfwSetCharCallback is our callback to pass the unicode char/key pressed to CEGUI.

glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)

== PyCEGUI Renderer ==
Create our PyCEGUI renderer.

if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()

== Main Loop ==
Our main loop runs until the glfw3 window is closed updating CEGUI, swapping the buffers and handling glfw events.

def updateCEGUI(self, elapsed):
##CEGUI updates ###
if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))

while not glfw.glfwWindowShouldClose(self.glfw_window):
PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)
# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time

# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)

# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)

# Handle glfw events
glfw.glfwPollEvents()

== Demo Source ==

This is the full source code for the demo, see above saving the keyboard mappings.

# -- coding: utf-8 --

import glfw
import OpenGL.GL as PyGL
import sys, os , site

## set the path of your PyCEGUI* modules
for _path in [os.path.join(s,'cegui-0.8') for s in site.getsitepackages()]:
print _path
sys.path.insert(0, _path)
sys.path.insert(0, "/media/sdb5/python-ogre-cegui/cegui-0.8/lib")

## set the path to our resource files
CEGUI_PATH = "/media/sdb5/Libraries/OGRE/sdk/v1-9/share/cegui-0/"

## import our PyCEGUI and out glfw3 to cegui key mappings
import PyCEGUI
import PyCEGUIOpenGLRenderer
from keymappings_glfw3 import *

def ConvertMouseButton(button):
''' Convert Mouse Buttons to CEGUI '''
if (button == glfw.GLFW_MOUSE_BUTTON_RIGHT):
return PyCEGUI.RightButton
elif (button == glfw.GLFW_MOUSE_BUTTON_LEFT):
return PyCEGUI.LeftButton
elif (button == glfw.GLFW_MOUSE_BUTTON_MIDDLE):
return PyCEGUI.MiddleButton
else:
return PyCEGUI.LeftButton

class Application(object):
def __init__(self):

# Initialize glfw
if not glfw.glfwInit():
print (" Error : glfw failed to initialize")
sys.exit (glfw.EXIT_FAILURE)

ceguiGL3Renderer = True
if ceguiGL3Renderer:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 3)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 2)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_FORWARD_COMPAT, PyGL.GL_TRUE)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_CORE_PROFILE)
else:
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MAJOR, 2)
glfw.glfwWindowHint(glfw.GLFW_CONTEXT_VERSION_MINOR, 1)
glfw.glfwWindowHint(glfw.GLFW_OPENGL_PROFILE, glfw.GLFW_OPENGL_ANY_PROFILE)

# our window hints
## http://www.glfw.org/docs/latest/window.html
## set our framebuffer related hints
glfw.glfwWindowHint(glfw.GLFW_DEPTH_BITS, 24)
glfw.glfwWindowHint(glfw.GLFW_STENCIL_BITS, 8)

glfw.glfwWindowHint(glfw.GLFW_FOCUSED, True)

fullScreen = False
# create window
if (not fullScreen):
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", None, None)
else:
glfw_window = glfw.glfwCreateWindow(1024, 768, "PyCEGUI glfw3 Demo", glfw.glfwGetPrimaryMonitor(), None)

# check window created
if not glfw_window:
print (" Error : glfw failed to create a window")
glfw.glfwTerminate()
sys.exit()
self.glfw_window = glfw_window

glfw.glfwMakeContextCurrent(glfw_window)

self.showglfwInfo()

## this does nothing on linux
glfw.glfwSwapInterval(0)

glfw.glfwSetInputMode(glfw_window, glfw.GLFW_CURSOR, glfw.GLFW_CURSOR_HIDDEN)

# call backs
glfw.glfwSetKeyCallback( glfw_window, self.on_key)
glfw.glfwSetMouseButtonCallback( glfw_window, self.on_mouse)
glfw.glfwSetCursorPosCallback( glfw_window, self.on_move)
glfw.glfwSetWindowSizeCallback( glfw_window, self.on_resize)
glfw.glfwSetCharCallback( glfw_window, self.on_char_callback)
glfw.glfwSetFramebufferSizeCallback( glfw_window, self.on_framebuffer_size_callback)

# initialise our CEGUI renderer
ctx_major = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)

if (not ceguiGL3Renderer):
PyCEGUIOpenGLRenderer.OpenGLRenderer.bootstrapSystem()
else :
PyCEGUIOpenGLRenderer.OpenGL3Renderer.bootstrapSystem()

# initialise PyCEGUI and resources
rp = PyCEGUI.System.getSingleton().getResourceProvider()

rp.setResourceGroupDirectory("schemes", CEGUI_PATH + "schemes")
rp.setResourceGroupDirectory("imagesets", CEGUI_PATH + "imagesets")
rp.setResourceGroupDirectory("fonts", CEGUI_PATH + "fonts")
rp.setResourceGroupDirectory("layouts", CEGUI_PATH + "layouts")
rp.setResourceGroupDirectory("looknfeels", CEGUI_PATH + "looknfeel")
rp.setResourceGroupDirectory("schemas", CEGUI_PATH + "xml_schemas")

PyCEGUI.ImageManager.setImagesetDefaultResourceGroup("imagesets")
PyCEGUI.Font.setDefaultResourceGroup("fonts")
PyCEGUI.Scheme.setDefaultResourceGroup("schemes")
PyCEGUI.WidgetLookManager.setDefaultResourceGroup("looknfeels")
PyCEGUI.WindowManager.setDefaultResourceGroup("layouts")

parser = PyCEGUI.System.getSingleton().getXMLParser()
if parser.isPropertyPresent("SchemaDefaultResourceGroup"):
parser.setProperty("SchemaDefaultResourceGroup", "schemas")

# Load schemes
PyCEGUI.SchemeManager.getSingleton().createFromFile("TaharezLook.scheme")
PyCEGUI.SchemeManager.getSingleton().createFromFile("WindowsLook.scheme")
PyCEGUI.System.getSingleton().getDefaultGUIContext().getMouseCursor().setDefaultImage("TaharezLook/MouseArrow")

# set root window
root = PyCEGUI.WindowManager.getSingleton().createWindow("DefaultWindow", "background_wnd");
root.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(0.0, 0),PyCEGUI.UDim(0.0, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(1.0, 0),PyCEGUI.UDim(1.0, 0)))
PyCEGUI.System.getSingleton().getDefaultGUIContext().setRootWindow(root)

# load a layout
layout = PyCEGUI.WindowManager.getSingleton().loadLayoutFromFile("TextDemo.layout")
root.addChild(layout.getChild('TextDemo'))
self.edit = root.getChild('TextDemo/MultiLineGroup/editMulti')

# create label for our FPS
self.labelFPS = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Label", "FPSLabel")
root.addChild(self.labelFPS)

# create hello button
button = PyCEGUI.WindowManager.getSingleton().createWindow("TaharezLook/Button", "HelloButton")
button.setArea( PyCEGUI.UVector2(PyCEGUI.UDim(.50, 0),PyCEGUI.UDim(.92, 0)) ,PyCEGUI.USize(PyCEGUI.UDim(0.3, 0),PyCEGUI.UDim(0.05, 0)))
button.setText("Hello")
root.addChild(button)
button.subscribeEvent(PyCEGUI.PushButton.EventClicked, self.OnbuttonClicked)

# init simple timing
self.previous_time = glfw.glfwGetTime()
self.current_time = self.previous_time

def showglfwInfo(self):
ctx_major = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)
ctx_minor = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_CONTEXT_VERSION_MINOR)
forward_compat = glfw.glfwGetWindowAttrib(self.glfw_window, glfw.GLFW_OPENGL_FORWARD_COMPAT)
print "Created Window for OpenGL version %d.%d " % ( ctx_major, ctx_major )
if ( ctx_major >=3 and forward_compat):
print "Context is forward compatible, you can't use OpenGL 2.x commands"
fwidth,fheight = glfw.glfwGetFramebufferSize(self.glfw_window)
width, height = glfw.glfwGetWindowSize(self.glfw_window)

print "Framebuffer size %dx%d Window size %dx%d " % (fwidth,fheight, width,height)

def OnbuttonClicked(self, args):
self.edit.setText(self.edit.getText() + "You Clicked")
return

def cleanUp(self):
''' shutdown glfw and CEGUI '''
PyCEGUIOpenGLRenderer.OpenGLRenderer.destroySystem()
glfw.glfwTerminate()

def updateGL(self):
''' glfw GL updates '''
pass

def updateCEGUI(self, elapsed):
''' CEGUI updates '''
#focused = glfw.glfwGetWindowAttrib(glfw_window, glfw.GLFW_CONTEXT_VERSION_MAJOR)

if (PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().injectTimePulse(elapsed)
PyCEGUI.System.getSingleton().renderAllGUIContexts()
self.labelFPS.setText("FPS : %s" %(str(int(1.0/elapsed))))

def mainLoop(self):
''' Loop until glfw window is closed '''

while not glfw.glfwWindowShouldClose(self.glfw_window):

PyGL.glClear(PyGL.GL_COLOR_BUFFER_BIT)

# update timing
self.current_time = glfw.glfwGetTime()
elapsed = self.current_time - self.previous_time
self.previous_time = self.current_time

# update GL/CEGUI
self.updateGL()
self.updateCEGUI(elapsed)

# Swap front and back buffers
glfw.glfwSwapBuffers(self.glfw_window)

# Handle glfw events
glfw.glfwPollEvents()

def on_framebuffer_size_callback(self,window,width,height):
''' the framebuffer on high-DPI monitors may differ from the screen co-ords, so notify display size change here '''
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))

def on_move(self, window, x,y):
''' pass glfw mouse moves to CEGUI '''
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectMousePosition(x, y)

def on_resize(self, window, width,height):
''' resize glfw viewport and CEGUI display '''
PyGL.glViewport(0, 0, width, height)
if ( PyCEGUI.System.getSingleton()):
PyCEGUI.System.getSingleton().notifyDisplaySizeChanged(PyCEGUI.Sizef(float(width), float(height) ))

def on_mouse(self, window, button, action, mods):
''' pass glfw mouse press events to CEGUI '''
if ( PyCEGUI.System.getSingleton()):
context = PyCEGUI.System.getSingleton().getDefaultGUIContext()
if (action == glfw.GLFW_PRESS):
context.injectMouseButtonDown( ConvertMouseButton(button) )
if (action == glfw.GLFW_RELEASE):
context.injectMouseButtonUp( ConvertMouseButton(button) )

def on_char_callback(self, window, code):
''' Unicode character callback function to CEGUI '''
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectChar(code)

def on_key(self, window, key, scancode, action, mods):
''' pass keypress events to CEGUI '''
if PyCEGUI.System.getSingleton():
cegui_key = KEYMAPPINGS[key]
if (not cegui_key==PyCEGUI.Key.Unknown):
if (action == glfw.GLFW_PRESS):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyDown(PyCEGUI.Key.Scan(cegui_key))
if (action == glfw.GLFW_RELEASE):
PyCEGUI.System.getSingleton().getDefaultGUIContext().injectKeyUp(PyCEGUI.Key.Scan(cegui_key))

## exit
if key == glfw.GLFW_KEY_ESCAPE and action == glfw.GLFW_PRESS:
glfw.glfwSetWindowShouldClose(window,1)
if __name__ == '__main__':
app = Application()
app.mainLoop()
app.cleanUp()
del app

And here is the link for the formatted [http://pastebin.com/d8RyqvSg source]

[[Category:Tutorials]]