OpenGLContext.passes._flat

Flat rendering passes (base implementation)

Classes

class FlatPass( SGObserver ):

Flat rendering pass with a single function to render scenegraph

Uses structural scenegraph observations to allow the actual rendering pass be a simple iteration over the paths known to be active in the scenegraph.

Rendering Attributes:

visible: whether we are currently rendering a visible pass
transparent: whether we are currently doing a transparent pass
lighting: whether we currently are rendering a lit pass
context: context for which we are rendering
cache: cache of the context for which we are rendering
projection: projection matrix of current view platform
modelView: model-view matrix of current view platform
viewport: 4-component viewport definition for current context
frustum: viewing-frustum definition for current view platform
MAX_LIGHTS: queried maximum number of lights

passCount -- not used, always set to 0 for code that expects a passCount to be available. transform -- ignored, legacy code only

uniforms

__call__( self , context )

Overall rendering pass interface for the context client

addTransparent( self , other )

applyUniforms( self , shader )

Apply our uniforms to the shader as appropriate

calculateFrustum( self )

Construct our Frustum instance (currently by extracting from mv matrix)

currentBackground( self )

Find our current background node

frustumVisibilityFilter( self , records )

Filter records for visibility using frustum planes

This does per-object culling based on frustum lookups rather than object query values. It should be fast *if* the frustcullaccel module is available, if not it will be dog-slow.

getModelView( self )

Retrieve the base model-view matrix for the rendering pass

getProjection( self )

Retrieve the projection matrix for the rendering pass

getViewport( self )

Retrieve the viewport parameters for the rendering pass

greatestDepth( self , toRender )

legacyBackgroundRender( self , vp , matrix )

Do legacy background rendering

legacyLightRender( self , matrix )

Do legacy light-rendering operation

Render( self , context , mode )

Render the geometry attached to this flat-renderer's scenegraph

renderGeometry( self , mvmatrix )

Render geometry present in the given mvmatrix

Intended for use in e.g. setting up a light texture, this operation *just* does a query to find the visible objects and then passes them (all) to renderOpaque

renderOpaque( self , toRender )

Render the opaque geometry from toRender (in reverse order)

renderSet( self , matrix )

Calculate ordered rendering set to display

renderTransparent( self , toRender )

Render the transparent geometry from toRender (in forward order)

selectRender( self , mode , toRender , events )

Render each path to color buffer

We render all geometry as non-transparent geometry with unique colour values for each object. We should be able to handle up to 2**24 objects before that starts failing.

setViewPlatform( self , vp )

Set our view platform

class SGObserver( object ):

Observer of a scenegraph that creates a flat set of paths

Uses dispatcher watches to observe any changes to the (rendering) structure of a scenegraph and uses it to update an internal set of paths for all renderable objects in the scenegraph.

__init__( self , scene , contexts )

Initialize the FlatPass for this scene and set of contexts

scene: the scenegraph to manage as a flattened hierarchy
contexts: set of (weakrefs to) contexts to be serviced, normally is a reference to Context.allContexts

integrate( self , node , parentPath = None )

Integrate any children of node which are of interest

npFor( self , node )

For some reason setdefault isn't working for the weakkeydict

onChildAdd( self , sender , value )

Sender has a new child named value

onChildRemove( self , sender , value )

Invalidate all paths where sender has value as its child IFF child no longer in renderedChildren

onSwitchChange( self , sender , value )

Purge all references to path