pfRuledSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfRuledSurface - A parametric ruled or lofted surface
FUNCTION SPECIFICATION
#include <Performer/pf/pfRuledSurface.h>
static pfType * pfRuledSurface::getClassType(void);
pfRuledSurface::pfRuledSurface();
pfRuledSurface::pfRuledSurface(pfCurve3d *c1,
pfCurve2d *c2);
void pfRuledSurface::setCurve1(pfCurve3d *c1);
pfCurve3d * pfRuledSurface::getCurve1() const;
void pfRuledSurface::setCurve2(pfCurve3d *c2);
pfCurve3d * pfRuledSurface::getCurve2() const;
void pfRuledSurface::evalPt(pfReal u, pfReal v,
pfVec3& pnt);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfRuledSurface is derived from the parent
class pfParaSurface, so each of these member functions of class
pfParaSurface are also directly usable with objects of class
pfRuledSurface. 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);
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();
Page 1
pfRuledSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfRuledSurface 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 pfRuledSurface 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 pfRuledSurface can also be used with these functions
designed for objects of class pfNode.
Page 2
pfRuledSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfRuledSurface 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 pfRuledSurface 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);
Page 3
pfRuledSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 ruled or lofted surface is a parametric surface defined by two
pfCurve3d curves. These two curves are bilinearly interpolated to produce
a parametric surface. The parameter u follows the defining curves and the
v direction is the direction of the ruling or linear interpolation.
The surface is defined as:
x(u,v) = (1 - v)*p1[0] + v*p2[0];
y(u,v) = (1 - v)*p1[1] + v*p2[1];
z(u,v) = (1 - v)*p1[2] + v*p2[2];
Where p1 and p2 are the points evaluated at u on the two defining curves.
Here u and v have a domain of [0..1]. u is scaled and biased to each of
the defining curves' domain such that when u=0 the curves' getBeginT()
value is used and likewise when u=1 the curves' getEndT() value is used,
see pfCurve3d.
pfRuledSurface::getClassType returns the pfType* for the class
pfRuledSurface. The pfType* returned by pfRuledSurface::getClassType is
the same as the pfType* returned by invoking the virtual function getType
on any instance of class pfRuledSurface. 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.
pfRuledSurface::pfRuledSurface creates an instance of pfRuledSurface. No
valid data is set.
pfRuledSurface::pfRuledSurface(pfCurve3d *c1,pfCurve3d *c2) creates a
parametric ruled surface defined by two three dimensional parametric
curves, pfCurve3d, c1 and c2.
pfRuledSurface::setCurve1 sets one of the defining three-dimensional
curves to c1.
pfRuledSurface::getCurve1 returns the first defining three-dimensional
parametric curve.
Page 4
pfRuledSurface(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
pfRuledSurface::setCurve2 sets the second defining three-dimensional
parametric curve to c2.
pfRuledSurface::getCurve2 returns the second defining three-dimensional
parametric curve.
pfRuledSurface::evalPt evaluates the surface value of the lofted surface
at parametric values u and v and stores the result in pnt. Values of u
and v are assumed to be in radians with a domain of [0..1]. Values
outside this domain may produce undefined results.
SEE ALSO
pfRep, pfGeode, pfParaSurface, pfCurve3d
Page 5
