| | |
- Context
-
- PygameContext(EventHandlerMixin, Context)
- EventHandlerMixin(EventHandlerMixin)
-
- PygameContext(EventHandlerMixin, Context)
class PygameContext(EventHandlerMixin, Context) |
| |
Context sub-class providing basic API support under PyGame
Unlike most of the windowing APIs, PyGame requires you to write
an explicit event handler loop, we provide a default loop method
called MainLoop.
|
| |
- Method resolution order:
- PygameContext
- EventHandlerMixin
- EventHandlerMixin
- Context
Methods defined here:
- CallVirtual(self, name, *args, **namedarguments)
- Call a potentially undefined method
- MainLoop(self)
- Run indefinitely until program is quit
- PygameQuit(self, event)
- Return a value indicating that the MainLoop should exit
- PygameVideoResize(self, event)
- Handle the resize of the window
- SwapBuffers(self)
- flip opengl doublebuffers
- __init__(self, title=None, size=(300, 300))
Data and non-method functions defined here:
- __doc__ = 'Context sub-class providing basic API support un...provide a default loop method\n\tcalled MainLoop.\n\t'
- __module__ = 'OpenGLContext.pygamecontext'
Methods inherited from EventHandlerMixin:
- PygameKeyDown(self, event)
- Convert a key-press to a context-style event
- PygameKeyUp(self, event)
- Convert a key-release to a context-style event
- PygameMouseButtonDown(self, event)
- Convert a mouse-button-press to a context-style event
- PygameMouseButtonUp(self, event)
- Convert a mouse-button-release to a context-style event
- PygameMouseMotion(self, event)
- Convert a mouse-button-move to a context-style event
Methods inherited from EventHandlerMixin:
- DoEventCascade(self)
- Do pre-rendering event cascade
Returns the total number of events generated by
timesensors and/or processed from the event cascade queue
- ProcessEvent(self, event)
- Primary dispatch point for events.
ProcessEvent uses the event's type attribute to determine the
appropriate manager for processing, then dispatches to that manager's
ProcessEvent method.
- addEventHandler(self, eventType, *arguments, **namedarguments)
- Add a new event handler function for the given event type
This is the primary client API for dealing with the event system.
Each event class will define a particular set of data values
required to form the routing key for the event. Each event handler
class will define a registerCallback function which converts
its arguments into a matching key.
This function merely determines the appropriate handler then
dispatches to the handler's registerCallback method (without the
eventType argument).
See: mouseevents, keyboardevents
- addEventManager(self, eventType, manager=None)
- Add an event manager to the internal table of managers.
The return value is the previous manager or None if there was
no previous manager.
- captureEvents(self, eventType, manager=None)
- Temporarily capture events of a particular type.
This temporarily replaces a particular manager within the
dispatch set with provided manager. This will normally be
used to create "modal" interfaces such as active drag
functions (where the interface is in a different "interaction
mode", so that actions have different meaning than in the
"default mode").
Passing None as the manager will restore the previous manager
to functioning.
Note: this function does not perform a "system capture"
of input (that is, mouse movements are only available if they
occur over the context's window and that window has focus).
Note: for capturing mouse input, you will likely want to
capture both movement and button events, it should be possible
to define a single handler to deal with both event types,
and pass that handler twice, once for each event type.
- getEventManager(self, eventType)
- Retrieve an event manager from the internal table of managers
Returns the appropriate manager, or None if there was no
manager registered for the given event type.
- getTimeManager(self)
- initializeEventManagers(self)
- Initialize the event manager classes for this context.
This implementation iterates over self.EventManagerClasses
(a list of (eventType, managerClass) values) and calls
addEventManager for each item.
Data and non-method functions inherited from EventHandlerMixin:
- EventManagerClasses = []
- TimeManagerClass = None
Methods inherited from Context:
- Background(self, mode=None)
- Customization point for clearing/drawing the background.
The default implementation clears the color and depth
buffers, using solid white for the clear color.
Note: This method is only called if there is no scene graph,
and if there is no SetupBindables( mode ) method
available on the Context.
- DoInit(self)
- Call the OnInit method at a time when the context is valid
This method provides a customization point where
contexts which do not completely initialize during
their __init__ method can arrange to have the OnInit
method processed after their initialization has
completed. The default implementation here simply
calls OnInit directly w/ appropriate setCurrent
and unsetCurrent calls.
Note:
The only context currently known to require
this customization is the wxPython-on-GTK context,
everything else completes context initialization
before calling Context.__init__.
- Lights(self, mode=None)
- Customization point for setting up global illumination parameters
Depending on the mode, should either enable or disable
lighting for all of those lights in the scene.
The default implementation enables lighting and light 0
if render mode is not select, disables them otherwise.
Note: This method is only called if there is no scene graph,
and if there is no SetupBindables( mode ) method
available on the Context.
- OnDraw(self, force=1, *arguments)
- Callback for the rendering/drawing mechanism
force -- if true, force a redraw. If false, then only
do a redraw if the event cascade has generated events.
return value is whether a visible change occured
This implementation does the following:
* calls lockScenegraph()
o calls DoEventCascade()
* calls unlockScenegraph()
* calls setCurrent()
* calls renderPasses( self )
See: visitor.py, rendervisitor.py, renderpass.py,
shadow/passes.py for examples of render-pass-sets
which can be triggered.
The RenderPasses define the core of the rendering
mechanism. The default rendering passes will defer
most rendering options to the scenegraph returned by
getSceneGraph(). If that value is None (default)
then the pass will use the Context's callbacks.
You can define new RenderPasses to replace the
rendering algorithm, override the Context's various
callbacks to write raw OpenGL code, or work by
customizing the scene graph library.
* if there was a visible change (which is the return value
from the render-pass-set), calls SwapBuffers()
* calls unsetCurrent()
- OnIdle(self, *arguments)
- Override to perform actions when the rendering loop is idle
- OnInit(self)
- Customization point for scene set up and initial processing
You override this method to do housekeeping chores such as
loading images and generating textures, loading pre-established
geometry, spawning new threads, etc.
This method is called after the completion of the Context.__init__
method for the rendering context. GUI implementers:
Wherever possible, this should be the very last function
called in the initialization of the context to allow user
code to use all the functionality of the context.
- OnResize(self, *arguments)
- Resize the window when the windowing library says to
- Render(self, mode=None)
- Customization point for geometry rendering
This method is called by the default render passes to
render the geometry for the system. Wherever possible,
you should pay attention to the rendering modes to allow
for optimization of your geometry (for instance,
selection passes do not require lighting).
The default implementation merely ensures that matrix mode
is currently model view.
See: visitor.py, rendervisitor.py, renderpass.py,
shadow/passes.py for definitions of the properties of the
mode.
- ViewPort(self, width, height)
- Set the size of the OpenGL rendering viewport for the context
This implementation assumes that the context takes up the entire
underlying window (i.e. that it starts at 0,0 and that width, height
will represent the entire size of the window).
- Viewpoint(self, mode=None)
- Customization point for setting up the projection matrix
The default implementation calls glFrustrum with fairly
generic values to establish a camera similar to a 35mm.
Note: Most real-world contexts use a ViewPlatformMixin
sub-class of Context, which uses a ViewPlatform object to
manage the viewpoint set up, so the default implementation
is seldom used.
Note: This method is currently called by just about every
rendering pass set regardless of whether there is a scene
graph (the scene graph rendering code doesn't yet have
camera support, so it simply calls this method). However,
if you define a SetupBindables( mode ) method on your
Context this customization point will not be called.
Eventually the scene graph may grow its own camera handling
code, at which point it will probably stop calling this
customization point.
- addPickEvent(self, event)
- Add event to list of events to be processed by selection-render-mode
This is a method of the Context, rather than the
rendering pass (which might seem more elegant given
that it is the rendering pass which deals with the
events being registered) because the requests to
render a pick event occur outside of the rendering
loop. As a result, there is (almost) never an
active context when the pick-event-request comes in.
- drawPoll(self, timeout=None)
- Wait timeout seconds for a redraw request
timeout -- timeout in seconds, if None, use
self.drawPollTimeout
returns 0 if timeout, 1 if true
- getPickEvents(self)
- Get the currently active pick-events
- getSceneGraph(self)
- Get the scene graph for the context (or None)
Overriding this method is the primary customization
point for those wishing to use the scene graph APIs
of OpenGLContext. You must return an instance of:
OpenGLContext.scenegraph.scenegraph.SceneGraph
Normally you would create that using either a loader
from OpenGLContext.loader:
from OpenGLContext.loader import vrml97
def OnInit( self ):
self.sg = vrml97.load( 'c:\somefile\world.wrl' )
def getSceneGraph( self ):
return self.sg
or by using the classes in OpenGLContext.scenegraph.basenodes:
from OpenGLContext.scenegraph import basenodes
def OnInit( self ):
self.sg = basenodes.sceneGraph(
children = [
basenodes.Transform(...)
],
)
to define the scenegraph in Python code.
- getTTFFiles(self)
- Get TrueType font-file registry object
- getViewPort(self)
- Method to retrieve the current dimensions of the context
Return value is a width, height tuple. See Context.ViewPort
for setting of this value.
- lockScenegraph(self, blocking=1)
- Lock scenegraph locks to prevent other update/rendering actions
Potentially this could be called from a thread other than the
GUI thread, allowing the other thread to update structures in
the scenegraph without mucking up any active rendering pass.
- renderedChildren(self, types=None)
- Get the rendered children of the scenegraph
- setCurrent(self, blocking=1)
- Set the OpenGL focus to this context
- setupCache(self)
- Setup caching strutures for content
This includes the general compiled-geometry caches
and the texture cache
- setupCallbacks(self)
- Establishes GUI callbacks for asynchronous event GUI systems
Subclasses and applications will register events
here for those event types in which they are interested.
Most minor applications should use interactivecontext's
abstract callbacks (which translate the GUI library's
native events into a common event framework for all
interactivecontexts).
The default implementation does nothing.
- setupDefaultEventCallbacks(self)
- Setup common callbacks for the context
This will normally be done in the GUI-lib's sub-class of
context. You might override it to provide other default
callbacks, but you'll normally want to call the base-class
implementation somewhere in that overridden method.
- setupExtensionManager(self)
- Create an extension manager for this context
- setupFontProviders(self)
- Load font providers for the context
See the OpenGLContext.scenegraph.text package for the
available font providers.
- setupRedrawRequest(self)
- Setup the redraw-request (threading) event
- setupScenegraphLock(self)
- Setup lock to protect scenegraph from updates during rendering
- setupThreading(self)
- Setup primitives (locks, events) for threading
- shouldRedraw(self)
- Return whether or not the context contents need to be redrawn
- suppressRedraw(self)
- Indicate to the context that there is no need to re-render
This method signals to the context that there are no updates
currently requiring redrawing of the context's contents.
See:
Context.shouldRedraw and Context.triggerRedraw
- triggerPick(self)
- Trigger a selection rendering pass
If the context is not currently drawing, the selection render will
occur immediately, otherwise it will occur the next time the
rendering loop reaches the selection stage.
- triggerRedraw(self, force=0)
- Indicate to the context that it should redraw when possible
If force is true, the rendering will begin immediately if the
context is not already drawing. Otherwise only the indicator flag
will be set.
- unlockScenegraph(self)
- Unlock scenegraph locks to allow other update/rendering actions
Potentially this could be called from a thread other than the
GUI thread, allowing the other thread to update structures in
the scenegraph without mucking up any active rendering pass.
- unsetCurrent(self)
- Give up the OpenGL focus from this context
Class methods inherited from Context:
- getApplicationName(cls) from __builtin__.class
- Retrieve the application name for configuration purposes
- getUserAppDataDirectory(cls) from __builtin__.class
- Retrieve user-specific configuration directory
Default implementation gives a directory-name in the
user's (system-specific) "application data" directory
named
Data and non-method functions inherited from Context:
- APPLICATION_NAME = 'OpenGLContext'
- DEF = '#Context'
- PROTO = 'Context'
- allContexts = []
- alreadyDrawn = None
- currentContext = None
- drawPollTimeout = 0.01
- drawing = None
- renderPasses = [<class 'OpenGLContext.renderpass.OpaqueRenderPa...ass 'OpenGLContext.renderpass.SelectRenderPass'>]
- Callable list of sub-passes with associated OverallPass
The PassSet is called once per render-cycle,
and is responsible for creating the OverallPass
which does the actual rendering. It simply
creates the OverallPass with the given sub-passes
and calls the OverallPass, returning the result.
- ttfFileRegistry = None
- viewportDimensions = (0, 0)
| |