IRIS Performer 1.2 API

"The Performer"

IRIS Performer Application Programming Interface (API)

libpf Functions

Initialization

long pfInit(void);

void pfExit(void);

long pfMultipipe(long numPipes);

long pfGetMultipipe(void);

long pfHyperpipe(long numHyperPipes);

long pfGetHyperpipe(pfPipe *pipe);

long pfMultiprocess(long mpMode);

long pfGetMultiprocess(void);

long pfConfig(void);

pid_t pfGetPID(long pipe, long proc);

long pfGetStage(pid_t pid, long *pipe);

Frame Control

long pfSync(void);

long pfFrame(void);

void pfDraw(void);

void pfCull(void);

void pfIsectFunc(pfIsectFuncType func);

pfIsectFuncType pfGetIsectFunc(void);

void *pfAllocIsectData(long bytes);

void *pfGetIsectData(void);

void pfPassIsectData(void);

void pfPhase(long phase);

long pfGetPhase(void);

float pfGetVideoRate(void);

float pfFrameRate(float rate);

float pfGetFrameRate(void);

long pfFieldRate(long fields);

long pfGetFieldRate(void);

long pfGetFrameCount(void);

pfObject

long pfGetId(void *unknown);

long pfGetType(pfObject *obj);

const char *pfGetTypeName(pfObject *obj);

long pfRef(pfObject *obj);

long pfUnref(pfObject *obj);

long pfUnrefDelete(pfObject *obj);

long pfGetRef(pfObject *obj);

long pfUserData(pfObject *obj, void *data);

void *pfGetUserData(pfObject *obj);

long pfCopy(pfObject *dst, pfObject *src);

long pfDelete(pfObject *obj);

void pfPrint(pfObject *pf, ulong travMode, ulong verbose, FILE *file);

void pfCopyFunc(void(*func)(pfObject *dst, pfObject *src));

void pfDeleteFunc(void(*func)(pfObject *obj));

void pfPrintFunc(void(*func)(pfObject *obj, ulong which, ulong verbose, FILE *file));

long pfGetGLHandle(pfObject *obj);

pfPipe

pfPipe *pfGetPipe(long pipeNum);

long pfGetHyperId(pfPipe *pipe);

long pfInitPipe(pfPipe *pipe, void(*initFunc)(pfPipe *));

void pfInitGfx(pfPipe *pipe);

void pfGetPipeOrigin(pfPipe *pipe, long *xo, long *yo);

void pfGetPipeSize(pfPipe *pipe, long *xs, long *ys);

long pfGetPipeScreen(pfPipe *pipe);

void pfPipeSwapFunc(pfPipe *pipe, pfPipeSwapFuncType func);

pfPipeSwapFuncType pfGetPipeSwapFunc(pfPipe *pipe);

void pfInitGLXGfx(pfPipe *pipe, void *display, ulong xWin, ulong glWin, ulong overWin, ulong mode);

long pfGetPipeWin(pfPipe *pipe);

void pfGetPipeGLXWins(pfPipe *pipe, void** display, ulong *xWin, ulong *glWin, ulong *overWin, ulong *mode);

pfChannel

pfChannel *pfNewChan(pfPipe *pipe);

pfPipe *pfGetChanPipe(pfChannel *chan);

void pfChanViewport(pfChannel *chan, float l, float r, float b, float t);

void pfGetChanViewport(pfChannel *chan, float *l, float *r, float *b, float *t);

void pfGetChanOrigin(pfChannel *chan, long *xo, long *yo);

void pfGetChanSize(pfChannel *chan, long *xs, long *ys);

long pfAttachChan(pfChannel *chan0, pfChannel *chan1);

long pfDetachChan(pfChannel *chan0, pfChannel *chan1);

void pfChanShare(pfChannel *chan0, ulong mask);

ulong pfGetChanShare(pfChannel *chan0);

void pfChanFOV(pfChannel *chan, float horiz, float vert);

void pfGetChanFOV(pfChannel *chan, float *horiz, float *vert);

void pfChanAutoAspect(pfChannel *chan, long which);

long pfGetChanAutoAspect(pfChannel *chan);

void pfChanNearFar(pfChannel *chan, float near, float far);

void pfGetChanNearFar(pfChannel *chan, float *near, float *far);

void pfGetChanBaseFrust(pfChannel *chan, pfFrustum *frust);

void pfChanViewOffsets(pfChannel *chan, pfVec3 xyz, pfVec3 hpr);

void pfGetChanViewOffsets(pfChannel *chan, pfVec3 xyz, pfVec3 hpr);

void pfChanView(pfChannel *chan, pfVec3 xyz, pfVec3 hpr);

void pfGetChanView(pfChannel *chan, pfVec3 xyz, pfVec3 hpr);

void pfChanViewMat(pfChannel *chan, pfMatrix mat);

void pfGetChanViewMat(pfChannel *chan, pfMatrix mat);

void *pfAllocChanData(pfChannel *chan, long size);

void *pfGetChanData(pfChannel *chan);

void pfPassChanData(pfChannel *chan);

void pfChanCullFunc(pfChannel *chan, pfChanFuncType func);

pfChanFuncType pfGetChanCullFunc(pfChannel *chan);

void pfChanDrawFunc(pfChannel *chan, pfChanFuncType func);

pfChanFuncType pfGetChanDrawFunc(pfChannel *chan);

void pfChanTravMode(pfChannel *chan, long trav, long mode);

long pfGetChanTravMode(pfChannel *chan, long trav);

void pfChanTravMask(pfChannel *chan, long which, ulong mask);

ulong pfGetChanTravMask(pfChannel *chan, long which);

void pfChanStressFilter(pfChannel *chan, float frac, float low, float high, float param, float max);

void pfGetChanStressFilter(pfChannel *chan, float *frac, float *low, float *high, float *param, float *max);

void pfChanStress(pfChannel *chan, float stress);

float pfGetChanStress(pfChannel *chan);

float pfGetChanLoad(pfChannel *chan);

void pfChanScene(pfChannel *chan, pfScene *scene);

pfScene *pfGetChanScene(pfChannel *chan);

void pfChanESky(pfChannel *chan, pfEarthSky *esky);

pfEarthSky *pfGetChanESky(pfChannel *chan);

void pfClearChan(pfChannel *chan);

long pfChanPick(pfChannel *chan, long mode, float px, float py, float radius, pfHit**picklist[]);

void pfChanLODAttr(pfChannel *chan, long attr, float val);

float pfGetChanLODAttr(pfChannel *chan, long attr);

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);

long pfGetFrustType(pfFrustum *fr);

void pfFrustAspect(pfFrustum *fr, long which, float widthHeightRatio);

float pfGetFrustAspect(pfFrustum *fr);

void pfGetFrustFOV(pfFrustum *fr, float *horiz, float *vert);

void pfFrustNearFar(pfFrustum *fr, float near, float far);

void pfGetFrustNearFar(pfFrustum *fr, float *near, float *far);

void pfOrthoXformFrust(pfFrustum *dst, pfFrustum *src, const pfMatrix mat);

void pfGetFrustNear(pfFrustum *fr, pfVec3 ll, pfVec3 lr, pfVec3 ul, pfVec3 ur);

void pfGetFrustFar(pfFrustum *fr, pfVec3 ll, pfVec3 lr, pfVec3 ul, pfVec3 ur);

long pfGetFrustEye(pfFrustum *fr, pfVec3 eye);

void pfApplyFrust(pfFrustum *fr);

long pfPtInFrust(const pfVec3 pt, pfFrustum *fr);

