| | |
- GLUTInteractiveContext(ViewPlatformMixin, InteractiveContext, GLUTContext)
-
- TestContext(VRMLContext, GLUTInteractiveContext)
- VRMLContext(object)
-
- TestContext(VRMLContext, GLUTInteractiveContext)
class TestContext(VRMLContext, GLUTInteractiveContext) |
| |
VRML97-loading Context testing class
|
| |
- Method resolution order:
- TestContext
- VRMLContext
- GLUTInteractiveContext
- ViewPlatformMixin
- InteractiveContext
- GLUTContext
- EventHandlerMixin
- EventHandlerMixin
- Context
- object
Methods defined here:
- OnInit(self)
- Load the image on initial load of the application
Methods inherited from VRMLContext:
- load(self, filename)
- Load given url, replacing current scenegraph
- setupFontProviders(self)
- Load font providers for the context
See the OpenGLContext.scenegraph.text package for the
available font providers.
Data descriptors inherited from VRMLContext:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
Data and other attributes inherited from VRMLContext:
- USE_FRUSTUM_CULLING = 1
- USE_OCCLUSION_CULLING = 0
- initialPosition = (0, 0, 10)
- sg = None
Methods inherited from ViewPlatformMixin:
- ViewPort(self, width, height)
- Set the size of the OpenGL rendering viewport for the context
Because the ViewPlatform provide support for
"constant aspect ratio" in scenes, it is necessary
to keep the ViewPlatform updated regarding the current
aspect ratio of the ViewPort. This implementation
merely calls the platform's setViewport, then
calls the super-class ViewPort method.
XXX
Unfortunately, because Context objects may be
old-style classes, we can't use super(), so
this implementation actually calls
context.Context.ViewPort directly.
- getViewPlatform(self)
- Customization Point: Instantiate ViewPlatform for this context
The default implementation is to instantiate a
viewplatform.ViewPlatform with position equal to
self.initialPosition and orientation equal to
self.initialOrientation.
See:
OpenGLContext.shadow.shadowcontext for
example where this method is overridden
- setMovementManager(self, manager)
- Set our current movement manager
- setupDefaultEventCallbacks(self)
- Customization point: Setup application default callbacks
This method binds a large number of callbacks which support
the OpenGLContext default camera-manipulation modes. In
particular:
* unmodified arrow keys for x,z (in camera coordinate
space) movement
* Alt+arrow keys for x,y (in camera coordinate space)
movement
* Ctrl+up/down arrow keys for rotating the head backward/
forward
* Mouse-button-2 (right) for entering "examine" mode
* '-' for straightening the view platform
Data and other attributes inherited from ViewPlatformMixin:
- initialOrientation = (0, 1, 0, 0)
- movementManager = None
- platform = None
- slider = None
Data and other attributes inherited from InteractiveContext:
- EventManagerClasses = [('keyboard', <class 'OpenGLContext.events.keyboardevents.KeyboardEventManager'>), ('keypress', <class 'OpenGLContext.events.keyboardevents.KeypressEventManager'>), ('mousebutton', <class 'OpenGLContext.events.mouseevents.MouseButtonEventManager'>), ('mousemove', <class 'OpenGLContext.events.mouseevents.MouseMoveEventManager'>), ('mousein', <class 'OpenGLContext.events.mouseevents.MouseInEventManager'>), ('mouseout', <class 'OpenGLContext.events.mouseevents.MouseOutEventManager'>)]
- TimeManagerClass = <class 'OpenGLContext.events.timeeventgeneratormanager.TimeEventGeneratorManager'>
- TimeEventGenerator EventManager object
This object conforms to the EventManager interface,
although it doesn't actually inherit from that class.
It provides support for the InternalTime generators
on which the Timer object is based.
Methods inherited from GLUTContext:
- OnRedisplay(self)
- windowing library has asked us to redisplay
- OnResize(self, width, height)
- Windowing library has resized the window
- SwapBuffers(self)
- Implementation: swap the buffers
- __init__(self, definition=None, **named)
- setCurrent(self)
- Acquire the GL "focus"
- setupCallbacks(self)
- Setup the various callbacks for this context
Class methods inherited from GLUTContext:
- ContextMainLoop(cls, *args, **named) from type
- Mainloop for the GLUT testing context
- glutFlagsFromDefinition(cls, definition) from type
- Create our initialisation flags from a definition
Data and other attributes inherited from GLUTContext:
- CONTEXT_DEFINITION_FLAG_MAPPING = (('doubleBuffer', GLUT_DOUBLE, GLUT_SINGLE, GLUT_DOUBLE), ('depthBuffer', GLUT_DEPTH, 0, GLUT_DEPTH), ('accumulationBuffer', GLUT_ACCUM, 0, GLUT_ACCUM), ('stencilBuffer', GLUT_STENCIL, 0, GLUT_STENCIL), ('rgb', GLUT_RGB, GLUT_INDEX, GLUT_RGB), ('multisampleBuffer', GLUT_MULTISAMPLE, 0, 0), ('multisampleSamples', GLUT_MULTISAMPLE, 0, 0), ('stereo', GLUT_STEREO, 0, 0))
- DISPLAYMODE = 18
- currentModifiers = 0
Methods inherited from EventHandlerMixin:
- glutOnCharacter(self, character, x, y)
- Convert character (non-control) press to context event
- glutOnKeyDown(self, character, x, y)
- Convert a key-press to a context-style event
- glutOnKeyUp(self, character, x, y)
- Convert a key-release to a context-style event
- glutOnMouseButton(self, button, state, x, y)
- Convert mouse-press-or-release to a Context-style event
- glutOnMouseMove(self, x, y)
- Convert mouse-movement 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)
- Get the time-event manager for this context
- 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.
Methods inherited from 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 and calls the glutInit()
function with an empty argument-list.
- 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: passes sub-package
See: visitor.py, rendervisitor.py, renderpass.py,
shadow/passes.py for examples of render-pass-sets
which can be triggered.
See: flat.py for standard second-generation renderer
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()
- OnFrameRate(self, event=None)
- Print the current frame-rate values
- OnIdle(self, *arguments)
- Override to perform actions when the rendering loop is idle
- OnNextViewpoint(self, event=None)
- Go to the next viewpoint for the scenegraph
- OnQuit(self, event=None)
- Quit the application (forcibly)
- OnSaveImage(self, event=None, template='%(script)s-screen-%(count)04i.png', script=None, date=None, overwrite=False)
- Save our current screen to disk (if possible)
- 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.
- 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)
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' )
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
- setupCache(self)
- Setup caching strutures for content
This includes the general compiled-geometry caches
and the texture cache
- setupExtensionManager(self)
- Create an extension manager for this context
- setupFrameRateCounter(self)
- Setup structures for managing frame-rate
This sets self.frameCounter to an instance of
framecounter.FrameCounter, which is a simple node
used to track frame-rate metadata during rendering.
Updates to the framecounter are performed by OnDraw
iff there is a visible change processed.
Note:
If you override this method, you need to either use
an object which has the same API as a FrameCounter or
use None, anything else will cause failures in the
core rendering loop!
- 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 type
- Retrieve the application name for configuration purposes
- getContextType(cls, entrypoint=None, type=<class 'OpenGLContext.plugins.InteractiveContext'>) from type
- Load a single context type via entry-point resolution
returns a Context sub-class *or* None if there is no such
context defined/available, will have a ContextMainLoop method
for running the Context top-level loop.
- getContextTypes(cls, type=<class 'OpenGLContext.plugins.InteractiveContext'>) from type
- Retrieve the set of defined context types
type -- testing type key from setup.py for the registered modules
returns list of setuptools entry-point objects which can be passed to
getContextType( name ) to retrieve the actual context type.
- getDefaultContextType(cls) from type
- Get the current user's preference for a default context type
- getDefaultTTFFont(cls, type='sans') from type
- Get the current user's preference for a default font
- getUserAppDataDirectory(cls) from type
- Retrieve user-specific configuration directory
Default implementation gives a directory-name in the
user's (system-specific) "application data" directory
named
- setDefaultContextType(cls, name) from type
- Set the current user's preference for a default font
- setDefaultTTFFont(cls, name, type='sans') from type
- Set the current user's preference for a default font
Static methods inherited from Context:
- fromConfig(cfg)
- Given a ConfigParser instance, produce a configured sub-class
Data and other attributes inherited from Context:
- APPLICATION_NAME = 'OpenGLContext'
- DEF = '#Context'
- PROTO = 'Context'
- allContexts = []
- alreadyDrawn = None
- contextDefinition = None
- currentContext = None
- drawPollTimeout = 0.01
- drawing = None
- frameCounter = None
- renderPasses = <OpenGLContext.passes.renderpass._defaultRenderPasses object>
- ttfFileRegistry = None
- viewportDimensions = (0, 0)
| |