PyVRML97 2.3.4b3__py3-none-any.whl

vrml/vrml97/scenegraph.py

@@ -0,0 +1,181 @@
+"""Scenegraph node-like "prototype" for VRML97"""
+from vrml import node, protofunctions, protonamespace, fieldtypes, route
+from vrml import copier as copiermodule
+from vrml.vrml97 import nodetypes
+import weakref
+from .._bytes import unicode
+
+class SceneGraph( nodetypes.Traversable, node.Node ):
+    ''' A VRML 97 sceneGraph
+    Attributes:
+        __gi__ -- constant string "sceneGraph"
+        DEF -- constant string ""
+        children -- Node list
+            List of the root children of the sceneGraph, nodes/scripts only
+        routes -- ROUTE list
+            List of the routes within the sceneGraph
+        defNames -- string DEFName: Node node
+            Mapping of DEF names to their respective nodes
+        protoTypes -- Namespace prototypes
+            Namespace (with chaining lookup) collection of prototypes
+            getattr( sceneGraph.protoTypes, 'nodeGI' ) retrieves a prototype
+    '''
+    PROTO = "sceneGraph"
+    children = node.MFNode( 'children',)
+    routes = route.MFRoute(
+        'routes',
+    )
+    baseURI = fieldtypes.SFString(
+        'baseURI',
+        1,
+        "",
+    )
+    def __init__(
+        self, root=None, protoTypes=None,
+        routes=None, defNames=None,
+        children=None, 
+        *args, **namedargs
+    ):
+        '''
+        root -- sceneGraph root or Dictionary root or Module root or None
+            Base object for root of protoType namespace hierarchy
+        protoTypes -- string nodeGI: Prototype PROTO
+            Dictionary of prototype definitions
+        routes -- ROUTE list or (string sourcenode, string sourceeventOut, string destinationnode, string destinationeventOut) list
+            List of route objects or tuples to be added to the sceneGraph
+            see attribute routes
+        defNames -- string DEFName: Node node
+            see attribute defNames
+        children -- Node list
+            see attribute children
+        '''
+        if root is not None:
+            self.root = weakref.ref( root )
+        else:
+            self.root = None
+        if protoTypes is None:
+            protoTypes = protonamespace.ProtoNamespace()
+        self.protoTypes = protoTypes
+        if defNames is None:
+            defNames = {}
+        self.defNames = defNames
+        namedargs['children'] = children
+        super( SceneGraph, self ).__init__(
+            *args,
+            **namedargs
+        )
+        node.Node.rootSceneGraph.fset( self, self )
+        if routes:
+            for route in routes:
+                self.addRoute( route )
+    def getProto( self, name ):
+        """Get a prototype by name
+
+        go up the scenegraph chain to try to resolve
+        """
+        current = self.protoTypes.get( name )
+        if current is not None:
+            return current
+        elif hasattr( self, 'root'):
+            root = self.root
+            if root:
+                root = root()
+                if root:
+                    return root.getProto( name )
+        return None
+        
+    def getDEF( self, name ):
+        """Get a node by DEF name"""
+        return self.defNames.get(name)
+    
+    def regDefName(self, defName, object):
+        ''' Register a DEF name for a particular object
+
+            defName -- string DEFName
+            object -- Node node
+
+        Eliminates previous references to the object by
+        its current DEFName and sets the object's new
+        DEFName.
+        '''
+        current = protofunctions.defName( object )
+        if self.defNames.get(current) is object:
+            del self.defNames[current]
+        protofunctions.defName( object, defName )
+        self.defNames[defName] = object
+    def addProto(self, proto):
+        '''Register a Prototype for this sceneGraph
+        proto -- Prototype PROTO
+        '''
+        self.protoTypes[protofunctions.name( proto ) ] = proto
+    def addRoute(self, route, *args):
+        '''Add a route to the scenegraph
+        
+        route,args -- Possible forms:
+        
+            ROUTE object -- added to routes
+            ((source)node,field,(destination)node,field) -- ROUTE
+                created, nodes may be strings, in which case 
+                getDEF( node ) is called for each
+            ((source)node,field,target( signal, sender, value )) -- 
+                field.watch( target ) is called for the source 
+                node (which can be a DEF name).
+        '''
+        if args:
+            route = (route,) + args
+        if isinstance( route, (tuple,list)):
+            if len(route) == 4:
+                # 4-element route definition, e.g. from strings...
+                from vrml.route import ROUTE
+                source,sourceField,destination,destinationField = route 
+                if isinstance( source, (str,unicode)):
+                    source = self.getDEF( source )
+                if isinstance( destination, (str,unicode)):
+                    destination = self.getDEF( destination )
+                route = ROUTE( 
+                    source = source,
+                    sourceField = sourceField,
+                    destination = destination,
+                    destinationField = destinationField,
+                )
+            elif len(route) == 3:
+                # 2-element source plus a function to receive...
+                source,sourceField,target = route 
+                if not callable( target ):
+                    raise TypeError(
+                        """Need a callable target object!"""
+                    )
+                if isinstance( source, (str,unicode)):
+                    source = self.getDEF( source )
+                field = protofunctions.getField( source, sourceField )
+                field.watch( source, target, ('set',field) )
+                field.watch( source, target, ('del',field) )
+        self.routes.append( route )
+        return route
+##	def addIsMap( self, name, node, field ):
+##		"""Add an isMap for the given name to the given node+field"""
+##		self.isMaps.setdefault( name, []).append( (node,field) )
+        
+    def copy( self, copier=None ):
+        """Copy this node for copier"""
+        if copier is None:
+            copier = copiermodule.Copier()
+        # order for creation is going to be important to make sure
+        # that prototypes are available to nodes getting re-built
+        # if we aren't sharing protos...
+        if not copier.shareProtos:
+            newPrototypes = protonamespace.ProtoNamespace()
+            for key,value in self.protoTypes.items():
+                newPrototypes[key] = protofunctions.copyProto( value, copier )
+        else:
+            newPrototypes = self.protoTypes.copy()
+        newDefs = {}
+        for key,value in self.defNames.items():
+            if (not key) or value is None:
+                continue
+            newDefs[key] = value.copy( copier )
+        node = super( SceneGraph, self).copy( copier )
+        node.protoTypes = newPrototypes
+        node.defNames = newDefs
+        return node
+    

