pfCompositeCurve3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfCompositeCurve3d - A composite curve
FUNCTION SPECIFICATION
#include <Performer/pf/pfCompositeCurve3d.h>
static pfType* pfCompositeCurve3d::getClassType(void);
pfCompositeCurve3d::pfCompositeCurve3d();
-
pfCompositeCurve3d::pfCompositeCurve3d(pfParaSurface *sur,
pfCurve2d *cur);
void pfCompositeCurve3d::set(pfParaSurface *sur,
pfCurve2d *c);
pfParaSurface* pfCompositeCurve3d::getSurface();
pfCurve2d* pfCompositeCurve3d::getCurve2d();
void pfCompositeCurve3d::evalPt(pfReal t, pfVec3 &pnt);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfCompositeCurve3d is derived from the parent
class pfCurve3d, so each of these member functions of class pfCurve3d are
also directly usable with objects of class pfCompositeCurve3d. This is
also true for ancestor classes of class pfCurve3d.
pfReal pfCurve3d::getBeginT()
pfReal pfCurve3d::getEndT()
pfVec3 pfCurve3d::getBeginPt();
pfVec3 pfCurve3d::getEndPt();
pfVec3 pfCurve3d::getBeginTan();
pfVec3 pfCurve3d::getEndTan();
void pfCurve3d::setClosed(int loopVal);
int pfCurve3d::getClosed();
void pfCurve3d::setClosedTol(pfReal tol);
pfReal pfCurve3d::getClosedTol();
virtual void pfCurve3d::evalPt(pfReal t, pfVec3& pnt) = 0;
virtual void pfCurve3d::evalTan(pfReal t, pfVec3& pnt);
virtual void pfCurve3d::evalNorm(pfReal t, pfVec3& pnt);
virtual void pfCurve3d::evalCurv(pfReal t, pfReal& curv);
void pfCurve3d::eval(pfReal t, pfVec3 &pnt, pfVec3 &tan,
pfReal &curv, pfVec3 &norm)
Since the class pfCurve3d is itself derived from the parent class pfRep,
objects of class pfCompositeCurve3d can also be used with these functions
designed for objects of class pfRep.
Page 1
pfCompositeCurve3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
void pfRep::setOrigin(const pfVec3 *origin);
void pfRep::setOrient(const pfMatrix *mat);
void pfRep::getOrigin(pfVec3& origin);
void pfRep::getOrient(pfMatrix& matrix);
Since the class pfRep is itself derived from the parent class pfGeode,
objects of class pfCompositeCurve3d can also be used with these functions
designed for objects of class pfGeode.
int pfGeode::addGSet(pfGeoSet* gset);
int pfGeode::removeGSet(pfGeoSet* gset);
int pfGeode::insertGSet(int index, pfGeoSet* gset);
int pfGeode::replaceGSet(pfGeoSet* old, pfGeoSet* new);
pfGeoSet * pfGeode::getGSet(int index);
int pfGeode::getNumGSets(void);
Since the class pfGeode is itself derived from the parent class pfNode,
objects of class pfCompositeCurve3d 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 pfCompositeCurve3d can also be used with these functions
designed for objects of class pfObject.
Page 2
pfCompositeCurve3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfCompositeCurve3d 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);
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();
DESCRIPTIONpfCompositeCurve3d defines a 3D curve that consists of a parametric
surface in object space and a 2D curve in the domain space of the
surface. If we denote (x,y,z) = (x(u,v), y(u,v),z(u,v)) to be the
surface mapping, and (u,v) = (u(t), v(t)) to be the curve mapping, then
the composite curve is the mapping
x = x(u(t), v(t));
y = y(u(t), v(t));
z = z(u(t), v(t));
The default domain (the range of t) is the domain of the 2D curve.
pfCompositeCurve3d::getClassType returns the pfType* for the class
pfCompositeCurve3d. The pfType* returned by
pfCompositeCurve3d::getClassType is the same as the pfType* returned by
invoking the virtual function getType on any instance of class
pfCompositeCurve3d. Because OpenGL Performer allows subclassing of
Page 3
pfCompositeCurve3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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.
pfCompositeCurve3d::pfCompositeCurve3d() creates an instance of an
pfCompositeCurve3d. By default the parametric domain is defined as
[0..1]. No valid data is set.
pfCompositeCurve3d::pfCompositeCurve3d(pfParaSurface *sur,pfCurve2d *c)
Creates an instance of pfCompositeCurve3d. The surface sur is set to sur
and the curve cur is set to cur. Notice that only the pointers are
copied. The domain [beginT, endT], where both beginT and endT are
inherited members from its superclass pfCurve3d, is set to the domain of
cur. The inherited member "dt" (see pfCurve3d), which is used for
derivative computation using central difference, is also set.
pfCompositeCurve3d::set The surface sur is set to sur and the curve cur
is set to cur. Notice that the only the pointers are copied. The
domain [beginT, endT], where both beginT and endT are inherited members
from its superclass pfCurve3d, is set to the domain of cur.
pfCompositeCurve3d::getParaSurface returns the surface pointer.
pfCompositeCurve3d::getCurve2d returns the curve2d pointer.
pfCompositeCurve3d::evalPt Evaluates the line at parametric value t. The
evaluator performs linear extrapolation of the line when the values of t
are outside the domain of t1 and t2.
SEE ALSO
pfRep, pfGeode, pfCurve3d, pfCurve2d, pfParaSurface
Page 4
