pfDoubleFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfDoubleFCS - Create, modify, and query double-precision flux coordinate
system nodes.
FUNCTION SPECIFICATION
#include <Performer/pf/pfDoubleFCS.h>
pfDoubleFCS::pfDoubleFCS(pfFlux *flux);
static pfType * pfDoubleFCS::getClassType(void);
void pfDoubleFCS::setFlux(pfFlux *flux);
pfFlux* pfDoubleFCS::getFlux(void);
void pfDoubleFCS::getMat(pfMatrix4d &m);
const pfMatrix4d* pfDoubleFCS::getMatPtr(void);
void pfDoubleFCS::setMatType(uint val);
uint pfDoubleFCS::getMatType();
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfDoubleFCS is derived from the parent class
pfDoubleSCS, so each of these member functions of class pfDoubleSCS are
also directly usable with objects of class pfDoubleFCS. This is also
true for ancestor classes of class pfDoubleSCS.
void pfDoubleSCS::getMat(pfMatrix4d &mat);
const pfMatrix4d* pfDoubleSCS::getMatPtr(void);
Since the class pfDoubleSCS is itself derived from the parent class
pfGroup, objects of class pfDoubleFCS can also be used with these
functions designed for objects of class pfGroup.
int pfGroup::addChild(pfNode *child);
int pfGroup::insertChild(int index, pfNode *child);
int pfGroup::replaceChild(pfNode *old, pfNode *new);
int pfGroup::removeChild(pfNode* child);
int pfGroup::searchChild(pfNode* child);
pfNode * pfGroup::getChild(int index);
int pfGroup::getNumChildren(void);
int pfGroup::bufferAddChild(pfNode *child);
int pfGroup::bufferRemoveChild(pfNode *child);
Since the class pfGroup is itself derived from the parent class pfNode,
objects of class pfDoubleFCS can also be used with these functions
designed for objects of class pfNode.
Page 1
pfDoubleFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
pfGroup * pfNode::getParent(int i);
int pfNode::getNumParents(void);
void pfNode::setBound(pfSphere *bsph, int mode);
int pfNode::getBound(pfSphere *bsph);
pfNode* pfNode::clone(int mode);
pfNode* pfNode::bufferClone(int mode, pfBuffer *buf);
int pfNode::flatten(int mode);
int pfNode::setName(const char *name);
const char * pfNode::getName(void);
pfNode* pfNode::find(const char *pathName, pfType *type);
pfNode* pfNode::lookup(const char *name, pfType* type);
int pfNode::isect(pfSegSet *segSet, pfHit **hits[]);
void pfNode::setTravMask(int which, uint mask, int setMode,
int bitOp);
uint pfNode::getTravMask(int which);
void pfNode::setTravFuncs(int which, pfNodeTravFuncType pre,
pfNodeTravFuncType post);
void pfNode::getTravFuncs(int which, pfNodeTravFuncType *pre,
pfNodeTravFuncType *post);
void pfNode::setTravData(int which, void *data);
void * pfNode::getTravData(int which);
void pfNode::setTravMode(int which, int mode, int val);
int pfNode::getTravMode(int which, int mode) const;
Since the class pfNode is itself derived from the parent class pfObject,
objects of class pfDoubleFCS can also be used with these functions
designed for objects of class pfObject.
void* pfObject::operator new(size_t);
void* pfObject::operator new(size_t, pfFluxMemory *fmem);
void pfObject::setUserData(void *data);
void pfObject::setUserData(int slot, void *data);
void* pfObject::getUserData(pfObject *obj);
void* pfObject::getUserData(pfObject *obj, int slot);
int pfObject::getNumUserData();
Since the class pfObject is itself derived from the parent class
pfMemory, objects of class pfDoubleFCS can also be used with these
functions designed for objects of class pfMemory.
void* pfMemory::getData(const void *ptr);
pfType * pfMemory::getType();
int pfMemory::isOfType(pfType *type);
int pfMemory::isExactType(pfType *type);
const char * pfMemory::getTypeName();
int pfMemory::copy(pfMemory *src);
int pfMemory::compare(const pfMemory *mem);
void pfMemory::print(uint which, uint verbose, char *prefix,
FILE *file);
Page 2
pfDoubleFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
int pfMemory::getArena(void *ptr);
void* pfMemory::getArena();
int pfMemory::ref();
int pfMemory::unref();
int pfMemory::unrefDelete();
int pfMemory::unrefGetRef();
int pfMemory::getRef();
int pfMemory::checkDelete();
int pfMemory::isFluxed();
void * pfMemory::getArena();
int pfMemory::getSize();
DESCRIPTION
A pfDoubleFCS (Double-precision Flux Coordinate System) is a pfDoubleSCS
whose matrix is contained in a pfFlux. A pfDoubleFCS is similar to a
pfDoubleDCS, in that its matrix can change, but since its matrix is
contained in a pfFlux, it can be animated using pfEngines.
new pfDoubleFCS creates and returns a handle to a pfDoubleFCS. The
matrix of a the new pfDoubleFCS will be contained in flux. Like other
pfNodes, pfDoubleFCSes are always allocated from shared memory and cannot
be created statically, on the stack or in arrays. pfDoubleFCSes should
be deleted using pfDelete rather than the delete operator.
pfDoubleFCS::getClassType returns the pfType* for the class pfDoubleFCS.
The pfType* returned by pfDoubleFCS::getClassType is the same as the
pfType* returned by invoking the virtual function getType on any instance
of class pfDoubleFCS. Because OpenGL Performer allows subclassing of
built-in types, when decisions are made based on the type of an object,
it is usually better to use the member function isOfType to test if an
object is of a type derived from a Performer type rather than to test for
strict equality of the pfType*'s.
pfDoubleFCS::setFlux attaches a pfFlux to a pDoubleFCS.
pfDoubleFCS::getFlux returns the pfFlux currently attached to a
pfDoubleFCS.
pfDoubleFCS::setMatType allows the specification of information about the
type of transformation the matrix represents. This information allows
Performer to speed up some operations. The matrix type is specified as
the OR of
PFMAT_TRANS:
matrix may include a translational component in the 4th row.
PFMAT_ROT
matrix may include a rotational component in the left upper 3X3
submatrix.
Page 3
pfDoubleFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
PFMAT_SCALE
matrix may include a uniform scale in the left upper 3X3
submatrix.
PFMAT_NONORTHO
matrix may include a non-uniform scale in the left upper 3X3
submatrix.
PFMAT_PROJ
matrix may include projections.
PFMAT_HOM_SCALE
matrix may have mat[4][4] != 1.
PFMAT_MIRROR
matrix may include mirroring transformation that switches
between right handed and left handed coordinate systems.
pfDoubleFCS::getMatType returns the matrix type as
set by pfDoubleFCS::setMatType. If no matrix type is set the
default is ~0, corresponding to a general matrix.
The transformation of a pfDoubleFCS affects all its children. As
the hierarchy is traversed from top to bottom, each new matrix is
pre-multiplied to create the new transformation. For example, if
DoubleFCSb is below DoubleFCSa in the scene graph, any geometry G
below DoubleFCSa is transformed as G*DoubleFCSb*DoubleFCSa.
pfNode::flatten cannot flatten pfDoubleFCSes since they may change
at run-time. In this case pfNode::flatten will compute a
pfDoubleSCS representing the accumulated static transformation that
the pfDoubleFCS inherits and insert it above the pfDoubleFCS.
Static transformations below a pfDoubleFCS are flattened as usual.
See pfNode::flatten for more details.
The presence of transformations in the scene graph impacts the
performance of intersection, culling and drawing. pfGeoSet culling
(see PFCULL_GSET in pfChannel::setTravMode) is disabled in portions
of the scene graph below pfDoubleFCSes.
Both pre and post CULL and DRAW callbacks attached to a pfDoubleFCS
(pfNode::setTravFuncs) will be affected by the transformation
represented by the pfDoubleFCS, i.e. - the pfDoubleFCS matrix will
already have been applied to the matrix stack before the pre
callback is called and will be popped only after the post callback
is called.
pfDoubleFCS::getMat copies the transformation matrix value from the
pfDoubleFCS into the matrix m. For faster matrix access,
pfDoubleFCS::getMatPtr can be used to get a const pointer to the
pfDoubleFCS's matrix.
Page 4
pfDoubleFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
SEE ALSO
pfFlux, pfEngine, pfGroup, pfChannel, pfLookupNode, pfFlatten,
pfMatrix4d, pfNode, pfDoubleSCS, pfDoubleDCS, pfScene, pfTraverser,
pfDelete
Page 5
