pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
NAMEpfOrientedLine3d - A 3d line oriented relative to a 3d point
FUNCTION SPECIFICATION
#include <Performer/pf/pfOrientedLine3d.h>
static pfType* pfOrientedLine3d::getClassType(void);
pfOrientedLine3d::pfOrientedLine3d();
pfOrientedLine3d::pfOrientedLine3d(pfReal x1, pfReal y1,
pfReal z1, pfReal t1, pfReal x2, pfReal y2,
pfReal z2, pfReal t2, pfReal ux, pfReal uy,
pfReal uz);
void pfOrientedLine3d::setUpPoint(pfReal ux, pfReal uy,
pfReal uz);
void pfOrientedLine3d::getUpPoint(pfReal *ux, pfReal *uy,
pfReal *uz);
void pfOrientedLine3d::evalPt(pfReal t, pfVec3 &pnt);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfOrientedLine3d is derived from the parent
class pfLine3d, so each of these member functions of class pfLine3d are
also directly usable with objects of class pfOrientedLine3d. This is
also true for ancestor classes of class pfLine3d.
void pfLine3d::setPoint1(pfReal x1, pfReal y1, pfReal z1, pfReal t1);
void pfLine3d::setPoint2(pfReal x2, pfReal y2, pfReal z2, pfReal t2);
void pfLine3d::getPoint1(pfReal *x1, pfReal *y1, pfReal *z1,
pfReal *t1);
void pfLine3d::getPoint2(pfReal *x2, pfReal *y2, pfReal *z2,
pfReal *t2);
void pfLine3d::evalPt(pfReal t, pfVec3 &pnt);
Since the class pfLine3d is itself derived from the parent class
pfCurve3d, objects of class pfOrientedLine3d can also be used with these
functions designed for objects of class pfCurve3d.
pfReal pfCurve3d::getBeginT()
pfReal pfCurve3d::getEndT()
pfVec3 pfCurve3d::getBeginPt();
pfVec3 pfCurve3d::getEndPt();
pfVec3 pfCurve3d::getBeginTan();
pfVec3 pfCurve3d::getEndTan();
void pfCurve3d::setClosed(int loopVal);
int pfCurve3d::getClosed();
Page 1
pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
void pfCurve3d::setClosedTol(pfReal tol);
pfReal pfCurve3d::getClosedTol();
virtual void pfCurve3d::evalPt(pfReal t, pfVec3& pnt) = 0;
virtual void pfCurve3d::evalTan(pfReal t, pfVec3& pnt);
virtual void pfCurve3d::evalNorm(pfReal t, pfVec3& pnt);
virtual void pfCurve3d::evalCurv(pfReal t, pfReal& curv);
void pfCurve3d::eval(pfReal t, pfVec3 &pnt, pfVec3 &tan,
pfReal &curv, pfVec3 &norm)
Since the class pfCurve3d is itself derived from the parent class pfRep,
objects of class pfOrientedLine3d can also be used with these functions
designed for objects of class pfRep.
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 pfRep is itself derived from the parent class pfGeode,
objects of class pfOrientedLine3d 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 pfOrientedLine3d 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);
Page 2
pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
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 pfOrientedLine3d 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 pfOrientedLine3d 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();
Page 3
pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C++ Reference Pages
DESCRIPTION
An oriented line is a three dimensional parametric line, subclassed from
pfLine3d, with a well defined principle normal. In general a line, being
a second order (i.e. degree one) equation, has an undefined second
derivative, leaving the principle normal undefined. A principle normal is
needed when one wants to use a line as a path for a pfFrenetSweptSurface
or when one wants to shade a line. We define the line's normal
orientation as being in the plane defined by the line and an up point,
such that the normal vector is always perpendicular to the line.
pfOrientedLine3d::getClassType returns the pfType* for the class
pfOrientedLine3d. The pfType* returned by pfOrientedLine3d::getClassType
is the same as the pfType* returned by invoking the virtual function
getType on any instance of class pfOrientedLine3d. 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.
pfOrientedLine3d::pfOrientedLine3d() creates an instance of an
pfOrientedLine3d. By default the parametric domain is defined as [0..1].
pfOrientedLine3d::pfOrientedLine3d(pfReal x1,pfReal y1,pfReal z1,pfReal
t1,pfReal x2,pfReal z2,pfReal y2,pfReal t2,pfReal ux,pfReal uy,pfReal uz)
creates an instance of a pfOrientedLine3d. The arguments here are the
same as those for pfLine3d plus the additional specification of the up
point, ux, uy, uz. These values should not lie on the line. A value
coincident to the line will result in a zero or undefined normal.
sets the up vector to ux, uy, uz. The same rules apply here as in the
constructor with respect to valid values.
pfOrientedLine3d::getUpPoint gets the up vector and stores it in ux, uy,
uz.
pfOrientedLine3d::evalNorm Evaluate the normal such that it is
perpendicular to the line and lies in the plane formed by the up point
and the line. This value is returned unnormalized, its length will be
proportional to the product of the length of tangent vector and the
distance of the point on the line at, t, and the up point.
SEE ALSO
pfRep, pfGeode, pfCurve3d, pfLine3d
Page 4
