pfSequence(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfSequence - Control animation sequence nodes.
FUNCTION SPECIFICATION
#include <Performer/pf/pfSequence.h>
pfSequence::pfSequence();
static pfType * pfSequence::getClassType(void);
void pfSequence::setTime(int frame, double time);
double pfSequence::getTime(int frame);
void pfSequence::setInterval(int mode, int begin, int end);
void pfSequence::getInterval(int *mode, int *begin,
int *end);
void pfSequence::setDuration(float speed, int nReps);
void pfSequence::getDuration(float *speed, int *nReps);
void pfSequence::setMode(int mode);
int pfSequence::getMode(void);
int pfSequence::getFrame(int *repeat);
void pfSequence::setEvaluation(int state);
int pfSequence::getEvaluation(void);
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. This is also true for
ancestor classes 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);
Page 1
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 * 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 pfSequence 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 pfSequence 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);
Page 2
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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);
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 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. new pfSequence creates and returns a handle to a
pfSequence. Like other pfNodes, pfSequences are always allocated from
shared memory and cannot be created statically, on the stack or in
arrays. pfSequences should be deleted using pfDelete rather than the
delete operator.
pfSequence::getClassType returns the pfType* for the class pfSequence.
The pfType* returned by pfSequence::getClassType is the same as the
pfType* returned by invoking the virtual function getType 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 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.
Children are added to a pfSequence using normal pfGroup API (-
pfGroup::addChild). The length of time that a child is drawn is
specified by pfSequence::setTime. 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 pfSequence::setMode below).
pfSequence::getTime returns the time for frame frame.
pfSequence::setInterval specifies the interval or range of frames
(children) to sequence. begin and end specify the beginning and ending
indexes of the pfSequence 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.
Page 3
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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. pfSequence::getInterval copies the
interval parameters into mode, begin, and end.
pfSequence::setDuration 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
pfSequence::setInterval.
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. pfSequence::getDuration copies the
duration parameters into speed and nReps.
pfSequence::setMode controls the run-time execution of the pfSequence.
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.
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.
Page 4
pfSequence(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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. pfSequence::setEvaluation enables adding/removing a pfSequence
to/from the global Performer list of sequences.
pfSequence::getEvaluation returns TRUE if the sequence is in the global
list.
pfSequence::getMode returns the mode of the pfSequence. The mode will
automatically be set to PFSEQ_STOP if the sequence completes the number
of repetitions set by pfSequence::setDuration.
pfSequence::getFrame returns the index of the child which the pfSequence
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
