pfCone(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfCone(3pf)NAMEpfCone - A parametric cone
FUNCTION SPECIFICATION
#include <Performer/pf/pfCone.h>
static pfType * pfCone::getClassType(void);
pfCone::pfCone();
pfCone::pfCone(pfReal radius, pfReal height);
void pfCone::setRadius(pfReal radiusVal);
pfReal pfCone::getRadius();
void pfCone::setHeight(pfReal height);
pfReal pfCone::setHeight();
void pfCone::evalPt(pfReal u, pfReal v, pfVec3& pnt);
void pfCone::evalNorm(pfReal u, pfReal v, pfVec3& norm);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfCone is derived from the parent class
pfParaSurface, so each of these member functions of class pfParaSurface
are also directly usable with objects of class pfCone. 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();
void pfParaSurface::getHandednessHint(pfBool _clockWise);
Page 1
pfCone(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfCone(3pf)
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 pfCone 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 pfCone 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 pfCone can also be used with these functions designed
for objects of class pfNode.
pfGroup * pfNode::getParent(int i);
Page 2
pfCone(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfCone(3pf)
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 pfCone 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 pfCone 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
pfCone(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfCone(3pf)
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 cone is a parametric surface defined by taking a circle in the x/y
plane and sweeping it a fixed distance along the z-axis in the positive
and negative directions while varying the radius of the circle as a
linear function of the distance swept. The sweeping distance is referred
to as the half height of the cone. Since the cone is centered at the
origin, the total height is twice the sweeping distance.
The surface is defined as:
x(u,v) = radius * cos(u) * alpha
y(u,v) = radius * sin(u) * alpha
z(u,v) = v
where
alpha = 1.0 - (v - beginV) / (endV - beginV)
The radius is the radius of the bottom circle. The u parameter is mapped
radially about cone and has a domain of 0 to 2*Pi. The v parameter is
mapped to the height. To obtain an arbitrarily-oriented cone, use pfRep
orientation matrix.
pfCone::getClassType returns the pfType* for the class pfCone. The
pfType* returned by pfCone::getClassType is the same as the pfType*
returned by invoking the virtual function getType on any instance of
class pfCone. 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.
pfCone::pfCone creates an instance of pfCone with radius set to 1 and
height set to 2.
pfCone::setRadius sets the cone's radius.
pfCone::getRadius returns the cone's mid-point radius.
Page 4
pfCone(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages pfCone(3pf)
pfCone::setHeight sets the cone's length.
pfCone::getHeight returns the cone's height.
pfCone::evalPt evaluates the surface value of the cone at parametric
values u and v and stores the result in pnt. The value of u is assumed to
be in radians with a domain of 0 to 2*PI. Values outside of this domain
may produce undefined results.
pfCone::evalNorm evaluates the normal of the cone at parametric values u
and v stores the result in norm. The value of u is assumed to be assumed
to be in radians with a domain of 0 to 2*PI. Values outside this domain
may produce undefined results.
The normal is defined as the right hand rule cross product of
<du/dx,du/dy,du/dz> and <dv/dx,dv/dy,dv/dz>.
SEE ALSO
pfRep, pfGeode, pfParaSurface
Page 5
