pfPieceWisePolyCurve3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
NAME
pfGetPieceWisePolyCurve3dClassType, pfNewPieceWisePolyCurve3d,
pfGetPieceWisePolyCurve3dControlHullByAddr,
pfPieceWisePolyCurve3dLimitParas, pfPieceWisePolyCurve3dReverse,
pfGetPieceWisePolyCurve3dLimitParasByAddr,
pfGetPieceWisePolyCurve3dReverse, pfGetPieceWisePolyCurve3dPatchCount,
pfGetPieceWisePolyCurve3dOrder - A 3D piecewise polynomial curve
FUNCTION SPECIFICATION
#include <Performer/pf.h>
pfType * pfGetPieceWisePolyCurve3dClassType(void);
pfPieceWisePolyCurve3d * pfNewPieceWisePolyCurve3d(void *arena);
pfVec3* -
pfGetPieceWisePolyCurve3dControlHullByAddr(pfPieceWisePolyCurve3d* curve,
int piece, int i);
void -
pfPieceWisePolyCurve3dLimitParas(pfPieceWisePolyCurve3d* curve,
int piece, pfReal w1, pfReal w2);
void -
pfPieceWisePolyCurve3dReverse(pfPieceWisePolyCurve3d* curve,
int _reverse);
pfVec3* -
pfGetPieceWisePolyCurve3dLimitParasByAddr(pfPieceWisePolyCurve3d* curve,
int piece);
int -
pfGetPieceWisePolyCurve3dReverse(pfPieceWisePolyCurve3d* curve);
int -
pfGetPieceWisePolyCurve3dPatchCount(pfPieceWisePolyCurve3d* curve);
int -
pfGetPieceWisePolyCurve3dOrder(pfPieceWisePolyCurve3d* curve,
int piece);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfPieceWisePolyCurve3d is derived from the
parent class pfCurve3d, so each of these member functions of class
pfCurve3d are also directly usable with objects of class
pfPieceWisePolyCurve3d. Casting an object of class
pfPieceWisePolyCurve3d to an object of class pfCurve3d is taken care of
automatically. This is also true for casts to objects of ancestor
classes of class pfCurve3d.
Page 1
pfPieceWisePolyCurve3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
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);
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 pfPieceWisePolyCurve3d 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 pfPieceWisePolyCurve3d 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 pfPieceWisePolyCurve3d 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[]);
Page 2
pfPieceWisePolyCurve3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
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);
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 pfPieceWisePolyCurve3d 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 pfPieceWisePolyCurve3d 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);
Page 3
pfPieceWisePolyCurve3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
DESCRIPTION
A piecewise polynomial curve consists of an array of polynomial curves.
Each polynomial curve is a polynomial mapping from t to UV plane, where
the domain is a subinterval of [0,1]. The polynomial coefficients are
set by ::setControlHull.
Notice that an pfPieceWisePolyCurve3d is a subclass of pfCurve3d. The
domain of a pfPieceWisePolyCurve3d is defined to be [0, n] where n is the
number of pieces.
If reverse is 0, then for any given t in [0, n], its corresponding uv is
evaluated in the following way: The index of the piece that corresponds
to t is floor(t), and the polynomial of that piece is evaluated at w1 +
(t-floor(t)) * (w2-w1) to get the (u,v), where [w1, w2] is the domain
interval (set by ::setLimitParas) of this piece.
If reverse is 1, then for any given t in [0,n], we first transform t into
n-t, then perform the normal evaluation (at n-t) as described in the
previous paragraph.
pfGetPieceWisePolyCurve3dClassType returns the pfType* for the class
pfPieceWisePolyCurve3d. The pfType* returned by
pfGetPieceWisePolyCurve3dClassType is the same as the pfType* returned by
invoking pfGetType on any instance of class pfPieceWisePolyCurve3d.
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.
pfNewPieceWisePolyCurve3d creates an instance of an
pfPieceWisePolyCurve3d. Creates an instance of pfPieceWisePolyCurve3d; no
valid data is set.
pfPieceWisePolyCurve3dControlHull sets the i'th coefficient of the piece
polynomial to p. piece is clamped if it is greater than the number of
pieces.
pfGetPieceWisePolyCurve3dControlHull returns the i'th coefficient of the
piece polynomial. No checks are made to see if piece is in the valid
range.
pfPieceWisePolyCurve3dLimitParas sets the intervals of the polynomial
pieces in the t domain, ie. values of w1 and w2 as explained in the class
description.
pfPieceWisePolyCurve3dReverse sets the reverse value to reverse.
_reverse=1 transforms t to n-t.
pfGetPieceWisePolyCurve3dLimitParas gets the value of the intervals of
the polynomial pieces in the t domain, ie. values of w1 and w2 as
explained above.
Page 4
pfPieceWisePolyCurve3d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
pfGetPieceWisePolyCurve3dReverse gets the value of the reverse.
pfGetPieceWisePolyCurve3dPatchCount returns the number of polynomial
pieces in the curve.
pfGetPieceWisePolyCurve3dOrder returns the order of t in the piece
polynomial.
pfPieceWisePolyCurve3dEvalPt evaluatges the curve at point t and returns
the UV result in pnt.
SEE ALSO
pfRep, pfGeode, pfCurve3d
Page 5
