OpenGLContext.rendervisitor
index
p:\openglcontext\rendervisitor.py

Basic Rendering code implemented as a Visitor class
 
The RenderVisitor class provides a basic implementation
of rendering a Context/scenegraph via a Visitor pattern.
It provides support for setting up lights, backgrounds,
viewpoints, transforms, and selection-names.  (Those last
two are only applicable to scenegraph-based applications).
 
A few helper classes provide post-node-traversal
resetting mechanisms.

 
Modules
            
Numeric
OpenGLContext.doinchildmatrix
OpenGLContext.frustum
math
vrml.node
OpenGLContext.scenegraph.nodepath
vrml.vrml97.nodetypes
sys
traceback
types
OpenGLContext.visitor
 
Classes
            
Visitor(object)
RenderVisitor
object
GroupPopToken
TransformOverflowToken
_TransformPopToken
 
class GroupPopToken(object)
      Pop name off name-stack and restore selection-mode-state
 
This is part of the visitor API used by the Grouping method
it restores the name stack after a Grouping node's children
are finished being visited.
 
   Methods defined here:
__call__(self, mode=None)
__init__(self, selectForced=0)

Data and non-method functions defined here:
__dict__ = <dict-proxy object at 0x072AF838>
__doc__ = "Pop name off name-stack and restore selection-mo...ng node's children\n\tare finished being visited.\n\t"
__module__ = 'OpenGLContext.rendervisitor'
__weakref__ = <member '__weakref__' of 'GroupPopToken' objects>

Methods inherited from object:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__hash__(...)
x.__hash__() <==> hash(x)
__reduce__(...)
helper for pickle
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__str__(...)
x.__str__() <==> str(x)

Data and non-method functions inherited from object:
__class__ = <type 'type'>
__new__ = <built-in method __new__ of type object at 0x1E0BD978>
T.__new__(S, ...) -> a new object with type S, a subtype of T
 
class RenderVisitor(Visitor)
      OpenGL Rendering visitor/traversal object for scenegraphs
 
This class does the "normal" setup and rendering for
"normal" scenegraph nodes, Context(s) and SceneGraph(s)
themselves.  It is the base class of most RenderPass
objects (with the notable exception of Transparent
rendering passes (which do no traversal at the moment)).
 
  
Method resolution order:
RenderVisitor
Visitor
object

Methods defined here:
Context(self, node)
Render the Context object
 
calls:
        ContextRenderSetup(node)
        ContextSetupDisplay(node)
        ContextSetupBindables(node)
ContextRenderSetup(self, node)
Set up the context for rendering prior to scene rendering
 
This method runs even when there is a scenegraph
 
It sets the rendering mode to GL_RENDER, and loads
identity matrices for the projection and model
view matrices.
ContextSetupBindables(self, node)
Set up the bindable objects (viewpoints, backgrounds, lights)
 
If the Context object has a non-null scenegraph, as
returned by getSceneGraph(), then this method will
do nothing, as the scenegraph will be responsible for
setting up the bindable nodes.
 
If the Context does not have the scenegraph, then we
look for a Context.SetupBindables method, and call
that with context.SetupBindables(self)
 
If the Context does not have a SetupBindables method
or a scenegraph, we call:
        context.Viewpoint ( self )
        context.Background( self )
        context.Lights ( self )
ContextSetupDisplay(self, node)
Establishes rendering parameters for context's rendering pass
 
This method runs even when there is a scenegraph
 
(Re-)establishes common rendering parameters which
may have been left in unexpected states.  If the Context
object has a SetupDisplay method, we call that.  Otherwise
we enable depth testing, set the depth test to GL_LESS,
enable face-culling, and set face-culling to cull back-faces.
Grouping(self, node)
Render a grouping node, return a finalisation token
 
Grouping notes are primarily of interest during selection
rendering passes, where they push and pop names on the
OpenGL name stack.  There are a number of selection-specific
attributes on the RenderPass object which determine whether
or not an individual Grouping node's name is pushed onto
the stack.
 
Grouping nodes also keep track of their individual
"sensitivity" (by monitoring whether or not they have a
mouse-sensor child).  Sensitive Grouping nodes alter the
RenderPass's selection-specific attributes to manipulate
their children's selection-mode rendering.
Rendering(self, node)
Render a rendering node (Shape)
 