long pfSphereIsectFrust(const pfSphere *sph, pfFrustum *fr);

long pfCylIsectFrust(const pfCylinder *cyl, pfFrustum *fr);

long pfBoxIsectFrust(const pfBox *box, pfFrustum *fr);

pfEarthSky

pfEarthSky *pfNewESky(void);

void pfESkyMode(pfEarthSky *esky, long mode, long val);

void pfESkyAttr(pfEarthSky *esky, long attr, float val);

void pfESkyColor(pfEarthSky *esky, long which, float r, float g, float b, float a);

void pfESkyFog(pfEarthSky *esky, long which, pfFog *fog);

pfPath

pfPath *pfNewPath(void);

long pfCullPath(pfPath *path, pfNode *root, long mode);

pfNode

long pfNodeName(pfNode *node, const char *name);

const char *pfGetNodeName(pfNode *node);

long pfFlatten(pfNode *node, long mode);

pfNode *pfClone(pfNode *node, long mode);

pfGroup *pfGetParent(pfNode *node, long i);

long pfGetNumParents(pfNode *node);

long pfNodeBSphere(pfNode *node, pfSphere *box, long mode);

long pfGetNodeBSphere(pfNode *node, pfSphere *box);

long pfNodeTravFuncs(pfNode *node, long which, pfNodeTravFuncType pre, pfNodeTravFuncType post);

long pfGetNodeTravFuncs(pfNode *node, long which, pfNodeTravFuncType *pre, pfNodeTravFuncType *post);

long pfNodeTravData(pfNode *node, long which, void *data);

void *pfGetNodeTravData(pfNode *node, long which);

long pfNodeTravMask(pfNode *node, long which, ulong mask, long setMode, long bitOp);

ulong pfGetNodeTravMask(pfNode *node, long which);

long pfNodePickSetup(pfNode *node);

long pfSegsIsectNode(pfNode *node, pfSegSet *segSet, pfHit* *hits[]);

long pfQueryHit(pfHit *hit, ulong which, float *dst);

long pfMQueryHit(pfHit *hit, ulong *which, float *dst);

pfGroup

pfGroup *pfNewGroup(void);

pfGroup *pfFindGroup(const char *name);

long pfAddChild(pfGroup *group, pfNode *child);

long pfReplaceChild(pfGroup *group, pfNode *old, pfNode *new);

long pfInsertChild(pfGroup *group, long index, pfNode *child);

long pfRemoveChild(pfGroup *group, pfNode *child);

pfNode *pfGetChild(pfGroup *group, long index);

long pfGetNumChildren(pfGroup *group);

pfScene

pfScene *pfNewScene(void);

pfScene *pfFindScene(const char *name);

pfSCS

pfSCS *pfNewSCS(pfMatrix m);

pfSCS *pfFindSCS(const char *name);

void pfGetSCSMat(pfSCS *scs, pfMatrix m);

pfDCS

pfDCS *pfNewDCS(void);

pfDCS *pfFindDCS(const char *name);

void pfDCSScale(pfDCS *dcs, float s);

void pfDCSTrans(pfDCS *dcs, float x, float y, float z);

void pfDCSRot(pfDCS *dcs, float h, float p, float r);

void pfDCSCoord(pfDCS *dcs, pfCoord *c);

void pfDCSMat(pfDCS *dcs, pfMatrix m);

void pfGetDCSMat(pfDCS *dcs, pfMatrix m);

pfLOD

pfLOD *pfNewLOD(void);

pfLOD *pfFindLOD(const char *name);

void pfLODRange(pfLOD *lod, long index, float range);

float pfGetLODRange(pfLOD *lod, long index);

void pfLODCenter(pfLOD *lod, pfVec3 center);

void pfGetLODCenter(pfLOD *lod, pfVec3 center);

pfSwitch

pfSwitch *pfNewSwitch(void);

pfSwitch *pfFindSwitch(const char *name);

long pfSwitchVal(pfSwitch *sw, long val);

long pfGetSwitchVal(pfSwitch *sw);

pfSequence

pfSequence *pfNewSeq(void);

pfSequence *pfFindSeq(const char *name);

void pfSeqTime(pfSequence *seq, long index, double t);

double pfGetSeqTime(pfSequence *seq, long index);

void pfSeqInterval(pfSequence *seq, long imode, long begin, long end);

void pfGetSeqInterval(pfSequence *seq, long *imode, long *begin, long *end);

void pfSeqDuration(pfSequence *seq, float speed, long repeat);

void pfGetSeqDuration(pfSequence *seq, float *speed, long *repeat);

void pfSeqMode(pfSequence *seq, long mode);

long pfGetSeqMode(pfSequence *seq);

long pfGetSeqFrame(pfSequence *seq, long *repeat);

pfLayer

pfLayer *pfNewLayer(void);

pfLayer *pfFindLayer(const char *name);

void pfLayerMode(pfLayer *layer, long mode);

long pfGetLayerMode(pfLayer *layer);

void pfLayerBase(pfLayer *layer, pfNode *base);

pfNode *pfGetLayerBase(pfLayer *layer);

void pfLayerDecal(pfLayer *layer, pfNode *decal);

pfNode *pfGetLayerDecal(pfLayer *layer);

pfPartition

pfPartition *pfNewPart(void);

pfPartition *pfFindPart(const char *name);

void pfBuildPart(pfPartition *part, long type);

long pfGetPartType(pfPartition *part);

void pfPartAttr(pfPartition *part, long attr, float val);

float pfGetPartAttr(pfPartition *part, long attr);

void pfUpdatePart(pfPartition *part);

pfLightPoint

pfLightPoint *pfNewLPoint(long n);

pfLightPoint *pfFindLPoint(const char *name);

long pfGetNumLPoints(pfLightPoint *lpoint);

void pfLPointFogScale(pfLightPoint *lpoint, float onsetScale, float opaqueScale);

void pfGetLPointFogScale(pfLightPoint *lpoint, float *onsetScale, float *opaqueScale);

void pfLPointSize(pfLightPoint *lpoint, float size);

float pfGetLPointSize(pfLightPoint *lpoint);

void pfLPointColor(pfLightPoint *lpoint, long index, pfVec4 color);

void pfGetLPointColor(pfLightPoint *lpoint, long index, pfVec4 color);

void pfLPointRot(pfLightPoint *lpoint, float azim, float elev, float roll);

void pfGetLPointRot(pfLightPoint *lpoint, float *azim, float *elev, float *roll);

void pfLPointShape(pfLightPoint *lpoint, long dir, float henv, float venv, float falloff);

void pfGetLPointShape(pfLightPoint *lpoint, long *dir, float *henv, float *venv, float *falloff);

void pfLPointPos(pfLightPoint *lpoint, long index, pfVec3 pos);

void pfGetLPointPos(pfLightPoint *lpoint, long index, pfVec3 pos);

pfLightSource

pfLightSource *pfNewLSource(void);

pfLightSource *pfFindLSource(const char *name);

void pfLightAmbient(pfLight *lt, float r, float g, float b);

void pfGetLightAmbient(pfLight *lt, float *r, float *g, float *b);

void pfLightColor(pfLight *lt, float r, float g, float b);

void pfGetLightColor(pfLight *lt, float *r, float *g, float *b);

void pfSpotLightDir(pfLight *lt, float x, float y, float z);

void pfGetSpotLightDir(pfLight *lt, float *x, float *y, float *z);

void pfSpotLightCone(pfLight *lt, float f1, float f2);

void pfGetSpotLightCone(pfLight *lt, float *f1, float *f2);

void pfLightPos(pfLight *lt, float x, float y, float z, float w);

