pfPieceWisePolyCurve2d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
NAME
pfGetPieceWisePolyCurve2dClassType, pfNewPieceWisePolyCurve2d,
pfGetPieceWisePolyCurve2dControlHullByAddr,
pfPieceWisePolyCurve2dLimitParas, pfPieceWisePolyCurve2dReverse,
pfGetPieceWisePolyCurve2dLimitParasByAddr,
pfGetPieceWisePolyCurve2dReverse, pfGetPieceWisePolyCurve2dPatchCount,
pfGetPieceWisePolyCurve2dOrder - A 2D piecewise polynomial curve
FUNCTION SPECIFICATION
#include <Performer/pf.h>
pfType * pfGetPieceWisePolyCurve2dClassType(void);
pfPieceWisePolyCurve2d * pfNewPieceWisePolyCurve2d(void *arena);
pfVec2* -
pfGetPieceWisePolyCurve2dControlHullByAddr(pfPieceWisePolyCurve2d* curve,
int piece, int i);
void -
pfPieceWisePolyCurve2dLimitParas(pfPieceWisePolyCurve2d* curve,
int piece, pfReal w1, pfReal w2);
void -
pfPieceWisePolyCurve2dReverse(pfPieceWisePolyCurve2d* curve,
int _reverse);
pfVec2* -
pfGetPieceWisePolyCurve2dLimitParasByAddr(pfPieceWisePolyCurve2d* curve,
int piece);
int -
pfGetPieceWisePolyCurve2dReverse(pfPieceWisePolyCurve2d* curve);
int -
pfGetPieceWisePolyCurve2dPatchCount(pfPieceWisePolyCurve2d* curve);
int -
pfGetPieceWisePolyCurve2dOrder(pfPieceWisePolyCurve2d* curve,
int piece);
PARENT CLASS FUNCTIONS
The OpenGL Performer class pfPieceWisePolyCurve2d is derived from the
parent class pfCurve2d, so each of these member functions of class
pfCurve2d are also directly usable with objects of class
pfPieceWisePolyCurve2d. Casting an object of class
pfPieceWisePolyCurve2d to an object of class pfCurve2d is taken care of
automatically. This is also true for casts to objects of ancestor
classes of class pfCurve2d.
Page 1
pfPieceWisePolyCurve2d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
void pfCurve2dBeginT(pfCurve2d *curve, pfReal t);
void pfCurve2dEndT(pfCurve2d *curve, pfReal t);
pfReal pfGetCurve2dBeginT(pfCurve2d *curve);
pfReal pfGetCurve2dEndT(pfCurve2d *curve);
void pfCurve2dSetClosed(pfCurve2d *curve, pfLoop loopVal);
pfLoop pfGetCurve2dClosed(pfCurve2d *curve);
void pfCurve2dClosedTol(pfCurve2d *curve, pfReal tol);
pfReal pfGetCurve2dClosedTol(pfCurve2d *curve);
void pfCurve2dEvalPt(pfCurve2d *curve, pfReal t, pfVec2 &pt);
void pfCurve2dEvalTan(pfCurve2d *curve, pfReal t, pfVec2 &pt);
void pfCurve2dEvalNorm(pfCurve2d *curve, pfReal t, pfVec2 &pt);
void pfCurve2dEvalCurv(pfCurve2d *curve, pfReal *curv);
void pfCurve2dEvalAll(pfCurve2d *curve, pfReal t, pfVec2 &pt,
pfVec2 &tan, pfReal *curv, pfVec2 norm);
Since the class pfCurve2d is itself derived from the parent class pfRep,
objects of class pfPieceWisePolyCurve2d 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 pfPieceWisePolyCurve2d 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 pfPieceWisePolyCurve2d 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);
Page 2
pfPieceWisePolyCurve2d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
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);
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 pfPieceWisePolyCurve2d 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 pfPieceWisePolyCurve2d 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);
Page 3
pfPieceWisePolyCurve2d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
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
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 pfPieceWisePolyCurve2d is a subclass of pfCurve2d. The
domain of a pfPieceWisePolyCurve2d 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.
pfGetPieceWisePolyCurve2dClassType returns the pfType* for the class
pfPieceWisePolyCurve2d. The pfType* returned by
pfGetPieceWisePolyCurve2dClassType is the same as the pfType* returned by
invoking pfGetType on any instance of class pfPieceWisePolyCurve2d.
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.
pfNewPieceWisePolyCurve2d creates an instance of an
pfPieceWisePolyCurve2d. Creates an instance of pfPieceWisePolyCurve2d; no
valid data is set.
pfPieceWisePolyCurve2dControlHull sets the i'th coefficient of the piece
polynomial to p. piece is clamped if it is greater than the number of
pieces.
pfGetPieceWisePolyCurve2dControlHull returns the i'th coefficient of the
piece polynomial. No checks are made to see if piece is in the valid
range.
pfPieceWisePolyCurve2dLimitParas sets the intervals of the polynomial
pieces in the t domain, ie. values of w1 and w2 as explained in the class
description.
Page 4
pfPieceWisePolyCurve2d(3pf) OpenGL Performer 3.2.2 libpf C Reference Pages
pfPieceWisePolyCurve2dReverse sets the reverse value to reverse.
_reverse=1 transforms t to n-t.
pfGetPieceWisePolyCurve2dLimitParas gets the value of the intervals of
the polynomial pieces in the t domain, ie. values of w1 and w2 as
explained above.
pfGetPieceWisePolyCurve2dReverse gets the value of the reverse.
pfGetPieceWisePolyCurve2dPatchCount returns the number of polynomial
pieces in the curve.
pfGetPieceWisePolyCurve2dOrder returns the order of t in the piece
polynomial.
pfPieceWisePolyCurve2dEvalPt evaluatges the curve at point t and returns
the UV result in pnt.
SEE ALSO
pfRep, pfGeode, pfCurve2d
Page 5
