pfSequence(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
NAME
pfNewSeq, pfGetSeqClassType, pfSeqTime, pfGetSeqTime, pfSeqInterval,
pfGetSeqInterval, pfSeqDuration, pfGetSeqDuration, pfSeqMode,
pfGetSeqMode, pfGetSeqFrame, pfSeqEvaluation, pfGetSeqEvaluation -
Control animation sequence nodes.
FUNCTION SPECIFICATION
#include <Performer/pf.h>
pfSequence * pfNewSeq(void);
pfType * pfGetSeqClassType(void);
void pfSeqTime(pfSequence *seq, int frame, double time);
double pfGetSeqTime(const pfSequence *seq, int frame);
void pfSeqInterval(pfSequence *seq, int mode, int begin,
int end);
void pfGetSeqInterval(const pfSequence *seq, int *mode,
int *begin, int *end);
void pfSeqDuration(pfSequence *seq, float speed, int nReps);
void pfGetSeqDuration(const pfSequence *seq, float *speed,
int *nReps);
void pfSeqMode(pfSequence *seq, int mode);
int pfGetSeqMode(const pfSequence *seq);
int pfGetSeqFrame(const pfSequence *seq, int *repeat);
void pfSeqEvaluation(const pfSequence *seq, int state);
int pfGetSeqEvaluation(const pfSequence *seq);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfSequence is derived from the parent class
pfGroup, so each of these member functions of class pfGroup are also
directly usable with objects of class pfSequence. Casting an object of
class pfSequence to an object of class pfGroup is taken care of
automatically. This is also true for casts to objects of ancestor
classes 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);
Page 1
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
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);
Since the class pfGroup is itself derived from the parent class pfNode,
objects of class pfSequence 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 pfSequence 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);
Page 2
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
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 pfSequence can also be used with these
functions designed for objects of class pfMemory.
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
seq identifies a pfSequence.
DESCRIPTION
A pfSequence is a pfGroup that sequences through a range of its children,
drawing each child for a certain length of time. Its primary use is for
animations, where a sequence of objects or geometry (children) represent
a desired visual event. pfNewSeq creates and returns a handle to a
pfSequence. Like other pfNodes, pfSequences are always allocated from
shared memory and can be deleted using pfDelete.
pfGetSeqClassType returns the pfType* for the class pfSequence. The
pfType* returned by pfGetSeqClassType is the same as the pfType* returned
by invoking pfGetType on any instance of class pfSequence. 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.
Children are added to a pfSequence using normal pfGroup API (pfAddChild).
The length of time that a child is drawn is specified by pfSeqTime.
frame is the index of a child that should be drawn for time seconds. If
frame < 0, then all children will be displayed for time seconds. If time
= 0.0 or time is not specified for a particular child, then it will not
be drawn at all. If time < 0.0 the sequence will pause at child frame
and draw it repeatedly until the sequence is resumed or stopped (see
Page 3
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
pfSeqMode below). pfGetSeqTime returns the time for frame frame.
pfSeqInterval specifies the interval or range of frames (children) to
sequence. begin and end specify the beginning and ending indexes of seq
respectively. Indexes are inclusive and should be in the range 0,
numChildren - 1. An index < 0 is equivalent to numChildren - 1 for
convenience. end may be less than begin for reverse sequences. The
default sequence interval is 0, numChildren - 1.
mode specifies how seq is sequenced over the range from begin to end if
it is a repeating sequence.
PFSEQ_CYCLE
seq will go from begin to end then restart at begin.
PFSEQ_SWING
seq will go back and forth from begin to end. The endpoint
frames are drawn only once when the swing changes directions.
The default mode is PFSEQ_CYCLE. pfGetSeqInterval copies the interval
parameters into mode, begin, and end.
pfSeqDuration controls the duration of an sequence. speed divides the
time that each sequence frame is displayed. Values < 1.0 slow down the
sequence while values > 1.0 speed up the sequence. The default speed is
1.0. nReps is the number of times seq repeats before stopping. If nReps
is < 0, seq will sequence indefinitely and if == 0 the sequence is
disabled. If nReps is > 1, seq will sequence for nReps cycles or swings
depending on the sequencing mode set by pfSeqInterval.
The number of repetitions for both PFSEQ_CYCLE and PFSEQ_SWING is
increased by 1 every time an endpoint of the sequence is reached.
Therefore PFSEQ_CYCLE begins to repeat itself after 1 repetition while
PFSEQ_SWING repeats itself after 2 repetitions. Note that for 1
repetition, both modes are equivalent.
The default value for nReps is 1. pfGetSeqDuration copies the duration
parameters into speed and nReps.
pfSeqMode controls the run-time execution of seq. mode is a symbolic
token:
PFSEQ_START
Restarts the sequence from its beginning. Once started, a
sequence may be stopped, paused, or started again in which case
it is restarted from its beginning.
PFSEQ_STOP
Stops the sequence. After an sequence is stopped, it is reset
so that further executions of the sequence begin from the
starting index.
Page 4
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
PFSEQ_PAUSE
Pauses the sequence without resetting it. When paused, the
current child will be drawn until the sequence is either
stopped or resumed.
PFSEQ_RESUME
Resumes a paused sequence.
Sequences are evaluated once per frame by pfAppFrame. The time used in
the evaluation is that set by pfFrameTimeStamp. This time is
automatically set by pfFrame but it may be overridden by the application
to account for varying latency due to non-constant frame rates.
By default, all sequences belong to a global Performer list of sequences.
All members of this list are considered for evaluation by pfAppFrame.
Only the active sequences are actually evaluated but looping through all
the sequences may be time consuming for scene graphs with many pfSequence
nodes. pfSeqEvaluation enables adding/removing a pfSequence to/from the
global Performer list of sequences. pfGetSeqEvaluation returns TRUE if
the sequence is in the global list.
pfGetSeqMode returns the mode of seq. The mode will automatically be set
to PFSEQ_STOP if the sequence completes the number of repetitions set by
pfSeqDuration.
pfGetSeqFrame returns the index of the child which seq is currently
drawing and also copies the number of repetitions it has completed into
repeat.
SEE ALSO
pfAppFrame, pfFrame, pfFrameTimeStamp, pfGroup, pfNode, pfDelete
Page 5