void pfGetLightPos(pfLight *lt, float *x, float *y, float *z, float *w);

long pfIsLightOn(pfLight *lt);

void pfLightOn(pfLight *lt);

void pfLightOff(pfLight *lt);

pfGeode

pfGeode *pfNewGeode(void);

pfGeode *pfFindGeode(const char *name);

long pfAddGSet(pfGeode *geode, pfGeoSet *gset);

long pfRemoveGSet(pfGeode *geode, pfGeoSet *gset);

long pfInsertGSet(pfGeode *geode, long index, pfGeoSet *gset);

long pfReplaceGSet(pfGeode *geode, pfGeoSet *old, pfGeoSet *new);

pfGeoSet *pfGetGSet(pfGeode *geode, long index);

long pfGetNumGSets(pfGeode *geode);

pfBillboard

pfBillboard *pfNewBboard(void);

pfBillboard *pfFindBboard(const char *name);

void pfBboardPos(pfBillboard *bill, long i, pfVec3 pos);

void pfGetBboardPos(pfBillboard *bill, long i, pfVec3 pos);

void pfBboardAxis(pfBillboard *bill, pfVec3 axis);

void pfGetBboardAxis(pfBillboard *bill, pfVec3 axis);

void pfBboardMode(pfBillboard *bill, long mode, long val);

long pfGetBboardMode(pfBillboard *bill, long mode);

pfTraverser

void pfCullResult(long result);

long pfGetParentCullResult(void);

long pfGetCullResult(void);

pfChannel *pfGetTravChan(pfTraverser *trav);

void pfGetTravMat(pfTraverser *trav, pfMatrix mat);

pfNode *pfGetTravNode(pfTraverser *trav);

long pfGetTravIndex(pfTraverser *trav);

pfFrameStats

pfStats *pfNewStats(void *arena);

ulong pfCloseStats(ulong enmask);

ulong pfOpenStats(pfStats *stats, ulong enmask);

ulong pfGetOpenStats(pfStats *stats, ulong enmask);

ulong pfStatsClass(pfStats *stats, ulong enable, long val);

ulong pfGetStatsClass(pfStats *stats, ulong enmask);

ulong pfStatsClassMode(pfStats *stats, long class, ulong mask, long val);

ulong pfGetStatsClassMode(pfStats *stats, long class);

void pfAccumulateStats(pfStats *cum, pfStats *cur, ulong which);

void pfAverageStats(pfStats *avg, pfStats *cum, ulong which, long num);

void pfChanStatsMode(pfChannel *chan, ulong mode, ulong val);

void pfClearStats(pfStats *stats, ulong which);

void pfCopyFStats(pfFrameStats *dst, ulong dstBufSel, pfFrameStats *src, ulong srcBufSel, ulong classes);

void pfCopyStats(pfStats *dst, pfStats *src, ulong which);

void pfDisableStatsHw(ulong which);

void pfDrawChanStats(pfChannel *chan);

void pfDrawFStats(pfFrameStats *stats, pfChannel *chan);

void pfEnableStatsHw(ulong which);

ulong pfGetEnableStatsHw(ulong which);

void pfFStatsCountNode(pfFrameStats *stats, long class, ulong mode, pfNode *node);

void pfResetStats(pfStats *stats);

void pfStatsAttr(pfStats *stats, long attr, float val);

void pfStatsCountGSet(pfStats *stats, pfGeoSet *gset);

void pfStatsHwAttr(long attr, float val);

float pfGetStatsAttr(pfStats *stats, long attr);

float pfGetStatsHwAttr(long attr);

long pfMQueryStats(pfStats *stats, ulong *which, float *dst);

long pfQueryStats(pfStats *stats, ulong which, float *dst);

pfFrameStats *pfGetChanFStats(pfChannel *chan);

pfFrameStats *pfNewFStats(void);

libpr Functions

pfGeoState

pfGeoState *pfNewGState(void *arena);

void pfGStateMode(pfGeoState *gs, long attr, long a);

long pfGetGStateMode(pfGeoState *gs, long attr);

void pfGStateInherit(pfGeoState *gs, ulong mask);

ulong pfGetGStateInherit(pfGeoState *gs);

void pfGStateAttr(pfGeoState *gs, long attr, void *a);

void *pfGetGStateAttr(pfGeoState *gs, long attr);

void pfLoadGState(pfGeoState *gs);

void pfApplyGState(pfGeoState *gs);

pfGeoState *pfGetCurGState(void);

pfState

void pfInitState(usptr_t *arena);

pfState *pfNewState(void);

void pfSelectState(pfState *state);

pfState *pfGetCurState(void);

void pfPushState(void);

void pfPopState(void);

void pfGetState(pfGeoState *gstate);

void pfFlushState(void);

void pfBasicState(void);

void pfOverride(ulong mask, long val);

ulong pfGetOverride(void);

Modes

void pfShadeModel(long model);

long pfGetShadeModel(void);

void pfTransparency(long type);

long pfGetTransparency(void);

void pfAlphaFunc(long ref, long func);

void pfGetAlphaFunc(long *ref, long *func);

void pfAntialias(long type);

long pfGetAntialias(void);

void pfDecal(long mode);

long pfGetDecal(void);

void pfCullFace(long cull);

long pfGetCullFace(void);

void pfEnable(long target);

void pfDisable(long target);

long pfGetEnable(long target);

void pfClear(long which, pfVec4 col);

pfGeoSet

pfGeoSet *pfNewGSet(void *arena);

void pfGSetNumPrims(pfGeoSet *gset, long n);

long pfGetGSetNumPrims(pfGeoSet *gset);

void pfGSetPrimType(pfGeoSet *gset, long type);

long pfGetGSetPrimType(pfGeoSet *gset);

void pfGSetPrimLengths(pfGeoSet *gset, long *lengths);

long *pfGetGSetPrimLengths(pfGeoSet *gset);

void pfGSetAttr(pfGeoSet *gset, long attr, long bind, void *alist, ushort *ilist);

long pfGetGSetAttrBind(pfGeoSet *gset, long attr);

void pfGetGSetAttrLists(pfGeoSet *gset, long attr, void* *alist, ushort* *ilist);

void pfGSetDrawMode(pfGeoSet *gset, long mode, long val);

long pfGetGSetDrawMode(pfGeoSet *gset, long mode);

void pfGSetGState(pfGeoSet *gset, pfGeoState *gstate);

pfGeoState *pfGetGSetGState(pfGeoSet *gset);

void pfDrawGSet(pfGeoSet *gset);

void pfGSetHlight(pfGeoSet *gset, pfHighlight *hlight);

pfHighlight *pfGetGSetHlight(pfGeoSet *gset);

void pfGSetLineWidth(pfGeoSet *gset, float width);

float pfGetGSetLineWidth(pfGeoSet *gset);

void pfGSetPntSize(pfGeoSet *gset, float s);

float pfGetGSetPntSize(pfGeoSet *gset);

void pfGetGSetBBox(pfGeoSet *gset, pfBox *box);

void pfGSetBBox(pfGeoSet *gset, pfBox *box);

void pfGSetIsectMask(pfGeoSet *gset, ulong mask, long setMode, long bitOp);

ulong pfGetGSetIsectMask(pfGeoSet *gset);

long pfSegsIsectGSet(pfGeoSet *gset, pfSegSet *segSet, pfHit* *hits[]);

long pfQueryGSet(pfGeoSet *gset, ulong *which, float *dst);

pfTexture

pfTexture *pfNewTex(void *arena);

long pfLoadTexFile(pfTexture *tex, char *fname);

