OpenGLContext.scenegraph.nodepath
index
/home/mcfletch/pylive/OpenGLContext/scenegraph/nodepath.py

node-path implementation for OpenGLContext

 
Modules
       
vrml.vrml97.nodepath
vrml.vrml97.nodetypes
OpenGLContext.quaternion

 
Classes
       
object
_NodePath
NodePath(_NodePath, NodePath)
WeakNodePath(_NodePath, WeakNodePath)

 
class NodePath(_NodePath, NodePath)
    
Method resolution order:
NodePath
_NodePath
NodePath
_NodePath
NodePath
list
object

Methods inherited from _NodePath:
quaternion(self)
Get summary quaternion for all rotations in stack
transform(self, mode=None, translate=1, scale=1, rotate=1)
For each Transforming node, do OpenGL transform
 
Does _not_ push-pop matrices, so do that before
if you want to save your current matrix.  This method
is useful primarily for storing paths to, for instance,
bindable nodes, where you want to be able to rapidly
transform down to the node, without needing a full
traversal of the scenegraph.

Methods inherited from _NodePath:
__add__(self, other)
Add parent-matrix pre-caching support to nodepaths
invalidate(self)
Set this path to be invalid (and all children paths)
isTransform(self, item)
Customization Point: determine whether a node is a Transform
iterchildren(self)
Iterate over child paths which are still live
iterdescendents(self)
Iterate over all descendent paths
itransformMatrix(self)
Manually generate an inverse transform matrix for this path
 
