pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
NAME
pfGetOrientedLine3dClassType, pfNewOrientedLine3d,
pfOrientedLine3dUpPoint, pfGetOrientedLine3dUpPoint,
pfOrientedLine3dEvalNorm - A 3d line oriented relative to a 3d point
FUNCTION SPECIFICATION
#include <Performer/pf.h>
pfType * pfGetOrientedLine3dClassType(void);
pfOrientedLine3d * pfNewOrientedLine3d(void *arena);
void pfOrientedLine3dUpPoint(pfOrientedLine3d *line,
pfReal ux, pfReal uy, pfReal uz);
void pfGetOrientedLine3dUpPoint(pfOrientedLine3d *line,
pfReal *ux, pfReal *uy, pfReal *uz);
void pfOrientedLine3dEvalNorm(pfOrientedLine3d *line,
pfReal t, pfVec3 &norm);
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. Casting an
object of class pfOrientedLine3d to an object of class pfLine3d is taken
care of automatically. This is also true for casts to objects of
ancestor classes of class pfLine3d.
void pfLine3dPoint1(pfLine3d *l, pfReal x1, pfReal y1, pfReal z1,
pfReal t1);
void pfLine3dPoint2(pfLine3d *l, pfReal x2, pfReal y2, pfReal z2,
pfReal t2);
void pfGetLine3dPoint1(pfLine3d *l, pfReal *x1, pfReal *y1, pfReal *z1,
pfReal *t1);
void pfGetLine3dPoint2(pfLine3d *l, pfReal *x2, pfReal *y2, pfReal *z2,
pfReal *t2);
void pfLine3dEvalPt(pfLine3d *curve, pfReal t, pfVec3 &pt);
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 pfGetCurve3dBeginT(pfCurve3d *curve);
pfReal pfGetCurve3dEndT(pfCurve3d *curve);
void pfCurve3dSetClosed(pfCurve3d *curve, int loopVal);
int pfGetCurve3dClosed(pfCurve3d *curve);
void pfCurve3dClosedTol(pfCurve3d *curve, pfReal tol);
pfReal pfGetCurve3dClosedTol(pfCurve3d *curve);
Page 1
pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
void pfCurve3dEvalPt(pfCurve3d *curve, pfReal t, pfVec3 &pt);
void pfCurve3dEvalTan(pfCurve3d *curve, pfReal t, pfVec3 &pt);
void pfCurve3dEvalNorm(pfCurve3d *curve, pfReal t, pfVec3 &pt);
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 pfRepOrigin(pfRep *rep, const pfVec3 origin);
void pfRepOrient(pfRep *rep, const pfMatrix mat);
void pfGetRepOrigin(pfRep *rep, pfVec3* origin);
void pfGetRepOrient(pfRep *rep, pfMatrix *mat);
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 pfAddGSet(pfGeode* geode, pfGeoSet* gset);
int pfRemoveGSet(pfGeode* geode, pfGeoSet* gset);
int pfInsertGSet(pfGeode* geode, int index, pfGeoSet* gset);
int pfReplaceGSet(pfGeode* geode, pfGeoSet* old, pfGeoSet* new);
pfGeoSet * pfGetGSet(const pfGeode* geode, int index);
int pfGetNumGSets(const pfGeode* geode);
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 * pfGetParent(const pfNode *node, int i);
int pfGetNumParents(const pfNode *node);
void pfNodeBSphere(pfNode *node, pfSphere *bsph, int mode);
int pfGetNodeBSphere(pfNode *node, pfSphere *bsph);
pfNode* pfClone(pfNode *node, int mode);
pfNode* pfBufferClone(pfNode *node, int mode, pfBuffer *buf);
int pfFlatten(pfNode *node, int mode);
int pfNodeName(pfNode *node, const char *name);
const char * pfGetNodeName(const pfNode *node);
pfNode* pfFindNode(pfNode *node, const char *pathName,
pfType *type);
pfNode* pfLookupNode(const char *name, pfType* type);
int pfNodeIsectSegs(pfNode *node, pfSegSet *segSet,
pfHit **hits[]);
void pfNodeTravMask(pfNode *node, int which, uint mask,
int setMode, int bitOp);
uint pfGetNodeTravMask(const pfNode *node, int which);
void pfNodeTravFuncs(pfNode* node, int which,
pfNodeTravFuncType pre, pfNodeTravFuncType post);
Page 2
pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
void pfGetNodeTravFuncs(const pfNode* node, int which,
pfNodeTravFuncType *pre, pfNodeTravFuncType *post);
void pfNodeTravData(pfNode *node, int which, void *data);
void * pfGetNodeTravData(const pfNode *node, int which);
void pfNodeTravMode(pfNode* node, int which, int mode,
int val);
int pfGetNodeTravMode(const pfNode* node, int which,
int mode);
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 pfUserDataSlot(pfObject *obj, int slot, void *data);
void pfUserData(pfObject *obj, void *data);
void* pfGetUserDataSlot(pfObject *obj, int slot);
void* pfGetUserData(pfObject *obj);
int pfGetNumUserData(pfObject *obj);
int pfGetNamedUserDataSlot(const char *name);
const char* pfGetUserDataSlotName(int slot);
int pfGetNumNamedUserDataSlots(void);
int pfDeleteGLHandle(pfObject *obj);
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.
pfType * pfGetType(const void *ptr);
int pfIsOfType(const void *ptr, pfType *type);
int pfIsExactType(const void *ptr, pfType *type);
const char * pfGetTypeName(const void *ptr);
int pfRef(void *ptr);
int pfUnref(void *ptr);
int pfUnrefDelete(void *ptr);
int pfUnrefGetRef(void *ptr);
int pfGetRef(const void *ptr);
int pfCopy(void *dst, void *src);
int pfDelete(void *ptr);
int pfIsFluxed(void *ptr);
int pfCompare(const void *ptr1, const void *ptr2);
void pfPrint(const void *ptr, uint which, uint verbose,
FILE *file);
void * pfGetArena(void *ptr);
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
Page 3
pfOrientedLine3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
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.
pfGetOrientedLine3dClassType returns the pfType* for the class
pfOrientedLine3d. The pfType* returned by pfGetOrientedLine3dClassType
is the same as the pfType* returned by invoking pfGetType 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 pfIsOfType 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.
pfNewOrientedLine3d creates an instance of an pfOrientedLine3d. By
default the parametric domain is defined as [0..1].
pfOrientedLine3dUpPointLCpfOrientedLine3d::setUpPoint sets the up vector
to ux, uy, uz. The same rules apply here as in the constructor with
respect to valid values.
pfGetOrientedLine3dUpPoint gets the up vector and stores it in ux, uy,
uz.
pfOrientedLine3dEvalNorm 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