void pfTexName(pfTexture *tex, char *name);

const char *pfGetTexName(pfTexture *tex);

void pfFreeTexImage(pfTexture *tex);

long pfTexImage(pfTexture *tex, ulong *image, long comp, long sx,

long sy, long sz);

void pfGetTexImage(pfTexture *tex, ulong* *image, long *comp, long *sx, long *sy, long *sz);

void pfTexFormat(pfTexture *tex, long format, long type);

long pfGetTexFormat(pfTexture *tex, long format);

void pfTexFilter(pfTexture *tex, long filt, long type);

long pfGetTexFilter(pfTexture *tex, long filt);

void pfTexRepeat(pfTexture *tex, long wrap, long type);

long pfGetTexRepeat(pfTexture *tex, long wrap);

void pfTexSpline(pfTexture *tex, long type, pfVec2 *pts, float clamp);

void pfGetTexSpline(pfTexture *tex, long type, pfVec2 *pts, float *clamp);

void pfDetailTexTile(pfTexture *tex, long j, long k, long m, long n, long scram);

void pfGetDetailTexTile(pfTexture *tex, long *j, long *k, long *m, long *n, long *scram);

void pfTexDetail(pfTexture *tex, pfTexture *detail);

pfTexture *pfGetTexDetail(pfTexture *tex);

void pfApplyTex(pfTexture *tex);

void pfIdleTex(pfTexture *tex);

pfTexture *pfGetCurTex(void);

long pfIsTexLoaded(pfTexture *tex);

pfTexEnv

pfTexEnv *pfNewTEnv(void *arena);

void pfTEnvMode(pfTexEnv *tev, long mode);

long pfGetTEnvMode(pfTexEnv *tev);

void pfTEnvComponent(pfTexEnv *tev, long comp);

long pfGetTEnvComponent(pfTexEnv *tev);

void pfTEnvBlendColor(pfTexEnv *tev, float r, float g, float b, float a);

void pfGetTEnvBlendColor(pfTexEnv *tev, float *r, float *g, float *b, float *a);

void pfApplyTEnv(pfTexEnv *tev);

pfTexEnv *pfGetCurTEnv(void);

pfMaterial

pfMaterial *pfNewMtl(void *arena);

void pfMtlSide(pfMaterial *mat, long side);

long pfGetMtlSide(pfMaterial *mat);

void pfMtlAlpha(pfMaterial *mat, float alpha);

float pfGetMtlAlpha(pfMaterial *mat);

void pfMtlShininess(pfMaterial *mat, float shininess);

float pfGetMtlShininess(pfMaterial *mat);

void pfMtlColor(pfMaterial *mat, long acolor, float r, float g, float b);

void pfGetMtlColor(pfMaterial *mat, long acolor, float *r, float *g, float *b);

void pfMtlColorMode(pfMaterial *mat, long side, long mode);

long pfGetMtlColorMode(pfMaterial *mat, long side);

void pfApplyMtl(pfMaterial *mat);

pfMaterial *pfGetCurMtl(long side);

pfLight

pfLight *pfNewLight(void *arena);

void pfLightAmbient(pfLight *lt, float r, float g, float b);

void pfGetLightAmbient(pfLight *lt, float *r, float *g, float *b);

void pfLightColor(pfLight *lt, float r, float g, float b);

void pfGetLightColor(pfLight *lt, float *r, float *g, float *b);

void pfSpotLightDir(pfLight *lt, float x, float y, float z);

void pfGetSpotLightDir(pfLight *lt, float *x, float *y, float *z);

void pfSpotLightCone(pfLight *lt, float f1, float f2);

void pfGetSpotLightCone(pfLight *lt, float *f1, float *f2);

void pfLightPos(pfLight *lt, float x, float y, float z, float w);

void pfGetLightPos(pfLight *lt, float *x, float *y, float *z, float *w);

long pfIsLightOn(pfLight *lt);

void pfLightOn(pfLight *lt);

void pfLightOff(pfLight *lt);

long pfGetCurLights(pfLight *lights[]);

pfLightModel

pfLightModel *pfNewLModel(void *arena);

void pfLModelAtten(pfLightModel *lm, float a0, float a1, float a2);

void pfGetLModelAtten(pfLightModel *lm, float *a0, float *a1, float *a2);

void pfLModelLocal(pfLightModel *lm, long l);

long pfGetLModelLocal(pfLightModel *lm);

void pfLModelTwoSide(pfLightModel *lm, long t);

long pfGetLModelTwoSide(pfLightModel *lm);

void pfLModelAmbient(pfLightModel *lm, float r, float g, float b);

void pfGetLModelAmbient(pfLightModel *lm, float *r, float *g, float *b);

void pfApplyLModel(pfLightModel *lm);

pfLightModel *pfGetCurLModel(void);

pfFog

pfFog *pfNewFog(void *arena);

void pfFogType(pfFog *fog, long type);

long pfGetFogType(pfFog *fog);

void pfFogRange(pfFog *fog, float onset, float opaque);

void pfGetFogRange(pfFog *fog, float *onset, float *opaque);

void pfFogOffsets(pfFog *fog, float onset, float opaque);

void pfGetFogOffsets(pfFog *fog, float *onset, float *opaque);

void pfFogRamp(pfFog *fog, long points, float *range, float *den- sity, float bias);

void pfGetFogRamp(pfFog *fog, long *points, float *range, float *density, float *bias);

void pfFogColor(pfFog *fog, float r, float g, float b);

void pfGetFogColor(pfFog *fog, float *r, float *g, float *b);

void pfApplyFog(pfFog *fog);

pfFog *pfGetCurFog(void);

IrisGL Matrix Stack

void pfScale(float x, float y, float z);

void pfTranslate(float x, float y, float z);

void pfRotate(long axis, float degrees);

void pfPushMatrix(void);

void pfPushIdentMatrix(void);

void pfPopMatrix(void);

void pfLoadMatrix(pfMatrix m);

void pfMultMatrix(pfMatrix m);

pfMalloc

void *pfMalloc(size_t nbytes, void *arena);

void *pfCalloc(size_t nelem, size_t elsize, void *arena);

void *pfRealloc(void *ptr, size_t nbytes);

void *pfGetMallocArena(void *ptr);

long pfGetMallocSize(void *ptr);

void pfFree(void *ptr);

pfDataPool

pfDataPool *pfNewDPool(long size, char *name);

long pfReleaseDPool(pfDataPool *dpool);

long pfGetDPoolSize(pfDataPool *dpool);

const char *pfGetDPoolName(pfDataPool *dpool);

void pfDPoolLock(void *m);

void pfDPoolUnlock(void *m);

long pfDPoolTest(void *m);

volatile void *pfDPoolAlloc(pfDataPool *dpool, long size, long id);

long pfDPoolFree(pfDataPool *dpool, void *dpmem);

volatile void *pfDPoolFind(pfDataPool *dpool, long id);

pfDataPool *pfAttachDPool(char *name);

pfFile

pfFile *pfCreateFile(char *path, mode_t mode);

pfFile *pfOpenFile(char *fname, long oflag, ...);

long pfCloseFile(pfFile *file);

long pfReadFile(pfFile *file, char *buf, long nbyte);

long pfWriteFile(pfFile *file, char *buf, long nbyte);

off_t pfSeekFile(pfFile *file, off_t off, long whence);

long pfGetFileStatus(pfFile *file, long attr);

pfList

pfList *pfNewList(long eltSize, long listLength, void *arena);

long pfGetListEltSize(pfList *len);

long pfGetListArrayLen(pfList *len);

