pfPlaneSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfPlaneSurface - A parametric plane.
FUNCTION SPECIFICATION
#include <Performer/pf/pfPlane.h>
static pfType * pfPlaneSurface::getClassType(void);
pfPlaneSurface::pfPlaneSurface();
void pfPlaneSurface::setPoint1(pfReal x1, pfReal y1,
pfReal z1, pfReal u1, pfReal v1);
void pfPlaneSurface::getPoint1(pfReal *x1, pfReal *y1,
pfReal *z1, pfReal *u1, pfReal *v1);
void pfPlaneSurface::setPoint2(pfReal x2, pfReal y2,
pfReal z2, pfReal u2);
void pfPlaneSurface::getPoint2(pfReal *x2, pfReal *y2,
pfReal *z2, pfReal *u2);
void pfPlaneSurface::setPoint3(pfReal x3, pfReal y3,
pfReal z3, pfReal v3);
void pfPlaneSurface::getPoint3(pfReal *x3, pfReal *y3,
pfReal *z3, pfReal *u3);
void pfPlaneSurface::evalPt(pfReal u, pfReal v,
pfVec3& pnt);
void pfPlaneSurface::evalDu(pfReal u, pfReal v, pfVec3& Du);
void pfPlaneSurface::evalDv(pfReal u, pfReal v, pfVec3& Dv);
void pfPlaneSurface::evalNorm(pfReal u, pfReal v,
pfVec3& norm);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfPlaneSurface is derived from the parent
class pfParaSurface, so each of these member functions of class
pfParaSurface are also directly usable with objects of class
pfPlaneSurface. 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);
Page 1
pfPlaneSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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);
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 pfPlaneSurface 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 pfPlaneSurface can also be used with these functions
designed for objects of class pfGeode.
Page 2
pfPlaneSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfPlaneSurface 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 pfPlaneSurface 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();
Page 3
pfPlaneSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
Since the class pfObject is itself derived from the parent class
pfMemory, objects of class pfPlaneSurface 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();
DESCRIPTION
A plane is a special type of parametric surface and is represented as a
mapping from UV to XYZ space. The parameterization is defined as follows.
A plane is defined by 3 points (which are not colinear) A, B, C
(corresponding to members pu, orig, and pv, respectively). If we denote
vector BA = A-B and vector BC = C-B, then any point on the plane can be
represented as B + u * BA + v * BC for some (u,v). In addition, we
reparameterize (u,v) by translation and scaling. More precisely, given a
(u,v), the point on the plane is defined as B + ((u-uBias)/uScale) * BA +
((v-vBias)/vScale) * BC.
In addition to the three points and the translation and scaling
information, the class also caches the directions
uDirection = pu - orig;
vDirection = pv - orig;
and the normal norm.
pfPlaneSurface::getClassType returns the pfType* for the class
pfPlaneSurface. The pfType* returned by pfPlaneSurface::getClassType is
the same as the pfType* returned by invoking the virtual function getType
on any instance of class pfPlaneSurface. 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.
Page 4
pfPlaneSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
pfPlaneSurface::pfPlaneSurface creates an instance of pfPlaneSurface with
orig set to (0,0,0), pu set to (1,0,0), pv set to (0,1,0), uScale set to
1, vScale set to 1, uBias set to 0, vBias set to 0. uDirection and
vDirection are computed accordingly.
The domain [beginU,endU]X[beginV,endV], which are inherited members from
pfParaSurface, is set to [0, 1] X [0, 1].
pfPlaneSurface::setPoint1 sets orig to be (x1, y1, z1). Sets uBias to u1
and vBias to v1. All the other members are updated as in the
constructor.
pfPlaneSurface::setPoint2 sets pu to be (x2, y2, z2). Sets uScale to be
u2 - uBias. All the other members are updated as in the constructor.
pfPlaneSurface::setPoint3 sets pv to be (x3, y3, z3). Sets vScale to be
v3 - vBias. All the other members are updated as in the constructor.
pfPlaneSurface::getPoint1 sets (x1, y1, z1) to be orig. Sets u1 to be
uBias and v1 to be vBias.
pfPlaneSurface::getPoint2 sets (x2, y2, z2) to be pu. Sets u2 to be uBias
+ uScale.
pfPlaneSurface::getPoint3 sets (x3, y3, z3) to be pv. Sets v3 to be vBias
+ vScale.
SEE ALSO
pfRep, pfGeode, pfParaSurface
Page 5