At the moment, this just calls node.Render( self )
SceneGraph(self, node)
Render a scenegraph object (SetupBindables)
 
This method is only called if the Context returns
a non-null value from getSceneGraph(), as it only
is called when a Scenegraph instance is encountered.
 
If a Scenegraph is active, we do not use the code in
ContextSetupBindables, so the Scenegraph is responsible
for setting up all of the bindable nodes it wishes
to have rendered.
 
calls:
        SceneGraphCamera(node)
        SceneGraphLights(node)
        SceneGraphBackground(node)
SceneGraphBackground(self, node)
Render background for a scenegraph
 
The background paths found by the OverallPass are used to
transform the individual background objects to their appropriate
positions in the scene. In general, only the rotation
of the path will affect a background node, as they are
rendered around the viewpoint, rather than around a
particular object-space position.
 
This method relies on the pre-scanning pass implemented
by the renderpass.OverallPass object.  That is not
a particularly desirable dependency, but eliminating it
will likely be quite messy.
SceneGraphCamera(self, node)
Setup the camera/viewpoint from the scenegraph
 
XXX
        At the moment, there is no Viewpoint support in
        OpenGLContext, so this method merely calls the
        Context's Viewpoint method.
SceneGraphDefaultlight(self, lightID)
Create the default headlight
 
VRML browsers generally have a default lighting scheme
where, if there are no lights in the scene, a headlight
is created pointing from the viewpoint forward into the scene.
 
The light paths found by the OverallPass are used to
transform the individual light objects to their appropriate
positions in the scene.
 
XXX
        This code is not quite right, instead of creating
        a headlight, it is just creating a simple light pointing
        forward from 0,0,10.  What we want is a light that always
        points forward from the current viewpoint in the current
        view direction.
SceneGraphLights(self, node)
Render lights for a scenegraph
 
The default implementation limits you to eight active
lights, despite the fact that many OpenGL renderers
support more than this.  There have been problems with
support for calculating light IDs beyond eight, so I
have limited the set for now.
 
This method relies on the pre-scanning pass implemented
by the renderpass.OverallPass object.  That is not
a particularly desirable dependency, but eliminating it
will likely be quite messy.
Transform(self, node)
Render a transform object, return a finalisation token
 
This method attempts to catch model-view matrix overflows
and gracefully handle them.  It returns "tokens" which reset
the model-view matrix to the previous condition.  This is
part of the Visitor API.
 
Note:
        Most Transforming nodes are also Grouping nodes,
        so both the Transform method and the Grouping method
        will be run for those nodes.
__init__(self)
Initialise the visitor object
buildVMethods(self)
Add scenegraph-package-specific class:method mappings

Data and non-method functions defined here:
__doc__ = 'OpenGL Rendering visitor/traversal object for sc... passes (which do no traversal at the moment)).\n\t'
__module__ = 'OpenGLContext.rendervisitor'
contextBaseClass = None
frustum = None

Methods inherited from Visitor:
children(self, node, types=(<class 'vrml.vrml97.nodetypes.Traversable'>, <class 'vrml.vrml97.nodetypes.Children'>, <class 'vrml.node.PrototypedNode'>, <class 'vrml.vrml97.nodetypes.Rendering'>))
Get children to visit for a node
 
Determine the set of children to be visited for
a given node in the node graph.  See the
childrenMethod method for details.  If no
childrenMethod is reported, an empty tuple
is reported.
visit(self, node)
Visit an individual node, dispatch to methods as necessary
 
The visiting algorithm is fairly involved compared
to the classic computer science Visitor algorithm.
 
First we call preVisit( node ), and if the
result of that is true, we continue processing.
This allows you to use preVisit to do such things
as processing every node in the scenegraph.
 
If we are visiting the node: (preVisit returned true)
 
        * add the node to self.currentStack
        * retrieve the "vmethods" for the node
        * call each vmethod with the node as argument
                o if the vmethod returns a finalization token
                        we store that token for finalization
        * we determine the children to visit for the node
        * for each child, we call visit recursively
        * during finalization (after children are finished
                processing)
                o if we have any finalization tokens, we call
                        those tokens
                o we call postVisit( node )
                o we restore the previous self.currentStack
                