void pfListArrayLen(pfList *list, long len);

const void* *pfGetListArray(pfList *list);

void pfResetList(pfList *list);

void pfCombineLists(pfList *dst, pfList *a, pfList *b);

void pfNum(pfList *list, long num);

long pfGetNum(pfList *list);

void pfAdd(pfList *list, void *elt);

void pfInsert(pfList *list, long index, void *elt);

long pfSearch(pfList *list, void *elt);

long pfRemove(pfList *list, void *elt);

long pfFastRemove(pfList *list, void *elt);

long pfReplace(pfList *list, void *old, void *new);

void pfSet(pfList *list, long index, void *elt);

void *pfGet(pfList *list, long index);

Error Handling

void pfNotifyHandler(pfNotifyFunction handler);

pfNotifyFunction pfGetNotifyHandler(void);

void pfNotifyLevel(long severity);

long pfGetNotifyLevel(void);

void pfNotify(long severity, long error, char *format, ...);

pfColortable

pfColortable *pfNewCtab(long size, void *arena);

long pfGetCtabSize(pfColortable *ctab);

void pfApplyCtab(pfColortable *ctab);

pfColortable *pfGetCurCtab(void);

long pfCtabColor(pfColortable *ctab, long index, pfVec4 acolor);

long pfGetCtabColor(pfColortable *ctab, long index, pfVec4 acolor);

pfVec4 *pfGetCtabColors(pfColortable *ctab);

pfHighlight

pfHighlight *pfNewHlight(void *arena);

pfHighlight *pfGetCurHlight(void);

void pfApplyHlight(pfHighlight *hl);

void pfDrawHlightedGSet(pfGeoSet *gset);

void pfHlightMode(pfHighlight *hl, ulong mode);

ulong pfGetHlightMode(pfHighlight *hl);

void pfHlightColor(pfHighlight *hl, ulong which, float r, float g, float b);

void pfGetHlightColor(pfHighlight *hl, ulong which, float *r, float *g, float *b);

void pfHlightAlpha(pfHighlight *hl, float a);

float pfGetHlightAlpha(pfHighlight *hl);

pfDispList

pfDispList *pfNewDList(long type, long size, void *arena);

long pfGetDListType(pfDispList *dlist);

long pfGetDListSize(pfDispList *dlist);

void pfOpenDList(pfDispList *dlist);

void pfCloseDList(void);

void pfResetDList(pfDispList *dlist);

pfDispList *pfGetCurDList(void);

long pfDrawDList(pfDispList *dlist);

void pfDListCallback(void(*callback)(void *), long bytes, void *data);

void pfAddDListCmd(long cmd);

void pfDrawGLObj(Object obj);

Clock Routines

double pfGetTime(void);

pid_t pfInitClock(double time);

void pfSelectClock(char *name);

File Search Path

void pfFilePath(const char *path);

const char *pfGetFilePath(void);

long pfFindFile(const char *file, char path[PF_MAXSTRING], int amode);

Shared Memory and Semaphores

void pfTmpDir(char *dir);

const char *pfGetTmpDir(void);

long pfInitArenas(void);

void *pfGetSharedArena(void);

void pfSharedArenaSize(ulong size);

ulong pfGetSharedArenaSize(void);

void pfSharedArenaBase(void *base);

void *pfGetSharedArenaBase(void);

usptr_t *pfGetSemaArena(void);

pfVClock Routines

void pfInitVClock(long ticks);

long pfGetVClock(void);

long pfVClockSync(long rate, long offset);

Floating Point Error Mode

void pfFPConfig(long which, float val);

float pfGetFPConfig(long which);

Basic Math Functions

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);

pfVec2

void pfSetVec2(pfVec2 dst, float x, float y);

void pfCopyVec2(pfVec2 dst, const pfVec2 v);

void pfNegateVec2(pfVec2 dst, const pfVec2 v);

void pfAddVec2(pfVec2 dst, const pfVec2 v1, const pfVec2 v2);

void pfSubVec2(pfVec2 dst, const pfVec2 v1, const pfVec2 v2);

void pfScaleVec2(pfVec2 dst, float s, const pfVec2 v);

void pfAddScaledVec2(pfVec2 dst, const pfVec2 v1, float s, const pfVec2 v2);

void pfCombineVec2(pfVec2 dst, float s1, const pfVec2 v1, float s2, const pfVec2 v2);

float pfNormalizeVec2(pfVec2 v);

float pfDotVec2(const pfVec2 v1, const pfVec2 v2);

float pfLengthVec2(const pfVec2 v);

float pfSqrDistancePt2(const pfVec2 v1, const pfVec2 v2);

float pfDistancePt2(const pfVec2 v1, const pfVec2 v2);

long pfEqualVec2(const pfVec2 v1, const pfVec2 v2);

long pfAlmostEqualVec2(const pfVec2 v1, const pfVec2 v2, float tol);

pfVec3

void pfSetVec3(pfVec3 dst, float x, float y, float z);

void pfCopyVec3(pfVec3 dst, const pfVec3 v);

void pfNegateVec3(pfVec3 dst, const pfVec3 v);

void pfAddVec3(pfVec3 dst, const pfVec3 v1, const pfVec3 v2);

void pfSubVec3(pfVec3 dst, const pfVec3 v1, const pfVec3 v2);

void pfScaleVec3(pfVec3 dst, float s, const pfVec3 v);

void pfAddScaledVec3(pfVec3 dst, const pfVec3 v1, float s, const pfVec3 v2);

void pfCombineVec3(pfVec3 dst, float s1, const pfVec3 v1, float s2, const pfVec3 v2);

float pfNormalizeVec3(pfVec3 v);

void pfCrossVec3(pfVec3 dst, const pfVec3 v1, const pfVec3 v2);

void pfXformPt3(pfVec3 dst, const pfVec3 v, const pfMatrix m);

void pfXformVec3(pfVec3 dst, const pfVec3 v, const pfMatrix m);

float pfDotVec3(const pfVec3 v1, const pfVec3 v2);

float pfLengthVec3(const pfVec3 v);

float pfSqrDistancePt3(const pfVec3 v1, const pfVec3 v2);

float pfDistancePt3(const pfVec3 v1, const pfVec3 v2);

long pfEqualVec3(const pfVec3 v1, const pfVec3 v2);

long pfAlmostEqualVec3(const pfVec3 v1, const pfVec3 v2, float tol);

pfVec4

void pfSetVec4(pfVec4 dst, float x, float y, float z, float w);

void pfCopyVec4(pfVec4 dst, const pfVec4 v);

void pfNegateVec4(pfVec4 dst, const pfVec4 v);

void pfAddVec4(pfVec4 dst, const pfVec4 v1, const pfVec4 v2);

void pfSubVec4(pfVec4 dst, const pfVec4 v1, const pfVec4 v2);

void pfScaleVec4(pfVec4 dst, float s, const pfVec4 v);

void pfAddScaledVec4(pfVec4 dst, const pfVec4 v1, float s, const pfVec4 v2);

void pfCombineVec4(pfVec4 dst, float s1, const pfVec4 v1, float s2, const pfVec4 v2);

float pfNormalizeVec4(pfVec4 v);

void pfXformVec4(pfVec4 dst, const pfVec4 v, const pfMatrix m);

float pfDotVec4(const pfVec4 v1, const pfVec4 v2);

float pfLengthVec4(const pfVec4 v);

float pfSqrDistancePt4(const pfVec4 v1, const pfVec4 v2);

float pfDistancePt4(const pfVec4 v1, const pfVec4 v2);