See transformMatrix for semantics
transformChildren(self, reverse=0)
Yield all transforming children
transformMatrix(self, translate=True, scale=True, rotate=True, matrixHolder=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.

Data descriptors inherited from _NodePath:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from _NodePath:
active = True
broken = False
children = None
parent = None

Methods inherited from NodePath:
__eq__(self, other)
Check whether we are equal to another path
__getslice__(self, start, stop)
Return a new path with our items from start to stop
__repr__(self)
Code-like representation of the node path
 
Note: this doesn't use super for determining
the base representation, as that might wind up
creating a name like:
    WeakNodePath( WeakTuple( Node, Node,...))
__str__(self)
Simple representation of a node-path for human consumption
common(self, other)
Return the common root sub-path between ourselves and other
 
If there is no common sub-root, returns an empty path

Methods inherited from list:
__contains__(...)
x.__contains__(y) <==> y in x
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__iadd__(...)
x.__iadd__(y) <==> x+=y
__imul__(...)
x.__imul__(y) <==> x*=y
__init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
__iter__(...)
x.__iter__() <==> iter(x)
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(...)
x.__rmul__(n) <==> n*x
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
__setslice__(...)
x.__setslice__(i, j, y) <==> x[i:j]=y
 
Use  of negative indices is not supported.
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
append(...)
L.append(object) -- append object to end
count(...)
L.count(value) -> integer -- return number of occurrences of value
extend(...)
L.extend(iterable) -- extend list by appending elements from the iterable
index(...)
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
insert(...)
L.insert(indexobject) -- insert object before index
pop(...)
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
remove(...)
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
reverse(...)
L.reverse() -- reverse *IN PLACE*
sort(...)
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1

Data and other attributes inherited from list:
__hash__ = None
__new__ = <built-in method __new__ of type object at 0x8187c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class WeakNodePath(_NodePath, WeakNodePath)
    
Method resolution order:
WeakNodePath
_NodePath
WeakNodePath
_NodePath
WeakNodePath
NodePath
WeakList
list
object

Methods inherited from _NodePath:
quaternion(self)
Get summary quaternion for all rotations in stack
transform(self, mode=None, translate=1, scale=1, rotate=1)
For each Transforming node, do OpenGL transform
 
Does _not_ push-pop matrices, so do that before
if you want to save your current matrix.  This method
is useful primarily for storing paths to, for instance,
bindable nodes, where you want to be able to rapidly
transform down to the node, without needing a full
traversal of the scenegraph.

Methods inherited from _NodePath:
__add__(self, other)
Add parent-matrix pre-caching support to nodepaths
invalidate(self)
Set this path to be invalid (and all children paths)
isTransform(self, item)
Customization Point: determine whether a node is a Transform
iterchildren(self)
Iterate over child paths which are still live
iterdescendents(self)
Iterate over all descendent paths
itransformMatrix(self)
Manually generate an inverse transform matrix for this path
 
See transformMatrix for semantics
transformChildren(self, reverse=0)
Yield all transforming children
transformMatrix(self, translate=True, scale=True, rotate=True, matrixHolder=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.

Data descriptors inherited from _NodePath:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from _NodePath:
active = True
broken = False
children = None
parent = None

Methods inherited from NodePath:
__eq__(self, other)
Check whether we are equal to another path
__getslice__(self, start, stop)
Return a new path with our items from start to stop
__repr__(self)
Code-like representation of the node path
 
Note: this doesn't use super for determining
the base representation, as that might wind up
creating a name like:
    WeakNodePath( WeakTuple( Node, Node,...))
__str__(self)
Simple representation of a node-path for human consumption
common(self, other)
Return the common root sub-path between ourselves and other
 
If there is no common sub-root, returns an empty path

Methods inherited from WeakList:
__contains__(self, item)
Return boolean indicating whether the item is in the list
__ge__(self, sequence)
Compare the list to another (>=)
__getitem__(self, index)
Get the item at the given index
__gt__(self, sequence)
Compare the list to another (>)
__iadd__ = extend(self, sequence)
Extend this list with another sequence
__init__(self, sequence=())
Initialize the list, with an optional sequence of objects
 
The WeakList will store weak references to objects
within the sequence.
__iter__(self)
Iterate over the list, yielding strong references
__le__(self, sequence)
Compare the list to another (<=)
__lt__(self, sequence)
Compare the list to another (<)
__ne__(self, sequence)
Compare the list to another (!=)
__setitem__(self, index, item)
Set the item at the given index
__setslice__(self, start, stop, sequence)
Set a sequence of items from the start to the stop index
append(self, item)
Append a single item to the list
count(self, item)
Return integer count of instances of item in list
extend(self, sequence)
Extend this list with another sequence
get(self)
Get all items as a list of strong references
index(self, item)
Return integer index of item in list
insert(self, index, item)
Insert an item at the given index
pop(self, index=-1)
Pop an item from the list, removing it and returning it
remove(self, item)
Remove the given item from the list
sort(self, function=None)
Sort the list of objects
 
This sorts the objects referenced,
then rebuilds the list of references!
unwrap(self, item)
Unwrap an individual item
 
This is a fairly trivial operation at the moment,
it merely calls the item with no arguments and
returns the result.
wrap(self, item)
Wrap an individual item in a weak-reference
 
If the item is already a weak reference, we store
a reference to the original item.  We use approximately
the same weak reference callback mechanism as the
standard weakref.WeakKeyDictionary object.

Methods inherited from list:
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__imul__(...)
x.__imul__(y) <==> x*=y
__len__(...)
x.__len__() <==> len(x)
__mul__(...)
x.__mul__(n) <==> x*n
__reversed__(...)
L.__reversed__() -- return a reverse iterator over the list
__rmul__(...)
x.__rmul__(n) <==> n*x
__sizeof__(...)
L.__sizeof__() -- size of L in memory, in bytes
reverse(...)
L.reverse() -- reverse *IN PLACE*

Data and other attributes inherited from list:
__hash__ = None
__new__ = <built-in method __new__ of type object at 0x8187c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

 
class _NodePath(object)
    OpenGLContext-specific node-path class
 
At the moment this only adds a single method,
transform() which traverses the path, calling
transform() for each Transforming node which
has a transform method.
 
  Methods defined here:
quaternion(self)
Get summary quaternion for all rotations in stack
transform(self, mode=None, translate=1, scale=1, rotate=1)
For each Transforming node, do OpenGL transform
 
Does _not_ push-pop matrices, so do that before
if you want to save your current matrix.  This method
is useful primarily for storing paths to, for instance,
bindable nodes, where you want to be able to rapidly
transform down to the node, without needing a full
traversal of the scenegraph.

 
Data
        CACHE = {}
__file__ = '/home/mcfletch/pylive/OpenGLContext/scenegraph/nodepath.pyc'
__name__ = 'OpenGLContext.scenegraph.nodepath'
__package__ = 'OpenGLContext.scenegraph'
glMultMatrixd = <OpenGL.wrapper.glMultMatrixd object at 0x259bb00>