pfCoonsSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfCoonsSurface - A parametric bilinear Coons Surface patch
FUNCTION SPECIFICATION
#include <Performer/pf/pfCoonsSurface.h>
static pfType * pfCoonsSurface::getClassType(void);
pfCoonsSurface::pfCoonsSurface();
pfCoonsSurface::pfCoonsSurface(pfCurve3d *right,
pfCurve3d *left, pfCurve3d *bottom,
pfCurve3d *top);
void pfCoonsSurface::setRight(pfCurve3d *right);
void pfCoonsSurface::setLeft(pfCurve3d *left);
void pfCoonsSurface::setBottom(pfCurve3d *bottom);
void pfCoonsSurface::setTop(pfCurve3d *top);
pfCurve3d * pfCoonsSurface::getRight();
pfCurve3d * pfCoonsSurface::getLeft();
pfCurve3d * pfCoonsSurface::getBottom();
pfCurve3d * pfCoonsSurface::getTop();
void pfCoonsSurface::evalPt(pfReal u, pfReal v,
pfVec3& pnt);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfCoonsSurface is derived from the parent
class pfParaSurface, so each of these member functions of class
pfParaSurface are also directly usable with objects of class
pfCoonsSurface. This is also true for ancestor classes 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);
pfReal pfParaSurface::getBeginV(pfParaSurface* surf);
Page 1
pfCoonsSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfCoonsSurface 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 pfCoonsSurface 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);
Page 2
pfCoonsSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfCoonsSurface 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 pfCoonsSurface 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 pfCoonsSurface can also be used with these
functions designed for objects of class pfMemory.
Page 3
pfCoonsSurface(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 Coons patch is a parametric surface defined by four pfCurve3 curves.
These four curves are bilinearly interpolated in the classic fashion.
The programming guide provides some details. The mathematical definition
can be found in G. Farin's book on Curves and surfaces. The boundary
curves must form a closed loop, or a Jordan curve. The "u,v" parameter
space of the Coons patch is always [0.0, 1.0] irrespective of the
boundary curves' parameter space. The left curve is with u=0 and the
bottom curve is with v=0. The range and direction of [startT endT] of the
top, bottom, right and left curves do not matter. Performer finds the
matching end points between curves.
pfCoonsSurface::getClassType returns the pfType* for the class
pfCoonsSurface. The pfType* returned by pfCoonsSurface::getClassType is
the same as the pfType* returned by invoking the virtual function getType
on any instance of class pfCoonsSurface. 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.
pfCoonsSurface::pfCoonsSurface creates an instance of pfCoonsSurface. No
valid data is set.
pfCoonsSurface::pfCoonsSurface(pfCurve3d *right,pfCurve3d *left,pfCurve3d
*bottom,pfCurve3d *top creates an instance of a parametric Coons patch,
where right, left, bottom and top are the four 3-dimensional boundary
curves. These four curves must be topologically consistent, that is, they
must form a closed, self non-intersecting piecewise loop.
pfCoonsSurface::setRight resets the Coons patch's right curve.
Page 4
pfCoonsSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
Consistency is checked and the curve is left undefined if right is NULL
or if topologically inconsistent.
pfCoonsSurface::setLeft resets the Coons patch's left curve. Consistency
is checked and the curve is left undefined if right is NULL or if
topologically inconsistent.
pfCoonsSurface::setBottom resets the Coons patch's bottom curve.
Consistency is checked and the curve is left undefined if right is NULL
or if topologically inconsistent.
pfCoonsSurface::setTop resets the Coons patch's top curve. Consistency is
checked and the curve is left undefined if right is NULL or if
topologically inconsistent.
pfCoonsSurface::getRight returns a pointer to the Coons patch's right
curve.
pfCoonsSurface::getLeft returns a pointer to the Coons patch's left
curve.
pfCoonsSurface::getBottom returns a pointer to the Coons patch's bottom
curve.
pfCoonsSurface::getTop returns a pointer to the Coons patch's top curve.
pfCoonsSurface::evalPt evaluates the surface value of the Coons patch at
parametric values u and v and stores the result pnt. Values of u and v
are assumed to be in the domain [0..1]x[0..1]. Values outside this domain
may produce undefined results. If any of the curves are undefined then
the returned value is in turn undefined and an warning is issued.
SEE ALSO
pfRep, pfGeode, pfParaSurface, pfCurve3d
Page 5