long pfEqualVec4(const pfVec4 v1, const pfVec4 v2);

long pfAlmostEqualVec4(const pfVec4 v1, const pfVec4 v2, float tol);

pfMatrix

void pfMakeIdentMat(pfMatrix dst);

void pfMakeRotOntoMat(pfMatrix dst, const pfVec3 v1, const pfVec3 v2);

void pfMakeRotMat(pfMatrix dst, float degrees, float x, float y, float z);

void pfMakeEulerMat(pfMatrix dst, float h, float p, float r);

void pfMakeTransMat(pfMatrix dst, float x, float y, float z);

void pfMakeScaleMat(pfMatrix dst, float x, float y, float z);

void pfMakeCoordMat(pfMatrix dst, const pfCoord *c);

void pfGetOrthoMatCoord(pfMatrix src, pfCoord *dst);

void pfSetMatRowVec3(pfMatrix dst, long r, const pfVec3 v);

void pfGetMatRowVec3(const pfMatrix m, long r, pfVec3 dst);

void pfSetMatColVec3(pfMatrix dst, long c, const pfVec3 v);

void pfGetMatColVec3(const pfMatrix m, long c, pfVec3 dst);

void pfCopyMat(pfMatrix dst, const pfMatrix m);

void pfTransposeMat(pfMatrix dst, const pfMatrix m);

void pfPreTransMat(pfMatrix dst, float x, float y, float z, const pfMatrix m);

void pfPostTransMat(pfMatrix dst, const pfMatrix m, float x, float y, float z);

void pfPreRotMat(pfMatrix dst, float degrees, float x, float y, float z, const pfMatrix m);

void pfPostRotMat(pfMatrix dst, const pfMatrix m, float degrees, float x, float y, float z);

void pfPreScaleMat(pfMatrix dst, float x, float y, float z, const pfMatrix m);

void pfPostScaleMat(pfMatrix dst, const pfMatrix m, float x, float y, float z);

void pfAddMat(pfMatrix dst, const pfMatrix m1, const pfMatrix m2);

void pfSubMat(pfMatrix dst, const pfMatrix m1, const pfMatrix m2);

void pfMultMat(pfMatrix dst, const pfMatrix m1, const pfMatrix m2);

void pfPostMultMat(pfMatrix dst, const pfMatrix m);

void pfPreMultMat(pfMatrix dst, const pfMatrix m);

long pfInvertMat(pfMatrix dst, const pfMatrix m);

void pfInvertAffMat(pfMatrix dst, const pfMatrix m);

void pfInvertOrthoMat(pfMatrix dst, const pfMatrix m);

void pfInvertOrthoNMat(pfMatrix dst, const pfMatrix m);

void pfInvertIdentMat(pfMatrix dst, const pfMatrix m);

long pfEqualMat(const pfMatrix m1, const pfMatrix m2);

long pfAlmostEqualMat(const pfMatrix m1, const pfMatrix m2, float tol);

long pfGetMatType(const pfMatrix m);

pfSeg

void pfClipSeg(pfSeg *dst, const pfSeg *seg, float d1, float d2);

void pfMakePtsSeg(pfSeg *dst, const pfVec3 p1, const pfVec3 p2);

void pfMakePolarSeg(pfSeg *dst, const pfVec3 pos, float head, float pitch, float len);

long pfClosestPtsOnSegs(const pfSeg *seg1, const pfSeg *seg2, pfVec3 ptOn1, pfVec3 ptOn2);

pfPlane

void pfMakePtsPlane(pfPlane *dst, const pfVec3 p1, const pfVec3 p2, const pfVec3 p3);

void pfMakeNormPtPlane(pfPlane *dst, const pfVec3 norm, const pfVec3 pos);

void pfOffsetPlane(pfPlane *dst, float d);

void pfClosestPtOnPlane(const pfPlane *p, const pfVec3 pt, pfVec3 dst);

void pfOrthoXformPlane(pfPlane *dst, const pfPlane *pln, const pfMatrix mat);

pfFrustum

pfFrustum *pfNewFrust(void *arena);

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);

long pfGetFrustType(pfFrustum *fr);

void pfFrustAspect(pfFrustum *fr, long which, float widthHeightRa- tio);

float pfGetFrustAspect(pfFrustum *fr);

void pfGetFrustFOV(pfFrustum *fr, float *fovh, float *fovv);

void pfFrustNearFar(pfFrustum *fr, float near, float far);

void pfGetFrustNearFar(pfFrustum *fr, float *near, float *far);

void pfOrthoXformFrust(pfFrustum *fr1, pfFrustum *fr2, const pfMa- trix mat);

void pfGetFrustNear(pfFrustum *fr, pfVec3 ll, pfVec3 lr, pfVec3 ul, pfVec3 ur);

void pfGetFrustFar(pfFrustum *fr, pfVec3 ll, pfVec3 lr, pfVec3 ul, pfVec3 ur);

long pfGetFrustEye(pfFrustum *fr, pfVec3 eye);

void pfApplyFrust(pfFrustum *fr);

pfBox

void pfMakeEmptyBox(pfBox *box);

void pfPtExtendBox(pfBox *dst, const pfVec3 pt);

void pfBoxExtendBox(pfBox *dst, const pfBox *box);

void pfBoxAroundPts(pfBox *dst, const pfVec3 *pts, long npt);

void pfBoxAroundBoxes(pfBox *dst, const pfBox* *boxes, long nbox);

void pfBoxAroundSpheres(pfBox *dst, const pfSphere* *sphs, long nsph);

void pfXformBox(pfBox *dst, const pfBox *box, const pfMatrix xform);

pfCylinder

void pfMakeEmptyCyl(pfCylinder *cyl);

void pfCylAroundSegs(pfCylinder *dst, const pfSeg* *segs, long nseg);

void pfOrthoXformCyl(pfCylinder *dst, const pfCylinder *cyl, const pfMatrix xform);

pfSphere

void pfMakeEmptySphere(pfSphere *sp);

void pfPtExtendSphere(pfSphere *dst, const pfVec3 pt);

void pfSphereExtendSphere(pfSphere *dst, const pfSphere *sph);

void pfCylExtendSphere(pfSphere *dst, const pfCylinder *cyl);

void pfSphereAroundPts(pfSphere *dst, const pfVec3 *pts, long npt);

void pfSphereAroundBoxes(pfSphere *sph, const pfBox* *boxes, long nbox);

void pfSphereAroundSpheres(pfSphere *sph, const pfSphere* *sphs, long nbox);

void pfOrthoXformSphere(pfSphere *dst, const pfSphere *sph, const pfMatrix xform);

pfPtIn

long pfPtInBox(const pfVec3 pt, const pfBox *box);

long pfPtInSphere(const pfVec3 pt, const pfSphere *sp);

long pfPtInCyl(const pfVec3 pt, const pfCylinder *cyl);

long pfPtInHalfSpace(const pfVec3 pt, const pfPlane *p);

long pfPtInFrust(const pfVec3 pt, pfFrustum *fr);

pfSegIsect

long pfSegIsectPlane(const pfSeg *seg, const pfPlane *p, float *d);

long pfSegIsectTri(const pfSeg *seg, const pfVec3 pt1, const pfVec3 pt2, const pfVec3 pt3, float *d);

long pfSegIsectHalfSpace(const pfSeg *seg, const pfPlane *hs, float *d1, float *d2);

long pfSegIsectBox(const pfSeg *seg, const pfBox *box, float *d1, float *d2);

long pfSegIsectSphere(const pfSeg *seg, const pfSphere *sph, float *d1, float *d2);

pfSphereIsect