vrml/vrml97/script.py

@@ -0,0 +1,25 @@
+"""VRML97 Script-node stub"""
+from vrml import node, fieldtypes
+from vrml.vrml97 import nodetypes
+
+class _Script( nodetypes.Children, node.Node ):
+    """A sub-type of node with scripting/pseudo-proto support
+
+    The class here just handles basic node-like functionality,
+    a special constructor factory takes care of the PROTO-like
+    functionality.
+    """
+    url = fieldtypes.MFString(
+        'url', 1,
+    )
+    directOutput = fieldtypes.SFBool(
+        'directOutput', default = 0,
+    )
+    mustEvaluate = fieldtypes.SFBool(
+        'mustEvaluate', default = 0,
+    )
+    
+def Script( fields, **namedarguments ):
+    """Create a new script prototype and an instance of that prototype"""
+    proto = node.prototype( 'Script', fields, baseClasses = (_Script,) )
+    return proto( **namedarguments )

vrml/vrml97/shaders.py

@@ -0,0 +1,123 @@
+"""Node definitions for a non-standard Programable Shaders extension
+"""
+from vrml.vrml97 import nodetypes
+from vrml import field, node, fieldtypes
+
+class ShaderGeometry( nodetypes.Children, nodetypes.Rendering, node.Node ):
+    """Generic geometry definition for a shader-based renderer
+    
+    attributes -- define the attribute pointers which feed the 
+        shader, the individual attributes may share a buffer or 
+        define one per attribute 
+    indices -- if present, node defining index array to be used 
+        to index into buffers, will be uploaded to an element 
+        buffer
+    uniforms -- Uniform nodes which are bound/updated on the 
+        shader before rendering this geometry, binds to the 
+        shader's location == to the uniform's name.
+    slices -- slices of the array to render, if not specified 
+        then we'll render the whole data-set
+    """
+    PROTO = "ShaderGeometry"
+    indices = field.newField( 'indices', 'MFInt32', 1, list )
+    attributes = field.newField( 'attributes','MFNode',1,list )
+    slices = field.newField( 'slices', 'MFNode',1,list )
+    uniforms = field.newField( 'uniforms','MFNode',1,list )
+    appearance = field.newField( 'appearance', 'SFNode',1,list )
+
+class ShaderSlice( node.Node ):
+    """Segment of a shader geometry element to render"""
+    offset = field.newField( 'offset', 'SFUInt32',1, -1 )
+    count = field.newField( 'count', 'SFUInt32',1, -1 )
+    uniforms = field.newField( 'uniforms','MFNode',1,list)
+
+class ShaderAttribute( node.Node ):
+    """Attribute (variable) binding for a shader
+    """
+    name = field.newField( 'name', 'SFString', 1, '' )
+    offset = field.newField( 'offset','SFUInt32',1, 0 )
+    stride = field.newField( 'stride', 'SFUInt32',1, 0 ) # default to buffer natural stride
+    size = field.newField( 'size','SFUInt32',1,3 ) # default num of elements
+    dataType = field.newField( 'dataType','SFString', 1, 'FLOAT' )
+    # the buffer into which we index...
+    buffer = field.newField( 'buffer','SFNode',1,node.NULL )
+    isCoord = field.newField( 'isCoord','SFBool',1,False)
+    bufferKey = field.newField( 'bufferKey', 'SFString', 1,'')
+    
+class ShaderBuffer( node.Node ):
+    """Buffer of data into which pointers can be generated"""
+    type = field.newField( 'type','SFString', 1, 'ARRAY' )
+    usage = field.newField( 'usage','SFString', 1, 'DYNAMIC_DRAW' )
+    buffer = field.newField( 'buffer','SFArray32', 1, list )
+class ShaderIndexBuffer( ShaderBuffer ):
+    """Buffer of data from which indices are generated"""
+    type = field.newField( 'type','SFString', 1, 'ELEMENT' )
+    usage = field.newField( 'usage','SFString', 1, 'DYNAMIC_DRAW' )
+    buffer = field.newField( 'buffer','MFUInt32', 1, list )
+
+class FloatUniform( node.Node ):
+    """Uniform (variable) binding for a shader
+    
+    The FloatUniform is the base class for FloatUniforms,
+    that is, there are FloatUniform1f, FloatUniform2f,
+    FloatUniformm3x2, etceteras Node-types, but not a
+    FloatUniform node-type.
+    """
+    name = field.newField( 'name', 'SFString', 1, '' )
+    # type values, 1f, 2f, 3f, 4f, m2, m3, m4, m2x3,m3x2,m2x4,m4x2,m3x4,m4x3
+    value = field.newField( 'value',  'SFArray32',  1,  list )
+
+class IntUniform( node.Node ):
+    """Uniform (variable) binding for a shader (integer form)
+    """
+    PROTO = "IntUniform"
+    name = field.newField( 'name', 'SFString', 1, '' )
+    # type values, 1i,2i,3i,4i
+    value = field.newField( 'value',  'MFInt32',  1,  list )
+
+class TextureUniform( node.Node ):
+    """Uniform which specifies a texture sampler"""
+    PROTO = 'TextureUniform'
+    name = field.newField( 'name','SFString', 1, '' )
+    value = field.newField( 'value', 'SFNode', 1, node.NULL )
+class TextureBufferUniform( node.Node ):
+    """Uniform which specifies a texture across vbo data"""
+    PROTO = 'TextureBufferUniform'
+    name = field.newField( 'name','SFString', 1, '' )
+    value = field.newField( 'value', 'SFNode', 1, node.NULL )
+    format = field.newField( 'format', 'SFString',1,'RGBA32F' )
+
+class GLSLShader( node.Node ):
+    """GLSL-based shader node"""
+    PROTO = "GLSLShader"
+    url = field.newField( 'url', 'MFString', 1, list)
+    source = field.newField( 'source','MFString',1, list)
+    imports = field.newField( 'imports', 'MFNode', 1, list )
+    # type values, VERTEX or FRAGMENT
+    type = field.newField( 'type',  'SFString', 1,  'VERTEX' ) 
+
+class GLSLImport( node.Node ):
+    """GLSL-base shader source-code import"""
+    PROTO = "GLSLImport"
+    url = field.newField( 'url', 'MFString', 1, list)
+    source = field.newField( 'source','MFString',1, list)
+
+class GLSLObject( node.Node ):
+    """GLSL-based shader object (compiled set of shaders)"""
+    PROTO = "GLSLObject"
+    # role values, VISIBLE, DEPTH, SELECT
+    role = field.newField( 'role', 'SFString', 1, 'VISIBLE' )
+    uniforms = field.newField( 'uniforms',  'MFNode',  1,  list )
+    shaders = field.newField( 'shaders',  'MFNode',  1,  list )
+    # textures is a set of texture uniforms...
+    textures = field.newField( 'textures', 'MFNode', 1, list )
+
+class Shader( node.Node ):
+    """Shader is a programmable substitute for an Appearance node"""
+    PROTO = 'Shader'
+    #Fields
+    material = field.newField( 'material', 'SFNode', 1, node.NULL)
+    objects = field.newField( 'objects',  'MFNode',  1,  list )
+    
+    implementation = field.newField( 'implementation','SFNode',1,node.NULL)
+

