Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
NAMEPerformer - Overview of OpenGL Performer and summary of the C++ Language
Bindings: libpr, libpf, libpfdu, libpfdb, libpfui, libpfx, and
libpfutil.
DESCRIPTION
Welcome to the OpenGL Performer application development environment.
OpenGL Performer is a powerful and comprehensive programming interface
for developers creating real-time visual simulation and other
performance-oriented 3D graphics applications. It simplifies development
of complex applications used for visual simulation, simulation-based
design, virtual reality, interactive entertainment, broadcast video,
architectural walk-through, and computer aided design.
OpenGL Performer is built atop the industry standard OpenGL graphics
library, includes both ANSI C and C++ bindings, and is available for both
the IRIX operating system, GNU/Linux and Microsoft Windows NT 4.0, 2000
and XP. It forms the foundation of a powerful suite of tools and
features for creating real-time visual simulation applications on IRIX,
Linux & MS Windows NT systems. OpenGL Performer 3.0 supports all SGI
systems running IRIX 6.5 or later, as well as IA32-based systems with
Linux or Microsoft Windows NT 4.0, 2000 or XP.
OpenGL Performer is an integral part of the InfiniteReality, VPRO,
Impact, and O2 visual simulation solutions and in particular, provides
interfaces to the advanced features of InfiniteReality class graphics.
OpenGL Performer is compatible with all SGI graphics platforms running
IRIX, Linux or MS Windows, and attains maximum performance on each.
OpenGL Performer is the flexible, intuitive, toolkit-based solution for
developers who want to optimize performance on SGI systems.
Take a Test Drive
If you are new to OpenGL Performer, the best way to start learning about
it is to go for a test drive. The Performer-based sample application
perfly is installed in the /usr/sbin directory on IRIX, in /usr/X11R6/bin
on Linux and in PFROOT/Bin on Microsoft Windows. To start perfly, all
that you need to do is type
perfly esprit.flt
Type "man pfiXformer" for details on how to drive, fly, or tumble; and
rerun perfly with the command line option "-help" for a full list of
features. Type "?" while running perfly to print a list of keyboard
command sequences to the shell window. The source code for this program
is in /usr/share/Performer/src/sample/C/perfly.
Page 1
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Handy Environment Variables to Remember
There are a few OpenGL Performer environment variables that can improve
your quality of life.
PFPATH
A colon separated list of directories in which to find
Performer data files:
PFLD_LIBRARY_PATH and PFLD_LIBRARY{N32,64}_PATH
A colon separated list of additional directories in which to
find database loaders. These directories are searched before
LD_LIBRARY_PATH.
PFNFYLEVEL
The maximum allowed of OpenGL Performer print message. 1-
FATAL, 2-WARN, 3-NOTICE, 4-INFO, 5-DEBUG, 6-FP_DEBUG, 7-
INTERNAL_DEBUG.
PFROOT
Specifies an alternate installation 'root' for Performer files,
to allow multiple versions of Performer to be installed on the
same system. Use this any time you install Performer to a
location other than the root (/).
PFSHAREDSIZE
The size (in bytes) of the shared memory arena to create. This
size will override any size specified with the
pfSharedArenaSize function.
PFSHAREDBASE
The address at which to place the shared memory arena. The
address specified with this environment variable will override
the address specified with pfSharedArenaBase.
_PF_FORCE_MULTIPROCESS
The value of this environment variable (interpreted as an
integer) overrides the parameter setting of the call to
pfMultiprocess. This is useful for changing the multi-
processing mode of an executable without a recompile. See man
pfMultiprocess for details about parameter values.
PF_LPOINT_BOARD
Pretend there is a calligraphic light point board for
calligraphic debugging.
PFXDEBUG
Turns on X Synchr onization for debugging. Very slow, but
helpful if you are exiting with X Errors. Setenv PFXDEBUG 1,
dbx the program, breakpoint in exit, run, look at stack trace
when stopped.
Page 2
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFMACHTYPE
Force the gfx machine type to be the give token for debugging.
Uses the values from /usr/include/sys/invent.h. (IRIX only)
PFASDLODSIZE
Set the number of LODs to be constructed in pfASD using
routines in pfdBuildASD.c. In general, a value less than 8 runs
a lot faster and uses much less space than any value beyond 8.
PFTMPDIR
sets the temporary directory location.
PFMEMDEBUG
This variable sets up the trace on pfMemory usage.
PFVIDEORATE
Allows the video rate calculation logic to be overridden with a
user-specified value. Use with caution.
PFARENADEBUG
This variable sets up tracing on shared arena creation & usage.
Set to 1 for basic output, 2 for exhaustive output. (Linux
only).
PFCULLSPINCOUNT
If DRAW has finished previous frame, wait for DRAW to grab most
recent buffer before updating it. This avoids hairy edge
problems when the CULL is short and the DRAW wakes up just
after the CULL has finished a new buffer.
PF_NO_FATAL_MESSAGEBOX
On the Windows operating system, the default behavior of
pfNotify when displaying a fatal error is to pop up an error
message box. If this variable is set, the message box will not
be displayed.
__PFTYPEMAGIC
Allows changing the value used to detect a pfType header.
Under typical operation, this should not be changed. This
should be set to a hexadecimal string (e.g., 0xa25d2830b) if
pfMemory::getMemory errors are occuring.
PF_MAX_ANISOTROPY
an anisotropic filter of the value specified by
PF_MAX_ANISOTROPY will be applied to pfTextures that do not set
the degree of anisotropy. This is only valid for graphics
hardware that support anisotropic texture filtering.
PF_ENABLE_MULTISAMPLE_VISUAL
On Irix, Performer will try to ask for a multisample visual by
default. On the commodity graphics cards that are often used
under Linux, a multisample visual, if available, will cause a
Page 3
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
significant performance penalty. Therefore, under Linux,
Performer does not ask for a multisample visual by default. If
this environment variable is set under Linux, Performer will
ask for a multisample visual.
_PF_NODE_FIND_REQUIRES_EXACT_TYPE
This environment variable can be used to revert the behavior of
pfNode::find (also called from within pfNodeLookup) to what it
was before being fixed for pf3.0.1. The old behavior would
carry out an exact type comparison (pfIsExactType) instead of
using pfIsOfType as suggested by the manpages.
PF_FORCE_GUI_REDRAW
This environment variable forces redraw of the gui created
using libpfutil, used in perfly, for example. The gui
disappears under windows on some graphics hardware and setting
this environment variable fixes the problem.
PF_USE_VERTEX_BUFFER_OBJECTS
By default pfGeoArrays try to use vertex buffer objects. By
setting this environment variable to 0, Performer tries to use
ATI's vertex array objects, if possible.
PF_MATERIAL_COLOR_COMPARE
When pfGeoStates are optimized for single global gstate
pfMaterials of all pfGeoStates are compared and collapsed into
fewer pfMaterials, if possible. In Performer 3.0 and older, it
was assumed that colors are used to change material diffuse and
ambient color when color material is on. Thus those colors
were ignored when comparing materials. Starting with Performer
3.1 all colors are used to compare pfMaterials because on newer
hardware it is not advantageous to use color material mode. You
can enable the old approach by setting this environment
variable to 0.
_PF_KILL_XINPUT_PROC_ON_EXIT
This environment variable can be set in order to override the
default mechanism used by Performer for terminating the X-
input-collection process fork'ed off by libpfutil, on exiting.
The default behavior is to use signalling (ie the X-input
process is notified of the death of its parent process and
itself exits); However, this can cause system-hangs on RH9 SMP
kernels, so an alternative method has been implemented, which
consists in explicitely kill-ing the input process from the APP
process prior to exit-ing. On SMP Linux kernels with version
2.4.20 or greater, this alternative method is selected by
default. Note that this env variable can be set to 0 in order
to force the signalling method, or set to 1 in order to force
the explicit-kill method on any IRIX or Linux system. This
environment variable has no effect on WIN32.
Page 4
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PF_CATCH_SIGINT_AND_EXIT
This environment variable can be set in order to instruct
Performer to intercept the SIGINT signal (received when user
presses <ctrl>C on the shell) and to exit cleanly by calling
pfExit. This prevents system freezes on Linux RH9 SMP kernels.
By default, SIGINT will be intercepted on SMP Linux kernels
with version 2.4.20 or greater. Setting this environment
variable to 0 or 1 will override the default behavior on any
IRIX and Linux systems. This environment variable has no effect
on WIN32.
PF_LOADER_FORCE_TESS
This environment variable, when set, informs the pfb and csb
loaders to tessellate the incoming geometry. When doing so it
will use the default value for tessellating surfaces (0.0001)
unless specified otherwise via the PF_DEFAULT_TESS_VALUE
environment variable.
In addition, one can use the ctol and ttol pseudo-loaders to
gain finer control over the tessellation parameters and also
control whether or not existing geometry should be
retesssellated at load time. For more information consult the
Programming Guide.
PF_NO_UNCOMPRESSED_TEXTURE
By default, the graphics driver on Onyx 4 keeps both compressed
and uncompressed copy of each texture. This requires addressing
of more memory and it is easy to run out of address space in a
32-bit multi-pipe application. The driver can be forced not to
keep the uncompressed copy of each texture and Performer does
that.
On the other hand, not having the uncompressed copy may cause
problems when getImage is called. Thus the user can request the
allocation of memory for an uncompressed version of each
texture by setting the environment variable
PF_NO_UNCOMPRESSED_TEXTURE to 0.
PF_BILLBOARD_DISABLE_ISECT
Intersection testing with pfBillboard objects has been enabled.
Setting this flag to 1 reverts to the previous behavior, where
Intersections are only tested against the bounding volume for a
pfBillboard.
PF_EVENT_FILE
Setting this environment variable to a filename will enable
event collection. Results are written to the file upon exiting
the application. See evanalyzer(1) for more information.
PF_SYNC_TO_VBLANK
If this environment variable is unset, or if it is set to "1",
Performer will set the environment variable __GL_SYNC_TO_VBLANK
Page 5
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
to "1" (and print a debug message) in function pfInit. On some
systems (SGI Onyx4, SGI Prism, and on NVIDIA based PCs) this
has the effect of forcing swapbuffer calls to synchronize to
the vertical refresh rate of the monitor. Explicitely set
PF_SYNC_TO_VBLANK to "0" if you want Performer to leave
__GL_SYNC_TO_VBLANK untouched.
OpenGL Performer Overview
OpenGL Performer consists of two combined libraries, libpf and libpr, and
five associated libraries, libpfdu, libpfdb, libpfui, libpfx, and
libpfutil.
The basis of OpenGL Performer is the performance rendering library
referred to as libpr, a low level library providing high speed rendering
functions based on pfGeoSets, efficient graphics state control using
pfGeoStates, and other application-neutral functions. Layered above
libpr is libpf, a real-time visual simulation environment providing a
high-performance multi-processing database rendering system that takes
best advantage of SGI symmetric multiprocessing CPU hardware. The
database utility library libpfdu provides powerful functions for defining
both geometric and appearance attributes of three dimensional objects,
encourages sharing of state and materials, and generates efficient
triangle strips from independent polygonal input. The database library
libpfdb uses the facilities of libpfdu, libpf, and libpr to import
database files in many popular industry standard database formats. These
loaders also serve as a guide to developers creating new database
importers. libpfui contains the user interface, and input management
facilities common to many interactive applications. The viewer class
library libpfx provides an easy-to-use interface for creating basic
OpenGL Performer applications. Completing the suite of libraries is
libpfutil, the OpenGL Performer utility library. It provides a collection
of important convenience routines implementing such diverse tasks as
smoke effects, MultiChannel Option support, graphical user interface
tools, input event collection and handling, and various traversal
functions.
Program Structure
Most OpenGL Performer application programs have a common general
structure. The following steps are typically involved in preparing for a
real-time simulation:
1. Initialize OpenGL Performer with pfInit.
2. Specify number of graphics pipelines with pfMultipipe, choose
the multiprocessing configuration by calling pfMultiprocess,
and specify the hardware mode with pfHyperpipe if needed.
Page 6
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
3. Initiate the chosen multiprocessing mode by calling pfConfig.
4. Initialize the frame rate with pfFrameRate and set the frame-
extend policy with pfPhase.
5. Create, configure, and open windows with new pfPipeWindow,
pfPipeWindow::setFBConfigAttrs, and pfPipeWindow::open, as
required.
6. Create and configure display channels with new pfChannel,
pfChannel::setTravFunc, pfChannel::setFOV, and
pfChannel::setScene as required.
Once the application has created a graphical rendering environment as
shown above, the remaining task is to iterate through a main simulation
loop once per frame.
7. Compute dynamics, update model matrices, etc.
8. Delay until the next frame time: pfSync
9. Perform latency critical viewpoint updates.
10. Draw a frame by calling pfFrame.
In many applications the viewpoint will be set in step 7 and both step 8
and step 9 are not required. The more general case is shown since it is
typical in head-tracked and other cases where low-latency applications
with last-minute position input must be used.
The libpr Performance Rendering Library
Libpr consists of many low-level hardware oriented facilities generally
required for real-time and other performance-oriented graphics
applications. These features include
High-speed rendering functions using the innovative pfGeoSet.
Efficient graphics state management and mode control based on the
pfGeoState.
Display lists suitable for rendering between multiple processes.
An extensive collection of fast linear algebra and math routines.
Intersection computation and detection services.
A colortable mechanism for rapid switching of database appearance.
Asynchronous file I/O system for real-time file operations.
Page 7
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Memory allocation oriented to shared memory and mutual exclusion.
High speed clock functions that hide the complexities of hardware
clocks.
GeoSets are collections of drawable geometry which group same-type
graphics primitives (e.g. triangles or quads) into one data object. The
GeoSet contains no geometry itself, only pointers to data arrays and
index arrays. Geometry arrays may be indexed or non-indexed (i.e.
stored in order) depending upon application requirements. Because all
the primitives in a GeoSet are of the same type and have the same
attributes, rendering of most databases is performed at maximum hardware
speed. There are many GeoSet rendering methods, one for each combination
of geometry and attribute specification. However, in OpenGL Performer,
all GeoSet rendering is performed through a single render dispatching
routine, pfGeoSet::draw.
GeoStates provide graphics state definitions (e.g. texture or material)
for GeoSets. When used in conjunction with Performer state management
functions, GeoSets can be rendered in a prescribed way without concern
for the inherited modes of the graphics pipeline. GeoSets may share
GeoStates. Less-used machine modes are not supported.
State Management and Mode Control. OpenGL Performer provides functions
that bundle together graphics library state control functions such as
lighting, materials, texture, and transparency. They have two purposes:
to track state and to allow the creation of display lists that can be
rendered later. The application program can set states in three ways:
globally, locally (via GeoState), and directly. State changes made using
direct graphics library calls are not "known" to the OpenGL Performer
state tracking mechanisms, and thus defeat OpenGL Performer state
management. However, functions exist to push state, pop state, and get
the current state so proper intermixing of direct graphics library and
OpenGL Performer functions can be achieved.
Display Lists are supported in OpenGL Performer. These are not typical
graphics library display lists, but rather simple token and data
mechanisms that do not cache geometry or state data and are designed to
allow efficient multiprocessing. These display lists use OpenGL
Performer state and rendering commands. They also support function
callbacks to allow application programs to perform any required special
processing during display list rendering.
OpenGL Windows can be configured, created and managed with the pfWindow
routines.
Math Support is provided by an extensive set of point, segment, vector,
plane, matrix, cylinder, sphere and frustum functions.
Intersection and collision detection functions are provided to test for
the intersection of line segments with cylinders, spheres, boxes, planes,
and geometry. Intersection functions for spheres, cylinders, and frusta
Page 8
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
are also provided.
ColorTables are supported by allowing GeoSet color indexes to refer to
common tables of RGBA color information. Color tables are global and may
be of any size. Any number of color tables may exist at one time and
they can be activated at any time. The active color table may be
switched in real-time without performance impact.
Asynchronous File I/O is provided by a simple non-blocking file access
method. This is provided to allow applications to retrieve file data
during real-time operation.
Memory Allocation is supported with routines to allocate memory from
process heap storage, shared memory arenas, and datapool memory. Shared
arenas must be used when multiple processes need to access data. The
arena is created by the application program. Datapools allow
applications to create shared arenas visible to any process where
allocations can be locked for easy mutual exclusion on a per allocation
basis.
High Speed Clock support is based on a high speed clock access routine
that reports elapsed time in seconds as a double precision floating point
number to highest machine resolution.
Statistics are maintained by OpenGL Performer on the geometry that is
drawn, state changes, transformations, and most internal operations.
These statistics can used for application tuning and form the basis for
OpenGL Performer's automatic system load management.
The libpf Visual Simulation Library
libpf is a high level library built on libpr that is architected and
implemented to meet the specific needs of real-time graphics software.
Applications developed with libpf are able to provide smooth motion
through elaborate scenes at programmable frame rates, all with very
little code development. libpf provides
Hierarchical scene graph processing and operators.
Transparent multiprocessing for parallel simulation, culling and
drawing.
Graphics load measurement and frame rate management.
Level of detail selection with smooth fade and rotational
invariance.
Rapid culling to the viewing frustum through hierarchical bounding
volumes.
Multiprocessed intersection detection and reporting.
Page 9
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Dynamic coordinate systems for highly interactive graphics.
Multibuffering of changes to the scene graph for simple
multiprocessing.
Multiprocessing
libpf provides a pipelined multiprocessing model for implementing visual
simulation applications. The application, visibility culling and drawing
tasks can all run in separate processes. The simulation process updates
the scene, the cull process traverses the scene checking for visibility
and generates display lists which are then rendered by the drawing
process. libpf multibuffering capabilities allow each process to have
copies of the scene graph and the user data appropriate to its target
frame time.
The simulation, culling, and drawing for a graphics pipeline may be
combined into one, two or three processes to allow an application to be
tailored to different hardware and expected CPU demand in each process.
For example, culling and drawing are normally done by separate processes
in order to obtain maximum graphics performance, but if an application is
simulation bound, it may wish to combine both cull and draw into a single
process.
Statistics are maintained for each OpenGL Performer process -
application, cull and draw. These statistics can be displayed in a
channel, printed, and queried using the pfFrameStats routines.
Graphics Pipes, Windows, and Channels
In addition to the functionality it derives from libpr, libpf supports
multiple channels per window, multiple windows per graphics pipe,
grouping of channels to form video walls, and frame synchronization
between multiple graphics pipes. libpf maintains a graphics stress value
for each channel and uses it to attempt to maintain a fixed frame rate by
manipulating levels-of-detail (LODs). Like many graphics libraries,
libpf assumes a coordinate system with +Z up, +X to the right and +Y into
the screen.
Database
libpf supports a general database hierarchy which consists of the
following node types:
pfNode General node (base class)
pfScene Top level node.
pfGroup Node with multiple children.
pfSCS Static coordinate system.
pfDoubleSCS Double-precision Static coordinate system
pfDCS Dynamic coordinate system.
pfDoubleDCS Double-precision Dynamic coordinate system
Page 10
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfFCS Fluxed (animated) coordinate system.
pfDoubleSCS Double-precision Fluxed coordinate system
pfLayer Layer or decal node.
pfLOD Level of detail node.
pfSwitch Switch node.
pfSequence Sequential animation node.
pfGeode Fundamental geometry node.
pfBillboard Special tracking leaf node.
pfLightPoint One or more emissive light points.
pfLightSource Definition of a graphics hardware light.
pfPartition Special culling acceleration node.
pfText 2D and 3D text geometry.
pfMorph Geometry morphing node.
Each of these is derived from pfNode and any function which requires a
pfNode* as an argument can accept any of the above types. Similarly
pfSCS, pfDCS, pfLOD, pfSequence and pfSwitch are derived from pfGroup and
can be used in any function which takes a pfGroup* as an argument.
Nodes can be assembled into a directed graph to represent a scene with
its modeling hierarchy. Geometry and graphics state information is
contained in pfGeoStates and pfGeoSets which are attached to pfGeodes.
Intersection inquiries are made via groups of line segments which can be
tested against a subgraph of the scene. Masks and callbacks can be
specified to allow evaluation of line-of-sight visibility, collisions,
and terrain intersections. libpf also provides earth-sky and weather
functions for modeling fog, haze and other atmospheric effects.
The libpfdu Database Utility Library
libpfdu provides helpful functions for constructing optimized OpenGL
Performer data structures and scene graphs. It is used by most of the
database loaders in libpfdb to take external file formats containing 3D
geometry and graphics state and load them into OpenGL Performer optimized
run-time data structures. Such utilities often prove very useful; most
modeling tools and file formats represent their data in structures that
correspond to the way users model data, but such data structures are
often mutually exclusive with effective and efficient OpenGL Performer
run-time structures.
libpfdu contains many utilities, including DSO support for database
loaders and their modes, file path support, and so on, but the heart of
libpfdu is the OpenGL Performer database builder and geometry builder.
The builders are tools that allow users to input or output a collection
of geometry and graphics state in immediate mode.
Users send geometric primitives one at a time, each with its
corresponding graphics state, to the builder. When the builder has
received all the data, the user simply requests optimized OpenGL
Performer data structures which can then be used as a part of a scene
graph. The builder hashes geometry into different `bins' based on the
Page 11
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
geometry's attribute binding types and associated graphics state. It also
keeps track of graphics state elements (textures, materials, light
models, fog, and so on) and shares state elements whenever possible.
Finally, the builder creates pfGeoSets that contain triangle meshes
created by running the original geometry through the libpfdu triangle-
meshing utility.
To go along with each pfGeoSet, the builder creates a pfGeoState (OpenGL
Performer's encapsulated state primitive). The builder generates
pfGeoStates that share as many attributes as possible with other
pfGeoStates in the scene graph.
Having created these primitives (pfGeoSets and pfGeoStates) the builder
will place them in a leaf node (pfGeode), and optionally create a spatial
hierarchy by running the new database through a spatial breakup utility
function which is also contained in libpfdu.
Note that the builder also allows the user to extend the notion of a
graphics state by registering callback functionality through builder API
and then treating this state or functionality like any other OpenGL
Performer state or mode (although such uses of the builder are slightly
more complicated). In short, libpfdu is a collection of utilities that
effectively act as a data funnel where users enter flattened 3D graphics
information and are given in return fully functional and optimized OpenGL
Performer run-time structures.
The libpfui User Interface Library
The libpfui library provides building blocks for writing manipulation
components for user interfaces. This library provides both C and C++
interfaces. Provided are separate components for motion control (-
pfiInputCoordXform), collision detection between the viewer and objects
in the scene (pfiCollide), and picking of objects in the scene based on
current mouse coordinates (pfiPick). The pfiInputCoordXform utilities
update transformation matrices that can be used to drive motion in an
application. The actual mapping of user events is orthogonal to these
motion models and can be done using the input collection utilities in
libpfutil, or directly with custom application code. The pfiXformer is a
re-implementation of the old pfuXformer based on these components and
combines several different kinds of motion control in one complex
component. The pfiXformer also provides mapping of user input events,
such as mouse and keyboard, to motion controls which is described in the
pfiXformer reference page. Examples of how to use these utilities can be
found in
/usr/share/Performer/src/pguide/libpfui
The libpfx Viewer Library
The libpfx library provides an easy-to-use interface for creating simple
OpenGL Performer applications. Through the pfViewer and pfViewerManager
Page 12
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
(and derived classes), users can quickly prototype applications that
perform the basic functions of OpenGL Performer.
The pfViewer is an abstract base class providing windowing control, pre-
and post-frame callbacks, a main application loop, the loading of
datasets, multi-channel and stereo operation, and basic visual elements
such as a pfEarthSky and pfLightSource.
The derived pfMotifViewer, pfGTKViewer, and pfViewkitViewer classes
provides the above functionality plus interfaces with their respective
standard GUI toolkits, Motif, GTK, and Viewkit respectively. Examples of
how to use these classes can be found in
/usr/share/Performer/src/pguide/libpfx
The libpfutil Utility Library
The libpfutil library contains a large number of miscellaneous functions
that provide support for the following important tasks.
Processor control enables the user to specify which CPU a particular
Performer process runs on and to devote a particular processor to a given
process.
Multiprocess rendezvous lets master and slave processes synchronize in a
multiprocessing environment.
GLX mixed model routines are provided for compatibility with previous
versions of OpenGL Performer. Current development should be based on the
pfWindow and pfPipeWindow API.
GL and X input handling is handled by an exhaustive set of commands that
operate on compressed, space-efficient queues of events.
Cursor control is provided to easily manipulate the cursors associated
with each window managed by OpenGL Performer.
X fonts are supported so that they can be used to draw text in OpenGL
Performer windows. The main task of these functions is to simplify the
use of X fonts and present a high-level interface to the user.
Graphical User Interfaces (GUIs) are made easily accessible to the user
through a set of functions that provide simple means to create a GUI, set
up widgets, manipulate them, set user-defined functions to control their
behavior and do other common tasks.
Scene graph traversal routines provide for different, highly-customizable
traversal mechanisms for the OpenGL Performer scene graph.
MultiChannel Option (MCO) is supported on RealityEngine graphics systems
by a set of functions that generically initialize channels for using MCO.
Page 13
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
These same routines support the two and eight video output (DG-2 and DG-
8) versions of the InfiniteReality display generator board as well.
Path following mechanisms allow the user to follow a pre-defined path in
a walkthrough application. Functions to create paths are also provided.
Various draw styles like haloed lines and wireframe images are supported
as a demonstration of the uses of multi-pass rendering.
Other utilities supported are for timer control to track time in real-
time independently of the frame-rate, managing hash tables, a simple
geometric simplification scheme for generating very simple level-of-
detail representations of the scene graph, texture loading and texture
animation, random number generation, flybox control, smoke and fire
simulation and converting light point states into textures.
The libpfdb Database Library
libpfdb is a collection of independent libraries (one for each supported
file format) that read or write a particular scene description file
format. These loaders are implemented using the IRIX Dynamic Shared
Object facility and are demand loaded as needed.
The loaders in libpfdb have been developed by SGI, by modeling tool
vendors, and by Performer customers. Many are provided in source form as
part of this OpenGL Performer distribution. Use these loaders as
templates to write custom loaders for whatever formats you require in
your applications. The different kinds of file formats supported by
OpenGL Performer are listed below
3ds AutoDesk 3DStudio binary data
bin Minor SGI format used by powerflip
bpoly Side Effects Software PRISMS binary
byu Brigham Young University CAD/FEA data csb OpenGL Optimizer
native csb format
dwb Coryphaeus Software Designer's Workbench
dxf AutoDesk AutoCAD ASCII format
flt11 MultiGen public domain Flight v11 format
flt14 MultiGen OpenFlight v14 format
gds McDonnell-Douglas GDS things data
gfo Minor SGI format (radiosity output)
im Minor SGI format (OpenGL Performer example)
irtp AAI/Graphicon Interactive Real-Time PHIGS
iv SGI OpenInventor / Silicon Studio Keystone
lsa Lightscape Technologies radiosity (ASCII)
lsb Lightscape Technologies radiosity (binary)
m University of Washington mesh data
medit Medit Productions medit modeling tool
nff Eric Haines' ray tracing test data format
obj Wavefront Technologies data format
Page 14
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
phd Minor SGI format (polyhedra)
pfa OpenGL Performer ASCII database format
pfb OpenGL Performer BINARY database format
poly Side Effects Software PRISMS ASCII data
pts University of Washington point data
ptu Minor SGI format (OpenGL Performer example)
sgf US NAVY standard graphics format
sgo Minor SGI format
spf US NAVY simple polygon format
sponge Sierpinski sponge 3D fractal generator
star Yale University compact star chart data
stla 3D Structures Stereolithography (ASCII)
stlb 3D Structures Stereolithography (binary)
sv Format of John Kichury's i3dm modeler
tri University of Minnesota Geometry Center data
unc University of North Carolina data
Source code for many of these loaders is provided with OpenGL Performer.
Loader source code is located in and below the directory
/usr/share/Performer/src/lib/libpfdb
While most loaders do in fact "load" data from files, scene graphs can
also be generated procedurally. The sponge loader is an example of such
automatic generation; it builds a model of the Menger (Sierpinski)
sponge, without requiring an input file. To see the sponge run perfly
specify the number of recursions (0, 1, 2, ...) as the filename. For
example
perfly 2.sponge
Learning More
Once you've seen OpenGL Performer in action, you will want to learn more
about it. The OpenGL Performer Programming Guide and the OpenGL
Performer Release Notes are the primary sources of information, but the
following overview will give you a head start in your learning process.
OpenGL Performer Sample Code
The OpenGL Performer sample code can be found in
/usr/share/Performer/src/pguide - small examples
and
Page 15
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
/usr/share/Performer/src/sample - sample applications
and its subdirectories. The "sample" subdirectory contains the various
flying demos like perfly and the Performer town demo. The "pguide"
subdirectory has further subdirectories for each OpenGL Performer
library. Each of these directories has example and sample programs that
highlight the features of the corresponding library.
OpenGL Performer Documentation
In addition to the reference pages on OpenGL Performer, an on-line
Programming Guide is also provided. To read this, run Insight and click
on the Performer Programming Guide button.
OpenGL Performer World Wide Web Home Page
The SGI web site contains an archive of OpenGL Performer-related
technical and promotional material in the software section.
Explore the SGI web site using the URL
http://www.sgi.com/
or go directly to the OpenGL Performer information with the URL
http://www.sgi.com/software/performer
OpenGL Performer Electronic Mailing List
The OpenGL Performer mailing list is a resource for developers who are
using OpenGL Performer to maximize the performance of their graphics
applications on SGI hardware. The info-performer list is intended to be
an unmoderated, free-form discussion of OpenGL Performer with issues both
technical and non-technical; and to provide feedback to SGI about the
product. Much like the comp.sys.sgi.* newsgroups, it is not an official
support channel but is monitored by the OpenGL Performer development
team, so it's an excellent source of early information about upcoming
events and product features, as well as a venue for asking questions and
having them answered.
To subscribe to the info-performer mailing list, send email to
info-performer-request@sgi.com
Once your request is processed you will receive submission and posting
instructions, some guidelines, and a current copy of the Performer
Page 16
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Frequently-Asked-Questions (FAQ) list.
The mailing list has become rather large and carries several hundred
messages per month. Mailing list archives are available in
http://reality.sgi.com/performer
OpenGL Performer Application Programming Interface
The OpenGL Performer application programming interface (API) has been
designed by following a consistent set of naming principles that are
outlined below. Following that review is a complete listing of the API
grouped by topic for your use as both a quick reference and as an API
directory.
Each of the libpf, libpr, libpfdu, libpfdb, libpfui, libpfx, and
libpfutil functions also has a complete reference page description
available via the IRIX man and xman commands. Refer to these reference
pages for a thorough discussion of the functions and data types, features
and limitations, performance and resource implications, and sample code
showing how these functions are used in practice.
OpenGL Performer Software Conventions
All the OpenGL Performer commands have intuitive names that describe what
they do. These mnemonic names make it easy for you to learn and remember
the commands. The names may look a little strange to you if you're
unfamiliar with this type of convention because they use a mixture of
upper and lowercase letters. Naming conventions provide for consistency
and uniqueness, both for routines and for symbolic tokens. Following
consistent naming practices in the software that you develop will make it
easier for you and others on your team to understand and debug your code.
Naming conventions for OpenGL Performer are as follows:
All class, command and token names, associated with libpf or libpr are
preceded by the letters pf, denoting the OpenGL Performer library. Member
functions do not have the pf prefix since the class name provides
sufficient scope resolution. Functions from the other libraries also
affix an identifying letter suffix (d, i, or u) to the pf prefix for
scope resolution purposes.
Library Prefix Example
_____________________________________________
libpf pf pfMultiprocess
libpr pf pfGetCurDList
libpfdu pfd pfdNewGeom
libpfdb pfd pfdLoadFile_medit
|
|
Page 17
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
libpfui pfi pfiResetXformerPosition
libpfutil pfu pfuDownloadTexList
|
|
Command and type names are mixed-case, while token names are uppercase.
For example, pfTexture is a type name and PFTEX_SHARPEN is a token name.
Underscores are not used in function names except in the libpfdb
libraries, where the underscore serves to separate the common loader name
(pfdLoad) from the file type extension (medit in the example above).
In type names, the part following the pf is usually spelled out in full,
as is the case with pfTexture, but in some cases a shortened form of the
word is used. For example, pfDispList is the name of the display-list
type.
Much of OpenGL Performer's interface involves setting parameters and
retrieving parameter values. For the sake of brevity, the word Set is
omitted from function names, so that instead of pfSetMtlColor, pfMtlColor
is the name of the routine used for setting the color of a pfMaterial.
Get, however, is not omitted from the names of routines that get
information, such as pfGetMtlColor. C++ member function names do include
both "get" and "set".
Routine names are constructed by appending a type name to an operation
name. The operation name always precedes the type name. In this case, the
operation name is unabbreviated and the type name is abbreviated. For
example, the name of the routine that applies a pfTexture is pfApplyTex.
Compound type names are abbreviated by the first initial of the first
word and the entire second word. For example, to draw a display list,
which is type pfDispList, use pfDrawDList.
Symbolic token names incorporate another abbreviation, usually shorter,
of the type name. For example
pfTexture tokens begin with PFTEX_.
pfDispList tokens begin with PFDL_.
This convention ensures that tokens for a particular type have their own
name space.
Other tokens and identifiers follow the conventions of ANSI C and C++
wherein a valid identifier consists of upper and lower-case alphabetic
characters, digits, and underscores, and the first character is not a
digit.
Page 18
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
LIBPF
Initialization
pfInit initializes all internal IRIS Performer data structures while
pfExit cleans up before returning control to the application. The other
functions provide support for multiprocessed execution. This involves
configuring IRIS Performer for multiple processes and threads and
multiple and multiplexed (hyper) pipes.
DLLEXPORT int pfInit(void);
DLLEXPORT int pfIsInited(void);
DLLEXPORT void pfExit(void);
DLLEXPORT void pfExitWithoutExit(void);
DLLEXPORT int pfMultipipe(int numPipes);
DLLEXPORT int pfGetMultipipe(void);
DLLEXPORT int pfHyperpipe(int numHyperPipes);
DLLEXPORT int pfGetHyperpipe(pfPipe *pipe);
DLLEXPORT int pfMultiprocess(int mpMode);
DLLEXPORT int pfGetMultiprocess(void);
DLLEXPORT int pfGetMPBitmask(void);
DLLEXPORT int pfMultithread(int pipe, uint stage, int nprocs);
DLLEXPORT int pfGetMultithread(int pipe, uint stage);
DLLEXPORT int pfMultithreadParami(int pipe, uint param, uint value);
DLLEXPORT uint pfGetMultithreadParami(int pipe, uint param);
DLLEXPORT int pfMultithreadParamf(int pipe, uint param, float value);
DLLEXPORT float
pfGetMultithreadParamf(int pipe, uint param);
DLLEXPORT int pfMultithreadParam(int pipe, uint param, void *value);
DLLEXPORT void *
pfGetMultithreadParam(int pipe, uint param);
DLLEXPORT int pfSKGetNumPrimsRemoved(int pipe, int primType);
DLLEXPORT int pfConfig(void);
DLLEXPORT int pfIsConfiged(void);
DLLEXPORT pid_t
pfGetPID(int pipe, uint stage);
DLLEXPORT uint pfGetStage(pid_t pid, int *pipe);
DLLEXPORT void pfStageConfigFunc(int pipe, uint stage,
pfStageFuncType configFunc);
DLLEXPORT pfStageFuncType
pfGetStageConfigFunc(int pipe, uint stage);
DLLEXPORT int pfConfigStage(int pipe, uint stage);
DLLEXPORT const char *
pfGetStageName(int pipe, uint stage);
DLLEXPORT const char *
pfGetPIDName(pid_t pid);
DLLEXPORT void pfCreateProcessFunc(pfCreateProcessFuncType func);
DLLEXPORT pfCreateProcessFuncType
pfGetCreateProcessFunc(void);
DLLEXPORT void pfProcessMiscCPU(int cpu);
DLLEXPORT int pfGetProcessMiscCPU(void);
DLLEXPORT void pfPrintProcessState(FILE *fp);
Page 19
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT int pfAddProcToKillOnExitList( pid_t pid );
Frame Control
IRIS Performer is designed to run at a fixed frame rate. pfFrame, pfSync
and associated functions set a frame rate the application should run at,
initiate each new frame of IRIS Performer processing and synchronize the
application process with the specified frame rate.
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.
DLLEXPORT void pfAppFrame(void);
DLLEXPORT int pfSync(void);
DLLEXPORT int pfFrame(void);
DLLEXPORT void pfApp(void);
DLLEXPORT void pfCull(void);
DLLEXPORT void pfDraw(void);
DLLEXPORT void pfDrawBin(int bin);
DLLEXPORT void pfDrawScene(void);
DLLEXPORT void pfLPoint(void);
DLLEXPORT void pfCompute(void);
DLLEXPORT void pfIsectFunc(pfIsectFuncType func);
DLLEXPORT pfIsectFuncType
pfGetIsectFunc(void);
DLLEXPORT void*
pfAllocIsectData(int bytes);
DLLEXPORT void*
pfGetIsectData(void);
DLLEXPORT void pfPassIsectData(void);
DLLEXPORT void pfDBase(void);
DLLEXPORT void pfDBaseFunc(pfDBaseFuncType func);
DLLEXPORT pfDBaseFuncType
pfGetDBaseFunc(void);
DLLEXPORT void*
pfAllocDBaseData(int bytes);
DLLEXPORT void*
pfGetDBaseData(void);
DLLEXPORT void pfPassDBaseData(void);
DLLEXPORT void pfComputeFunc(pfComputeFuncType func);
DLLEXPORT pfComputeFuncType
pfGetComputeFunc(void);
DLLEXPORT void*
pfAllocComputeData(int bytes);
DLLEXPORT void*
pfGetComputeData(void);
Page 20
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT void pfPassComputeData(void);
DLLEXPORT int pfGetLastPipeFrameCount(int pipe);
DLLEXPORT int pfGetPipeDrawCount(int pipe);
DLLEXPORT int pfGetPipeNum(void);
DLLEXPORT void pfPhase(int phase);
DLLEXPORT int pfGetPhase(void);
DLLEXPORT void pfVideoRate(float vrate);
DLLEXPORT float
pfGetVideoRate(void);
DLLEXPORT float
pfFrameRate(float rate);
DLLEXPORT float
pfGetFrameRate(void);
DLLEXPORT int pfFieldRate(int fields);
DLLEXPORT int pfGetFieldRate(void);
DLLEXPORT int pfGetFrameCount(void);
DLLEXPORT double
pfGetFrameTimeStamp(void);
DLLEXPORT void pfFrameTimeStamp(double t);
DLLEXPORT pfFlux*
pfGetFrameTimeFlux(void);
DLLEXPORT int pfGetId(void *mem);
DLLEXPORT int pfAsyncDelete(void *mem);
DLLEXPORT int pfCopy(void *dst, void *src);
DLLEXPORT void pfProcessPriorityUpgrade(int state);
DLLEXPORT int pfGetProcessPriorityUpgrade(void);
DLLEXPORT void pfProcessHighestPriority(int pri);
DLLEXPORT int pfGetProcessHighestPriority(void);
Surface support
pfPipe Functions
A pfPipe is a software rendering pipeline which renders one or more
pfChannels into one or more pfPipeWindows. Typically one pfPipe is
created for each hardware graphics pipeline.
DLLEXPORT pfPipe*
pfGetPipe(int pipeNum);
DLLEXPORT int pfInitPipe(pfPipe *pipe, pfPipeFuncType configFunc);
pfPipe C++ API
These functions create and manipulate pfPipes. Control can be exercised
over the hardware screen used by the pfPipe and the way a pfPipe swaps
color buffers at the end of each frame.
pfType* pfPipe::getClassType();
void pfPipe::setSwapFunc(pfPipeSwapFuncType func);
pfPipeSwapFuncType
pfPipe::getSwapFunc()const;
float pfPipe::getLoad()const;
void pfPipe::getSize(int *xs, int *ys)const;
Page 21
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfPipe::setScreen(int scr);
int pfPipe::getScreen()const;
void pfPipe::setServer(int dis);
int pfPipe::getServer()const;
void pfPipe::setWSConnectionName(const char *name);
const char* pfPipe::getWSConnectionName()const;
pfMPClipTexture*
pfPipe::getMPClipTexture(int i)const;
int pfPipe::getNumMPClipTextures()const;
pfChannel* pfPipe::getChan(int i)const;
int pfPipe::getNumChans()const;
pfPipeWindow* pfPipe::getPWin(int i)const;
int pfPipe::getNumPWins()const;
void pfPipe::setIncrementalStateChanNum(int num);
int pfPipe::getIncrementalStateChanNum()const;
int pfPipe::getHyperId()const;
void pfPipe::bindPVChans();
void pfPipe::unbindPVChans();
int pfPipe::movePWin(int where, pfPipeWindow *pw);
void pfPipe::addMPClipTexture(pfMPClipTexture *clip);
int pfPipe::removeMPClipTexture(pfMPClipTexture *clip);
void pfPipe::setTotalTexLoadTime(float totalTexLoadTime);
float pfPipe::getTotalTexLoadTime()const;
pfCompositor* pfPipe::getCompositor();
int pfPipe::isCompositorMaster();
int pfPipe::getCompositorChildIndex();
pfBuffer C++ API
The pfBuffer data structure logically encompasses libpf objects such as
pfNodes. Newly created objects are automatically "attached" to the
current pfBuffer specified by pfBuffer::select. Later, any objects
created in buf may be merged into the main IRIS Performer processing
stream with pfBuffer::merge. In conjunction with a forked DBASE process
(see pfMultiprocess and pfDBaseFunc), the pfBuffer mechanism supports
asynchronous parallel creation and deletion of database objects. This is
the foundation of a real-time database paging system.
new pfBuffer();
void pfBuffer::setScope(pfObject *obj, int scope);
int pfBuffer::getScope(pfObject *obj);
void pfBuffer::merge();
int pfBuffer::unrefDelete(void *mem);
int pfBuffer::unrefDeleteFromData(void *mem);
int pfBuffer::checkDelete(void *mem);
int pfBuffer::checkDeleteFromData(void *mem);
int pfBuffer::insert(void *parent, int index, void *child);
int pfBuffer::remove(void *parent, void *child);
int pfBuffer::add(void *parent, void *child);
int pfBuffer::replace(void *parent, void *oldChild,
void *newChild);
Page 22
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfBuffer::set(void *parent, int index, void *child);
void pfBuffer::select();
DLLEXPORT pfBuffer*
pfGetCurBuffer(void);
DLLEXPORT void pfInitGfx(void);
pfPipeWindow C++ API
A pfPipeWindow creates a window on the screen managed by a given pfPipe.
Programs render to a pfPipeWindow by attaching a pfChannel of that pfPipe
to the pfPipeWindow. Various ways of controlling the behavior of
pfPipeWindows are provided including specifying their position and size
on the screen, specifying user-specified callbacks to configure them in
the DRAW process, controlling lists of pfWindows that can draw into a
singe pfPipewindow, and manipulating pfChannels assigned to the
pfPipeWindows.
new pfPipeWindow(pfPipe *p);
pfType* pfPipeWindow::getClassType();
void pfPipeWindow::printSwapGroup();
void pfPipeWindow::setName(const char *name);
const char* pfPipeWindow::getName();
void pfPipeWindow::setWSConnectionName(const char *name);
const char* pfPipeWindow::getWSConnectionName();
void pfPipeWindow::setMode(int mode, int val);
int pfPipeWindow::getMode(int mode);
void pfPipeWindow::setWinType(uint type);
uint pfPipeWindow::getWinType()const;
pfState* pfPipeWindow::getCurState();
void pfPipeWindow::setAspect(int x, int y);
void pfPipeWindow::getAspect(int *x, int *y);
void pfPipeWindow::setOriginSize(int xo, int yo, int xs,
int ys);
void pfPipeWindow::setOrigin(int xo, int yo);
void pfPipeWindow::getOrigin(int *xo, int *yo);
void pfPipeWindow::getScreenOrigin(int *xo, int *yo);
void pfPipeWindow::setSize(int xs, int ys);
void pfPipeWindow::getSize(int *xs, int *ys);
void pfPipeWindow::setFullScreen();
void pfPipeWindow::getCurOriginSize(int *xo, int *yo, int *xs,
int *ys);
void pfPipeWindow::getCurScreenOriginSize(int *xo, int *yo,
int *xs, int *ys);
void pfPipeWindow::setOverlayWin(pfWindow *ow);
pfWindow* pfPipeWindow::getOverlayWin();
void pfPipeWindow::setStatsWin(pfWindow *sw);
pfWindow* pfPipeWindow::getStatsWin();
void pfPipeWindow::setScreen(int screen);
int pfPipeWindow::getScreen();
void pfPipeWindow::setShare(int mode);
uint pfPipeWindow::getShare();
Page 23
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfPipeWindow::setWSWindow(pfWSConnection dsp,
pfWSWindow wsw);
Window pfPipeWindow::getWSWindow();
void pfPipeWindow::setWSDrawable(pfWSConnection dsp,
pfWSDrawable gxw);
pfWSDrawable pfPipeWindow::getWSDrawable();
pfWSDrawable pfPipeWindow::getCurWSDrawable();
void pfPipeWindow::setFBConfigData(void *data);
void* pfPipeWindow::getFBConfigData();
void pfPipeWindow::setFBConfigAttrs(int *attr);
int* pfPipeWindow::getFBConfigAttrs();
void pfPipeWindow::setFBConfig(XVisualInfo *vis);
XVisualInfo* pfPipeWindow::getFBConfig();
void pfPipeWindow::setFBConfigId(int vId);
int pfPipeWindow::getFBConfigId();
void pfPipeWindow::setIndex(int index);
int pfPipeWindow::getIndex();
pfWindow* pfPipeWindow::getSelect();
void pfPipeWindow::setGLCxt(pfGLContext gc);
pfGLContext pfPipeWindow::getGLCxt();
void pfPipeWindow::setSwapBarrier(int barrierName);
int pfPipeWindow::getSwapBarrier();
void pfPipeWindow::setWinList(pfList *wl);
pfList* pfPipeWindow::getWinList()const;
void pfPipeWindow::setCompositorShareMask(uint mask);
uint pfPipeWindow::getCompositorShareMask()const;
int pfPipeWindow::attachWin(pfWindow *w1);
int pfPipeWindow::detachWin(pfWindow *w1);
int pfPipeWindow::attach(pfPipeWindow *pw1);
int pfPipeWindow::detach(pfPipeWindow *pw1);
void pfPipeWindow::attachSwapGroup(pfPipeWindow *w1);
void pfPipeWindow::attachWinSwapGroup(pfWindow *w1);
void pfPipeWindow::detachSwapGroup();
pfWindow* pfPipeWindow::select();
void pfPipeWindow::swapBuffers();
pfFBConfig pfPipeWindow::chooseFBConfig(int *attr);
int pfPipeWindow::isOpen();
int pfPipeWindow::isManaged();
int pfPipeWindow::inSwapGroup();
int pfPipeWindow::query(int which, int *dst);
int pfPipeWindow::mQuery(int *which, int *dst);
pfPipe* pfPipeWindow::getPipe();
int pfPipeWindow::getPipeIndex()const;
void pfPipeWindow::setConfigFunc(pfPWinFuncType func);
pfPWinFuncType pfPipeWindow::getConfigFunc();
int pfPipeWindow::getChanIndex(pfChannel *chan);
void pfPipeWindow::config();
void pfPipeWindow::open();
void pfPipeWindow::close();
void pfPipeWindow::closeGL();
Page 24
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfPipeWindow::removeChan(pfChannel *chan);
int pfPipeWindow::addChan(pfChannel *chan);
void pfPipeWindow::insertChan(int where, pfChannel *chan);
int pfPipeWindow::moveChan(int where, pfChannel *chan);
pfChannel* pfPipeWindow::getChan(int which);
int pfPipeWindow::getNumChans()const;
int pfPipeWindow::addPVChan(pfPipeVideoChannel *vchan);
void pfPipeWindow::setPVChan(int num,
pfPipeVideoChannel *vchan);
void pfPipeWindow::removePVChan(pfPipeVideoChannel *vchan);
void pfPipeWindow::removePVChanIndex(int num);
pfPipeVideoChannel*
pfPipeWindow::getPVChan(int num);
pfPipeVideoChannel*
pfPipeWindow::getPVChanId(int num);
pfPipeVideoChannel*
pfPipeWindow::getPosPVChan(int x, int y);
int pfPipeWindow::getPVChanIndex(pfPipeVideoChannel *vchan);
int pfPipeWindow::getNumPVChans()const;
void pfPipeWindow::bindPVChans();
void pfPipeWindow::unbindPVChans();
pfPipeVideoChannel C++ API
The pfPipeVideoChannel capability is used to direct the output of
pfChannels to different video outputs. A pfPipeVideoChannel is created
from a pfPipe and can only be used to manage video channels on the
graphics pipeline managed by the parent pfPipe. They are similar to
pfVideoChannels but are tracked and maintained by libpf and are needed by
libpf to draw pfChannels.
new pfPipeVideoChannel(pfPipe *p);
pfType* pfPipeVideoChannel::getClassType();
void pfPipeVideoChannel::setMode(int mode, int val);
int pfPipeVideoChannel::getMode(int mode);
void pfPipeVideoChannel::setWSWindow(pfWSWindow wsWin);
pfWSWindow pfPipeVideoChannel::getWSWindow()const;
void pfPipeVideoChannel::setCallig(pfCalligraphic *ca);
pfCalligraphic*
pfPipeVideoChannel::getCallig()const;
void pfPipeVideoChannel::getOrigin(int *xo, int *yo);
void pfPipeVideoChannel::getSize(int *xs, int *ys);
void pfPipeVideoChannel::getMinDeltas(int *dx, int *dy)const;
void pfPipeVideoChannel::getScreenOutputOrigin(int *xo,
int *yo);
void pfPipeVideoChannel::setOutputOrigin(int xo, int yo);
void pfPipeVideoChannel::getOutputOrigin(int *xo, int *yo);
void pfPipeVideoChannel::setOutputSize(int xs, int ys);
void pfPipeVideoChannel::getOutputSize(int *xs, int *ys);
void pfPipeVideoChannel::setAreaScale(float s);
float pfPipeVideoChannel::getAreaScale();
Page 25
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfPipeVideoChannel::setMinScale(float xs, float ys);
void pfPipeVideoChannel::getMinScale(float *xs,
float *ys)const;
void pfPipeVideoChannel::setMaxScale(float xs, float ys);
void pfPipeVideoChannel::getMaxScale(float *xs,
float *ys)const;
void pfPipeVideoChannel::setScale(float xs, float ys);
void pfPipeVideoChannel::getScale(float *xs, float *ys)const;
void pfPipeVideoChannel::setFullRect();
int pfPipeVideoChannel::getScreen()const;
void pfPipeVideoChannel::setId(int index);
int pfPipeVideoChannel::getId();
pfWSVideoChannelInfo
pfPipeVideoChannel::getInfo();
void pfPipeVideoChannel::setDVRMode(int mode);
int pfPipeVideoChannel::getDVRMode()const;
void pfPipeVideoChannel::setStressFilter(float frac, float low,
float high, float ps, float s, float max);
void pfPipeVideoChannel::getStressFilter(float *frac,
float *low, float *high, float *ps, float *s,
float *max)const;
void pfPipeVideoChannel::setStress(float stress);
float pfPipeVideoChannel::getStress()const;
float pfPipeVideoChannel::getLoad()const;
void pfPipeVideoChannel::setMinIncScale(float xs, float ys);
void pfPipeVideoChannel::getMinIncScale(float *xs,
float *ys)const;
void pfPipeVideoChannel::setMaxIncScale(float xs, float ys);
void pfPipeVideoChannel::getMaxIncScale(float *xs,
float *ys)const;
void pfPipeVideoChannel::setMinDecScale(float xs, float ys);
void pfPipeVideoChannel::getMinDecScale(float *xs,
float *ys)const;
void pfPipeVideoChannel::setMaxDecScale(float xs, float ys);
void pfPipeVideoChannel::getMaxDecScale(float *xs,
float *ys)const;
void pfPipeVideoChannel::select();
void pfPipeVideoChannel::apply();
void pfPipeVideoChannel::bind();
void pfPipeVideoChannel::unbind();
int pfPipeVideoChannel::isBound()const;
int pfPipeVideoChannel::isActive();
pfPipe* pfPipeVideoChannel::getPipe();
pfPipeWindow* pfPipeVideoChannel::getPWin();
int pfPipeVideoChannel::getPWinIndex();
DLLEXPORT void pfNodePickSetup(pfNode* node);
pfChannel C++ API
A pfChannel's primary function is to define a viewing frustum which is
used both for viewing and for culling. A pfChannel can be associated with
a pfPipe with new pfChannel. All aspects of the pfChannel's viewing
frustum, field of view (FOV), aspect ratio, view point and viewing
Page 26
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
direction can be modified. A custom culling volume for the pfChannel can
be set (pfChannel::setCullPtope).
Different queries can be made about the pfChannel (pfChannel::get*) and
user-defined traversal functions and mode can be set (pfChannel::set*).
Functions are provided to control IRIS Performer's level-of-detail (LOD)
behavior by specifying view position, field-of-view, and viewport pixel
size (pfChannel::setLOD* and pfChannel::getLOD*). pfChannel::setStress
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 pfChannel::setScene and pfChannel::setESky, 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 pfChannel::pick 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
(pfChannel::setBinSort and friends).
new pfChannel(pfPipe *p);
pfType* pfChannel::getClassType();
int pfChannel::getFrustType()const;
void pfChannel::setAspect(int which, float xyaspect);
float pfChannel::getAspect();
void pfChannel::getFOV(float *fovH, float *fovV)const;
void pfChannel::setNearFar(float n, float f);
void pfChannel::getNearFar(float *n, float *f)const;
void pfChannel::getNear(pfVec3& ll, pfVec3& lr, pfVec3& ul,
pfVec3& ur)const;
void pfChannel::getFar(pfVec3& ll, pfVec3& lr, pfVec3& ul,
pfVec3& ur)const;
void pfChannel::getPtope(pfPolytope *dst)const;
int pfChannel::getEye(pfVec3& eye)const;
int pfChannel::getUserFrustType()const;
float pfChannel::getUserAspect();
void pfChannel::getUserFOV(float *fovH, float *fovV)const;
void pfChannel::getUserNearFar(float *n, float *f)const;
void pfChannel::getUserNear(pfVec3& ll, pfVec3& lr, pfVec3& ul,
pfVec3& ur)const;
void pfChannel::getUserFar(pfVec3& ll, pfVec3& lr, pfVec3& ul,
pfVec3& ur)const;
void pfChannel::getUserPtope(pfPolytope *dst)const;
int pfChannel::getUserEye(pfVec3& eye)const;
void pfChannel::makePersp(float l, float r, float b, float t);
void pfChannel::makeOrtho(float l, float r, float b, float t);
void pfChannel::makeInfPersp(float l, float r, float b,
float t);
Page 27
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfChannel::makeOutputPersp(float l, float r, float b,
float t);
void pfChannel::makeOutputOrtho(float l, float r, float b,
float t);
void pfChannel::makeOutputInfPersp(float l, float r, float b,
float t);
void pfChannel::getLeftRightBottomTop(float *l, float *r,
float *b, float *t);
void pfChannel::getUserLeftRightBottomTop(float *l, float *r,
float *b, float *t);
void pfChannel::makeSimple(float fov);
void pfChannel::orthoXform(pfFrustum *fr, const pfMatrix& mat);
int pfChannel::contains(const pfVec3& pt)const;
int pfChannel::contains(const pfSphere *sphere)const;
int pfChannel::contains(const pfBox *box)const;
int pfChannel::contains(const pfCylinder *cyl)const;
int pfChannel::userContains(const pfVec3& pt)const;
int pfChannel::userContains(const pfSphere *sphere)const;
int pfChannel::userContains(const pfBox *box)const;
int pfChannel::userContains(const pfCylinder *cyl)const;
void pfChannel::apply();
pfPipe* pfChannel::getPipe()const;
pfPipeWindow* pfChannel::getPWin();
int pfChannel::getPWinIndex();
pfPipeVideoChannel*
pfChannel::getPVChan()const;
pfPipeVideoChannel*
pfChannel::getFramePVChan()const;
void pfChannel::setPWinPVChanIndex(int num);
int pfChannel::getPWinPVChanIndex()const;
void pfChannel::setFOV(float fovH, float fovV);
void pfChannel::setViewport(float l, float r, float b,
float t);
void pfChannel::getViewport(float *l, float *r, float *b,
float *t)const;
void pfChannel::setOutputViewport(float l, float r, float b,
float t);
void pfChannel::getOutputViewport(float *l, float *r, float *b,
float *t)const;
void pfChannel::getOrigin(int *xo, int *yo)const;
void pfChannel::getSize(int *xs, int *ys)const;
void pfChannel::getOutputOrigin(int *xo, int *yo)const;
void pfChannel::getOutputSize(int *xs, int *ys)const;
void pfChannel::setPixScale(float s);
void pfChannel::setMinPixScale(float min);
void pfChannel::setMaxPixScale(float max);
float pfChannel::getPixScale()const;
float pfChannel::getMinPixScale()const;
float pfChannel::getMaxPixScale()const;
void pfChannel::setProjMode(int mode);
Page 28
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfChannel::getProjMode()const;
void pfChannel::setShare(uint mask);
uint pfChannel::getShare()const;
void pfChannel::setCompositorShareMask(uint mask);
uint pfChannel::getCompositorShareMask()const;
void pfChannel::setAutoAspect(int which);
int pfChannel::getAutoAspect()const;
void pfChannel::getBaseFrust(pfFrustum *frust)const;
void pfChannel::getBaseUserFrust(pfFrustum *frust)const;
void pfChannel::setViewOffsets(pfVec3& xyz, pfVec3& hpr);
void pfChannel::getViewOffsets(pfVec3& xyz, pfVec3& hpr)const;
void pfChannel::setView(pfVec3& vp, pfVec3& vd);
void pfChannel::setViewD(pfVec3d& vp, pfVec3d& vd);
void pfChannel::getView(pfVec3& vp, pfVec3& vd);
void pfChannel::getViewD(pfVec3d& vp, pfVec3d& vd);
void pfChannel::setViewMat(pfMatrix& mat);
void pfChannel::setViewMatD(pfMatrix4d& mat);
void pfChannel::getViewMat(pfMatrix& mat)const;
void pfChannel::getViewMatD(pfMatrix4d& mat)const;
void pfChannel::getOffsetViewMat(pfMatrix& mat)const;
void pfChannel::setCullPtope(const pfPolytope *vol);
int pfChannel::getCullPtope(pfPolytope *vol, int space)const;
void* pfChannel::allocChanData(int size);
void pfChannel::setChanData(void *data, size_t size);
void* pfChannel::getChanData()const;
size_t pfChannel::getChanDataSize()const;
void pfChannel::setTravFunc(int trav, pfChanFuncType func);
pfChanFuncType pfChannel::getTravFunc(int trav)const;
void pfChannel::setTravMode(int trav, int mode);
int pfChannel::getTravMode(int trav)const;
void pfChannel::setTravMask(int which, uint mask);
uint pfChannel::getTravMask(int which)const;
void pfChannel::setStressFilter(float frac, float low,
float high, float s, float max);
void pfChannel::getStressFilter(float *frac, float *low,
float *high, float *s, float *max)const;
void pfChannel::setStress(float stress);
float pfChannel::getStress()const;
float pfChannel::getLoad()const;
void pfChannel::setScene(pfScene *s);
pfScene* pfChannel::getScene()const;
void pfChannel::setESky(pfEarthSky *es);
pfEarthSky* pfChannel::getESky()const;
void pfChannel::setGState(pfGeoState *gstate);
pfGeoState* pfChannel::getGState()const;
void pfChannel::setGStateTable(pfList *list);
pfList* pfChannel::getGStateTable()const;
void pfChannel::setLODAttr(int attr, float val);
float pfChannel::getLODAttr(int attr)const;
void pfChannel::setLODState(const pfLODState *ls);
Page 29
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfChannel::getLODState(pfLODState *ls)const;
void pfChannel::setLODStateList(pfList *stateList);
pfList* pfChannel::getLODStateList()const;
int pfChannel::setStatsMode(uint mode, uint val);
pfFrameStats* pfChannel::getFStats();
void pfChannel::setCalligEnable(int enable);
int pfChannel::getCalligEnable()const;
void pfChannel::setCallig(pfCalligraphic *callig);
pfCalligraphic*
pfChannel::getCallig()const;
pfCalligraphic*
pfChannel::getCurCallig();
void pfChannel::setBinSort(int bin, int sortType,
uint64_t *sortOrders);
int pfChannel::getBinSort(int bin, uint64_t *sortOrders);
void pfChannel::setBinSortPriority(int bin, int priority);
int pfChannel::getBinSortPriority(int bin)const;
void pfChannel::setBinOrder(int bin, int order);
int pfChannel::getBinOrder(int bin)const;
void pfChannel::setBinChildOrderMask(int bin,
uint64_t orderMask);
uint64_t pfChannel::getBinChildOrderMask(int bin)const;
void pfChannel::setBinFlags(int bin, int flags);
int pfChannel::getBinFlags(int bin)const;
void pfChannel::setBinCallBack(int bin, int type,
pfDListFuncType func);
pfDListFuncType
pfChannel::getBinCallBack(int bin, int type);
void pfChannel::setBinUserData(int bin, void *userData,
int size);
void* pfChannel::getBinUserData(int bin, int *size);
int pfChannel::getFreeBin();
int pfChannel::findSubBin(int bin1, int bin2, int create);
int pfChannel::findBinParent(int bin, int lastKnownParent);
pfCullProgram* pfChannel::getCullProgram();
void pfChannel::addBinChild(int child, int root,
uint64_t rootMask);
int pfChannel::isSubbinOf(int bin1, int bin2);
int pfChannel::attach(pfChannel *chan1);
int pfChannel::detach(pfChannel *chan1);
int pfChannel::ASDattach(pfChannel *chan1);
int pfChannel::ASDdetach(pfChannel *chan1);
void pfChannel::passChanData();
int pfChannel::pick(int mode, float px, float py,
float radius, pfHit **pickList[]);
void pfChannel::clear();
void pfChannel::drawStats();
int pfChannel::isect(pfNode *node, pfSegSet *segSet,
pfHit **hits[], pfMatrix *ma);
void pfChannel::computeMatrices(pfMatrix *model,
pfMatrix *proj);
Page 30
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfEarthSky C++ API
These functions provide a means to clear the frame and Z-buffer, draw a
sky, horizon and ground plane, and to implement various weather effects
like fog and clouds.
new pfEarthSky();
pfType* pfEarthSky::getClassType();
void pfEarthSky::setMode(int mode, int val);
int pfEarthSky::getMode(int mode);
void pfEarthSky::setAttr(int mode, float val);
float pfEarthSky::getAttr(int mode);
void pfEarthSky::setColor(int which, float r, float g, float b,
float a);
void pfEarthSky::getColor(int which, float *r, float *g,
float *b, float *a);
void pfEarthSky::setFog(int which, pfFog *fog);
pfFog* pfEarthSky::getFog(int which);
void pfEarthSky::setFogDensities(int numpt, float *elevations,
float *densities);
void pfEarthSky::getFogDensities(int *numpt, float **elevations,
float **densities);
void pfEarthSky::setFogTextureElevations(int n, float *elev);
void pfEarthSky::getFogTextureElevations(int *n, float **elev);
void pfEarthSky::setFogTexture(pfTexture *tex);
pfTexture* pfEarthSky::getFogTexture();
void pfEarthSky::setFogTextureColorTable(int n, uchar *table);
void pfEarthSky::getFogTextureColorTable(int *n, uchar **table);
void pfEarthSky::loadFogTextureColorTable();
void pfEarthSky::makeFogTexture();
pfMPClipTexture C++ API
A pfMPClipTexture is a libpf wrapper used to allow for the multi-process
operation of a pfClipTexture. A pfMPClipTexture allows user to center
the pfClipTexture in the app, have all of the work to determine the
necessary disk and texture loading done in the cull, and have all of
texture loads applied frame accurately in the draw.
new pfMPClipTexture();
pfType* pfMPClipTexture::getClassType();
void pfMPClipTexture::setClipTexture(pfClipTexture *clip);
pfClipTexture* pfMPClipTexture::getClipTexture();
void pfMPClipTexture::setCenter(int s, int t, int r);
void pfMPClipTexture::getCenter(int *s, int *t, int *r);
void pfMPClipTexture::setInvalidBorder(int invalidBorder);
int pfMPClipTexture::getInvalidBorder();
void pfMPClipTexture::setVirtualLODOffset(int lodOffset);
int pfMPClipTexture::getVirtualLODOffset();
void -
pfMPClipTexture::setNumEffectiveLevels(int effectiveLevels);
int pfMPClipTexture::getNumEffectiveLevels();
Page 31
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfMPClipTexture::setMaster(pfMPClipTexture *master);
pfMPClipTexture*
pfMPClipTexture::getMaster()const;
pfList* pfMPClipTexture::getSlaves()const;
void pfMPClipTexture::setShareMask(uint sharemask);
uint pfMPClipTexture::getShareMask();
void pfMPClipTexture::setLODRange(float min, float max);
void pfMPClipTexture::getLODRange(float *min, float *max);
pfPipe* pfMPClipTexture::getPipe()const;
void pfMPClipTexture::setDTRMode(uint mask);
uint pfMPClipTexture::getDTRMode();
void pfMPClipTexture::setLODBias(float lodBiasS,
float lodBiasT, float lodBiasR);
void pfMPClipTexture::getLODBias(float *lodBiasS,
float *lodBiasT, float *lodBiasR);
void pfMPClipTexture::setMagFilter(uint magFilter);
uint pfMPClipTexture::getMagFilter();
void pfMPClipTexture::setDTRFadeCount(int count);
int pfMPClipTexture::getDTRFadeCount();
void pfMPClipTexture::setDTRBlurMargin(float frac);
float pfMPClipTexture::getDTRBlurMargin();
void pfMPClipTexture::setTexLoadTime(float msec);
float pfMPClipTexture::getTexLoadTime();
void pfMPClipTexture::setTexLoadTimeFrac(float frac);
float pfMPClipTexture::getTexLoadTimeFrac();
float pfMPClipTexture::getCurTexLoadTime();
void pfMPClipTexture::beginRecord(const char *fileName);
void pfMPClipTexture::endRecord();
int pfMPClipTexture::isRecording();
void pfMPClipTexture::beginPlay(const char *fileName);
void pfMPClipTexture::endPlay();
int pfMPClipTexture::isPlaying();
void pfMPClipTexture::setLODOffsetLimit(int lo, int hi);
void pfMPClipTexture::getLODOffsetLimit(int *lo, int *hi);
void pfMPClipTexture::setNumEffectiveLevelsLimit(int lo,
int hi);
void pfMPClipTexture::getNumEffectiveLevelsLimit(int *lo,
int *hi);
void pfMPClipTexture::setMinLODLimit(float lo, float hi);
void pfMPClipTexture::getMinLODLimit(float *lo, float *hi);
void pfMPClipTexture::setMaxLODLimit(float lo, float hi);
void pfMPClipTexture::getMaxLODLimit(float *lo, float *hi);
void pfMPClipTexture::setLODBiasLimit(float Slo, float Shi,
float Tlo, float Thi, float Rlo, float Rhi);
void pfMPClipTexture::getLODBiasLimit(float *Slo, float *Shi,
float *Tlo, float *Thi, float *Rlo, float *Rhi);
void pfMPClipTexture::apply();
pfVolFog C++ API
new(void *arena)
pfVolFog();
Page 32
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfType* pfVolFog::getClassType();
void pfVolFog::setColor(float r, float g, float b);
void pfVolFog::getColor(float *r, float *g, float *b);
void pfVolFog::setFlags(int which, int val);
int pfVolFog::getFlags(int which);
void pfVolFog::setVal(int which, float val);
void pfVolFog::getVal(int which, float *val);
void pfVolFog::setAttr(int which, void *attr);
void pfVolFog::getAttr(int which, void *attr);
void pfVolFog::apply(pfScene *scene);
void pfVolFog::draw(pfChannel *channel);
void pfVolFog::addChannel(pfChannel *channel);
void pfVolFog::updateView();
void pfVolFog::rotateFogCS(pfMatrix *mat);
void pfVolFog::addNode(pfNode *node);
void pfVolFog::deleteNode(pfNode *node);
void pfVolFog::setDensity(float density);
float pfVolFog::getDensity();
void pfVolFog::setVal(int which, int index, float val);
void pfVolFog::getVal(int which, int index, float *val);
void pfVolFog::setVal(int which, pfNode *node, float val);
void pfVolFog::getVal(int which, pfNode *node, float *val);
void pfVolFog::setAttr(int which, int index, void *attr);
void pfVolFog::getAttr(int which, int index, void *attr);
void pfVolFog::setAttr(int which, pfNode *node, void *attr);
void pfVolFog::getAttr(int which, pfNode *node, void *attr);
pfTexture* pfVolFog::getTexture();
void pfVolFog::addPoint(float elevation, float density);
void pfVolFog::addColoredPoint(float elevation, float density,
float r, float g, float b);
pfStateMapList C++ API
new(void *arena)
pfStateMapList(pfStateMapList *last);
pfType* pfStateMapList::getClassType();
pfRotorWash C++ API
new(void *arena)
pfRotorWash(int mesh_rings, int mesh_spokes);
pfType* pfRotorWash::getClassType();
pfNode* pfRotorWash::getNode();
pfTexture* pfRotorWash::getTexture(pfGeoState *gstate, int frame);
void pfRotorWash::setTextures(pfGeoState **gstates, int num,
char *name, int numtex);
void pfRotorWash::setColor(pfGeoState *geostate, float r,
float g, float b, float a);
void pfRotorWash::setRadii(float in_1, float in_2, float out_1,
float out_2);
void pfRotorWash::setAlpha(float a_inner, float a_outer);
void pfRotorWash::setDisplacement(float value);
Page 33
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfRotorWash::setSubdivisionLevel(int level);
int pfRotorWash::getSubdivisionLevel();
void pfRotorWash::setMaxTriangles(int maxTris);
int pfRotorWash::getMaxTriangles();
void pfRotorWash::highlight(float red, float green,
float blue);
void pfRotorWash::unhighlight();
void pfRotorWash::compute(pfNode *terrain, float x, float y,
float phase);
pfCullProgram C++ API
int pfCullProgram::testPolytope(int index);
void pfCullProgram::addBinParent(int bin);
int pfCullProgram::isSubbinOf(int bin);
int pfCullProgram::testSmallerThan(float threshold);
void pfCullProgram::resetBinParents();
void pfCullProgram::resetCullProgram(int flags);
void pfCullProgram::setNumPolytopes(int i);
int pfCullProgram::getNumPolytopes();
void pfCullProgram::setPolytope(int index, pfPolytope *pol);
pfPolytope* pfCullProgram::getPolytope(int index);
void pfCullProgram::setFlags(int which, int value);
int pfCullProgram::getFlags(int which);
pfShadow C++ API
new pfShadow();
pfType* pfShadow::getClassType();
void pfShadow::setNumCasters(int index);
int pfShadow::getNumCasters();
void pfShadow::setShadowCaster(int index, pfNode *caster,
pfMatrix & mat);
void pfShadow::adjustCasterCenter(int index, pfVec3 & trans);
pfNode* pfShadow::getShadowCaster(int index);
pfMatrix* pfShadow::getShadowCasterMatrix(int index);
void pfShadow::setNumSources(int num);
int pfShadow::getNumSources();
void pfShadow::setSourcePos(int index, float x, float y, float z,
float w);
void pfShadow::getSourcePos(int index, float *x, float *y,
float *z, float *w);
void pfShadow::setLight(int index, pfLight *light);
pfLight* pfShadow::getLight(int index);
void pfShadow::setAmbientFactor(int light, float factor);
float pfShadow::getAmbientFactor(int light);
void pfShadow::setShadowTexture(int caster, int light,
pfTexture *tex);
pfTexture* pfShadow::getShadowTexture(int caster, int light);
void pfShadow::addChannel(pfChannel *channel);
void pfShadow::updateView();
void pfShadow::updateCaster(int index, pfMatrix & mat);
Page 34
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfShadow::apply();
void pfShadow::draw(pfChannel *chan);
void pfShadow::setFlags(int which, int value);
int pfShadow::getFlags(int which)const;
void pfShadow::setVal(int caster, int light, int which,
float val);
float pfShadow::getVal(int caster, int light, int which);
pfDirData* pfShadow::getDirData(int caster, int light);
pfDirData C++ API
new(void *arena)
pfDirData();
pfType* pfDirData::getClassType();
void pfDirData::setData(int num, pfVec3 *directions,
void **userData);
void pfDirData::getDirData(int *num, pfVec3 **directions,
void ***userData);
void pfDirData::setDirections(int num, pfVec3 *directions);
void pfDirData::generateDirections(int num, int type,
float *data);
void pfDirData::getDirections(int *num, pfVec3 **directions);
int pfDirData::getNumGroups(int *viewsPerGroup);
int pfDirData::getGroup(int group, int *views);
int pfDirData::getNeighboringViews(int viewIndex,
int **neighbors);
int pfDirData::getFlags(int which)const;
int pfDirData::findData(pfVec3 *dir, pfVec3 *resDir,
void **resData);
int pfDirData::findData2(pfVec3 *dir, pfVec3 *resDir,
void **resData, float *weight);
int pfDirData::findData3(pfVec3 *dir, pfVec3 *resDir,
void **resData, float *weight);
int pfDirData::findData4(pfVec3 *dir, pfVec3 *resDir,
void **resData, float *weight);
pfIBRtexture C++ API
new(void *arena)
pfIBRtexture();
pfType* pfIBRtexture::getClassType();
void pfIBRtexture::loadIBRTexture(char *format, int numTex,
int skipTex);
void pfIBRtexture::setIBRTexture(pfTexture **textures,
int numTex);
void pfIBRtexture::getIBRTextures(pfTexture ***textures,
int *numTex);
void pfIBRtexture::setIBRdirections(pfVec3 *directions,
int numDirs);
void pfIBRtexture::getIBRdirections(pfVec3 **directions,
int *numDirs);
int pfIBRtexture::getNumIBRTextures();
Page 35
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfDirData* pfIBRtexture::getDirData();
void pfIBRtexture::computeProxyTexCoords(pfIBRnode *node,
pfVec3 *center, float aspect, float scale,
pfVec2 *texShift);
pfTexture* pfIBRtexture::getDefaultTexture();
void pfIBRtexture::setFlags(int which, int value);
int pfIBRtexture::getFlags(int which)const;
void pfIBRtexture::setDirection(float dir);
float pfIBRtexture::getDirection()const;
pfLoadBalance C++ API
new pfLoadBalance(int size);
pfType* pfLoadBalance::getClassType();
void pfLoadBalance::setLoad(int index, float load);
float pfLoadBalance::getLoad(int index);
void pfLoadBalance::balance();
float pfLoadBalance::getWork(int index);
void pfLoadBalance::setActualWork(int index, float w);
void pfLoadBalance::setVal(int what, float val);
float pfLoadBalance::getVal(int what);
void pfLoadBalance::setNumActive(int num);
int pfLoadBalance::getNumActive();
pfCompositor C++ API
new pfCompositor( int netID );
pfType* pfCompositor::getClassType();
int pfCompositor::getNumHWCompositors();
int pfCompositor::getHWCompositorNetworkId(int c);
int pfCompositor::getHWCompositorNumInputs(int c);
int pfCompositor::getHWCompositorInputType(int c, int i);
char* pfCompositor::getHWCompositorInputPipeName(int c, int i);
int pfCompositor::getHWCompositorInputNetworkId(int c, int i);
pfCompositor* pfCompositor::getHWCompositorPfCompositor(int c);
int pfCompositor::getNumCompositedPipes();
int pfCompositor::getNumCompositors();
pfCompositor* pfCompositor::getCompositor(int i);
int pfCompositor::getNetworkId();
void pfCompositor::autoSetup(int num_inputs);
int pfCompositor::addChild(char* pipe_name);
int pfCompositor::addChild(pfCompositor *comp);
int pfCompositor::getNumChildren();
int pfCompositor::getChildType(int index);
pfCompositor* pfCompositor::getChildCompositor(int index);
pfPipe* pfCompositor::getChildPipe(int index);
char* pfCompositor::getChildPipeName(int index);
int pfCompositor::getChildPipeId(int index);
pfCompositor* pfCompositor::getParent();
int pfCompositor::getNumActiveChildren();
int pfCompositor::setNumActiveChildren(int n);
void pfCompositor::setViewport(float left, float right,
float bottom, float top);
Page 36
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfCompositor::getViewport(float *left, float *right,
float *bot, float *top);
void pfCompositor::setVal(int what, float val);
float pfCompositor::getVal(int what);
void pfCompositor::setMode(int what, int val);
int pfCompositor::getMode(int what);
void pfCompositor::setLoadBalancer(pfLoadBalance *balancer);
pfLoadBalance* pfCompositor::getLoadBalancer();
void pfCompositor::setChildViewport(int i, float left,
float right, float bot, float top);
void pfCompositor::getChildViewport(int i, float* l, float* r,
float* b, float* t);
void pfCompositor::resetChildrenViewports();
pfPipe* pfCompositor::getMasterPipe();
int pfCompositor::getMasterPipeId();
int pfCompositor::getNumPipes();
pfPipe* pfCompositor::getPipe(int p);
pfPipeWindow* pfCompositor::getPWin(int p);
pfChannel* pfCompositor::getChan(int p, int c);
pfCompositor* pfCompositor::getRoot();
void pfCompositor::setChannelClipped(int chan_num, int clip );
uchar pfCompositor::getChannelClipped(int chan_num);
int pfCompositor::setAntialiasJitter( int n, float* jitter );
int pfCompositor::getAntialiasJitter( int n, float* jitter );
uint pfCompositor::getDefaultChanShareMask();
void pfCompositor::setDefaultChanShareMask(uint mask);
pfCteChanData C++ API
new(void *arena)
pfCteChanData( pfChannel* chan );
pfType* pfCteChanData::getClassType();
pfDispListOptimizer C++ API
new(void *arena)
pfDispListOptimizer();
pfType* pfDispListOptimizer::getClassType();
void pfDispListOptimizer::setDispList(pfDispList *dlist);
void pfDispListOptimizer::reset();
int pfDispListOptimizer::advance();
void pfDispListOptimizer::setNumServers(int num);
int pfDispListOptimizer::getNumServers();
void pfDispListOptimizer::setMyId(int id);
int pfDispListOptimizer::getMyId();
void pfDispListOptimizer::setChannel(pfChannel *c);
pfChannel* pfDispListOptimizer::getChannel();
void pfDispListOptimizer::initModelviewMatrix(pfMatrix& M);
void pfDispListOptimizer::initProjectionMatrix(pfMatrix& M);
int pfDispListOptimizer::getNumGSetsProcessed();
void pfDispListOptimizer::setTimeSlice(float t);
float pfDispListOptimizer::getTimeSlice();
Page 37
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfDispListOptimizer::setOptimizationMask(uint m);
uint pfDispListOptimizer::getOptimizationMask();
int pfDispListOptimizer::getNumTrisRemoved();
int pfDispListOptimizer::getNumLinesRemoved();
int pfDispListOptimizer::getNumPointsRemoved();
int pfDispListOptimizer::getNumVertsRemoved();
void pfDispListOptimizer::setUserFunc(pfSidekickFunc func,
void *userFuncData);
pfSidekickFunc pfDispListOptimizer::getUserFunc();
void* pfDispListOptimizer::getUserFuncData();
void pfDispListOptimizer::setCullFace(int mode);
int pfDispListOptimizer::getCullFace();
void* pfDispListOptimizer::getTmpMemory(int size);
pfGeoSet* pfDispListOptimizer::getTmpGSet();
pfMatrix* pfDispListOptimizer::getMatrix(int which);
pfGeoSet* pfDispListOptimizer::cloneGSet(pfGeoSet *gset,
uint copyMask);
pfGeoSet* pfDispListOptimizer::optimize(pfGeoSet *gset);
pfMeshVertex C++ API
void pfMeshVertex::setCoord(pfVec3 *v);
pfVec3* pfMeshVertex::getCoord();
void pfMeshVertex::setCoordPtr(pfVec3 *v);
pfVec3* pfMeshVertex::getCoordPtr();
void pfMeshVertex::setNextVertex(int v);
int pfMeshVertex::getNextVertex();
void pfMeshVertex::setNumNeighbors(int n);
int pfMeshVertex::getNumNeighbors();
void pfMeshVertex::setNeighbor(int i, pfMeshVertexNeighbor *n);
pfMeshVertexNeighbor*
pfMeshVertex::getNeighbor(int i);
pfMeshVertexNeighbor*
pfMeshVertex::getPreviousNeighbor(int v1);
int pfMeshVertex::getPreviousNeighborIndex(int v1);
pfMeshVertexNeighbor*
pfMeshVertex::getNextNeighbor(int v1);
int pfMeshVertex::getNextNeighborIndex(int v1);
void pfMeshVertex::setFlags(int which, int value);
int pfMeshVertex::getFlags(int which);
pfMeshFace C++ API
void pfMeshFace::setPart(int p);
int pfMeshFace::getPart();
void pfMeshFace::setGState(pfGeoState *g);
pfGeoState* pfMeshFace::getGState();
void pfMeshFace::setNumVerts(int n);
int pfMeshFace::getNumVerts();
void pfMeshFace::setVertex(int i, int v);
int pfMeshFace::getVertex(int i);
void pfMeshFace::setTexCoord(int i, pfVec2 *v);
Page 38
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfVec2* pfMeshFace::getTexCoord(int i);
void pfMeshFace::setVerts(int *v, int n);
int pfMeshFace::getVerts(int *v, int size);
void pfMeshFace::setFlags(int which, int value);
int pfMeshFace::getFlags(int which);
pfMesh C++ API
new(void *arena)
pfMesh();
void pfMesh::setFlags(int which, int value);
int pfMesh::getFlags(int which);
void pfMesh::setVal(int which, float val);
void pfMesh::getVal(int which, float *val);
void pfMesh::setAttr(int which, void *attr);
void pfMesh::getAttr(int which, void **attr);
int pfMesh::getNumVertices();
void pfMesh::setNumVertices(int num);
pfMeshVertex* pfMesh::getVertex(int i);
pfVec3* pfMesh::getVertexCoords(int i);
int pfMesh::getEdgeType(int v, int v1);
int pfMesh::getNumFaces();
void pfMesh::setNumFaces(int num);
void pfMesh::addGeoSet(pfGeoSet *gset, int currentPart,
pfMatrix *xform);
int pfMesh::addTriangle(pfVec3 *v1, pfVec3 *v2, pfVec3 *v3,
pfMatrix *xform, int part, pfGeoState *gstate);
int pfMesh::addFace(pfVec3 **verts, int num, pfMatrix *xform,
int part, pfGeoState *gstate);
void pfMesh::getTriangle(int t, int *v1, int *v2, int *v3);
pfMeshFace* pfMesh::getFace(int t);
pfBox* pfMesh::getBBox();
void pfMesh::setBBox(pfBox *b);
pfSphere* pfMesh::getGridBsphere();
void pfMesh::setGridBsphere(pfSphere *b);
void pfMesh::splitVertex(int vbegin, int vend);
void pfMesh::splitVertices();
void pfMesh::updateMesh();
pfNode C++ API
A pfNode is an abstract type which cannot be explicitly created. The
pfNode routines operate on the common aspects of other IRIS Performer
node types which are derived from pfNode. IRIS Performer provides four
major traversals of the scene graph: ISECT, APP, CULL, and DRAW. These
functions (pfNode::setTrav*) can be used to set which nodes are
traversed, the functions to be invoked during the traversal, when the
traversal is initiated and what data is provided to the traversal.
pfType* pfNode::getClassType();
void pfNode::setTravMask(int which, uint mask, int setMode,
int bitOp);
Page 39
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfNode* pfNode::find(const char *name, pfType *type);
int pfNode::setName(const char *name);
const char* pfNode::getName()const;
void pfNode::setTravFuncs(int which, pfNodeTravFuncType pre,
pfNodeTravFuncType post);
void pfNode::getTravFuncs(int which, pfNodeTravFuncType *pre,
pfNodeTravFuncType *post)const;
void pfNode::setTravData(int which, void *data);
void* pfNode::getTravData(int which)const;
uint pfNode::getTravMask(int which)const;
void pfNode::setTravMode(int which, int mode, int val);
int pfNode::getTravMode(int which, int mode)const;
void pfNode::setBufferMode(int mode, int val);
int pfNode::getBufferMode(int mode)const;
pfGroup* pfNode::getParent(int i)const;
int pfNode::getNumParents()const;
void pfNode::setBound(pfSphere *sph, int mode);
int pfNode::getBound(pfSphere *sph);
pfNode* pfNode::lookup(const char *name, pfType* type);
int pfNode::isect(pfSegSet *segSet, pfHit **hits[]);
int pfNode::flatten(int mode);
pfNode* pfNode::clone(int mode);
pfNode* pfNode::bufferClone(int mode, pfBuffer *buf);
pfGroup C++ API
A pfGroup is the internal node type of the IRIS Performer hierarchy and
is derived from pfNode. The functions allow children to be added to and
deleted from a pfGroup node and queries to be made about a pfGroup node's
children.
new pfGroup();
pfType* pfGroup::getClassType();
int pfGroup::addChild(pfNode *child);
int pfGroup::insertChild(int index, pfNode *child);
int pfGroup::removeChild(pfNode *child);
int pfGroup::replaceChild(pfNode *oldn, pfNode *newn);
int pfGroup::bufferAddChild(pfNode *child);
int pfGroup::bufferRemoveChild(pfNode *child);
pfNode* pfGroup::getChild(int i)const;
int pfGroup::getNumChildren()const;
int pfGroup::searchChild(pfNode *n)const;
pfScene C++ API
A pfScene is the root of a hierarchical database which may be drawn or
intersected with. pfGeoStates can be attached to and removed from a
pfScene.
new pfScene();
pfType* pfScene::getClassType();
void pfScene::setGState(pfGeoState *gs);
Page 40
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfGeoState* pfScene::getGState()const;
void pfScene::setGStateIndex(int gs);
int pfScene::getGStateIndex()const;
pfSCS C++ API
These functions manipulate the matrix associated with a pfSCS node. A
pfSCS node represents a static coordinate system -- a modeling transform
that cannot be changed once created.
new pfSCS(pfMatrix& m);
pfType* pfSCS::getClassType();
void pfSCS::getMat(pfMatrix& m);
const pfMatrix*
pfSCS::getMatPtr();
pfDCS C++ API
These functions manipulate the matrix associated with a pfDCS node. A
pfDCS node represents a dynamic coordinate system -- a modeling transform
that can be changed after it is created.
new pfDCS();
pfType* pfDCS::getClassType();
void pfDCS::getMat(pfMatrix& m);
const pfMatrix*
pfDCS::getMatPtr();
void pfDCS::setMatType(uint val);
uint pfDCS::getMatType()const;
void pfDCS::setMat(pfMatrix& m);
void pfDCS::setCoord(pfCoord *c);
void pfDCS::setRot(float h, float p, float r);
void pfDCS::setTrans(float x, float y, float z);
void pfDCS::setScale(float s);
void pfDCS::setScale(float xs, float ys, float zs);
pfFCS C++ API
These functions manipulate a pfFCS node. A pfFCS is a Flux Coordinate
System node. The matrix of a pfFCS is contained in a pfFlux linked to
it. This allows the pfFCS to be animated using a pfEngine.
new pfFCS(pfFlux *flux);
pfType* pfFCS::getClassType();
void pfFCS::getMat(pfMatrix& m);
const pfMatrix*
pfFCS::getMatPtr();
void pfFCS::setMatType(uint val);
uint pfFCS::getMatType()const;
void pfFCS::setFlux(pfFlux *flux);
pfFlux* pfFCS::getFlux();
pfDoubleSCS C++ API
Page 41
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new pfDoubleSCS(pfMatrix4d& m);
pfType* pfDoubleSCS::getClassType();
void pfDoubleSCS::getMat(pfMatrix4d& m);
const pfMatrix4d*
pfDoubleSCS::getMatPtr();
pfDoubleDCS C++ API
new pfDoubleDCS();
pfType* pfDoubleDCS::getClassType();
void pfDoubleDCS::getMat(pfMatrix4d& m);
const pfMatrix4d*
pfDoubleDCS::getMatPtr();
void pfDoubleDCS::setMatType(uint val);
uint pfDoubleDCS::getMatType()const;
void pfDoubleDCS::setMat(pfMatrix4d& m);
void pfDoubleDCS::setCoordd(pfCoordd *c);
void pfDoubleDCS::setRot(double h, double p, double r);
void pfDoubleDCS::setTrans(double x, double y, double z);
void pfDoubleDCS::setScale(double s);
void pfDoubleDCS::setScale(double xs, double ys, double zs);
pfDoubleFCS C++ API
new pfDoubleFCS(pfFlux *flux);
pfType* pfDoubleFCS::getClassType();
void pfDoubleFCS::getMat(pfMatrix4d& m);
const pfMatrix4d*
pfDoubleFCS::getMatPtr();
void pfDoubleFCS::setMatType(uint val);
uint pfDoubleFCS::getMatType()const;
void pfDoubleFCS::setFlux(pfFlux *flux);
pfFlux* pfDoubleFCS::getFlux();
pfLODState C++ API
A pfLODState is a definition of how an LOD or group of LODs should
respond to range and stress. The functions form an interface to create
LOD states, set their attributes and give them names.
new pfLODState();
pfType* pfLODState::getClassType();
void pfLODState::setAttr(int attr, float val);
float pfLODState::getAttr(int attr);
int pfLODState::setName(const char *name);
const char* pfLODState::getName()const;
pfLODState* pfLODState::find(const char *findName);
pfLOD C++ API
Level-of-detail is a technique for manipulating model complexity based on
image quality and rendering speed. IRIS Performer uses range-based LOD
and adjusts for field-of-view and viewport pixel size. Each pfLOD node
has the different levels-of-detail as its children. The pfGroup API can
be used to manipulate this child list. A particular LOD is picked based
on a transition range. These transition ranges can be set by
Page 42
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfLOD::setRange and pfLOD::setTransition to ensure smooth transitions
between different LODs. A given pfLOD can also be associated with a
pfLODState.
new pfLOD();
pfType* pfLOD::getClassType();
void pfLOD::setCenter(pfVec3& c);
void pfLOD::getCenter(pfVec3& c)const;
void pfLOD::setRange(int index, float range);
int pfLOD::getNumRanges()const;
float pfLOD::getRange(int index)const;
void pfLOD::setTransition(int index, float delta);
int pfLOD::getNumTransitions()const;
float pfLOD::getTransition(int index)const;
void pfLOD::setLODState(pfLODState *ls);
pfLODState* pfLOD::getLODState()const;
void pfLOD::setLODStateIndex(int index);
int pfLOD::getLODStateIndex()const;
void pfLOD::setRangeFlux(int index, pfFlux *flux);
int pfLOD::getNumRangeFluxes()const;
pfFlux* pfLOD::getRangeFlux(int index)const;
void pfLOD::setUserEvalFunc(pfLODEvalFuncType evalFunc);
pfLODEvalFuncType
pfLOD::getUserEvalFunc();
float pfLOD::evaluate(const pfChannel *chan,
const pfMatrix *offset);
pfSwitch C++ API
The functions manipulate pfSwitch nodes which are interior nodes in the
IRIS Performer node hierarchy that select one, all, or none of their
children. The mode of selection is set by pfSwitch::setVal.
new pfSwitch();
pfType* pfSwitch::getClassType();
int pfSwitch::setVal(float val);
float pfSwitch::getVal()const;
int pfSwitch::setValFlux(pfFlux *valFlux);
pfFlux* pfSwitch::getValFlux()const;
pfMorph C++ API
A pfMorph node manipulates the geometric attributes of pfGeoSets and
other geometric primitives. Its primary use is for geometric morphing
where the colors, normals, texture coordinates and coordinates of
geometry are smoothly changed over time to simulate actions such as
facial and skeletal animation, ocean waves, morph level-of-detail, and
special effects. The attributes of a pfMorph node, the method of
accessing the source arrays of a pfMorph attribute (non-indexed or
indexed) and the weights attached to these attributes can be set and
queried by these functions.
Page 43
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new pfMorph();
pfType* pfMorph::getClassType();
int pfMorph::setAttr(int index, int attr, int nelts, void *dst,
int nsrcs, float *alist[], ushort *ilist[], int n[]);
int pfMorph::getNumAttrs()const;
int pfMorph::getSrc(int index, int src, float **alist,
ushort **ilist, int *n)const;
int pfMorph::getNumSrcs(int index)const;
void* pfMorph::getDst(int index)const;
int pfMorph::setWeights(int index, float *weights);
int pfMorph::getWeights(int index, float *weights)const;
void pfMorph::evaluate();
pfSequence C++ API
A pfSequence node is a pfGroup node that sequences through a range of its
children, drawing each child for a certain length of time. Children are
added to a pfSequence using normal pfGroup API. The length of time to
draw each child and the range of children to sequence through are set by
these functions.
new pfSequence();
pfType* pfSequence::getClassType();
void pfSequence::setDuration(float sp, int nRep);
void pfSequence::getDuration(float *sp, int *nRep)const;
void pfSequence::setInterval(int imode, int beg, int e);
void pfSequence::getInterval(int *imode, int *beg, int *e)const;
void pfSequence::setMode(int m);
int pfSequence::getMode()const;
void pfSequence::setTime(int index, double time);
double pfSequence::getTime(int index)const;
int pfSequence::getFrame(int *rep)const;
void pfSequence::setEvaluation(int state);
int pfSequence::getEvaluation();
pfLayer C++ API
A pfLayer is a node derived from pfGroup that supports proper drawing of
coplanar geometry on IRIS platforms so as to prevent distracting
artifacts caused by numerical precision when rendering coplanar geometry
on Z-buffer based machines. These functions create pfLayers and define
the base layer and the other (decal) layers.
new pfLayer();
pfType* pfLayer::getClassType();
void pfLayer::setBase(pfNode *n);
pfNode* pfLayer::getBase()const;
void pfLayer::setDecal(pfNode *n);
pfNode* pfLayer::getDecal()const;
void pfLayer::setMode(int mode);
int pfLayer::getMode()const;
void pfLayer::setPlane(pfPlane *plane);
Page 44
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfPlane* pfLayer::getPlane()const;
pfPartition C++ API
A pfPartition node is a type of pfGroup node which organizes the scene
graphs of its children into a static data structure which can be more
efficient for intersections. pfPartition::build constructs a spatial
partitioning based on the value of type. The other functions update a
partition and control the values of its attributes.
new pfPartition();
pfType* pfPartition::getClassType();
void pfPartition::setVal(int which, float val);
float pfPartition::getVal(int which);
void pfPartition::setAttr(int which, void *attr);
void* pfPartition::getAttr(int which);
void pfPartition::build();
void pfPartition::update();
pfLightPoint C++ API
A pfLightPoint is a pfNode that contains one or more light points. A
light point is visible as one or more self-illuminated small points but
does not illuminate surrounding objects. These functions form an
interface to create light points and control various light point
parameters like size, number, shape, direction, color, position and
intensity in a fog.
new pfLightPoint(int n);
pfType* pfLightPoint::getClassType();
int pfLightPoint::getNumPoints()const;
void pfLightPoint::setSize(float s);
float pfLightPoint::getSize()const;
void pfLightPoint::setFogScale(float onset, float opaque);
void pfLightPoint::getFogScale(float *onset, float *opaque)const;
void pfLightPoint::setRot(float azim, float elev, float roll);
void pfLightPoint::getRot(float *azim, float *elev,
float *roll)const;
void pfLightPoint::setShape(int dir, float he, float ve, float f);
void pfLightPoint::getShape(int *dir, float *he, float *ve,
float *f)const;
pfGeoSet* pfLightPoint::getGSet()const;
void pfLightPoint::setPos(int i, pfVec3& p);
void pfLightPoint::getPos(int i, pfVec3& p)const;
void pfLightPoint::setColor(int i, pfVec4& clr);
void pfLightPoint::getColor(int i, pfVec4& clr)const;
pfLightSource C++ API
A pfLightSource is a pfNode which can illuminate geometry in a pfScene.
The pfLightSource routines create pfLightSources, set them off and on and
control various other properties
Page 45
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new pfLightSource();
pfType* pfLightSource::getClassType();
void pfLightSource::setColor(int which, float r, float g, float b);
void pfLightSource::getColor(int which, float* r, float* g,
float* b);
void pfLightSource::setAmbient(float r, float g, float b);
void pfLightSource::getAmbient(float* r, float* g, float* b);
void pfLightSource::setPos(float x, float y, float z, float w);
void pfLightSource::getPos(float* x, float* y, float* z, float* w);
void pfLightSource::setAtten(float a0, float a1, float a2);
void pfLightSource::getAtten(float* a0, float* a1, float* a2);
void pfLightSource::setSpotCutoffDelta(float f1);
float pfLightSource::getSpotCutoffDelta();
void pfLightSource::setSpotDir(float x, float y, float z);
void pfLightSource::getSpotDir(float* x, float* y, float* z);
void pfLightSource::setSpotCone(float f1, float f2);
void pfLightSource::getSpotCone(float* f1, float* f2);
void pfLightSource::on();
void pfLightSource::off();
int pfLightSource::isOn();
void pfLightSource::setMode(int mode, int val);
int pfLightSource::getMode(int mode)const;
void pfLightSource::setVal(int mode, float val);
float pfLightSource::getVal(int mode)const;
void pfLightSource::setAttr(int attr, void *obj);
void* pfLightSource::getAttr(int attr)const;
pfGeode C++ API
A pfGeode is a leaf node in the IRIS Performer scene graph hierarchy. It
is a list of pfGeoSets which it draws and intersects with. Functions are
provided to creates pfGeode and manipulate the list of pfGeoStates
attached to them.
new pfGeode();
pfType* pfGeode::getClassType();
int pfGeode::addGSet(pfGeoSet *gset);
int pfGeode::insertGSet(int index, pfGeoSet *gset);
int pfGeode::replaceGSet(pfGeoSet *oldgs, pfGeoSet *newgs);
int pfGeode::removeGSet(pfGeoSet *gset);
int pfGeode::countShadedGSets();
pfGeoSet* pfGeode::getGSet(int i)const;
int pfGeode::getNumGSets()const;
pfASD C++ API
pfASD is a pfNode which provides multiprocessed evaluation of very large
terrain with multi-resolution LODs in a pfScene. It supports
multichannel and multipipe. pfASD can be associated with multiple
geostates.
new pfASD();
Page 46
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfType* pfASD::getClassType();
void pfASD::setAttr(int which, int type, int size, void *attr);
void pfASD::getAttr(int which, int *type, int *size,
void **attr);
void pfASD::setMorphAttrs(int mc);
int pfASD::getMorphAttrs();
void pfASD::getActiveGeom(pfChannel *chan, pfList *geom);
void pfASD::setNumBaseFaces(int num);
int pfASD::getNumBaseFaces();
void pfASD::setGStates(pfGeoState **gs, int num);
void pfASD::getGStates(pfGeoState ***gs, int *num);
pfGeoState* pfASD::getGState(int num);
int pfASD::getNumGStates();
void pfASD::setSyncGroup(uint syncGroup);
uint pfASD::getSyncGroup();
void pfASD::enableClipRings();
void pfASD::setNumClipRings(int numrings);
void pfASD::setClipRings(float *rings);
float* pfASD::getClipRings();
int pfASD::getNumClipRings();
void pfASD::setFaceBBoxes(pfBox *box);
pfBox* pfASD::getFaceBBoxes();
void pfASD::setFaceBBox(pfBox *facebbox, int faceid);
void pfASD::getFaceBBox(pfBox *facebbox, int faceid);
void pfASD::setBBox(pfBox *box);
void pfASD::getBBox(pfBox *box);
void pfASD::config();
void pfASD::setMaxMorphDepth(int m,
float _morphweightconstraint);
void pfASD::getMaxMorphDepth(int *m,
float *_morphweightconstraint);
void pfASD::setLODState(pfLODState *ls);
pfLODState* pfASD::getLODState();
void pfASD::setLODStateIndex(int lsi);
int pfASD::getLODStateIndex();
void pfASD::setEvalMethod(int method);
int pfASD::getEvalMethod();
void pfASD::setEvalFunc(pfASDEvalFuncType eval);
pfASDEvalFuncType
pfASD::getEvalFunc();
void pfASD::setMask(uint which, uint mask, int id);
void pfASD::setCullEnlarge(float fov, float nearPlane,
float farPlane);
void pfASD::setMorphWeight(int vertid, float morphweight);
void pfASD::unsetMorphWeight(int vertid);
void pfASD::initMask(uint which);
void pfASD::clearAllMasks(uint which);
void -
pfASD::setCalcVirtualClipTexParamsFunc(pfASDCalcVirtualClipTexParamsFuncType func);
pfASDCalcVirtualClipTexParamsFuncType
pfASD::getCalcVirtualClipTexParamsFunc();
Page 47
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfASD::isPaging();
int pfASD::isPageMaster();
void pfASD::initPaging();
void pfASD::setTileSize(float **tsize);
float** pfASD::getTileSize();
void pfASD::setPageSize(short **page);
short** pfASD::getPageSize();
void pfASD::setTotalTiles(short **tilenum);
short** pfASD::getTotalTiles();
void pfASD::setMaxTileMemSize(int tilefaces, int tileverts);
void pfASD::getMaxTileMemSize(int *tilefaces, int *tileverts);
void pfASD::setOrigin(pfVec3 *min);
pfVec3* pfASD::getOrigin();
void pfASD::setPageFname(char *fname);
char* pfASD::getPageFname();
void pfASD::overrideViewingParams(pfChannel *chan,
pfMatrix& M);
int pfASD::addQueryArray(float *vertices, float *down,
int nofVertices, uint mask, pfFlux *results);
void pfASD::deleteQueryArray(int index);
void pfASD::setQueryArrayElement(int arrayIndex,
int elementIndex, float *vertex, float *down);
uint pfASD::containsQueryArray(float *vertices, float *down,
int nofVertices);
void pfASD::deleteQueryGeoSet(int index);
int pfASD::addQueryGeoSet(pfGeoSet *gset, float *down,
uint mask, pfFlux *results);
void pfASD::replaceQueryGeoSet(int index, pfGeoSet *gset,
float *down);
void pfASD::projectPointFinestPositionNormal(float *base,
float *down, uint flags, float *base_pos,
float *base_normal);
void pfASD::projectPointFinestPosition(float *base,
float *down, uint flags, float *base_pos);
void pfASD::getQueryArrayPositionSpan(int index, pfBox *box);
pfText C++ API
A pfText node is a list of pfStrings much as a pfGeode is a list of
pfGeoSets. The two APIs are also similar - a new pfText node can be
created and the list of pfStrings attached to it can be manipulated by
addition, insertion, removal or replacement.
new pfText();
pfType* pfText::getClassType();
int pfText::addString(pfString *str);
int pfText::insertString(int index, pfString *str);
int pfText::replaceString(pfString *oldgs, pfString *newgs);
int pfText::removeString(pfString *str);
pfString* pfText::getString(int i)const;
int pfText::getNumStrings()const;
Page 48
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfBillboard C++ API
A pfBillboard is a pfGeode in which each pfGeoSet rotates to follow the
eyepoint. Billboards are useful for representing complex objects which
are roughly symmetrical about one or more axes. A pfBillboard can
contain any number of pfGeoSets which can be added to and removed from
the pfBillboard using pfGeode API. Further, the position, mode and axis
of rotation of a pfBillboard can also be manipulated.
new pfBillboard();
pfType* pfBillboard::getClassType();
void pfBillboard::setAxis(const pfVec3& axis);
void pfBillboard::getAxis(pfVec3& axis);
void pfBillboard::setMode(int mode, int val);
int pfBillboard::getMode(int mode);
void pfBillboard::setPos(int i, const pfVec3& pos);
void pfBillboard::getPos(int i, pfVec3& pos);
void pfBillboard::setPosFlux(pfFlux *flux);
pfFlux* pfBillboard::getPosFlux();
pfIBRnode C++ API
new pfIBRnode();
pfType* pfIBRnode::getClassType();
void pfIBRnode::setIBRtexture(pfIBRtexture *tex);
pfIBRtexture* pfIBRnode::getIBRtexture();
void pfIBRnode::setAngles(int i, float horAngle,
float verAngle);
void pfIBRnode::getAngles(int i, float *horAngle,
float *verAngle);
int pfIBRnode::getNumAngles();
void pfIBRnode::setProxyTexCoords(pfVec2 ***texCoords);
pfVec2*** pfIBRnode::getProxyTexCoords();
void pfIBRnode::setFlags(int which, int value);
int pfIBRnode::getFlags(int which)const;
pfSubdivSurface C++ API
new(void *arena)
pfSubdivSurface();
void pfSubdivSurface::setFlags(int which, int value);
int pfSubdivSurface::getFlags(int which);
void pfSubdivSurface::setVal(int which, float val);
void pfSubdivSurface::getVal(int which, float *val);
void pfSubdivSurface::setMesh(pfMesh *mesh);
pfMesh* pfSubdivSurface::getMesh();
void pfSubdivSurface::updateControlMesh();
pfType* pfSubdivSurface::getClassType();
void pfSubdivSurface::draw();
pfRep C++ API
pfType* pfRep::getClassType();
void pfRep::setOrigin( const pfRVec3& org);
Page 49
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfRep::setOrient( const pfRMatrix& mat);
void pfRep::getOrigin( pfRVec3& org)const;
void pfRep::getOrient( pfRMatrix& mat)const;
pfCurve2d C++ API
pfType* pfCurve2d::getClassType();
void pfCurve2d::setBeginT(const pfReal beginT);
void pfCurve2d::setEndT(const pfReal endT);
pfReal pfCurve2d::getBeginT()const;
pfReal pfCurve2d::getEndT()const;
void pfCurve2d::setClosed(const pfLoop loopVal);
pfLoop pfCurve2d::getClosed();
void pfCurve2d::setClosedTol(const pfReal tol);
pfReal pfCurve2d::getClosedTol()const;
void pfCurve2d::evalPt(pfReal t, pfRVec2 & pnt);
void pfCurve2d::evalTan(pfReal t, pfRVec2 & tan);
void pfCurve2d::evalNorm(pfReal t, pfRVec2 & norm);
void pfCurve2d::evalCurv(pfReal t, pfReal* curv);
void pfCurve2d::eval(pfReal t, pfRVec2 & pnt, pfRVec2 & tan,
pfReal *curv, pfRVec2 & norm);
pfDisCurve2d C++ API
new pfDisCurve2d();
pfType* pfDisCurve2d::getClassType();
void pfDisCurve2d::set(int nPoints, pfReal *points);
pfLoop pfDisCurve2d::getClosed();
void pfDisCurve2d::setClosed(pfLoop c);
void pfDisCurve2d::setPoint(int i, const pfRVec2& pnt);
int pfDisCurve2d::getPointCount();
pfReal pfDisCurve2d::getCurvature(int i)const;
pfRVec2* pfDisCurve2d::getPointByAddr(int i);
void pfDisCurve2d::computeTangents();
void pfDisCurve2d::computeNormals();
void pfDisCurve2d::computeCurvatures();
void pfDisCurve2d::computeDerivatives();
pfCurve3d C++ API
pfType* pfCurve3d::getClassType();
void pfCurve3d::setBeginT(pfReal beginT);
void pfCurve3d::setEndT(pfReal endT);
pfReal pfCurve3d::getBeginT();
pfReal pfCurve3d::getEndT();
void pfCurve3d::getBeginPt(pfRVec3& retVal);
void pfCurve3d::getEndPt(pfRVec3& retVal);
void pfCurve3d::getBeginTan(pfRVec3& retVal);
void pfCurve3d::getEndTan(pfRVec3& retVal);
void pfCurve3d::setClosed(pfLoop loopVal);
pfLoop pfCurve3d::getClosed();
void pfCurve3d::setClosedTol(pfReal tol);
pfReal pfCurve3d::getClosedTol();
Page 50
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfCurve3d::evalPt(pfReal t, pfRVec3 & pnt);
void pfCurve3d::evalTan(pfReal t, pfRVec3 & tan);
void pfCurve3d::evalNorm(pfReal t, pfRVec3 & norm);
void pfCurve3d::evalCurv(pfReal t, pfReal *curv);
void pfCurve3d::eval(pfReal t, pfRVec3 & pnt, pfRVec3 & tan,
pfReal *curv, pfRVec3& norm);
void pfCurve3d::tessellate(pfTessellateAction *action,
pfBool scaleTolByCurvature, pfReal chordalDevTol,
int samples);
pfDisCurve3d C++ API
new pfDisCurve3d();
new pfDisCurve3d(int nPoints, pfReal *points);
pfType* pfDisCurve3d::getClassType();
void pfDisCurve3d::set(int nPoints, pfReal *points);
pfLoop pfDisCurve3d::getClosed();
void pfDisCurve3d::setClosed(pfLoop c);
void pfDisCurve3d::setPoint(int i, const pfRVec3& pnt);
int pfDisCurve3d::getPointCount();
const pfRVec3* pfDisCurve3d::getPointAddr(int i);
const pfRVec3* pfDisCurve3d::getTangentAddr(int i);
const pfRVec3* pfDisCurve3d::getNormalAddr(int i);
pfReal pfDisCurve3d::getCurvature(int i);
void pfDisCurve3d::computeTangents();
void pfDisCurve3d::computeNormals();
void pfDisCurve3d::computeCurvatures();
void pfDisCurve3d::computeDerivatives();
pfCompositeCurve3d C++ API
new pfCompositeCurve3d();
new pfCompositeCurve3d(pfParaSurface *sur, pfCurve2d *cur);
pfType* pfCompositeCurve3d::getClassType();
void pfCompositeCurve3d::set(pfParaSurface *sur,
pfCurve2d *cur);
pfParaSurface* pfCompositeCurve3d::getParaSurface()const;
pfCurve2d* pfCompositeCurve3d::getCurve2d()const;
void pfCompositeCurve3d::evalPt(pfReal t, pfRVec3 & pnt);
pfParaSurface C++ API
void pfParaSurface::setBeginU( pfReal u);
void pfParaSurface::setEndU( pfReal u);
void pfParaSurface::setBeginV( pfReal v);
void pfParaSurface::setEndV( pfReal v);
void pfParaSurface::setSolidId( int solidId);
void pfParaSurface::setTopoId( int topoId);
void pfParaSurface::setSurfaceId( int surfaceId);
pfReal pfParaSurface::getBeginU()const;
pfReal pfParaSurface::getEndU()const;
pfReal pfParaSurface::getBeginV()const;
pfReal pfParaSurface::getEndV()const;
Page 51
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfParaSurface::getTrimLoopCount();
pfLoop pfParaSurface::getTrimLoopClosed(int loopNum);
int pfParaSurface::getTrimCurveCount(int loopNum);
pfEdge* pfParaSurface::getTrimCurve( int loopNum, int curveNum);
pfTopo* pfParaSurface::getTopo();
int pfParaSurface::getTopoId();
int pfParaSurface::getSolidId()const;
int pfParaSurface::getSurfaceId();
void pfParaSurface::setHandednessHint(pfBool clockWise);
pfBool pfParaSurface::getHandednessHint()const;
void pfParaSurface::insertTrimCurve( int loopNum, pfCurve2d *c,
pfDisCurve2d *d);
void pfParaSurface::addTrimCurve( int loopNum, pfCurve2d *c,
pfDisCurve2d *d);
void pfParaSurface::setTrimLoopClosed( int loopNum,
pfLoop closed);
void pfParaSurface::evalPt( pfReal u, pfReal v, pfRVec3 & pnt);
void pfParaSurface::evalDu( pfReal u, pfReal v, pfRVec3 & Du);
void pfParaSurface::evalDv( pfReal u, pfReal v, pfRVec3 & Dv);
void pfParaSurface::evalDuu( pfReal u, pfReal v, pfRVec3 & Duu);
void pfParaSurface::evalDvv( pfReal u, pfReal v, pfRVec3 & Dvv);
void pfParaSurface::evalDuv( pfReal u, pfReal v, pfRVec3 & Duv);
void pfParaSurface::evalNorm( pfReal u, pfReal v,
pfRVec3 & norm);
void pfParaSurface::evalD( pfReal u, pfReal v, pfReal theta,
pfRVec3 & D);
void pfParaSurface::evalDD( pfReal u, pfReal v, pfReal theta,
pfRVec3 & DD);
int pfParaSurface::setGState(pfGeoState *gState);
pfGeoState* pfParaSurface::getGState()const;
void pfParaSurface::clearTessellation();
if xyz is pfParaSurface::unref();
void pfParaSurface::copyBackShadowTrimCurve();
pfType* pfParaSurface::getClassType();
pfNurbSurface C++ API
new pfNurbSurface();
pfType* pfNurbSurface::getClassType();
void pfNurbSurface::setControlHull(int iu, int iv,
const pfRVec3& p);
void pfNurbSurface::setControlHull(int iu, int iv,
const pfRVec4& p);
void pfNurbSurface::setWeight(int iu, int iv, pfReal w);
void pfNurbSurface::setUknot(int iu, pfReal u);
void pfNurbSurface::setVknot(int iv, pfReal v);
void pfNurbSurface::setControlHullUSize(int s);
void pfNurbSurface::setControlHullVSize(int s);
const pfRVec3* pfNurbSurface::getControlHull(int iu, int iv);
int pfNurbSurface::getControlHullUSize();
int pfNurbSurface::getControlHullVSize();
Page 52
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfReal pfNurbSurface::getWeight(int iu, int iv);
pfReal pfNurbSurface::getUknot(int iu);
pfReal pfNurbSurface::getVknot(int iv);
int pfNurbSurface::getUknotCount();
int pfNurbSurface::getVknotCount();
int pfNurbSurface::getUorder();
int pfNurbSurface::getVorder();
void pfNurbSurface::removeControlHullElm(int iu, int iv);
void pfNurbSurface::removeUknot(int iu);
void pfNurbSurface::removeVknot(int iv);
void pfNurbSurface::flipUV();
void pfNurbSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
void pfNurbSurface::evalDu(pfReal u, pfReal v, pfRVec3 & Du);
void pfNurbSurface::evalDv(pfReal u, pfReal v, pfRVec3 & Du);
void pfNurbSurface::evalNorm(pfReal u, pfReal v,
pfRVec3 & norm);
pfLine2d C++ API
new pfLine2d();
new pfLine2d(pfReal x1, pfReal y1, pfReal t1, pfReal x2, pfReal y2,
pfReal t2);
pfType* pfLine2d::getClassType();
void pfLine2d::setPoint1( pfReal x1, pfReal y1, pfReal t1);
void pfLine2d::setPoint2( pfReal x2, pfReal y2, pfReal t2);
void pfLine2d::getPoint1( pfReal *x1, pfReal *y1, pfReal *t1)const;
void pfLine2d::getPoint2( pfReal *x2, pfReal *y2, pfReal *t2)const;
void pfLine2d::evalPt(pfReal t, pfRVec2 & pnt);
pfCircle2d C++ API
new pfCircle2d();
new pfCircle2d(pfReal radius, pfRVec2 *org);
pfType* pfCircle2d::getClassType();
void pfCircle2d::setRadius(pfReal radius);
pfReal pfCircle2d::getRadius()const;
void pfCircle2d::evalPt(pfReal t, pfRVec2 & pnt);
void pfCircle2d::evalTan(pfReal t, pfRVec2 & tan);
void pfCircle2d::evalCurv(pfReal t, pfReal* curv);
void pfCircle2d::evalNorm(pfReal t, pfRVec2 & norm);
void pfCircle2d::eval(pfReal t, pfRVec2 & pnt, pfRVec2 & tan,
pfReal* curv, pfRVec2& norm);
pfPieceWisePolyCurve2d C++ API
new pfPieceWisePolyCurve2d();
pfType* pfPieceWisePolyCurve2d::getClassType();
void pfPieceWisePolyCurve2d::setControlHull(int piece, int i,
const pfRVec2& p);
pfRVec2* pfPieceWisePolyCurve2d::getControlHullByAddr(int piece,
int i);
void pfPieceWisePolyCurve2d::setLimitParas(int piece, pfReal w1,
pfReal w2);
Page 53
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfPieceWisePolyCurve2d::setReverse(int reverse);
pfRVec2* pfPieceWisePolyCurve2d::getLimitParasByAddr(int piece);
int pfPieceWisePolyCurve2d::getReverse()const;
int pfPieceWisePolyCurve2d::getPatchCount()const;
int pfPieceWisePolyCurve2d::getOrder(int piece);
void pfPieceWisePolyCurve2d::evalPt(pfReal t, pfRVec2& pnt);
void pfPieceWisePolyCurve2d::evalBreakPoints(pfParaSurface *sur);
pfLine3d C++ API
new pfLine3d();
new pfLine3d(pfReal x1, pfReal y1, pfReal z1, pfReal t1, pfReal x2,
pfReal y2, pfReal z2, pfReal t2);
pfType* pfLine3d::getClassType();
void pfLine3d::setPoint1(pfReal x1, pfReal y1, pfReal z1,
pfReal t1);
void pfLine3d::setPoint2(pfReal x2, pfReal y2, pfReal z2,
pfReal t2);
void pfLine3d::getPoint1(pfReal *x1, pfReal *y1, pfReal *z1,
pfReal *t1)const;
void pfLine3d::getPoint2(pfReal *x2, pfReal *y2, pfReal *z2,
pfReal *t2)const;
void pfLine3d::evalPt(pfReal t, pfRVec3 & pnt);
pfNurbCurve2d C++ API
new pfNurbCurve2d();
new pfNurbCurve2d(pfReal tBegin, pfReal tEnd);
pfType* pfNurbCurve2d::getClassType();
void pfNurbCurve2d::setControlHull(int i, const pfRVec3 & p);
void pfNurbCurve2d::setWeight(int i, pfReal w);
void pfNurbCurve2d::setKnot(int i, pfReal t);
void pfNurbCurve2d::setControlHullSize(int s);
pfRVec2* pfNurbCurve2d::getControlHull(int i);
pfReal pfNurbCurve2d::getWeight(int i);
int pfNurbCurve2d::getControlHullSize();
int pfNurbCurve2d::getKnotCount();
pfReal pfNurbCurve2d::getKnot(int i);
int pfNurbCurve2d::getOrder();
void pfNurbCurve2d::removeControlHullPnt(int i);
void pfNurbCurve2d::removeKnot(int i);
void pfNurbCurve2d::evalPt(pfReal t, pfRVec2 & pnt);
void pfNurbCurve2d::setControlHull(int i, const pfRVec2 & p);
pfNurbCurve3d C++ API
new pfNurbCurve3d();
new pfNurbCurve3d(pfReal tBegin, pfReal tEnd);
pfType* pfNurbCurve3d::getClassType();
void pfNurbCurve3d::setControlHull(int i, const pfRVec3 & p);
void pfNurbCurve3d::setControlHull(int i, const pfRVec4 & p);
void pfNurbCurve3d::setWeight(int i, pfReal w);
void pfNurbCurve3d::setKnot(int i, pfReal t);
Page 54
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfNurbCurve3d::setControlHullSize(int s);
pfRVec3* pfNurbCurve3d::getControlHull(int i);
pfReal pfNurbCurve3d::getWeight(int i);
int pfNurbCurve3d::getControlHullSize();
int pfNurbCurve3d::getKnotCount()const;
pfReal pfNurbCurve3d::getKnot(int i);
pfReal pfNurbCurve3d::getOrder()const;
void pfNurbCurve3d::removeControlHullPnt(int i);
void pfNurbCurve3d::removeKnot(int i);
void pfNurbCurve3d::evalPt(pfReal u, pfRVec3 & pnt);
pfEdge C++ API
new(void *arena)
pfEdge();
pfType* pfEdge::getClassType();
pfCurve2d* pfEdge::getContCurve()const;
void pfEdge::setContCurve(pfCurve2d *c);
pfDisCurve2d* pfEdge::getDisCurve()const;
void pfEdge::setDisCurve( pfDisCurve2d *d);
int pfEdge::getBoundary()const;
void pfEdge::setBoundary( int boundaryId);
void pfEdge::setBoundaryDir( int dir );
int pfEdge::getBoundaryDir()const;
pfBoundary C++ API
new(void *arena)
pfBoundary( );
void pfBoundary::addEdge( int i, pfParaSurface *sur,
int trimLoop, int trimCurve );
int pfBoundary::getSurface( int i )const;
void pfBoundary::setSurface( int i, int surfaceId);
int pfBoundary::getLoop( int i )const;
void pfBoundary::setLoop( int i, int loopNum );
void pfBoundary::setTrimCurve( int i , int curveNum);
int pfBoundary::getTrimCurve(int i)const;
int pfBoundary::getWingCount()const;
int pfBoundary::getBoundaryId()const;
void pfBoundary::setBoundaryId( int boundaryId );
pfType* pfBoundary::getClassType();
pfJunction C++ API
new(void *arena)
pfJunction( );
pfType* pfJunction::getClassType();
void pfJunction::addEndPt( int i, pfParaSurface *sur,
int trimLoop, int trimCurve, int which );
int pfJunction::getSpokeCount();
int pfJunction::getSurface( int i );
int pfJunction::getLoop( int i );
int pfJunction::getTrimCurve( int i );
Page 55
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfJunction::getWhichEndPt( int i );
pfTessellateAction C++ API
pfType* pfTessellateAction::getClassType();
int pfTessellateAction::getTriangleCount()const;
int pfTessellateAction::getTriStripCount()const;
int pfTessellateAction::getTriFanCount()const;
void pfTessellateAction::setReverseTrimLoop( const pfBool enable );
pfBool pfTessellateAction::getReverseTrimLoop()const;
void -
pfTessellateAction::setBuildTopoWhileTess(const pfBool buildTopoWhileTess);
pfBool pfTessellateAction::getBuildTopoWhileTess()const;
void pfTessellateAction::setTopo(pfTopo * topo);
pfTopo* pfTessellateAction::getTopo()const;
pfTessParaSurfaceAction C++ API
new(void *arena)
pfTessParaSurfaceAction();
void -
pfTessParaSurfaceAction::setChordalDevTol(const pfReal chordalDevTol);
pfReal pfTessParaSurfaceAction::getChordalDevTol();
void -
pfTessParaSurfaceAction::setScaleTolByCurvature(const pfReal scaleTolByCurvature);
pfBool pfTessParaSurfaceAction::getScaleTolByCurvature( );
void pfTessParaSurfaceAction::setSampling(const int samples);
int pfTessParaSurfaceAction::getSampling( );
void -
pfTessParaSurfaceAction::setNonUniformSampling(const pfBool uniformSamplingFlag);
pfBool pfTessParaSurfaceAction::getNonUniformSampling();
void -
pfTessParaSurfaceAction::setGenUVCoordinates(const pfBool genUVCoordinates);
pfBool pfTessParaSurfaceAction::getGenUVCoordinates();
void pfTessParaSurfaceAction::setGenGeoArrays(pfBool enable);
pfBool pfTessParaSurfaceAction::getGenGeoArrays()const;
void -
pfTessParaSurfaceAction::tessellate(pfTessParaSurfaceAction *action,
pfObject *object);
void pfTessParaSurfaceAction::tessellator(pfParaSurface *sur);
pfPieceWisePolySurface C++ API
new pfPieceWisePolySurface();
pfType* pfPieceWisePolySurface::getClassType();
void pfPieceWisePolySurface::setControlHull(int patchu, int patchv,
int iu, int iv, const pfRVec3* p);
pfRVec3* pfPieceWisePolySurface::getControlHull(int patchu, int patchv,
int iu, int iv);
int pfPieceWisePolySurface::getUpatchCount();
int pfPieceWisePolySurface::getVpatchCount();
int pfPieceWisePolySurface::getUorder(int patchu, int patchv);
int pfPieceWisePolySurface::getVorder(int patchu, int patchv);
Page 56
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfTopo C++ API
new(void *arena)
pfTopo();
pfType* pfTopo::getClassType();
void pfTopo::setDistanceTol( pfReal tol, pfLengthUnits u );
pfReal pfTopo::getDistanceTol( )const;
pfLengthUnits pfTopo::getLengthUnits()const;
void pfTopo::setSurface( int i, pfParaSurface *sur );
pfParaSurface* pfTopo::getSurface( int i );
int pfTopo::getSurfaceCount( );
pfBoundary* pfTopo::getBoundary( int i );
int pfTopo::getBoundaryCount( );
int pfTopo::getSolidCount();
pfSolid* pfTopo::getSolid( int i );
int pfTopo::addSolid(pfSolid *solid);
int pfTopo::getTopoId();
pfBool pfTopo::addSurface( pfParaSurface *sur );
int pfTopo::addBoundary( pfBoundary *bnd );
void pfTopo::buildTopology();
int pfTopo::buildSolids();
pfTopo* pfTopo::getGlobalTopo(int n);
int pfTopo::getNumTopos();
int pfTopo::getBeginRange()const;
int pfTopo::getEndRange()const;
void pfTopo::buildTopologyCurSur(pfParaSurface *currentSur);
pfScalar C++ API
pfType* pfScalar::getClassType();
pfReal pfScalar::eval(pfReal u);
pfCompositeScalar C++ API
new(void *arena)
pfCompositeScalar( );
pfScalar* pfCompositeScalar::getOutF()const;
pfScalar* pfCompositeScalar::getInF()const;
void pfCompositeScalar::setOutF(pfScalar *outF);
void pfCompositeScalar::setInF(pfScalar *inF);
pfReal pfCompositeScalar::eval(pfReal u);
pfType* pfCompositeScalar::getClassType();
pfCosScalar C++ API
new(void *arena)
pfCosScalar( );
pfReal pfCosScalar::eval(pfReal u);
pfType* pfCosScalar::getClassType();
pfSinScalar C++ API
new(void *arena)
pfSinScalar( );
pfReal pfSinScalar::eval(pfReal u);
Page 57
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfType* pfSinScalar::getClassType();
pfPolyScalar C++ API
new(void *arena)
pfPolyScalar();
void pfPolyScalar::set(int degree, pfReal* coef);
int pfPolyScalar::getDegree()const;
pfReal pfPolyScalar::getCoef(int i);
pfReal pfPolyScalar::eval(pfReal u);
pfType* pfPolyScalar::getClassType();
pfSolid C++ API
new(void *arena)
pfSolid();
pfType* pfSolid::getClassType();
void pfSolid::addSurface( pfParaSurface* sur );
pfParaSurface* pfSolid::getSurface( int i);
int pfSolid::getSurfaceCount( );
void pfSolid::setSolidId(int solidId);
int pfSolid::getSolidId();
pfTorusSurface C++ API
new pfTorusSurface();
new pfTorusSurface(pfReal majorRadius, pfReal minorRadius);
pfType* pfTorusSurface::getClassType();
void pfTorusSurface::setMajorRadius(pfReal majorRadiusVal);
void pfTorusSurface::setMinorRadius(pfReal minorRadiusVal);
pfReal pfTorusSurface::getMajorRadius( )const;
pfReal pfTorusSurface::getMinorRadius( )const;
void pfTorusSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
void pfTorusSurface::evalNorm(pfReal u, pfReal v, pfRVec3 & norm);
pfCoonsSurface C++ API
new pfCoonsSurface();
new pfCoonsSurface(pfCurve3d *right, pfCurve3d *left,
pfCurve3d *bottom, pfCurve3d *top);
pfType* pfCoonsSurface::getClassType();
void pfCoonsSurface::setRight(pfCurve3d *right);
void pfCoonsSurface::setLeft(pfCurve3d *left);
void pfCoonsSurface::setBottom(pfCurve3d *bottom);
void pfCoonsSurface::setTop(pfCurve3d *top);
pfCurve3d* pfCoonsSurface::getTop()const;
pfCurve3d* pfCoonsSurface::getBottom()const;
pfCurve3d* pfCoonsSurface::getLeft()const;
pfCurve3d* pfCoonsSurface::getRight()const;
void pfCoonsSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
pfSweptSurface C++ API
new pfSweptSurface();
pfType* pfSweptSurface::getClassType();
Page 58
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfSweptSurface::setCrossSection(pfCurve3d *crossSection);
void pfSweptSurface::setPath(pfCurve3d *path);
void pfSweptSurface::setT(pfCurve3d *tng);
void pfSweptSurface::setB(pfCurve3d *b);
pfCurve3d* pfSweptSurface::getCrossSection()const;
pfCurve3d* pfSweptSurface::getPath()const;
pfCurve3d* pfSweptSurface::getT()const;
pfCurve3d* pfSweptSurface::getB()const;
pfScalar* pfSweptSurface::getProf()const;
pfFrenetSweptSurface C++ API
new pfFrenetSweptSurface();
new pfFrenetSweptSurface(pfCurve3d *crossSection, pfCurve3d *path,
pfScalar *profile);
void pfFrenetSweptSurface::set(pfCurve3d *crossSection,
pfCurve3d *path, pfScalar *profile);
pfType* pfFrenetSweptSurface::getClassType();
pfHsplineSurface C++ API
new pfHsplineSurface();
new pfHsplineSurface(pfReal *p, pfReal *tu, pfReal *tv,
pfReal *tuv, pfReal *uu, pfReal *vv, int uKnotCount,
int vKnotCount);
pfType* pfHsplineSurface::getClassType();
void pfHsplineSurface::getP(int i, int j, pfRVec3& v);
void pfHsplineSurface::getTu(int i, int j, pfRVec3& v);
void pfHsplineSurface::getTv(int i, int j, pfRVec3& v);
void pfHsplineSurface::getTuv(int i, int j, pfRVec3& v);
pfReal pfHsplineSurface::getUknot(int i);
pfReal pfHsplineSurface::getVknot(int j);
int pfHsplineSurface::getUknotCount();
int pfHsplineSurface::getVknotCount();
pfBool pfHsplineSurface::getCylindrical();
void pfHsplineSurface::setAll(pfReal *p, pfReal *tu, pfReal *tv,
pfReal *tuv, pfReal *uu, pfReal *vv, int uKnotCount,
int vKnotCount);
void pfHsplineSurface::setCylindrical(pfBool cylindrical);
void pfHsplineSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
pfSphereSurface C++ API
new pfSphereSurface();
new pfSphereSurface(pfReal radius);
pfType* pfSphereSurface::getClassType();
void pfSphereSurface::setRadius(pfReal radiusVal);
pfReal pfSphereSurface::getRadius()const;
void pfSphereSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
void pfSphereSurface::evalNorm(pfReal u, pfReal v, pfRVec3 & norm);
pfConeSurface C++ API
new pfConeSurface();
Page 59
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new pfConeSurface(pfReal radius, pfReal height);
pfType* pfConeSurface::getClassType();
void pfConeSurface::setRadius(pfReal radius);
void pfConeSurface::setHeight(pfReal height);
pfReal pfConeSurface::getRadius()const;
pfReal pfConeSurface::getHeight()const;
void pfConeSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
void pfConeSurface::evalNorm(pfReal u, pfReal v, pfRVec3 & norm);
pfCylinderSurface C++ API
new pfCylinderSurface();
new pfCylinderSurface(pfReal radius, pfReal height);
pfType* pfCylinderSurface::getClassType();
void pfCylinderSurface::setRadius(pfReal radiusVal);
void pfCylinderSurface::setHeight(pfReal heightVal);
pfReal pfCylinderSurface::getRadius( )const;
pfReal pfCylinderSurface::getHeight( )const;
void pfCylinderSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
void pfCylinderSurface::evalNorm(pfReal u, pfReal v,
pfRVec3 & norm);
pfPlaneSurface C++ API
new pfPlaneSurface();
new pfPlaneSurface(pfReal x1, pfReal y1, pfReal z1, pfReal u1,
pfReal v1, pfReal x2, pfReal y2, pfReal z2, pfReal u2,
pfReal x3, pfReal y3, pfReal z3, pfReal v3);
pfType* pfPlaneSurface::getClassType();
void pfPlaneSurface::setPoint1(pfReal x1, pfReal y1, pfReal z1,
pfReal u1, pfReal v1);
void pfPlaneSurface::setPoint2(pfReal x2, pfReal y2, pfReal z2,
pfReal u2);
void pfPlaneSurface::setPoint3(pfReal x3, pfReal y3, pfReal z3,
pfReal v3);
void pfPlaneSurface::getPoint1(pfReal *x1, pfReal *y1, pfReal *z1,
pfReal *u1, pfReal *v1);
void pfPlaneSurface::getPoint2(pfReal *x2, pfReal *y2, pfReal *z2,
pfReal *u2);
void pfPlaneSurface::getPoint3(pfReal *x3, pfReal *y3, pfReal *z3,
pfReal *v3);
void pfPlaneSurface::evalPt(pfReal u, pfReal v, pfRVec3 & pnt);
void pfPlaneSurface::evalDu(pfReal u, pfReal v, pfRVec3 & Du);
void pfPlaneSurface::evalDv(pfReal u, pfReal v, pfRVec3 & Dv);
void pfPlaneSurface::evalNorm(pfReal u, pfReal v, pfRVec3 & norm);
pfHsplineCurve2d C++ API
new pfHsplineCurve2d();
pfType* pfHsplineCurve2d::getClassType();
int pfHsplineCurve2d::getKnotCount()const;
void pfHsplineCurve2d::setPoint(int i, const pfRVec2 & p);
void pfHsplineCurve2d::setTangent(int i, const pfRVec2 & tng);
Page 60
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfHsplineCurve2d::setKnot(int i, pfReal t);
pfRVec2* pfHsplineCurve2d::getPoint(int i);
pfRVec2* pfHsplineCurve2d::getTangent(int i);
pfReal pfHsplineCurve2d::getKnot(int i);
void pfHsplineCurve2d::evalPt(pfReal t, pfRVec2 & pnt);
pfHsplineCurve3d C++ API
new pfHsplineCurve3d();
pfType* pfHsplineCurve3d::getClassType();
int pfHsplineCurve3d::getKnotCount()const;
void pfHsplineCurve3d::setPoint(int i, const pfRVec3 & p);
void pfHsplineCurve3d::setTangent(int i, const pfRVec3 & tng);
void pfHsplineCurve3d::setKnot(int i, pfReal t);
pfRVec3* pfHsplineCurve3d::getPoint(int i);
pfRVec3* pfHsplineCurve3d::getTangent(int i);
pfReal pfHsplineCurve3d::getKnot(int i);
pfSuperQuadCurve2d C++ API
new pfSuperQuadCurve2d();
pfType* pfSuperQuadCurve2d::getClassType();
void pfSuperQuadCurve2d::setRadius(pfReal radius);
pfReal pfSuperQuadCurve2d::getRadius()const;
void pfSuperQuadCurve2d::setExponent(pfReal exponent);
pfReal pfSuperQuadCurve2d::getExponent()const;
void pfSuperQuadCurve2d::evalPt(pfReal t, pfRVec2 & pnt);
pfSuperQuadCurve3d C++ API
new pfSuperQuadCurve3d();
new pfSuperQuadCurve3d(pfReal radius, pfRVec3 *origin,
pfReal exponent);
pfType* pfSuperQuadCurve3d::getClassType();
void pfSuperQuadCurve3d::setRadius(pfReal radius);
pfReal pfSuperQuadCurve3d::getRadius()const;
void pfSuperQuadCurve3d::setExponent(pfReal exponent);
pfReal pfSuperQuadCurve3d::getExponent()const;
void pfSuperQuadCurve3d::evalPt(pfReal t, pfRVec3 & pnt);
pfRuledSurface C++ API
new pfRuledSurface();
new pfRuledSurface(pfCurve3d *c1, pfCurve3d *c2);
pfType* pfRuledSurface::getClassType();
void pfRuledSurface::setCurve1(pfCurve3d *c1);
void pfRuledSurface::setCurve2(pfCurve3d *c2);
pfCurve3d* pfRuledSurface::getCurve1()const;
pfCurve3d* pfRuledSurface::getCurve2()const;
pfOrientedLine3d C++ API
new pfOrientedLine3d();
new pfOrientedLine3d(pfReal x1, pfReal y1, pfReal z1, pfReal t1,
pfReal x2, pfReal y2, pfReal z2, pfReal t2, pfReal ux,
pfReal uy, pfReal uz);
Page 61
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfType* pfOrientedLine3d::getClassType();
void pfOrientedLine3d::setUpPoint(pfReal ux, pfReal uy, pfReal uz);
void pfOrientedLine3d::getUpPoint(pfReal *ux, pfReal *uy,
pfReal *uz)const;
void pfOrientedLine3d::evalNorm(pfReal t, pfRVec3 & norm);
pfPieceWisePolyCurve3d C++ API
new pfPieceWisePolyCurve3d();
pfType* pfPieceWisePolyCurve3d::getClassType();
void pfPieceWisePolyCurve3d::setControlHull(int piece, int i,
const pfRVec3& p);
void pfPieceWisePolyCurve3d::setLimitParas(int piece, pfReal w1,
pfReal w2);
void pfPieceWisePolyCurve3d::setReverse(int reverse);
int pfPieceWisePolyCurve3d::getReverse()const;
int pfPieceWisePolyCurve3d::getPatchCount();
int pfPieceWisePolyCurve3d::getOrder(int piece);
void pfPieceWisePolyCurve3d::evalPt(pfReal t, pfRVec3& pnt);
pfCircle3d C++ API
new pfCircle3d();
new pfCircle3d(pfReal rad, pfRVec3 *org);
pfType* pfCircle3d::getClassType();
void pfCircle3d::setRadius(pfReal radius);
pfReal pfCircle3d::getRadius()const;
void pfCircle3d::evalPt(pfReal t, pfRVec3 & pnt);
void pfCircle3d::evalTan(pfReal t, pfRVec3 & tan);
void pfCircle3d::evalCurv(pfReal t, pfReal *curv);
void pfCircle3d::evalNorm(pfReal t, pfRVec3 & norm);
void pfCircle3d::eval(pfReal t, pfRVec3 & pnt, pfRVec3 & tan,
pfReal *curv, pfRVec3& norm);
pfPath C++ API
A pfPath is a dynamically-sized array of pfNode pointers that defines a
specific path or chain of nodes through a scene graph. new pfPath
creates a new path.
new pfPath();
pfType* pfPath::getClassType();
DLLEXPORT void pfCullResult(int result);
DLLEXPORT int pfGetParentCullResult(void);
DLLEXPORT int pfGetCullResult(void);
DLLEXPORT int pfCullPath(pfPath *path, pfNode *root, int mode);
pfTraverser C++ API
These functions are provided as a means to obtain information about the
behavior of the IRIS Performer traversal routines. They can be used to
determine the pfChannel or pfNode currently being culled or drawn, set
the matrix for the current traversal, determine the path from the root of
the scene graph to the node currently being traversed and the results of
culling the node currently being traversed and the parent of the current
node.
Page 62
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfChannel* pfTraverser::getChan()const;
pfNode* pfTraverser::getNode()const;
void pfTraverser::getMat(pfMatrix & mat)const;
void pfTraverser::getMatD(pfMatrix4d & mat)const;
int pfTraverser::isSinglePrecision();
int pfTraverser::getIndex()const;
const pfPath* pfTraverser::getPath()const;
pfFrameStats C++ API
A pfFrameStats structure contains a pfStats class as well as additional
statistics classes and support for tracking frame related tasks. Many of
the functions correspond directly to similar functions for the pfStats
class.
new pfFrameStats();
pfType* pfFrameStats::getClassType();
uint pfFrameStats::setClass(uint mask, int val);
uint pfFrameStats::getClass(uint emask);
uint pfFrameStats::setClassMode(int class, uint mask, int val);
uint pfFrameStats::getClassMode(int class);
void pfFrameStats::setAttr(int attr, float val);
float pfFrameStats::getAttr(int attr);
uint pfFrameStats::getOpen(uint emask);
uint pfFrameStats::open(uint enmask);
uint pfFrameStats::close(uint enmask);
void pfFrameStats::reset();
void pfFrameStats::clear(uint which);
void pfFrameStats::accumulate(pfFrameStats* src, uint which);
void pfFrameStats::average(pfFrameStats* src, uint which, int num);
void pfFrameStats::count(pfGeoSet *gset);
int pfFrameStats::query(uint which, void *dst, int size);
int pfFrameStats::mQuery(uint *which, void *dst, int size);
void pfFrameStats::draw(pfChannel *chan);
void pfFrameStats::countNode(int class, uint mode, pfNode * node);
LIBPR
DLLEXPORT void*
pr_amalloc(size_t size, void*);
DLLEXPORT void*
pr_arealloc(void* ptr, size_t size, void*);
DLLEXPORT void pr_afree(void* ptr, void*);
DLLEXPORT long sginap(long);
int mpin(void*, int);
int munpin(void*, int);
DLLEXPORT int oserror();
void blockproc(int pid);
void unblockproc(int pid);
int m_get_myid();
uint set_fpc_csr(uint);
Page 63
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
uint get_fpc_csr(void);
int sproc(void (*)(void *), int, void *);
int sprocsp(void(void*, size_t), int, void*, caddr_t, size_t);
int sprocsp(sprocFunc, int, void*, caddr_t, size_t);
void m_sync(void);
void glPolygonOffsetEXT( GLfloat factor, GLfloat bias );
ulong test_then_add(ulong *stuff, ulong junk);
DLLEXPORT uint32_t
test_then_add32(uint32_t *, uint32_t);
DLLEXPORT uint32_t
test_and_set32(uint32_t *, uint32_t);
DLLEXPORT uint32_t
add_then_test32(uint32_t *, uint32_t);
set/unset bitmasks
classes
Initialization Routines
These routines initialize and configure Performer to use multiple
processors and graphics pipelines. All libpf appliciations must call
pfInit and pfConfig before creating a scene graph or initiating rendering
with pfFrame. pfInit initializes shared memory and the clock. pfConfig
creates multiple processes based on the requested configuration and sets
up internal data structures for frame-accurate propagation of data
between the processes.
DLLEXPORT void prInit(void);
DLLEXPORT int prIsInited(void);
DLLEXPORT void prExit(void);
Shared Memory
This is an interface to creating and manipulating a shared memory area to
house the data structures shared by the different IRIS Performer
processes. pfInitArenas creates a shared memory arena that can be used to
allocate memory, locks and semaphores from. The other functions free this
arena, control the directory where it is created, return handles to the
shared memory and the semaphore memory and set the base address and size
of these shared memory areas.
DLLEXPORT int pfInitArenas(void);
DLLEXPORT int pfFreeArenas(void);
DLLEXPORT PF_USPTR_T*
pfGetSemaArena(void);
DLLEXPORT void pfSemaArenaSize(size_t size);
DLLEXPORT size_t
pfGetSemaArenaSize(void);
DLLEXPORT void pfSemaArenaBase(void *base);
DLLEXPORT void*
pfGetSemaArenaBase(void);
DLLEXPORT void*
pfGetSharedArena(void);
Page 64
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT void pfSharedArenaSize(size_t size);
DLLEXPORT size_t
pfGetSharedArenaSize(void);
DLLEXPORT void pfSharedArenaBase(void *base);
DLLEXPORT void*
pfGetSharedArenaBase(void);
DLLEXPORT void pfTmpDir(char *dir);
const DLLEXPORT char *
pfGetTmpDir(void);
Draw Modes
IRIS Performer supports a large number of drawing modes like shading,
transparency, anti-aliasing and coplanar geometry. These functions define
these modes and enable and disable them.
Shader Program Parameter Types
DLLEXPORT void pfShadeModel(int model);
DLLEXPORT int pfGetShadeModel(void);
DLLEXPORT void pfTransparency(int type);
DLLEXPORT int pfGetTransparency(void);
DLLEXPORT void pfAlphaFunc(float ref, int func);
DLLEXPORT void pfGetAlphaFunc(float* ref, int* func);
DLLEXPORT void pfAntialias(int type);
DLLEXPORT int pfGetAntialias(void);
DLLEXPORT void pfDecal(int mode);
DLLEXPORT void pfApplyDecalPlane(pfPlane *plane);
DLLEXPORT pfPlane *
pfGetCurDecalPlane(void);
DLLEXPORT int pfGetDecal(void);
DLLEXPORT void pfCullFace(int cull);
DLLEXPORT int pfGetCullFace(void);
DLLEXPORT void pfApplyTMat(pfMatrix *mat);
DLLEXPORT void pfEnable(uint64_t target);
DLLEXPORT void pfDisable(uint64_t target);
DLLEXPORT int pfGetEnable(int target);
DLLEXPORT void pfFogScale(float fogScale);
DLLEXPORT float
pfGetFogScale(void);
DLLEXPORT void pfFogOffset(float *offset);
DLLEXPORT void pfGetFogOffset(float *offset);
DLLEXPORT void pfClear(int which, const pfVec4 col);
DLLEXPORT void pfClear(int which, const pfVec4 *col);
DLLEXPORT void pfGLOverride(int mode, float val);
DLLEXPORT float
pfGetGLOverride(int mode);
GL Matrix Stack
These functions operate on the graphics library matrix stack. Various
standard operations on matrices are supported.
Page 65
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT void pfScale(float x, float y, float z);
DLLEXPORT void pfTranslate(float x, float y, float z);
DLLEXPORT void pfRotate(int axis, float degrees);
DLLEXPORT void pfPushMatrix(void);
DLLEXPORT void pfPushIdentMatrix(void);
DLLEXPORT void pfPopMatrix(void);
DLLEXPORT void pfLoadMatrix(const pfMatrix m);
DLLEXPORT void pfMultMatrix(const pfMatrix m);
Precision modes
Collaboration
void pfCollabEnque(int ,
Notification
These functions provide a general purpose error message and notification
handling facility for applications using IRIS Performer. User-defined
functions can be used as notifiers.
DLLEXPORT void pfNotifyHandler(pfNotifyFuncType handler);
DLLEXPORT pfNotifyFuncType
pfGetNotifyHandler(void);
DLLEXPORT void pfDefaultNotifyHandler(pfNotifyData *notice);
DLLEXPORT void pfNotifyLock(void);
DLLEXPORT void pfNotifyUnlock(void);
DLLEXPORT void pfNotifyLevel(int severity);
DLLEXPORT int pfGetNotifyLevel(void);
DLLEXPORT void pfNotify(int severity, int error, char *format,
Clock Routines
These routines provide a simple and consistent interface to the high
resolution hardware-specific timers available on most SGI platforms.
DLLEXPORT double
pfGetTime(void);
DLLEXPORT pid_t
pfInitClock(double time);
DLLEXPORT void pfWrapClock(void);
DLLEXPORT void pfClockName(char *name);
DLLEXPORT const char*
pfGetClockName(void);
DLLEXPORT void pfClockMode(int mode);
DLLEXPORT int pfGetClockMode(void);
File Paths
These functions can be used to specify a UNIX-style file path to search
for files in and to find files in such a path.
DLLEXPORT void pfFilePath(const char* path);
DLLEXPORT void pfFilePathv(const char *s,
DLLEXPORT const char*
pfGetFilePath(void);
Page 66
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT int pfFindFile(const char* file, char path[PF_MAXSTRING],
int amode);
Video Clock Routines
These functions provide an interface to the video retrace clock attached
to each graphics pipeline. Once a video clock is initialised, its current
value can be determined and it can be used to synchronize a process with
a time barrier.
DLLEXPORT int pfStartVClock(void);
DLLEXPORT void pfStopVClock(void);
DLLEXPORT void pfInitVClock(int ticks);
DLLEXPORT void pfVClockOffset(int offset);
DLLEXPORT int pfGetVClockOffset(void);
DLLEXPORT void pfVClockVideoRate(float rate);
DLLEXPORT float
pfVClockGetVideoRate(void);
DLLEXPORT int pfGetVClock(void);
DLLEXPORT int pfVClockSync(int rate, int offset);
DLLEXPORT void pfVClockFineAdjust(double timestamp);
DLLEXPORT float
pfVClockEstimateSleep(int ticks, float fraction);
pfVideoChannel Routines
IRIS Performer manages the state of video channels with pfVideoChannels.
Real-time operations can be done during rendering one on the current
video channel of the drawing process, pfCurVideoChan and pfGetCurVChan.
DLLEXPORT pfVideoChannel *
pfGetCurVChan(void);
pfWindow Routines
IRIS Performer provides a system-independent window paradigm. The
prInitGfx function may be called to initialize the graphics subsystem and
acquire the graphics attributes Performer requires. Use pfGetCurWin to
gain access to the current window.
DLLEXPORT void prInitGfx(void);
DLLEXPORT pfWindow *
pfGetCurWin(void);
Window System Routines
The pfWSConnection data structure encapsulates the workstation-
independent frame-buffer (window) facility in IRIS Performer. These
functions serve to define specific windowing attributes necessary for the
application, to open and close windows, and to manipulate the window
parameters.
DLLEXPORT void pfCloseWSConnection(pfWSConnection dsp);
DLLEXPORT pfFBConfig
pfChooseFBConfig(pfWSConnection dsp, int screen,
int *attr);
Page 67
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT pfFBConfig
pfChooseFBConfigData(void **dst, pfWSConnection dsp,
int screen, int *attr, void *arena);
DLLEXPORT void pfSelectWSConnection(pfWSConnection);
DLLEXPORT pfWSConnection
pfOpenWSConnection(const char *str, int shared);
DLLEXPORT pfWSConnection
pfOpenScreen(int screen, int shared);
DLLEXPORT pfWSConnection
pfGetCurWSConnection(void);
DLLEXPORT const char*
pfGetWSConnectionName(pfWSConnection);
DLLEXPORT void pfGetScreenSize(int screen, int *x, int *y);
DLLEXPORT int pfGetNumScreenVChans(int scr);
Query Features
Use the QueryFeature routines to determine the presence, absence, or
limitations of features in the underlying graphics implementation, like
the availability of attenuation in the lighting model or the availability
of multiple graphics pipes.
DLLEXPORT const char *
pfGetMachString(void);
DLLEXPORT const char *
pfGetRelString(void);
float pfGetIRIXRelease(void);
DLLEXPORT int pfQueryFeature(int64_t which, int *dst);
DLLEXPORT int pfMQueryFeature(int *which, int *dst);
DLLEXPORT void pfFeature(int which, int val);
DLLEXPORT void pfStippleMasks(int numLevels, GLubyte **masks);
Query System
Use the QuerySys routines to determine the capacity and limitations of
the underlying graphics implementation, like the size of texture memory
or the number of stencil planes available.
DLLEXPORT int pfQuerySys(int which, int *dst);
DLLEXPORT int pfMQuerySys(int *which, int *dst);
DLLEXPORT int pfQueryPerf(int which, void *dst);
DLLEXPORT int pfPerf(int which, void *dst);
DLLEXPORT int pfGentle_ussetlock(ulock_t lock, int spins);
Event Instrumentation
DLLEXPORT void pfInitializeEvents(void);
DLLEXPORT void pfResetEvents(void);
DLLEXPORT void pfEventSampleOn(void);
DLLEXPORT void pfEventSampleOff(void);
DLLEXPORT void pfWriteEvents(char *filename);
pfObject C++ API
A pfObject is the abstract data type from which the major IRIS Performer
data structures are derived. Although pfObjects cannot be created
Page 68
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
directly, most IRIS Performer data structures are derived from them and
thus inherit the functionality of the pfObject routines and those for
pfMemory.
pfType* pfObject::getClassType();
void pfObject::setCopyFunc(pfCopyFuncType func);
pfCopyFuncType pfObject::getCopyFunc();
void pfObject::setDeleteFunc(pfDeleteFuncType func);
pfMergeFuncType
pfObject::getMergeFunc();
void pfObject::setMergeFunc(pfMergeFuncType func);
pfDeleteFuncType
pfObject::getDeleteFunc();
void pfObject::setPrintFunc(pfPrintFuncType func);
pfPrintFuncType
pfObject::getPrintFunc();
void pfObject::setCopyFunc(int slot, pfCopyFuncType func);
pfCopyFuncType pfObject::getCopyFunc(int slot);
void pfObject::setDeleteFunc(int slot, pfDeleteFuncType func);
pfDeleteFuncType
pfObject::getDeleteFunc(int slot);
void pfObject::setMergeFunc(int slot, pfMergeFuncType func);
pfMergeFuncType
pfObject::getMergeFunc(int slot);
void pfObject::setPrintFunc(int slot, pfPrintFuncType func);
pfPrintFuncType
pfObject::getPrintFunc(int slot);
int pfObject::getGLHandle(const pfObject *obj);
void pfObject::deleteGLHandle(pfObject *obj);
void pfObject::setUserData(pfObject* obj, void* data);
void* pfObject::getUserData(pfObject* obj);
void pfObject::setUserData(pfObject* obj, int slot,
void* data);
void* pfObject::getUserData(pfObject* obj, int slot);
int pfObject::getNumUserData(pfObject* obj);
int pfObject::getNamedUserDataSlot(const char *name);
const char* pfObject::getUserDataSlotName(int slot);
int pfObject::getNumNamedUserDataSlots();
pfType C++ API
All IRIS Performer data types that derive from pfObject/pfMemory have an
associated pfType. The pfType can be used to determine the class
ancestory of both built-in and add-on data types.
new pfType(pfType *parent, char *name);
pfType* pfType::getParent();
int pfType::isDerivedFrom(pfType *ancestor);
void pfType::setMaxTypes(int n);
pfImageCache C++ API
A pfImageCache allows a selected subset of an arbitrarily large tiled
image to be cached in main memory and incrementally updated from disk or
Page 69
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
other file system devices as the origin of the selected subset is
changed. pfImageCaches hold an MxNxO grid of tiles in main memory while
providing access to the complete set of tiles on disk as needed.
new(void *arena)
pfImageCache();
pfType* pfImageCache::getClassType();
void pfImageCache::setName(const char *name);
const char* pfImageCache::getName();
void pfImageCache::setProtoTile(pfImageTile *tile);
pfImageTile* pfImageCache::getProtoTile();
void pfImageCache::setTexRegionOrg(int originS, int originT,
int originR);
void pfImageCache::setTexRegionSize(int sizeS, int sizeT,
int sizeR);
void pfImageCache::getTexRegionOrg(int *originS, int *originT,
int *originR);
void pfImageCache::getTexRegionSize(int *sizeS, int *sizeT,
int *sizeR);
void pfImageCache::getCurTexRegionOrg(int *originS,
int *originT, int *originR);
void pfImageCache::getCurTexRegionSize(int *sizeS, int *sizeT,
int *sizeR);
void pfImageCache::setMemRegionOrg(int tileS, int tileT,
int tileR);
void pfImageCache::setMemRegionSize(int tileS, int tileT,
int tileR);
void pfImageCache::getMemRegionOrg(int *orgTileS,
int *orgTileT, int *orgTileR);
void pfImageCache::getMemRegionSize(int *sizeS, int *sizeT,
int *sizeR);
void pfImageCache::getCurMemRegionOrg(int *orgS, int *orgT,
int *orgR);
void pfImageCache::getCurMemRegionSize(int *sizeS, int *sizeT,
int *sizeR);
void pfImageCache::setTexSize(int s, int t, int r);
void pfImageCache::getTexSize(int *s, int *t, int *r);
void pfImageCache::getTexRegionOffset(int *s, int *t, int *r);
void pfImageCache::setTex(void *dst, int lvl, int type);
void pfImageCache::getTex(void **dst, int *lvl, int *type);
void pfImageCache::setImageSize(int sizeS, int sizeT,
int sizeR);
void pfImageCache::getImageSize(int *sizeS, int *sizeT,
int *sizeR);
void -
pfImageCache::setReadQueueFunc(pfImageCacheReadQueueFuncType func);
void -
pfImageCache::setTileFileNameFunc(pfTileFileNameFuncType func);
pfImageCacheReadQueueFuncType
pfImageCache::getReadQueueFunc();
Page 70
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfTileFileNameFuncType
pfImageCache::getTileFileNameFunc();
void pfImageCache::setFileStreamServer(int dim, int which,
const char *device);
const char* pfImageCache::getFileStreamServer(int dim, int which);
void pfImageCache::setStreamServerQueue(int dim, int which,
pfQueue *q);
pfQueue* pfImageCache::getStreamServerQueue(int dim, int which);
pfQueue* -
pfImageCache::getStreamServerQueueByName(const char *name);
void pfImageCache::setTileFileNameFormat(const char *fmtString,
int nArgs, int *argList);
void -
pfImageCache::getTileFileNameFormat(const char **fmtString,
int *nArgs, const int **argList);
int pfImageCache::getNumStreamServers(int dim)const;
void pfImageCache::setMode(int mode, int val);
int pfImageCache::getMode(int mode);
void pfImageCache::setMaster(pfImageCache *master);
pfImageCache* pfImageCache::getMaster()const;
pfList* pfImageCache::getSlaves()const;
void pfImageCache::setDTRMode(uint mode);
uint pfImageCache::getDTRMode();
pfImageTile* pfImageCache::getTile(int s, int t, int r);
const pfList* pfImageCache::getLoadUpdates();
void pfImageCache::calcTexRegion(int *orgS, int *orgT,
int *orgR, int *sizeS, int *sizeT, int *sizeR);
void pfImageCache::calcMemRegion(int *orgS, int *orgT,
int *orgR, int *sizeS, int *sizeT, int *sizeR);
int pfImageCache::isValid(int s, int t, int r, int sizeS,
int sizeT, int sizeR);
int pfImageCache::isValid();
int pfImageCache::isTexRegChanged();
void pfImageCache::setMemoryMode(int m);
int pfImageCache::getMemoryMode();
void pfImageCache::setNumReplicaReaders(int m);
int pfImageCache::getNumReplicaReaders();
float pfImageCache::apply(float msec);
void pfImageCache::apply();
void pfImageCache::invalidate();
void pfImageCache::autoConfigFileName(pfImageTile *itile);
pfClipTexture C++ API
A pfClipTexture is used to represent a very large texture image with a
modest amount of texture memory supplemented by a moderate amount of main
memory and a correspondingly greater quantity of backing store on disk.
The implementation keeps a small area of interest of each level of a
MIP-map in the hardware texture cache at any one time. This stack of
subimages then forms a cached sub-volume of the normal pyramid of
hierarchical resolutions stored within a MIP-map.
Page 71
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new(void *arena)
pfClipTexture();
pfType* pfClipTexture::getClassType();
int pfClipTexture::getMaxClipSize( int bytespertexel );
int pfClipTexture::isEmulated();
int pfClipTexture::getNumClippedLevels();
void* pfClipTexture::getCteAttr( int which );
void pfClipTexture::setCteAttr( int which, void* val );
void pfClipTexture::setLevel(int level, pfObject* levelObj);
pfObject* pfClipTexture::getLevel(int level);
void pfClipTexture::setCenter(int s, int t, int r);
void pfClipTexture::getCenter(int *s, int *t, int *r);
void pfClipTexture::getCurCenter(int *s, int *t, int *r);
void pfClipTexture::setClipSize(int clipSize);
int pfClipTexture::getClipSize();
void pfClipTexture::setVirtualLODOffset(int offset);
int pfClipTexture::getVirtualLODOffset();
void pfClipTexture::setNumEffectiveLevels(int levels);
int pfClipTexture::getNumEffectiveLevels();
void pfClipTexture::setNumAllocatedLevels(int levels);
int pfClipTexture::getNumAllocatedLevels();
void pfClipTexture::setVirtualSize(int width, int height,
int depth);
void pfClipTexture::getVirtualSize(int *width, int *height,
int *depth);
void pfClipTexture::setInvalidBorder(int nTexels);
int pfClipTexture::getInvalidBorder();
void pfClipTexture::setLevelPhaseMargin(int level, int size);
int pfClipTexture::getLevelPhaseMargin(int level);
void pfClipTexture::setLevelPhaseShift(int level,
int phaseShiftS, int phaseShiftT, int phaseShiftR);
void pfClipTexture::getLevelPhaseShift(int level,
int *phaseShiftS, int *phaseShiftT, int *phaseShiftR);
void pfClipTexture::getOffset(int *s, int *t, int *r);
void pfClipTexture::setTexLoadTime(float msec);
float pfClipTexture::getTexLoadTime();
void pfClipTexture::setMaster(pfClipTexture *master);
pfClipTexture* pfClipTexture::getMaster()const;
pfList* pfClipTexture::getSlaves()const;
void pfClipTexture::setMinClipSizeRatio(float size);
float pfClipTexture::getMinClipSizeRatio();
void pfClipTexture::setDTRMode(uint mask);
uint pfClipTexture::getDTRMode();
float pfClipTexture::getMinDTRLOD();
void pfClipTexture::setDTRFadeCount(int count);
int pfClipTexture::getDTRFadeCount();
void pfClipTexture::setDTRBlurMargin(float frac);
float pfClipTexture::getDTRBlurMargin();
void pfClipTexture::setLODOffsetLimit(int lo, int hi);
void pfClipTexture::getLODOffsetLimit(int *lo, int *hi);
Page 72
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfClipTexture::setNumEffectiveLevelsLimit(int lo, int hi);
void pfClipTexture::getNumEffectiveLevelsLimit(int *lo,
int *hi);
void pfClipTexture::setMinLODLimit(float lo, float hi);
void pfClipTexture::getMinLODLimit(float *lo, float *hi);
void pfClipTexture::setMaxLODLimit(float lo, float hi);
void pfClipTexture::getMaxLODLimit(float *lo, float *hi);
void pfClipTexture::setLODBiasLimit(float Slo, float Shi,
float Tlo, float Thi, float Rlo, float Rhi);
void pfClipTexture::getLODBiasLimit(float *Slo, float *Shi,
float *Tlo, float *Thi, float *Rlo, float *Rhi);
void pfClipTexture::setLODRange(float min, float max);
void pfClipTexture::getLODRange(float *min, float *max);
void pfClipTexture::getCurLODRange(float *min, float *max);
void pfClipTexture::setLODBias(float s, float t, float r);
void pfClipTexture::getLODBias(float *s, float *t, float *r);
void pfClipTexture::getCurLODBias(float *s, float *t,
float *r);
void pfClipTexture::apply();
void pfClipTexture::applyMemReg();
void pfClipTexture::applyTexReg();
void pfClipTexture::updateMemReg();
void pfClipTexture::updateTexReg();
void pfClipTexture::update();
void pfClipTexture::invalidate();
void pfClipTexture::applyVirtualParams(int offset, int levels);
void pfClipTexture::applyCenter(int s, int t, int r);
int pfClipTexture::isVirtual();
DLLEXPORT pfQueue*
pfGetGlobalReadQueue(void);
DLLEXPORT void pfDeleteGlobalReadQueue(void);
pfImageTile C++ API
A pfImageTile is representation of a texture image in main memory. A
pfImageTile can be used to load textures or pieces of texture from disk
and store them in certain byte configurations in main memory. Further
these pfImageTiles can then be used as the source for pfTextures or
pfTexLoads in order to load imagery into a GL texture from main memory.
new(void *arena)
pfImageTile();
pfType* pfImageTile::getClassType();
void pfImageTile::setSize(int w, int h, int d);
void pfImageTile::getSize(int *w, int *h, int *d);
void pfImageTile::setOrigin(int s, int t, int r);
void pfImageTile::getOrigin(int *s, int *t, int *r);
void pfImageTile::setMem(uchar *img, int nBytes);
uchar* pfImageTile::getMem();
uchar* pfImageTile::getReadableMem();
void pfImageTile::setReplica(pfReplica *replica);
Page 73
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfImageTile::setMemQueue(pfQueue *q);
const pfQueue* pfImageTile::getMemQueue();
int pfImageTile::getNumImageComponents();
void pfImageTile::setMemImageFormat(int format);
int pfImageTile::getMemImageFormat();
void pfImageTile::setMemImageType(int type);
int pfImageTile::getMemImageType();
int pfImageTile::getMemImageTexelSize();
void pfImageTile::setMemInfo(int psize, int lock);
void pfImageTile::getMemInfo(int *psize, int *lock);
void pfImageTile::setName(const char *fname);
const char* pfImageTile::getName();
void pfImageTile::setFileName(const char *fname);
const char* pfImageTile::getFileName();
int pfImageTile::getFileImageTexelSize();
void pfImageTile::setFileTile(int tileS, int tileT, int tileR);
void pfImageTile::getFileTile(int *tileS, int *tileT,
int *tileR);
void pfImageTile::setNumFileTiles(int nTilesS, int nTilesT,
int nTilesR);
void pfImageTile::getNumFileTiles(int *nTilesS, int *nTilesT,
int *nTilesR);
void pfImageTile::setFileImageFormat(int fileFmt);
int pfImageTile::getFileImageFormat();
void pfImageTile::setFileImageType(int fileType);
int pfImageTile::getFileImageType();
uchar* pfImageTile::getSubTile(int s, int t, int r);
uchar* pfImageTile::getValidSubTile(int s, int t, int r);
void pfImageTile::setReadQueue(pfQueue *q);
pfQueue* pfImageTile::getReadQueue();
int pfImageTile::getTotalBytes();
int pfImageTile::getValidBytes();
int pfImageTile::getValidTexels();
void pfImageTile::setValidTexels(int nTexels);
int pfImageTile::isValid();
int pfImageTile::isLoading();
int pfImageTile::isDirty();
void pfImageTile::setReadFunc(pfReadImageTileFuncType func);
pfReadImageTileFuncType
pfImageTile::getReadFunc();
void pfImageTile::setDefaultTile(pfImageTile *default);
pfImageTile* pfImageTile::getDefaultTile();
void pfImageTile::setDefaultTileMode(int useDefault);
int pfImageTile::getDefaultTileMode();
void pfImageTile::setHeaderOffset(int hdr);
int pfImageTile::getHeaderOffset();
void pfImageTile::setPriority(int priority);
int pfImageTile::getPriority();
void pfImageTile::setImageCache(pfImageCache *ic);
pfImageCache* pfImageTile::getImageCache();
Page 74
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfImageTile::setTileIndex(int s, int t, int r);
void pfImageTile::getTileIndex(int *s, int *t, int *r);
void -
pfImageTile::setFileNameFunc(pfTileFileNameFuncType fnFunc);
pfTileFileNameFuncType
pfImageTile::getFileNameFunc();
int pfImageTile::load();
int pfImageTile::load(int nTexels);
int pfImageTile::load(const char *fname);
int pfImageTile::load(const char *fname, int nTexels);
void pfImageTile::freeMem();
void pfImageTile::setMemoryMode(int m);
int pfImageTile::getMemoryMode();
void pfImageTile::setNumReplicaReaders(int m);
int pfImageTile::getNumReplicaReaders();
int pfImageTile::ReadDirect(pfImageTile *itile, int ntexels);
int pfImageTile::ReadNormal(pfImageTile *itile, int ntexels);
int pfImageTile::ProcessOneRead(void *data);
void pfImageTile::sortFunc(pfQueueSortFuncData *data);
uchar* pfImageTile::getUnalignedMem()const;
short pfImageTile::getUseMemQueue()const;
void pfImageTile::setUseMemQueue(short useMemQueue);
pfTexLoad C++ API
a pfTexLoad is used to control the mapping from texture images external
to the GL to texture images currently loaded into the GL. Each load
defines a load of a certain size from the origin of one of several
sources to a origin in a destination pfTexture which corresponds to a GL
texture.
new(void *arena)
pfTexLoad();
pfType* pfTexLoad::getClassType();
void pfTexLoad::setAttr(int attr, void *val);
void* pfTexLoad::getAttr(int attr);
void pfTexLoad::setMode(int mode, int val);
int pfTexLoad::getMode(int mode);
void pfTexLoad::setVal(int which, float val);
float pfTexLoad::getVal(int which);
void pfTexLoad::setSrcOrg(int s, int t, int r);
void pfTexLoad::getSrcOrg(int *s, int *t, int *r);
void pfTexLoad::setDstOrg(int s, int t, int r);
void pfTexLoad::getDstOrg(int *s, int *t, int *r);
void pfTexLoad::setSrc(void *src);
void* pfTexLoad::getSrc();
void pfTexLoad::setSrcLevel(int lvl);
int pfTexLoad::getSrcLevel();
void pfTexLoad::setDst(void *tex);
void* pfTexLoad::getDst();
void pfTexLoad::setDstLevel(int lvl);
Page 75
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfTexLoad::getDstLevel();
void pfTexLoad::setSize(int w, int h, int d);
void pfTexLoad::getSize(int *w, int *h, int *d);
void pfTexLoad::setFrame(int frameCount);
int pfTexLoad::getFrame();
int pfTexLoad::getPrevLoadedTexels();
int pfTexLoad::getDirty();
int pfTexLoad::setDirty(int dirtmask);
int pfTexLoad::getStatus();
int pfTexLoad::apply();
int pfTexLoad::apply(int texels);
DLLEXPORT int pfGetNumGlobalQueueServiceProcs(void);
DLLEXPORT int pfGetGlobalQueueServiceProcPID(int n);
DLLEXPORT pfQueue*
pfGetGlobalQueueServiceProcQueue(int n);
pfQueue C++ API
The pfQueue data type is implemented as a dynamically sized array of
arbitrary, but homogeneously-sized, elements. Further, the pfQueue
supports insertion and deletion from multiple processes and implements a
convenient sproc-based multithreaded queue management system for
asynchronous queue service tasks.
new(void *arena)
pfQueue(int eltSize, int nElts);
pfType* pfQueue::getClassType();
void pfQueue::setArrayLen(int length);
int pfQueue::getArrayLen();
int pfQueue::getNum();
int pfQueue::getElementSize();
int pfQueue::getNumServiceProcs();
int pfQueue::getServiceProcPID(int which);
void pfQueue::setSortFunc(pfQueueSortFuncType func);
pfQueueSortFuncType
pfQueue::getSortFunc();
void pfQueue::setSortMode(int bool);
int pfQueue::getSortMode();
void pfQueue::setInputRange(int low, int hi);
void pfQueue::getInputRange(int *low, int *hi);
void pfQueue::setOutputRange(int low, int hi);
void pfQueue::getOutputRange(int *low, int *hi);
int pfQueue::getSortProcPID();
void pfQueue::insert(void *elt);
void pfQueue::insertFront(void *elt);
void* pfQueue::remove();
void* pfQueue::attemptRemove();
int pfQueue::addServiceProc(pfQueueServiceFuncType fnc);
int pfQueue::signalAllServiceProcs(int count, int token);
void pfQueue::notifySortProc();
DLLEXPORT pfFog*
pfGetCurFog(void);
Page 76
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfFog C++ API
pfFog is used to simulate atmospheric phenomena such as fog and haze and
for depthcueing. The fog color is blended with the color that is
computed for rendered geometry based on the geometry's range from the
eyepoint. IRIS Performer provides functions for defining fog color,
ranges, and other attributes.
new(void *arena)
pfFog();
pfType* pfFog::getClassType();
void pfFog::setFogType(int type);
int pfFog::getFogType()const;
void pfFog::setRange(float onset, float opaque);
void pfFog::getRange(float* onset, float* opaque)const;
void pfFog::setOffsets(float onset, float opaque);
void pfFog::getOffsets(float *onset, float *opaque)const;
void pfFog::setRamp(int points, float* range, float* density,
float bias);
void pfFog::getRamp(int* points, float* range, float* density,
float* bias)const;
void pfFog::setColor(float r, float g, float b);
void pfFog::getColor(float* r, float* g, float* b)const;
float pfFog::getDensity(float range)const;
void pfFog::apply();
DLLEXPORT pfColortable*
pfGetCurCtab(void);
pfColortable C++ API
A pfColortable is a 'color indexing' mechanism used by pfGeoSets.
pfGeoSets can be drawn with the colors defined in the current globally
active pfColortable rather than by using the pfGeoset's own local color
list. This facility can be used for instant large-scale color
manipulation of geometry in a scene.
new(void *arena)
pfColortable(int size);
pfType* pfColortable::getClassType();
int pfColortable::getCtabSize()const;
int pfColortable::setColor(int index, pfVec4& acolor);
int pfColortable::getColor(int index, pfVec4& acolor)const;
pfVec4* pfColortable::getColors()const;
void pfColortable::apply();
pfDataPool C++ API
A pfDataPool is similar to a shared memory malloc arena but adds the
ability to lock/unlock pfDataPool memory for multiprocessing
applications. The pfDataPool functions allow related or unrelated
processes to share data and provide a means for locking data blocks to
eliminate data collision.
Page 77
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfDataPool* pfDataPool::create(uint size, char* name);
pfDataPool* pfDataPool::attach(char* name);
pfType* pfDataPool::getClassType();
const char* pfDataPool::getName();
void pfDataPool::setAttachAddr(void *addr);
void* pfDataPool::getAttachAddr();
int pfDataPool::getDPoolSize();
volatile void* pfDataPool::alloc(uint size, int id);
volatile void* pfDataPool::find(int id);
int pfDataPool::free(void* dpmem);
int pfDataPool::release();
int pfDataPool::lock(void* dpmem);
int pfDataPool::lock(void* dpmem, int spins, int block);
void pfDataPool::unlock(void* dpmem);
int pfDataPool::test(void* dpmem);
DLLEXPORT pfDispList*
pfGetCurDList(void);
DLLEXPORT void pfDrawGLObj(GLOBJECT obj);
pfDispList C++ API
A pfDispList is a display list that once open, captures certain libpr
commands, such as pfTransparency, pfTexture::apply, or pfGeoSet::draw.
After it is closed, it may be executed through Performer to perform the
recorded commands. pfDispLists are designed for multiprocessing, where
one process builds a display list of the visible scene and another
process draws it.
new(void *arena)
pfDispList(int type, int size);
pfType* pfDispList::getClassType();
int pfDispList::getSize()const;
void pfDispList::setMode(int mode, int val);
int pfDispList::getMode(int mode)const;
int pfDispList::getDListType()const;
int pfDispList::draw();
int pfDispList::isEmpty();
int pfDispList::compile();
int pfDispList::preprocess(int flag);
void pfDispList::open();
void pfDispList::close();
int pfDispList::append(const pfDispList *src);
void pfDispList::reset();
void pfDispList::resetBanks();
void pfDispList::addCmd(int cmd);
void pfDispList::callback(pfDListFuncType callback, int bytes,
void* data);
pfGeoSet* pfDispList::getTmpGSet(int myId);
void* pfDispList::getTmpBuffer(int myId, int size);
pfFont C++ API
The pfFont facility provides the capability to load fonts for 3-D
rendering with the string drawing routines from pfString and pfText.
Page 78
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
IRIS Performer uses this facility to provide wireframe, flat, extruded,
and textured-quad fonts in three dimensions.
new(void *arena)
pfFont();
pfType* pfFont::getClassType();
void pfFont::setCharGSet(int ascii, pfGeoSet *gset);
pfGeoSet* pfFont::getCharGSet(int ascii);
void pfFont::setCharSpacing(int ascii, pfVec3 & spacing);
const pfVec3* pfFont::getCharSpacing(int ascii);
void pfFont::setAttr(int which, void *attr);
void* pfFont::getAttr(int which);
void pfFont::setVal(int which, float val);
float pfFont::getVal(int which);
void pfFont::setMode(int mode, int val);
int pfFont::getMode(int mode);
DLLEXPORT int pfFluxedGSetInit(pfFluxMemory *fmem);
pfGeoSet C++ API
The pfGeoSet (short for "Geometry Set") is a fundamental IRIS Performer
data structure. Each pfGeoSet is a collection of geometry with one
primitive type, such as points, lines, triangles, and homogeneous
attribute bindings, such as "untextured with colors per vertex and
normals per primitive," so that each pfGeoSet may be presented to the
graphics subsystem with as little overhead as possible, using an
optimized draw routine, one for each type of pfGeoSet.
new(void *arena)
pfGeoSet();
pfType* pfGeoSet::getClassType();
void pfGeoSet::setNumPrims(int n);
int pfGeoSet::getNumPrims()const;
void pfGeoSet::setPrimType(int type);
int pfGeoSet::getPrimType()const;
void pfGeoSet::setPrimLengths(int *lengths);
int* pfGeoSet::getPrimLengths()const;
int pfGeoSet::getPrimLength(int i)const;
void pfGeoSet::setAttr(int attr, int bind, void* alist,
ushort* ilist);
void pfGeoSet::setMultiAttr(int attr, int index, int bind,
void* alist, ushort* ilist);
int pfGeoSet::getAttrBind(int attr)const;
int pfGeoSet::getMultiAttrBind(int attr, int index)const;
void pfGeoSet::getAttrLists(int attr, void** alist,
ushort** ilist)const;
void pfGeoSet::getMultiAttrLists(int attr, int index,
void** alist, ushort** ilist)const;
int pfGeoSet::getAttrRange(int attr, int *min, int *max)const;
int pfGeoSet::getMultiAttrRange(int attr, int index, int *min,
int *max)const;
Page 79
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfGeoSet::setDrawMode(int mode, int val);
int pfGeoSet::getDrawMode(int mode)const;
void pfGeoSet::setGState(pfGeoState *gstate);
pfGeoState* pfGeoSet::getGState()const;
void pfGeoSet::setGStateIndex(int id);
int pfGeoSet::getGStateIndex()const;
void pfGeoSet::setHlight(pfHighlight *hlight);
pfHighlight* pfGeoSet::getHlight()const;
void pfGeoSet::setDecalPlane(pfPlane *plane);
pfPlane* pfGeoSet::getDecalPlane()const;
void pfGeoSet::setLineWidth(float width);
float pfGeoSet::getLineWidth()const;
void pfGeoSet::setPntSize(float s);
float pfGeoSet::getPntSize()const;
void pfGeoSet::setIsectMask(uint mask, int setMode, int bitOp);
uint pfGeoSet::getIsectMask()const;
void pfGeoSet::setDrawBin(short bin);
int pfGeoSet::getDrawBin()const;
void pfGeoSet::setDrawOrder(uint order);
uint pfGeoSet::getDrawOrder()const;
void pfGeoSet::setAppearance(islAppearance *appearance_);
islAppearance* pfGeoSet::getAppearance()const;
int pfGeoSet::isShaded();
int pfGeoSet::getNumTextures();
void pfGeoSet::setOptimize(int state);
int pfGeoSet::getOptimize();
void pfGeoSet::setBound(pfBox* box, int mode);
int pfGeoSet::getBound(pfBox* box);
void pfGeoSet::setBoundFlux(pfFlux* flux);
pfFlux* pfGeoSet::getBoundFlux();
void pfGeoSet::hideStripPrim(int i);
void pfGeoSet::unhideStripPrim(int i);
int pfGeoSet::isStripPrimHidden(int i);
void pfGeoSet::updateCteRefs();
void pfGeoSet::calcTexBBox();
void pfGeoSet::setTexBBox( uint centerS, uint centerT,
uint halfwidth, uint halfheight );
void pfGeoSet::setTexBBox( float minS, float maxS, float minT,
float maxT );
int pfGeoSet::getTexBBox( uint* centerS, uint* centerT,
uint* halfwidth, uint* halfheight );
int pfGeoSet::getTexBBox( float* minS, float* maxS,
float* minT, float* maxT );
void pfGeoSet::setCteAttr( int which, void* val );
void* pfGeoSet::getCteAttr( int which );
void pfGeoSet::quickCopy(pfGeoSet *src);
void pfGeoSet::quickSetAttr(int attr, void* alist,
ushort* ilist);
void pfGeoSet::quickSetMultiAttr(int attr, int index,
void* alist, ushort* ilist);
Page 80
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfGeoSet::quickSetPrimLengths(int *lengths);
void pfGeoSet::quickReset(int extRefOnly);
void pfGeoSet::draw();
void pfGeoSet::drawBB();
void pfGeoSet::compile();
int pfGeoSet::query(uint which, void *dst)const;
int pfGeoSet::mQuery(uint *which, void *dst)const;
int pfGeoSet::isect(pfSegSet *segSet, pfHit **hits[]);
void pfGeoSet::drawHlightOnly();
void pfGeoSet::setPassFilter(uint mask);
uint pfGeoSet::getPassFilter();
pfHit C++ API
These routines support the testing of intersections of line segments with
geometry in pfGeoSets.
pfType* pfHit::getClassType();
int pfHit::query(uint which, void *dst)const;
int pfHit::mQuery(uint *which, void *dst)const;
pfHits C++ API
pfType* pfHits::getClassType();
int pfHits::checkNewProcess(int *outPidIndex);
void pfHits::reset(pfSegSet *segSet, pfHit **hits[]);
void pfHits::add(pfSegSet *segSet, pfHit **hits[], pfHit *newHit,
int segmentId);
int pfHits::getNofHits(pfSegSet *segSet, pfHit **hits[]);
pfHit* pfHits::getSpareHitAtom();
pfVertexAttr C++ API
new(void *arena)
pfVertexAttr(pfGeoArray *parent, int attrType);
void pfVertexAttr::setName(char *name);
char* pfVertexAttr::getName()const;
pfFunc pfVertexAttr::getGLFunc()const;
GLenum pfVertexAttr::getClientState()const;
ushort pfVertexAttr::getMask()const;
short pfVertexAttr::getInstance()const;
short pfVertexAttr::getMaskOff()const;
void* pfVertexAttr::getPtr()const;
GLsizei pfVertexAttr::getStride()const;
GLenum pfVertexAttr::getDataType()const;
short pfVertexAttr::getSize()const;
void pfVertexAttr::setPtr(void *data);
void pfVertexAttr::setStride(GLsizei stride);
void pfVertexAttr::setDataType(GLenum type);
void pfVertexAttr::setSize(short size);
void pfVertexAttr::setAll(void *ptr, GLsizei stride,
GLenum type, short size);
int pfVertexAttr::copy(const pfVertexAttr *src);
Page 81
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfVertexAttr::compare(const pfVertexAttr *obj)const;
pfGeoArray C++ API
new(void *arena)
pfGeoArray();
pfType* pfGeoArray::getClassType();
pfVertexAttr* pfGeoArray::addAttrType(int type, char* name, int stage);
pfVertexAttr* pfGeoArray::queryAttrType(char *name)const;
pfVertexAttr* pfGeoArray::queryAttrType(int attrType)const;
pfVertexAttr* pfGeoArray::queryAttrType(int attrType, int inst)const;
int pfGeoArray::getNumAttrsOfType(int attrType)const;
void pfGeoArray::addAttr(pfVertexAttr *ai, int size,
GLenum type, GLsizei stride, void *ptr);
void pfGeoArray::setAttr(int attr, int bind, void* alist,
ushort* ilist);
void pfGeoArray::setMultiAttr(int attr, int index, int bind,
void* alist, ushort* ilist);
int pfGeoArray::getAttrBind(int attr)const;
int pfGeoArray::getMultiAttrBind(int attr, int index)const;
void pfGeoArray::getAttrLists(int attr, void** alist,
ushort** ilist)const;
void pfGeoArray::getMultiAttrLists(int attr, int index,
void** alist, ushort** ilist)const;
int pfGeoArray::getAttrRange(int attr, int *min,
int *max)const;
int pfGeoArray::getMultiAttrRange(int attr, int index,
int *min, int *max)const;
pfVertexAttr* pfGeoArray::setAttr(int attrType, int size, GLenum type,
GLenum stride, void *ptr);
pfVertexAttr* pfGeoArray::setMultiAttr(int attrType, int stage,
int size, GLenum type, GLenum stride, void *ptr);
void pfGeoArray::removeAttr(pfVertexAttr *ai);
void pfGeoArray::disableAttr(pfVertexAttr *ai);
void pfGeoArray::enableAttr(pfVertexAttr *ai);
void pfGeoArray::setIndexArray(uint *iarray);
void pfGeoArray::setIndexArray(ushort *iarray);
void pfGeoArray::setIndexArray(uchar *iarray);
uint* pfGeoArray::getIndexArray()const;
GLenum pfGeoArray::getIndexArrayType()const;
void pfGeoArray::allowCache(int x);
void pfGeoArray::updateData();
int pfGeoArray::getNumAttrs()const;
pfVertexAttr* pfGeoArray::getNthAttr(int n)const;
int pfGeoArray::isStandardArray(pfVertexAttr *ai, int *gtype,
int *gindex);
int pfGeoArray::getArrayMemSize(pfVertexAttr *ai,
int *elemSize);
void pfGeoArray::setDrawIndex();
int pfGeoArray::XformAttr(GLenum attrType, int ptType,
pfMatrix *xform);
Page 82
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfGeoArray::setupCoords(pfGeoArray *dis);
void pfGeoArray::cleanupCoords(pfGeoArray *dis);
DLLEXPORT pfGeoState*
pfGetCurGState(void);
DLLEXPORT pfGeoState*
pfGetCurIndexedGState(int index);
DLLEXPORT pfList*
pfGetCurGStateTable(void);
pfGeoState C++ API
pfGeoState is an encapsulation of libpr graphics modes and attributes,
and is normally bound to pfGeoSets. The pfGeoState represents a complete
graphics state, allowing IRIS Performer to draw pfGeoSets in an arbitrary
order and evaluate state changes in a lazy fashion to reduce overhead
caused by changing graphics state.
new(void *arena)
pfGeoState();
pfType* pfGeoState::getClassType();
void pfGeoState::setMode(uint64_t attr, int a);
int pfGeoState::getMode(uint64_t attr)const;
int pfGeoState::getCurMode(uint64_t attr)const;
int pfGeoState::getCombinedMode(uint64_t attr,
const pfGeoState *combState)const;
void pfGeoState::setMultiMode(uint64_t attr, int index, int a);
int pfGeoState::getMultiMode(uint64_t attr, int index)const;
int pfGeoState::getCurMultiMode(uint64_t attr,
int index)const;
int pfGeoState::getCombinedMultiMode(uint64_t attr, int index,
const pfGeoState *combState)const;
void pfGeoState::setVal(uint64_t attr, float a);
float pfGeoState::getVal(uint64_t attr)const;
float pfGeoState::getCurVal(uint64_t attr)const;
float pfGeoState::getCombinedVal(uint64_t attr,
const pfGeoState *combState)const;
void pfGeoState::setMultiVal(uint64_t attr, float *values);
int pfGeoState::getMultiVal(uint64_t attr, float *values);
int pfGeoState::getCurMultiVal(uint64_t attr, float *values);
void pfGeoState::setInherit(uint64_t mask);
uint64_t pfGeoState::getInherit()const;
void pfGeoState::setAttr(uint64_t attr, void* a);
void* pfGeoState::getAttr(uint64_t attr)const;
void* pfGeoState::getCurAttr(uint64_t attr)const;
void* pfGeoState::getCombinedAttr(uint64_t attr,
const pfGeoState *combState)const;
void pfGeoState::setMultiAttr(uint64_t attr, int index,
void* a);
void* pfGeoState::getMultiAttr(uint64_t attr, int index)const;
void* pfGeoState::getCurMultiAttr(uint64_t attr,
int index)const;
Page 83
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void* pfGeoState::getCombinedMultiAttr(uint64_t attr, int index,
const pfGeoState *combState)const;
int pfGeoState::getNumTextures();
void pfGeoState::load();
void pfGeoState::apply();
void pfGeoState::makeBasic();
void pfGeoState::applyTable(pfList *gstab);
DLLEXPORT pfHighlight *
pfGetCurHlight(void);
pfHighlight C++ API
IRIS Performer supports a mechanism for highlighting individual objects
in a scene with a variety of special drawing styles that are activated by
applying a pfHighlight state structure. Highlighting makes use of
outlining of lines and polygons and of filling polygons with patterned or
textured overlays.
new(void *arena)
pfHighlight();
pfType* pfHighlight::getClassType();
void pfHighlight::setMode(uint mode);
uint pfHighlight::getMode()const;
pfGeoState* pfHighlight::getGState()const;
void pfHighlight::setGState(pfGeoState *gstate);
void pfHighlight::setGStateIndex(int id);
int pfHighlight::getGStateIndex()const;
void pfHighlight::setColor(uint which, float r, float g,
float b);
void pfHighlight::getColor(uint which, float *r, float *g,
float *b)const;
void pfHighlight::setAlpha(float a);
float pfHighlight::getAlpha()const;
void pfHighlight::setNormalLength(float len, float bboxScale);
void pfHighlight::getNormalLength(float *len,
float *bboxScale)const;
void pfHighlight::setLineWidth( float width );
float pfHighlight::getLineWidth()const;
void pfHighlight::setPntSize( float size );
float pfHighlight::getPntSize()const;
void pfHighlight::setLinePat(int which, ushort pat);
ushort pfHighlight::getLinePat(int which)const;
void pfHighlight::setFillPat( int which, uint *fillPat );
void pfHighlight::getFillPat(int which, uint *pat)const;
void pfHighlight::setTex(pfTexture *tex);
pfTexture* pfHighlight::getTex()const;
void pfHighlight::setTEnv(pfTexEnv *tev);
pfTexEnv* pfHighlight::getTEnv()const;
void pfHighlight::setTGen(pfTexGen *tgen);
pfTexGen* pfHighlight::getTGen()const;
void pfHighlight::apply();
Page 84
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT int pfGetCurLights(pfLight *lights[PF_MAX_LIGHTS]);
pfLight C++ API
A pfLight is a light source that illuminates scene geometry, generating
realistic shading effects. A pfLight cannot itself be seen but
attributes such as color, spotlight direction, and position can be set to
provide illuminative effects on scene geometry.
new(void *arena)
pfLight();
pfType* pfLight::getClassType();
void pfLight::setColor(int which, float r, float g, float b);
void pfLight::getColor(int which, float* r, float* g,
float* b)const;
void pfLight::setAmbient(float r, float g, float b);
void pfLight::getAmbient(float* r, float* g, float* b)const;
void pfLight::setPos(float x, float y, float z, float w);
void pfLight::getPos(float* x, float* y, float* z,
float* w)const;
void pfLight::setAtten(float a0, float a1, float a2);
void pfLight::getAtten(float* a0, float* a1, float* a2)const;
void pfLight::setSpotDir(float x, float y, float z);
void pfLight::getSpotDir(float* x, float* y, float* z)const;
void pfLight::setSpotCone(float f1, float f2);
void pfLight::getSpotCone(float* f1, float* f2)const;
void pfLight::setSpotCutoffDelta(float f1);
float pfLight::getSpotCutoffDelta()const;
void pfLight::on();
void pfLight::off();
int pfLight::isOn();
DLLEXPORT pfLightModel*
pfGetCurLModel(void);
pfLightModel C++ API
A pfLightModel defines characteristics of the hardware lighting model
used to illuminate geometry, such as attenuation, local vs. global
lighting model, and ambient energy.
new(void *arena)
pfLightModel();
pfType* pfLightModel::getClassType();
void pfLightModel::setLocal(int l);
int pfLightModel::getLocal()const;
void pfLightModel::setTwoSide(int t);
int pfLightModel::getTwoSide()const;
void pfLightModel::setColorControl(int c);
int pfLightModel::getColorControl()const;
void pfLightModel::setAmbient(float r, float g, float b);
void pfLightModel::getAmbient(float* r, float* g,
float* b)const;
Page 85
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfLightModel::setAtten(float a0, float a1, float a2);
void pfLightModel::getAtten(float* a0, float* a1,
float* a2)const;
void pfLightModel::apply();
DLLEXPORT pfLPointState*
pfGetCurLPState(void);
pfLPointState C++ API
A pfLPointState is a libpr data structure which, in conjunction with a
pfGeoSet of type PFGS_POINTS, supports a sophisticated light point
primitive type. Examples of light points are stars, beacons, strobes, and
taxiway lights. Light points are different from light sources in that a
pfLight is not itself visible but illuminates scene geometry, whereas a
light point is visible as a self-illuminated small point that does not
illuminate surrounding objects.
new(void *arena)
pfLPointState();
pfType* pfLPointState::getClassType();
void pfLPointState::setMode(int mode, int val);
int pfLPointState::getMode(int mode)const;
void pfLPointState::setVal(int attr, float val);
float pfLPointState::getVal(int attr)const;
void pfLPointState::setShape(float horiz, float vert,
float roll, float falloff, float ambient);
void pfLPointState::getShape(float *horiz, float *vert,
float *roll, float *falloff, float *ambient)const;
void pfLPointState::setBackColor(float r, float g, float b,
float a);
void pfLPointState::getBackColor(float *r, float *g, float *b,
float *a);
void -
pfLPointState::setRasterFunc(pfRasterFuncType rasterCallback,
void *data);
void -
pfLPointState::getRasterFunc(pfRasterFuncType *rasterCallback,
void **data);
void -
pfLPointState::setCalligFunc(pfCalligFuncType calligraphicCallback,
void *data);
void -
pfLPointState::getCalligFunc(pfCalligFuncType *calligraphicCallback,
void **data);
void pfLPointState::apply();
void pfLPointState::makeRangeTex(pfTexture *tex, int size,
pfFog* fog);
void pfLPointState::makeShapeTex(pfTexture *tex, int size);
DLLEXPORT pfMaterial*
pfGetCurMtl(int side);
Page 86
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfMaterial C++ API
In conjunction with other lighting parameters, a pfMaterial defines the
appearance of illuminated geometry. A pfMaterial defines the reflectance
characteristics of surfaces such as diffuse color and shininess.
new(void *arena)
pfMaterial();
pfType* pfMaterial::getClassType();
void pfMaterial::setSide(int side);
int pfMaterial::getSide();
void pfMaterial::setAlpha(float alpha);
float pfMaterial::getAlpha();
void pfMaterial::setShininess(float shininess);
float pfMaterial::getShininess();
void pfMaterial::setColor(int acolor, float r, float g,
float b);
void pfMaterial::getColor(int acolor, float* r, float* g,
float* b);
void pfMaterial::setColorMode(int side, int mode);
int pfMaterial::getColorMode(int side);
void pfMaterial::apply();
void pfMaterial::fullCopy(pfMaterial *src);
DLLEXPORT pfSprite*
pfGetCurSprite(void);
pfSprite C++ API
pfSprite is an intelligent transformation and is logically grouped with
other libpr transformation primitives like pfMultMatrix. pfSprite
rotates geometry orthogonal to the viewer, so the viewer only sees the
"front" of the model. As a result, complexity is saved in the model by
omitting the "back" geometry. A further performance enhancement is to
incorporate visual complexity in a texture map rather than in geometry.
Thus, on machines with fast texture mapping, sprites can present very
complex images with very little geometry. Classic examples of textured
sprites use a single quadrilateral that when rotated about a vertical
axis simulate trees and when rotated about a point simulate clouds or
puffs of smoke.
new(void *arena)
pfSprite();
pfType* pfSprite::getClassType();
void pfSprite::setMode(int which, int val);
int pfSprite::getMode(int which)const;
void pfSprite::setAxis(float x, float y, float z);
void pfSprite::getAxis(float *x, float *y, float *z);
void pfSprite::begin();
void pfSprite::end();
void pfSprite::position(float x, float y, float z);
DLLEXPORT void pfInitState(usptr_t* arena);
DLLEXPORT pfState*
pfGetCurState(void);
Page 87
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
DLLEXPORT void pfPushState(void);
DLLEXPORT void pfPopState(void);
DLLEXPORT void pfGetState(pfGeoState *gstate);
DLLEXPORT void pfFlushState(void);
DLLEXPORT void pfBasicState(void);
DLLEXPORT void pfOverride(uint64_t mask, int val);
DLLEXPORT uint64_t
pfGetOverride(void);
DLLEXPORT void pfModelMat(pfMatrix mat);
DLLEXPORT void pfGetModelMat(pfMatrix mat);
DLLEXPORT void pfViewMat(pfMatrix mat);
DLLEXPORT void pfGetViewMat(pfMatrix mat);
DLLEXPORT void pfInvViewMat(pfMatrix mat);
DLLEXPORT void pfGetInvViewMat(pfMatrix mat);
DLLEXPORT void pfProjMat(pfMatrix mat);
DLLEXPORT void pfGetProjMat(pfMatrix mat);
DLLEXPORT void pfTexMat(pfMatrix mat);
DLLEXPORT void pfGetTexMat(pfMatrix mat);
DLLEXPORT void pfInvModelMat(pfMatrix mat);
DLLEXPORT void pfGetInvModelMat(pfMatrix mat);
DLLEXPORT void pfPixScale(float pscale);
DLLEXPORT float
pfGetPixScale(void);
DLLEXPORT void pfNearPixDist(float pd);
DLLEXPORT float
pfGetNearPixDist(void);
pfState C++ API
IRIS Performer manages a subset of the graphics library state for
convenience and improved performance, and thus provides its own API for
manipulating graphics state such as transparency, antialiasing, or fog.
Attributes not set within a pfGeoState are inherited from the pfState.
new(void *arena)
pfState();
pfType* pfState::getClassType();
void pfState::select();
void pfState::load();
void pfState::attach(pfState *state1);
pfString C++ API
pfString provides a pfGeoSet like facility for encapsulating geometry to
display a string in 3-D with attributes such as color, arbitrary
transformation matrix, and font (see pfFont).
new(void *arena)
pfString();
pfType* pfString::getClassType();
size_t pfString::getStringLength()const;
void pfString::setMode(int mode, int val);
Page 88
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfString::getMode(int mode)const;
void pfString::setFont(pfFont* fnt);
pfFont* pfString::getFont()const;
void pfString::setString(const char* cstr);
const char* pfString::getString()const;
const pfGeoSet*
pfString::getCharGSet(int index)const;
const pfVec3* pfString::getCharPos(int index)const;
void pfString::setSpacingScale(float sx, float sy, float sz);
void pfString::getSpacingScale(float *sx, float *sy,
float *sz)const;
void pfString::setGState(pfGeoState *gs);
pfGeoState* pfString::getGState()const;
void pfString::setColor(float r, float g, float b, float a);
void pfString::getColor(float *r, float *g, float *b,
float *a)const;
void pfString::setBBox(const pfBox* newbox);
const pfBox* pfString::getBBox()const;
void pfString::setMat(const pfMatrix & mat);
void pfString::getMat(pfMatrix & mat)const;
void pfString::setIsectMask(uint mask, int setMode, int bitOp);
uint pfString::getIsectMask()const;
void pfString::draw();
void pfString::flatten();
int pfString::isect(pfSegSet *segSet, pfHit **hits[]);
DLLEXPORT pfTexture*
pfGetCurTex(void);
DLLEXPORT void pfTexBorderColor(pfTexture* tex, pfVec4 clr);
pfTexture C++ API
pfTexture encapsulates texturing data and attributes such as the texture
image itself, the texture data format and the filters for proximity and
distance.
new(void *arena)
pfTexture();
pfType* pfTexture::getClassType();
void pfTexture::setName(const char *name);
void pfTexture::setMultiName(const char *name, int imageIndex);
const char* pfTexture::getName()const;
const char* pfTexture::getMultiName(int imageIndex);
void pfTexture::setImage(uint* image, int comp, int sx, int sy,
int sz);
void pfTexture::setCompressedImage(uint* image, int comp,
int sx, int sy, int sz, int compressedSize);
void pfTexture::setMultiImage(uint* image, int imageIndex,
int comp, int sx, int sy, int sz);
void pfTexture::setMultiCompressedImage(uint* image,
int imageIndex, int comp, int sx, int sy, int sz,
int compressedSize);
Page 89
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfTexture::getImage(uint** image, int* comp, int* sx,
int* sy, int* sz)const;
void pfTexture::getCompressedImage(uint** image, int* comp,
int* sx, int* sy, int* sz, int* compressedSize)const;
void pfTexture::getMultiImage(uint** image, int imageIndex,
int* comp, int* sx, int* sy, int* sz)const;
void pfTexture::getMultiCompressedImage(uint** image,
int imageIndex, int* comp, int* sx, int* sy, int* sz,
int* compressedSize)const;
void pfTexture::compressImage(int imageIndex, int intformat,
int flags);
void pfTexture::getBorderColor(pfVec4 *clr);
void pfTexture::setBorderType(int type);
int pfTexture::getBorderType();
void pfTexture::setFormat(int format, int type);
int pfTexture::getFormat(int format)const;
void pfTexture::setFilter(int filt, int type);
int pfTexture::getFilter(int filt)const;
void pfTexture::setRepeat(int wrap, int type);
int pfTexture::getRepeat(int wrap)const;
void pfTexture::setLODRange(float min, float max);
void pfTexture::getLODRange(float *min, float *max);
void pfTexture::setLODBias(float biasS, float biasT,
float biasR);
void pfTexture::getLODBias(float *biasS, float *biasT,
float *biasR);
void pfTexture::setSpline(int type, pfVec2 *pts, float clamp);
void pfTexture::getSpline(int type, pfVec2 *pts,
float *clamp)const;
void pfTexture::setDetail(int l, pfTexture *detail);
void pfTexture::getDetail(int *l, pfTexture **detail)const;
pfTexture* pfTexture::getDetailTex()const;
void pfTexture::setDetailTexTile(int j, int k, int m, int n,
int scram);
void pfTexture::getDetailTexTile(int *j, int *k, int *m,
int *n, int *scram)const;
void pfTexture::setList(pfList *list);
pfList* pfTexture::getList()const;
void pfTexture::setFrame(float frame);
float pfTexture::getFrame()const;
void pfTexture::setLoadImage(uint* image);
uint* pfTexture::getLoadImage()const;
void pfTexture::setLoadMode(int mode, int val);
int pfTexture::getLoadMode(int mode)const;
void pfTexture::setLoadVal(int mode, void* val);
void* pfTexture::getLoadVal(int mode)const;
void pfTexture::setLevel(int level, pfTexture* ltex);
pfTexture* pfTexture::getLevel(int level);
void pfTexture::setLoadOrigin(int which, int xo, int yo);
void pfTexture::getLoadOrigin(int which, int *xo, int *yo);
Page 90
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfTexture::setLoadSize(int xs, int ys);
void pfTexture::getLoadSize(int *xs, int *ys)const;
void pfTexture::setValidMap(pfTextureValidMap *validMap);
pfTextureValidMap*
pfTexture::getValidMap()const;
void pfTexture::getCurLODRange(float *min, float *max);
void pfTexture::getCurLODBias(float *biasS, float *biasT,
float *biasR);
void pfTexture::setAnisotropy(const int degree);
int pfTexture::getAnisotropy()const;
void pfTexture::apply();
void pfTexture::multiApply(int myID);
void pfTexture::applyMinLOD(float min);
void pfTexture::applyMaxLOD(float max);
void pfTexture::applyLODBias(float biasS, float biasT,
float biasR);
void pfTexture::format();
void pfTexture::load();
void pfTexture::loadLevel(int level);
void pfTexture::subload(int source, uint *image, int xsrc,
int ysrc, int srcwid, int xdst, int ydst, int xsize,
int ysize);
void pfTexture::subloadMulti(int source, uint *image,
int imageIndex, int xsrc, int ysrc, int srcwid,
int xdst, int ydst, int xsize, int ysize);
void pfTexture::subloadLevel(int source, uint *image, int xsrc,
int ysrc, int srcwid, int xdst, int ydst, int xsize,
int ysize, int level);
void pfTexture::subloadMultiLevel(int source, uint *image,
int imageIndex, int xsrc, int ysrc, int srcwid,
int xdst, int ydst, int xsize, int ysize, int level);
int pfTexture::loadFile(const char* fname);
int pfTexture::loadMultiFile(const char* fname,
int imageIndex);
int pfTexture::saveFile(const char* fname);
int pfTexture::saveMultiFile(const char* fname,
int imageIndex);
int pfTexture::saveFileType(const char* fname,
const char* type);
int pfTexture::saveMultiFileType(const char* fname,
int imageIndex, const char* type);
void pfTexture::freeImage();
void pfTexture::idle();
int pfTexture::isLoaded()const;
int pfTexture::isFormatted()const;
DLLEXPORT pfTexEnv*
pfGetCurTEnv(void);
pfTexEnv C++ API
pfTexEnv encapsulates the texture environment and how the texture should
interact with the colors of the geometry to which it is bound, i.e. how
graphics coordinates are transformed into texture coordinates.
Page 91
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new(void *arena)
pfTexEnv();
pfType* pfTexEnv::getClassType();
void pfTexEnv::setMode(int mode);
int pfTexEnv::getMode()const;
void pfTexEnv::setComponent(int comp);
int pfTexEnv::getComponent()const;
void pfTexEnv::setBlendColor(float r, float g, float b,
float a);
void pfTexEnv::getBlendColor(float* r, float* g, float* b,
float* a);
void pfTexEnv::apply();
void pfTexEnv::multiApply(int myID);
DLLEXPORT pfTexGen*
pfGetCurTGen(void);
pfTexGen C++ API
The pfTexGen capability is used to automatically generate texture
coordinates for geometry, typically for special effects like projected
texture, reflection mapping, and lightpoints (see pfLPointState).
new(void *arena)
pfTexGen();
pfType* pfTexGen::getClassType();
void pfTexGen::setMode(int texCoord, int mode);
int pfTexGen::getMode(int texCoord)const;
void pfTexGen::setPoint(int texCoord, float x, float y,
float z, float dx, float dy, float dz);
void pfTexGen::getPoint(int texCoord, float *x, float *y,
float *z);
void pfTexGen::setPlane(int texCoord, float x, float y,
float z, float d);
void pfTexGen::getPlane(int texCoord, float* x, float* y,
float* z, float* d);
void pfTexGen::apply();
void pfTexGen::multiApply(int myID);
DLLEXPORT pfTexLOD*
pfGetCurTLOD(void);
pfTexLOD C++ API
A pfTexLOD object is a libpr state attribute used to control (limit or
bias) the use of levels of detail within a MIP-map or Clipmap pfTexture.
The levels of detail within the texture that are accessed can be limited
by setting the pfTexLOD's LOD range. Further, the computation of the
current LOD value can be biased towards more or less sharp resolution set
levels in associated pfTexture. These controls are useful in conjunction
with dynamic texture loading where the accessed levels can be limited to
the levels actually loaded, and also for artificially blurring or
sharpening a texture as might be used in simulating rain or depth-of-
field effects.
Page 92
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new(void *arena)
pfTexLOD();
pfType* pfTexLOD::getClassType();
void pfTexLOD::setRange(float min, float max);
void pfTexLOD::getRange(float *min, float *max);
void pfTexLOD::setBias(float biasS, float biasT, float biasR);
void pfTexLOD::getBias(float *biasS, float *biasT,
float *biasR);
void pfTexLOD::apply();
void pfTexLOD::multiApply(int myID);
pfTextureValidMapLevel C++ API
A pfTextureValidMapLevel is a piece of a pfTextureValidMap, representing
a particular mipmap level.
pfTextureValidMap C++ API
A pfTextureValidMap is an object that can be attached to a pfTexture. It
keeps track in main memory of which portions of a texture are currently
loaded in texture memory. This can be useful for debugging, verifying
that a desired rectangle of texels has actually been downloaded, when the
downloadeding may have been done in many little pieces.
new(void *arena)
pfTextureValidMap(int virtSizeS, int virtSizeT,
int mapSizeS, int mapSizeT, int clipSizeS,
int clipSizeT, int quantumS, int quantumT);
void pfTextureValidMap::construct(int virtSizeS, int virtSizeT,
int mapSizeS, int mapSizeT, int clipSizeS,
int clipSizeT, int quantumS, int quantumT,
void *arena);
void pfTextureValidMap::destruct();
void pfTextureValidMap::recordTexLoad(int level, int s0,
int t0, int ns, int nt);
void pfTextureValidMap::setTracing(int tracing);
void pfTextureValidMap::print(FILE *fp, int minLevelSize,
int maxLevelSize);
int pfTextureValidMap::isValidCenter(int centerS, int centerT,
int invalidBorder, int verbose);
int pfTextureValidMap::isValid(int level, int s0, int t0,
int ns, int nt);
pfGProgram C++ API
new(void *arena)
pfGProgram();
pfType* pfGProgram::getClassType();
int pfGProgram::loadProgram(const char *filename);
void pfGProgram::setProgram(const char *code);
void pfGProgram::setProgram(const char *code, int length);
Page 93
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfGProgram::getProgram(char **code)const;
int pfGProgram::getProgramLength();
int pfGProgram::getNativeProgramLength();
int pfGProgram::isValid();
void pfGProgram::apply();
pfGProgramParms C++ API
new(void *arena)
pfGProgramParms(int ptype);
pfType* pfGProgramParms::getClassType();
void pfGProgramParms::apply();
void pfGProgramParms::setParameters(int index, int type,
int count, void* ptr);
void pfGProgramParms::update();
void pfGProgramParms::freeIndex(int ix);
int pfGProgramParms::getNumParameters();
void pfGProgramParms::getParameters(int i, int *ix, int *type,
int *count, void **v);
void pfGProgramParms::getParametersByIndex(int ix, int *type,
int *count, void **v);
int pfGProgramParms::getType();
pfVertexProgram C++ API
new(void *arena)
pfVertexProgram();
pfType* pfVertexProgram::getClassType();
pfFragmentProgram C++ API
new(void *arena)
pfFragmentProgram();
pfType* pfFragmentProgram::getClassType();
pfShaderObject C++ API
new(void *arena)
pfShaderObject();
int pfShaderObject::getShaderType()const;
void pfShaderObject::setShaderType(int shdType);
const char* pfShaderObject::getName()const;
void pfShaderObject::setName(const char *name);
void pfShaderObject::load();
void pfShaderObject::setSource(GLcharARB *src);
void pfShaderObject::setSource(GLint numStrings,
const GLcharARB **src, GLint *lengths);
char* pfShaderObject::getSource()const;
int pfShaderObject::getCompileStatus()const;
GLhandleARB pfShaderObject::getHandle()const;
int pfShaderObject::getAttr(int what)const;
int pfShaderObject::compare(const pfMemory *mem)const;
int pfShaderObject::copy(const pfMemory *src);
pfType* pfShaderObject::getClassType();
Page 94
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfShaderProgram C++ API
new(void *arena)
pfShaderProgram();
void pfShaderProgram::addShader(pfShaderObject *shader);
int pfShaderProgram::getNumShaders();
pfShaderObject*
pfShaderProgram::getShader(int i);
void pfShaderProgram::removeShader(pfShaderObject *shader);
void pfShaderProgram::replaceShader(pfShaderObject *old,
pfShaderObject *new);
void pfShaderProgram::replaceShader(int i,
pfShaderObject *replacement);
void pfShaderProgram::apply();
GLboolean pfShaderProgram::validate();
GLhandleARB pfShaderProgram::getHandle()const;
GLint pfShaderProgram::findUniform(const GLcharARB *name);
GLint pfShaderProgram::addUniform(const GLcharARB *name,
uint uniType, int size, void *data);
void pfShaderProgram::setUniform(GLint whichOne, void *data);
GLint pfShaderProgram::getUniformDataSize(GLint whichOne)const;
int pfShaderProgram::getNumUniforms();
void* pfShaderProgram::getUniformData(int whichOne);
char* pfShaderProgram::getUniformName(int whichOne);
int pfShaderProgram::getUniformNumVals(int whichOne);
int pfShaderProgram::getUniformType(int whichOne);
char pfShaderProgram::getUniformClampMode(int whichOne)const;
void pfShaderProgram::setUniformClampMode(int whichOne,
char clampMode);
void* pfShaderProgram::getUniformMin(int whichOne)const;
void* pfShaderProgram::getUniformMax(int whichOne)const;
void pfShaderProgram::setUniformMin(int whichOne, void *data);
void pfShaderProgram::setUniformMax(int whichOne, void *data);
char -
pfShaderProgram::getUniformNormalizedFlag(int whichOne)const;
void pfShaderProgram::setUniformNormalizedFlag(int whichOne,
char onOrOff);
int pfShaderProgram::compare(const pfMemory *mem)const;
int pfShaderProgram::copy(const pfMemory *src);
pfType* pfShaderProgram::getClassType();
int pfShaderProgram::getUniTypeSize(int uniType);
pfCycleMemory C++ API
The pfCycleMemory data type is the low-level memory object used by
pfCycleBuffers to provide the illusion of a single block of memory that
can have a different value for each process that references it at one
instant in time. For example, a pfGeoSet might have vertex position,
normal, color, or texture arrays that are being morphed in process A,
culled in process B, drawn in process C, and intersected with in process
D, all with different values due to temporal reasons. Refer to the
pfCycleBuffer overview for a description of how the two features work in
concert.
Page 95
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfType* pfCycleMemory::getClassType();
pfCycleBuffer* pfCycleMemory::getCBuffer();
int pfCycleMemory::getFrame()const;
pfCycleBuffer C++ API
pfCycleBuffer supports efficient management of dynamically modified data
in a multi-stage multiprocessed pipeline. A pfCycleBuffer logically
contains multiple pfCycleMemorys. Each process has a global index which
selects the currently active pfCycleMemory in each pfCycleBuffer. This
index can be advanced once a frame by pfCycleBuffer::setCurIndex so that
the buffers "cycle". By advancing the index appropriately in each
pipeline stage, dynamic data can be frame-accurately propagated down the
pipeline.
new(void *arena)
pfCycleBuffer(size_t nbytes);
pfType* pfCycleBuffer::getClassType();
pfCycleMemory* pfCycleBuffer::getCMem(int index)const;
void* pfCycleBuffer::getCurData()const;
void pfCycleBuffer::changed();
void pfCycleBuffer::init(void *data);
int pfCycleBuffer::config(int numBuffers);
int pfCycleBuffer::getConfig();
int pfCycleBuffer::frame();
int pfCycleBuffer::getFrameCount();
int pfCycleBuffer::getCurIndex();
void pfCycleBuffer::setCurIndex(int index);
pfCycleBuffer* pfCycleBuffer::getCBuffer(void *data);
pfFluxMemory C++ API
The pfFluxMemory data type is the low-level memory object used by
pfFluxes to provide multibuffering for a block of memory for asynchronous
accessing processes. pfFluxMemory is often used for arrays of morphing
vertex attribute data. Refer to the pfFlux overview for a complete
description.
pfType* pfFluxMemory::getClassType();
pfFluxMemory* pfFluxMemory::getFluxMemory(void *data);
pfFlux* pfFluxMemory::getFlux();
pfFlux C++ API
A pfFlux is a container for dynamic data. It can hold multiple copies of
the data so that each Performer process can each have a copy of the data
that is appropriate to the frame they are working on.
new(void *arena)
pfFlux(size_t nbytes, int numBuffers);
new(void *arena)
pfFlux(pfFluxInitFuncType initFunc, int numBuffers);
pfType* pfFlux::getClassType();
Page 96
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void* pfFlux::getCurData();
void* pfFlux::getWritableData();
void* pfFlux::getBufferData(int bufferid);
void pfFlux::setMode(int mode, int val);
int pfFlux::getMode(int mode)const;
void pfFlux::setMask(uint mask);
uint pfFlux::getMask()const;
void pfFlux::setSyncGroup(uint syncGroup);
uint pfFlux::getSyncGroup()const;
size_t pfFlux::getDataSize()const;
int pfFlux::getNumBuffers(int type)const;
pfFluxInitFuncType
pfFlux::getInitFunc()const;
pfEngine* pfFlux::getSrcEngine(int index)const;
int pfFlux::getNumSrcEngines()const;
pfEngine* pfFlux::getClientEngine(int index)const;
int pfFlux::getNumClientEngines()const;
void pfFlux::setUserCopyFunc(pfFluxUserCopyFuncType func);
pfFluxUserCopyFuncType
pfFlux::getUserCopyFunc();
void pfFlux::writeComplete();
void pfFlux::srcChanged();
void pfFlux::initData(void *data);
void pfFlux::callDataFunc(pfFluxDataFuncType func,
void *funcData);
void pfFlux::evaluate(int mask);
void pfFlux::evaluate(int mask, pfVec3 eye_pos);
int pfFlux::setDefaultNumBuffers(int numBuffers);
int pfFlux::getDefaultNumBuffers();
pfFlux* pfFlux::getFlux(void *data);
void* pfFlux::getCurData(void *data);
void* pfFlux::getWritableData(void *data);
void pfFlux::writeComplete(void *data);
void pfFlux::setFrame(int frame);
void pfFlux::keepFrame(int frame);
void pfFlux::shiftFrameByPID(pid_t pid, int frame);
int pfFlux::getFrame();
void pfFlux::enableSyncGroup(uint syncGroup);
void pfFlux::disableSyncGroup(uint syncGroup);
int pfFlux::getEnableSyncGroup(uint syncGroup);
void pfFlux::syncGroupReady(uint syncGroup);
void pfFlux::syncComplete();
int pfFlux::getNamedSyncGroup(const char *name);
const char* pfFlux::getSyncGroupName(uint syncGroup);
int pfFlux::getNumNamedSyncGroups();
pfEngine C++ API
pfEngine is a generator dynamic data. From a set of sources a pfEngine
calculates a new set of values for a destination. There are a number of
predefined functions available, as well as the ability to define your own
functions.
Page 97
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
new(void *arena)
pfEngine(int function);
pfType* pfEngine::getClassType();
void pfEngine::setSrc(int index, void *data, ushort *ilist,
int icount, int offset, int stride);
void pfEngine::getSrc(int index, void **data, ushort **ilist,
int *icount, int *offset, int *stride)const;
int pfEngine::getNumSrcs()const;
void pfEngine::setDst(void *data, ushort *ilist, int offset,
int stride);
void pfEngine::getDst(void **data, ushort **ilist, int *offset,
int *stride)const;
void pfEngine::setIterations(int iterations, int itemsPer);
void pfEngine::getIterations(int *iterations,
int *itemsPer)const;
int pfEngine::getFunction()const;
void pfEngine::setUserFunction(pfEngineFuncType func);
pfEngineFuncType
pfEngine::getUserFunction()const;
void pfEngine::setMode(int mode, int val);
int pfEngine::getMode(int mode)const;
void pfEngine::setMask(uint mask);
uint pfEngine::getMask()const;
void pfEngine::setEvaluationRange(pfVec3& center, float min,
float max);
void pfEngine::getEvaluationRange(pfVec3& center, float *min,
float *max)const;
void pfEngine::srcChanged();
void pfEngine::evaluate(int mask);
void pfEngine::evaluate(int mask, pfVec3 eye_pos);
pfMemory C++ API
A pfMemory is the data type from which the major IRIS Performer types are
derived and also provides the primary mechanism for allocating memory
used by pfMalloc.
pfType* pfMemory::getClassType();
int pfMemory::getArenaBytesUsed();
void* pfMemory::malloc(size_t nbytes, void *arena);
void* pfMemory::calloc(size_t numelem, size_t elsize,
void *arena);
char* pfMemory::strdup(const char *str, void *arena);
void* pfMemory::memalign(size_t nbytes, void *arena);
void* pfMemory::realloc(void *data, size_t nbytes);
size_t pfMemory::getSize(void *data);
size_t pfMemory::getSizeFromData(void *data);
void* pfMemory::getArena(void *data);
void* pfMemory::getArenaFromData(void *data);
void pfMemory::free(void *data);
void* pfMemory::getData(const void *data);
Page 98
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfMemory* pfMemory::getMemory(const void *data);
pfMemory* pfMemory::getMemoryFromData(const void *data);
const char* pfMemory::getTypeName(const void *data);
const char* pfMemory::getTypeNameFromData(const void *data);
pfType* pfMemory::getType(const void *data);
pfType* pfMemory::getTypeFromData(const void *data);
int pfMemory::isOfType(const void *data, pfType *type);
int pfMemory::isOfTypeFromData(const void *data,
pfType *type);
int pfMemory::isExactType(const void *data, pfType *type);
int pfMemory::isExactTypeFromData(const void *data,
pfType *type);
int pfMemory::isFluxed(const void *data);
int pfMemory::isFluxedFromData(const void *data);
int pfMemory::ref(void* mem);
int pfMemory::refFromData(void* mem);
int pfMemory::unref(void* mem);
int pfMemory::unrefFromData(void* mem);
int pfMemory::getRef(const void* mem);
int pfMemory::getRefFromData(const void* mem);
int pfMemory::compare(const void* mem1, const void* mem2);
int pfMemory::compareFromData(const void* mem1,
const void* mem2);
int pfMemory::print(const void* mem, uint travMode,
uint verbose, FILE* file);
int pfMemory::printFromData(const void* mem, uint travMode,
uint verbose, FILE* file);
int pfMemory::checkDelete(void* mem);
int pfMemory::checkDeleteFromData(void* mem);
int pfMemory::unrefGetRef(void* mem);
int pfMemory::unrefGetRefFromData(void* mem);
int pfMemory::unrefDelete(void* mem);
int pfMemory::unrefDeleteFromData(void* mem);
int pfMemory::copy(void* dst, const void* src);
int pfMemory::copyFromData(void* dst, const void* src);
DLLEXPORT pfFile*
pfOpenFile(char* fname, int oflag,
pfFile C++ API
pfFile provides a non-blocking, multiprocessing mechanism for file I/O
with a similar interface to the standard UNIX file I/O functions. The
difference is that these routines return immediately without blocking
while the physical file-system access operation completes and also that
instead of an integer file descriptor, a pfFile handle is used.
pfFile* pfFile::create(char* fname, mode_t mode);
pfType* pfFile::getClassType();
int pfFile::getStatus(int attr)const;
int pfFile::read(char* buf, int nbyte);
int pfFile::write(char* buf, int nbyte);
Page 99
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
off_t pfFile::seek(off_t off, int whence);
int pfFile::close();
pfList C++ API
A pfList is a dynamically-sized array of arbitrary, but homogeneously-
sized, elements. IRIS Performer provides the facility to create,
manipulate, and search a pfList.
new(void *arena)
pfList(int eltSize, int listLength);
pfType* pfList::getClassType();
int pfList::getEltSize()const;
void** pfList::getArray()const;
void pfList::setArrayLen(int alen);
int pfList::getArrayLen()const;
void pfList::setNum(int newNum);
int pfList::getNum()const;
void pfList::set(int index, void *elt);
void* pfList::get(int index)const;
void pfList::reset();
void pfList::combine(const pfList *a, const pfList *b);
void pfList::add(void *elt);
void* pfList::rem();
void pfList::insert(int index, void *elt);
int pfList::search(void *elt)const;
int pfList::remove(void *elt);
void pfList::removeIndex(int index);
int pfList::move(int index, void *elt);
int pfList::fastRemove(void *elt);
void pfList::fastRemoveIndex(int index);
int pfList::replace(void *oldElt, void *newElt);
pfMigrator C++ API
pfType* pfMigrator::getClassType();
void pfMigrator::migrate(char* vaddr, size_t size, int cpuId);
void pfMigrator::migrate(char* vaddr, size_t size, char *nodeName);
void pfMigrator::migrate(char* vaddr, size_t size, int numCPUS,
int *cpuId);
void pfMigrator::migrate(char* vaddr, size_t size, int numNodes,
char **nodeName);
char* pfMigrator::getNodeName(int cpuId);
int pfMigrator::getNumNodes();
int pfMigrator::getNumCPUs();
pfReplicaMemory C++ API
pfType* pfReplicaMemory::getClassType();
pfReplicaMemory*
pfReplicaMemory::getReplicaMemory(void *data);
pfReplica* pfReplicaMemory::getReplica();
Page 100
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfReplica C++ API
new(void *arena)
pfReplica(size_t nbytes, int numBuffers);
pfType* pfReplica::getClassType();
void* pfReplica::getWritableData();
void* pfReplica::getReadableData();
size_t pfReplica::getDataSize();
int pfReplica::getNumReadBuffers();
void pfReplica::writeComplete();
void pfReplica::assignReaderCPU(int cpuID, int bufferID);
void pfReplica::placeReadableBuffer(int bufferID, int cpuID);
void pfReplica::placeReadableBuffer(int bufferID,
char *nodeName);
void pfReplica::placeReadableBuffer(int bufferID, int numCPUs,
int *cpuID);
void pfReplica::placeReadableBuffer(int bufferID, int numNodes,
char **nodeName);
void pfReplica::placeWritableBuffer(int cpuID);
void pfReplica::placeWritableBuffer(char *nodeName);
void pfReplica::placeWritableBuffer(int numCPUs, int *cpuID);
void pfReplica::placeWritableBuffer(int numNodes,
char **nodeName);
int pfReplica::loadConfigFile(char *filename);
int pfReplica::pinBuffers();
int pfReplica::unpinBuffers();
void pfReplica::realloc(size_t newSize);
pfReplica* pfReplica::getReplica(void *data);
pfWindow C++ API
These functions provide a single API for creating and managing windows
that works across the IRIS GL, IRIS GLX Mixed Mode, and OpenGL-X
environments. Window system independent types have been provided to
match the X Window System types to provide complete portability between
the IRIS GL and OpenGL-X windowing environments.
new(void *arena)
pfWindow();
pfType* pfWindow::getClassType();
void pfWindow::setName(const char *name);
const char* pfWindow::getName()const;
void pfWindow::setMode(int mode, int val);
int pfWindow::getMode(int mode)const;
void pfWindow::setWinType(uint type);
uint pfWindow::getWinType()const;
pfState* pfWindow::getCurState()const;
void pfWindow::setAspect(int x, int y);
void pfWindow::getAspect(int *x, int *y)const;
void pfWindow::setOriginSize(int xo, int yo, int xs, int ys);
void pfWindow::setOrigin(int xo, int yo);
void pfWindow::getOrigin(int *xo, int *yo)const;
Page 101
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfWindow::setSize(int xs, int ys);
void pfWindow::getSize(int *xs, int *ys)const;
void pfWindow::getScreenOrigin(int *xo, int *yo);
void pfWindow::setFullScreen();
void pfWindow::getCurOriginSize(int *xo, int *yo, int *xs,
int *ys);
void pfWindow::getCurScreenOriginSize(int *xo, int *yo,
int *xs, int *ys);
void pfWindow::setOverlayWin(pfWindow *ow);
pfWindow* pfWindow::getOverlayWin()const;
void pfWindow::setStatsWin(pfWindow *ow);
pfWindow* pfWindow::getStatsWin()const;
void pfWindow::setScreen(int s);
int pfWindow::getScreen()const;
void pfWindow::setShare(uint mode);
uint pfWindow::getShare()const;
void pfWindow::setSwapBarrier(int barrierName);
int pfWindow::getSwapBarrier();
int pfWindow::inSwapGroup();
void pfWindow::setWSWindow(pfWSConnection dsp,
pfWSWindow wsWin);
pfWSWindow pfWindow::getWSWindow()const;
void pfWindow::setWSDrawable(pfWSConnection dsp,
pfWSDrawable wsWin);
pfWSDrawable pfWindow::getWSDrawable()const;
pfWSDrawable pfWindow::getCurWSDrawable()const;
void pfWindow::setWSConnectionName(const char *name);
const char* pfWindow::getWSConnectionName()const;
void pfWindow::setFBConfigData(void *data);
void* pfWindow::getFBConfigData();
void pfWindow::setFBConfigAttrs(int *attr);
int* pfWindow::getFBConfigAttrs()const;
void pfWindow::setPixelFormatAttrs(GLint *iattrs,
GLfloat *fattrs);
void pfWindow::getPixelFormatAttrs(GLint *iattrs,
GLfloat *fattrs);
void pfWindow::setFBConfig(pfFBConfig vInfo);
pfFBConfig pfWindow::getFBConfig()const;
void pfWindow::setFBConfigId(int vId);
int pfWindow::getFBConfigId()const;
void pfWindow::setIndex(int index);
int pfWindow::getIndex()const;
pfWindow* pfWindow::getSelect();
void pfWindow::setGLCxt(pfGLContext gCxt);
pfGLContext pfWindow::getGLCxt()const;
void pfWindow::setWinList(pfList *wl);
pfList* pfWindow::getWinList()const;
void pfWindow::open();
void pfWindow::close();
void pfWindow::closeGL();
Page 102
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfWindow::attach(pfWindow *w1);
int pfWindow::detach(pfWindow *w1);
void pfWindow::attachSwapGroup(pfWindow *w1);
void pfWindow::detachSwapGroup();
pfWindow* pfWindow::select();
void pfWindow::swapBuffers();
pfFBConfig pfWindow::chooseFBConfig(int *attr);
int pfWindow::isOpen()const;
int pfWindow::isManaged()const;
int pfWindow::query(int which, int *dst);
int pfWindow::mQuery(int *which, int *dst);
pfWindow* pfWindow::openNewNoPort(const char *name, int screen);
void pfWindow::setWndClassName(char *name);
HCURSOR pfWindow::getWin32Cursor()const;
void pfWindow::setWin32Cursor(HCURSOR cursor);
pfVideoChannel C++ API
Each pfVideoChannel provides the capability to query and control the
state and output area of a hardware video channel. This support is
provided via the XSGIvc video control X extension for Silicon Graphics
platforms. This is the mechanism through which dynamic video resolution
and other video hardware features are managed.
new(void *arena)
pfVideoChannel();
pfType* pfVideoChannel::getClassType();
void pfVideoChannel::setWSWindow(pfWSWindow wsWin);
pfWSWindow pfVideoChannel::getWSWindow()const;
void pfVideoChannel::getOrigin(int *xo, int *yo);
void pfVideoChannel::getSize(int *xs, int *ys);
void pfVideoChannel::getScreenOutputOrigin(int *xo, int *yo);
void pfVideoChannel::setOutputOrigin(int xo, int yo);
void pfVideoChannel::getOutputOrigin(int *xo, int *yo);
void pfVideoChannel::setOutputSize(int xs, int ys);
void pfVideoChannel::getOutputSize(int *xs, int *ys);
void pfVideoChannel::setAreaScale(float s);
float pfVideoChannel::getAreaScale();
void pfVideoChannel::setScale(float xs, float ys);
void pfVideoChannel::getScale(float *xs, float *ys)const;
void pfVideoChannel::setMinScale(float xs, float ys);
void pfVideoChannel::getMinScale(float *xs, float *ys)const;
void pfVideoChannel::setMaxScale(float xs, float ys);
void pfVideoChannel::getMaxScale(float *xs, float *ys)const;
void pfVideoChannel::getMinDeltas(int *dx, int *dy)const;
void pfVideoChannel::setFullRect();
void pfVideoChannel::setScreen(int screen);
int pfVideoChannel::getScreen()const;
void pfVideoChannel::setId(int index);
int pfVideoChannel::getId();
void pfVideoChannel::setMode(int mode, int val);
Page 103
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfVideoChannel::getMode(int mode);
void pfVideoChannel::setCallig(pfCalligraphic *calligraphic);
pfCalligraphic*
pfVideoChannel::getCallig()const;
pfWSVideoChannelInfo
pfVideoChannel::getInfo();
void pfVideoChannel::select();
void pfVideoChannel::apply();
void pfVideoChannel::bind();
void pfVideoChannel::unbind();
int pfVideoChannel::isBound()const;
int pfVideoChannel::isActive();
DLLEXPORT void pfSelectCallig(pfCalligraphic *calligraphic);
DLLEXPORT pfCalligraphic *
pfGetCurCallig(void);
pfCalligraphic C++ API
The pfCalligraphic functions provide support for calligraphic lights, and
advanced display technique most commonly used in civil aviation training
to represent airport lights. Calligraphic support requires the
calligraphic light point OpenGL extension available only on Infinite
Reality graphics systems, a special calligraphic light point display
controller board (the LPB), physical cables between each Infinite Reality
raster manager board and the LPB, and a special calligraphy-capable
monitor or projector able to handle both swept raster images and
individually positioned lights.
new(void *arena)
pfCalligraphic();
pfType* pfCalligraphic::getClassType();
int pfCalligraphic::initBoard(int numPipe);
uint pfCalligraphic::queryBoard(int numPipe);
int pfCalligraphic::closeBoard(int numPipe);
int pfCalligraphic::isBoardInited(int numPipe);
LPB_info* pfCalligraphic::getInfo(int numPipe);
int pfCalligraphic::getDeviceId(int numPipe);
int pfCalligraphic::partition(int board, size_t *allocate,
int n);
int pfCalligraphic::waitForVME(int board);
int pfCalligraphic::waitForVISI(int board);
void pfCalligraphic::swapVME(int board);
int pfCalligraphic::getBoardMemSize(int board);
void pfCalligraphic::setZFootPrintSize(float size);
float pfCalligraphic::getZFootPrintSize();
void pfCalligraphic::setDrawTime(float time);
float pfCalligraphic::getDrawTime();
void pfCalligraphic::setFilterSize(uint sizeX, uint sizeY);
void pfCalligraphic::getFilterSize(uint *sizeX, uint *sizeY);
void pfCalligraphic::setDefocus(float defocus);
float pfCalligraphic::getDefocus();
Page 104
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfCalligraphic::setRasterDefocus(float defocus);
float pfCalligraphic::getRasterDefocus();
void pfCalligraphic::setStress(float stress);
float pfCalligraphic::getStress();
int pfCalligraphic::setChannel(int pipe, int channel);
int pfCalligraphic::getChannel(int *pipe, int *channel);
void pfCalligraphic::setWin(float xmin, float ymin,
float width, float height);
void pfCalligraphic::getWin(float *xmin, float *ymin,
float *width, float *height);
void pfCalligraphic::setMultisample(int n);
int pfCalligraphic::getMultisample();
int -
pfCalligraphic::downLoadSlewTable(pfCalligSlewTableEnum offset,
pfCalligSlewTable Slew);
int -
pfCalligraphic::upLoadSlewTable(pfCalligSlewTableEnum offset,
pfCalligSlewTable Slew);
int -
pfCalligraphic::downLoadGammaTable(pfCalligGammaTableEnum offset,
pfCalligGammaTable Gamma);
int -
pfCalligraphic::upLoadGammaTable(pfCalligGammaTableEnum offset,
pfCalligGammaTable Gamma);
void pfCalligraphic::setExposureRatio(float ratio);
float pfCalligraphic::getExposureRatio();
void pfCalligraphic::setXYSwap(int flag);
int pfCalligraphic::getXYSwap();
void pfCalligraphic::setProjMatrix(pfMatrix *projMat);
void pfCalligraphic::getProjMatrix(pfMatrix *projMat);
void pfCalligraphic::collectStats(pfStats *stats);
int pfCalligraphic::isInited();
pfCombiner C++ API
new(void *arena)
pfCombiner();
pfType* pfCombiner::getClassType();
void pfCombiner::apply();
void pfCombiner::setGeneralInput(GLenum stage, GLenum portion,
GLenum variable, GLenum input, GLenum mapping,
GLenum componentUsage);
void pfCombiner::setGeneralOutput(GLenum stage, GLenum portion,
GLenum abOutput, GLenum cdOutput, GLenum sumOutput,
GLenum scale, GLenum bias, GLboolean abDotProduct,
GLboolean cdDotProduct, GLboolean muxSum);
void pfCombiner::setFinalInput(GLenum variable, GLenum input,
GLenum mapping, GLenum componentUsage);
void pfCombiner::setActiveCombiners(int count);
void pfCombiner::setActiveConstColors(int count);
void pfCombiner::setConstantColor0(const pfVec4 color);
Page 105
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfCombiner::setConstantColor1(const pfVec4 color);
void pfCombiner::setGeneralConstantColor0(GLenum stage,
const pfVec4 color);
void pfCombiner::setGeneralConstantColor1(GLenum stage,
const pfVec4 color);
void pfCombiner::setFinalConstantColor0(const pfVec4 color);
void pfCombiner::setFinalConstantColor1(const pfVec4 color);
int pfCombiner::print(uint travMode, uint verbose,
char *prefix, FILE *file);
int pfCombiner::getMaxGeneralCombiners();
pfISLTexCoordData C++ API
new(void *arena)
pfISLTexCoordData();
pfType* pfISLTexCoordData::getClassType();
void* pfISLTexCoordData::borrowMemory(int size);
islAppearance* pfISLTexCoordData::getAppearance();
pfGeoSet* pfISLTexCoordData::getGSet();
pfMatrix* pfISLTexCoordData::getModelview();
pfMatrix* pfISLTexCoordData::getViewmat();
DLLEXPORT void pfGfxPipeTimestamp(uint flag);
DLLEXPORT pfStats*
pfGetCurStats(void);
pfStats C++ API
These functions are used to collect, manipulate, print, and query
statistics on state operations, geometry, and graphics and system
operations. IRIS Performer has the ability to keep many types of
statistics. Some statistics can be expensive to gather and might
possibly influence other statistics. To alleviate this problem,
statistics are divided into different classes based on the tasks that
they monitor. The specific statistics classes of interest may be selected
with pfStats::setClass.
new(void *arena)
pfStats();
pfType* pfStats::getClassType();
uint pfStats::setClassMode(int class, uint mask, int val);
uint pfStats::getClassMode(int class);
void pfStats::setAttr(int attr, float val);
float pfStats::getAttr(int attr);
uint pfStats::setClass(uint enmask, int val);
uint pfStats::getClass(uint enmask);
int pfStats::getGfxPipeTimestampStatus(uint stamp);
int pfStats::getNumGfxPipeTimestamps();
uint pfStats::getOpen(uint enmask);
uint pfStats::open(uint enmask);
uint pfStats::close(uint enmask);
uint pfStats::collectGfxPipe(uint enmask);
void pfStats::reset();
Page 106
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfStats::clear(uint which);
void pfStats::accumulate(pfStats* src, uint which);
void pfStats::average(pfStats* src, uint which, int num);
void pfStats::copy(const pfStats *src, uint which);
void pfStats::count(pfGeoSet * gset);
int pfStats::query(uint which, void *dst, int size);
int pfStats::mQuery(uint * which, void *dst, int size);
void pfStats::setHwAttr(int attr, float val);
float pfStats::getHwAttr(int attr);
void pfStats::enableHw(uint which);
void pfStats::disableHw(uint which);
uint pfStats::getHwEnable(uint which);
DLLEXPORT void pfFPConfig(int which, float val);
DLLEXPORT float
pfGetFPConfig(int which);
DLLEXPORT void pfDPConfig(int which, double val);
DLLEXPORT double
pfGetDPConfig(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);
pfVec2 C++ API
Math functions for 2-component vectors. Most of these routines have
macro equivalents which are described in the pfVec2 man page. The man
page also describes C++ arithmetic and indexing operators which are not
listed here.
void pfVec2::set(float x, float y);
void pfVec2::copy(const pfVec2& v);
int pfVec2::equal(const pfVec2& v)const;
int pfVec2::almostEqual(const pfVec2& v, float tol)const;
void pfVec2::negate(const pfVec2& v);
float pfVec2::dot(const pfVec2& v)const;
void pfVec2::add(const pfVec2& v1, const pfVec2& v2);
void pfVec2::sub(const pfVec2& v1, const pfVec2& v2);
void pfVec2::scale(float s, const pfVec2& v);
void pfVec2::addScaled(const pfVec2& v1, float s, const pfVec2& v2);
void pfVec2::combine(float a, const pfVec2& v1, float b,
const pfVec2& v2);
float pfVec2::sqrDistance(const pfVec2& v)const;
float pfVec2::normalize();
float pfVec2::length()const;
float pfVec2::distance(const pfVec2& v)const;
pfVec3 C++ API
Math functions for 3-component vectors. Most of these routines have
macro equivalents which are described in the pfVec3 man page. The man
page also describes C++ arithmetic and indexing operators which are not
Page 107
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
listed here.
void pfVec3::set(float x, float y, float z);
void pfVec3::copy(const pfVec3& v);
int pfVec3::equal(const pfVec3& v)const;
int pfVec3::almostEqual(const pfVec3& v, float tol)const;
void pfVec3::negate(const pfVec3& v);
float pfVec3::dot(const pfVec3& v)const;
void pfVec3::add(const pfVec3& v1, const pfVec3& v2);
void pfVec3::sub(const pfVec3& v1, const pfVec3& v2);
void pfVec3::scale(float s, const pfVec3& v);
void pfVec3::addScaled(const pfVec3& v1, float s, const pfVec3& v2);
void pfVec3::combine(float a, const pfVec3& v1, float b,
const pfVec3& v2);
float pfVec3::sqrDistance(const pfVec3& v)const;
float pfVec3::normalize();
float pfVec3::length()const;
float pfVec3::distance(const pfVec3& v)const;
void pfVec3::cross(const pfVec3& v1, const pfVec3& v2);
void pfVec3::xformVec(const pfVec3& v, const pfMatrix& m);
void pfVec3::xformPt(const pfVec3& v, const pfMatrix& m);
void pfVec3::fullXformPt(const pfVec3& v, const pfMatrix& m);
float pfVec3::fullXformPtw(const pfVec3& v, const pfMatrix& m);
pfVec4 C++ API
Math functions for 4-component vectors. Most of these routines have
macro equivalents which are described in the pfVec4 man page. The man
page also describes C++ arithmetic and indexing operators which are not
listed here.
void pfVec4::set(float x, float y, float z, float w);
void pfVec4::copy(const pfVec4& v);
int pfVec4::equal(const pfVec4& v)const;
int pfVec4::almostEqual(const pfVec4& v, float tol)const;
void pfVec4::negate(const pfVec4& v);
float pfVec4::dot(const pfVec4& v)const;
void pfVec4::add(const pfVec4& v1, const pfVec4& v2);
void pfVec4::sub(const pfVec4& v1, const pfVec4& v2);
void pfVec4::scale(float s, const pfVec4& v);
void pfVec4::addScaled(const pfVec4& v1, float s, const pfVec4& v2);
void pfVec4::combine(float a, const pfVec4& v1, float b,
const pfVec4& v2);
float pfVec4::sqrDistance(const pfVec4& v)const;
float pfVec4::normalize();
float pfVec4::length()const;
float pfVec4::distance(const pfVec4& v)const;
void pfVec4::xform(const pfVec4& v, const pfMatrix& m);
pfMatrix C++ API
The pfMatrix data type represents a complete 4x4 real matrix. Most
accesses to pfMatrix go through pfMatrix::operator[], but pfMatrix is a
public struct whose data member mat is directly accessible, e.g. for
Page 108
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
passing to a routine expecting a float* such as glLoadMatrixf. These
routines create transformation matrices based on multiplying a row vector
by a matrix on the right, i.e. the vector v transformed by m is v * m.
Many actions will go considerably faster if the last column is (0,0,0,1).
Some of these routines have macro equivalents which are described in the
pfMatrix man page. The man page also describes C++ arithmetic and
indexing operators which are not listed here.
void pfMatrix::set(float *m);
int pfMatrix::getMatType()const;
void pfMatrix::setRow(int r, const pfVec3& v);
void pfMatrix::setRow(int r, float x, float y, float z, float w);
void pfMatrix::getRow(int r, pfVec3& dst)const;
void pfMatrix::getRow(int r, float *x, float *y, float *z,
float *w)const;
void pfMatrix::setCol(int c, const pfVec3& v);
void pfMatrix::setCol(int c, float x, float y, float z, float w);
void pfMatrix::getCol(int c, pfVec3& dst)const;
void pfMatrix::getCol(int c, float *x, float *y, float *z,
float *w)const;
void pfMatrix::getOrthoCoord(pfCoord* dst)const;
void pfMatrix::makeIdent();
void pfMatrix::makeEuler(float hdeg, float pdeg, float rdeg);
void pfMatrix::makeRot(float degrees, float x, float y, float z);
void pfMatrix::makeTrans(float x, float y, float z);
void pfMatrix::makeScale(float x, float y, float z);
void pfMatrix::makeVecRotVec(const pfVec3& v1, const pfVec3& v2);
void pfMatrix::makeCoord(const pfCoord* c);
void pfMatrix::getOrthoQuat(pfQuat& dst)const;
void pfMatrix::makeQuat(const pfQuat& q);
void pfMatrix::copy(const pfMatrix& v);
int pfMatrix::equal(const pfMatrix& m)const;
int pfMatrix::almostEqual(const pfMatrix& m2, float tol)const;
void pfMatrix::transpose(pfMatrix& m);
void pfMatrix::mult(const pfMatrix& m1, const pfMatrix & m2);
void pfMatrix::add(const pfMatrix& m1, const pfMatrix & m2);
void pfMatrix::sub(const pfMatrix& m1, const pfMatrix & m2);
void pfMatrix::scale(float s, const pfMatrix & m);
void pfMatrix::postMult(const pfMatrix& m);
void pfMatrix::preMult(const pfMatrix& m);
int pfMatrix::invertFull(pfMatrix& m);
void pfMatrix::invertAff(const pfMatrix& m);
void pfMatrix::invertOrtho(const pfMatrix& m);
void pfMatrix::invertOrthoN(pfMatrix& m);
void pfMatrix::invertIdent(const pfMatrix& m);
void pfMatrix::preTrans(float x, float y, float z, pfMatrix& m);
void pfMatrix::postTrans(const pfMatrix& m, float x, float y, float z);
void pfMatrix::preRot(float degrees, float x, float y, float z,
pfMatrix& m);
Page 109
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfMatrix::postRot(const pfMatrix& m, float degrees, float x,
float y, float z);
void pfMatrix::preScale(float xs, float ys, float zs, pfMatrix& m);
void pfMatrix::postScale(const pfMatrix& m, float xs, float ys,
float zs);
pfQuat C++ API
pfQuat represents a quaternion as the four floating point values (x, y,
z, w) of a pfVec4. Some of these routines have macro equivalents which
are described in the pfMatrix man page. The man page also describes C++
arithmetic and indexing operators which are not listed here.
void pfQuat::getRot(float *angle, float *x, float *y, float *z)const;
void pfQuat::makeRot(float angle, float x, float y, float z);
void pfQuat::getRot(pfMatrix & m);
void pfQuat::makeRot(const pfMatrix & m);
void pfQuat::makeVecRotVec(const pfVec3 & rotateFrom,
const pfVec3 rotateTo);
void pfQuat::conj(const pfQuat& v);
float pfQuat::length()const;
void pfQuat::mult(const pfQuat& q1, const pfQuat& q2);
void pfQuat::div(const pfQuat& q1, const pfQuat& q2);
void pfQuat::invert(const pfQuat& q1);
void pfQuat::exp(const pfQuat& q);
void pfQuat::log(const pfQuat& q);
void pfQuat::slerp(float t, const pfQuat& q1, const pfQuat& q2);
void pfQuat::squad(float t, const pfQuat& q1, const pfQuat& q2,
const pfQuat& a, const pfQuat& b);
void pfQuat::meanTangent(const pfQuat& q1, const pfQuat& q2,
const pfQuat& q3);
pfVec2d C++ API
void pfVec2d::set(double x, double y);
void pfVec2d::copy(const pfVec2d& v);
int pfVec2d::equal(const pfVec2d& v)const;
int pfVec2d::almostEqual(const pfVec2d& v, double tol)const;
void pfVec2d::negate(const pfVec2d& v);
double pfVec2d::dot(const pfVec2d& v)const;
void pfVec2d::add(const pfVec2d& v1, const pfVec2d& v2);
void pfVec2d::sub(const pfVec2d& v1, const pfVec2d& v2);
void pfVec2d::scale(double s, const pfVec2d& v);
void pfVec2d::addScaled(const pfVec2d& v1, double s,
const pfVec2d& v2);
void pfVec2d::combine(double a, const pfVec2d& v1, double b,
const pfVec2d& v2);
double pfVec2d::sqrDistance(const pfVec2d& v)const;
double pfVec2d::normalize();
double pfVec2d::length()const;
double pfVec2d::distance(const pfVec2d& v)const;
Page 110
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfVec3d C++ API
void pfVec3d::set(double x, double y, double z);
void pfVec3d::copy(const pfVec3d& v);
int pfVec3d::equal(const pfVec3d& v)const;
int pfVec3d::almostEqual(const pfVec3d& v, double tol)const;
void pfVec3d::negate(const pfVec3d& v);
double pfVec3d::dot(const pfVec3d& v)const;
void pfVec3d::add(const pfVec3d& v1, const pfVec3d& v2);
void pfVec3d::sub(const pfVec3d& v1, const pfVec3d& v2);
void pfVec3d::scale(double s, const pfVec3d& v);
void pfVec3d::addScaled(const pfVec3d& v1, double s,
const pfVec3d& v2);
void pfVec3d::combine(double a, const pfVec3d& v1, double b,
const pfVec3d& v2);
double pfVec3d::sqrDistance(const pfVec3d& v)const;
double pfVec3d::normalize();
double pfVec3d::length()const;
double pfVec3d::distance(const pfVec3d& v)const;
void pfVec3d::cross(const pfVec3d& v1, const pfVec3d& v2);
void pfVec3d::xformVec(const pfVec3d& v, const pfMatrix4d& m);
void pfVec3d::xformPt(const pfVec3d& v, const pfMatrix4d& m);
void pfVec3d::fullXformPt(const pfVec3d& v, const pfMatrix4d& m);
double pfVec3d::fullXformPtw(const pfVec3d& v, const pfMatrix4d& m);
pfVec4d C++ API
void pfVec4d::set(double x, double y, double z, double w);
void pfVec4d::copy(const pfVec4d& v);
int pfVec4d::equal(const pfVec4d& v)const;
int pfVec4d::almostEqual(const pfVec4d& v, double tol)const;
void pfVec4d::negate(const pfVec4d& v);
double pfVec4d::dot(const pfVec4d& v)const;
void pfVec4d::add(const pfVec4d& v1, const pfVec4d& v2);
void pfVec4d::sub(const pfVec4d& v1, const pfVec4d& v2);
void pfVec4d::scale(double s, const pfVec4d& v);
void pfVec4d::addScaled(const pfVec4d& v1, double s,
const pfVec4d& v2);
void pfVec4d::combine(double a, const pfVec4d& v1, double b,
const pfVec4d& v2);
double pfVec4d::sqrDistance(const pfVec4d& v)const;
double pfVec4d::normalize();
double pfVec4d::length()const;
double pfVec4d::distance(const pfVec4d& v)const;
void pfVec4d::xform(const pfVec4d& v, const pfMatrix4d& m);
pfMatrix4d C++ API
void pfMatrix4d::set(double *m);
int pfMatrix4d::getMatType()const;
void pfMatrix4d::setRow(int r, const pfVec3d& v);
void pfMatrix4d::setRow(int r, double x, double y, double z, double w);
void pfMatrix4d::getRow(int r, pfVec3d& dst)const;
Page 111
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfMatrix4d::getRow(int r, double *x, double *y, double *z,
double *w)const;
void pfMatrix4d::setCol(int c, const pfVec3d& v);
void pfMatrix4d::setCol(int c, double x, double y, double z, double w);
void pfMatrix4d::getCol(int c, pfVec3d& dst)const;
void pfMatrix4d::getCol(int c, double *x, double *y, double *z,
double *w)const;
void pfMatrix4d::getOrthoCoordd(pfCoordd* dst)const;
void pfMatrix4d::makeIdent();
void pfMatrix4d::makeEuler(double hdeg, double pdeg, double rdeg);
void pfMatrix4d::makeRot(double degrees, double x, double y, double z);
void pfMatrix4d::makeTrans(double x, double y, double z);
void pfMatrix4d::makeScale(double x, double y, double z);
void pfMatrix4d::makeVecRotVec(const pfVec3d& v1, const pfVec3d& v2);
void pfMatrix4d::makeCoordd(const pfCoordd* c);
void pfMatrix4d::getOrthoQuat(pfQuatd& dst)const;
void pfMatrix4d::makeQuat(const pfQuatd& q);
void pfMatrix4d::copy(const pfMatrix4d& v);
int pfMatrix4d::equal(const pfMatrix4d& m)const;
int pfMatrix4d::almostEqual(const pfMatrix4d& m2, double tol)const;
void pfMatrix4d::transpose(pfMatrix4d& m);
void pfMatrix4d::mult(const pfMatrix4d& m1, const pfMatrix4d & m2);
void pfMatrix4d::add(const pfMatrix4d& m1, const pfMatrix4d & m2);
void pfMatrix4d::sub(const pfMatrix4d& m1, const pfMatrix4d & m2);
void pfMatrix4d::scale(double s, const pfMatrix4d & m);
void pfMatrix4d::postMult(const pfMatrix4d& m);
void pfMatrix4d::preMult(const pfMatrix4d& m);
int pfMatrix4d::invertFull(pfMatrix4d& m);
void pfMatrix4d::invertAff(const pfMatrix4d& m);
void pfMatrix4d::invertOrtho(const pfMatrix4d& m);
void pfMatrix4d::invertOrthoN(pfMatrix4d& m);
void pfMatrix4d::invertIdent(const pfMatrix4d& m);
void pfMatrix4d::preTrans(double x, double y, double z, pfMatrix4d& m);
void pfMatrix4d::postTrans(const pfMatrix4d& m, double x, double y,
double z);
void pfMatrix4d::preRot(double degrees, double x, double y, double z,
pfMatrix4d& m);
void pfMatrix4d::postRot(const pfMatrix4d& m, double degrees, double x,
double y, double z);
void pfMatrix4d::preScale(double xs, double ys, double zs,
pfMatrix4d& m);
void pfMatrix4d::postScale(const pfMatrix4d& m, double xs, double ys,
double zs);
pfQuatd C++ API
void pfQuatd::getRot(double *angle, double *x, double *y,
double *z)const;
void pfQuatd::makeRot(double angle, double x, double y, double z);
void pfQuatd::getRot(pfMatrix4d & m);
void pfQuatd::makeRot(const pfMatrix4d & m);
Page 112
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfQuatd::makeVecRotVec(const pfVec3d & rotateFrom,
const pfVec3d rotateTo);
void pfQuatd::conj(const pfQuatd& v);
double pfQuatd::length()const;
void pfQuatd::mult(const pfQuatd& q1, const pfQuatd& q2);
void pfQuatd::div(const pfQuatd& q1, const pfQuatd& q2);
void pfQuatd::invert(const pfQuatd& q1);
void pfQuatd::exp(const pfQuatd& q);
void pfQuatd::log(const pfQuatd& q);
void pfQuatd::slerp(double t, const pfQuatd& q1, const pfQuatd& q2);
void pfQuatd::squad(double t, const pfQuatd& q1, const pfQuatd& q2,
const pfQuatd& a, const pfQuatd& b);
void pfQuatd::meanTangent(const pfQuatd& q1, const pfQuatd& q2,
const pfQuatd& q3);
pfMatStack C++ API
These routines allow the creation and manipulation of a stack of 4x4
matrices.
new(void *arena)
pfMatStack(int size);
pfType* pfMatStack::getClassType();
void pfMatStack::get(pfMatrix& m)const;
pfMatrix* pfMatStack::getTop()const;
int pfMatStack::getDepth()const;
void pfMatStack::reset();
int pfMatStack::push();
int pfMatStack::pop();
void pfMatStack::load(const pfMatrix& m);
void pfMatStack::preMult(const pfMatrix& m);
void pfMatStack::postMult(const pfMatrix& m);
void pfMatStack::preTrans(float x, float y, float z);
void pfMatStack::postTrans(float x, float y, float z);
void pfMatStack::preRot(float degrees, float x, float y,
float z);
void pfMatStack::postRot(float degrees, float x, float y,
float z);
void pfMatStack::preScale(float xs, float ys, float zs);
void pfMatStack::postScale(float xs, float ys, float zs);
pfSeg C++ API
A pfSeg represents a line segment starting at pos, extending for a length
length in the direction dir. The routines assume that dir is of unit
length, otherwise the results are undefined. pfSeg is a public struct
whose data members pos, dir and length may be operated on directly.
void pfSeg::makePts(const pfVec3& p1, const pfVec3& p2);
void pfSeg::makePolar(const pfVec3& pos, float azi, float elev,
float len);
void pfSeg::clip(const pfSeg *seg, float d1, float d2);
Page 113
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfSeg::closestPtsOn(const pfSeg *seg, pfVec3& dst1,
pfVec3& dst2)const;
void pfSeg::fromSegd(const pfSegd *segd);
pfSegd C++ API
void pfSegd::makePts(const pfVec3& p1, const pfVec3& p2);
void pfSegd::makePts(const pfVec3d& p1, const pfVec3d& p2);
void pfSegd::makePolar(const pfVec3& pos, float azi, float elev,
float len);
void pfSegd::makePolar(const pfVec3d& pos, float azi, float elev,
float len);
void pfSegd::clip(const pfSegd *seg, float d1, float d2);
int pfSegd::closestPtsOn(const pfSegd *seg, pfVec3& dst1,
pfVec3& dst2)const;
int pfSegd::closestPtsOn(const pfSegd *seg, pfVec3d& dst1,
pfVec3d& dst2)const;
void pfSegd::fromSeg(const pfSeg *seg);
pfPlane C++ API
A pfPlane represents an infinite 2D plane as a normal and a distance
offset from the origin in the normal direction. A point on the plane
satisfies the equation normal dot (x, y, z) = offset. pfPlane is a
public struct whose data members normal and offset may be operated on
directly.
void pfPlane::makePts(const pfVec3& p1, const pfVec3& p2,
const pfVec3& p3);
void pfPlane::makeNormPt(const pfVec3& norm, const pfVec3& pos);
void pfPlane::displace(float d);
int pfPlane::contains(const pfBox *box)const;
int pfPlane::contains(const pfSphere *sph)const;
int pfPlane::contains(const pfCylinder *cyl)const;
int pfPlane::contains(const pfVec3& pt)const;
void pfPlane::orthoXform(const pfPlane *pln, const pfMatrix& m);
void pfPlane::closestPtOn(const pfVec3& pt, pfVec3& dst)const;
int pfPlane::isect(const pfSeg *seg, float *d)const;
int pfPlane::isect(const pfSegd *seg, double *d)const;
int pfPlane::isect(const pfSeg *seg, float *d1, float *d2)const;
int pfPlane::isect(const pfSegd *seg, double *d1, double *d2)const;
int pfPlane::clipConvexPolygon(int nVerts, pfVec3 verts[], int texdim,
float texcoords[]);
pfSphere C++ API
pfSpheres are typically used as bounding volumes in a scene graph. These
routines allow bounding spheres to be created and manipulated.
void pfSphere::makeEmpty();
int pfSphere::contains(const pfVec3& pt)const;
int pfSphere::contains(const pfSphere *sph)const;
int pfSphere::contains(const pfCylinder *cyl)const;
Page 114
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
int pfSphere::contains(const pfCylinderd *cyl)const;
int pfSphere::contains(const pfBox *box)const;
void pfSphere::around(const pfVec3* pts, int npt);
void pfSphere::around(const pfSphere **sphs, int nsph);
void pfSphere::around(const pfBox **boxes, int nbox);
void pfSphere::around(const pfCylinder **cyls, int ncyl);
void pfSphere::extendBy(const pfVec3& pt);
void pfSphere::extendBy(const pfSphere *sph);
void pfSphere::extendBy(const pfCylinder *cyl);
void pfSphere::orthoXform(const pfSphere *sph, const pfMatrix& m);
int pfSphere::isect(const pfSeg *seg, float *d1, float *d2)const;
pfSpheredf C++ API
void pfSpheredf::makeEmpty();
int pfSpheredf::contains(const pfVec3& pt)const;
int pfSpheredf::contains(const pfSpheredf *sph)const;
int pfSpheredf::contains(const pfCylinder *cyl)const;
int pfSpheredf::contains(const pfCylinderd *cyl)const;
int pfSpheredf::contains(const pfBox *box)const;
void pfSpheredf::around(const pfVec3* pts, int npt);
void pfSpheredf::around(const pfSpheredf **sphs, int nsph);
void pfSpheredf::around(const pfBox **boxes, int nbox);
void pfSpheredf::around(const pfCylinder **cyls, int ncyl);
void pfSpheredf::extendBy(const pfVec3& pt);
void pfSpheredf::extendBy(const pfSpheredf *sph);
void pfSpheredf::extendBy(const pfCylinder *cyl);
void pfSpheredf::orthoXform(const pfSpheredf *sph,
const pfMatrix4d& m);
pfSpheredd C++ API
void pfSpheredd::makeEmpty();
int pfSpheredd::contains(const pfVec3& pt)const;
int pfSpheredd::contains(const pfSpheredd *sph)const;
int pfSpheredd::contains(const pfCylinder *cyl)const;
int pfSpheredd::contains(const pfCylinderd *cyl)const;
int pfSpheredd::contains(const pfBox *box)const;
void pfSpheredd::around(const pfVec3* pts, int npt);
void pfSpheredd::around(const pfSpheredd **sphs, int nsph);
void pfSpheredd::around(const pfBox **boxes, int nbox);
void pfSpheredd::around(const pfCylinder **cyls, int ncyl);
void pfSpheredd::extendBy(const pfVec3& pt);
void pfSpheredd::extendBy(const pfSpheredd *sph);
void pfSpheredd::extendBy(const pfCylinder *cyl);
void pfSpheredd::orthoXform(const pfSpheredd *sph,
const pfMatrix4d& m);
pfCylinder C++ API
A pfCylinder represents a cylinder of finite length. The routines listed
here provide means of creating and extending cylinders for use as
bounding geometry around groups of line segments. The cylinder is
defined by its center, radius, axis and halfLength. The routines assume
axis is a vector of unit length, otherwise results are undefined.
Page 115
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
pfCylinder is a public struct whose data members center, radius, axis and
halfLength may be operated on directly.
void pfCylinder::makeEmpty();
int pfCylinder::contains(const pfVec3& pt)const;
void pfCylinder::orthoXform(const pfCylinder *cyl, const pfMatrix& m);
void pfCylinder::around(const pfVec3 *pts, int npt);
void pfCylinder::around(const pfSeg **segs, int nseg);
void pfCylinder::around(const pfSphere **sphs, int nsph);
void pfCylinder::around(const pfBox **boxes, int nbox);
void pfCylinder::extendBy(const pfSphere *sph);
void pfCylinder::extendBy(const pfCylinder *cyl);
void pfCylinder::extendBy(const pfVec3& pt);
int pfCylinder::isect(const pfSeg *seg, float *d1, float *d2)const;
void pfCylinder::fromCylinderd(pfCylinderd *cyl);
pfCylinderd C++ API
void pfCylinderd::makeEmpty();
int pfCylinderd::contains(const pfVec3& pt)const;
int pfCylinderd::contains(const pfVec3d& pt)const;
void pfCylinderd::orthoXform(const pfCylinderd *cyl,
const pfMatrix4d& m);
void pfCylinderd::around(const pfVec3 *pts, int npt);
void pfCylinderd::around(const pfSeg **segs, int nseg);
void pfCylinderd::around(const pfSegd **segs, int nseg);
void pfCylinderd::around(const pfSphere **sphs, int nsph);
void pfCylinderd::around(const pfSpheredd **sphs, int nsph);
void pfCylinderd::around(const pfBox **boxes, int nbox);
void pfCylinderd::extendBy(const pfSphere *sph);
void pfCylinderd::extendBy(const pfSpheredd *sph);
void pfCylinderd::extendBy(const pfCylinder *cyl);
void pfCylinderd::extendBy(const pfCylinderd *cyl);
void pfCylinderd::extendBy(const pfVec3& pt);
void pfCylinderd::extendBy(const pfVec3d& pt);
int pfCylinderd::isect(const pfSeg *seg, float *d1, float *d2)const;
int pfCylinderd::isect(const pfSegd *seg, double *d1,
double *d2)const;
void pfCylinderd::fromCylinder(pfCylinder *cyl);
pfBox C++ API
A pfBox is an axis-aligned box which can be used for intersection tests
and for maintaining bounding information about geometry. A box
represents the axis-aligned hexahedral volume: (x, y, z) where min[0] <=
x <= max[0], min[1] <= y <= max[1] and min[2] <= z <= max[2]. pfBox is a
public struct whose data members min and max may be operated on directly.
void pfBox::makeEmpty();
int pfBox::contains(const pfVec3& pt)const;
int pfBox::contains(const pfBox *inbox);
int pfBox::contains(const pfSphere *sphere)const;
Page 116
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfBox::xform(const pfBox *box, const pfMatrix& xform);
void pfBox::around(const pfVec3 *pts, int npt);
void pfBox::around(const pfSphere **sphs, int nsph);
void pfBox::around(const pfBox **boxes, int nbox);
void pfBox::around(const pfCylinder **cyls, int ncyl);
void pfBox::extendBy(const pfVec3& pt);
void pfBox::extendBy(const pfBox *box);
int pfBox::isect(const pfSeg *seg, float *d1, float *d2)const;
pfPolytope C++ API
A pfPolytope is a set of half spaces whose intersection defines a convex,
possibly semi-infinite, volume which may be used for culling and other
intersection testing where a tighter bound than a pfBox, pfSphere, or
pfCylinder is of benefit.
new(void *arena)
pfPolytope();
pfType* pfPolytope::getClassType();
int pfPolytope::getNumFacets()const;
int pfPolytope::setFacet(int i, const pfPlane *p);
int pfPolytope::getFacet(int i, pfPlane *p)const;
int pfPolytope::removeFacet(int i);
void pfPolytope::orthoXform(const pfPolytope *src,
const pfMatrix& mat);
int pfPolytope::contains(const pfVec3& pt)const;
int pfPolytope::contains(const pfSphere *sphere)const;
int pfPolytope::contains(const pfBox *box)const;
int pfPolytope::contains(const pfCylinder *cyl)const;
int pfPolytope::contains(const pfPolytope *ptope)const;
pfFrustum C++ API
A pfFrustum represents a viewing and or culling volume bounded by left,
right, top, bottom, near and far planes.
new(void *arena)
pfFrustum();
pfType* pfFrustum::getClassType();
int pfFrustum::getFrustType()const;
void pfFrustum::setAspect(int which, float widthHeightRatio);
float pfFrustum::getAspect()const;
void pfFrustum::getFOV(float* fovh, float* fovv)const;
void pfFrustum::setNearFar(float nearDist, float farDist);
void pfFrustum::getNearFar(float* nearDist,
float* farDist)const;
void pfFrustum::getNear(pfVec3& ll, pfVec3& lr, pfVec3& ul,
pfVec3& ur)const;
void pfFrustum::getFar(pfVec3& ll, pfVec3& lr, pfVec3& ul,
pfVec3& ur)const;
void pfFrustum::getPtope(pfPolytope *dst)const;
void pfFrustum::getGLProjMat(pfMatrix & mat)const;
Page 117
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
void pfFrustum::getLeftRightBottomTop(float *l, float *r,
float *b, float *t)const;
int pfFrustum::getEye(pfVec3& eye)const;
void pfFrustum::makePersp(float left, float right, float bot,
float top);
void pfFrustum::makeOrtho(float left, float right, float bot,
float top);
void pfFrustum::makeSimple(float fov);
void pfFrustum::makeInfPersp(float left, float right,
float bot, float top);
void pfFrustum::orthoXform(const pfFrustum* fr2,
const pfMatrix& mat);
int pfFrustum::recommendNear(const pfSphere *sph,
pfVec3 & result_point, int use_cone)const;
int pfFrustum::recommendNear(int nVerts,
pfVec3 convexPolygonVerts[], pfVec3 & recommended,
pfVec2 convexPolygonTexCoords[],
pfVec2 & recommendedTextureCoord)const;
int pfFrustum::contains(const pfVec3& pt)const;
int pfFrustum::contains(const pfSphere *sphere)const;
int pfFrustum::contains(const pfBox *box)const;
int pfFrustum::contains(const pfCylinder *cyl)const;
void pfFrustum::apply()const;
Triangle Intersection
This routine returns the intersection of a triangle with a line segment
and is the basis for Performer's performing intersection testing and
picking against geometry contained in pfGeoSets.
int DLLEXPORT pfTriIsectSeg(const pfVec3 pt1, const pfVec3 pt2,
const pfVec3 pt3, const pfSeg* seg, float* d);
LIBPFDU
Database Conversions
IRIS Performer provides an extensive array of converters which load
file-based geometry formats into a pfScene hierarchical scene graph.
These functions also provide the capability to set attributes which
modify the behavior of individual loaders.
PFDUDLLEXPORT pfNode*
pfdLoadFile(const char *file);
PFDUDLLEXPORT int
pfdStoreFile(pfNode *root, const char *file);
PFDUDLLEXPORT pfNode*
pfdConvertFrom(void *root, const char *ext);
PFDUDLLEXPORT void*
pfdConvertTo(pfNode* root, const char *ext);
PFDUDLLEXPORT int
pfdInitConverter(const char *ext);
Page 118
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT int
pfdExitConverter(const char *ext);
PFDUDLLEXPORT FILE*
pfdOpenFile(const char *file);
PFDUDLLEXPORT void
pfdAddExtAlias(const char *ext, const char *alias);
PFDUDLLEXPORT void
pfdConverterMode(const char *ext, int mode, int value);
PFDUDLLEXPORT int
pfdGetConverterMode(const char *ext, int mode);
PFDUDLLEXPORT void
pfdConverterAttr(const char *ext, int which, void *attr);
PFDUDLLEXPORT void*
pfdGetConverterAttr(const char *ext, int which);
PFDUDLLEXPORT void
pfdConverterVal(const char *ext, int which, float val);
PFDUDLLEXPORT float
pfdGetConverterVal(const char *ext, int which);
PFDUDLLEXPORT int pfdRegisterUserFunc(void *func,
PFDUDLLEXPORT int
pfdGetRegisteredUserFunc(void *func, char **name,
char **dso_name);
PFDUDLLEXPORT int
pfdIsRegisteredUserFunc(void *func);
PFDUDLLEXPORT void *
pfdFindRegisteredUserFunc(char *name);
PFDUDLLEXPORT void
pfdPrintSceneGraphStats(pfNode *node, double elapsedTime);
Generate pfGeoSets
These routines are provided to conveniently construct pfGeoSets for
various geometric objects. The resulting objects are always positioned
and sized in canonical ways. The user can then apply a transformation to
these pfGeoSets to achieve the desired shape and position.
PFDUDLLEXPORT pfGeoSet *
pfdNewCube(void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewSphere(int ntris, void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewCylinder(int ntris, void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewCone(int ntris, void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewPipe(float botRadius, float topRadius, int ntris,
void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewPyramid(void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewArrow(int ntris, void *arena);
Page 119
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT pfGeoSet *
pfdNewDoubleArrow(int ntris, void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewTorus(float rMajor, float rMinor, int nDivMajor,
int nDivMinor, void* arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewCircle(int ntris, void *arena);
PFDUDLLEXPORT pfGeoSet *
pfdNewRing(int ntris, void *arena);
PFDUDLLEXPORT void
pfdXformGSet(pfGeoSet *gset, pfMatrix mat);
PFDUDLLEXPORT void
pfdGSetColor(pfGeoSet *gset, float r, float g, float b,
float a);
Mesh Triangles
Forming independent triangles into triangle strips (or meshes) can
significantly improve rendering performance on IRIS systems. Strips
reduce the amount of work required by the CPU, bus, and graphics
subsystem. IRIS Performer provides this utility facility for converting
independent triangles into strips.
PFDUDLLEXPORT pfGeoSet*
pfdMeshGSet(pfGeoSet *gset);
PFDUDLLEXPORT void
pfdMesherMode(int mode, int val);
PFDUDLLEXPORT int
pfdGetMesherMode(int mode);
PFDUDLLEXPORT void
pfdShowStrips(pfGeoSet *gset);
Optimize Scene Graphs
pfdCleanTree and pfdStaticize optimize the scene graph. pfdCleanTree
removes pfGroups with one or fewer child and pfSCSes with identity
transformations. pfdStaticize conditionally converts pfDCSes to pfSCSes,
usually in preparation for pfFlatten.
PFDUDLLEXPORT pfNode*
pfdCleanTree(pfNode *node, pfuTravFuncType doitfunc);
PFDUDLLEXPORT void
pfdReplaceNode(pfNode *oldn, pfNode *newn);
PFDUDLLEXPORT void
pfdInsertGroup(pfNode *oldn, pfGroup *grp);
PFDUDLLEXPORT void
pfdRemoveGroup(pfGroup *oldn);
PFDUDLLEXPORT pfNode*
pfdFreezeTransforms(pfNode *node,
pfuTravFuncType doitfunc);
Breakup Scene Graphs
pfdBreakup is provided as a utility to break unstructured scene geometry
into a spacially subdivided scene hierarchy. Spacially subdivided
Page 120
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
geometry is more easily culled and less time is spent drawing geometry
which does not contribute to the final image.
PFDUDLLEXPORT pfNode*
pfdBreakup(pfGeode *geode, float geodeSize,
int stripLength, int geodeChild);
Generate Hierarchies
For performance reasons, it is desirable that the geometry in a scene be
organized into a spatial hierarchy. However, it is often easiest to
model geometry using logical, rather than spatial, divisions.
pfdTravGetGSets and pfdSpatialize can be used to partition an already
constructed scene.
PFDUDLLEXPORT pfList *
pfdTravGetGSets(pfNode *node);
PFDUDLLEXPORT pfGroup*
pfdSpatialize(pfGroup *group, float maxGeodeSize,
int maxGeoSets);
Share pfGeoStates
It is obviously desirable to share state between database objects in IRIS
Performer whenever possible. The notion of pervasive state sharing
underpins the entire pfGeoState mechanism. Common data such as texture,
materials, and lighting models are often duplicated in many different
objects throughout a database. This collection of functions provides the
means necessary to easily achieve sharing among these objects by
automatically producing a non-redundant set of states.
PFDUDLLEXPORT pfdShare*
pfdNewShare(void);
PFDUDLLEXPORT pfdShare*
pfdGetGlobalShare(void);
PFDUDLLEXPORT void
pfdSetGlobalShare(pfdShare *share);
PFDUDLLEXPORT int
pfdCleanShare(pfdShare *share);
PFDUDLLEXPORT void
pfdDelShare(pfdShare *share, int deepDelete);
PFDUDLLEXPORT void
pfdPrintShare(pfdShare *share);
PFDUDLLEXPORT int
pfdCountShare(pfdShare *share);
PFDUDLLEXPORT pfList*
pfdGetSharedList(pfdShare *share, pfType* type);
PFDUDLLEXPORT pfObject*
pfdNewSharedObject(pfdShare *share, pfObject *object);
PFDUDLLEXPORT pfObject*
pfdFindSharedObject(pfdShare *share, pfObject *object);
PFDUDLLEXPORT int
pfdAddSharedObject(pfdShare *share, pfObject *object);
Page 121
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT void
pfdMakeShared(pfNode *node);
PFDUDLLEXPORT void
pfdMakeSharedScene(pfScene *scene);
PFDUDLLEXPORT int
pfdCleanShare(pfdShare *share);
PFDUDLLEXPORT int
pfdRemoveSharedObject(pfdShare *share, pfObject *object);
PFDUDLLEXPORT pfList*
pfdGetNodeGStateList(pfNode *node);
Combine pfLayers
When multiple sibling layer nodes have been created, efficiency will be
improved by combining them together. pfdCombineLayers provides for
exactly this kind of optimization.
PFDUDLLEXPORT void
pfdCombineLayers(pfNode *node);
Combine pfBillboards
The performance of pfBillboard nodes is enhanced when they contain
several pfGeoSets each as opposed to a scene graph with a large number of
single pfGeoSet pfBillboards. The pfdCombineBillboards() traversal
creates this efficient situation by traversing a scene graph and
combining the pfGeoSets of sibling pfBillboard nodes into a single
pfBillboard node.
PFDUDLLEXPORT void
pfdCombineBillboards(pfNode *node, int sizeLimit);
The Geometry Builder
It is seldom the case that database models are expressed directly in
internal Performer structures (pfGeoSets). Instead, models are generally
described in geometric constructs defined by the modeller. The Performer
GeoBuilder is meant to simplify the task of translating model geometry
into Performer geometry structures. The GeoBuilder can also create many
kinds of polygon mesh (e.g. triangle-strips) pfGeoSets, which can
significantly improve performance.
PFDUDLLEXPORT pfdGeom*
pfdNewGeom(int numV);
PFDUDLLEXPORT void
pfdResizeGeom(pfdGeom *geom, int numV);
PFDUDLLEXPORT void
pfdDelGeom(pfdGeom *geom);
PFDUDLLEXPORT int
pfdReverseGeom(pfdGeom *geom);
PFDUDLLEXPORT void
pfdCopyGeom(pfdGeom *dst, pfdGeom *src);
PFDUDLLEXPORT pfdGeoBuilder*
pfdNewGeoBldr(void);
Page 122
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT void
pfdDelGeoBldr(pfdGeoBuilder* bldr);
PFDUDLLEXPORT void
pfdGeoBldrMode(pfdGeoBuilder* bldr, int mode, int val);
PFDUDLLEXPORT int
pfdGetGeoBldrMode(pfdGeoBuilder* bldr, int mode);
PFDUDLLEXPORT int
pfdTriangulatePoly(pfdGeom *pgon, pfdPrim *triList);
PFDUDLLEXPORT void
pfdAddGeom(pfdGeoBuilder *bldr, pfdGeom *Geom, int num);
PFDUDLLEXPORT void
pfdAddLineStrips(pfdGeoBuilder *bldr, pfdGeom *lineStrips,
int num);
PFDUDLLEXPORT void
pfdAddLines(pfdGeoBuilder *bldr, pfdGeom *lines);
PFDUDLLEXPORT void
pfdAddPoints(pfdGeoBuilder *bldr, pfdGeom *points);
PFDUDLLEXPORT void
pfdAddPoly(pfdGeoBuilder *bldr, pfdGeom *poly);
PFDUDLLEXPORT void
pfdAddIndexedLineStrips(pfdGeoBuilder *bldr,
pfdGeom *lines, int num);
PFDUDLLEXPORT void
pfdAddIndexedLines(pfdGeoBuilder *bldr, pfdGeom *lines);
PFDUDLLEXPORT void
pfdAddIndexedPoints(pfdGeoBuilder *bldr, pfdGeom *points);
PFDUDLLEXPORT void
pfdAddIndexedPoly(pfdGeoBuilder *bldr, pfdGeom *poly);
PFDUDLLEXPORT void
pfdAddIndexedTri(pfdGeoBuilder *bldr, pfdPrim *tri);
PFDUDLLEXPORT void
pfdAddLine(pfdGeoBuilder *bldr, pfdPrim *line);
PFDUDLLEXPORT void
pfdAddPoint(pfdGeoBuilder *bldr, pfdPrim *Point);
PFDUDLLEXPORT void
pfdAddTri(pfdGeoBuilder *bldr, pfdPrim *tri);
PFDUDLLEXPORT int
pfdGetNumTris(pfdGeoBuilder *bldr);
PFDUDLLEXPORT const pfList*
pfdBuildGSets(pfdGeoBuilder *bldr);
PFDUDLLEXPORT void
pfdPrintGSet(pfGeoSet *gset);
The Scene Builder
The Performer Builder is meant to manage most of the details of
constructing efficient runtime structures from input models. It provides
a simple and convenient interface for bringing scene data into the
application without the need for considering how best to structure that
data for efficient rendering in Performer. The Builder provides a
comprehensive interface between model input code (such as database file
parsers) and the internal mechanisms of scene representation in
Performer. In addition to handling input geometry, as the GeoBuilder
Page 123
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
does, the Builder also manages the associated graphics state.
PFDUDLLEXPORT void
pfdInitBldr(void);
PFDUDLLEXPORT void
pfdExitBldr(void);
PFDUDLLEXPORT pfdBuilder *
pfdNewBldr(void);
PFDUDLLEXPORT void
pfdDelBldr(pfdBuilder *bldr);
PFDUDLLEXPORT void
pfdSelectBldr(pfdBuilder *bldr);
PFDUDLLEXPORT pfdBuilder *
pfdGetCurBldr(void);
PFDUDLLEXPORT void
pfdBldrDeleteNode(pfNode *node);
PFDUDLLEXPORT void
pfdBldrMode(int mode, int val);
PFDUDLLEXPORT int
pfdGetBldrMode(int mode);
PFDUDLLEXPORT void
pfdBldrAttr(int which, void *attr);
PFDUDLLEXPORT void *
pfdGetBldrAttr(int which);
PFDUDLLEXPORT pfObject *
pfdGetTemplateObject(pfType *type);
PFDUDLLEXPORT void
pfdResetObject(pfObject *obj);
PFDUDLLEXPORT void
pfdResetAllTemplateObjects(void);
PFDUDLLEXPORT void
pfdMakeDefaultObject(pfObject *obj);
PFDUDLLEXPORT void
pfdResetBldrGeometry(void);
PFDUDLLEXPORT void
pfdResetBldrShare(void);
PFDUDLLEXPORT void
pfdCleanBldrShare(void);
PFDUDLLEXPORT pfdShare *
pfdGetBldrShare(void);
PFDUDLLEXPORT void
pfdSetBldrShare(pfdShare *share);
PFDUDLLEXPORT void
pfdCaptureDefaultBldrState(void);
PFDUDLLEXPORT void
pfdResetBldrState(void);
PFDUDLLEXPORT void
pfdPushBldrState(void);
PFDUDLLEXPORT void
pfdPopBldrState(void);
Page 124
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT void
pfdSaveBldrState(void *name);
PFDUDLLEXPORT void
pfdLoadBldrState(void *name);
PFDUDLLEXPORT void
pfdBldrGState(const pfGeoState *gstate);
PFDUDLLEXPORT const pfGeoState *
pfdGetBldrGState(void);
PFDUDLLEXPORT void
pfdBldrStateVal(uint64_t which, float val);
PFDUDLLEXPORT float
pfdGetBldrStateVal(uint64_t which);
PFDUDLLEXPORT void
pfdBldrStateMode(uint64_t mode, int val);
PFDUDLLEXPORT int
pfdGetBldrStateMode(uint64_t mode);
PFDUDLLEXPORT void
pfdBldrStateAttr(uint64_t which, const void *attr);
PFDUDLLEXPORT const void *
pfdGetBldrStateAttr(uint64_t attr);
PFDUDLLEXPORT void
pfdBldrStateInherit(uint64_t mask);
PFDUDLLEXPORT uint64_t
pfdGetBldrStateInherit(void);
PFDUDLLEXPORT void
pfdSelectBldrName(void *name);
PFDUDLLEXPORT void *
pfdGetCurBldrName(void);
PFDUDLLEXPORT void
pfdAddBldrGeom(pfdGeom *p, int n);
PFDUDLLEXPORT void
pfdAddIndexedBldrGeom(pfdGeom *p, int n);
PFDUDLLEXPORT pfNode *
pfdBuild(void);
PFDUDLLEXPORT pfNode *
pfdBuildNode(void *name);
PFDUDLLEXPORT void
pfdDefaultGState(pfGeoState *def);
PFDUDLLEXPORT const pfGeoState*
pfdGetDefaultGState(void);
PFDUDLLEXPORT void pfdMakeSceneGState(pfGeoState *sceneGState,
PFDUDLLEXPORT void pfdOptimizeGStateList(pfList *gstateList,
Clipmap and Icache Utilities
There are two types of cliptexture functionality included in the libpfdu
library; pfClipTexture and pfImageCache configuration file parsers, and
update traversal functions. The parsers are used to create and configure
pfClipTexture and pfImageCache classes using ascii configuration files.
The update functions are obsolete functions for centering cliptextures;
their functionality has been replaced by pfuClipCenterNodes(). They are
only included for backwards compatibility.
Page 125
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT pfImageCache *pfdLoadImageCache(const char *fileName,
PFDUDLLEXPORT pfImageCache *pfdLoadImageCacheState(const char *fileName,
PFDUDLLEXPORT pfMPClipTexture *
pfdLoadMPClipTexture(const char *fileName);
PFDUDLLEXPORT pfClipTexture *
pfdLoadClipTexture(const char *fileName);
PFDUDLLEXPORT pfClipTexture *pfdLoadClipTextureState(const char *fileName,
PFDUDLLEXPORT int
pfdImageCacheNodeUpdate(pfTraverser *trav,
void *userData);
PFDUDLLEXPORT int
pfdClipTextureNodeUpdate(pfTraverser *trav,
void *userData);
Haeberli Font Extensions
This is Paul Haeberli's cool font extension header file - Performer uses
Paul's font library to load fonts into pfFont structures.
PFDUDLLEXPORT pfFont*
pfdLoadFont(const char *ftype, const char *name,
int style);
PFDUDLLEXPORT pfFont*
pfdLoadFont_type1(const char *name, int style);
Texture Callbacks
These routines are now obsolete in that Performer now supports the notion
of texture coordinate generation in pfGeoStates via the pfTexGen
pfObject. However, these routines are still a good example of how to
implement functionality in the draw process through callbacks. Similarly
this set of routines also fits into the builder state extension mechanism
- see the pfdBuilder man pages.
PFDUDLLEXPORT int
pfdPreDrawTexgenExt(pfTraverser *trav, void *data);
PFDUDLLEXPORT int
pfdPostDrawTexgenExt(pfTraverser *trav, void *data);
PFDUDLLEXPORT int
pfdPreDrawReflMap(pfTraverser *trav, void *data);
PFDUDLLEXPORT int
pfdPostDrawReflMap(pfTraverser *trav, void *data);
PFDUDLLEXPORT int
pfdPreDrawContourMap(pfTraverser *trav, void *data);
PFDUDLLEXPORT int
pfdPostDrawContourMap(pfTraverser *trav, void *data);
PFDUDLLEXPORT int
pfdPreDrawLinearMap(pfTraverser *trav, void *data);
PFDUDLLEXPORT int
pfdPostDrawLinearMap(pfTraverser *trav, void *data);
PFDUDLLEXPORT void
pfdTexgenParams(const float *newParamsX,
const float *newParamsY);
Page 126
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Function Extensors
pfdExtensors provide a framework for extending application functionality.
They allow generalized callbacks to be attached to the model database.
These callbacks can be called from any Performer traversal. The
following functions are used to manipulate and install extensors.
PFDUDLLEXPORT 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);
PFDUDLLEXPORT void
pfdStateCallback(int stateToken, int whichCBack,
pfNodeTravFuncType callback);
PFDUDLLEXPORT pfNodeTravFuncType
pfdGetStateCallback(int stateToken, int which);
PFDUDLLEXPORT int
pfdGetStateToken(void *name);
PFDUDLLEXPORT int
pfdGetUniqueStateToken(void);
PFDUDLLEXPORT pfdExtensor*
pfdNewExtensor(int which);
PFDUDLLEXPORT pfdExtensorType*
pfdNewExtensorType(int token);
PFDUDLLEXPORT int
pfdCompareExtensor(void *a, void *b);
PFDUDLLEXPORT int
pfdCompareExtraStates(void *lista, void *listb);
PFDUDLLEXPORT void
pfdCopyExtraStates(pfList *dst, pfList *src);
PFDUDLLEXPORT pfdExtensor*
pfdGetExtensor(int token);
PFDUDLLEXPORT pfdExtensorType*
pfdGetExtensorType(int token);
PFDUDLLEXPORT void *
pfdUniqifyData(pfList *dataList, const void *data,
long dataSize, void *(*newData)(long),
int (*compare)(void *, void *), long (*copy)(void *,
void *), int *compareResult);
PFDUDLLEXPORT pfASD *
pfdBuildASD(uint numx, uint numy, pfVec3 *data, int mode,
int inputlods, int buildpaging, char *prename,
char *confname, char *pagename, int *lookahead);
PFDUDLLEXPORT void
pfdStoreASD(pfASD *asd, FILE *f);
PFDUDLLEXPORT void
pfdBreakTiles(int numlods, pfASDLODRange *lods,
int numverts, pfASDVert *verts, int numfaces,
pfASDFace *faces, int numfaces0, char *prename,
char *conf);
Page 127
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT void
pfdPagingLookahead(char *confname, char *pagename,
int *lookahead);
PFDUDLLEXPORT void
pfdWriteFile(int ***FACE, int **numf, int ***V,
int **numv, pfASDFace *faces, pfASDVert *verts,
pfBox *facebounds, int lod, int x, int y,
char *prename);
PFDUDLLEXPORT pfASD *
pfdLoadConfig(char *fname, char *pagename);
PFDUDLLEXPORT void
pfdProcessASDTiles(char *fname, char *pagename);
ASD vertex projection
pfdProjectVerticesOnASD projects a list of vertices onto the finest level
of detail of pfASD. This function, together with pfdAlignVerticesToASD
will enable the casting of shadow of geometry on pfASD surface and
conforming layered features such as roads on pfASD surface.
PFDUDLLEXPORT void
pfdAlignVerticesToASD(pfASD *asd, pfVec3 *v,
int nofVertices, float *base, float *down,
float *azimuth, ulong opcode, pfVec3 *v_aligned);
ASD vertex projection
pfdProjectVerticesOnASD projects a list of vertices onto the finest level
of detail of pfASD. This function, together with pfdAlignVerticesToASD
will enable the casting of shadow of geometry on pfASD surface and
conforming layered features such as roads on pfASD surface.
PFDUDLLEXPORT void
pfdExtractGraphTriangles(pfNode *node, pfGeoSet *gset,
ulong flags);
ASD Clipring computation
pfASD works in real-time with virtual cliptexture. The active mesh
evaluated by pfASD is grouped into pfGeodes internally. These groups of
geometry are bounded by concentric rings using pfASDLODRange. Additional
levels can be allocated within the original smallest pfASDLODRange to
further support the finer levels in cliptexture.
PFDUDLLEXPORT void
pfdASDClipring(pfASD *asd, int numrings);
PFDUDLLEXPORT pfdImage *
pfdLoadImage(const char *fileName);
PFDUDLLEXPORT pfdImage *
pfdLoadImage_sgi(const char *fileName);
PFDUDLLEXPORT void
pfdDelImage(pfdImage *image);
PFDUDLLEXPORT void
pfdStoreImage(pfdImage *image, const char *fileName);
Page 128
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT void
pfdStoreImage_sgi(pfdImage *image, const char *fileName);
PFDUDLLEXPORT void
pfdImagePack(pfdImage *image, int format);
PFDUDLLEXPORT void
pfdImageFromPfTexture(pfdImage *image, pfTexture *pftex);
PFDUDLLEXPORT void
pfdImageToPfTexture(pfdImage *image, pfTexture *pftex);
PFDUDLLEXPORT void pfdImageGenMipmaps(pfdImage *image,
PFDUDLLEXPORT void
pfdImageDelMipmaps(pfdImage *image);
PFDUDLLEXPORT void
pfdImageAlignment(pfdImage *image, int alignment);
PFDUDLLEXPORT pfdASDGenerator *
pfdNewASDGen(void);
PFDUDLLEXPORT void pfdASDGenerate (
PFDUDLLEXPORT void pfdASDGenPlaneGeometry (
PFDUDLLEXPORT void pfdASDGenSphereGeometry (
PFDUDLLEXPORT void pfdASDGenElevationFunc (
PFDUDLLEXPORT void pfdASDGenPrune (
PFDUDLLEXPORT void pfdASDGenGridSize (
PFDUDLLEXPORT void pfdASDGenTileSize (
PFDUDLLEXPORT void pfdASDGenNofLevels (
PFDUDLLEXPORT void pfdASDGenTempFile (
PFDUDLLEXPORT void pfdASDGenOutputFile (
PFDUDLLEXPORT void pfdASDGenLookahead (
PFDUDLLEXPORT void pfdASDGenAddSegment (
PFDUDLLEXPORT void pfdASDGenAddTriangle (
PFDUDLLEXPORT islAppearance *
pfdLoadAppearance(const char *filename);
PFDUDLLEXPORT int
pfdStoreAppearance(const char *filename,
islAppearance *app);
PFDUDLLEXPORT char *
pfdGetAppearanceFilename(islAppearance *app);
PFDUDLLEXPORT void
pfdAddNodeToMesh(pfNode *root, pfMesh *mesh, int part);
PFDUDLLEXPORT pfNode* pfdMergeGraph(pfNode *node,
PFDUDLLEXPORT pfNode* pfdStripGraph(pfNode *node,
PFDUDLLEXPORT pfNode* pfdSpatializeGraph(pfNode *node,
PFDUDLLEXPORT pfGeoArray *
pfdConvertGeoSetToGeoArray(pfGeoSet *gset, int flags);
PFDUDLLEXPORT void
pfdConvertNodeGeoSetsToGeoArrays(pfNode *node, int flags);
PFDUDLLEXPORT void
pfdClearTessellation(pfNode *root);
PFDUDLLEXPORT void
pfdTessellateGeometry(pfNode *root,
pfTessParaSurfaceAction *action);
PFDUDLLEXPORT void
pfdBuildTopologyTraverse(pfTopo *topo, pfNode *root);
Page 129
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFDUDLLEXPORT uchar *pfdAssembleData(int uncompressedSize,
LIBPFUI
PFUIDLLEXPORT void
pfiInit(void);
pfiMotionCoord
The pfiMotionCoord.i class provides a modular definition of motion
parameters and limits for position, speed, and acceleration, as well as
mechanisms for querying and reseting the current state of motion.
PFUIDLLEXPORT pfType*
pfiGetMotionCoordClassType(void);
PFUIDLLEXPORT pfiMotionCoord *
pfiNewMotionCoord(void *arena);
pfiInputCoord
The pfiInputCoord class is an abstract class providing a general
interface for controlling an input device. A child class is
pfi2DInputCoord.
PFUIDLLEXPORT pfType*
pfiGetInputCoordClassType(void);
PFUIDLLEXPORT pfiInputCoord *
pfiNewInputCoord(void *arena);
PFUIDLLEXPORT void
pfiInputCoordVec(pfiInputCoord *ic, float *vec);
PFUIDLLEXPORT void
pfiGetInputCoordVec(pfiInputCoord *ic, float *vec);
pfiInputXform
Building user interfaces requires managing user input events. These
functions provide a window system independent means of handling event
streams.
PFUIDLLEXPORT pfiInput *
pfiNewInput(void *arena);
PFUIDLLEXPORT void
pfiInputName(pfiInput *in, const char *name);
PFUIDLLEXPORT const char *
pfiIsIXGetName(pfiInput *in);
PFUIDLLEXPORT void
pfiInputFocus(pfiInput *in, int focus);
PFUIDLLEXPORT int
pfiGetInputFocus(pfiInput *in);
PFUIDLLEXPORT void
pfiInputEventMask(pfiInput *in, int emask);
Page 130
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT int
pfiGetInputEventMask(pfiInput *in);
PFUIDLLEXPORT void
pfiInputEventStreamCollector(pfiInput *in,
pfiEventStreamHandlerType func, void *data);
PFUIDLLEXPORT void
pfiGetInputEventStreamCollector(pfiInput *in,
pfiEventStreamHandlerType *func, void **data);
PFUIDLLEXPORT void
pfiInputEventStreamProcessor(pfiInput *in,
pfiEventStreamHandlerType func, void *data);
PFUIDLLEXPORT void
pfiGetInputEventStreamProcessor(pfiInput *in,
pfiEventStreamHandlerType *func, void **data);
PFUIDLLEXPORT void
pfiInputEventHandler(pfiInput *in,
pfuEventHandlerFuncType func, void *data);
PFUIDLLEXPORT void
pfiGetInputEventHandler(pfiInput *in,
pfuEventHandlerFuncType *func, void **data);
PFUIDLLEXPORT void
pfiResetInput(pfiInput *in);
PFUIDLLEXPORT void
pfiCollectInputEvents(pfiInput *in);
PFUIDLLEXPORT void
pfiProcessInputEvents(pfiInput *in);
PFUIDLLEXPORT int
pfiHaveFastMouseClick(pfuMouse *mouse, int button,
float msecs);
PFUIDLLEXPORT pfiInputXform *
pfiNewIXform(void *arena);
PFUIDLLEXPORT void
pfiIXformFocus(pfiInputXform *in, int focus);
PFUIDLLEXPORT int
pfiIsIXformInMotion(pfiInputXform *ix);
PFUIDLLEXPORT void
pfiStopIXform(pfiInputXform *ix);
PFUIDLLEXPORT void
pfiResetIXform(pfiInputXform *ix);
PFUIDLLEXPORT void
pfiUpdateIXform(pfiInputXform *ix);
PFUIDLLEXPORT void
pfiIXformMode(pfiInputXform *ix, int mode, int val);
PFUIDLLEXPORT int
pfiGetIXformMode(pfiInputXform *ix, int mode);
PFUIDLLEXPORT void
pfiResetIXformPosition(pfiInputXform *ix);
PFUIDLLEXPORT void
pfiIXformMat(pfiInputXform *ix, pfMatrix mat);
PFUIDLLEXPORT void
pfiGetIXformMat(pfiInputXform *ix, pfMatrix mat);
Page 131
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT void
pfiIXformInput(pfiInputXform *ix, pfiInput *in);
PFUIDLLEXPORT pfiInput*
pfiGetIXformInput(pfiInputXform *ix);
PFUIDLLEXPORT void
pfiIXformInputCoordPtr(pfiInputXform *ix,
pfiInputCoord *xcoord);
PFUIDLLEXPORT pfiInputCoord*
pfiGetIXformInputCoordPtr(pfiInputXform *ix);
PFUIDLLEXPORT void
pfiIXformMotionCoord(pfiInputXform *ix,
pfiMotionCoord *xcoord);
PFUIDLLEXPORT void
pfiGetIXformMotionCoord(pfiInputXform *ix,
pfiMotionCoord *xcoord);
PFUIDLLEXPORT void
pfiIXformResetCoord(pfiInputXform *ix, pfCoord *resetPos);
PFUIDLLEXPORT void
pfiGetIXformResetCoord(pfiInputXform *ix,
pfCoord *resetPos);
PFUIDLLEXPORT void
pfiIXformCoord(pfiInputXform *ix, pfCoord *coord);
PFUIDLLEXPORT void
pfiGetIXformCoord(pfiInputXform *ix, pfCoord *coord);
PFUIDLLEXPORT void
pfiIXformStartMotion(pfiInputXform *xf, float startSpeed,
float startAccel);
PFUIDLLEXPORT void
pfiGetIXformStartMotion(pfiInputXform *xf,
float *startSpeed, float *startAccel);
PFUIDLLEXPORT void
pfiIXformMotionLimits(pfiInputXform *xf, float maxSpeed,
float angularVel, float maxAccel);
PFUIDLLEXPORT void
pfiGetIXformMotionLimits(pfiInputXform *xf,
float *maxSpeed, float *angularVel, float *maxAccel);
PFUIDLLEXPORT void
pfiIXformDBLimits(pfiInputXform *xf, pfBox *dbLimits);
PFUIDLLEXPORT void
pfiGetIXformDBLimits(pfiInputXform *xf, pfBox *dbLimits);
PFUIDLLEXPORT void
pfiIXformBSphere(pfiInputXform *xf, pfSphere *sphere);
PFUIDLLEXPORT void
pfiGetIXformBSphere(pfiInputXform *xf, pfSphere *sphere);
PFUIDLLEXPORT void
pfiIXformUpdateFunc(pfiInputXform *ix,
pfiInputXformUpdateFuncType func, void *data);
PFUIDLLEXPORT void
pfiGetIXformUpdateFunc(pfiInputXform *ix,
pfiInputXformUpdateFuncType *func, void **data);
Page 132
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT void
pfiIXformMotionFuncs(pfiInputXform *ix,
pfiInputXformFuncType start,
pfiInputXformFuncType stop, void *data);
PFUIDLLEXPORT void
pfiGetIXformMotionFuncs(pfiInputXform *ix,
pfiInputXformFuncType *start,
pfiInputXformFuncType *stop, void **data);
PFUIDLLEXPORT pfiInputXformTrackball *
pfiNewIXformTrackball(void *arena);
PFUIDLLEXPORT void
pfiIXformTrackballMode(pfiInputXformTrackball *tb,
int mode, int val);
PFUIDLLEXPORT int
pfiGetIXformTrackballMode(pfiInputXformTrackball *tb,
int mode);
PFUIDLLEXPORT pfiInputXformTrackball *
pfiCreate2DIXformTrackball(void *arena);
PFUIDLLEXPORT int
pfiUpdate2DIXformTrackball(pfiInputXform *tb,
pfiInputCoord *icoord, void *data);
PFUIDLLEXPORT pfiInputXformSpheric *
pfiNewIXSpheric(void *arena);
mode,
PFUIDLLEXPORT void pfiIXformSphericMode(pfiInputXformSpheric *spheric, int
PFUIDLLEXPORT int
pfiGetIXformSphericMode(pfiInputXformSpheric *spheric,
int mode);
PFUIDLLEXPORT void pfiIXformSphericParameter(pfiInputXformSpheric *spheric,
*spheric,
PFUIDLLEXPORT float pfiGetIXformSphericParameter(pfiInputXformSpheric
PFUIDLLEXPORT pfiInputXformSpheric *
pfiCreate2DIXformSpheric(void *arnea);
PFUIDLLEXPORT int pfiUpdate2DIXformSpheric(pfiInputXform *spheric,
PFUIDLLEXPORT pfType *
pfiGetIXformTravelClassType(void);
PFUIDLLEXPORT pfType *
pfiGetIXformDriveClassType(void);
PFUIDLLEXPORT pfType *
pfiGetIXformFlyClassType(void);
PFUIDLLEXPORT pfType *
pfiGetIXformSphericClassType(void);
PFUIDLLEXPORT pfType *
pfiGetIXformTrackballClassType(void);
PFUIDLLEXPORT pfiInputXformDrive *
pfiNewIXformDrive(void *arena);
PFUIDLLEXPORT void
pfiIXformDriveMode(pfiInputXformDrive *drive, int mode,
int val);
PFUIDLLEXPORT int
pfiGetIXformDriveMode(pfiInputXformDrive *drive,
int mode);
Page 133
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT void
pfiIXformDriveHeight(pfiInputXformDrive* drive,
float height);
PFUIDLLEXPORT float
pfiGetIXformDriveHeight(pfiInputXformDrive* drive);
PFUIDLLEXPORT pfiInputXformDrive *
pfiCreate2DIXformDrive(void *arena);
PFUIDLLEXPORT int
pfiUpdate2DIXformDrive(pfiInputXform *drive,
pfiInputCoord *icoord, void *data);
PFUIDLLEXPORT pfiInputXformFly *
pfiNewIXFly(void *arena);
PFUIDLLEXPORT void
pfiIXformFlyMode(pfiInputXformFly *fly, int mode,
int val);
PFUIDLLEXPORT int
pfiGetIXformFlyMode(pfiInputXformFly *fly, int mode);
PFUIDLLEXPORT pfiInputXformFly *
pfiCreate2DIXformFly(void *arnea);
PFUIDLLEXPORT int
pfiUpdate2DIXformFly(pfiInputXform *fly,
pfiInputCoord *icoord, void *data);
pfiCollide
For realistic motion through a scene, an application must detect
collisions between the viewer and the scene. These functions provide
that functionality. Typical uses of these utilities are to prevent
movement through walls and to maintain a constant "driving" distance
above the ground.
PFUIDLLEXPORT pfType *
pfiGetCollideClassType(void);
PFUIDLLEXPORT pfiCollide *
pfiNewCollide(void *arena);
PFUIDLLEXPORT void
pfiEnableCollide(pfiCollide *collide);
PFUIDLLEXPORT void
pfiDisableCollide(pfiCollide *collide);
PFUIDLLEXPORT int
pfiGetCollideEnable(pfiCollide *collide);
PFUIDLLEXPORT void
pfiCollideMode(pfiCollide *collide, int mode, int val);
PFUIDLLEXPORT int
pfiGetCollideMode(pfiCollide *collide, int mode);
PFUIDLLEXPORT void
pfiCollideStatus(pfiCollide *collide, int status);
PFUIDLLEXPORT int
pfiGetCollideStatus(pfiCollide *collide);
PFUIDLLEXPORT void
pfiCollideDist(pfiCollide *collide, float dist);
Page 134
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT float
pfiGetCollideDist(pfiCollide *collide);
PFUIDLLEXPORT void
pfiCollideHeightAboveGrnd(pfiCollide *collide,
float dist);
PFUIDLLEXPORT float
pfiGetCollideHeightAboveGrnd(pfiCollide *collide);
PFUIDLLEXPORT void
pfiCollideGroundNode(pfiCollide *collide, pfNode* ground);
PFUIDLLEXPORT pfNode *
pfiGetCollideGroundNode(pfiCollide *collide);
PFUIDLLEXPORT void
pfiCollideObjNode(pfiCollide *collide, pfNode* db);
PFUIDLLEXPORT pfNode *
pfiGetCollideObjNode(pfiCollide *collide);
PFUIDLLEXPORT void
pfiGetCollideMotionCoord(pfiCollide *collide,
pfiMotionCoord* xcoord);
PFUIDLLEXPORT void
pfiCollideFunc(pfiCollide *collide,
pfiCollideFuncType func, void *data);
PFUIDLLEXPORT void
pfiGetCollisionFunc(pfiCollide *collide,
pfiCollideFuncType *func, void **data);
PFUIDLLEXPORT int
pfiUpdateCollide(pfiCollide *collide);
pfiPick
The pfiPick utility facilitates user interaction and manipulation of a
scene. It provides a means to translate mouse locations on the screen
into the coordinate space of the world being viewed. Having done this,
it can also determine what objects are being pointed to by the mouse.
PFUIDLLEXPORT pfType *
pfiGetPickClassType(void);
PFUIDLLEXPORT pfiPick *
pfiNewPick(void *arena);
PFUIDLLEXPORT void
pfiPickMode(pfiPick *pick, int mode, int val);
PFUIDLLEXPORT int
pfiGetPickMode(pfiPick *pick, int mode);
PFUIDLLEXPORT void
pfiPickHitFunc(pfiPick *pick, pfiPickFuncType func,
void *data);
PFUIDLLEXPORT void
pfiGetPicktHitFunc(pfiPick *pick, pfiPickFuncType *func,
void **data);
PFUIDLLEXPORT void
pfiAddPickChan(pfiPick *pick, pfChannel *chan);
PFUIDLLEXPORT void
pfiInsertPickChan(pfiPick *pick, int index,
pfChannel *chan);
Page 135
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT void
pfiRemovePickChan(pfiPick *pick, pfChannel *chan);
PFUIDLLEXPORT int
pfiGetPickNumHits(pfiPick *pick);
PFUIDLLEXPORT pfNode *
pfiGetPickNode(pfiPick *pick);
PFUIDLLEXPORT pfGeoSet *
pfiGetPickGSet(pfiPick *pick);
PFUIDLLEXPORT void
pfiSetupPickChans(pfiPick *pick);
PFUIDLLEXPORT int
pfiDoPick(pfiPick *pick, int x, int y);
PFUIDLLEXPORT void
pfiResetPick(pfiPick *pick);
pfiXformer
pfiXformer objects provide a simple means for user-controlled motion in a
scene. The pfiXformer updates a transformation matrix based on a
selected motion model and user input. This transformation matrix can be
used by the application for whatever purposes it desires. In particular,
the matrix can be used to update the viewpoint defined for a pfChannel or
the transformation of a pfDCS node.
PFUIDLLEXPORT pfType*
pfiGetXformerClassType(void);
PFUIDLLEXPORT pfiXformer *
pfiNewXformer(void* arena);
PFUIDLLEXPORT void
pfiXformerModel(pfiXformer* xf, int index,
pfiInputXform* model);
PFUIDLLEXPORT void
pfiSelectXformerModel(pfiXformer* xf, int which);
PFUIDLLEXPORT pfiInputXform*
pfiGetXformerCurModel(pfiXformer* xf);
PFUIDLLEXPORT int
pfiGetXformerCurModelIndex(pfiXformer* xf);
PFUIDLLEXPORT int
pfiRemoveXformerModel(pfiXformer* xf, int index);
PFUIDLLEXPORT int
pfiRemoveXformerModelIndex(pfiXformer* xf,
pfiInputXform* model);
PFUIDLLEXPORT void
pfiStopXformer(pfiXformer* xf);
PFUIDLLEXPORT void
pfiResetXformer(pfiXformer* xf);
PFUIDLLEXPORT void
pfiResetXformerPosition(pfiXformer* xf);
PFUIDLLEXPORT void
pfiCenterXformer(pfiXformer* xf);
PFUIDLLEXPORT void
pfiXformerAutoInput(pfiXformer* xf, pfChannel* chan,
pfuMouse* mouse, pfuEventStream* events);
Page 136
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT void
pfiXformerMat(pfiXformer* xf, pfMatrix mat);
PFUIDLLEXPORT void
pfiGetXformerMat(pfiXformer* xf, pfMatrix mat);
PFUIDLLEXPORT void
pfiXformerModelMat(pfiXformer* xf, pfMatrix mat);
PFUIDLLEXPORT void
pfiGetXformerModelMat(pfiXformer* xf, pfMatrix mat);
PFUIDLLEXPORT void
pfiXformerCoord(pfiXformer* xf, pfCoord *coord);
PFUIDLLEXPORT void
pfiGetXformerCoord(pfiXformer* xf, pfCoord *coord);
PFUIDLLEXPORT void
pfiXformerResetCoord(pfiXformer* xf, pfCoord *resetPos);
PFUIDLLEXPORT void
pfiGetXformerResetCoord(pfiXformer* xf,
pfCoord *resetPos);
PFUIDLLEXPORT void
pfiXformerNode(pfiXformer* xf, pfNode *node);
PFUIDLLEXPORT pfNode *
pfiGetXformerNode(pfiXformer* xf);
PFUIDLLEXPORT void
pfiXformerAutoPosition(pfiXformer* xf, pfChannel *chan,
pfDCS *dcs);
PFUIDLLEXPORT void
pfiGetXformerAutoPosition(pfiXformer* xf,
pfChannel **chan, pfDCS **dcs);
PFUIDLLEXPORT void
pfiXformerLimits(pfiXformer* xf, float maxSpeed,
float angularVel, float maxAccel, pfBox* dbLimits);
PFUIDLLEXPORT void
pfiGetXformerLimits(pfiXformer* xf, float *maxSpeed,
float *angularVel, float *maxAccel, pfBox* dbLimits);
PFUIDLLEXPORT void
pfiEnableXformerCollision(pfiXformer* xf);
PFUIDLLEXPORT void
pfiDisableXformerCollision(pfiXformer* xf);
PFUIDLLEXPORT int
pfiGetXformerCollisionEnable(pfiXformer* xf);
PFUIDLLEXPORT void
pfiXformerCollision(pfiXformer* xf, int mode, float val,
pfNode* node);
PFUIDLLEXPORT int
pfiGetXformerCollisionStatus(pfiXformer* xf);
PFUIDLLEXPORT void
pfiUpdateXformer(pfiXformer* xf);
PFUIDLLEXPORT int
pfiCollideXformer(pfiXformer* xf);
PFUIDLLEXPORT pfType*
pfiGetTDFXformerClassType(void);
Page 137
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUIDLLEXPORT pfiTDFXformer *
pfiNewTDFXformer(void* arena);
PFUIDLLEXPORT pfiXformer *
pfiCreateTDFXformer( pfiInputXformTrackball *tb,
pfiInputXformDrive *drive, pfiInputXformFly *fly,
void *arena);
PFUIDLLEXPORT void
pfiTDFXformerFastClickTime(pfiTDFXformer* xf, float time);
PFUIDLLEXPORT float
pfiGetTDFXformerFastClickTime(pfiXformer* xf);
PFUIDLLEXPORT void
pfiTDFXformerTrackball(pfiTDFXformer *xf,
pfiInputXformTrackball *tb);
PFUIDLLEXPORT pfiInputXformTrackball *
pfiGetTDFXformerTrackball(pfiTDFXformer *xf);
PFUIDLLEXPORT void
pfiTDFXformerDrive(pfiTDFXformer *xf,
pfiInputXformDrive *tb);
PFUIDLLEXPORT pfiInputXformFly *
pfiGetTDFXformerFly(pfiTDFXformer *xf);
PFUIDLLEXPORT void
pfiTDFXformerFly(pfiTDFXformer *xf, pfiInputXformFly *tb);
PFUIDLLEXPORT pfiInputXformDrive *
pfiGetTDFXformerDrive(pfiTDFXformer *xf);
PFUIDLLEXPORT void
pfiTDFXformerSpheric(pfiTDFXformer *xf,
pfiInputXformSpheric *tb);
PFUIDLLEXPORT pfiInputXformSpheric *
pfiGetTDFXformerSpheric(pfiTDFXformer *xf);
PFUIDLLEXPORT int
pfiProcessTDFXformerMouseEvents(pfiInput *,
pfuEventStream *, void *data);
PFUIDLLEXPORT void
pfiProcessTDFXformerMouse(pfiTDFXformer *xf,
pfuMouse *mouse, pfChannel *inputChan);
PFUIDLLEXPORT void
pfiProcessTDFTrackballMouse(pfiTDFXformer *xf,
pfiInputXformTrackball *trackball, pfuMouse *mouse);
PFUIDLLEXPORT void
pfiProcessTDFSphericMouse(pfiTDFXformer *xf,
pfiInputXformSpheric *spheric, pfuMouse *mouse);
PFUIDLLEXPORT void
pfiProcessTDFTravelMouse(pfiTDFXformer *xf,
pfiInputXformTravel *tr, pfuMouse *mouse);
LIBPFUTIL
libpfutil Management
Before using any libpfutil utilities, the library must be initialized.
These functions provide for proper initialization and control of
libpfutil.
Page 138
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuInit(void);
PFUDLLEXPORT void
pfuInitClasses(void);
PFUDLLEXPORT pfDataPool*
pfuGetUtilDPool(void);
PFUDLLEXPORT void
pfuExitUtil(void);
PFUDLLEXPORT void
pfuDPoolSize(long size);
PFUDLLEXPORT long
pfuGetDPoolSize(void);
PFUDLLEXPORT volatile void*
pfuFindUtilDPData(int id);
pfuAutoList C++ API
The pfuAutoList class provides management of a dynamically-sized list of
pfMemory elements and routines to insert and remove elements from the
list. pfuAutoList deletes its elements when the list is deleted.
PFUDLLEXPORT void
pfuInit(void);
PFUDLLEXPORT pfuAutoList*
pfuNewAutoList(int listLength, void *arena);
PFUDLLEXPORT pfType*
pfuGetAutoListClassType(void);
PFUDLLEXPORT int
pfuGetNum(const pfuAutoList* list);
PFUDLLEXPORT void
pfuSet(pfuAutoList* list, int index, void *elt);
PFUDLLEXPORT void*
pfuGet(const pfuAutoList* list, int index);
PFUDLLEXPORT void
pfuResetList(pfuAutoList* list);
PFUDLLEXPORT void
pfuAdd(pfuAutoList* list, void *elt);
PFUDLLEXPORT void
pfuInsert(pfuAutoList* list, int index, void *elt);
PFUDLLEXPORT int
pfuSearch(const pfuAutoList* list, void *elt);
PFUDLLEXPORT int
pfuSearchForType(const pfuAutoList* list, pfType *type);
PFUDLLEXPORT int
pfuRemove(pfuAutoList* list, void *elt);
PFUDLLEXPORT void
pfuRemoveIndex(pfuAutoList* list, int index);
PFUDLLEXPORT int
pfuMove(pfuAutoList* list, int index, void *elt);
PFUDLLEXPORT int
pfuReplace(pfuAutoList* list, void *oldElt, void *newElt);
Page 139
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Processor Control
In certain circumstances, users may wish to control which CPU a
particular IRIS Performer subprocess runs on. They might even wish to
exclusively devote a particular processor to a given subprocess. These
functions provide control of the scheduling of IRIS Performer
subprocesses on a machine's processors.
PFUDLLEXPORT int
pfuRunProcOn(int cpu);
PFUDLLEXPORT int
pfuLockDownProc(int cpu);
PFUDLLEXPORT int
pfuLockDownApp(void);
PFUDLLEXPORT int
pfuLockDownCull(pfPipe *);
PFUDLLEXPORT int
pfuLockDownDraw(pfPipe *);
PFUDLLEXPORT int
pfuLockDownLPoint(pfPipe *);
PFUDLLEXPORT int
pfuPrioritizeProcs(int onOff);
PFUDLLEXPORT int
pfuRunDiskProcsOn(int cpu);
Process Manager C-API
Then pfuProcessManager is a C++ extensible process manager framework bsed
on the pfuBaseProcessManager class with a default process manager class,
pfuDefaultProcessManger for providing a standard policy for allocating
CPUs for IRIS Performer processes and setting priorities for those
processes.
PFUDLLEXPORT void
pfuInitDefaultProcessManager(void);
PFUDLLEXPORT void
pfuReconfigureProcessManager(void);
PFUDLLEXPORT void
pfuReleaseProcessManager(void);
PFUDLLEXPORT void
pfuProcessManagerMode(int mode, int val);
PFUDLLEXPORT int
pfuGetProcessManagerMode(int mode);
PFUDLLEXPORT void
pfuSelectProcessManager(pfuBaseProcessManager *);
PFUDLLEXPORT pfuBaseProcessManager *
pfuGetCurProcessManager(void);
PFUDLLEXPORT void
pfuProcessManagerCreateFunc(pfuProcessHandlerFuncType func,
uint procMask);
PFUDLLEXPORT void
pfuGetProcessManagerCreateFunc(pfuProcessHandlerFuncType *func,
uint *procMask);
Page 140
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuProcessManagerPlaceFunc(pfuProcessHandlerFuncType func,
uint procMask);
PFUDLLEXPORT void
pfuGetProcessManagerPlaceFunc(pfuProcessHandlerFuncType *func,
uint *procMask);
PFUDLLEXPORT void
pfuProcessManagerPrioritizeFunc(pfuProcessHandlerFuncType func,
uint procMask);
PFUDLLEXPORT void
pfuGetProcessManagerPrioritizeFunc(pfuProcessHandlerFuncType *func,
uint *procMask);
PFUDLLEXPORT int
pfuFreeAllCPUs(void);
Clip Center Node C-API
The pfuClipCenterNode is a C++ subclass of the the pfGroup node that can
be placed in the scene graph to manage a cliptexture, automatically
setting the cliptexture center every frame based on the geometry in view.
The clip center node is placed in the scene graph so that its child nodes
contain the geometry textured by the cliptexture. Optionally, the clip
center node can also contain a link to a reference node, which contains a
simplified version of the cliptextured geometry to make the cliptexture
center calculation faster.
PFUDLLEXPORT pfuClipCenterNode *
pfuNewClipCenterNode(void);
PFUDLLEXPORT pfType *
pfuGetClipCenterNodeClassType(void);
PFUDLLEXPORT void
pfuClipCenterNodeCallback(pfuClipCenterNode *ccn,
pfuClipCenterPostAppCallbackType *cb);
PFUDLLEXPORT pfuClipCenterPostAppCallbackType *
pfuGetClipCenterNodeCallback(pfuClipCenterNode *ccn);
PFUDLLEXPORT void
pfuClipCenterNodeRefNode(pfuClipCenterNode *ccn,
pfNode *node);
PFUDLLEXPORT pfNode *
pfuGetClipCenterNodeRefNode(pfuClipCenterNode *ccn);
PFUDLLEXPORT void
pfuClipCenterNodeClipTexture(pfuClipCenterNode *ccn,
pfClipTexture *ct);
PFUDLLEXPORT pfClipTexture *
pfuGetClipCenterNodeClipTexture(pfuClipCenterNode *ccn);
PFUDLLEXPORT void
pfuClipCenterNodeMPClipTexture(pfuClipCenterNode *ccn,
pfMPClipTexture *mpct);
PFUDLLEXPORT pfMPClipTexture *
pfuGetClipCenterNodeMPClipTexture(pfuClipCenterNode *ccn);
PFUDLLEXPORT pfChannel *
pfuGetClipCenterNodeChannel(pfuClipCenterNode *ccn);
Page 141
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuClipCenterNodeChannel(pfuClipCenterNode *ccn,
pfChannel *chan);
SubClass TexGen Clip Center Node C-API
The pfuTexGenClipCenterNode is a subclass node of pfuClipCenterNode. It
uses the eyepoint as the clipcenter by transforing eyepoint from object
space into texture space using pfTexGen. This node is useful when the
cliptexture is projected onto geometry using pfTexGen.
PFUDLLEXPORT pfuTexGenClipCenterNode *
pfuNewTexGenClipCenterNode(void);
PFUDLLEXPORT void
pfuTexGenClipCenterNodeTexGen(pfuTexGenClipCenterNode *ccn,
pfTexGen *tgen);
PFUDLLEXPORT pfTexGen *
pfuGetTexGenClipCenterNodeTexGen(pfuTexGenClipCenterNode *ccn);
Multiprocess Rendezvous
These rendezvous functions provide the functionality necessary for
synchronizing master and slave processes in a multiprocessing
environment.
PFUDLLEXPORT void
pfuInitRendezvous(pfuRendezvous *rvous, int numSlaves);
PFUDLLEXPORT void
pfuMasterRendezvous(pfuRendezvous *rvous);
PFUDLLEXPORT void
pfuSlaveRendezvous(pfuRendezvous *rvous, int id);
Spin-free Barrier
PFUDLLEXPORT pfuBarrier *
pfuBarrierCreate(PF_USPTR_T *usptr);
PFUDLLEXPORT void
pfuBarrierDestroy(pfuBarrier *b);
PFUDLLEXPORT void
pfuBarrierEnter(pfuBarrier *b, uint n);
GLX Mixed Mode
The libpfutil GLX routines are now provided for compatibility with
previous versions of Performer. New development should be done based on
the pfWindow and pfPipeWindow API that provides a single API for managing
IrisGL, Mixed Mode, and OpenGL windows.
PFUDLLEXPORT pfuXDisplay *
pfuOpenXDisplay(int screen);
PFUDLLEXPORT pfuGLXWindow *
pfuGLXWinopen(pfPipe *p, pfPipeWindow *pw,
const char *name);
PFUDLLEXPORT void
pfuGetGLXWin(pfPipe *pipe, pfuGLXWindow *glxWin);
Page 142
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT const char *
pfuGetGLXDisplayString(pfPipe *pipe);
PFUDLLEXPORT void
pfuGLMapcolors(pfVec3 *clrs, int start, int num);
PFUDLLEXPORT int
pfuGLXAllocColormap(pfuXDisplay *dsp, pfuXWindow w);
PFUDLLEXPORT void
pfuGLXMapcolors(pfuXDisplay *dsp, pfuXWindow w,
pfVec3 *clrs, int loc, int num);
PFUDLLEXPORT void
pfuMapWinColors(pfWindow *w, pfVec3 *clrs, int start,
int num);
PFUDLLEXPORT void
pfuMapPWinColors(pfPipeWindow *pwin, pfVec3 *clrs,
int start, int num);
PFUDLLEXPORT void
pfuPrintWinFBConfig(pfWindow *win, FILE *file);
PFUDLLEXPORT void
pfuPrintPWinFBConfig(pfPipeWindow *pwin, FILE *file);
PFUDLLEXPORT pfFBConfig
pfuChooseFBConfig(Display *dsp, int screen,
int *constraints, void *arena);
PFUDLLEXPORT pfuFBConfigConstraint
pfuFBConstraintValue(int constraint, int value,
float weight);
min, int max,
PFUDLLEXPORT pfuFBConfigConstraint pfuFBConstraintRange(int constraint, int
PFUDLLEXPORT pfFBConfig pfuSelectFBConfig(Display *display, int screen,
PFUDLLEXPORT pfFBConfig
pfuChooseWGLFBConfig(GLint *iConstraints, int layer,
void *arena);
Input Handling
These functions provide an interface for managing X and GL event streams.
PFUDLLEXPORT pfuEventQueue *
pfuNewEventQ(pfDataPool *dp, int id);
PFUDLLEXPORT void
pfuResetEventStream(pfuEventStream *es);
PFUDLLEXPORT void
pfuResetEventQ(pfuEventQueue *eq);
PFUDLLEXPORT void
pfuAppendEventQ(pfuEventQueue *eq0, pfuEventQueue *eq1);
PFUDLLEXPORT void
pfuAppendEventQStream(pfuEventQueue *eq,
pfuEventStream *es);
PFUDLLEXPORT void
pfuEventQStream(pfuEventQueue *eq, pfuEventStream *es);
PFUDLLEXPORT pfuEventStream *
pfuGetEventQStream(pfuEventQueue *eq);
Page 143
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuGetEventQEvents(pfuEventStream *events,
pfuEventQueue *eq);
PFUDLLEXPORT void
pfuIncEventQFrame(pfuEventQueue *eq);
PFUDLLEXPORT void
pfuEventQFrame(pfuEventQueue *eq, int val);
PFUDLLEXPORT int
pfuGetEventQFrame(pfuEventQueue *eq);
PFUDLLEXPORT void
pfuIncEventStreamFrame(pfuEventStream *es);
PFUDLLEXPORT void
pfuEventStreamFrame(pfuEventStream *es, int val);
PFUDLLEXPORT int
pfuGetEventStreamFrame(pfuEventStream *es);
PFUDLLEXPORT void
pfuInitInput(pfPipeWindow *pw, int mode);
PFUDLLEXPORT void
pfuInitMultiChanInput(pfChannel **chanArray, int numChans,
int mode);
PFUDLLEXPORT void
pfuExitInput(void);
PFUDLLEXPORT int
pfuMapMouseToChan(pfuMouse *mouse, pfChannel *chan);
PFUDLLEXPORT int
pfuMouseInChan(pfuMouse *mouse, pfChannel *chan);
PFUDLLEXPORT void
pfuCollectInput(void);
PFUDLLEXPORT void
pfuCollectGLEventStream(pfuEventStream *events,
pfuMouse *mouse, int handlerMask,
pfuEventHandlerFuncType handlerFunc);
PFUDLLEXPORT void
pfuCollectXEventStream(pfWSConnection dsp,
pfuEventStream *events, pfuMouse *mouse,
int handlerMask, pfuEventHandlerFuncType handlerFunc);
PFUDLLEXPORT void
pfuGetMouse(pfuMouse *mouse);
PFUDLLEXPORT void
pfuGetEvents(pfuEventStream *events);
PFUDLLEXPORT void
pfuInputHandler(pfuEventHandlerFuncType userFunc,
uint mask);
PFUDLLEXPORT void pfuMouseButtonClick(pfuMouse *mouse,
PFUDLLEXPORT void pfuMouseButtonRelease(pfuMouse *mouse,
PFUDLLEXPORT double
pfuMapXTime(double xtime);
Cursor Control
Each window managed by Performer, both pfWindows and pfPipeWindows, can
have an associated cursor. These functions can be used to manage the
various cursors desired by an application.
Page 144
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT Cursor
pfuGetInvisibleCursor(void);
PFUDLLEXPORT void
pfuLoadPWinCursor(pfPipeWindow *w, int c);
PFUDLLEXPORT void
pfuLoadWinCursor(pfWindow *w, int c);
PFUDLLEXPORT void
pfuLoadChanCursor(pfChannel *chan, int c);
PFUDLLEXPORT Cursor
pfuCreateCursor(Cursor index);
PFUDLLEXPORT void
pfuDraw2DCursor(int mx, int my);
PFUDLLEXPORT void
pfuDrawPWin2DCursor(pfPipeWindow *pw, int mx, int my);
PFUDLLEXPORT void
pfuDrawVChan2DCursor(pfVideoChannel *vChan, int mx,
int my);
PFUDLLEXPORT void
pfuDrawPVChan2DCursor(pfPipeVideoChannel *vChan, int mx,
int my);
PFUDLLEXPORT void
pfuDrawChan2DCursor(pfChannel *chan, int mx, int my);
PFUDLLEXPORT void
pfuCursorColor(pfVec3 fg, pfVec3 bg);
PFUDLLEXPORT void
pfuCursorType(int val);
PFUDLLEXPORT int
pfuGetCursorType(void);
PFUDLLEXPORT void
pfuSelCursor(int c);
PFUDLLEXPORT void
pfuCursor(Cursor c, int index);
PFUDLLEXPORT Cursor
pfuGetCursor(int index);
PFUDLLEXPORT void
pfuInitGUICursors(void);
PFUDLLEXPORT void
pfuGUICursor(int target, int c);
PFUDLLEXPORT Cursor
pfuGetGUICursor(int target);
PFUDLLEXPORT void
pfuGUICursorSel(int sel);
PFUDLLEXPORT Cursor
pfuGetGUICursorSel(void);
PFUDLLEXPORT void
pfuUpdateGUICursor(void);
PFUDLLEXPORT void
pfuDrawChanDVRBox(pfChannel *chan);
OpenGL X Fonts
It is convenient to be able to draw text in Performer windows. When
programming with OpenGL, an application must use X fonts for this
Page 145
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
purpose. These functions simplify the use of X fonts for this purpose by
hiding much of the low-level font management.
PFUDLLEXPORT void
pfuLoadXFont(char *fontName, pfuXFont *fnt);
PFUDLLEXPORT void
pfuLoadWINFont(LOGFONT *lf, pfuXFont *fnt);
PFUDLLEXPORT void
pfuMakeXFontBitmaps(pfuXFont *fnt);
PFUDLLEXPORT void
pfuMakeRasterXFont(char *fontName, pfuXFont *font);
PFUDLLEXPORT void
pfuSetXFont(pfuXFont *);
PFUDLLEXPORT void
pfuGetCurXFont(pfuXFont *);
PFUDLLEXPORT int
pfuGetXFontWidth(pfuXFont *, const char *);
PFUDLLEXPORT int
pfuGetXFontHeight(pfuXFont *);
PFUDLLEXPORT void
pfuCharPos(float x, float y, float z);
PFUDLLEXPORT void
pfuDrawString(const char *s);
PFUDLLEXPORT void
pfuDrawStringPos(const char *s, float x, float y,
float z);
Simple GUI
Many applications require a simple user interface. Their needs are often
far more restricted than the functionality provided by user interface
libraries such as Motif. For those cases in which a simple and efficient
user interface is required, these functions can be used to provide one.
PFUDLLEXPORT void
pfuInitGUI(pfPipeWindow *pw);
PFUDLLEXPORT void
pfuExitGUI(void);
PFUDLLEXPORT void
pfuEnableGUI(int en);
PFUDLLEXPORT void
pfuUpdateGUI(pfuMouse *mouse);
PFUDLLEXPORT pfChannel *
pfuGetGUIChan(void);
PFUDLLEXPORT void
pfuRedrawGUI(void);
PFUDLLEXPORT void
pfuGUIViewport(float l, float r, float b, float t);
PFUDLLEXPORT void
pfuGetGUIViewport(float *l, float *r, float *b, float *t);
PFUDLLEXPORT int
pfuInGUI(int x, int y);
Page 146
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuFitWidgets(int val);
PFUDLLEXPORT void
pfuGetGUIScale(float *x, float *y);
PFUDLLEXPORT void
pfuGetGUITranslation(float *x, float *y);
PFUDLLEXPORT void
pfuGUIHlight(pfHighlight *hlight);
PFUDLLEXPORT pfHighlight *
pfuGetGUIHlight(void);
PFUDLLEXPORT pfuPanel*
pfuNewPanel(void);
PFUDLLEXPORT void
pfuEnablePanel(pfuPanel *p);
PFUDLLEXPORT void
pfuDisablePanel(pfuPanel *p);
PFUDLLEXPORT void
pfuGetPanelOriginSize(pfuPanel *p, float *xo, float *yo,
float *xs, float *ys);
PFUDLLEXPORT pfuWidget *
pfuNewWidget(pfuPanel *p, int type, int id);
PFUDLLEXPORT int
pfuGetWidgetType(pfuWidget *w);
PFUDLLEXPORT void
pfuEnableWidget(pfuWidget *w);
PFUDLLEXPORT void
pfuDisableWidget(pfuWidget *w);
PFUDLLEXPORT void
pfuHideWidget(pfuWidget *w);
PFUDLLEXPORT void
pfuUnhideWidget(pfuWidget *w);
PFUDLLEXPORT int
pfuGetWidgetId(pfuWidget *w);
PFUDLLEXPORT void
pfuWidgetDim(pfuWidget *w, int xo, int yo, int xs,
int ys);
PFUDLLEXPORT void
pfuGetWidgetDim(pfuWidget *w, int *xo, int *yo, int *xs,
int *ys);
PFUDLLEXPORT void
pfuWidgetLabel(pfuWidget *w, const char *label);
PFUDLLEXPORT int
pfuGetWidgetLabelWidth(pfuWidget *w);
PFUDLLEXPORT const char *
pfuGetWidgetLabel(pfuWidget *w);
PFUDLLEXPORT void
pfuWidgetRange(pfuWidget *w, int mode, float min,
float max, float val);
PFUDLLEXPORT void
pfuWidgetValue(pfuWidget *w, float val);
Page 147
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT float
pfuGetWidgetValue(pfuWidget *w);
PFUDLLEXPORT void
pfuWidgetDefaultValue(pfuWidget *w, float val);
PFUDLLEXPORT void
pfuWidgetDrawFunc(pfuWidget *w,
pfuWidgetDrawFuncType func);
PFUDLLEXPORT void
pfuWidgetSelectFunc(pfuWidget *w,
pfuWidgetSelectFuncType func);
PFUDLLEXPORT void
pfuWidgetActionFunc(pfuWidget *w,
pfuWidgetActionFuncType func);
PFUDLLEXPORT pfuWidgetActionFuncType
pfuGetWidgetActionFunc(pfuWidget *w);
PFUDLLEXPORT pfuWidgetSelectFuncType
pfuGetWidgetSelectFunc(pfuWidget *w);
PFUDLLEXPORT pfuWidgetDrawFuncType
pfuGetWidgetDrawFunc(pfuWidget *w);
PFUDLLEXPORT void
pfuWidgetValueScaleFunc(pfuWidget * w, float (*fun)(float,
void*), float (*invfun)(float, void*), void *arg);
PFUDLLEXPORT void
pfuWidgetSelections(pfuWidget *w, pfuGUIString *attrList,
int *valList, void (**funcList)(pfuWidget *w),
int numSelections);
PFUDLLEXPORT void
pfuWidgetSelection(pfuWidget *w, int index);
PFUDLLEXPORT int
pfuGetWidgetSelection(pfuWidget *w);
PFUDLLEXPORT void
pfuWidgetDefaultSelection(pfuWidget *w, int index);
PFUDLLEXPORT void
pfuWidgetDefaultOnOff(pfuWidget * w, int on);
PFUDLLEXPORT void
pfuWidgetOnOff(pfuWidget *w, int on);
PFUDLLEXPORT int
pfuIsWidgetOn(pfuWidget *w);
PFUDLLEXPORT void
pfuWidgetMode(pfuWidget * w, int mode, int val);
PFUDLLEXPORT int
pfuGetWidgetMode(pfuWidget * w, int mode);
PFUDLLEXPORT void
pfuResetGUI(void);
PFUDLLEXPORT void
pfuResetPanel(pfuPanel *p);
PFUDLLEXPORT void
pfuResetWidget(pfuWidget *w);
PFUDLLEXPORT void
pfuDrawTree(pfChannel *chan, pfNode *node,
pfVec3 panXYScale);
Page 148
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuDrawMessage(pfChannel *chan, const char *msg, int rel,
int just, float x, float y, int size, int cmode);
PFUDLLEXPORT void
pfuDrawMessageCI(pfChannel *chan, const char *msg,
int rel, int just, float x, float y, int size,
int textClr, int shadowClr);
PFUDLLEXPORT void
pfuDrawMessageRGB(pfChannel *chan, const char *msg,
int rel, int just, float x, float y, int size,
pfVec4 textClr, pfVec4 shadowClr);
Scene Graph Traversal
Traversals are widely applicable to many tasks required in Performer
applications. These functions provide a customizable, recursive
traversal of an IRIS Performer scene graph.
PFUDLLEXPORT int
pfuTravCountNumVerts(pfNode *node);
PFUDLLEXPORT int
pfuTraverse(pfNode *node, pfuTraverser *trav);
PFUDLLEXPORT void
pfuInitTraverser(pfuTraverser *trav);
PFUDLLEXPORT void
pfuTravCalcBBox(pfNode *node, pfBox *box);
PFUDLLEXPORT void
pfuTravCountDB(pfNode *node, pfFrameStats *fstats);
PFUDLLEXPORT void
pfuTravGLProf(pfNode *node, int mode);
PFUDLLEXPORT void
pfuTravNodeAttrBind(pfNode *node, uint attr, uint bind);
PFUDLLEXPORT void
pfuTravNodeHlight(pfNode *node, pfHighlight *hl);
PFUDLLEXPORT void
pfuTravPrintNodes(pfNode *node, const char *fname);
PFUDLLEXPORT int
pfuFillGSetPackedAttrs(pfGeoSet *gset, int mask);
PFUDLLEXPORT void
pfuDelGSetAttrs(pfGeoSet *gset, int delMask);
PFUDLLEXPORT void
pfuTravCreatePackedAttrs(pfNode *node, int format,
int delMask);
PFUDLLEXPORT void
pfuMeshToQuad(pfGeoSet *gset);
PFUDLLEXPORT void
pfuMeshToTri(pfGeoSet *gset);
PFUDLLEXPORT void
pfuTravMeshToIndep(pfNode *node);
PFUDLLEXPORT void
pfuTravSetDListMode(pfNode *node, int enable);
Page 149
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuTravCompileDLists(pfNode *node, int delMask);
PFUDLLEXPORT void
pfuTravDrawDLists(pfNode *node);
PFUDLLEXPORT int
pfuCalcDepth(pfNode *node);
PFUDLLEXPORT pfNode *
pfuLowestCommonAncestor(pfNode *scene, int (*fun)(pfNode*,
void*), void *arg, int mode);
PFUDLLEXPORT pfNode *
pfuLowestCommonAncestorOfGeoSets(pfNode *scene,
int (*fun)(pfGeoSet*, void*), void *arg, int mode);
PFUDLLEXPORT pfTexture *
pfuFindTexture(pfNode *scene, int i,
int (*fun)(pfGeoState*, pfTexture*, void*), void *arg,
int mode);
PFUDLLEXPORT int
pfuGetClosestPoint(pfNode *node, float eyex, float eyey,
float eyez, const pfTexture *tex, int travmode,
float *x, float *y, float *z, float *s, float *t,
float *r);
PFUDLLEXPORT int
pfuGetNearestVisiblePointToEyePlane(pfNode *node,
pfFrustum *frust, const pfTexture *tex, int travmode,
float *x, float *y, float *z, float *s, float *t,
float *r);
PFUDLLEXPORT int
pfuGetClosestPointOnTriangle(pfVec3 p, pfVec3 v0,
pfVec3 v1, pfVec3 v2, float *closest_distsqrd,
float *W0, float *W1, float *W2);
PFUDLLEXPORT void
pfuFindASDs(pfNode *node, pfList *ASDs);
PFUDLLEXPORT void
pfuProcessClipCenters(pfNode *node,
pfList *mpcliptextures);
PFUDLLEXPORT void
pfuProcessClipCentersWithChannel(pfNode *node,
pfList *mpcliptextures, pfChannel *chan);
PFUDLLEXPORT pfNode *
pfuNewSphereFrontOld(int n, pfTexture *texture,
pfVec2 lonlat[2], pfVec2 st[2], int update_frequency);
PFUDLLEXPORT pfNode *
pfuNewSphereFront(float hightol, float lowtol,
pfTexture *texture, pfVec2 lonlat[2], pfVec2 st[2],
int update_frequency);
PFUDLLEXPORT int
pfuGridifySaveSize(int width, int height, int pixeldepth,
int borderwidth);
PFUDLLEXPORT void
pfuGridifyMem(uchar *buf, int width, int height,
int pixeldepth, int borderwidth,
const uchar color[/* pixeldepth */],
Page 150
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
uchar savecolors[/* pfuGridifySaveSize() */]);
PFUDLLEXPORT void
pfuUnGridifyMem(uchar *buf, int width, int height,
int pixeldepth, int borderwidth,
const uchar savedcolors[/* pfuGridifySaveSize() */]);
PFUDLLEXPORT int
pfuGridifyFileP(const char *infilename_for_errors,
FILE *infp, const char *outfilename_for_errors,
FILE *outfp, int width, int height, int depth,
int borderwidth, uchar color[/* depth */]);
PFUDLLEXPORT int
pfuGridifyFile(const char *filename, int width,
int height, int depth, int borderwidth,
uchar color[/* depth */]);
PFUDLLEXPORT int
pfuGridifyImageTile(pfImageTile *itile, int pixeldepth,
const uchar color[/* pixeldepth */], int isproto);
PFUDLLEXPORT int
pfuUnGridifyImageTile(pfImageTile *itile);
PFUDLLEXPORT int
pfuGridifyImageCache(pfImageCache *icache, int pixeldepth,
uchar color[/* pixeldepth */]);
PFUDLLEXPORT int
pfuUnGridifyImageCache(pfImageCache *icache);
PFUDLLEXPORT int
pfuGridifyClipTexture(pfClipTexture *cliptex);
PFUDLLEXPORT int
pfuUnGridifyClipTexture(pfClipTexture *cliptex);
PFUDLLEXPORT int
pfuGridifyMPClipTexture(pfMPClipTexture *mpcliptex);
PFUDLLEXPORT int
pfuUnGridifyMPClipTexture(pfMPClipTexture *mpcliptex);
PFUDLLEXPORT int
pfuGridifyAnyClipTexture(pfNode *scene, int i);
PFUDLLEXPORT int
pfuUnGridifyAnyClipTexture(pfNode *scene, int i);
PFUDLLEXPORT float
pfuMipMinLOD(pfChannel *chan, pfFrustum *cullfrust,
pfSphere *bsph, float min_dst_dxyz, int logmaxtexdim,
int algorithm);
PFUDLLEXPORT float
pfuCalcSizeFinestMipLOD(pfFrustum *cullFrust,
int viewportWidth, int viewportHeight,
float heightAboveTerrain, float min_dst_dxyz,
int maxtexsize);
PFUDLLEXPORT void
pfuTravCachedCull(pfNode* node, int numChans);
MultiChannel Option
These functions serve as a generic way of initializing channels when
using the Multi-Channel Option (MCO) available on RealityEngine graphics
systems.
Page 151
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuTileChans(pfChannel **chn, int nChans, int ntilesx,
int ntilesy);
PFUDLLEXPORT void
pfuConfigMCO(pfChannel **chn, int nChans);
PFUDLLEXPORT int
pfuGetNumMCOChannels(pfPipe *p);
PFUDLLEXPORT void
pfuTileChan(pfChannel **chn, int thisChan, int nChans,
float l, float r, float b, float t);
MultiPipe Statistics
pfuManageMPipeStats provides a simple mechanism for acquiring frame
timing statistics over a period of time and saving them to a disk file.
PFUDLLEXPORT int
pfuManageMPipeStats(int nFrames, int nSampledPipes);
Path Following
Automated path following can greatly simplify the construction of
interactive walkthrough applications. These functions provide the means
for creating and using automated paths.
PFUDLLEXPORT pfuPath *
pfuNewPath(void);
PFUDLLEXPORT pfuPath *
pfuSharePath(pfuPath *path);
PFUDLLEXPORT pfuPath *
pfuCopyPath(pfuPath *path);
PFUDLLEXPORT pfuPath *
pfuClosePath(pfuPath *path);
PFUDLLEXPORT int
pfuFollowPath(pfuPath *path, float seconds, pfVec3 where,
pfVec3 orient);
PFUDLLEXPORT int
pfuPrintPath(pfuPath *path);
PFUDLLEXPORT int
pfuAddPath(pfuPath *path, pfVec3 first, pfVec3 final);
PFUDLLEXPORT int
pfuAddArc(pfuPath *path, pfVec3 center, float radius,
pfVec2 angles);
PFUDLLEXPORT int
pfuAddFillet(pfuPath *path, float radius);
PFUDLLEXPORT int
pfuAddSpeed(pfuPath *path, float desired, float rate);
PFUDLLEXPORT int
pfuAddDelay(pfuPath *path, float delay);
PFUDLLEXPORT int
pfuAddFile(pfuPath *path, char *name);
Page 152
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Cliptexture Config Utilities
Collision Detection
This is the old utility for collision detection. These functions are
provided to ease the transition of existing Performer-based applications
to the new API. They should not be used in developing new software and
are likely to be removed in a future release. Refer to the reference
pages for more information.
PFUDLLEXPORT void
pfuCollisionChan(pfChannel *chan);
PFUDLLEXPORT pfChannel*
pfuGetCollisionChan(void);
PFUDLLEXPORT void
pfuCollideSetup(pfNode *node, int mode, int mask);
PFUDLLEXPORT int
pfuCollideGrnd(pfCoord *coord, pfNode *node, pfVec3 zpr);
PFUDLLEXPORT int
pfuCollideGrndObj(pfCoord *coord, pfNode *grndNode,
pfVec3 zpr, pfSeg *seg, pfNode *objNode,
pfVec3 hitPos, pfVec3 hitNorm);
PFUDLLEXPORT int
pfuCollideObj(pfSeg *seg, pfNode *objNode, pfVec3 hitPos,
pfVec3 hitNorm);
Timer Control
Tracking the passage of time is essential for interactive applications.
Performer provides pfuTimer objects, which are both real-time and
independent of frame rate.
PFUDLLEXPORT pfuTimer*
pfuNewTimer(void *arena, int size);
PFUDLLEXPORT void
pfuInitTimer(pfuTimer *timer, double start, double delta,
void (*func)(pfuTimer*), void *data);
PFUDLLEXPORT void
pfuStartTimer(pfuTimer *timer);
PFUDLLEXPORT void
pfuStopTimer(pfuTimer *timer);
PFUDLLEXPORT void
pfuEvalTimers(void);
PFUDLLEXPORT int
pfuEvalTimer(pfuTimer *timer);
PFUDLLEXPORT int
pfuActiveTimer(pfuTimer * timer);
Hash Tables
Hash tables are an ubiquitous data structure. They are used internally
by Performer, and many Performer applications will find them very useful.
These functions provide a simple hash table facility to all Performer-
based systems.
Page 153
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT pfuHashTable*
pfuNewHTable(int numb, int eltsize, void* arena);
PFUDLLEXPORT void
pfuDelHTable(pfuHashTable* ht);
PFUDLLEXPORT void
pfuResetHTable(pfuHashTable* ht);
PFUDLLEXPORT pfuHashElt*
pfuEnterHash(pfuHashTable* ht, pfuHashElt* elt);
PFUDLLEXPORT int
pfuRemoveHash(pfuHashTable* ht, pfuHashElt* elt);
PFUDLLEXPORT int
pfuFindHash(pfuHashTable* ht, pfuHashElt* elt);
PFUDLLEXPORT int
pfuHashGSetVerts(pfGeoSet *gset);
PFUDLLEXPORT int
pfuCalcHashSize(int size);
Geometric Simplification
These functions can be used to automatically generate very simple level-
of-detail representations of a subgraph from the bounding boxes of the
geometric objects contained in that subgraph.
PFUDLLEXPORT pfLOD*
pfuBoxLOD(pfGroup *grp, int flat, pfVec4* clr);
PFUDLLEXPORT pfGeoSet*
pfuMakeBoxGSet(pfBox *box, pfVec4 clr, int flat);
Texture Loading
These functions assist in the sharing and downloading of textures, both
of which are important for performance. Sharing of texture data reduces
memory requirements and can subsequently increase efficiency. For
consistent frame rates, it is also very important to download textures
into the graphics pipeline's physical texture memory before beginning
simulation.
PFUDLLEXPORT pfTexture*
pfuNewSharedTex(const char *filename, void *arena);
PFUDLLEXPORT pfList*
pfuGetSharedTexList(void);
PFUDLLEXPORT pfList *
pfuMakeTexList(pfNode *node);
PFUDLLEXPORT pfList *
pfuMakeSceneTexList(pfScene *node);
PFUDLLEXPORT void
pfuDownloadTexList(pfList *list, int style);
PFUDLLEXPORT void
pfuCompressTexList(pfList *list, int style);
PFUDLLEXPORT int
pfuGetTexSize(pfTexture *tex);
Page 154
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Texture Animation
It may be necessary to animate textures to achieve specific visual
effects. These functions allow the application to setup sequences of
textures which define an animation.
PFUDLLEXPORT void
pfuNewTexList(pfTexture *tex);
PFUDLLEXPORT pfList *
pfuLoadTexListFiles(pfList *movieTexList,
char nameList[][PF_MAXSTRING], int len);
PFUDLLEXPORT pfList *
pfuLoadTexListFmt(pfList *movieTexList,
const char *fmtStr, int start, int end);
PFUDLLEXPORT pfSequence *
pfuNewProjector(pfTexture *handle);
PFUDLLEXPORT int
pfuProjectorPreDrawCB(pfTraverser *trav, void *travData);
Detail Texture
The following is a utility for matching a list of detail textures to
their base textures according to a mapping structure and downloading the
detail textures to hardware texture memory.
PFUDLLEXPORT void
pfuLoadDetailTextures(pfList *list, pfuDetailInfo *di,
int ndi);
Texture Memory
The following provides a utility for displaying the contents of hardware
texture memory inside your own window.
PFUDLLEXPORT void
pfuShowTextureMemory( pfPipeWindow *pw, pfList *texList,
int format );
PFUDLLEXPORT void
pfuClearTextureMemory( void );
Random Numbers
Generating good random numbers is very important for many simulation
tasks. These functions provide a portable interface to the system random
number generator which is somewhat more convenient than random.
PFUDLLEXPORT void
pfuRandomize(int seed);
PFUDLLEXPORT long
pfuRandomLong(void);
PFUDLLEXPORT float
pfuRandomFloat(void);
PFUDLLEXPORT void
pfuRandomColor(pfVec4 rgba, float minColor,
float maxColor);
Page 155
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
Flybox Control
These routines provide a simple interface to the BG Systems flybox but do
not provide a flight model based on the flybox.
PFUDLLEXPORT int
pfuOpenFlybox(char *p);
PFUDLLEXPORT int
pfuReadFlybox(int *dioval, float *inbuf);
PFUDLLEXPORT int
pfuGetFlybox(float *analog, int *but);
PFUDLLEXPORT int
pfuGetFlyboxActive(void);
PFUDLLEXPORT int
pfuInitFlybox(void);
Smoke Simulation
These functions simulate the appearance of smoke and fire. They are
included both as a utility in simulations as well as a demonstration of
how to model such phenomena.
PFUDLLEXPORT void
pfuInitSmokes(void);
PFUDLLEXPORT pfuSmoke *
pfuNewSmoke(void);
PFUDLLEXPORT void
pfuSmokeType(pfuSmoke *smoke, int type);
PFUDLLEXPORT void
pfuSmokeOrigin(pfuSmoke* smoke, pfVec3 origin,
float radius);
PFUDLLEXPORT void
pfuSmokeDir(pfuSmoke* smoke, pfVec3 dir);
PFUDLLEXPORT void
pfuSmokeVelocity(pfuSmoke* smoke, float turbulence,
float speed);
PFUDLLEXPORT void
pfuGetSmokeVelocity(pfuSmoke* smoke, float *turbulence,
float *speed);
PFUDLLEXPORT void
pfuSmokeMode(pfuSmoke* smoke, int mode);
PFUDLLEXPORT void
pfuDrawSmokes(pfVec3 eye);
PFUDLLEXPORT void
pfuSmokeTex(pfuSmoke* smoke, pfTexture* tex);
PFUDLLEXPORT void
pfuSmokeDuration(pfuSmoke* smoke, float dur);
PFUDLLEXPORT void
pfuSmokeDensity(pfuSmoke* smoke, float dens, float diss,
float expansion);
PFUDLLEXPORT void
pfuGetSmokeDensity(pfuSmoke* smoke, float *dens,
float *diss, float *expansion);
Page 156
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void
pfuSmokeColor(pfuSmoke* smoke, pfVec3 bgn, pfVec3 end);
LightPointState Utilities
These functions can derive a texture image from a pfLightPoint
specification.
PFUDLLEXPORT void
pfuMakeLPStateShapeTex(pfLPointState *lps, pfTexture *tex,
int size);
PFUDLLEXPORT void
pfuMakeLPStateRangeTex(pfLPointState *lps, pfTexture *tex,
int size, pfFog *fog);
Draw Styles
These functions demonstrate how to use multi-pass rendering to achieve
various special drawing effects. Hidden line elimination and haloed
lines are two examples of effects which can be created using these
functions.
PFUDLLEXPORT void
pfuPreDrawStyle(int style, pfVec4 scribeColor);
PFUDLLEXPORT void
pfuPostDrawStyle(int style);
PFUDLLEXPORT void
pfuPushChanOrtho(pfChannel *chan, float left, float right,
float bottom, float top, float near_, float far_ );
PFUDLLEXPORT void
pfuPopChanOrtho(pfChannel *chan);
PFUDLLEXPORT void
pfuCalcNormalizedChanXY(float* px, float* py,
pfChannel* chan, int xpos, int ypos);
PFUDLLEXPORT void
pfuCalcNormalizedChanXYd(double* px, double* py,
pfChannel* chan, int xpos, int ypos);
PFUDLLEXPORT int
pfuSaveImage(char* name, int xorg, int yorg, int xsize,
int ysize, int saveAlpha);
PFUDLLEXPORT pfPipe *pfuAddMPClipTextureToPipes(pfMPClipTexture *master,
PFUDLLEXPORT void pfuAddMPClipTexturesToPipes(pfList *mpcliptextures,
PFUDLLEXPORT pfClipTexture *
pfuMakeClipTexture(pfuClipTexConfig *config);
PFUDLLEXPORT void
pfuInitClipTexConfig(pfuClipTexConfig *config);
PFUDLLEXPORT void
pfuFreeClipTexConfig(pfuClipTexConfig *config);
PFUDLLEXPORT pfImageCache *pfuMakeImageCache(pfTexture *texture,
PFUDLLEXPORT void
pfuInitImgCacheConfig(pfuImgCacheConfig *config);
PFUDLLEXPORT void
pfuFreeImgCacheConfig(pfuImgCacheConfig *config);
Page 157
Performer(3pf) OpenGL Performer 3.2.2 C++ Reference Page Overview
PFUDLLEXPORT void pfuCalcVirtualClipTexParams(
PFUDLLEXPORT void pfuReallyInvalidateClipTexture(pfClipTexture *clipTex,
PFUDLLEXPORT int pfuCalcTexDerivs(
Page 158