long pfSphereIsectHalfSpace(const pfSphere *sph, const pfPlane *hs);

long pfSphereIsectSphere(const pfSphere *sph1, const pfSphere *sp2);

long pfSphereIsectFrust(const pfSphere *sph, pfFrustum *fr);

pfCylIsect

long pfCylIsectSphere(const pfCylinder *cyl, const pfSphere *sph);

long pfCylIsectHalfSpace(const pfCylinder *cyl, const pfPlane *hs);

long pfCylIsectFrust(const pfCylinder *cyl, pfFrustum *fr);

pfBoxIsect

long pfBoxIsectHalfSpace(const pfBox *box, const pfPlane *hs);

long pfBoxIsectBox(const pfBox *box1, const pfBox *box2);

long pfBoxIsectFrust(const pfBox *box, pfFrustum *fr);

pfMatStack

void pfResetMStack(pfMatStack *stack);

long pfPushMStack(pfMatStack *stack);

long pfPopMStack(pfMatStack *stack);

void pfPreMultMStack(pfMatStack *stack, const pfMatrix m);

void pfPostMultMStack(pfMatStack *stack, const pfMatrix m);

void pfLoadMStack(pfMatStack *stack, const pfMatrix m);

void pfGetMStack(pfMatStack *stack, pfMatrix m);

pfMatrix *pfGetMStackTop(pfMatStack *stack);

long pfGetMStackDepth(pfMatStack *stack);

void pfPreTransMStack(pfMatStack *stack, float x, float y, float z);

void pfPostTransMStack(pfMatStack *stack, float x, float y, float z);

void pfPreRotMStack(pfMatStack *stack, float degrees, float x, float y, float z);

void pfPostRotMStack(pfMatStack *stack, float degrees, float x, float y, float z);

void pfPreScaleMStack(pfMatStack *stack, float xs, float ys, float zs);

void pfPostScaleMStack(pfMatStack *stack, float xs, float ys, float zs);

libpfutil Functions

Utility Library Initialization

pfDataPool *pfuGetUtilDPool(void);

void pfuExitUtil(void);

Lock Down CPUs

long pfuFreeCPUs(void);

long pfuRunProcOn(long cpu);

long pfuLockDownProc(long cpu);

long pfuLockDownApp(void);

long pfuLockDownCull(pfPipe *);

long pfuLockDownDraw(pfPipe *);

GLX Mixed Mode

pfuXDisplay *pfuOpenXDisplay(long screen);

pfuGLXWindow *pfuGLXWinopen(pfuXDisplay *dsp, pfPipe *pipe, const char *name, long left, long right, long bottom, long top);

GLXconfig *pfuGLXCreateWindow(pfuXDisplay *xdsp, pfuXWindow parent, int x, int y, int w, int h, int borderWidth, ...);

void pfuPipeGLXWin(pfPipe *p, pfuXWindow new);

void pfuGetGLXWin(pfPipe *pipe, pfuGLXWindow *glxWin);

const char *pfuGetGLXDisplayString(pfPipe *pipe);

void pfuPipeGLXMSConfig(pfPipe *p, long on);

Mouse and Keyboard Event Input

void pfuInitInput(pfPipe *pipe, long mode);

void pfuExitInput(void);

void pfuGetMouse(pfuMouse *mouse);

void pfuGetEvents(pfuEvent *events);

long pfuMapMouseToChan(pfuMouse *mouse, pfChannel *chan);

void pfuCollectInput(void);

void pfuInputHandler(void(*userFunc)(ulong dev, ulong val, pfuCustomEvent *pfuevent), ulong handlerMask);

Cursor

void pfuCursor(long target, long c);

long pfuGetCursor(long target);

void pfuCursorSel(long sel);

long pfuGetCursorSel(void);

Graphical User Interface

void pfuInitGUI(pfPipe *pipe);

void pfuExitGUI(void);

void pfuEnableGUI(long en);

void pfuUpdateGUI(void);

void pfuRedrawGUI(void);

void pfuGUIViewport(float l, float r, float b, float t);

void pfuGetGUIViewport(float *l, float *r, float *b, float *t);

long pfuInGUI(long x, long y);

void pfuFitWidgets(long val);

void pfuGetGUIScale(float *x, float *y);

void pfuGetGUITranslation(float *x, float *y);

pfuPanel *pfuNewPanel(void);

void pfuEnablePanel(pfuPanel *p, long en);

void pfuGetPanelSize(pfuPanel *p, float *xo, float *xs, float *yo, float *ys);

pfuWidget *pfuNewWidget(pfuPanel *p, long type, long id);

long pfuGetWidgetType(pfuWidget *w);

long pfuGetWidgetId(pfuWidget *w);

void pfuWidgetDim(pfuWidget *w, long xo, long yo, long xs, long ys);

void pfuGetWidgetDim(pfuWidget *w, long *xo, long *yo, long *xs, long *ys);

void pfuWidgetLabel(pfuWidget *w, const char *label);

long pfuGetWidgetLabelWidth(pfuWidget *w);

const char *pfuGetWidgetLabel(pfuWidget *w);

long pfuGetWidgetSize(pfuWidget *w, long *xs, long *ys);

void pfuWidgetRange(pfuWidget *w, long mode, float min, float max, float val);

void pfuWidgetValue(pfuWidget *w, float val);

float pfuGetWidgetValue(pfuWidget *w);

void pfuWidgetDefaultValue(pfuWidget *w, float val);

void pfuWidgetFunc(pfuWidget *w, void(*)(pfuWidget *w));

void pfuWidgetSelections(pfuWidget *w, pfuGUIString *attrList, long *valList, void(* *funcList)(pfuWidget *w), long numSelections);

void pfuWidgetSelection(pfuWidget *w, long index);

long pfuGetWidgetSelection(pfuWidget *w);

void pfuWidgetDefaultSelection(pfuWidget *w, long index);

void pfuWidgetDefaultOnOff(pfuWidget *w, long on);

void pfuIsWidgetDefaultOnOff(pfuWidget *w, long on);

void pfuWidgetOnOff(pfuWidget *w, long on);

long pfuIsWidgetOn(pfuWidget *w);

void pfuResetGUI(void);

void pfuResetPanel(pfuPanel *p);

void pfuResetWidget(pfuWidget *w);

void pfuDrawMessage(pfChannel *chan, const char *msg, long rel, long just, float x, float y, long size);

Callbacks

long pfuPreDrawReflMap(pfTraverser *trav, void *data);

long pfuPostDrawReflMap(pfTraverser *trav, void *data);

pfuTraverser

void pfuInitTraverser(pfuTraverser *trav);

long pfuTraverse(pfNode *node, pfuTraverser *trav);

void pfuTravPrintNodes(pfNode *node, const char *fname);

void pfuTravCountDB(pfNode *node, pfFrameStats *fstats);

void pfuTravNodeHlight(pfNode *node, pfHighlight *hl);

void pfuTravNodeAttrBind(pfNode *node, ulong attr, ulong bind);

void pfuTravGLProf(pfNode *node, long mode);

void pfuTravCalcBBox(pfNode *node, pfBox *box);

long pfuTravCountNumVerts(pfNode *node);

pfuMCO

void pfuTileChans(pfChannel* *chn, long nChans, long ntilesx, long ntilesy);

void pfuConfigMCO(pfChannel* *chn, long nChans);

long pfuGetMCOChannels(pfPipe *p);

void pfuTileChan(pfChannel* *chn, long thisChan, long nChans, float l, float r, float b, float t);

pfuPath

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 pfuAddLine(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);

pfuXformer

