OpenGLContext.scenegraph.shaders

Shader node implementation

Functions

_uniformCls( suffix )

Classes

class _Buffer( object ):

VBO based buffer implementation for generic geometry

bind( self , mode )

Bind this buffer so that we can perform e.g. mappings on it

gl_target( self )

gl_usage( self )

unbind( self , mode )

vbo( self , mode )

Render this buffer on the mode

class _GLSLObjectCache( object ):

class _TextureUniform( _Uniform ):

bind( self , shader , mode , index )

class _Uniform( object ):

Uniform common operations

currentValue( self , shader , mode )

Retrieve the current value for this item

Is a customization point for uniforms that should be calculated on demand...

location( self , shader , mode )

Get our location (-1 if not defined/used)

class FloatUniform( _UniformFloatUniform ):

Uniform (variable) binding for a shader

render( self , shader , mode , location = None )

Set this uniform value for the given shader

This is called at render-time to update the value...

class FloatUniform1f( FloatUniform ):

class FloatUniform2f( FloatUniform ):

class FloatUniform3f( FloatUniform ):

class FloatUniform4f( FloatUniform ):

class FloatUniformm2( FloatUniform ):

class FloatUniformm2x3( FloatUniform ):

class FloatUniformm2x4( FloatUniform ):

class FloatUniformm3( FloatUniform ):

class FloatUniformm3x2( FloatUniform ):

class FloatUniformm3x4( FloatUniform ):

class FloatUniformm4( FloatUniform ):

class FloatUniformm4x2( FloatUniform ):

class FloatUniformm4x3( FloatUniform ):

class GLSLImport( GLSLImport ):

GLSL-based importable code library

url

exposedField MFString url []

class GLSLObject( GLSLObject ):

GLSL-based shader object (compiled set of shaders)

compileLog

field SFString compileLog

compile( self , mode , shader )

Compile into GLSL linked object

getLocation( self , mode , name , uniform = True )

Retrieve attribute/uniform location

getVariable( self , name )

Retrieve uniform/attribute by name

holderDepend( self , holder )

Make this holder depend on our compilation vars

program( self , mode )

Retrieve our program ID

render( self , mode , shader = None )

Render this shader in the current mode

renderPost( self , token , mode )

Post-render cleanup...

sortKey( self , mode , matrix )

Produce the sorting key for this shape's appearance/shaders/etc

class GLSLShader( GLSLShader ):

GLSL-based shader node

compileLog

field SFString compileLog

url

exposedField MFString url []

compile( self )

holderDepend( self , holder )

visible( self , * args , ** named )

class IntUniform( _UniformIntUniform ):

Uniform (variable) binding for a shader (integer form)

class IntUniform1i( IntUniform ):

class IntUniform2i( IntUniform ):

class IntUniform3i( IntUniform ):

class IntUniform4i( IntUniform ):

class Shader( Shader ):

Shader is a programmable substitute for an Appearance node

current

exposedField SFNode SFNode NULL

currentImplementation( self )

render( self , mode = None )

Render the shader

renderPost( self , textureToken = None , mode = None )

Cleanup after rendering of this node has completed

sortKey( self , mode , matrix )

Produce the sorting key for this shape's appearance/shaders/etc

class ShaderAttribute( ShaderAttribute ):

VBO-based buffer implementation for generic geomtry indices

boundingVolume( self , mode )

Calculate bounding volume of this attribute's current values

bufferView( self )

Retrieve a view of our buffer that is just this attribute's values

render( self , shader , mode )

Set this uniform value for the given shader

This is called at render-time to update the value...

renderPost( self , mode , shader , token = None )

class ShaderBuffer( _BufferShaderBuffer ):

Regular vertex-buffer mechanism

class ShaderGeometry( ShaderGeometry ):

Renderable geometry type using shaders

boundingVolume( self , mode )

Create a bounding-volume object for this node

This is our geometry's boundingVolume, with the addition that any dependent volume must be dependent on our geometry field.

Render( self , mode = None )

Do run-time rendering of the Shape for the given mode

sortKey( self , mode , matrix )

Produce the sorting key for this shape's appearance/shaders/etc

visible( self , frustum = None , matrix = None , occlusion = 0 , mode = None )

Check whether this renderable node intersects frustum

frustum: the bounding volume frustum with a planes attribute which defines the plane equations for each active clipping plane
matrix: the active OpenGL transformation matrix for this node, used to determine the transforms for the grouping-node's bounding volumes. Is calculated from current OpenGL state if not provided.

class ShaderIndexBuffer( _BufferShaderIndexBuffer ):

Index array buffer mechanism

class ShaderSlice( ShaderSlice ):

Slice of a shader to render

class ShaderURLField( MFString ):

Field for managing interactions with a Shader's URL value

fset( self , client , value , notify = 1 )

Set the client's URL, then try to load the image

loadBackground( self , client , url , contexts )

subLoad( self , client , urlFragment , i , overall )

class TextureBufferUniform( _TextureUniformTextureBufferUniform ):

Uniform (variable) finding for a VBO-based texture sampler

baseFunction( location , v0 )

get_format( self )

render( self , shader , mode , index )

Bind the actual uniform value

texture( self , mode )

Render this buffer on the mode

class TextureUniform( _TextureUniformTextureUniform ):

Uniform (variable) binding for a texture sampler

baseFunction( location , v0 )

render( self , shader , mode , index )

Bind the actual uniform value