pfFrenetSweptSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfFrenetSweptSurface - A Frenet swept surface
FUNCTION SPECIFICATION
#include <Performer/pf/pfFrenetSweptSurface.h>
static pfType * pfFrenetSweptSurface::getClassType(void);
pfFrenetSweptSurface::pfFrenetSweptSurface();
-
pfFrenetSweptSurface::pfFrenetSweptSrface(pfCurve3d *crossSection,
pfCurve3d *path, pfScalar *profile);
void pfFrenetSweptSurface::set(pfCurve3d *crossSection,
pfCurve3d *path, pfScalar *profile);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfFrenetSweptSurface is derived from the
parent class pfSweptSurface, so each of these member functions of class
pfSweptSurface are also directly usable with objects of class
pfFrenetSweptSurface. This is also true for ancestor classes of class
pfSweptSurface.
void pfSweptSurface::setCrossSection(pfCurve3d *crossSection);
void pfSweptSurface::setPath(pfCurve3d *path);
void pfSweptSurface::setT(pfCurve3d *tng);
void pfSweptSurface::setB(pfCurve3d *b);
void pfSweptSurface::setProf(pfScalar *profile);
pfCurve3d* pfSweptSurface::getCrossSection() const;
pfCurve3d* pfSweptSurface::getPath() const;
pfCurve3d* pfSweptSurface::getT() const;
pfCurve3d* pfSweptSurface::getB() const;
pfScalar* pfSweptSurface::getProf() const;
void pfSweptSurface::evalPt(pfReal u, pfReal v, pfVec3& pnt);
Since the class pfSweptSurface is itself derived from the parent class
pfParaSurface, objects of class pfFrenetSweptSurface can also be used
with these functions designed for objects of class pfParaSurface.
void pfParaSurface::setBeginU(pfReal u);
void pfParaSurface::setEndU(pfReal u);
void pfParaSurface::setBeginV(pfReal v);
void pfParaSurface::setEndV(pfReal v);
void pfParaSurface::setSolidId(int solidId);
void pfParaSurface::setTopoId(int topoId);
void pfParaSurface::setSurfaceId(int surfaceId);
pfReal pfParaSurface::getBeginU(pfParaSurface* surf);
pfReal pfParaSurface::getEndU(pfParaSurface* surf);
Page 1
pfFrenetSweptSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
pfReal pfParaSurface::getBeginV(pfParaSurface* surf);
pfReal pfParaSurface::getEndV(pfParaSurface* surf);
int pfParaSurface::getTrimLoopCount(pfParaSurface* surf);
pfLoop pfParaSurface::getTrimLoopClosed(int loopNum);
int pfParaSurface::getTrimCurveCount(int loopNum);
pfEdge* pfParaSurface::getTrimCurve(int loopNum, int curveNum);
pfTopo* pfParaSurface::getTopo();
int pfParaSurface::getTopoId();
int pfParaSurface::getSolidId();
int pfParaSurface::getSurfaceId();
void pfParaSurface::getHandednessHint(pfBool _clockWise);
pfBool pfParaSurface::getHandednessHint();
void pfParaSurface::insertTrimCurve(int loopNum, pfCurve2d *c,
pfDisCurve2d *d);
void pfParaSurface::addTrimCurve(int loopNum, pfCurve2d *c,
pfDisCurve2d *d);
void pfParaSurface::setTrimLoopClosed(int loopNum,
pfLoop closed);
void pfParaSurface::evalPt(pfReal u, pfReal v, pfVec3& pnt);
void pfParaSurface::evalDu(pfReal u, pfReal v, pfVec3& Du);
void pfParaSurface::evalDv(pfReal u, pfReal v, pfVec3& Dv);
void pfParaSurface::evalDuu(pfReal u, pfReal v, pfVec3& Duu);
void pfParaSurface::evalDvv(pfReal u, pfReal v, pfVec3& Dvv);
void pfParaSurface::evalDuv(pfReal u, pfReal v, pfVec3& Duv);
void pfParaSurface::evalNorm(pfReal u, pfReal v, pfVec3& norm);
void pfParaSurface::evalD(pfReal u, pfReal v, pfReal theta,
pfVec3& D);
void pfParaSurface::evalDD(pfReal u, pfReal v, pfReal theta,
pfVec3& DD);
int pfParaSurface::setGState(pfGeoState *gState);
pfGeoState* pfParaSurface::getGState();
void pfParaSurface::clearTessellation();
Since the class pfParaSurface is itself derived from the parent class
pfGeode, objects of class pfFrenetSweptSurface can also be used with
these functions designed for objects of class pfGeode.
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 pfGeode is itself derived from the parent class pfGeode,
objects of class pfFrenetSweptSurface can also be used with these
functions designed for objects of class pfGeode.
int pfGeode::addGSet(pfGeoSet* gset);
int pfGeode::removeGSet(pfGeoSet* gset);
Page 2
pfFrenetSweptSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfFrenetSweptSurface 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 pfFrenetSweptSurface 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 pfFrenetSweptSurface can also be used with
these functions designed for objects of class pfMemory.
Page 3
pfFrenetSweptSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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();
DESCRIPTION
A Frenet swept surface is a special type of swept surface. A general
swept surface is defined in pfFrenetSweptSurface. A Frenet swept surface
uses the tangent and binormal path(u) as t and b which are the inherited
members from the superclass pfSweptSurface and are used to generate the
frame matrix of the swept surface.
pfFrenetSweptSurface::getClassType returns the pfType* for the class
pfFrenetSweptSurface. The pfType* returned by
pfFrenetSweptSurface::getClassType is the same as the pfType* returned by
invoking the virtual function getType on any instance of class
pfFrenetSweptSurface. 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.
pfFrenetSweptSurface::pfFrenetSweptSurface creates an instance of
pfFrenetSweptSurface. No valid data is set.
pfFrenetSweptSurface::pfFrenetSweptSurface(pfCurve3d
*crossSection,pfCurve33d *path,pfScalar *profile) creates an instance of
a pfFrenetSweptSurface creates an instance of a pfFrenetSweptSurface with
inherited members crossSection, path and profile set to the arguments
crossSection, path and profile respectively. The inherited t is set to
the tangent path and the inherited member b is set to the binormal of
path. Since t and b are both represented as 3d curves (pfCurve3d), data
structures are created for them.
pfFrenetSweptSurface::set Sets the 3 inherited members. The inherited
member t is set to the tangent path of path and the inherited member b is
Page 4
pfFrenetSweptSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
set to the binormal of path. Since t and b are both represented as 3d
curves (pfCurve3d), data structures are created for them. See the
Programmer's Guide for additional information.
SEE ALSO
pfRep, pfGeode, pfParaSurface, pfCurve3d, pfScalar, pfSweptSurface
Page 5
