"The Performer"
int pfInit(void);
void pfExit(void);
int pfMultipipe(int numPipes);
int pfGetMultipipe(void);
int pfHyperpipe(int numHyperPipes);
int pfGetHyperpipe(pfPipe *pipe);
int pfMultiprocess(int mpMode);
int pfGetMultiprocess(void);
int pfMultithread(int pipe, uint stage, int nprocs);
int pfGetMultithread(int pipe, uint stage);
int pfConfig(void);
pid_t pfGetPID(int pipe, uint stage);
uint pfGetStage(pid_t pid, int *pipe);
void pfStageConfigFunc(int pipe, uint stage, pfStageFuncType configFunc);
pfStageFuncType pfGetStageConfigFunc(int pipe, uint stage);
int pfConfigStage(int pipe, uint stage);
pfApp, pfCull, pfDraw and pfDBase trigger the default IRIS Performer processing for each stage of the graphics pipeline. User-defined callbacks can be specified for each of these stages using the pf*Func functions. Data can be allocated for each stage and also passed down the different stages of the pipeline.
The other functions in this set manipulate IRIS Performer memory (pfMemory) and its associated reference counts.
void pfAppFrame(void);
int pfSync(void);
int pfFrame(void);
void pfApp(void);
void pfCull(void);
void pfDraw(void);
void pfDrawBin(int bin);
void pfIsectFunc(pfIsectFuncType func);
pfIsectFuncType pfGetIsectFunc(void);
void* pfAllocIsectData(int bytes);
void* pfGetIsectData(void);
void pfPassIsectData(void);
void pfDBase(void);
void pfDBaseFunc(pfDBaseFuncType func);
pfDBaseFuncType pfGetDBaseFunc(void);
void* pfAllocDBaseData(int bytes);
void* pfGetDBaseData(void);
void pfPassDBaseData(void);
void pfPhase(int phase);
int pfGetPhase(void);
void pfVideoRate(float vrate);
float pfGetVideoRate(void);
float pfFrameRate(float rate);
float pfGetFrameRate(void);
int pfFieldRate(int fields);
int pfGetFieldRate(void);
int pfGetFrameCount(void);
double pfGetFrameTimeStamp(void);
void pfFrameTimeStamp(double t);
int pfGetId(void *mem);
int pfAsyncDelete(void *mem);
int pfCopy(void *dst, void *src);
pfPipe* pfGetPipe(int pipeNum);
int pfInitPipe(pfPipe *pipe, pfPipeFuncType configFunc);
pfType* pfGetPipeClassType(void);
void pfPipeSwapFunc(pfPipe* pipe,
pfPipeSwapFuncType func);
pfPipeSwapFuncType pfGetPipeSwapFunc(const pfPipe* pipe);
void pfGetPipeSize(const pfPipe* pipe, int *xs, int *ys);
void pfPipeScreen(pfPipe* pipe, int scr);
int pfGetPipeScreen(const pfPipe* pipe);
void pfPipeWSConnectionName(pfPipe* pipe,
const char *name);
const char* pfGetPipeWSConnectionName(const pfPipe* pipe);
pfChannel* pfGetPipeChan(const pfPipe* pipe, int i);
int pfGetPipeNumChans(const pfPipe* pipe);
pfPipeWindow* pfGetPipePWin(const pfPipe* pipe, int i);
int pfGetPipeNumPWins(const pfPipe* pipe);
int pfGetPipeHyperId(const pfPipe* pipe);
int pfMovePWin(pfPipe* pipe, int where,
pfPipeWindow *pw);
pfBuffer* pfGetCurBuffer(void);
pfBuffer* pfNewBuffer(void);
void pfBufferScope(pfBuffer* buffer, pfObject *obj, int scope);
int pfGetBufferScope(pfBuffer* buffer, pfObject *obj);
void pfMergeBuffer(void);
int pfUnrefDelete(void *mem);
int pfDelete(void *mem);
int pfBufferInsert(void *parent, int index, void *child);
int pfBufferRemove(void *parent, void *child);
int pfBufferAdd(void *parent, void *child);
int pfBufferReplace(void *parent, void *oldChild, void *newChild);
void pfSelectBuffer(pfBuffer* buffer);
void pfInitGfx(void);
pfPipeWindow* pfNewPWin(pfPipe *p);
pfType* pfGetPWinClassType(void);
void pfPWinName(pfPipeWindow* pwin, const char *name);
const char* pfGetPWinName(pfPipeWindow* pwin);
void pfPWinWSConnectionName(pfPipeWindow* pwin,
const char *name);
const char* pfGetPWinWSConnectionName(pfPipeWindow* pwin);
void pfPWinMode(pfPipeWindow* pwin, int mode, int val);
int pfGetPWinMode(pfPipeWindow* pwin, int mode);
void pfPWinType(pfPipeWindow* pwin, uint type);
uint pfGetPWinType(pfPipeWindow* pwin);
pfState* pfGetPWinCurState(pfPipeWindow* pwin);
void pfPWinAspect(pfPipeWindow* pwin, int x, int y);
void pfGetPWinAspect(pfPipeWindow* pwin, int *x, int *y);
void pfPWinOriginSize(pfPipeWindow* pwin, int xo, int yo,
int xs, int ys);
void pfPWinOrigin(pfPipeWindow* pwin, int xo, int yo);
void pfGetPWinOrigin(pfPipeWindow* pwin, int *xo, int *yo);
void pfPWinSize(pfPipeWindow* pwin, int xs, int ys);
void pfGetPWinSize(pfPipeWindow* pwin, int *xs, int *ys);
void pfPWinFullScreen(pfPipeWindow* pwin);
void pfGetPWinCurOriginSize(pfPipeWindow* pwin, int *xo,
int *yo, int *xs, int *ys);
void pfGetPWinCurScreenOriginSize(pfPipeWindow* pwin,
int *xo, int *yo, int *xs, int *ys);
void pfPWinOverlayWin(pfPipeWindow* pwin, pfWindow *ow);
pfWindow* pfGetPWinOverlayWin(pfPipeWindow* pwin);
void pfPWinStatsWin(pfPipeWindow* pwin, pfWindow *sw);
pfWindow* pfGetPWinStatsWin(pfPipeWindow* pwin);
void pfPWinScreen(pfPipeWindow* pwin, int screen);
int pfGetPWinScreen(pfPipeWindow* pwin);
void pfPWinShare(pfPipeWindow* pwin, int mode);
uint pfGetPWinShare(pfPipeWindow* pwin);
void pfPWinWSWindow(pfPipeWindow* pwin, pfWSConnection dsp,
pfWSWindow wsw);
Window pfGetPWinWSWindow(pfPipeWindow* pwin);
void pfPWinWSDrawable(pfPipeWindow* pwin, pfWSConnection dsp,
pfWSDrawable gxw);
pfWSDrawable pfGetPWinWSDrawable(pfPipeWindow* pwin);
pfWSDrawable pfGetPWinCurWSDrawable(pfPipeWindow* pwin);
void pfPWinFBConfigData(pfPipeWindow* pwin, void *data);
void* pfGetPWinFBConfigData(pfPipeWindow* pwin);
void pfPWinFBConfigAttrs(pfPipeWindow* pwin, int *attr);
int* pfGetPWinFBConfigAttrs(pfPipeWindow* pwin);
void pfPWinFBConfig(pfPipeWindow* pwin, XVisualInfo *vis);
XVisualInfo* pfGetPWinFBConfig(pfPipeWindow* pwin);
void pfPWinFBConfigId(pfPipeWindow* pwin, int vId);
int pfGetPWinFBConfigId(pfPipeWindow* pwin);
void pfPWinIndex(pfPipeWindow* pwin, int index);
int pfGetPWinIndex(pfPipeWindow* pwin);
pfWindow* pfGetPWinSelect(pfPipeWindow* pwin);
void pfPWinGLCxt(pfPipeWindow* pwin, pfGLContext gc);
pfGLContext pfGetPWinGLCxt(pfPipeWindow* pwin);
void pfPWinList(pfPipeWindow* pwin, pfList *wl);
pfList* pfGetPWinList(const pfPipeWindow* pwin);
int pfAttachPWinWin(pfPipeWindow* pwin, pfWindow *w1);
int pfDetachPWinWin(pfPipeWindow* pwin, pfWindow *w1);
int pfAttachPWin(pfPipeWindow* pwin, pfPipeWindow *pw1);
int pfDetachPWin(pfPipeWindow* pwin, pfPipeWindow *pw1);
pfWindow* pfSelectPWin(pfPipeWindow* pwin);
void pfSwapPWinBuffers(pfPipeWindow* pwin);
pfFBConfig pfChoosePWinFBConfig(pfPipeWindow* pwin, int *attr);
int pfIsPWinOpen(pfPipeWindow* pwin);
int pfQueryPWin(pfPipeWindow* pwin, int which, int *dst);
int pfMQueryPWin(pfPipeWindow* pwin, int *which, int *dst);
pfPipe* pfGetPWinPipe(pfPipeWindow* pwin);
int pfGetPWinPipeIndex(const pfPipeWindow* pwin);
void pfPWinConfigFunc(pfPipeWindow* pwin,
pfPWinFuncType func);
pfPWinFuncType pfGetPWinConfigFunc(pfPipeWindow* pwin);
int pfGetPWinChanIndex(pfPipeWindow* pwin, pfChannel *chan);
void pfConfigPWin(pfPipeWindow* pwin);
void pfOpenPWin(pfPipeWindow* pwin);
void pfClosePWin(pfPipeWindow* pwin);
void pfClosePWinGL(pfPipeWindow* pwin);
int pfRemoveChan(pfPipeWindow* pwin, pfChannel *chan);
void pfAddChan(pfPipeWindow* pwin, pfChannel *chan);
void pfInsertChan(pfPipeWindow* pwin, int where,
pfChannel *chan);
int pfMoveChan(pfPipeWindow* pwin, int where,
pfChannel *chan);
pfChannel* pfGetChan(pfPipeWindow* pwin, int which);
int pfGetNumChans(const pfPipeWindow* pwin);
void pfNodePickSetup(pfNode* node);
Different queries can be made about the pfChannel (pfGetChan*) and user-defined traversal functions and mode can be set (pfChanTrav*). Functions are provided to control IRIS Performer's level-of-detail (LOD) behavior by specifying view position, field-of-view, and viewport pixel size (pfChanLOD*). pfChanStress can be used to specify when the system is at stress so that the LOD behavior is suitably modified.
The pfScene and the pfEarthSky that the pfChannel culls and draws are set using pfChanScene and pfChanESky, respectively. The pfChannel's pfGeoState and pfGeoStateTable can also be specified. Screen to world-space ray intersections on a pfChannel's scene can be performed using pfChanPick and related functions.
IRIS Performer can also sort the database into "bins" which are rendered in a user-specified order. In addition, geometry within a bin may be sorted by graphics state like texture or by range for front-to-back or back-to-front rendering. Functions are provided to achieve this behavior (pfChanBinSort and friends).
pfChannel* pfNewChan(pfPipe *p);
pfType* pfGetChanClassType(void);
int pfGetChanFrustType(const pfChannel* chan);
void pfChanAspect(pfChannel* chan, int which,
float xyaspect);
float pfGetChanAspect(pfChannel* chan);
void pfGetChanFOV(const pfChannel* chan, float *fovH,
float *fovV);
void pfChanNearFar(pfChannel* chan, float n, float f);
void pfGetChanNearFar(const pfChannel* chan, float *n,
float *f);
void pfGetChanNear(const pfChannel* chan, pfVec3 ll,
pfVec3 lr, pfVec3 ul, pfVec3 ur);
void pfGetChanFar(const pfChannel* chan, pfVec3 ll,
pfVec3 lr, pfVec3 ul, pfVec3 ur);
void pfGetChanPtope(const pfChannel* chan, pfPolytope *dst);
int pfGetChanEye(const pfChannel* chan, pfVec3 eye);
void pfMakePerspChan(pfChannel* chan, float l, float r,
float b, float t);
void pfMakeOrthoChan(pfChannel* chan, float l, float r,
float b, float t);
void pfMakeSimpleChan(pfChannel* chan, float fov);
void pfOrthoXformChan(pfChannel* chan, pfFrustum *fr,
const pfMatrix mat);
int pfChanContainsPt(const pfChannel* chan,
const pfVec3 pt);
int pfChanContainsSphere(const pfChannel* chan,
const pfSphere *sphere);
int pfChanContainsBox(const pfChannel* chan,
const pfBox *box);
int pfChanContainsCyl(const pfChannel* chan,
const pfCylinder *cyl);
void pfApplyChan(pfChannel* chan);
pfPipe* pfGetChanPipe(const pfChannel* chan);
pfPipeWindow* pfGetChanPWin(pfChannel* chan);
int pfGetChanPWinIndex(pfChannel* chan);
void pfChanFOV(pfChannel* chan, float fovH, float fovV);
void pfChanViewport(pfChannel* chan, float l, float r,
float b, float t);
void pfGetChanViewport(const pfChannel* chan, float *l,
float *r, float *b, float *t);
void pfGetChanOrigin(const pfChannel* chan, int *xo,
int *yo);
void pfGetChanSize(const pfChannel* chan, int *xs, int *ys);
void pfChanShare(pfChannel* chan, uint mask);
uint pfGetChanShare(const pfChannel* chan);
void pfChanAutoAspect(pfChannel* chan, int which);
int pfGetChanAutoAspect(const pfChannel* chan);
void pfGetChanBaseFrust(const pfChannel* chan,
pfFrustum *frust);
void pfChanViewOffsets(pfChannel* chan, pfVec3 xyz,
pfVec3 hpr);
void pfGetChanViewOffsets(const pfChannel* chan, pfVec3 xyz,
pfVec3 hpr);
void pfChanView(pfChannel* chan, pfVec3 vp, pfVec3 vd);
void pfGetChanView(pfChannel* chan, pfVec3 vp, pfVec3 vd);
void pfChanViewMat(pfChannel* chan, pfMatrix mat);
void pfGetChanViewMat(const pfChannel* chan, pfMatrix mat);
void pfGetChanOffsetViewMat(const pfChannel* chan,
pfMatrix mat);
void pfChanCullPtope(pfChannel* chan, const pfPolytope *vol);
void pfGetChanCullPtope(const pfChannel* chan,
pfPolytope *vol);
void* pfAllocChanData(pfChannel* chan, int size);
void pfChanData(pfChannel* chan, void *data, size_t size);
void* pfGetChanData(const pfChannel* chan);
size_t pfGetChanDataSize(const pfChannel* chan);
void pfChanTravFunc(pfChannel* chan, int trav,
pfChanFuncType func);
pfChanFuncType pfGetChanTravFunc(const pfChannel* chan, int trav);
void pfChanTravMode(pfChannel* chan, int trav, int mode);
int pfGetChanTravMode(const pfChannel* chan, int trav);
void pfChanTravMask(pfChannel* chan, int which, uint mask);
uint pfGetChanTravMask(const pfChannel* chan, int which);
void pfChanStressFilter(pfChannel* chan, float frac,
float low, float high, float s, float max);
void pfGetChanStressFilter(const pfChannel* chan,
float *frac, float *low, float *high, float *s,
float *max);
void pfChanStress(pfChannel* chan, float stress);
float pfGetChanStress(const pfChannel* chan);
float pfGetChanLoad(const pfChannel* chan);
void pfChanScene(pfChannel* chan, pfScene *s);
pfScene* pfGetChanScene(const pfChannel* chan);
void pfChanESky(pfChannel* chan, pfEarthSky *es);
pfEarthSky* pfGetChanESky(const pfChannel* chan);
void pfChanGState(pfChannel* chan, pfGeoState *gstate);
pfGeoState* pfGetChanGState(const pfChannel* chan);
void pfChanGStateTable(pfChannel* chan, pfList *list);
pfList* pfGetChanGStateTable(const pfChannel* chan);
void pfChanLODAttr(pfChannel* chan, int attr, float val);
float pfGetChanLODAttr(const pfChannel* chan, int attr);
void pfChanLODState(pfChannel* chan, const pfLODState *ls);
void pfGetChanLODState(const pfChannel* chan,
pfLODState *ls);
void pfChanLODStateList(pfChannel* chan, pfList *stateList);
pfList* pfGetChanLODStateList(const pfChannel* chan);
int pfChanStatsMode(pfChannel* chan, uint mode, uint val);
pfFrameStats* pfGetChanFStats(pfChannel* chan);
void pfChanBinSort(pfChannel* chan, int bin, int sortType,
int *sortOrders);
int pfGetChanBinSort(pfChannel* chan, int bin,
int *sortOrders);
void pfChanBinOrder(pfChannel* chan, int bin, int order);
int pfGetChanBinOrder(const pfChannel* chan, int bin);
int pfAttachChan(pfChannel* chan, pfChannel *chan1);
int pfDetachChan(pfChannel* chan, pfChannel *chan1);
void pfPassChanData(pfChannel* chan);
int pfChanPick(pfChannel* chan, int mode, float px,
float py, float radius, pfHit **pickList[]);
void pfClearChan(pfChannel* chan);
void pfDrawChanStats(pfChannel* chan);
int pfChanNodeIsectSegs(pfChannel* chan, pfNode *node,
pfSegSet *segSet, pfHit **hits[], pfMatrix *ma);
pfEarthSky* pfNewESky(void);
pfType* pfGetESkyClassType(void);
void pfESkyMode(pfEarthSky* esky, int mode, int val);
int pfGetESkyMode(pfEarthSky* esky, int mode);
void pfESkyAttr(pfEarthSky* esky, int mode, float val);
float pfGetESkyAttr(pfEarthSky* esky, int mode);
void pfESkyColor(pfEarthSky* esky, int which, float r, float g,
float b, float a);
void pfGetESkyColor(pfEarthSky* esky, int which, float *r,
float *g, float *b, float *a);
void pfESkyFog(pfEarthSky* esky, int which, pfFog *fog);
pfFog* pfGetESkyFog(pfEarthSky* esky, int which);
pfType* pfGetNodeClassType(void);
void pfNodeTravMask(pfNode* node, int which, uint mask,
int setMode, int bitOp);
pfNode* pfFindNode(pfNode* node, const char *name, pfType *type);
int pfNodeName(pfNode* node, const char *name);
const char* pfGetNodeName(const pfNode* node);
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);
uint pfGetNodeTravMask(const pfNode* node, int which);
void pfNodeBufferMode(pfNode* node, int mode, int val);
int pfGetNodeBufferMode(const pfNode* node, int mode);
pfGroup* pfGetParent(const pfNode* node, int i);
int pfGetNumParents(const pfNode* node);
void pfNodeBSphere(pfNode* node, pfSphere *sph, int mode);
int pfGetNodeBSphere(pfNode* node, pfSphere *sph);
pfNode* pfLookupNode(const char *name, pfType* type);
int pfNodeIsectSegs(pfNode* node, pfSegSet *segSet,
pfHit **hits[]);
int pfFlatten(pfNode* node, int mode);
pfNode* pfClone(pfNode* node, int mode);
pfNode* pfBufferClone(pfNode* node, int mode, pfBuffer *buf);
pfGroup* pfNewGroup(void);
pfType* pfGetGroupClassType(void);
int pfAddChild(pfGroup* group, pfNode *child);
int pfInsertChild(pfGroup* group, int index, pfNode *child);
int pfRemoveChild(pfGroup* group, pfNode *child);
int pfReplaceChild(pfGroup* group, pfNode *oldn, pfNode *newn);
int pfBufferAddChild(pfGroup* group, pfNode *child);
int pfBufferRemoveChild(pfGroup* group, pfNode *child);
pfNode* pfGetChild(const pfGroup* group, int i);
int pfGetNumChildren(const pfGroup* group);
int pfSearchChild(const pfGroup* group, pfNode *n);
pfScene* pfNewScene(void);
pfType* pfGetSceneClassType(void);
void pfSceneGState(pfScene* scene, pfGeoState *gs);
pfGeoState* pfGetSceneGState(const pfScene* scene);
void pfSceneGStateIndex(pfScene* scene, int gs);
int pfGetSceneGStateIndex(const pfScene* scene);
pfSCS* pfNewSCS(pfMatrix m);
pfType* pfGetSCSClassType(void);
void pfGetSCSMat(pfSCS* scs, pfMatrix m);
const pfMatrix* pfGetSCSMatPtr(pfSCS* scs);
pfDCS* pfNewDCS(void);
pfType* pfGetDCSClassType(void);
void pfGetDCSMat(pfDCS* dcs, pfMatrix m);
const pfMatrix* pfGetDCSMatPtr(pfDCS* dcs);
void pfDCSMatType(pfDCS* dcs, uint val);
uint pfGetDCSMatType(const pfDCS* dcs);
void pfDCSMat(pfDCS* dcs, pfMatrix m);
void pfDCSCoord(pfDCS* dcs, pfCoord *c);
void pfDCSRot(pfDCS* dcs, float h, float p, float r);
void pfDCSTrans(pfDCS* dcs, float x, float y, float z);
void pfDCSScale(pfDCS* dcs, float s);
void pfDCSScaleXYZ(pfDCS* dcs, float xs, float ys,
float zs);
pfLODState* pfNewLODState(void);
pfType* pfGetLODStateClassType(void);
void pfLODStateAttr(pfLODState* lodstate, int attr, float val);
float pfGetLODStateAttr(pfLODState* lodstate, int attr);
int pfLODStateName(pfLODState* lodstate, const char *name);
const char* pfGetLODStateName(const pfLODState* lodstate);
pfLODState* pfFindLODState(const char *findName);
pfLOD* pfNewLOD(void);
pfType* pfGetLODClassType(void);
void pfLODCenter(pfLOD* lod, pfVec3 c);
void pfGetLODCenter(const pfLOD* lod, pfVec3 c);
void pfLODRange(pfLOD* lod, int index, float range);
int pfGetLODNumRanges(const pfLOD* lod);
float pfGetLODRange(const pfLOD* lod, int index);
void pfLODTransition(pfLOD* lod, int index, float delta);
int pfGetLODNumTransitions(const pfLOD* lod);
float pfGetLODTransition(const pfLOD* lod, int index);
void pfLODLODState(pfLOD* lod, pfLODState *ls);
pfLODState* pfGetLODLODState(const pfLOD* lod);
void pfLODLODStateIndex(pfLOD* lod, int index);
int pfGetLODLODStateIndex(const pfLOD* lod);
float pfEvaluateLOD(pfLOD* lod, const pfChannel *chan,
const pfMatrix *offset);
pfSwitch* pfNewSwitch(void);
pfType* pfGetSwitchClassType(void);
int pfSwitchVal(pfSwitch* switch, int val);
int pfGetSwitchVal(const pfSwitch* switch);
pfMorph* pfNewMorph(void);
pfType* pfGetMorphClassType(void);
int pfMorphAttr(pfMorph* morph, int index, int attr, int nelts,
void *dst, int nsrcs, float *alist[], ushort *ilist[],
int n[]);
int pfGetMorphNumAttrs(const pfMorph* morph);
int pfGetMorphSrc(const pfMorph* morph, int index, int src,
float **alist, ushort **ilist, int *n);
int pfGetMorphNumSrcs(const pfMorph* morph, int index);
void* pfGetMorphDst(const pfMorph* morph, int index);
int pfMorphWeights(pfMorph* morph, int index, float *weights);
int pfGetMorphWeights(const pfMorph* morph, int index,
float *weights);
void pfEvaluateMorph(pfMorph* morph);
pfSequence* pfNewSeq(void);
pfType* pfGetSeqClassType(void);
void pfSeqDuration(pfSequence* seq, float sp, int nRep);
void pfGetSeqDuration(const pfSequence* seq, float *sp,
int *nRep);
void pfSeqInterval(pfSequence* seq, int imode, int beg, int e);
void pfGetSeqInterval(const pfSequence* seq, int *imode,
int *beg, int *e);
void pfSeqMode(pfSequence* seq, int m);
int pfGetSeqMode(const pfSequence* seq);
void pfSeqTime(pfSequence* seq, int index, double time);
double pfGetSeqTime(const pfSequence* seq, int index);
int pfGetSeqFrame(const pfSequence* seq, int *rep);
pfLayer* pfNewLayer(void);
pfType* pfGetLayerClassType(void);
void pfLayerBase(pfLayer* layer, pfNode *n);
pfNode* pfGetLayerBase(const pfLayer* layer);
void pfLayerDecal(pfLayer* layer, pfNode *n);
pfNode* pfGetLayerDecal(const pfLayer* layer);
void pfLayerMode(pfLayer* layer, int mode);
int pfGetLayerMode(const pfLayer* layer);
pfPartition* pfNewPart(void);
pfType* pfGetPartClassType(void);
void pfPartVal(pfPartition* part, int which, float val);
float pfGetPartVal(pfPartition* part, int which);
void pfPartAttr(pfPartition* part, int which, void *attr);
void* pfGetPartAttr(pfPartition* part, int which);
void pfBuildPart(pfPartition* part);
void pfUpdatePart(pfPartition* part);
pfLightPoint* pfNewLPoint(int n);
pfType* pfGetLPointClassType(void);
int pfGetNumLPoints(const pfLightPoint* lpoint);
void pfLPointSize(pfLightPoint* lpoint, float s);
float pfGetLPointSize(const pfLightPoint* lpoint);
void pfLPointFogScale(pfLightPoint* lpoint, float onset,
float opaque);
void pfGetLPointFogScale(const pfLightPoint* lpoint,
float *onset, float *opaque);
void pfLPointRot(pfLightPoint* lpoint, float azim, float elev,
float roll);
void pfGetLPointRot(const pfLightPoint* lpoint, float *azim,
float *elev, float *roll);
void pfLPointShape(pfLightPoint* lpoint, int dir, float he,
float ve, float f);
void pfGetLPointShape(const pfLightPoint* lpoint, int *dir,
float *he, float *ve, float *f);
pfGeoSet* pfGetLPointGSet(const pfLightPoint* lpoint);
void pfLPointPos(pfLightPoint* lpoint, int i, pfVec3 p);
void pfGetLPointPos(const pfLightPoint* lpoint, int i,
pfVec3 p);
void pfLPointColor(pfLightPoint* lpoint, int i, pfVec4 clr);
void pfGetLPointColor(const pfLightPoint* lpoint, int i,
pfVec4 clr);
pfLightSource* pfNewLSource(void);
pfType* pfGetLSourceClassType(void);
void pfLSourceColor(pfLightSource* lsource, int which,
float r, float g, float b);
void pfGetLSourceColor(pfLightSource* lsource, int which,
float* r, float* g, float* b);
void pfLSourceAmbient(pfLightSource* lsource, float r,
float g, float b);
void pfGetLSourceAmbient(pfLightSource* lsource, float* r,
float* g, float* b);
void pfLSourcePos(pfLightSource* lsource, float x, float y,
float z, float w);
void pfGetLSourcePos(pfLightSource* lsource, float* x,
float* y, float* z, float* w);
void pfLSourceAtten(pfLightSource* lsource, float a0,
float a1, float a2);
void pfGetLSourceAtten(pfLightSource* lsource, float* a0,
float* a1, float* a2);
void pfSpotLSourceDir(pfLightSource* lsource, float x,
float y, float z);
void pfGetSpotLSourceDir(pfLightSource* lsource, float* x,
float* y, float* z);
void pfSpotLSourceCone(pfLightSource* lsource, float f1,
float f2);
void pfGetSpotLSourceCone(pfLightSource* lsource, float* f1,
float* f2);
void pfLSourceOn(pfLightSource* lsource);
void pfLSourceOff(pfLightSource* lsource);
int pfIsLSourceOn(pfLightSource* lsource);
void pfLSourceMode(pfLightSource* lsource, int mode,
int val);
int pfGetLSourceMode(const pfLightSource* lsource,
int mode);
void pfLSourceVal(pfLightSource* lsource, int mode,
float val);
float pfGetLSourceVal(const pfLightSource* lsource, int mode);
void pfLSourceAttr(pfLightSource* lsource, int attr,
void *obj);
void* pfGetLSourceAttr(const pfLightSource* lsource,
int attr);
pfGeode* pfNewGeode(void);
pfType* pfGetGeodeClassType(void);
int pfAddGSet(pfGeode* geode, pfGeoSet *gset);
int pfInsertGSet(pfGeode* geode, int index, pfGeoSet *gset);
int pfReplaceGSet(pfGeode* geode, pfGeoSet *oldgs,
pfGeoSet *newgs);
int pfRemoveGSet(pfGeode* geode, pfGeoSet *gset);
pfGeoSet* pfGetGSet(const pfGeode* geode, int i);
int pfGetNumGSets(const pfGeode* geode);
pfText* pfNewText(void);
pfType* pfGetTextClassType(void);
int pfAddString(pfText* text, pfString *str);
int pfInsertString(pfText* text, int index, pfString *str);
int pfReplaceString(pfText* text, pfString *oldgs,
pfString *newgs);
int pfRemoveString(pfText* text, pfString *str);
pfString* pfGetString(const pfText* text, int i);
int pfGetNumStrings(const pfText* text);
pfBillboard* pfNewBboard(void);
pfType* pfGetBboardClassType(void);
void pfBboardAxis(pfBillboard* bboard, const pfVec3 axis);
void pfGetBboardAxis(pfBillboard* bboard, pfVec3 axis);
void pfBboardMode(pfBillboard* bboard, int mode, int val);
int pfGetBboardMode(pfBillboard* bboard, int mode);
void pfBboardPos(pfBillboard* bboard, int i, const pfVec3 pos);
void pfGetBboardPos(pfBillboard* bboard, int i, pfVec3 pos);
pfPath* pfNewPath(void);
pfType* pfGetPathClassType(void);
void pfCullResult(int result);
int pfGetParentCullResult(void);
int pfGetCullResult(void);
int pfCullPath(pfPath *path, pfNode *root, int mode);
pfChannel* pfGetTravChan(const pfTraverser* trav);
pfNode* pfGetTravNode(const pfTraverser* trav);
void pfGetTravMat(const pfTraverser* trav, pfMatrix mat);
int pfGetTravIndex(const pfTraverser* trav);
const pfPath* pfGetTravPath(const pfTraverser* trav);
pfFrameStats* pfNewFStats(void);
pfType* pfGetFStatsClassType(void);
uint pfFStatsClass(pfFrameStats *fstats, uint mask, int val);
uint pfGetFStatsClass(pfFrameStats *fstats, uint emask);
uint pfFStatsClassMode(pfFrameStats *fstats, int class,
uint mask, int val);
uint pfGetFStatsClassMode(pfFrameStats *fstats, int class);
void pfFStatsAttr(pfFrameStats *fstats, int attr, float val);
float pfGetFStatsAttr(pfFrameStats *fstats, int attr);
uint pfGetOpenFStats(pfFrameStats *fstats, uint emask);
uint pfOpenFStats(pfFrameStats *fstats, uint enmask);
uint pfCloseFStats(uint enmask);
void pfResetFStats(pfFrameStats *fstats);
void pfClearFStats(pfFrameStats *fstats, uint which);
void pfAccumulateFStats(pfFrameStats *fstats,
pfFrameStats* src, uint which);
void pfAverageFStats(pfFrameStats *fstats, pfFrameStats* src,
uint which, int num);
void pfFStatsCountGSet(pfFrameStats *fstats, pfGeoSet *gset);
int pfQueryFStats(pfFrameStats *fstats, uint which,
void *dst, int size);
int pfMQueryFStats(pfFrameStats *fstats, uint *which,
void *dst, int size);
void pfDrawFStats(pfFrameStats *fstats, pfChannel *chan);
void pfFStatsCountNode(pfFrameStats *fstats, int class,
uint mode, pfNode * node);
libpr Functions
void prInit(void);
void prExit(void);
int pfInitArenas(void);
int pfFreeArenas(void);
PF_USPTR_T* pfGetSemaArena(void);
void pfSemaArenaSize(size_t size);
size_t pfGetSemaArenaSize(void);
void pfSemaArenaBase(void *base);
void* pfGetSemaArenaBase(void);
void* pfGetSharedArena(void);
void pfSharedArenaSize(size_t size);
size_t pfGetSharedArenaSize(void);
void pfSharedArenaBase(void *base);
void* pfGetSharedArenaBase(void);
void pfTmpDir(char *dir);
const char * pfGetTmpDir(void);
void pfShadeModel(int model);
int pfGetShadeModel(void);
void pfTransparency(int type);
int pfGetTransparency(void);
void pfAlphaFunc(float ref, int func);
void pfGetAlphaFunc(float* ref, int* func);
void pfAntialias(int type);
int pfGetAntialias(void);
void pfDecal(int mode);
int pfGetDecal(void);
void pfCullFace(int cull);
int pfGetCullFace(void);
void pfEnable(int target);
void pfDisable(int target);
int pfGetEnable(int target);
void pfClear(int which, const pfVec4 col);
void pfClear(int which, const pfVec4 *col);
void pfGLOverride(int mode, float val);
float pfGetGLOverride(int mode);
void pfScale(float x, float y, float z);
void pfTranslate(float x, float y, float z);
void pfRotate(int axis, float degrees);
void pfPushMatrix(void);
void pfPushIdentMatrix(void);
void pfPopMatrix(void);
void pfLoadMatrix(const pfMatrix m);
void pfMultMatrix(const pfMatrix m);
void pfNotifyHandler(pfNotifyFuncType handler);
pfNotifyFuncType pfGetNotifyHandler(void);
void pfDefaultNotifyHandler(pfNotifyData *notice);
void pfNotifyLevel(int severity);
int pfGetNotifyLevel(void);
void pfNotify(int severity, int error, char *format,
double pfGetTime(void);
pid_t pfInitClock(double time);
void pfWrapClock(void);
void pfClockName(char *name);
const char* pfGetClockName(void);
void pfClockMode(int mode);
int pfGetClockMode(void);
void pfFilePath(const char* path);
const char* pfGetFilePath(void);
int pfFindFile(const char* file, char path[PF_MAXSTRING],
int amode);
int pfStartVClock(void);
void pfStopVClock(void);
void pfInitVClock(int ticks);
void pfVClockOffset(int offset);
int pfGetVClockOffset(void);
int pfGetVClock(void);
int pfVClockSync(int rate, int offset);
void prInitGfx(void);
pfWindow * pfGetCurWin(void);
void pfCloseWSConnection(pfWSConnection dsp);
pfFBConfig pfChooseFBConfig(pfWSConnection dsp, int screen,
int *attr);
pfFBConfig pfChooseFBConfigData(void **dst, pfWSConnection dsp,
int screen, int *attr, void *arena);
void pfSelectWSConnection(pfWSConnection);
pfWSConnection pfOpenWSConnection(const char *str, int shared);
pfWSConnection pfOpenScreen(int screen, int shared);
pfWSConnection pfGetCurWSConnection(void);
const char* pfGetWSConnectionName(pfWSConnection);
void pfGetScreenSize(int screen, int *x, int *y);
int pfQueryFeature(int which, int *dst);
int pfMQueryFeature(int *which, int *dst);
void pfFeature(int which, int val);
int pfQuerySys(int which, int *dst);
int pfMQuerySys(int *which, int *dst);
pfType* pfGetObjectClassType(void);
void pfCopyFunc(pfCopyFuncType func);
pfCopyFuncType pfGetCopyFunc(void);
void pfDeleteFunc(pfDeleteFuncType func);
pfMergeFuncType pfGetMergeFunc(void);
void pfMergeFunc(pfMergeFuncType func);
pfDeleteFuncType pfGetDeleteFunc(void);
void pfPrintFunc(pfPrintFuncType func);
pfPrintFuncType pfGetPrintFunc(void);
int pfGetGLHandle(const pfObject *obj);
void pfUserData(pfObject* obj, void* data);
void* pfGetUserData(pfObject* obj);
pfType* pfNewType(pfType *parent, char *name);
pfType* pfGetTypeParent(pfType* type);
int pfIsDerivedFrom(pfType* type, pfType *ancestor);
void pfMaxTypes(int n);
pfFog* pfGetCurFog(void);
pfFog* pfNewFog(void *arena);
pfType* pfGetFogClassType(void);
void pfFogType(pfFog* fog, int type);
int pfGetFogType(const pfFog* fog);
void pfFogRange(pfFog* fog, float onset, float opaque);
void pfGetFogRange(const pfFog* fog, float* onset,
float* opaque);
void pfFogOffsets(pfFog* fog, float onset, float opaque);
void pfGetFogOffsets(const pfFog* fog, float *onset,
float *opaque);
void pfFogRamp(pfFog* fog, int points, float* range,
float* density, float bias);
void pfGetFogRamp(const pfFog* fog, int* points, float* range,
float* density, float* bias);
void pfFogColor(pfFog* fog, float r, float g, float b);
void pfGetFogColor(const pfFog* fog, float* r, float* g,
float* b);
float pfGetFogDensity(const pfFog* fog, float range);
void pfApplyFog(pfFog* fog);
pfColortable* pfGetCurCtab(void);
pfColortable* pfNewCtab(int size, void *arena);
pfType* pfGetCtabClassType(void);
int pfGetCtabSize(const pfColortable* ctab);
int pfCtabColor(pfColortable* ctab, int index,
pfVec4 acolor);
int pfGetCtabColor(const pfColortable* ctab, int index,
pfVec4 acolor);
pfVec4* pfGetCtabColors(const pfColortable* ctab);
void pfApplyCtab(pfColortable* ctab);
pfDataPool* pfCreateDPool(uint size, char* name);
pfDataPool* pfAttachDPool(char* name);
pfType* pfGetDPoolClassType(void);
const char* pfGetDPoolName(pfDataPool* dpool);
void pfDPoolAttachAddr(void *addr);
void* pfGetDPoolAttachAddr(void);
int pfGetDPoolSize(pfDataPool* dpool);
volatile void* pfDPoolAlloc(pfDataPool* dpool, uint size, int id);
volatile void* pfDPoolFind(pfDataPool* dpool, int id);
int pfDPoolFree(pfDataPool* dpool, void* dpmem);
int pfReleaseDPool(pfDataPool* dpool);
int pfDPoolLock(void* dpmem);
int pfDPoolSpinLock(void* dpmem, int spins, int block);
void pfDPoolUnlock(void* dpmem);
int pfDPoolTest(void* dpmem);
pfDispList* pfNewDList(int type, int size, void *arena);
pfType* pfGetDListClassType(void);
int pfGetDListSize(const pfDispList* dlist);
int pfGetDListType(const pfDispList* dlist);
int pfDrawDList(pfDispList* dlist);
void pfOpenDList(pfDispList* dlist);
void pfCloseDList(void);
void pfResetDList(pfDispList* dlist);
void pfAddDListCmd(int cmd);
void pfDListCallback(pfDListFuncType callback, int bytes,
void* data);
pfDispList* pfGetCurDList(void);
void pfDrawGLObj(GLOBJECT obj);
pfFont* pfNewFont(void *arena);
pfType* pfGetFontClassType(void);
void pfFontCharGSet(pfFont* font, int ascii, pfGeoSet *gset);
pfGeoSet* pfGetFontCharGSet(pfFont* font, int ascii);
void pfFontCharSpacing(pfFont* font, int ascii,
pfVec3 spacing);
const pfVec3* pfGetFontCharSpacing(pfFont* font, int ascii);
void pfFontAttr(pfFont* font, int which, void *attr);
void* pfGetFontAttr(pfFont* font, int which);
void pfFontVal(pfFont* font, int which, float val);
float pfGetFontVal(pfFont* font, int which);
void pfFontMode(pfFont* font, int mode, int val);
int pfGetFontMode(pfFont* font, int mode);
pfGeoSet* pfNewGSet(void *arena);
pfType* pfGetGSetClassType(void);
void pfGSetNumPrims(pfGeoSet* gset, int n);
int pfGetGSetNumPrims(const pfGeoSet* gset);
void pfGSetPrimType(pfGeoSet* gset, int type);
int pfGetGSetPrimType(const pfGeoSet* gset);
void pfGSetPrimLengths(pfGeoSet* gset, int *lengths);
int* pfGetGSetPrimLengths(const pfGeoSet* gset);
void pfGSetAttr(pfGeoSet* gset, int attr, int bind,
void* alist, ushort* ilist);
int pfGetGSetAttrBind(const pfGeoSet* gset, int attr);
void pfGetGSetAttrLists(const pfGeoSet* gset, int attr,
void** alist, ushort** ilist);
int pfGetGSetAttrRange(const pfGeoSet* gset, int attr,
int *min, int *max);
void pfGSetDrawMode(pfGeoSet* gset, int mode, int val);
int pfGetGSetDrawMode(const pfGeoSet* gset, int mode);
void pfGSetGState(pfGeoSet* gset, pfGeoState *gstate);
pfGeoState* pfGetGSetGState(const pfGeoSet* gset);
void pfGSetGStateIndex(pfGeoSet* gset, int id);
int pfGetGSetGStateIndex(const pfGeoSet* gset);
void pfGSetHlight(pfGeoSet* gset, pfHighlight *hlight);
pfHighlight* pfGetGSetHlight(const pfGeoSet* gset);
void pfGSetLineWidth(pfGeoSet* gset, float width);
float pfGetGSetLineWidth(const pfGeoSet* gset);
void pfGSetPntSize(pfGeoSet* gset, float s);
float pfGetGSetPntSize(const pfGeoSet* gset);
void pfGSetIsectMask(pfGeoSet* gset, uint mask, int setMode,
int bitOp);
uint pfGetGSetIsectMask(const pfGeoSet* gset);
void pfGSetDrawBin(pfGeoSet* gset, short bin);
int pfGetGSetDrawBin(const pfGeoSet* gset);
void pfGSetBBox(pfGeoSet* gset, pfBox* box, int mode);
int pfGetGSetBBox(pfGeoSet* gset, pfBox* box);
void pfDrawGSet(pfGeoSet* gset);
int pfQueryGSet(const pfGeoSet* gset, uint which, void *dst);
int pfMQueryGSet(const pfGeoSet* gset, uint *which,
void *dst);
int pfGSetIsectSegs(pfGeoSet* gset, pfSegSet *segSet,
pfHit **hits[]);
void pfDrawHlightedGSet(pfGeoSet* gset);
void pfGSetPassFilter(uint mask);
uint pfGetGSetPassFilter(void);
pfType* pfGetHitClassType(void);
int pfQueryHit(const pfHit* hit, uint which, void *dst);
int pfMQueryHit(const pfHit* hit, uint *which, void *dst);
pfGeoState* pfGetCurGState(void);
pfGeoState* pfGetCurIndexedGState(int index);
pfList* pfGetCurGStateTable(void);
pfGeoState* pfNewGState(void *arena);
pfType* pfGetGStateClassType(void);
void pfGStateMode(pfGeoState* gstate, int attr, int a);
int pfGetGStateMode(const pfGeoState* gstate, int attr);
int pfGetGStateCurMode(const pfGeoState* gstate, int attr);
int pfGetGStateCombinedMode(const pfGeoState* gstate,
int attr, const pfGeoState *combState);
void pfGStateVal(pfGeoState* gstate, int attr, float a);
float pfGetGStateVal(const pfGeoState* gstate, int attr);
float pfGetGStateCurVal(const pfGeoState* gstate, int attr);
float pfGetGStateCombinedVal(const pfGeoState* gstate,
int attr, const pfGeoState *combState);
void pfGStateInherit(pfGeoState* gstate, uint mask);
uint pfGetGStateInherit(const pfGeoState* gstate);
void pfGStateAttr(pfGeoState* gstate, int attr, void* a);
void* pfGetGStateAttr(const pfGeoState* gstate, int attr);
void* pfGetGStateCurAttr(const pfGeoState* gstate, int attr);
void* pfGetGStateCombinedAttr(const pfGeoState* gstate,
int attr, const pfGeoState *combState);
void pfLoadGState(pfGeoState* gstate);
void pfApplyGState(pfGeoState* gstate);
void pfMakeBasicGState(pfGeoState* gstate);
void pfApplyGStateTable(pfList *gstab);
pfHighlight * pfGetCurHlight(void);
pfHighlight* pfNewHlight(void *arena);
pfType* pfGetHlightClassType(void);
void pfHlightMode(pfHighlight* hlight, uint mode);
uint pfGetHlightMode(const pfHighlight* hlight);
pfGeoState* pfGetHlightGState(const pfHighlight* hlight);
void pfHlightGState(pfHighlight* hlight, pfGeoState *gstate);
void pfHlightGStateIndex(pfHighlight* hlight, int id);
int pfGetHlightGStateIndex(const pfHighlight* hlight);
void pfHlightColor(pfHighlight* hlight, uint which, float r,
float g, float b);
void pfGetHlightColor(const pfHighlight* hlight, uint which,
float *r, float *g, float *b);
void pfHlightAlpha(pfHighlight* hlight, float a);
float pfGetHlightAlpha(const pfHighlight* hlight);
void pfHlightNormalLength(pfHighlight* hlight, float len,
float bboxScale);
void pfGetHlightNormalLength(const pfHighlight* hlight,
float *len, float *bboxScale);
void pfHlightLineWidth(pfHighlight* hlight, float width );
float pfGetHlightLineWidth(const pfHighlight* hlight);
void pfHlightPntSize(pfHighlight* hlight, float size );
float pfGetHlightPntSize(const pfHighlight* hlight);
void pfHlightLinePat(pfHighlight* hlight, int which,
ushort pat);
ushort pfGetHlightLinePat(const pfHighlight* hlight, int which);
void pfHlightFillPat(pfHighlight* hlight, int which,
uint *fillPat );
void pfGetHlightFillPat(const pfHighlight* hlight, int which,
uint *pat);
void pfHlightTex(pfHighlight* hlight, pfTexture *tex);
pfTexture* pfGetHlightTex(const pfHighlight* hlight);
void pfHlightTEnv(pfHighlight* hlight, pfTexEnv *tev);
pfTexEnv* pfGetHlightTEnv(const pfHighlight* hlight);
void pfHlightTGen(pfHighlight* hlight, pfTexGen *tgen);
pfTexGen* pfGetHlightTGen(const pfHighlight* hlight);
void pfApplyHlight(pfHighlight* hlight);
int pfGetCurLights(pfLight *lights[PF_MAX_LIGHTS]);
pfLight* pfNewLight(void *arena);
pfType* pfGetLightClassType(void);
void pfLightColor(pfLight* light, int which, float r, float g,
float b);
void pfGetLightColor(const pfLight* light, int which,
float* r, float* g, float* b);
void pfLightAmbient(pfLight* light, float r, float g,
float b);
void pfGetLightAmbient(const pfLight* light, float* r,
float* g, float* b);
void pfLightPos(pfLight* light, float x, float y, float z,
float w);
void pfGetLightPos(const pfLight* light, float* x, float* y,
float* z, float* w);
void pfLightAtten(pfLight* light, float a0, float a1,
float a2);
void pfGetLightAtten(const pfLight* light, float* a0,
float* a1, float* a2);
void pfSpotLightDir(pfLight* light, float x, float y,
float z);
void pfGetSpotLightDir(const pfLight* light, float* x,
float* y, float* z);
void pfSpotLightCone(pfLight* light, float f1, float f2);
void pfGetSpotLightCone(const pfLight* light, float* f1,
float* f2);
void pfLightOn(pfLight* light);
void pfLightOff(pfLight* light);
int pfIsLightOn(pfLight* light);
pfLightModel* pfGetCurLModel(void);
pfLightModel* pfNewLModel(void *arena);
pfType* pfGetLModelClassType(void);
void pfLModelLocal(pfLightModel* lmodel, int l);
int pfGetLModelLocal(const pfLightModel* lmodel);
void pfLModelTwoSide(pfLightModel* lmodel, int t);
int pfGetLModelTwoSide(const pfLightModel* lmodel);
void pfLModelAmbient(pfLightModel* lmodel, float r, float g,
float b);
void pfGetLModelAmbient(const pfLightModel* lmodel, float* r,
float* g, float* b);
void pfLModelAtten(pfLightModel* lmodel, float a0, float a1,
float a2);
void pfGetLModelAtten(const pfLightModel* lmodel, float* a0,
float* a1, float* a2);
void pfApplyLModel(pfLightModel* lmodel);
pfLPointState* pfGetCurLPState(void);
pfLPointState* pfNewLPState(void *arena);
pfType* pfGetLPStateClassType(void);
void pfLPStateMode(pfLPointState* lpstate, int mode,
int val);
int pfGetLPStateMode(const pfLPointState* lpstate,
int mode);
void pfLPStateVal(pfLPointState* lpstate, int attr,
float val);
float pfGetLPStateVal(const pfLPointState* lpstate, int attr);
void pfLPStateShape(pfLPointState* lpstate, float horiz,
float vert, float roll, float falloff,
float ambient);
void pfGetLPStateShape(const pfLPointState* lpstate,
float *horiz, float *vert, float *roll,
float *falloff, float *ambient);
void pfLPStateBackColor(pfLPointState* lpstate, float r,
float g, float b, float a);
void pfGetLPStateBackColor(pfLPointState* lpstate, float *r,
float *g, float *b, float *a);
void pfApplyLPState(pfLPointState* lpstate);
void pfMakeLPStateRangeTex(pfLPointState* lpstate,
pfTexture *tex, int size, pfFog* fog);
void pfMakeLPStateShapeTex(pfLPointState* lpstate,
pfTexture *tex, int size);
pfMaterial* pfGetCurMtl(int side);
pfMaterial* pfNewMtl(void *arena);
pfType* pfGetMtlClassType(void);
void pfMtlSide(pfMaterial* mtl, int side);
int pfGetMtlSide(pfMaterial* mtl);
void pfMtlAlpha(pfMaterial* mtl, float alpha);
float pfGetMtlAlpha(pfMaterial* mtl);
void pfMtlShininess(pfMaterial* mtl, float shininess);
float pfGetMtlShininess(pfMaterial* mtl);
void pfMtlColor(pfMaterial* mtl, int acolor, float r, float g,
float b);
void pfGetMtlColor(pfMaterial* mtl, int acolor, float* r,
float* g, float* b);
void pfMtlColorMode(pfMaterial* mtl, int side, int mode);
int pfGetMtlColorMode(pfMaterial* mtl, int side);
void pfApplyMtl(pfMaterial* mtl);
pfSprite* pfGetCurSprite(void);
pfSprite* pfNewSprite(void *arena);
pfType* pfGetSpriteClassType(void);
void pfSpriteMode(pfSprite* sprite, int which, int val);
int pfGetSpriteMode(const pfSprite* sprite, int which);
void pfSpriteAxis(pfSprite* sprite, float x, float y, float z);
void pfGetSpriteAxis(pfSprite* sprite, float *x, float *y,
float *z);
void pfBeginSprite(pfSprite* sprite);
void pfEndSprite(void);
void pfPositionSprite(float x, float y, float z);
void pfInitState(usptr_t* arena);
pfState* pfGetCurState(void);
void pfPushState(void);
void pfPopState(void);
void pfGetState(pfGeoState *gstate);
void pfFlushState(void);
void pfBasicState(void);
void pfOverride(uint mask, int val);
uint pfGetOverride(void);
void pfModelMat(pfMatrix mat);
void pfGetModelMat(pfMatrix mat);
void pfViewMat(pfMatrix mat);
void pfGetViewMat(pfMatrix mat);
void pfTexMat(pfMatrix mat);
void pfGetTexMat(pfMatrix mat);
void pfInvModelMat(pfMatrix mat);
void pfGetInvModelMat(pfMatrix mat);
void pfNearPixDist(float pd);
float pfGetNearPixDist(void);
pfState* pfNewState(void);
pfType* pfGetStateClassType(void);
void pfSelectState(pfState* state);
void pfLoadState(pfState* state);
void pfAttachState(pfState* state, pfState *state1);
pfString* pfNewString(void *arena);
pfType* pfGetStringClassType(void);
int pfGetStringStringLength(const pfString* string);
void pfStringMode(pfString* string, int mode, int val);
int pfGetStringMode(const pfString* string, int mode);
void pfStringFont(pfString* string, pfFont* fnt);
pfFont* pfGetStringFont(const pfString* string);
void pfStringString(pfString* string, const char* cstr);
const char* pfGetStringString(const pfString* string);
const pfGeoSet* pfGetStringCharGSet(const pfString* string,
int index);
const pfVec3* pfGetStringCharPos(const pfString* string,
int index);
void pfStringSpacingScale(pfString* string, float sx,
float sy, float sz);
void pfGetStringSpacingScale(const pfString* string,
float *sx, float *sy, float *sz);
void pfStringGState(pfString* string, pfGeoState *gs);
const pfGeoState* pfGetStringGState(const pfString* string);
void pfStringColor(pfString* string, float r, float g,
float b, float a);
void pfGetStringColor(const pfString* string, float *r,
float *g, float *b, float *a);
void pfStringBBox(pfString* string, const pfBox* newbox);
const pfBox* pfGetStringBBox(const pfString* string);
void pfStringMat(pfString* string, const pfMatrix mat);
void pfGetStringMat(const pfString* string, pfMatrix mat);
void pfStringIsectMask(pfString* string, uint mask,
int setMode, int bitOp);
uint pfGetStringIsectMask(const pfString* string);
void pfDrawString(pfString* string);
void pfFlattenString(pfString* string);
int pfStringIsectSegs(pfString* string, pfSegSet *segSet,
pfHit **hits[]);
pfTexture* pfGetCurTex(void);
pfTexture* pfNewTex(void *arena);
pfType* pfGetTexClassType(void);
void pfTexName(pfTexture* tex, const char *name);
const char* pfGetTexName(const pfTexture* tex);
void pfTexImage(pfTexture* tex, uint* image, int comp, int sx,
int sy, int sz);
void pfGetTexImage(const pfTexture* tex, uint** image,
int* comp, int* sx, int* sy, int* sz);
void pfTexLoadImage(pfTexture* tex, uint* image);
uint* pfGetTexLoadImage(const pfTexture* tex);
void pfTexBorderColor(pfTexture* tex, pfVec4 clr);
void pfGetTexBorderColor(pfTexture* tex, pfVec4 *clr);
void pfTexBorderType(pfTexture* tex, int type);
int pfGetTexBorderType(pfTexture* tex);
void pfTexFormat(pfTexture* tex, int format, int type);
int pfGetTexFormat(const pfTexture* tex, int format);
void pfTexFilter(pfTexture* tex, int filt, int type);
int pfGetTexFilter(const pfTexture* tex, int filt);
void pfTexRepeat(pfTexture* tex, int wrap, int type);
int pfGetTexRepeat(const pfTexture* tex, int wrap);
void pfTexSpline(pfTexture* tex, int type, pfVec2 *pts,
float clamp);
void pfGetTexSpline(const pfTexture* tex, int type, pfVec2 *pts,
float *clamp);
void pfTexDetail(pfTexture* tex, int l, pfTexture *detail);
void pfGetTexDetail(const pfTexture* tex, int *l,
pfTexture **detail);
pfTexture* pfGetTexDetailTex(const pfTexture* tex);
void pfDetailTexTile(pfTexture* tex, int j, int k, int m, int n,
int scram);
void pfGetDetailTexTile(const pfTexture* tex, int *j, int *k,
int *m, int *n, int *scram);
void pfTexList(pfTexture* tex, pfList *list);
pfList* pfGetTexList(const pfTexture* tex);
void pfTexFrame(pfTexture* tex, float frame);
float pfGetTexFrame(const pfTexture* tex);
void pfTexLoadMode(pfTexture* tex, int mode, int val);
int pfGetTexLoadMode(const pfTexture* tex, int mode);
void pfTexLevel(pfTexture* tex, int level, pfTexture* ltex);
pfTexture* pfGetTexLevel(pfTexture* tex, int level);
void pfTexLoadOrigin(pfTexture* tex, int which, int xo, int yo);
void pfGetTexLoadOrigin(pfTexture* tex, int which, int *xo,
int *yo);
void pfTexLoadSize(pfTexture* tex, int xs, int ys);
void pfGetTexLoadSize(const pfTexture* tex, int *xs, int *ys);
void pfApplyTex(pfTexture* tex);
void pfFormatTex(pfTexture* tex);
void pfLoadTex(pfTexture* tex);
void pfLoadTexLevel(pfTexture* tex, int level);
void pfSubloadTex(pfTexture* tex, int source, uint *image,
int xsrc, int ysrc, int xdst, int ydst, int xsize,
int ysize);
void pfSubloadTexLevel(pfTexture* tex, int source, uint *image,
int xsrc, int ysrc, int xdst, int ydst, int xsize,
int ysize, int level);
int pfLoadTexFile(pfTexture* tex, char* fname);
void pfFreeTexImage(pfTexture* tex);
void pfIdleTex(pfTexture* tex);
int pfIsTexLoaded(const pfTexture* tex);
int pfIsTexFormatted(const pfTexture* tex);
pfTexEnv* pfGetCurTEnv(void);
pfTexEnv* pfNewTEnv(void *arena);
pfType* pfGetTEnvClassType(void);
void pfTEnvMode(pfTexEnv* tenv, int mode);
int pfGetTEnvMode(const pfTexEnv* tenv);
void pfTEnvComponent(pfTexEnv* tenv, int comp);
int pfGetTEnvComponent(const pfTexEnv* tenv);
void pfTEnvBlendColor(pfTexEnv* tenv, float r, float g, float b,
float a);
void pfGetTEnvBlendColor(pfTexEnv* tenv, float* r, float* g,
float* b, float* a);
void pfApplyTEnv(pfTexEnv* tenv);
pfTexGen* pfGetCurTGen(void);
pfTexGen* pfNewTGen(void *arena);
pfType* pfGetTGenClassType(void);
void pfTGenMode(pfTexGen* tgen, int texCoord, int mode);
int pfGetTGenMode(const pfTexGen* tgen, int texCoord);
void pfTGenPlane(pfTexGen* tgen, int texCoord, float x, float y,
float z, float d);
void pfGetTGenPlane(pfTexGen* tgen, int texCoord, float* x,
float* y, float* z, float* d);
void pfApplyTGen(pfTexGen* tgen);
pfType* pfGetCMemClassType(void);
pfCycleBuffer* pfGetCMemCBuffer(pfCycleMemory* cmem);
int pfGetCMemFrame(const pfCycleMemory* cmem);
pfCycleBuffer* pfNewCBuffer(size_t nbytes, void *arena);
pfType* pfGetCBufferClassType(void);
pfCycleMemory* pfGetCBufferCMem(const pfCycleBuffer* cBuf, int index);
void* pfGetCurCBufferData(const pfCycleBuffer* cBuf);
void pfCBufferChanged(pfCycleBuffer* cBuf);
void pfInitCBuffer(pfCycleBuffer* cBuf, void *data);
int pfCBufferConfig(int numBuffers);
int pfGetCBufferConfig(void);
int pfCBufferFrame(void);
int pfGetCBufferFrameCount(void);
int pfGetCurCBufferIndex(void);
void pfCurCBufferIndex(int index);
pfCycleBuffer* pfGetCBuffer(void *data);
pfType* pfGetMemoryClassType(void);
void* pfMalloc(size_t nbytes, void *arena);
void* pfCalloc(size_t numelem, size_t elsize, void *arena);
char* pfStrdup(const char *str, void *arena);
void* pfRealloc(void *data, size_t nbytes);
size_t pfGetSize(void *data);
void* pfGetArena(void *data);
void pfFree(void *data);
void* pfGetData(const void *data);
pfMemory* pfGetMemory(const void *data);
const char* pfGetTypeName(const void *data);
pfType* pfGetType(const void *data);
int pfIsOfType(const void *data, pfType *type);
int pfIsExactType(const void *data, pfType *type);
int pfRef(void* mem);
int pfUnref(void* mem);
ushort pfGetRef(const void* mem);
int pfCompare(const void* mem1, const void* mem2);
int pfPrint(const void* mem, uint travMode, uint verbose,
FILE* file);
int prDelete(void* mem);
int prUnrefDelete(void* mem);
int prCopy(void* dst, const void* src);
pfFile* pfOpenFile(char* fname, int oflag,
pfFile* pfCreateFile(char* fname, mode_t mode);
pfType* pfGetFileClassType(void);
int pfGetFileStatus(const pfFile* file, int attr);
int pfReadFile(pfFile* file, char* buf, int nbyte);
int pfWriteFile(pfFile* file, char* buf, int nbyte);
off_t pfSeekFile(pfFile* file, off_t off, int whence);
int pfCloseFile(pfFile* file);
pfList* pfNewList(int eltSize, int listLength, void *arena);
pfType* pfGetListClassType(void);
int pfGetListEltSize(const pfList* list);
void** pfGetListArray(const pfList* list);
void pfListArrayLen(pfList* list, int alen);
int pfGetListArrayLen(const pfList* list);
void pfNum(pfList* list, int newNum);
int pfGetNum(const pfList* list);
void pfSet(pfList* list, int index, void *elt);
void* pfGet(const pfList* list, int index);
void pfResetList(pfList* list);
void pfCombineLists(pfList* lists, const pfList *a,
const pfList *b);
void pfAdd(pfList* lists, void *elt);
void pfInsert(pfList* lists, int index, void *elt);
int pfSearch(const pfList* lists, void *elt);
int pfRemove(pfList* lists, void *elt);
void pfRemoveIndex(pfList* lists, int index);
int pfMove(pfList* lists, int index, void *elt);
int pfFastRemove(pfList* lists, void *elt);
void pfFastRemoveIndex(pfList* lists, int index);
int pfReplace(pfList* lists, void *oldElt, void *newElt);
pfWindow* pfNewWin(void *arena);
pfType* pfGetWinClassType(void);
void pfWinName(pfWindow* win, const char *name);
const char* pfGetWinName(const pfWindow* win);
void pfWinMode(pfWindow* win, int mode, int val);
int pfGetWinMode(const pfWindow* win, int mode);
void pfWinType(pfWindow* win, uint type);
uint pfGetWinType(const pfWindow* win);
pfState* pfGetWinCurState(const pfWindow* win);
void pfWinAspect(pfWindow* win, int x, int y);
void pfGetWinAspect(const pfWindow* win, int *x, int *y);
void pfWinOriginSize(pfWindow* win, int xo, int yo, int xs,
int ys);
void pfWinOrigin(pfWindow* win, int xo, int yo);
void pfGetWinOrigin(const pfWindow* win, int *xo, int *yo);
void pfWinSize(pfWindow* win, int xs, int ys);
void pfGetWinSize(const pfWindow* win, int *xs, int *ys);
void pfWinFullScreen(pfWindow* win);
void pfGetWinCurOriginSize(pfWindow* win, int *xo, int *yo,
int *xs, int *ys);
void pfGetWinCurScreenOriginSize(pfWindow* win, int *xo,
int *yo, int *xs, int *ys);
void pfWinOverlayWin(pfWindow* win, pfWindow *ow);
pfWindow* pfGetWinOverlayWin(const pfWindow* win);
void pfWinStatsWin(pfWindow* win, pfWindow *ow);
pfWindow* pfGetWinStatsWin(const pfWindow* win);
void pfWinScreen(pfWindow* win, int s);
int pfGetWinScreen(const pfWindow* win);
void pfWinShare(pfWindow* win, uint mode);
uint pfGetWinShare(const pfWindow* win);
void pfWinWSWindow(pfWindow* win, pfWSConnection dsp,
pfWSWindow wsWin);
pfWSWindow pfGetWinWSWindow(const pfWindow* win);
void pfWinWSDrawable(pfWindow* win, pfWSConnection dsp,
pfWSDrawable wsWin);
pfWSDrawable pfGetWinWSDrawable(const pfWindow* win);
pfWSDrawable pfGetWinCurWSDrawable(const pfWindow* win);
void pfWinWSConnectionName(pfWindow* win, const char *name);
const char* pfGetWinWSConnectionName(const pfWindow* win);
void pfWinFBConfigData(pfWindow* win, void *data);
void* pfGetWinFBConfigData(pfWindow* win);
void pfWinFBConfigAttrs(pfWindow* win, int *attr);
int* pfGetWinFBConfigAttrs(const pfWindow* win);
void pfWinFBConfig(pfWindow* win, pfFBConfig vInfo);
pfFBConfig pfGetWinFBConfig(const pfWindow* win);
void pfWinFBConfigId(pfWindow* win, int vId);
int pfGetWinFBConfigId(const pfWindow* win);
void pfWinIndex(pfWindow* win, int index);
int pfGetWinIndex(const pfWindow* win);
pfWindow* pfGetWinSelect(pfWindow* win);
void pfWinGLCxt(pfWindow* win, pfGLContext gCxt);
pfGLContext pfGetWinGLCxt(const pfWindow* win);
void pfWinList(pfWindow* win, pfList *wl);
pfList* pfGetWinList(const pfWindow* win);
void pfOpenWin(pfWindow* win);
void pfCloseWin(pfWindow* win);
void pfCloseWinGL(pfWindow* win);
int pfAttachWin(pfWindow* win, pfWindow *w1);
int pfDetachWin(pfWindow* win, pfWindow *w1);
pfWindow* pfSelectWin(pfWindow* win);
void pfSwapWinBuffers(pfWindow* win);
pfFBConfig pfChooseWinFBConfig(pfWindow* win, int *attr);
int pfIsWinOpen(const pfWindow* win);
int pfQueryWin(pfWindow* win, int which, int *dst);
int pfMQueryWin(pfWindow* win, int *which, int *dst);
pfWindow* pfOpenNewNoPortWin(const char *name, int screen);
pfStats* pfGetCurStats(void);
pfStats* pfNewStats(void *arena);
pfType* pfGetStatsClassType(void);
uint pfStatsClassMode(pfStats* stats, int class, uint mask,
int val);
uint pfGetStatsClassMode(pfStats* stats, int class);
void pfStatsAttr(pfStats* stats, int attr, float val);
float pfGetStatsAttr(pfStats* stats, int attr);
uint pfStatsClass(pfStats* stats, uint enmask, int val);
uint pfGetStatsClass(pfStats* stats, uint enmask);
uint pfGetOpenStats(pfStats* stats, uint enmask);
uint pfOpenStats(pfStats* stats, uint enmask);
uint pfCloseStats(uint enmask);
void pfResetStats(pfStats* stats);
void pfClearStats(pfStats* stats, uint which);
void pfAccumulateStats(pfStats* stats, pfStats* src, uint which);
void pfAverageStats(pfStats* stats, pfStats* src, uint which,
int num);
void pfCopyStats(pfStats* stats, const pfStats *src, uint which);
void pfStatsCountGSet(pfStats* stats, pfGeoSet * gset);
int pfQueryStats(pfStats* stats, uint which, void *dst, int size);
int pfMQueryStats(pfStats* stats, uint * which, void *dst,
int size);
void pfStatsHwAttr(int attr, float val);
float pfGetStatsHwAttr(int attr);
void pfEnableStatsHw(uint which);
void pfDisableStatsHw(uint which);
uint pfGetStatsHwEnable(uint which);
void pfFPConfig(int which, float val);
float pfGetFPConfig(int which);
void pfSinCos(float arg, float* s, float* c);
float pfTan(float arg);
float pfArcTan2(float y, float x);
float pfArcSin(float arg);
float pfArcCos(float arg);
float pfSqrt(float arg);
void pfSetVec2(pfVec2 vec2, float x, float y);
void pfCopyVec2(pfVec2 vec2, const pfVec2 v);
int pfEqualVec2(const pfVec2 vec2, const pfVec2 v);
int pfAlmostEqualVec2(const pfVec2 vec2, const pfVec2 v, float tol);
void pfNegateVec2(pfVec2 vec2, const pfVec2 v);
float pfDotVec2(const pfVec2 vec2, const pfVec2 v);
void pfAddVec2(pfVec2 vec2, const pfVec2 v1, const pfVec2 v2);
void pfSubVec2(pfVec2 vec2, const pfVec2 v1, const pfVec2 v2);
void pfScaleVec2(pfVec2 vec2, float s, const pfVec2 v);
void pfAddScaledVec2(pfVec2 vec2, const pfVec2 v1, float s,
const pfVec2 v2);
void pfCombineVec2(pfVec2 vec2, float a, const pfVec2 v1, float b,
const pfVec2 v2);
float pfSqrDistancePt2(const pfVec2 vec2, const pfVec2 v);
float pfNormalizeVec2(pfVec2 vec2);
float pfLengthVec2(const pfVec2 vec2);
float pfDistancePt2(const pfVec2 vec2, const pfVec2 v);
void pfSetVec3(pfVec3 vec3, float x, float y, float z);
void pfCopyVec3(pfVec3 vec3, const pfVec3 v);
int pfEqualVec3(const pfVec3 vec3, const pfVec3 v);
int pfAlmostEqualVec3(const pfVec3 vec3, const pfVec3 v, float tol);
void pfNegateVec3(pfVec3 vec3, const pfVec3 v);
float pfDotVec3(const pfVec3 vec3, const pfVec3 v);
void pfAddVec3(pfVec3 vec3, const pfVec3 v1, const pfVec3 v2);
void pfSubVec3(pfVec3 vec3, const pfVec3 v1, const pfVec3 v2);
void pfScaleVec3(pfVec3 vec3, float s, const pfVec3 v);
void pfAddScaledVec3(pfVec3 vec3, const pfVec3 v1, float s,
const pfVec3 v2);
void pfCombineVec3(pfVec3 vec3, float a, const pfVec3 v1, float b,
const pfVec3 v2);
float pfSqrDistancePt3(const pfVec3 vec3, const pfVec3 v);
float pfNormalizeVec3(pfVec3 vec3);
float pfLengthVec3(const pfVec3 vec3);
float pfDistancePt3(const pfVec3 vec3, const pfVec3 v);
void pfCrossVec3(pfVec3 vec3, const pfVec3 v1, const pfVec3 v2);
void pfXformVec3(pfVec3 vec3, const pfVec3 v, const pfMatrix m);
void pfXformPt3(pfVec3 vec3, const pfVec3 v, const pfMatrix m);
void pfFullXformPt3(pfVec3 vec3, const pfVec3 v, const pfMatrix m);
void pfSetVec4(pfVec4 vec4, float x, float y, float z, float w);
void pfCopyVec4(pfVec4 vec4, const pfVec4 v);
int pfEqualVec4(const pfVec4 vec4, const pfVec4 v);
int pfAlmostEqualVec4(const pfVec4 vec4, const pfVec4 v, float tol);
void pfNegateVec4(pfVec4 vec4, const pfVec4 v);
float pfDotVec4(const pfVec4 vec4, const pfVec4 v);
void pfAddVec4(pfVec4 vec4, const pfVec4 v1, const pfVec4 v2);
void pfSubVec4(pfVec4 vec4, const pfVec4 v1, const pfVec4 v2);
void pfScaleVec4(pfVec4 vec4, float s, const pfVec4 v);
void pfAddScaledVec4(pfVec4 vec4, const pfVec4 v1, float s,
const pfVec4 v2);
void pfCombineVec4(pfVec4 vec4, float a, const pfVec4 v1, float b,
const pfVec4 v2);
float pfSqrDistancePt4(const pfVec4 vec4, const pfVec4 v);
float pfNormalizeVec4(pfVec4 vec4);
float pfLengthVec4(const pfVec4 vec4);
float pfDistancePt4(const pfVec4 vec4, const pfVec4 v);
void pfXformVec4(pfVec4 vec4, const pfVec4 v, const pfMatrix m);
Some of these routines have macro equivalents which are described in the pfMatrix man page.
void pfSetMat(pfMatrix mat, float *m);
int pfGetMatType(const pfMatrix mat);
void pfSetMatRowVec3(pfMatrix mat, int r, const pfVec3 v);
void pfSetMatRow(pfMatrix mat, int r, float x, float y, float z,
float w);
void pfGetMatRowVec3(pfMatrix mat, int r, pfVec3 dst);
void pfGetMatRow(pfMatrix mat, int r, float *x, float *y, float *z,
float *w);
void pfSetMatColVec3(pfMatrix mat, int c, const pfVec3 v);
void pfSetMatCol(pfMatrix mat, int c, float x, float y, float z,
float w);
void pfGetMatColVec3(pfMatrix mat, int c, pfVec3 dst);
void pfGetMatCol(pfMatrix mat, int c, float *x, float *y, float *z,
float *w);
void pfGetOrthoMatCoord(pfMatrix mat, pfCoord* dst);
void pfMakeIdentMat(pfMatrix mat);
void pfMakeEulerMat(pfMatrix mat, float hdeg, float pdeg, float rdeg);
void pfMakeRotMat(pfMatrix mat, float degrees, float x, float y,
float z);
void pfMakeTransMat(pfMatrix mat, float x, float y, float z);
void pfMakeScaleMat(pfMatrix mat, float x, float y, float z);
void pfMakeVecRotVecMat(pfMatrix mat, const pfVec3 v1,
const pfVec3 v2);
void pfMakeCoordMat(pfMatrix mat, const pfCoord* c);
void pfGetOrthoMatQuat(pfMatrix mat, pfQuat dst);
void pfMakeQuatMat(pfMatrix mat, const pfQuat q);
void pfCopyMat(pfMatrix mat, const pfMatrix v);
int pfEqualMat(const pfMatrix mat, const pfMatrix m);
int pfAlmostEqualMat(const pfMatrix mat, const pfMatrix m2,
float tol);
void pfTransposeMat(pfMatrix mat, pfMatrix m);
void pfMultMat(pfMatrix mat, const pfMatrix m1, const pfMatrix m2);
void pfAddMat(pfMatrix mat, const pfMatrix m1, const pfMatrix m2);
void pfSubMat(pfMatrix mat, const pfMatrix m1, const pfMatrix m2);
void pfScaleMat(pfMatrix mat, float s, const pfMatrix m);
void pfPostMultMat(pfMatrix mat, const pfMatrix m);
void pfPreMultMat(pfMatrix mat, const pfMatrix m);
int pfInvertFullMat(pfMatrix mat, pfMatrix m);
void pfInvertAffMat(pfMatrix mat, const pfMatrix m);
void pfInvertOrthoMat(pfMatrix mat, const pfMatrix m);
void pfInvertOrthoNMat(pfMatrix mat, pfMatrix m);
void pfInvertIdentMat(pfMatrix mat, const pfMatrix m);
void pfPreTransMat(pfMatrix mat, float x, float y, float z,
pfMatrix m);
void pfPostTransMat(pfMatrix mat, const pfMatrix m, float x, float y,
float z);
void pfPreRotMat(pfMatrix mat, float degrees, float x, float y,
float z, pfMatrix m);
void pfPostRotMat(pfMatrix mat, const pfMatrix m, float degrees,
float x, float y, float z);
void pfPreScaleMat(pfMatrix mat, float xs, float ys, float zs,
pfMatrix m);
void pfPostScaleMat(pfMatrix mat, const pfMatrix m, float xs, float ys,
float zs);
void pfGetQuatRot(pfQuat quat, float *angle, float *x, float *y,
float *z);
void pfMakeRotQuat(pfQuat quat, float angle, float x, float y,
float z);
void pfConjQuat(pfQuat quat, const pfQuat v);
float pfLengthQuat(const pfQuat quat);
void pfMultQuat(pfQuat quat, const pfQuat q1, const pfQuat q2);
void pfDivQuat(pfQuat quat, const pfQuat q1, const pfQuat q2);
void pfInvertQuat(pfQuat quat, const pfQuat q1);
void pfExpQuat(pfQuat quat, const pfQuat q);
void pfLogQuat(pfQuat quat, const pfQuat q);
void pfSlerpQuat(pfQuat quat, float t, const pfQuat q1,
const pfQuat q2);
void pfSquadQuat(pfQuat quat, float t, const pfQuat q1,
const pfQuat q2, const pfQuat a, const pfQuat b);
void pfQuatMeanTangent(pfQuat quat, const pfQuat q1, const pfQuat q2,
const pfQuat q3);
pfMatStack* pfNewMStack(int size, void *arena);
pfType* pfGetMStackClassType(void);
void pfGetMStack(const pfMatStack* mst, pfMatrix m);
pfMatrix* pfGetMStackTop(const pfMatStack* mst);
int pfGetMStackDepth(const pfMatStack* mst);
void pfResetMStack(pfMatStack* mst);
int pfPushMStack(pfMatStack* mst);
int pfPopMStack(pfMatStack* mst);
void pfLoadMStack(pfMatStack* mst, const pfMatrix m);
void pfPreMultMStack(pfMatStack* mst, const pfMatrix m);
void pfPostMultMStack(pfMatStack* mst, const pfMatrix m);
void pfPreTransMStack(pfMatStack* mst, float x, float y,
float z);
void pfPostTransMStack(pfMatStack* mst, float x, float y,
float z);
void pfPreRotMStack(pfMatStack* mst, float degrees, float x,
float y, float z);
void pfPostRotMStack(pfMatStack* mst, float degrees, float x,
float y, float z);
void pfPreScaleMStack(pfMatStack* mst, float xs, float ys,
float zs);
void pfPostScaleMStack(pfMatStack* mst, float xs, float ys,
float zs);
void pfMakePtsSeg(pfSeg* seg, const pfVec3 p1, const pfVec3 p2);
void pfMakePolarSeg(pfSeg* seg, const pfVec3 pos, float azi,
float elev, float len);
void pfClipSeg(pfSeg* seg, const pfSeg *seg, float d1, float d2);
int pfClosestPtsOnSeg(const pfSeg* seg, const pfSeg *seg, pfVec3 dst1,
pfVec3 dst2);
void pfMakePtsPlane(pfPlane* plane, const pfVec3 p1, const pfVec3 p2,
const pfVec3 p3);
void pfMakeNormPtPlane(pfPlane* plane, const pfVec3 norm,
const pfVec3 pos);
void pfDisplacePlane(pfPlane* plane, float d);
int pfHalfSpaceContainsBox(const pfPlane* plane, const pfBox *box);
int pfHalfSpaceContainsSphere(const pfPlane* plane,
const pfSphere *sph);
int pfHalfSpaceContainsCyl(const pfPlane* plane,
const pfCylinder *cyl);
int pfHalfSpaceContainsPt(const pfPlane* plane, const pfVec3 pt);
void pfOrthoXformPlane(pfPlane* plane, const pfPlane *pln,
const pfMatrix m);
void pfClosestPtOnPlane(const pfPlane* plane, const pfVec3 pt,
pfVec3 dst);
int pfPlaneIsectSeg(const pfPlane* plane, const pfSeg *seg, float *d);
int pfHalfSpaceIsectSeg(const pfPlane* plane, const pfSeg *seg,
float *d1, float *d2);
void pfMakeEmptySphere(pfSphere* sphere);
int pfSphereContainsPt(const pfSphere* sphere, const pfVec3 pt);
int pfSphereContainsSphere(const pfSphere* sphere,
const pfSphere *sph);
int pfSphereContainsCyl(const pfSphere* sphere,
const pfCylinder *cyl);
void pfSphereAroundPts(pfSphere* sphere, const pfVec3* pts, int npt);
void pfSphereAroundSpheres(pfSphere* sphere, const pfSphere **sphs,
int nsph);
void pfSphereAroundBoxes(pfSphere* sphere, const pfBox **boxes,
int nbox);
void pfSphereAroundCyls(pfSphere* sphere, const pfCylinder **cyls,
int ncyl);
void pfSphereExtendByPt(pfSphere* sphere, const pfVec3 pt);
void pfSphereExtendBySphere(pfSphere* sphere, const pfSphere *sph);
void pfSphereExtendByCyl(pfSphere* sphere, const pfCylinder *cyl);
void pfOrthoXformSphere(pfSphere* sphere, const pfSphere *sph,
const pfMatrix m);
int pfSphereIsectSeg(const pfSphere* sphere, const pfSeg *seg,
float *d1, float *d2);
void pfMakeEmptyCyl(pfCylinder* cyl);
int pfCylContainsPt(const pfCylinder* cyl, const pfVec3 pt);
void pfOrthoXformCyl(pfCylinder* cyl, const pfCylinder *cyl,
const pfMatrix m);
void pfCylAroundPts(pfCylinder* cyl, const pfVec3 *pts, int npt);
void pfCylAroundSegs(pfCylinder* cyl, const pfSeg **segs, int nseg);
void pfCylAroundSpheres(pfCylinder* cyl, const pfSphere **sphs,
int nsph);
void pfCylAroundBoxes(pfCylinder* cyl, const pfBox **boxes, int nbox);
void pfCylExtendBySphere(pfCylinder* cyl, const pfSphere *sph);
void pfCylExtendByCyl(pfCylinder* cyl, const pfCylinder *cyl);
void pfCylExtendByBox(pfCylinder* cyl, const pfVec3 pt);
int pfCylIsectSeg(const pfCylinder* cyl, const pfSeg *seg, float *d1,
float *d2);
void pfMakeEmptyBox(pfBox* box);
int pfBoxContainsPt(const pfBox* box, const pfVec3 pt);
int pfBoxContainsBox(pfBox* box, const pfBox *inbox);
void pfXformBox(pfBox* box, const pfBox *box, const pfMatrix xform);
void pfBoxAroundPts(pfBox* box, const pfVec3 *pts, int npt);
void pfBoxAroundSpheres(pfBox* box, const pfSphere **sphs, int nsph);
void pfBoxAroundBoxes(pfBox* box, const pfBox **boxes, int nbox);
void pfBoxAroundCyls(pfBox* box, const pfCylinder **cyls, int ncyl);
void pfBoxExtendByPt(pfBox* box, const pfVec3 pt);
void pfBoxExtendByBox(pfBox* box, const pfBox *box);
int pfBoxIsectSeg(const pfBox* box, const pfSeg *seg, float *d1,
float *d2);
pfPolytope* pfNewPtope(void *arena);
pfType* pfGetPtopeClassType(void);
int pfGetPtopeNumFacets(pfPolytope* ptp);
int pfPtopeFacet(pfPolytope* ptp, int i, const pfPlane *p);
int pfGetPtopeFacet(pfPolytope* ptp, int i, pfPlane *p);
int pfRemovePtopeFacet(pfPolytope* ptp, int i);
void pfOrthoXformPtope(pfPolytope* ptp, const pfPolytope *src,
const pfMatrix mat);
int pfPtopeContainsPt(const pfPolytope* ptp, const pfVec3 pt);
int pfPtopeContainsSphere(const pfPolytope* ptp,
const pfSphere *sphere);
int pfPtopeContainsBox(const pfPolytope* ptp,
const pfBox *box);
int pfPtopeContainsCyl(const pfPolytope* ptp,
const pfCylinder *cyl);
int pfPtopeContainsPtope(const pfPolytope* ptp,
const pfPolytope *ptope);
pfFrustum* pfNewFrust(void *arena);
pfType* pfGetFrustClassType(void);
int pfGetFrustType(const pfFrustum* fr);
void pfFrustAspect(pfFrustum* fr, int which,
float widthHeightRatio);
float pfGetFrustAspect(const pfFrustum* fr);
void pfGetFrustFOV(const pfFrustum* fr, float* fovh,
float* fovv);
void pfFrustNearFar(pfFrustum* fr, float nearDist,
float farDist);
void pfGetFrustNearFar(const pfFrustum* fr, float* nearDist,
float* farDist);
void pfGetFrustNear(const pfFrustum* fr, pfVec3 ll, pfVec3 lr,
pfVec3 ul, pfVec3 ur);
void pfGetFrustFar(const pfFrustum* fr, pfVec3 ll, pfVec3 lr,
pfVec3 ul, pfVec3 ur);
void pfGetFrustPtope(const pfFrustum* fr, pfPolytope *dst);
void pfGetFrustGLProjMat(const pfFrustum* fr, pfMatrix mat);
int pfGetFrustEye(const pfFrustum* fr, pfVec3 eye);
void pfMakePerspFrust(pfFrustum* fr, float left, float right,
float bot, float top);
void pfMakeOrthoFrust(pfFrustum* fr, float left, float right,
float bot, float top);
void pfMakeSimpleFrust(pfFrustum* fr, float fov);
void pfOrthoXformFrust(pfFrustum* fr, const pfFrustum* fr2,
const pfMatrix mat);
int pfFrustContainsPt(const pfFrustum* fr, const pfVec3 pt);
int pfFrustContainsSphere(const pfFrustum* fr,
const pfSphere *sphere);
int pfFrustContainsBox(const pfFrustum* fr, const pfBox *box);
int pfFrustContainsCyl(const pfFrustum* fr,
const pfCylinder *cyl);
void pfApplyFrust(const pfFrustum* fr);
int pfTriIsectSeg(const pfVec3 pt1, const pfVec3 pt2, const pfVec3 pt3,
const pfSeg* seg, float* d);
libpfdu Functions
pfNode* pfdLoadFile(const char *file);
int pfdStoreFile(pfNode *root, const char *file);
pfNode* pfdConvertFrom(void *root, const char *ext);
void* pfdConvertTo(pfNode* root, const char *ext);
int pfdInitConverter(const char *ext);
int pfdExitConverter(const char *ext);
FILE* pfdOpenFile(const char *file);
void pfdAddExtAlias(const char *ext, const char *alias);
void pfdConverterMode(const char *ext, int mode, int value);
int pfdGetConverterMode(const char *ext, int mode);
void pfdConverterAttr(const char *ext, int which, void *attr);
void* pfdGetConverterAttr(const char *ext, int which);
void pfdConverterVal(const char *ext, int which, float val);
float pfdGetConverterVal(const char *ext, int which);
void pfdPrintSceneGraphStats(pfNode *node, double elapsedTime);
pfGeoSet * pfdNewCube(void *arena);
pfGeoSet * pfdNewSphere(int ntris, void *arena);
pfGeoSet * pfdNewCylinder(int ntris, void *arena);
pfGeoSet * pfdNewCone(int ntris, void *arena);
pfGeoSet * pfdNewPipe(float botRadius, float topRadius, int ntris,
void *arena);
pfGeoSet * pfdNewPyramid(void *arena);
pfGeoSet * pfdNewArrow(int ntris, void *arena);
pfGeoSet * pfdNewDoubleArrow(int ntris, void *arena);
pfGeoSet * pfdNewCircle(int ntris, void *arena);
pfGeoSet * pfdNewRing(int ntris, void *arena);
void pfdXformGSet(pfGeoSet *gset, pfMatrix mat);
void pfdGSetColor(pfGeoSet *gset, float r, float g, float b,
float a);
pfGeoSet* pfdMeshGSet(pfGeoSet *gset);
void pfdMesherMode(int mode, int val);
int pfdGetMesherMode(int mode);
void pfdShowStrips(pfGeoSet *gset);
pfNode* pfdCleanTree(pfNode *node, pfuTravFuncType doitfunc);
void pfdReplaceNode(pfNode *oldn, pfNode *newn);
void pfdInsertGroup(pfNode *oldn, pfGroup *grp);
void pfdRemoveGroup(pfGroup *oldn);
pfNode* pfdFreezeTransforms(pfNode *node, pfuTravFuncType doitfunc);
pfNode* pfdBreakup(pfGeode *geode, float geodeSize, int stripLength,
int geodeChild);
pfList * pfdTravGetGSets(pfNode *node);
pfGroup* pfdSpatialize(pfGroup *group, float maxGeodeSize,
int maxGeoSets);
pfdShare* pfdNewShare(void);
int pfdCleanShare(pfdShare *share);
void pfdDelShare(pfdShare *share, int deepDelete);
void pfdPrintShare(pfdShare *share);
int pfdCountShare(pfdShare *share);
pfList* pfdGetSharedList(pfdShare *share, pfType* type);
pfObject* pfdNewSharedObject(pfdShare *share, pfObject *object);
pfObject* pfdFindSharedObject(pfdShare *share, pfObject *object);
int pfdAddSharedObject(pfdShare *share, pfObject *object);
void pfdMakeShared(pfNode *node);
void pfdMakeSharedScene(pfScene *scene);
int pfdCleanShare(pfdShare *share);
int pfdRemoveSharedObject(pfdShare *share, pfObject *object);
pfList* pfdGetNodeGStateList(pfNode *node);
void pfdCombineLayers(pfNode *node);
void pfdCombineBillboards(pfNode *node, int sizeLimit);
pfdGeom* pfdNewGeom(int numV);
void pfdResizeGeom(pfdGeom *geom, int numV);
void pfdDelGeom(pfdGeom *geom);
int pfdReverseGeom(pfdGeom *geom);
pfdGeoBuilder* pfdNewGeoBldr(void);
void pfdDelGeoBldr(pfdGeoBuilder* bldr);
void pfdGeoBldrMode(pfdGeoBuilder* bldr, int mode, int val);
int pfdGetGeoBldrMode(pfdGeoBuilder* bldr, int mode);
int pfdTriangulatePoly(pfdGeom *pgon, pfdPrim *triList);
void pfdAddGeom(pfdGeoBuilder *bldr, pfdGeom *Geom, int num);
void pfdAddLineStrips(pfdGeoBuilder *bldr,
pfdGeom *lineStrips, int num);
void pfdAddLines(pfdGeoBuilder *bldr, pfdGeom *lines);
void pfdAddPoints(pfdGeoBuilder *bldr, pfdGeom *points);
void pfdAddPoly(pfdGeoBuilder *bldr, pfdGeom *poly);
void pfdAddIndexedLineStrips(pfdGeoBuilder *bldr,
pfdGeom *lines, int num);
void pfdAddIndexedLines(pfdGeoBuilder *bldr, pfdGeom *lines);
void pfdAddIndexedPoints(pfdGeoBuilder *bldr,
pfdGeom *points);
void pfdAddIndexedPoly(pfdGeoBuilder *bldr, pfdGeom *poly);
void pfdAddIndexedTri(pfdGeoBuilder *bldr, pfdPrim *tri);
void pfdAddLine(pfdGeoBuilder *bldr, pfdPrim *line);
void pfdAddPoint(pfdGeoBuilder *bldr, pfdPrim *Point);
void pfdAddTri(pfdGeoBuilder *bldr, pfdPrim *tri);
int pfdGetNumTris(pfdGeoBuilder *bldr);
const pfList* pfdBuildGSets(pfdGeoBuilder *bldr);
void pfdPrintGSet(pfGeoSet *gset);
void pfdInitBldr(void);
void pfdExitBldr(void);
pfdBuilder * pfdNewBldr(void);
void pfdDelBldr(pfdBuilder *bldr);
void pfdSelectBldr(pfdBuilder *bldr);
pfdBuilder * pfdGetCurBldr(void);
void pfdBldrDeleteNode(pfNode *node);
void pfdBldrMode(int mode, int val);
int pfdGetBldrMode(int mode);
void pfdBldrAttr(int which, void *attr);
void * pfdGetBldrAttr(int which);
pfObject * pfdGetTemplateObject(pfType *type);
void pfdResetObject(pfObject *obj);
void pfdResetAllTemplateObjects(void);
void pfdMakeDefaultObject(pfObject *obj);
void pfdResetBldrGeometry(void);
void pfdResetBldrShare(void);
void pfdCleanBldrShare(void);
void pfdCaptureDefaultBldrState(void);
void pfdResetBldrState(void);
void pfdPushBldrState(void);
void pfdPopBldrState(void);
void pfdSaveBldrState(void *name);
void pfdLoadBldrState(void *name);
void pfdBldrGState(const pfGeoState *gstate);
const pfGeoState * pfdGetBldrGState(void);
void pfdBldrStateVal(int which, float val);
float pfdGetBldrStateVal(int which);
void pfdBldrStateMode(int mode, int val);
int pfdGetBldrStateMode(int mode);
void pfdBldrStateAttr(int which, const void *attr);
const void * pfdGetBldrStateAttr(int attr);
void pfdBldrStateInherit(uint mask);
uint pfdGetBldrStateInherit(void);
void pfdSelectBldrName(void *name);
void * pfdGetCurBldrName(void);
void pfdAddBldrGeom(pfdGeom *p, int n);
void pfdAddIndexedBldrGeom(pfdGeom *p, int n);
pfNode * pfdBuild(void);
pfNode * pfdBuildNode(void *name);
void pfdDefaultGState(pfGeoState *def);
const pfGeoState* pfdGetDefaultGState(void);
void pfdMakeSceneGState(pfGeoState *sceneGState,
void pfdOptimizeGStateList(pfList *gstateList,
pfFont* pfdLoadFont(const char *ftype, const char *name, int style);
pfFont* pfdLoadFont_type1(const char *name, int style);
int pfdPreDrawTexgenExt(pfTraverser *trav, void *data);
int pfdPostDrawTexgenExt(pfTraverser *trav, void *data);
int pfdPreDrawReflMap(pfTraverser *trav, void *data);
int pfdPostDrawReflMap(pfTraverser *trav, void *data);
int pfdPreDrawContourMap(pfTraverser *trav, void *data);
int pfdPostDrawContourMap(pfTraverser *trav, void *data);
int pfdPreDrawLinearMap(pfTraverser *trav, void *data);
int pfdPostDrawLinearMap(pfTraverser *trav, void *data);
void pfdTexgenParams(const float *newParamsX, const float *newParamsY);
int pfdAddState(void *name, long dataSize,
void (*initialize)(void *data),
void (*deletor)(void *data),
int (*compare)(void *data1, void *data2),
long (*copy)(void *dst, void *src), int token);
void pfdStateCallback(int stateToken, int whichCBack,
pfNodeTravFuncType callback);
pfNodeTravFuncType pfdGetStateCallback(int stateToken, int which);
int pfdGetStateToken(void *name);
int pfdGetUniqueStateToken(void);
pfdExtensor* pfdNewExtensor(int which);
pfdExtensorType* pfdNewExtensorType(int token);
int pfdCompareExtensor(void *a, void *b);
int pfdCompareExtraStates(void *lista, void *listb);
void pfdCopyExtraStates(pfList *dst, pfList *src);
pfdExtensor* pfdGetExtensor(int token);
pfdExtensorType* pfdGetExtensorType(int token);
void * pfdUniqifyData(pfList *dataList, const void *data,
long dataSize, void *(*newData)(long),
int (*compare)(void *, void *),
long (*copy)(void *, void *),
int *compareResult);
void pfiInit(void);
pfType* pfiGetMotionCoordClassType(void);
pfiMotionCoord * pfiNewMotionCoord(void *arena);
pfType* pfiGetInputCoordClassType(void);
pfiInputCoord * pfiNewInputCoord(void *arena);
void pfiInputCoordVec(pfiInputCoord *ic, float *vec);
void pfiGetInputCoordVec(pfiInputCoord *ic, float *vec);
pfiInput * pfiNewInput(void *arena);
void pfiInputName(pfiInput *in, const char *name);
const char * pfiIsIXGetName(pfiInput *in);
void pfiInputFocus(pfiInput *in, int focus);
int pfiGetInputFocus(pfiInput *in);
void pfiInputEventMask(pfiInput *in, int emask);
int pfiGetInputEventMask(pfiInput *in);
void pfiInputEventStreamCollector(pfiInput *in,
pfiEventStreamHandlerType func,
void *data);
void pfiGetInputEventStreamCollector(pfiInput *in,
pfiEventStreamHandlerType *func,
void **data);
void pfiInputEventStreamProcessor(pfiInput *in,
pfiEventStreamHandlerType func,
void *data);
void pfiGetInputEventStreamProcessor(pfiInput *in,
pfiEventStreamHandlerType *func,
void **data);
void pfiInputEventHandler(pfiInput *in,
pfuEventHandlerFuncType func, void *data);
void pfiGetInputEventHandler(pfiInput *in,
pfuEventHandlerFuncType *func,
void **data);
void pfiResetInput(pfiInput *in);
void pfiCollectInputEvents(pfiInput *in);
void pfiProcessInputEvents(pfiInput *in);
int pfiHaveFastMouseClick(pfuMouse *mouse,
int button, float msecs);
pfiInputXform * pfiNewIXform(void *arena);
void pfiIXformFocus(pfiInputXform *in, int focus);
int pfiIsIXformInMotion(pfiInputXform *ix);
void pfiStopIXform(pfiInputXform *ix);
void pfiResetIXform(pfiInputXform *ix);
void pfiUpdateIXform(pfiInputXform *ix);
void pfiIXformMode(pfiInputXform *ix, int mode,
int val);
int pfiGetIXformMode(pfiInputXform *ix, int mode);
void pfiResetIXformPosition(pfiInputXform *ix);
void pfiIXformMat(pfiInputXform *ix, pfMatrix mat);
void pfiGetIXformMat(pfiInputXform *ix,
pfMatrix mat);
void pfiIXformInput(pfiInputXform *ix,
pfiInput *in);
pfiInput* pfiGetIXformInput(pfiInputXform *ix);
void pfiIXformInputCoordPtr(pfiInputXform *ix,
pfiInputCoord *xcoord);
pfiInputCoord* pfiGetIXformInputCoordPtr(pfiInputXform *ix);
void pfiIXformMotionCoord(pfiInputXform *ix,
pfiMotionCoord *xcoord);
void pfiGetIXformMotionCoord(pfiInputXform *ix,
pfiMotionCoord *xcoord);
void pfiIXformResetCoord(pfiInputXform *ix,
pfCoord *resetPos);
void pfiGetIXformResetCoord(pfiInputXform *ix,
pfCoord *resetPos);
void pfiIXformCoord(pfiInputXform *ix,
pfCoord *coord);
void pfiGetIXformCoord(pfiInputXform *ix,
pfCoord *coord);
void pfiIXformStartMotion(pfiInputXform *xf,
float startSpeed, float startAccel);
void pfiGetIXformStartMotion(pfiInputXform *xf,
float *startSpeed, float *startAccel);
void pfiIXformMotionLimits(pfiInputXform *xf,
float maxSpeed, float angularVel,
float maxAccel);
void pfiGetIXformMotionLimits(pfiInputXform *xf,
float *maxSpeed, float *angularVel,
float *maxAccel);
void pfiIXformDBLimits(pfiInputXform *xf,
pfBox *dbLimits);
void pfiGetIXformDBLimits(pfiInputXform *xf,
pfBox *dbLimits);
void pfiIXformBSphere(pfiInputXform *xf,
pfSphere *sphere);
void pfiGetIXformBSphere(pfiInputXform *xf,
pfSphere *sphere);
void pfiIXformUpudateFunc(pfiInputXform *ix,
pfiInputXformUpdateFuncType func,
void *data);
void pfiGetIXformUpudateFunc(pfiInputXform *ix,
pfiInputXformUpdateFuncType *func,
void **data);
void pfiIXformMotionFuncs(pfiInputXform *ix,
pfiInputXformFuncType start,
pfiInputXformFuncType stop, void *data);
void pfiGetIXformMotionFuncs(pfiInputXform *ix,
pfiInputXformFuncType *start,
pfiInputXformFuncType *stop, void **data);
pfiInputXformTrackball * pfiNewIXformTrackball(void *arena);
void pfiIXformTrackballMode(pfiInputXformTrackball *tb,
int mode, int val);
int pfiGetIXformTrackballMode(pfiInputXformTrackball *tb,
int mode);
pfiInputXformTrackball * pfiCreate2DIXformTrackball(void *arena);
int pfiUpdate2DIXformTrackball(pfiInputXform *tb,
pfiInputCoord *icoord, void *data);
pfType * pfiGetIXformTravelClassType(void);
pfType * pfiGetIXformDriveClassType(void);
pfType * pfiGetIXformFlyClassType(void);
pfType * pfiGetIXformTrackballClassType(void);
pfiInputXformDrive * pfiNewIXformDrive(void *arena);
void pfiIXformDriveMode(pfiInputXformDrive *drive,
int mode, int val);
int pfiGetIXformDriveMode(pfiInputXformDrive *drive,
int mode);
void pfiIXformDriveHeight(pfiInputXformDrive* drive,
float height);
float pfiGetIXformDriveHeight(pfiInputXformDrive* drive);
pfiInputXformDrive * pfiCreate2DIXformDrive(void *arena);
int pfiUpdate2DIXformDrive(pfiInputXform *drive,
pfiInputCoord *icoord, void *data);
pfiInputXformFly * pfiNewIXFly(void *arena);
void pfiIXformFlyMode(pfiInputXformFly *fly,
int mode, int val);
int pfiGetIXformFlyMode(pfiInputXformFly *fly,
int mode);
pfiInputXformFly * pfiCreate2DIXformFly(void *arnea);
int pfiUpdate2DIXformFly(pfiInputXform *fly,
pfiInputCoord *icoord, void *data);
pfType * pfiGetCollideClassType(void);
pfiCollide * pfiNewCollide(void *arena);
void pfiEnableCollide(pfiCollide *collide);
void pfiDisableCollide(pfiCollide *collide);
int pfiGetCollideEnable(pfiCollide *collide);
void pfiCollideMode(pfiCollide *collide, int mode, int val);
int pfiGetCollideMode(pfiCollide *collide, int mode);
void pfiCollideStatus(pfiCollide *collide, int status);
int pfiGetCollideStatus(pfiCollide *collide);
void pfiCollideDist(pfiCollide *collide, float dist);
float pfiGetCollideDist(pfiCollide *collide);
void pfiCollideHeightAboveGrnd(pfiCollide *collide,
float dist);
float pfiGetCollideHeightAboveGrnd(pfiCollide *collide);
void pfiCollideGroundNode(pfiCollide *collide, pfNode* ground);
pfNode * pfiGetCollideGroundNode(pfiCollide *collide);
void pfiCollideObjNode(pfiCollide *collide, pfNode* db);
pfNode * pfiGetCollideObjNode(pfiCollide *collide);
void pfiGetCollideMotionCoord(pfiCollide *collide,
pfiMotionCoord* xcoord);
void pfiCollideFunc(pfiCollide *collide,
pfiCollideFuncType func, void *data);
void pfiGetCollisionFunc(pfiCollide *collide,
pfiCollideFuncType *func, void **data);
int pfiUpdateCollide(pfiCollide *collide);
pfType * pfiGetPickClassType(void);
pfiPick * pfiNewPick(void *arena);
void pfiPickMode(pfiPick *pick, int mode, int val);
int pfiGetPickMode(pfiPick *pick, int mode);
void pfiPickHitFunc(pfiPick *pick, pfiPickFuncType func,
void *data);
void pfiGetPicktHitFunc(pfiPick *pick, pfiPickFuncType *func,
void **data);
void pfiAddPickChan(pfiPick *pick, pfChannel *chan);
void pfiInsertPickChan(pfiPick *pick, int index,
pfChannel *chan);
void pfiRemovePickChan(pfiPick *pick, pfChannel *chan);
int pfiGetPickNumHits(pfiPick *pick);
pfNode * pfiGetPickNode(pfiPick *pick);
pfGeoSet * pfiGetPickGSet(pfiPick *pick);
void pfiSetupPickChans(pfiPick *pick);
int pfiDoPick(pfiPick *pick, int x, int y);
void pfiResetPick(pfiPick *pick);
pfType* pfiGetXformerClassType(void);
pfiXformer * pfiNewXformer(void* arena);
void pfiXformerModel(pfiXformer* xf, int index,
pfiInputXform* model);
void pfiSelectXformerModel(pfiXformer* xf,
int which);
pfiInputXform* pfiGetXformerCurModel(pfiXformer* xf);
int pfiGetXformerCurModelIndex(pfiXformer* xf);
int pfiRemoveXformerModel(pfiXformer* xf,
int index);
int pfiRemoveXformerModelIndex(pfiXformer* xf,
pfiInputXform* model);
void pfiStopXformer(pfiXformer* xf);
void pfiResetXformer(pfiXformer* xf);
void pfiResetXformerPosition(pfiXformer* xf);
void pfiCenterXformer(pfiXformer* xf);
void pfiXformerAutoInput(pfiXformer* xf,
pfChannel* chan, pfuMouse* mouse,
pfuEventStream* events);
void pfiXformerMat(pfiXformer* xf, pfMatrix mat);
void pfiGetXformerMat(pfiXformer* xf,
pfMatrix mat);
void pfiXformerModelMat(pfiXformer* xf,
pfMatrix mat);
void pfiGetXformerModelMat(pfiXformer* xf,
pfMatrix mat);
void pfiXformerCoord(pfiXformer* xf,
pfCoord *coord);
void pfiGetXformerCoord(pfiXformer* xf,
pfCoord *coord);
void pfiXformerResetCoord(pfiXformer* xf,
pfCoord *resetPos);
void pfiGetXformerResetCoord(pfiXformer* xf,
pfCoord *resetPos);
void pfiXformerNode(pfiXformer* xf, pfNode *node);
pfNode * pfiGetXformerNode(pfiXformer* xf);
void pfiXformerAutoPosition(pfiXformer* xf,
pfChannel *chan, pfDCS *dcs);
void pfiGetXformerAutoPosition(pfiXformer* xf,
pfChannel **chan, pfDCS **dcs);
void pfiXformerLimits(pfiXformer* xf,
float maxSpeed, float angularVel,
float maxAccel, pfBox* dbLimits);
void pfiGetXformerLimits(pfiXformer* xf,
float *maxSpeed, float *angularVel,
float *maxAccel, pfBox* dbLimits);
void pfiEnableXformerCollision(pfiXformer* xf);
void pfiDisableXformerCollision(pfiXformer* xf);
int pfiGetXformerCollisionEnable(pfiXformer* xf);
void pfiXformerCollision(pfiXformer* xf, int mode,
float val, pfNode* node);
int pfiGetXformerCollisionStatus(pfiXformer* xf);
void pfiUpdateXformer(pfiXformer* xf);
int pfiCollideXformer(pfiXformer* xf);
pfType* pfiGetTDFXformerClassType(void);
pfiTDFXformer * pfiNewTDFXformer(void* arena);
pfiXformer * pfiCreateTDFXformer( pfiInputXformTrackball *tb,
pfiInputXformDrive *drive,
pfiInputXformFly *fly, void *arena);
void pfiTDFXformerStartMotion(pfiTDFXformer* xf,
float startSpeed, float startAccel,
float accelMult);
void pfiGetTDFXformerStartMotion(pfiTDFXformer* xf,
float *startSpeed, float *startAccel,
float *accelMult);
void pfiTDFXformerFastClickTime(pfiTDFXformer* xf,
float time);
float pfiGetTDFXformerFastClickTime(pfiXformer* xf);
void pfiTDFXformerTrackball(pfiTDFXformer *xf,
pfiInputXformTrackball *tb);
pfiInputXformTrackball * pfiGetTDFXformerTrackball(pfiTDFXformer *xf);
void pfiTDFXformerDrive(pfiTDFXformer *xf,
pfiInputXformDrive *tb);
pfiInputXformFly * pfiGetTDFXformerFly(pfiTDFXformer *xf);
void pfiTDFXformerFly(pfiTDFXformer *xf,
pfiInputXformFly *tb);
pfiInputXformDrive * pfiGetTDFXformerDrive(pfiTDFXformer *xf);
int pfiProcessTDFXformerMouseEvents(pfiInput *,
pfuEventStream *, void *data);
void pfiProcessTDFXformerMouse(pfiTDFXformer *xf,
pfuMouse *mouse, pfChannel *inputChan);
void pfiProcessTDFTrackballMouse(pfiTDFXformer *xf,
pfiInputXformTrackball *trackball,
pfuMouse *mouse);
void pfiProcessTDFTravelMouse(pfiTDFXformer *xf,
pfiInputXformTravel *tr, pfuMouse *mouse);
void pfuInitUtil(void);
pfDataPool* pfuGetUtilDPool(void);
void pfuExitUtil(void);
void pfuDPoolSize(long size);
long pfuGetDPoolSize(void);
volatile void* pfuFindUtilDPData(int id);
int pfuFreeCPUs(void);
int pfuRunProcOn(int cpu);
int pfuLockDownProc(int cpu);
int pfuLockDownApp(void);
int pfuLockDownCull(pfPipe *);
int pfuLockDownDraw(pfPipe *);
int pfuPrioritizeProcs(int onOff);
void pfuInitRendezvous(pfuRendezvous *rvous, int numSlaves);
void pfuMasterRendezvous(pfuRendezvous *rvous);
void pfuSlaveRendezvous(pfuRendezvous *rvous, int id);
pfuXDisplay * pfuOpenXDisplay(int screen);
pfuGLXWindow * pfuGLXWinopen(pfPipe *p, pfPipeWindow *pw,
const char *name);
void pfuGetGLXWin(pfPipe *pipe, pfuGLXWindow *glxWin);
const char * pfuGetGLXDisplayString(pfPipe *pipe);
void pfuGLMapcolors(pfVec3 *clrs, int start, int num);
int pfuGLXAllocColormap(pfuXDisplay *dsp, pfuXWindow w);
void pfuGLXMapcolors(pfuXDisplay *dsp, pfuXWindow w,
pfVec3 *clrs, int loc, int num);
void pfuMapWinColors(pfWindow *w, pfVec3 *clrs, int start,
int num);
void pfuMapPWinColors(pfPipeWindow *pwin, pfVec3 *clrs,
int start, int num);
void pfuPrintWinFBConfig(pfWindow *win, FILE *file);
void pfuPrintPWinFBConfig(pfPipeWindow *pwin, FILE *file);
pfFBConfig pfuChooseFBConfig(Display *dsp, int screen,
int *constraints, void *arena);
pfuEventQueue * pfuNewEventQ(pfDataPool *dp, int id);
void pfuResetEventStream(pfuEventStream *es);
void pfuResetEventQ(pfuEventQueue *eq);
void pfuAppendEventQ(pfuEventQueue *eq0,
pfuEventQueue *eq1);
void pfuAppendEventQStream(pfuEventQueue *eq,
pfuEventStream *es);
void pfuEventQStream(pfuEventQueue *eq,
pfuEventStream *es);
pfuEventStream * pfuGetEventQStream(pfuEventQueue *eq);
void pfuGetEventQEvents(pfuEventStream *events,
pfuEventQueue *eq);
void pfuIncEventQFrame(pfuEventQueue *eq);
void pfuEventQFrame(pfuEventQueue *eq, int val);
int pfuGetEventQFrame(pfuEventQueue *eq);
void pfuIncEventStreamFrame(pfuEventStream *es);
void pfuEventStreamFrame(pfuEventStream *es, int val);
int pfuGetEventStreamFrame(pfuEventStream *es);
void pfuInitInput(pfPipeWindow *pw, int mode);
void pfuExitInput(void);
int pfuMapMouseToChan(pfuMouse *mouse, pfChannel *chan);
int pfuMouseInChan(pfuMouse *mouse, pfChannel *chan);
void pfuCollectInput(void);
void pfuCollectGLEventStream(pfuEventStream *events,
pfuMouse *mouse, int handlerMask,
pfuEventHandlerFuncType handlerFunc);
void pfuCollectXEventStream(pfWSConnection dsp,
pfuEventStream *events, pfuMouse *mouse,
int handlerMask,
pfuEventHandlerFuncType handlerFunc);
void pfuGetMouse(pfuMouse *mouse);
void pfuGetEvents(pfuEventStream *events);
void pfuInputHandler(pfuEventHandlerFuncType userFunc,
uint mask);
void pfuMouseButtonClick(pfuMouse *mouse,
void pfuMouseButtonRelease(pfuMouse *mouse,
double pfuMapXTime(double xtime);
Cursor pfuGetInvisibleCursor(void);
void pfuLoadPWinCursor(pfPipeWindow *w, Cursor c);
void pfuLoadWinCursor(pfWindow *w, Cursor c);
Cursor pfuCreateDftCursor(int index);
void pfuCursor(Cursor c, int index);
Cursor pfuGetCursor(int index);
void pfuInitGUICursors(void);
void pfuGUICursor(int target, Cursor c);
Cursor pfuGetGUICursor(int target);
void pfuGUICursorSel(Cursor sel);
Cursor pfuGetGUICursorSel(void);
void pfuUpdateGUICursor(void);
void pfuLoadXFont(char *fontName, pfuXFont *fnt);
void pfuMakeXFontBitmaps(pfuXFont *fnt);
void pfuMakeRasterXFont(char *fontName, pfuXFont *font);
void pfuSetXFont(pfuXFont *);
void pfuGetCurXFont(pfuXFont *);
int pfuGetXFontWidth(pfuXFont *, const char *);
int pfuGetXFontHeight(pfuXFont *);
void pfuCharPos(float x, float y, float z);
void pfuDrawString(const char *s);
void pfuDrawStringPos(const char *s, float x, float y, float z);
void pfuInitGUI(pfPipeWindow *pw);
void pfuExitGUI(void);
void pfuEnableGUI(int en);
void pfuUpdateGUI(pfuMouse *mouse);
void pfuRedrawGUI(void);
void pfuGUIViewport(float l, float r, float b,
float t);
void pfuGetGUIViewport(float *l, float *r, float *b,
float *t);
int pfuInGUI(int x, int y);
void pfuFitWidgets(int val);
void pfuGetGUIScale(float *x, float *y);
void pfuGetGUITranslation(float *x, float *y);
void pfuGUIHlight(pfHighlight *hlight);
pfHighlight * pfuGetGUIHlight(void);
pfuPanel* pfuNewPanel(void);
void pfuEnablePanel(pfuPanel *p);
void pfuDisablePanel(pfuPanel *p);
void pfuGetPanelOriginSize(pfuPanel *p, float *xo,
float *yo, float *xs, float *ys);
pfuWidget * pfuNewWidget(pfuPanel *p, int type, int id);
int pfuGetWidgetType(pfuWidget *w);
void pfuEnableWidget(pfuWidget *w);
void pfuDisableWidget(pfuWidget *w);
int pfuGetWidgetId(pfuWidget *w);
void pfuWidgetDim(pfuWidget *w, int xo, int yo,
int xs, int ys);
void pfuGetWidgetDim(pfuWidget *w, int *xo, int *yo,
int *xs, int *ys);
void pfuWidgetLabel(pfuWidget *w,
const char *label);
int pfuGetWidgetLabelWidth(pfuWidget *w);
const char * pfuGetWidgetLabel(pfuWidget *w);
void pfuWidgetRange(pfuWidget *w, int mode,
float min, float max, float val);
void pfuWidgetValue(pfuWidget *w, float val);
float pfuGetWidgetValue(pfuWidget *w);
void pfuWidgetDefaultValue(pfuWidget *w, float val);
void pfuWidgetDrawFunc(pfuWidget *w,
pfuWidgetDrawFuncType func);
void pfuWidgetSelectFunc(pfuWidget *w,
pfuWidgetSelectFuncType func);
void pfuWidgetActionFunc(pfuWidget *w,
pfuWidgetActionFuncType func);
pfuWidgetActionFuncType pfuGetWidgetActionFunc(pfuWidget *w);
pfuWidgetSelectFuncType pfuGetWidgetSelectFunc(pfuWidget *w);
pfuWidgetDrawFuncType pfuGetWidgetDrawFunc(pfuWidget *w);
void pfuWidgetSelections(pfuWidget *w,
pfuGUIString *attrList, int *valList,
void (**funcList)(pfuWidget *w),
int numSelections);
void pfuWidgetSelection(pfuWidget *w, int index);
int pfuGetWidgetSelection(pfuWidget *w);
void pfuWidgetDefaultSelection(pfuWidget *w,
int index);
void pfuWidgetDefaultOnOff(pfuWidget * w, int on);
void pfuWidgetOnOff(pfuWidget *w, int on);
int pfuIsWidgetOn(pfuWidget *w);
void pfuResetGUI(void);
void pfuResetPanel(pfuPanel *p);
void pfuResetWidget(pfuWidget *w);
void pfuDrawTree(pfChannel *chan, pfNode *node,
pfVec3 panXYScale);
void pfuDrawMessage(pfChannel *chan,
const char *msg, int rel, int just,
float x, float y, int size, int cmode);
void pfuDrawMessageCI(pfChannel *chan,
const char *msg, int rel, int just,
float x, float y, int size, int textClr,
int shadowClr);
void pfuDrawMessageRGB(pfChannel *chan,
const char *msg, int rel, int just,
float x, float y, int size, pfVec4 textClr,
pfVec4 shadowClr);
int pfuTravCountNumVerts(pfNode *node);
int pfuTraverse(pfNode *node, pfuTraverser *trav);
void pfuInitTraverser(pfuTraverser *trav);
void pfuTravCalcBBox(pfNode *node, pfBox *box);
void pfuTravCountDB(pfNode *node, pfFrameStats *fstats);
void pfuTravGLProf(pfNode *node, int mode);
void pfuTravNodeAttrBind(pfNode *node, uint attr, uint bind);
void pfuTravNodeHlight(pfNode *node, pfHighlight *hl);
void pfuTravPrintNodes(pfNode *node, const char *fname);
int pfuCalcDepth(pfNode *node);
void pfuTravCachedCull(pfNode* node, int numChans);
void pfuTileChans(pfChannel **chn, int nChans, int ntilesx,
int ntilesy);
void pfuConfigMCO(pfChannel **chn, int nChans);
int pfuGetMCOChannels(pfPipe *p);
void pfuTileChan(pfChannel **chn, int thisChan, int nChans, float l,
float r, float b, float t);
int pfuManageMPipeStats(int nFrames, int nSampledPipes);
pfuPath * pfuNewPath(void);
pfuPath * pfuSharePath(pfuPath *path);
pfuPath * pfuCopyPath(pfuPath *path);
pfuPath * pfuClosePath(pfuPath *path);
int pfuFollowPath(pfuPath *path, float seconds, pfVec3 where,
pfVec3 orient);
int pfuPrintPath(pfuPath *path);
int pfuAddPath(pfuPath *path, pfVec3 first, pfVec3 final);
int pfuAddArc(pfuPath *path, pfVec3 center, float radius,
pfVec2 angles);
int pfuAddFillet(pfuPath *path, float radius);
int pfuAddSpeed(pfuPath *path, float desired, float rate);
int pfuAddDelay(pfuPath *path, float delay);
int pfuAddFile(pfuPath *path, char *name);
void pfuCollisionChan(pfChannel *chan);
pfChannel* pfuGetCollisionChan(void);
void pfuCollideSetup(pfNode *node, int mode, int mask);
int pfuCollideGrnd(pfCoord *coord, pfNode *node, pfVec3 zpr);
int pfuCollideGrndObj(pfCoord *coord, pfNode *grndNode,
pfVec3 zpr, pfSeg *seg, pfNode *objNode, pfVec3 hitPos,
pfVec3 hitNorm);
int pfuCollideObj(pfSeg *seg, pfNode *objNode, pfVec3 hitPos,
pfVec3 hitNorm);
pfuTimer* pfuNewTimer(void *arena, int size);
void pfuInitTimer(pfuTimer *timer, double start, double delta,
void (*func)(pfuTimer*), void *data);
void pfuStartTimer(pfuTimer *timer);
void pfuStopTimer(pfuTimer *timer);
void pfuEvalTimers(void);
int pfuEvalTimer(pfuTimer *timer);
int pfuActiveTimer(pfuTimer * timer);
pfuHashTable* pfuNewHTable(int numb, int eltsize, void* arena);
void pfuDelHTable(pfuHashTable* ht);
void pfuResetHTable(pfuHashTable* ht);
pfuHashElt* pfuEnterHash(pfuHashTable* ht, pfuHashElt* elt);
int pfuRemoveHash(pfuHashTable* ht, pfuHashElt* elt);
int pfuFindHash(pfuHashTable* ht, pfuHashElt* elt);
int pfuHashGSetVerts(pfGeoSet *gset);
int pfuCalcHashSize(int size);
pfLOD* pfuBoxLOD(pfGroup *grp, int flat, pfVec4* clr);
pfGeoSet* pfuMakeBoxGSet(pfBox *box, pfVec4 clr, int flat);
pfTexture* pfuNewSharedTex(const char *filename, void *arena);
pfList* pfuGetSharedTexList(void);
pfList * pfuMakeTexList(pfNode *node);
pfList * pfuMakeSceneTexList(pfScene *node);
void pfuDownloadTexList(pfList *list, int style);
int pfuGetTexSize(pfTexture *tex);
void pfuNewTexList(pfTexture *tex);
pfList * pfuLoadTexListFiles(pfList *movieTexList,
char nameList[][PF_MAXSTRING], int len);
pfList * pfuLoadTexListFmt(pfList *movieTexList,
const char *fmtStr, int start, int end);
pfSequence * pfuNewProjector(pfTexture *handle);
int pfuProjectorPreDrawCB(pfTraverser *trav, void *travData);
void pfuRandomize(int seed);
long pfuRandomLong(void);
float pfuRandomFloat(void);
void pfuRandomColor(pfVec4 rgba, float minColor, float maxColor);
int pfuOpenFlybox(char *p);
int pfuReadFlybox(int *dioval, float *inbuf);
int pfuGetFlybox(float *analog, int *but);
int pfuGetFlyboxActive(void);
int pfuInitFlybox(void);
void pfuInitSmokes(void);
pfuSmoke * pfuNewSmoke(void);
void pfuSmokeType(pfuSmoke *smoke, int type);
void pfuSmokeOrigin(pfuSmoke* smoke, pfVec3 origin,
float radius);
void pfuSmokeDir(pfuSmoke* smoke, pfVec3 dir);
void pfuSmokeVelocity(pfuSmoke* smoke, float turbulence,
float speed);
void pfuGetSmokeVelocity(pfuSmoke* smoke, float *turbulence,
float *speed);
void pfuSmokeMode(pfuSmoke* smoke, int mode);
void pfuDrawSmokes(pfVec3 eye);
void pfuSmokeTex(pfuSmoke* smoke, pfTexture* tex);
void pfuSmokeDuration(pfuSmoke* smoke, float dur);
void pfuSmokeDensity(pfuSmoke* smoke, float dens, float diss,
float expansion);
void pfuGetSmokeDensity(pfuSmoke* smoke, float *dens,
float *diss, float *expansion);
void pfuSmokeColor(pfuSmoke* smoke, pfVec3 bgn, pfVec3 end);
void pfuMakeLPStateShapeTex(pfLPointState *lps, pfTexture *tex,
int size);
void pfuMakeLPStateRangeTex(pfLPointState *lps, pfTexture *tex,
int size, pfFog *fog);
void pfuPreDrawStyle(int style, pfVec4 scribeColor);
void pfuPostDrawStyle(int style);
void pfuCalcNormalizedChanXY(float* px, float* py, pfChannel* chan,
int xpos, int ypos);
int pfuSaveImage(char* name, int xorg, int yorg, int xsize, int ysize,
int saveAlpha);
Compiled by: Allan Schaffer