PyVRML97 2.3.4b3__py3-none-any.whl

vrml/vrml97/nodepath.py

@@ -0,0 +1,135 @@
+"""Node-paths for VRML97 incl. transform-matrix calculation
+"""
+from __future__ import generators
+from vrml import nodepath
+from vrml.cache import CACHE
+from vrml.vrml97 import transformmatrix, nodetypes
+from vrml.arrays import *
+import weakref
+try:
+    xrange 
+except NameError:
+    xrange = range
+
+
+class _MatrixHolder( object ):
+    def __init__( self, matrix):
+        self.matrix = matrix
+
+class _NodePath( object ):
+    """Path within a VRML97 scenegraph from root to particular node
+
+    Adds transformation-matrix calculation functions
+    based on the nodetypes.Transforming node's
+    attributes.
+    """
+    parent = None
+    children = None
+    active = True
+    broken = False
+    def isTransform( self, item ):
+        """Customization Point: determine whether a node is a Transform"""
+        return isinstance(item, nodetypes.Transforming)
+    
+    def transformMatrix( self, translate=True, scale=True, rotate=True, matrixHolder=False, inverse=False ):
+        """Calculate (and cache) a transform matrix for this path
+        
+        Calculates our transformMatrix from our parent's transform 
+        and the set of nodes between our parent and ourself.  Normally
+        that should be a *single* node or *none* in most cases.
+        
+        translate -- if true, include translations in the matrix 
+        scale -- if true, include scales in the matrix 
+        rotate -- if true, include rotations in the matrix
+
+        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.
+        """
+        key=(['matrix','inverse_matrix'][int(bool(inverse))],translate,scale,rotate)
+        holder = CACHE.getHolder( self, key=key )
+        if holder is None:
+            doConnect = True 
+            holder = CACHE.holder( self, None, key=key )
+            mHolder = None
+        else:
+            doConnect = False
+            mHolder = holder.data
+            if mHolder is not None:
+                return mHolder
+        def get_mat( item ):
+            child_holder = item.localMatrices(translate=translate,scale=scale,rotate=rotate)
+            if doConnect:
+                holder.depend( child_holder )
+                # TODO: assumes child is a Transform!
+                if translate:
+                    holder.depend( item, 'translation' )
+                if scale:
+                    holder.depend( item, 'scale' )
+                    holder.depend( item, 'scaleOrientation' )
+                if rotate:
+                    holder.depend( item, 'rotation' )
+                    holder.depend( item, 'center' )
+            return child_holder.data[inverse]
+        matrix = transformmatrix.compressMatrices( 
+            *[get_mat(item) for item in self.transformChildren(reverse=inverse)]
+        )
+        if matrix is None:
+            matrix = identity(4, dtype='f')
+        holder.data = matrix
+        return holder.data
+    def transformChildren( self, reverse=0 ):
+        """Yield all transforming children"""
+        t = nodetypes.Transforming
+        if reverse:
+            for i in xrange(len(self)-1,-1, -1):
+                item = self[i]
+                if isinstance(item, t):
+                    yield item
+                
+        else: # forward...
+            for item in self:
+                if isinstance(item, t):
+                    yield item
+
+    def __add__(self, other):
+        """Add parent-matrix pre-caching support to nodepaths"""
+        base = super( _NodePath, self).__add__( other )
+        base.parent = self
+        if self.children is None:
+            self.children = []
+        self.children.append( weakref.ref( base ))
+        # watch for other sending events which say that 
+        # this relationship is no longer active...
+        return base
+    def iterchildren( self ):
+        """Iterate over child paths which are still live"""
+        if self.children is not None:
+            for childref in self.children[:]:
+                child = childref()
+                if child is not None:
+                    yield child 
+                else:
+                    self.children.remove( childref )
+    def iterdescendents( self ):
+        """Iterate over all descendent paths"""
+        for child in self.iterchildren():
+            yield child 
+            for desc in child.iterchildren():
+                yield desc 
+    def invalidate( self ):
+        """Set this path to be invalid (and all children paths)"""
+        self.broken = True 
+        for desc in self.iterdescendents( ):
+            desc.broken = True 
+
+class NodePath( _NodePath, nodepath.NodePath ):
+    """Strong-reference version of VRML97 NodePath"""
+class WeakNodePath( _NodePath, nodepath.WeakNodePath ):
+    """Weak-reference version of VRML97 NodePath"""

vrml/vrml97/nodetypes.py

@@ -0,0 +1,95 @@
+"""VRML97 semantic node-types"""
+from vrml import node
+
+class Traversable( object ):
+    """Traversable nodes (Nodes which have node attributes)
+    """
+class Grouping( Traversable ):
+    """Grouping nodes (Nodes which group children together)
+    """
+    sensitive = 0
+class Transforming( Grouping ):
+    """Nodes which alter the transform matrix for children
+
+    This is a fairly small set of types:
+
+        Transform
+        Billboard
+
+    Billboard is not yet implemented, so there's
+    only the one functional node in the type-set
+    """
+    def localMatrices( self, translate=True,scale=True,rotate=True ):
+        """Calculate/lookup our local matrices
+        
+        Certain operations want, e.g. just the rotation of an item,
+        so we actually can store 2**3 possible variations of the local 
+        matrices.  In practice we only see a very small number.
+        
+        returns holder, where holder.data == (forward,inverse) matrix 
+        for the local node, each of which can be None
+        """
+        raise NotImplemented
+
+class Children( object ):
+    """Children nodes (Nodes which can belong to a Grouping)
+    """
+    sensitive = 0
+
+
+class Rendering( object ):
+    """Rendering nodes (Shapes)
+    """
+class Geometry( object ):
+    """Geometry nodes (Nodes which can appear in the geometry field of shapes)
+    """
+class Texture( object ):
+    """Texture nodes
+    """
+
+
+class Sensor( object ):
+    """Sensor nodes
+
+    Note: All Sensors are also Children, though
+        that isn't represented here.
+    """
+class PointingSensor( Sensor ):
+    """Pointing-Device Sensor nodes
+    """
+
+
+class Bindable( object ):
+    """Bindable nodes
+
+    Note: All Bindables are also Children, though
+        that isn't represented here.
+    """
+class Background( Bindable ):
+    """Background nodes
+    """
+class Viewpoint( Bindable ):
+    """Viewpoint nodes
+    """
+class NavigationInfo( Bindable ):
+    """NavigationInfo nodes
+    """
+class Fog( Bindable ):
+    """Fog nodes
+    """
+
+class Light( object ):
+    """Light nodes
+    """
+
+
+class Interpolator( object ):
+    """Interpolator nodes
+    """
+class TimeDependent( object ):
+    """TimeDependent nodes
+    """
+class Auditory( object ):
+    """Auditory nodes (nodes with produce sound)
+    """
+    

