pfFCS(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages pfFCS(3pf)NAME
pfNewFCS, pfGetFCSClassType, pfFCSFlux, pfGetFCSFlux, pfGetFCSMat,
pfGetFCSMatPtr, pfFCSMatType, pfGetFCSMatType - Create, modify, and query
flux coordinate system nodes.
FUNCTION SPECIFICATION
#include <Performer/pf.h>
pfFCS * pfNewFCS(pfFlux *flux);
pfType * pfGetFCSClassType(void);
void pfFCSFlux(pfFCS* fcs, pfFlux *flux);
pfFlux* pfGetFCSFlux(pfFCS* fcs);
void pfGetFCSMat(pfFCS *fcs, pfMatrix m);
const pfMatrix* pfGetFCSMatPtr(pfFCS *fcs);
void pfFCSMatType(pfFCS *fcs, uint val);
uint pfGetFCSMatType(pfFCS *fcs);
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. Casting an object of class pfFCS to an
object of class pfSCS is taken care of automatically. This is also true
for casts to objects of ancestor classes of class pfSCS.
void pfGetSCSMat(pfSCS *scs, pfMatrix mat);
const pfMatrix* pfGetSCSMatPtr(pfSCS *scs);
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 pfAddChild(pfGroup *group, pfNode *child);
int pfInsertChild(pfGroup *group, int index, pfNode *child);
int pfReplaceChild(pfGroup *group, pfNode *old, pfNode *new);
int pfRemoveChild(pfGroup *group, pfNode* child);
int pfSearchChild(pfGroup *group, pfNode* child);
pfNode * pfGetChild(const pfGroup *group, int index);
int pfGetNumChildren(const pfGroup *group);
int pfBufferAddChild(pfGroup *group, pfNode *child);
int pfBufferRemoveChild(pfGroup *group, pfNode *child);
Page 1
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages pfFCS(3pf)
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.
pfGroup * pfGetParent(const pfNode *node, int i);
int pfGetNumParents(const pfNode *node);
void pfNodeBSphere(pfNode *node, pfSphere *bsph, int mode);
int pfGetNodeBSphere(pfNode *node, pfSphere *bsph);
pfNode* pfClone(pfNode *node, int mode);
pfNode* pfBufferClone(pfNode *node, int mode, pfBuffer *buf);
int pfFlatten(pfNode *node, int mode);
int pfNodeName(pfNode *node, const char *name);
const char * pfGetNodeName(const pfNode *node);
pfNode* pfFindNode(pfNode *node, const char *pathName,
pfType *type);
pfNode* pfLookupNode(const char *name, pfType* type);
int pfNodeIsectSegs(pfNode *node, pfSegSet *segSet,
pfHit **hits[]);
void pfNodeTravMask(pfNode *node, int which, uint mask,
int setMode, int bitOp);
uint pfGetNodeTravMask(const pfNode *node, int which);
void pfNodeTravFuncs(pfNode* node, int which,
pfNodeTravFuncType pre, pfNodeTravFuncType post);
void pfGetNodeTravFuncs(const pfNode* node, int which,
pfNodeTravFuncType *pre, pfNodeTravFuncType *post);
void pfNodeTravData(pfNode *node, int which, void *data);
void * pfGetNodeTravData(const pfNode *node, int which);
void pfNodeTravMode(pfNode* node, int which, int mode,
int val);
int pfGetNodeTravMode(const pfNode* node, int which,
int mode);
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 pfUserDataSlot(pfObject *obj, int slot, void *data);
void pfUserData(pfObject *obj, void *data);
void* pfGetUserDataSlot(pfObject *obj, int slot);
void* pfGetUserData(pfObject *obj);
int pfGetNumUserData(pfObject *obj);
int pfGetNamedUserDataSlot(const char *name);
const char* pfGetUserDataSlotName(int slot);
int pfGetNumNamedUserDataSlots(void);
int pfDeleteGLHandle(pfObject *obj);
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.
Page 2
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages pfFCS(3pf)
pfType * pfGetType(const void *ptr);
int pfIsOfType(const void *ptr, pfType *type);
int pfIsExactType(const void *ptr, pfType *type);
const char * pfGetTypeName(const void *ptr);
int pfRef(void *ptr);
int pfUnref(void *ptr);
int pfUnrefDelete(void *ptr);
int pfUnrefGetRef(void *ptr);
int pfGetRef(const void *ptr);
int pfCopy(void *dst, void *src);
int pfDelete(void *ptr);
int pfIsFluxed(void *ptr);
int pfCompare(const void *ptr1, const void *ptr2);
void pfPrint(const void *ptr, uint which, uint verbose,
FILE *file);
void * pfGetArena(void *ptr);
PARAMETERS
fcs identifies a pfFCS
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.
pfNewFCS 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 can be deleted using pfDelete.
pfGetFCSClassType returns the pfType* for the class pfFCS. The pfType*
returned by pfGetFCSClassType is the same as the pfType* returned by
invoking pfGetType 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 pfIsOfType 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.
pfFCSFlux attaches a pfFlux to a pFCS.
pfGetFCSFlux returns the pfFlux currently attached to a pfFCS.
pfFCSMatType 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.
Page 3
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages pfFCS(3pf)
PFMAT_ROT
matrix may include a rotational component in the left upper 3X3
submatrix.
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.
pfGetFCSMatType returns the matrix type as
set by pfFCSMatType. 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.
pfFlatten cannot flatten pfFCSes since they may change at run-time.
In this case pfFlatten 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 pfFlatten 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 pfChanTravMode) is disabled in portions of the
scene graph below pfFCSes.
Both pre and post CULL and DRAW callbacks attached to a pfFCS (-
pfNodeTravFuncs) 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.
pfGetFCSMat copies the transformation matrix value from fcs into the
matrix m. For faster matrix access, pfGetFCSMatPtr can be used to
get a const pointer to fcs's matrix.
Page 4
pfFCS(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages pfFCS(3pf)SEE ALSO
pfFlux, pfEngine, pfGroup, pfChanTravMode, pfLookupNode, pfFlatten,
pfMatrix, pfNode, pfSCS, pfScene, pfTraverser, pfDelete
Page 5
