Crond: /* Requirements */ superfluous

2011-06-20T15:50:58Z

‎Requirements: superfluous

Crond: /* Source */ pep8

2011-06-18T20:51:08Z

‎Source: pep8

Show changes

Crond: ord

2011-06-18T20:19:32Z

ord

Crond: /* Introduction */

2011-06-18T20:14:55Z

‎Introduction

Crond: Created page with "{{VersionBadge|0.7}} {{VersionAtLeast|0.7.5}}

== Introduction == This is a simple modification of the basic OpenGL application, as found [User:Crond/san..."

2011-06-18T20:14:35Z

Created page with "{{VersionBadge|0.7}} {{VersionAtLeast|0.7.5}} == Introduction == This is a simple modification of the basic OpenGL application, as found [User:Crond/san..."

New page

{{VersionBadge|0.7}} {{VersionAtLeast|0.7.5}}
 

== Introduction ==
This is a simple modification of the basic OpenGL application, as found [User:Crond/sandbox/openglExample|here]. The goal is to present the basics of keyboard processing, via OpenGL and PyCEGUI.

== Requirements ==
* Python 2.6 (untested on Python 3.+)
* PyCEGUI
* PyOpenGL (GLU and GLUT, as well)

== Notes ==
This example assumes you have the CEGUI resources located in the same directory as the script; change `PATH_RESOURCES` if they are elsewhere.

== Source ==
<source lang="python">
#!/usr/bin/env python
#
#
# example.py

# Import: std
import sys, os

# Import: PyOpenGL
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *

# Import: PyCEGUI
import PyCEGUI
from PyCEGUIOpenGLRenderer import OpenGLRenderer as Renderer

# Constants
PATH_RESOURCES = './'

# Application
class Application(object):

# Constructor
def __init__(self):
super(Application, self).__init__()
self.lastFrameTime = 0
self.updateFPS = 0
return

# Initialize: OpenGL
# - A full list of values for `glutInitDisplayMode` can be found in the GLUT
# documentation.
def initializeOpenGL(self):
glutInit()
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA)
glutInitWindowSize(1024, 768)
glutInitWindowPosition(-1, -1) # Let the windowing system figure it out
glutCreateWindow("Crazy Eddie's GUI Mk-2 - glut Base Application")
glutSetCursor(GLUT_CURSOR_NONE)
return

# Initialize: Handlers
# - Setup the methods which will be called when events happen.
def initializeHandlers(self):
glutDisplayFunc(self.handlerDisplay)
glutReshapeFunc(self.handlerResize)
glutKeyboardFunc(self.handlerKeyboard)
glutMouseFunc(self.handlerMouse)
glutMotionFunc(self.handlerMouseMotion)
glutPassiveMotionFunc(self.handlerMouseMotion)
return

# Initialize: PyCEGUI
# - Store some components; saves a lot of typing.
def initializePyCEGUI(self):
Renderer.bootstrapSystem()
self.sys = PyCEGUI.System.getSingleton()
self.rp = self.sys.getResourceProvider()
self.scheme = PyCEGUI.SchemeManager.getSingleton()
self.wm = PyCEGUI.WindowManager.getSingleton()
return

# Initialize: Defaults
# - Resource locations.
def initializeDefaults(self):
self.rp.setResourceGroupDirectory('schemes', os.path.join(PATH_RESOURCES, 'datafiles/schemes'))
self.rp.setResourceGroupDirectory('imagesets', os.path.join(PATH_RESOURCES, 'datafiles/imagesets'))
self.rp.setResourceGroupDirectory('fonts', os.path.join(PATH_RESOURCES, 'datafiles/fonts'))
self.rp.setResourceGroupDirectory('layouts', os.path.join(PATH_RESOURCES, 'datafiles/layouts'))
self.rp.setResourceGroupDirectory('looknfeels', os.path.join(PATH_RESOURCES, 'datafiles/looknfeel'))
self.rp.setResourceGroupDirectory('schemas', os.path.join(PATH_RESOURCES, 'datafiles/xml_schemas'))
PyCEGUI.Imageset.setDefaultResourceGroup('imagesets')
PyCEGUI.Font.setDefaultResourceGroup('fonts')
PyCEGUI.Scheme.setDefaultResourceGroup('schemes')
PyCEGUI.WidgetLookManager.setDefaultResourceGroup('looknfeels')
PyCEGUI.WindowManager.setDefaultResourceGroup('layouts')
parser = self.sys.getXMLParser()
if parser.isPropertyPresent('SchemaDefaultResourceGroup'):
parser.setProperty('SchemaDefaultResourceGroup', 'schemas')
return

# Initialize: GUI
# - This is where we are actually setting up the windows we will see.
def initializeGUI(self):
self.scheme.create('VanillaSkin.scheme')
self.scheme.create('TaharezLook.scheme')

