pfFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfFCS(3pf)NAMEpfFCS - Create, modify, and query flux coordinate system nodes.
FUNCTION SPECIFICATION
#include <Performer/pf/pfFCS.h>
pfFCS::pfFCS(pfFlux *flux);
static pfType * pfFCS::getClassType(void);
void pfFCS::setFlux(pfFlux *flux);
pfFlux* pfFCS::getFlux(void);
void pfFCS::getMat(pfMatrix &m);
const pfMatrix* pfFCS::getMatPtr(void);
void pfFCS::setMatType(uint val);
uint pfFCS::getMatType();
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfFCS is derived from the parent class pfSCS,
so each of these member functions of class pfSCS are also directly usable
with objects of class pfFCS. This is also true for ancestor classes of
class pfSCS.
void pfSCS::getMat(pfMatrix &mat);
const pfMatrix* pfSCS::getMatPtr(void);
Since the class pfSCS is itself derived from the parent class pfGroup,
objects of class pfFCS 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 pfFCS can also be used with these functions designed for
objects of class pfNode.
Page 1
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfFCS(3pf)
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 pfFCS 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 pfFCS 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
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfFCS(3pf)
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 pfFCS (Flux Coordinate System) is a pfSCS whose matrix is contained in
a pfFlux. A pfFCS is similar to a pfDCS, in that its matrix can change,
but since its matrix is contained in a pfFlux, it can be animated using
pfEngines.
new pfFCS creates and returns a handle to a pfFCS. The matrix of a the
new pfFCS will be contained in flux. Like other pfNodes, pfFCSes are
always allocated from shared memory and cannot be created statically, on
the stack or in arrays. pfFCSes should be deleted using pfDelete rather
than the delete operator.
pfFCS::getClassType returns the pfType* for the class pfFCS. The pfType*
returned by pfFCS::getClassType is the same as the pfType* returned by
invoking the virtual function getType on any instance of class pfFCS.
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.
pfFCS::setFlux attaches a pfFlux to a pFCS.
pfFCS::getFlux returns the pfFlux currently attached to a pfFCS.
pfFCS::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
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfFCS(3pf)
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.
pfFCS::getMatType returns the matrix type as
set by pfFCS::setMatType. If no matrix type is set the default is
~0, corresponding to a general matrix.
The transformation of a pfFCS 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 FCSb
is below FCSa in the scene graph, any geometry G below FCSa is
transformed as G*FCSb*FCSa.
pfNode::flatten cannot flatten pfFCSes since they may change at
run-time. In this case pfNode::flatten will compute a pfSCS
representing the accumulated static transformation that the pfFCS
inherits and insert it above the pfFCS. Static transformations
below a pfFCS 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 pfFCSes.
Both pre and post CULL and DRAW callbacks attached to a pfFCS (-
pfNode::setTravFuncs) will be affected by the transformation
represented by the pfFCS, i.e. - the pfFCS 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.
pfFCS::getMat copies the transformation matrix value from the pfFCS
into the matrix m. For faster matrix access, pfFCS::getMatPtr can
be used to get a const pointer to the pfFCS's matrix.
Page 4
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfFCS(3pf)SEE ALSO
pfFlux, pfEngine, pfGroup, pfChannel, pfLookupNode, pfFlatten, pfMatrix,
pfNode, pfSCS, pfScene, pfTraverser, pfDelete
Page 5