vrml/vrml97/nurbs.py

@@ -0,0 +1,79 @@
+"""Node definitions for the VRML97 nurbs extension proposal
+
+OpenGLContext only has the most rudimentary of NURBs support,
+and still this module doesn't even define many of the NURBs-
+related prototypes which you could run across.  I've not
+provided the more funky of the nodes, such as the interpolators
+and the deformation matrices.
+"""
+from vrml.vrml97 import nodetypes
+from vrml import field, node, fieldtypes
+
+### Trimming curves
+class Contour2D( node.Node ):
+    """A 2D contour (collection of joined segments)
+
+    children -- a set of polylines and/or curves which are
+        joined to form the trimming contour
+    """
+    PROTO = "Contour2D"
+    children = field.newField( 'children', 'MFNode', 1, list)
+    
+class Polyline2D( node.Node ):
+    """A 2D piece-wise-linear polyline"""
+    PROTO = "Polyline2D"
+    point = field.newField( 'point', 'MFVec2f', 1, list)
+class NurbsCurve2D( node.Node ):
+    """A 2D nurbs curve normally used for trimming surfaces"""
+    PROTO = "NurbsCurve2D"
+    knot = field.newField( 'knot', 'MFFloat32', 1, list)
+    order = field.newField( 'order', 'SFInt32', 1, 3)
+    controlPoint = field.newField( 'controlPoint', 'MFVec2f', 1, list)
+    weight = field.newField( 'weight', 'MFFloat32', 1, list)
+    tessellation = field.newField( 'tessellation', 'SFInt32', 1, 0)
+
+### Surfaces and Curves
+class NurbsCurve( nodetypes.Geometry, node.Node ):
+    """A 3D nurbs curve (a curvy line in 3D space)
+    """
+    PROTO = "NurbsCurve"
+    knot = field.newField( 'knot', 'MFFloat32', 1, list)
+    order = field.newField( 'order', 'SFInt32', 1, 3)
+    controlPoint = field.newField( 'controlPoint', 'MFVec3f', 1, list)
+    color = field.newField( 'color', 'MFColor', 1, list)
+    weight = field.newField( 'weight', 'MFFloat32', 1, list)
+    tessellation = field.newField( 'tessellation', 'SFInt32', 1, 0)
+
+class NurbsSurface( nodetypes.Geometry, node.Node ):
+    """A Nurbs surface object"""
+    PROTO = "NurbsSurface"
+    uDimension = field.newField( 'uDimension', 'SFInt32', 1, 0)
+    vDimension = field.newField( 'vDimension', 'SFInt32', 1, 0)
+    uKnot = field.newField( 'uKnot', 'MFFloat32', 1, list)
+    vKnot = field.newField( 'vKnot', 'MFFloat32', 1, list)
+    uOrder = field.newField( 'uOrder', 'SFInt32', 1, 3)
+    vOrder = field.newField( 'vOrder', 'SFInt32', 1, 3)
+    controlPoint = field.newField( 'controlPoint', 'MFVec3f', 1, list)
+    color = field.newField( 'color', 'MFColor', 1, list)
+    weight = field.newField( 'weight', 'MFFloat32', 1, list)
+    uTessellation = field.newField( 'uTessellation', 'SFInt32', 1, 0)
+    vTessellation = field.newField( 'vTessellation', 'SFInt32', 1, 0)
+    texCoord = field.newField( 'texCoord', 'SFNode', 1, node.NULL)
+    solid = field.newField( 'solid', 'SFBool', 0, 1)
+    ccw = field.newField( 'ccw', 'SFBool', 0, 1)
+
+class TrimmedSurface( nodetypes.Geometry, node.Node ):
+    """A trimmed Nurbs surface object"""
+    PROTO = "TrimmedSurface"
+    trimmingContour = field.newField( 'trimmingContour', 'MFNode', 1, list)
+    surface = field.newField( 'surface', 'SFNode', 1, node.NULL)
+
+### Unused...
+class NurbsGroup( node.Node ):
+    """(Unused) holder for multiple nurbs objects"""
+    PROTO = "NurbsGroup"
+    children = field.newField( 'children', 'MFNode', 1, list)
+    tessellationScale = field.newField( 'tessellationScale', 'SFFloat', 1, 1.0)
+    bboxSize = field.newField( 'bboxSize', 'SFVec3f', 0, [-1.0, -1.0, -1.0])
+    bboxCenter = field.newField( 'bboxCenter', 'SFVec3f', 0, [0.0, 0.0, 0.0])
+