pfuXformer *pfuNewXformer(void *arena);

void pfuXformerMode(pfuXformer *xf, long mode);

long pfuGetXformerMode(pfuXformer *xf);

void pfuStopXformer(pfuXformer *xf);

void pfuXformerAutoInput(pfuXformer *xf, pfChannel *chan, pfuMouse *mouse, pfuEvent *events);

void pfuXformerMat(pfuXformer *xf, pfMatrix mat);

void pfuGetXformerMat(pfuXformer *xf, pfMatrix mat);

void pfuXformerCoord(pfuXformer *xf, pfCoord *coord);

void pfuGetXformerCoord(pfuXformer *xf, pfCoord *coord);

void pfuXformerLimits(pfuXformer *xf, float maxSpeed, float angu- larVel, float maxAccel, pfBox *dbLimits);

void pfuGetXformerLimits(pfuXformer *xf, float *maxSpeed, float *angularVel, float *maxAccel, pfBox *dbLimits);

void pfuXformerCollision(pfuXformer *xf, long mode, float val, pfNode *node);

long pfuGetXformerCollisionStatus(pfuXformer *xf);

void pfuUpdateXformer(pfuXformer *xf);

long pfuCollideXformer(pfuXformer *xf);

pfuIsect

long pfuSegsIsectNode(pfNode *node, pfSeg* *segs, long nseg, long mode, ulong mask, pfCylinder *bcyl, pfuIsect *isects, long(*discFunc)(pfuIsect *isect));

Collision

void pfuCollideSetup(pfNode *node, long mode, long mask);

long pfuCollideEllipse(pfNode *node, pfMatrix xform, pfVec3 center, pfVec3 radii, long mask, pfVec3 pt, pfVec3 norm);

long pfuCollideSweep(pfNode *node, long id, pfMatrix xform, pfVec3 *pts, long npts, long mask, pfuIsect *isects);

long pfuCollideGrnd(pfCoord *coord, pfNode *node, pfVec3 zpr);

long pfuCollideGrndObj(pfCoord *coord, pfNode *grndNode, pfVec3 zpr, pfSeg *seg, pfNode *objNode, pfVec3 hitPos, pfVec3 hitNorm);

long pfuCollideObj(pfSeg *seg, pfNode *objNode, pfVec3 hitPos, pfVec3 hitNorm);

pfuTimer

pfuTimer *pfuNewTimer(void *arena, long 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);

long pfuEvalTimer(pfuTimer *timer);

pfuBuilder

pfuBuilder *pfuNewBuilder(void);

void pfuDelBuilder(pfuBuilder *bldr);

void pfuBuilderMode(pfuBuilder *bldr, long mode, long val);

long pfuGetBuilderMode(pfuBuilder *bldr, long mode);

long pfuTriangulatePoly(pfuPoly *pgon, pfuTri *triList);

void pfuAddPoly(pfuBuilder *bldr, pfuPoly *poly);

void pfuAddTri(pfuBuilder *bldr, pfuTri *tri);

long pfuGetNumTris(pfuBuilder *bldr);

pfList *pfuMakeGSets(pfuBuilder *bldr);

pfuHashTable

pfuHashTable *pfuNewHTable(long numb, long eltsize, void *arena);

void pfuDelHTable(pfuHashTable *ht);

void pfuResetHTable(pfuHashTable *ht);

pfuHashElt *pfuEnterHash(pfuHashTable *ht, pfuHashElt *elt);

long pfuRemoveHash(pfuHashTable *ht, pfuHashElt *elt);

long pfuFindHash(pfuHashTable *ht, pfuHashElt *elt);

long pfuHashGSetVerts(pfGeoSet *gset);

long pfuCalcHashSize(long size);

Triangle Mesher

pfGeoSet *pfuMeshGSet(pfGeoSet *gset);

void pfuMesherMode(long mode, long val);

long pfuGetMesherMode(long mode);

pfuBreakup and BoxLOD

pfNode *pfuBreakup(pfGeode *geode, float geodeSize, long stripLength, long geodeChild);

pfLOD *pfuBoxLOD(pfGroup *grp, long flat, pfVec4 *clr);

pfGeoSet *pfuMakeBoxGSet(pfBox *box, pfVec4 clr, long flat);

Texture Utilities

pfTexture *pfuNewSharedTex(const char *filename, void *arena);

pfList *pfuGetSharedTexList(void);

pfList *pfuMakeTexList(pfNode *node);

void pfuDownloadTexList(pfList *list, long style);

long pfuGetTexSize(pfTexture *tex);

Flybox

long pfuOpenFlybox(char *p);

long pfuReadFlybox(long *dioval, float *inbuf);

long pfuGetFlybox(float *analog, long *but);

long pfuGetFlyboxActive(void);

long pfuInitFlybox(void);

long pfuIsFlyboxActive(void);

pfuSmoke

void pfuInitSmokes(void);

pfuSmoke *pfuNewSmoke(void);

void pfuSmokeType(pfuSmoke *smoke, long type);

void pfuSmokeOrigin(pfuSmoke *smoke, pfVec3 origin, float radius);

void pfuSmokeVelocity(pfuSmoke *smoke, float turbulence, float speed);

void pfuGetSmokeVelocity(pfuSmoke *smoke, float *turbulence, float *speed);

void pfuSmokeDir(pfuSmoke *smoke, pfVec3 dir);

void pfuSmokeMode(pfuSmoke *smoke, long 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);

Screen Snapshot

void pfuCalcNormalizedChanXY(float *px, float *py, pfChannel *chan, long xpos, long ypos);

long pfuSaveImage(char *name, long xorg, long yorg, long xsize, long ysize);

libpfsgi Functions

Database Loaders

pfNode *LoadFile(char *file, pfGeoState *geostate);

pfNode *LoadBin(char *file, pfGeoState *geostate);

pfNode *LoadDwb(char *file);

pfNode *LoadDxf(char *file, pfGeoState *geostate);

pfNode *LoadGfo(char *file, pfGeoState *geostate);

pfNode *LoadIrtp(char *file, pfGeoState *geostate);

pfNode *LoadIv(char *file, pfGeoState *geostate);

pfNode *LoadLsa(char *file, pfGeoState *geostate);

pfNode *LoadLsb(char *file, pfGeoState *geostate);

pfNode *LoadObj(char *file, pfGeoState *geostate);

pfNode *LoadPoly(char *file, pfGeoState *geostate);

pfNode *LoadPtu(char *file, pfGeoState *geostate);

pfNode *LoadSgo(char *file, pfGeoState *geostate);

pfNode *LoadStl(char *file, pfGeoState *geostate);

pfNode *LoadStla(char *file, pfGeoState *geostate);

pfNode *LoadStlb(char *file, pfGeoState *geostate);

pfNode *LoadSv(char *file, pfGeoState *geostate);

FLIGHT V11 Loader

pfNode *LoadFlt11(const char *file);

void ScanFlt11(const char *file);

void LoadFlt11Mode(long mode, long val);

long GetLoadFlt11Mode(long mode);

long GetFlt11TexList(pfTexture** *tex);

long GetNumSharedFlt11Tex(void);

long GetSharedFlt11TexList(pfTexture *tex[]);

FLIGHT V13 Loader

pfNode *LoadFlt(const char *file);

void ScanFlt(const char *file);

void LoadFltMode(long mode, long val);

long GetLoadFltMode(long mode);

long GetFltTexList(pfTexture** *tex);

long GetNumSharedFltTex(void);

long GetSharedFltTexList(pfTexture *tex[]);

Compiled by: Allan Schaffer