Note: this is the "production" version of visit
which only logs errors, not "info" level traces,
this avoids the 100's of 1000's of calls generated
by the huge number of iterations.
vmethods(self, obj)
Get all relevant "virtual methods" as unbound methods
 
Returns *all* registered vmethods for the classes in the
given object's class's __mro__
 
This version caches the unbound methods in a per-visitor-
class dictionary, which should make it at least a little
faster.

Class methods inherited from Visitor:
addChildrenMethod(self, type, function) from type
Register function for determining children for a given type
 
XXX
        Methods are stored in the _childrenMethods dictionary,
        which is currently class-static, I would rather this
        were an instance variable, but that makes registration
        something you need to do for every new instance, while
        normally you only want to override for very special
        sub-classes (I haven't yet discovered a case where I
        want to do it).
 
Note:
        This is currently a class method due to the class-
        static nature!

Data and non-method functions inherited from Visitor:
__dict__ = <dict-proxy object at 0x07340530>
__weakref__ = <member '__weakref__' of 'Visitor' objects>
_childrenMethods = {}

Methods inherited from object:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__hash__(...)
x.__hash__() <==> hash(x)
__reduce__(...)
helper for pickle
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__str__(...)
x.__str__() <==> str(x)

Data and non-method functions inherited from object:
__class__ = <type 'type'>
__new__ = <built-in method __new__ of type object at 0x1E0BD978>
T.__new__(S, ...) -> a new object with type S, a subtype of T
 
class TransformOverflowToken(object)
      Restore previous matrix in model-view-stack overflow situations
 
This is part of the visitor API used by the Transform method
it restores the model-view matrix stack after a Transforming
node's children are finished being visited.
 
This version is used when the model-view matrix stack
has overflowed, using the more expensive glLoadMatrixd
call to do the restoration.
 
   Methods defined here:
__call__(self, mode=None)
__init__(self, matrix)

Data and non-method functions defined here:
__dict__ = <dict-proxy object at 0x0725FF60>
__doc__ = 'Restore previous matrix in model-view-stack over...sive glLoadMatrixd\n\tcall to do the restoration.\n\t'
__module__ = 'OpenGLContext.rendervisitor'
__weakref__ = <member '__weakref__' of 'TransformOverflowToken' objects>

Methods inherited from object:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__hash__(...)
x.__hash__() <==> hash(x)
__reduce__(...)
helper for pickle
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__str__(...)
x.__str__() <==> str(x)

Data and non-method functions inherited from object:
__class__ = <type 'type'>
__new__ = <built-in method __new__ of type object at 0x1E0BD978>
T.__new__(S, ...) -> a new object with type S, a subtype of T
 
class _TransformPopToken(object)
      Pop matrix off model-view-stack
 
This is part of the visitor API used by the Transform method
it restores the model-view matrix stack after a Transforming
node's children are finished being visited.
 
This version is used when the model-view matrix stack
has not overflowed, which allows us to use the more efficient
glPopMatrix call.
 
   Methods defined here:
__call__(self, mode=None)

Data and non-method functions defined here:
__dict__ = <dict-proxy object at 0x0725FF60>
__doc__ = 'Pop matrix off model-view-stack\n\n\tThis is part o...us to use the more efficient\n\tglPopMatrix call.\n\t'
__module__ = 'OpenGLContext.rendervisitor'
__weakref__ = <member '__weakref__' of '_TransformPopToken' objects>

Methods inherited from object:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__hash__(...)
x.__hash__() <==> hash(x)
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__reduce__(...)
helper for pickle
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__str__(...)
x.__str__() <==> str(x)

Data and non-method functions inherited from object:
__class__ = <type 'type'>
__new__ = <built-in method __new__ of type object at 0x1E0BD978>
T.__new__(S, ...) -> a new object with type S, a subtype of T
 
Data
             DEBUG = 10
RADTODEG = 57.295779513082323
TransformPopToken = <OpenGLContext.rendervisitor._TransformPopToken object at 0x056FECE8>
visitor_log = <logging.Logger instance at 0x056F3980>