# GUISheet
self.rootWindow = self.wm.loadWindowLayout('VanillaWindows.layout')
self.sys.setGUISheet(self.rootWindow)

# Cursor
self.sys.setDefaultMouseCursor('Vanilla-Images', 'MouseArrow')

# An extra window
w = self.wm.createWindow('TaharezLook/FrameWindow', 'Demo window')
self.rootWindow.addChildWindow(w)
return

# Initialize
def Initialize(self):
self.initializeOpenGL()
self.initializeHandlers()
self.initializePyCEGUI()
self.initializeDefaults()
self.initializeGUI()
return

# Handler: Display
def handlerDisplay(self):

# Injecting the time allows CEGUI to know how much time has passed, and
# use that to coordinate certain activities - fading, animation, tooltips,
# etc.
now = glutGet(GLUT_ELAPSED_TIME)
elapsed = (now - self.lastFrameTime) / 1000.0
self.lastFrameTime = now
self.updateFPS = self.updateFPS - elapsed
self.sys.injectTimePulse(elapsed)

# Actual rendering
# - `renderGUI` updates CEGUI's picture of the GUI.
# - `glutPostRedisplay` is what actually marks the window as needing to
# be redrawn by OpenGL.
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
self.sys.renderGUI()
glutPostRedisplay()
glutSwapBuffers()
return

# Handler: Resize
# - `glViewport` modifies the OpenGL viewport to whatever the window size is.
def handlerResize(self, width, height):
glViewport(0, 0, width, height)
self.sys.notifyDisplaySizeChanged(PyCEGUI.Size(width, height))
return

# Handler: Keyboard
def handlerKeyboard(self, key, x, y):
self.sys.injectChar(ord(key))
return

# Handler: Mouse buttons
def handlerMouse(self, button, state, x, y):
if button == GLUT_LEFT_BUTTON:
if state == GLUT_UP:
self.sys.injectMouseButtonUp(PyCEGUI.LeftButton)
else:
self.sys.injectMouseButtonDown(PyCEGUI.LeftButton)
elif button == GLUT_RIGHT_BUTTON:
if state == GLUT_UP:
self.sys.injectMouseButtonUp(PyCEGUI.RightButton)
else:
self.sys.injectMouseButtonDown(PyCEGUI.RightButton)
return

# Handler: Mouse motion
def handlerMouseMotion(self, x, y):
self.sys.injectMousePosition(x, y)
return

# Run
def Run(self):
self.lastFrameTime = glutGet(GLUT_ELAPSED_TIME)
glutMainLoop()
return

# Main
def main():
app = Application()
app.Initialize()
app.Run()
return 0

# Guard
if __name__ == '__main__':
sys.exit(main())
</source>

== Demonstration ==
We can see that this works by running the application, and typing into the Editbox, as provided by the 'New Node' frame window.

← Older revision		Revision as of 20:19, 18 June 2011
Line 200:		Line 200:
	== Demonstration ==		== Demonstration ==
	We can see that this works by running the application, and typing into the Editbox, as provided by the 'New Node' frame window.		We can see that this works by running the application, and typing into the Editbox, as provided by the 'New Node' frame window.
		+
		+	== Examination ==
		+	=== 'ord' function ===
		+	The 'ord' function is a built-in Python function, which converts a single character (or a string of length one, if you prefer) to its Unicode/ASCII value; for further details, see the Python documentation [http://docs.python.org/release/2.6.5/library/functions.html#ord here].

@@ Line 6: / Line 6: @@
 == Requirements ==
-* Python 2.6 (untested on Python 3.+)
+* Python 2.6
 * PyCEGUI
-* PyOpenGL (GLU and GLUT, as well)
+* PyOpenGL
 == Notes ==

@@ Line 3: / Line 3: @@
 == Introduction ==
-This is a simple modification of the basic OpenGL application, as found [User:Crond/sandbox/openglExample|here]. The goal is to present the basics of keyboard processing, via OpenGL and PyCEGUI.
+This is a simple modification of the basic OpenGL application, as found [[User:Crond/sandbox/openglExample|here]]. The goal is to present the basics of keyboard processing, via OpenGL and PyCEGUI.
 == Requirements ==

User:Crond/sandbox/openglKeyboardExample - Revision history

Crond: /* Requirements */ superfluous

Crond: /* Source */ pep8

Crond: ord

Crond: /* Introduction */

Crond: Created page with "{{VersionBadge|0.7}} {{VersionAtLeast|0.7.5}} == Introduction == This is a simple modification of the basic OpenGL application, as found [User:Crond/san..."

Crond: Created page with "{{VersionBadge|0.7}} {{VersionAtLeast|0.7.5}}

== Introduction == This is a simple modification of the basic OpenGL application, as found [User:Crond/san..."