vrml/vrml97/transformmatrix.py

@@ -0,0 +1,193 @@
+"""Utility module for creating transformation matrices
+
+Basically this gives you the ability to construct
+transformation matrices without needing OpenGL
+or similar run-time engines.  The result is that
+design-time utilities can process files without
+trading dependencies on a particular run-time.
+
+This code is originally from the mcf.vrml processing
+engine, and has only been cosmetically altered to
+fit the new organizational pattern.
+
+Note: to apply these matrices to a particular coordinate,
+you would do the following:
+
+    p = ones( 4 )
+    p[:3] = coordinate
+    return dot( p, matrix)
+
+That is, you use the homogenous coordinate, and
+make it the first item in the dot'ing.
+"""
+from math import *
+from vrml.arrays import *
+try:
+    from vrml.vrml97._transformmatrix_accel import (
+        rotMatrix,
+        scaleMatrix,
+        transMatrix,
+        perspectiveMatrix,
+        orthoMatrix,
+    )
+except ImportError:
+    from vrml.vrml97._transformmatrix import (
+        rotMatrix,
+        scaleMatrix,
+        transMatrix,
+        perspectiveMatrix,
+        orthoMatrix,
+    )
+
+assert perspectiveMatrix 
+assert orthoMatrix
+
+# used to determine whether angles are non-null
+TWOPI = pi * 2.0
+RADTODEG = 360./TWOPI
+DEGTORAD = TWOPI/360.
+# used to determine the center point of a transform
+ORIGINPOINT = array([0,0,0,1],'f')
+VERY_SMALL = 1e-300
+
+def transformMatrix(
+        translation = (0,0,0),
+        center = (0,0,0),
+        rotation = (0,1,0,0),
+        scale = (1,1,1),
+        scaleOrientation = (0,1,0,0),
+        parentMatrix = None,
+    ):
+    """Convert VRML transform values to an overall matrix
+
+    Returns 4x4 transformation matrix
+    Note that this uses VRML standard for rotations
+    (angle last, and in radians).
+
+    This should return matrices which, when applied to
+    local-space coordinates, give you parent-space
+    coordinates.
+
+    parentMatrix if provided, should be the parent's
+    transformation matrix, a 4x4 matrix of such as
+    returned by this function.
+    """
+    T,T1 = transMatrix( translation )
+    C,C1 = transMatrix( center )
+    R,R1 = rotMatrix( rotation )
+    SO,SO1 = rotMatrix( scaleOrientation )
+    S,S1 = scaleMatrix( scale )
+    return compressMatrices( parentMatrix, T,C,R,SO,S,SO1,C1 )
+    
+def itransformMatrix(
+        translation = (0,0,0),
+        center = (0,0,0),
+        rotation = (0,1,0,0),
+        scale = (1,1,1),
+        scaleOrientation = (0,1,0,0),
+        parentMatrix = None,
+    ):
+    """Convert VRML transform values to an inverse transform matrix
+
+    Returns 4x4 transformation matrix
+    Note that this uses VRML standard for rotations
+    (angle last, and in radians).
+
+    This should return matrices which, when applied to
+    parent-space coordinates, give you local-space
+    coordinates for the corresponding transform.
+
+    Note: this is a substantially un-tested algorithm
+    though it seems to be properly constructed as far
+    as I can see.  Whether to use dot(x, parentMatrix)
+    or the reverse is not immediately clear to me.
+    
+    parentMatrix if provided, should be the child's
+    transformation matrix, a 4x4 matrix of such as
+    returned by this function.
+    """
+    T,T1 = transMatrix( translation )
+    C,C1 = transMatrix( center )
+    R,R1 = rotMatrix( rotation )
+    SO,SO1 = rotMatrix( scaleOrientation )
+    S,S1 = scaleMatrix( scale )
+    return compressMatrices( parentMatrix, C,SO, S1, SO1, R1, C1, T1)
+
+def transformMatrices( 
+        translation = (0,0,0),
+        center = (0,0,0),
+        rotation = (0,1,0,0),
+        scale = (1,1,1),
+        scaleOrientation = (0,1,0,0),
+        parentMatrix = None,
+    ):
+    """Calculate both forward and backward matrices for these parameters"""
+    T,T1 = transMatrix( translation )
+    C,C1 = transMatrix( center )
+    R,R1 = rotMatrix( rotation )
+    SO,SO1 = rotMatrix( scaleOrientation )
+    S,S1 = scaleMatrix( scale )
+    return (
+        compressMatrices( parentMatrix, T,C,R,SO,S,SO1,C1 ),
+        compressMatrices( parentMatrix, C,SO, S1, SO1, R1, C1, T1)
+    )
+
+def localMatrices(
+        translation = (0,0,0),
+        center = (0,0,0),
+        rotation = (0,1,0,0),
+        scale = (1,1,1),
+        scaleOrientation = (0,1,0,0),
+        parentMatrix = None,
+    ):
+    """Calculate (forward,inverse) matrices for this transform element"""
+    T,T1 = transMatrix( translation )
+    C,C1 = transMatrix( center )
+    R,R1 = rotMatrix( rotation )
+    SO,SO1 = rotMatrix( scaleOrientation )
+    S,S1 = scaleMatrix( scale )
+    return (
+        compressMatrices( T,C,R,SO,S,SO1,C1 ),
+        compressMatrices( C,SO, S1, SO1, R1, C1, T1)
+    )
+
+def compressMatrices( *matrices ):
+    """Compress a set of matrices
+    
+    Any (or all) of the matrices may be None,
+    if *all* are None, then the result will be None,
+    otherwise will be the dot product of all of the 
+    matrices...
+    """
+    if not matrices:
+        return None 
+    else:
+        first = matrices[0]
+        matrices = matrices[1:]
+    for item in matrices:
+        if item is not None:
+            if first is None:
+                first = item
+            else:
+                first = dot( item, first )
+    return first
+
+    
+def center(
+    translation = (0,0,0),
+    center = (0,0,0),
+    parentMatrix = None,
+):
+    """Determine the center of rotation for a transform node
+
+    Returns the parent-space coordinate of the
+    node's center of rotation.
+    """
+    if parentMatrix is None:
+        parentMatrix = identity(4)
+    T,T1 = transMatrix( translation )
+    C,C1 = transMatrix( center )
+    for x in (T,C):
+        if x:
+            parentMatrix = dot( x, parentMatrix)
+    return dot( ORIGINPOINT, parentMatrix )

vrml/weakkeydictfix.py

@@ -0,0 +1,36 @@
+"""Module providing patched weakkeydictionary operation"""
+import weakref
+ref = weakref.ref
+
+class WeakKeyDictionary( weakref.WeakKeyDictionary ):
+    """Sub-class to work around error in WeakKeyDictionary implementation
+
+    Python 2.2.2 and 2.2.3c1 both have an annoying
+    problem in their __delitem__ for the
+    WeakKeyDictionary class.  This class provides
+    a work-around for it.
+    """
+    def __init__(self, dict=None):
+        """Initialize the WeakKeyDictionary
+
+        dict -- previously-existing weak key records or
+            None to create a new dictionary
+        """
+        self.data = {}
+        def remove(k, selfref=ref(self)):
+            self = selfref()
+            if self is not None and self.data:
+                try:
+                    v = self.data.get( k )
+                    del self.data[k]
+                except (KeyError,RuntimeError):
+                    pass
+            # now v goes out of scope and is deleted...
+        self._remove = remove
+        if dict is not None: self.update(dict)
+    def __delitem__(self, key):
+        """Overridden delitem to avoid scanning"""
+        try:
+            del self.data[weakref.ref(key)]
+        except KeyError:
+            raise KeyError( """Item %r does not appear as a key"""%( key,))