Index
Prev |  |

## Index

2D tiles
  How the Compositor Functions

3D characters
  3D Text

3D text
  3D Text

3DS format. See formats
  AutoDesk 3DS Format

accessing GL
  Immediate Mode

acreate()
  Creating and Deleting OpenGL Performer Objects
  Allocating Memory With pfMalloc()
  Glossary

activation of traversals
  Database Traversal

active database
  billboards
    pfBillboard Nodes

active scene graph. See application traversal
  Application Traversal

active surface definition
  Active Surface Definiton (ASD)
  Active Surface Definition

adding surfaces
  Building Topology Incrementally: A Single-Traversal Build

addQueryArray
  Adding a Q uery Array

addQueryGeoSets
  Adding a Q uery Array

adjacency information
  Adjacency Information: pfEdge

adjacent surfaces
  tessellation
    Creating and Maintaining Surface Topology

affine transformations
  Matrix Operations

alias, definition
  Glossary

align geometry
  Aligning a Geometry With a pfASD Surface Example

allocating memory. See memory
  Allocating Memory With pfMalloc()

alpha function
  Alpha Function

animation
  pfSequence Nodes
  Animating a Geometry
  using quaternions for
    Quaternion Operations

anisotropic filtering
  Texture Management

antialiasing
  Antialiasing
  Using the pfCompositor Class

APP
  The Functional Stages of a Pipeline

application areas
  rapid rendering
    Why Use OpenGL Performer?
  simulation-based design
    Why Use OpenGL Performer?
  virtual reality
    Why Use OpenGL Performer?
  virtual sets
    Why Use OpenGL Performer?
  visual simulation
    Why Use OpenGL Performer?

application buffer
  pfBuffer
  defined
    Glossary

application traversal
  Application Traversal

ARB fragment programs
  Texture Memory and Hardware Support Checking

ArchVision RPC database format
  ArchVision RPC Format

arenas
  Allocating Memory With pfMalloc()
  defined
    Glossary
  See also shared memory
    Allocating Memory With pfMalloc()

arithmetic, precision of
  Special Coding Tips

ASD
  Active Surface Definiton (ASD)
  Active Surface Definition
  A Very Complex ASD
  and pfEngine
    Aligning Light Points Above a pfASD Surface Example
  cliptexture
    Combining pfClipTex ture and pfASD
  flow chart
    ASD Solution Flow Chart
  paging
    Paging
  simple example
    A Very Simple ASD
  vertices
    Vertices

aspect ratio matching
  Setting Up a Viewing Frustum

assembly mock-up
  Why Use OpenGL Performer?

assignment operators
  Math Operators

asynchronous database paging, definition
  Glossary

asynchronous database processing
  Asynchronous Database Processing

asynchronous deletion
  pfAsyncDelete

asynchronous I/O
  Asynchronous I/O (IRIX only)

atmospheric effects
  enabling
    Atmospheric Effects

attribute binding, definition
  Glossary

attribute data structure
  Attributes

attributes
  Data Structures
  Attributes
  bindings
    Attribute Bindings
    `libpr` Databases
  flat-shaded
    Attribute Bindings
  global
    Global Attributes
  overview
    Attributes
  traversals
    Database Traversal

AutoCAD
  AutoCAD DXF Format

automatic type casting
  Base Classes

average statistics
  The pfStats Data Structure
  See also statistics
    The pfStats Data Structure

avoiding cracks
  Creating and Maintaining Surface Topology

axes, default
  Setting Up a Viewpoint

axially aligned boxes
  Axially Aligned Boxes

backface culling
  CULL Sidekick Processes
  Cull Sidekick Processes
  CULL Sidekick Optimization Mask

base classes
  Base Classes

base geometry
  Decals
  definition
    Glossary

basic-block counting
  Using `pixie`, `prof`, and `gprof` to Measure Performance

behaviors
  Application Traversal

bezel, definition
  Glossary

Bezier curves
  Features of NURBS and Bezier Curves

bilinear interpolation
  Ruled Surfaces

billboards
  pfBillboard Nodes
  Graphics and Modeling Techniques to Improve Performances
  defined
    Glossary
  implementation using sprites
    Sprite Transformations

BIN format. See formats
  SGI BIN Format

binary operators
  Math Operators

binning, definition
  Glossary

bins
  Sorting the Scene
  definition
    Glossary

blended transparency
  Transparency

blur
  Dynamic Texture Resolution

blur margin
  Changing Levels
  Glossary

bottlenecks
  CULL Process Optimizations
  Graphics Pipeline Tuning Tips
  fill
    Fill Bottlenecks
  host
    Host Bottlenecks
  transform
    Transform Bottlenecks

bounding volumes
  defined
    Glossary
  example code
    Bounding Volumes
  See also volumes
    Bounding Volumes

b-reps
  Summary of Scene Graph Topology: pfTopo

B-splines See NURBS
  NURBS Overview

buffer scope
  pfBuffer
  defined
    Glossary

BYU format. See formats
  Brigham Young University BYU Format

C++, See OpenGL Performer C++ API
  Programming with C++

caching
  intersections
    Efficient Intersection and Traversals
  state changes
    Draw Stage and Graphics Pipeline Optimizations

CAD applications
  higher-order primitives
    Higher-Order Geometric Primitives
  moving viewpoint
    Spatial Curves

CAD data
  NURBS
    NURBS Overview

callbacks
  culling
    Paths through the Scene Graph
    pfNode Cull and Draw Callbacks
  customized culling
    Cull Traversal
  discriminators for intersections
    Discriminator Callbacks
  draw
    pfNode Cull and Draw Callbacks
  function
    pfNode Cull and Draw Callbacks
  node
    pfNode Cull and Draw Callbacks
  post-cull
    pfNode Cull and Draw Callbacks
  post-draw
    pfNode Cull and Draw Callbacks
  pre-cull
    pfNode Cull and Draw Callbacks
  pre-draw
    pfNode Cull and Draw Callbacks
  process
    Process Callbacks

calligraphic light point
  Calligraphic Light Points

calligraphic lights, number of
  Maximum Number of Calligraphic Lights

calligraphic vs. raster displays
  Calligraphic Versus Raster Displays

calligraphic, color correction
  Color Correction

calligraphic, simulating
  Debugging Calligrap hic Lights on Non-Calligraphic Systems

CASEVision
  Performance Measurement Tools

Catmull-Clark subdivision
  Creating a Subdivision Surface
  Loop and Catmull-Clark Subdivisions
  The libpfsubdiv Pseudo Loader

channels
  Channels
  channel share group
    Using Channel Groups
    definition
      Glossary
  configuring
    Using Channels
    Creating and Configuring a pfChannel
  creating
    Creating and Configuring a pfChannel
  definition
    Glossary
  multiple, rendering
    Using Multiple Channels
  share mask, definition
    Glossary

children, of a node, definition
  Glossary

circles
  in space
    Circles in Space
  in the plane
    Circles in the Plane

class hierarchy, definition
  Glossary

class inheritance
  Base Classes
  Base Classes
  definition
    Glossary

classes
  libpf
    pfBillboard
      pfNode
      pfBillboard Nodes
      Header Files
    pfBuffer
      Header Files
      Asynchronous Database Processing
    pfChannel
      Setting Up the Display Environment
      Creating and Configuring a pfChannel
      Header Files
      Header Files
      Configuring pfPipeWindows and pfChannels
    pfDCS
      pfNode
      pfDCS Nodes
      pfDoubleDCS Nodes
      State Inheritance
      Header Files
    pfDoubleDCS
      pfNode
      Header Files
    pfDoubleFCS
      pfNode
      Header Files
    pfDoubleSCS
      pfNode
      Header Files
    pfEarthSky
      Setting Up a Scene
      Header Files
      Using pfEarthSky
    pfFrameStats
      Statistics
    pfGeode
      pfNode
      pfGeode Nodes
      Header Files
    pfGroup
      pfNode
      Header Files
    pfIBRnode
      Creating a pfIBRnode
      ArchVision RPC Format
    pfIBRtexture
      Creating a pfIBRtexture
      ArchVision RPC Format
    pfLayer
      pfNode
      pfLayer Nodes
      Header Files
    pfLightPoint
      Header Files
    pfLightSource
      pfNode
      Header Files
    pfLOD
      pfNode
      pfLOD Nodes
      Header Files
      Header Files
    pfLODState
      Header Files
    pfMPClipTexture
      Header Files
      Pipes
    pfNode
      Nodes
      pfNode
      pfNode Attributes
      pfNode Operations
      Header Files
    pfPartition
      pfNode
      pfPartition Nodes
      Header Files
    pfPath
      Header Files
    pfPipe
      Setting Up the Display Environment
      Creating and Configuring a pfPipe
      Header Files
      Using the Default Hyperpipe Mapping to Graphic Pipes
    pfPipeVideoChannel
      Header Files
    pfPipeWindow
      Setting Up the Display Environment
      Header Files
      Configuring pfPipeWindows and pfChannels
      Configuring pfPipeWindows and pfChannels
      Using pfPipeWindows
    pfRotorWash
      Header Files
    pfScene
      Setting Up the Display Environment
      pfNode
      pfScene Nodes
      Header Files
    pfSCS
      pfNode
      pfSCS Nodes
      pfDoubleSCS Nodes
      State Inheritance
      Header Files
    pfSequence
      pfNode
      pfSequence Nodes
      Header Files
    pfShader
      Header Files
      Header Files
    pfShaderManager
      Header Files
    pfShadow
      Creating a pfShadow
    pfSwitch
      pfNode
      pfSwitch Nodes
      Header Files
    pfText
      pfNode
      Header Files
    pfTraverser
      Header Files
    pfVolFog
      Header Files
      Patchy Fog and Layered Fog
  libpfdu
    pfdBuilder
      Creating an OpenGL Performer Database Converter using `libpfdu`
    pfdGeom
      Creating an OpenGL Performer Database Converter using `libpfdu`
    pfdPrim
      Creating an OpenGL Performer Database Converter using `libpfdu`
  libpfv
    pfvDisplayMngr
      Importing OpenGL Multipipe SDK (MPK) Configuration Files
    pfvInteractor
      Picking, Selection, and Interaction
    pfvPicker
      Picking, Selection, and Interaction
    pfvSelector
      Picking, Selection, and Interaction
    pfvViewer
      Importing OpenGL Multipipe SDK (MPK) Configuration Files
      Overview
  libpr
    pfBox
      Header Files
      Axially Aligned Boxes
    pfClipTexture
      Header Files
      Pipes
    pfColortable
      Header Files
    pfCompositor
      Using the pfCompositor Class
    pfCycleBuffer
      Header Files
      CycleBuffers
    pfCycleMemory
      Header Files
      CycleBuffers
    pfCylinder
      Header Files
      Cylinders
    pfDataPool
      Header Files
      Datapools
    pfDispList
      Header Files
      Draw Stage and Graphics Pipeline Optimizations
    pfFBState
      Header Files
    pfFile
      Header Files
    pfFog
      Header Files
    pfFont
      Header Files
      pfFont
    pfFrustum
      Header Files
    pfGeoArray
      pfGeoArray (Geometry Array)
    pfGeoSet
      Header Files
      pfGeoSet (Geometry Set)
      Draw Stage and Graphics Pipeline Optimizations
    pfGeoState
      Header Files
    pfHighlight
      Header Files
      Header Files
    pfHit
      Header Files
      Intersecting with pfGeoSets
    pfLight
      Header Files
    pfLightModel
      Header Files
    pfList
      Header Files
    pfLoadBalance
      Load Balancing
    pfLPointState
      Header Files
    pfMaterial
      Header Files
    pfMatrix
      Header Files
      Matrix Operations
    pfMatStack
      Header Files
      Matrix Stack Operations
    pfMemory
      Header Files
    pfObject
      Header Files
    pfPassList
      Header Files
    pfPlane
      Half-spaces (Planes)
    pfPolytope
      Header Files
    pfQuat
      Header Files
      Quaternion Operations
    pfQueue
      `libpr` Support
    pfSeg
      Header Files
      Creating and Working with Line Segments
    pfSegSet
      Intersection Requests: pfSegSets
      Header Files
    pfSphere
      Header Files
      Spheres
    pfSprite
      Header Files
      Sprite Transformations
    pfState
      Header Files
    pfStats
      Header Files
      Statistics
      The pfStats Data Structure
    pfString
      Header Files
      pfString
    pfTexEnv
      Header Files
    pfTexGen
      Header Files
    pfTexture
      Header Files
      Configuring a pfTexture
    pfType
      Header Files
    pfVec2
      Header Files
      Vector Operations
    pfVec3
      Header Files
      Vector Operations
    pfVec4
      Header Files
      Vector Operations
    pfWindow
      Header Files

clearTessellation()
  Reading and Writing Topology Information: Using Pseudo Loaders

clip center
  Overview
  Updating the Clipce nter

clip center node
  Clipcenter Node

clip region
  Overview

clip size
  Overview

clip_size
  virt_size and clip_size

clipfly application
  Sample Applications

clipped level
  Why Do These Assumptions Work?

clipped, definition
  Glossary

clipping planes, definition
  Glossary

cliptexture
  ClipTextures
  Load-Time Configuration
  Glossary
  and ASD
    Combining pfClipTex ture and pfASD
  center
    Centering
  configuration
    Cliptexture Configuration
    Cliptexture Configuration
  inset
    Cliptexture Insets
  invalidating
    Invalidating Cliptextures
  load control
    Cliptexture Load Control
  loaders
    Loaders that Support Cliptextures
  manipulating
    Manipulating Cliptextures
  multipipe applications
    Using Cliptextures in Multipipe Applications
  multiprocessing
    MPClipTextures
  preprocessing
    Cliptexture API
  read queue
    Read Queue Sorting
  sample code
    Cliptexture Sample Code
  slave
    Slave Cliptextures with Offset Centers
  slave and master
    Making Masters and Slaves
    When to Make Master/Slave Cliptexture Groups
  test and demo programs
    Test and Demo Pro grams
  utility code
    Cliptexture Utility Code
  virtual
    Virtual Cliptextures on InfiniteReality Systems
    Virtual ClipTextures
    Virtualizing Cliptextures
  with multiple pipes
    Using Cliptextures with Multiple Pipes

clocks
  high-resolution
    High-Resolution Clocks

cloned instancing
  Cloned Instancing
  definition
    Glossary

clones
  Clones

cloning, definition
  Glossary

close()
  Asynchronous I/O (IRIX only)

closed loop control system
  Dynamic Load Management

code examples. See example code
  An Example of Scene Creation

color correction
  Color Correction

compiled mode
  pfGeoSet Draw Mode
  definition
    Glossary

complex pixels, definition
  Glossary

composite curves
  Curves on Surfaces: pfCompositeCurve3d

compositors
  Using Scalable Graphics Hardware
  How the Compositor Functions
  Using the pfCompositor Class

computer aided design
  Why Use OpenGL Performer?

cones
  pfConeSurface

configuration
  cliptexture
    Cliptexture Configuration
    Cliptexture Configuration
  cliptexture files
    Configuration Files
  cliptexture utilities
    Configuration Utilities
  default tile
    Configuring the Default Tile
  files
    cliptextures
      Configuration Files
    MPK
      Importing OpenGL Multipipe SDK (MPK) Configuration Files
    XML
      Reading XML Configuration Files
      More Sample Programs, Configuration Files, and Source Code
  image cache
    Configuring an Image Cache
    Image Cache Configuration
    Image Cache Configuration File Details
    Configuration Fields
    Image Cache Configuration File Description
  image cache levels
    Configuring an Image Cache Level
  image cache proto tile
    Configuring an Image Cache Proto Tile
  image tile
    Configuring Image Tiles
  load time
    Load-Time Configuration
  optional image cache
    Optional Image Cache Configuration Files
  pfChannel
    Creating and Configuring a pfChannel
  pfFrustum
    Setting Up a Viewing Frustum
  pfPipe
    Creating and Configuring a pfPipe
  pfPipeWindow
    Using pfPipeWindows
  pfScene
    Setting Up a Scene
  pfTexture
    Configuring a pfTexture
  viewpoint
    Setting Up a Viewpoint
  viewport
    Setting Up a Viewport

configuration file
  creating
    Creating Configuration Files

connecting surface patches
  Collecting Connected Surfaces: pfSolid

containment, frustum
  Visibility Testing

control hull, NURBS
  Control Hull

control parameters for NURBS
  NURBS Elements That Determine the Control Parameters

conventions
  typographical
    Conventions

Coons patch
  Coons Patches

coordinate mismatches
  Overview of Topology Tasks

coordinate systems
  Setting Up a Viewpoint
  dynamic. See pfDCS nodes
    pfDCS Nodes
    pfDoubleDCS Nodes
  static. See pfSCS nodes
    pfSCS Nodes
    pfDoubleSCS Nodes

coplanar geometry
  pfLayer Nodes
  Decals
  Decals

copying pfObjects
  Copying Objects with pfCopy()

core dump
  from aggregate pfObject allocation
    Creating and Deleting OpenGL Performer Objects
  from mixing malloc() and pfFree()
    Allocating Memory With pfMalloc()
  from mixing pfMalloc() and free()
    Allocating Memory With pfMalloc()
  from static pfObject allocation
    Creating and Deleting OpenGL Performer Objects
  from unshared pfObject allocation
    Creating and Deleting OpenGL Performer Objects

Coryphaeus
  DWB format
    `libpfdu` - Utilities for Creating Efficient OpenGL Performer Run-Time Structures

cost tables
  Cost Tables
  Glossary

counter, video
  Video Refresh Counter (VClock)

counting, basic-block
  Using `pixie`, `prof`, and `gprof` to Measure Performance

CPU statistics
  CPU Statistics

cracks
  avoiding
    Creating and Maintaining Surface Topology
  possible reasons
    Overview of Topology Tasks

critically damped, definition
  Glossary

.csb files
  Reading and Writing Topology Information: Using Pseudo Loaders

cube map textures
  Texture Formats
  Texture Formats

CULL
  The Functional Stages of a Pipeline
  backface culling
    CULL Sidekick Processes
    Cull Sidekick Processes
    CULL Sidekick Optimization Mask
  sidekick processes
    CULL Sidekick Processes
    Cull Sidekick Processes

cull programs
  Cull Programs

cull volume visualization, definition
  Glossary

culling
  callbacks
    Cull Traversal
  definition
    Glossary
  efficient
    Organizing a Database for Efficient Culling
  multithreading
    Multithreading
  See also traversals
    Database Traversal
  traversal
    Cull Traversal

cull-overlap-draw multiprocessing model
  Cull-Overlap-Draw Mode

cumulative statistics
  The pfStats Data Structure
  See also statistics
    The pfStats Data Structure

current statistics
  The pfStats Data Structure
  See also statistics
    The pfStats Data Structure

curves
  and trim loops
    Defining Edges of a Parametric Surface: Trim Loops and Curves
  composite
    Curves on Surfaces: pfCompositeCurve3d
  discrete curves in space
    Discrete Curves in Space
  discrete curves in the plane
    Discrete Curves in the Plane
  Hermite spline
    Hermite Spline Curves in Space
  in space
    Spatial Curves
  in the plane
    Planar Curves
  NURBS
    Trimmed NURBS
  NURBS curve
    NURBS Surfaces
  superquadric
    Superquadrics in Space
  trim curve
    Defining Edges of a Parametric Surface: Trim Loops and Curves
  using splines
    Hermite-Spline Curves in the Plane

cut-ins
  How the Compositor Functions

cycle buffers
  Passthrough Data
  CycleBuffers

cylinders
  pfCylinderSurface
  as bounding volumes
    Cylinders
  bounding
    Efficient Intersection and Traversals

data fusion
  defined
    Glossary

data structures
  Data Structures

database loaders
  Initialization and Type Definition

database paging
  Organizing a Database for Efficient Culling
  Asynchronous Database Processing
  definition
    Glossary

databases
  importing
    Importing Databases
  optimization
    Balancing Cull and Draw Processing with Database Hierarchy
  organization
    Database Organization
    Organizing a Database for Efficient Culling
  traversals
    Database Traversal

datapools. See pfDataPool data structures
  Datapools

dbx
  See debugging
    Use the Simplest Process Model

DCS. See pfDCS nodes
  pfDCS Nodes
  pfDoubleDCS Nodes

debug libraries, definition
  Glossary

debugging
  dbx
    Use the Simplest Process Model
  guidelines
    Guidelines for Debugging
  ogldebug
    Using `ogldebug` to Observe Graphics Calls
  shared memory and
    Shared Memory

decal geometry, definition
  Glossary

decals
  Generating Decals
  See also coplanar geometry
    Decals

decomposition
  hardware decomposition
    How the Compositor Functions
  spatial
    Hyperpipe Concepts
  temporal
    Hyperpipe Concepts

decomposition modes
  Using the pfCompositor Class

default tile
  configuration
    Configuring the Default Tile

deleting objects
  pfDelete() and Reference Counting

depth complexity, definition
  Glossary

detail texture
  Graphics and Modeling Techniques to Improve Performances

device, streaming
  num_streams, s_streams, t_streams, and r_streams

disabling graphics modes
  Enable / Disable

discrete curves
  in space
    Discrete Curves in Space
  in the plane
    Discrete Curves in the Plane

discriminator callbacks
  for intersections
    Discriminator Callbacks

displace decaling
  Decals
  defined
    Glossary

display list
  Display Lists
  Draw Stage and Graphics Pipeline Optimizations
  definition
    Glossary

display list mode
  pfGeoSet Draw Mode

display, raster vs. calligraphic
  Calligraphic Versus Raster Displays

display, stereo
  One Window per Pipe, Multiple Channels per Window

displaying statistics. See statistics
  Statistics

DLL (dynamic link library) files
  pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer

dlopen()
  Loading Process Internals
  Finding and initializing a Converter

dlsym()
  Loading Process Internals
  Finding and initializing a Converter

double-precision arithmetic
  Special Coding Tips

double-precision matrices
  pfDoubleSCS Nodes
  pfDoubleDCS Nodes
  pfDoubleFCS Nodes

download time
  cliptexture
    Download Time

DPLEX (Video Digital Multiplexer)
  Using Scalable Graphics Hardware

DRAW
  The Functional Stages of a Pipeline

DRaW Computing Associates
  WRL Format

draw mask
  pfNode Draw Mask

draw mask, definition
  Glossary

draw traversals. See traversals
  Database Traversal

drop, definition
  Glossary

DSO (dynamic shared object) files
  pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer

DTR
  Load Cont rol
  Dynamic Texture Resolution

DVR
  Maintaining Frame Rate Using D ynamic Vid eo Res olution

DWB format. See formats
  Designer's Workbench DWB Format

DXF format. See formats
  AutoCAD DXF Format

dynamic coordinate systems. See pfDCS nodes
  pfDCS Nodes
  pfDoubleDCS Nodes

dynamic link library (DLL) files
  pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer

dynamic shared object (DSO) files
  pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer
  Glossary

Dynamic Texture Resolution
  Cliptexture Load Control

dynamic video resolution
  Maintaining Frame Rate Using D ynamic Vid eo Res olution

dynamic, definition
  Glossary

earth/sky model
  Setting Up a Scene

edges
  defining
    Defining Edges of a Parametric Surface: Trim Loops and Curves

effective levels
  Virtual Cliptextures on InfiniteReality Systems

effects, atmospheric, enabling
  Atmospheric Effects

elastomeric propulsion system
  Setting Up a Viewpoint

enabling
  atmospheric effects
    Atmospheric Effects
  fog
    Atmospheric Effects
  graphics modes
    Enable / Disable
  statistics classes
    Statistics Rules of Use

engine, and ASD
  Aligning Light Points Above a pfASD Surface Example

enterView()
  Extending a pfvViewer—Module Entry Points

enterWorld()
  Extending a pfvViewer—Module Entry Points

environment variables
  DISPLAY
    Communicating with the Window System
  LD_LIBRARY_PATH
    Shell Environment Variables
    Using `pixie`, `prof`, and `gprof` to Measure Performance
    Using `pixie`, `prof`, and `gprof` to Measure Performance
  PFHOME
    Shell Environment Variables
  PFLD_LIBRARY_PATH
    Shell Environment Variables
  PFNFYLEVEL
    Error Handling and Notification
  PFPATH
    File Search Paths
    File Search Paths
    File Search Paths
  PFTMPDIR
    Shared Arenas
  PROFDIR
    Using `pixie`, `prof`, and `gprof` to Measure Performance

environmental model
  Setting Up a Scene

error handling
  floating-point operations
    Avoid Floating-Point Exceptions
  notification levels
    Error Handling and Notification

Euler angles
  Setting Up a Viewpoint
  defined
    Glossary

evaluation function
  Evaluation Function
  default
    Default Evaluation Function
  overriding
    Overriding the Default Evaluation Function
  timing
    ASD Evaluation Function Timing

evaluator functions
  Mathematical Description of a Planar Curve

evanalyzer program
  Viewing Events—`evanalyzer`

EventView performance analyzer
  EventView—A Performance Analyzer

evgraph program
  Using EventView Tools

evhist program
  Using EventView Tools

evmerge program
  Using EventView Tools

evpp program
  Using EventView Tools

example code
  bounding volume
    Bounding Volumes
  C++
    invalid creation of objects
      Creating and Deleting OpenGL Performer Objects
    valid creation of objects
      Creating and Deleting OpenGL Performer Objects
  calligraphic lights
    Calligraphic Light Example
  converting to pfFlux
    Converting to pfFlux
  convex polyhedrons
    Intersecting with Volumes
  creating cloned instances
    Cloned Instancing
  cull-process callbacks
    Process Callbacks
  database loaders
    Initialization and Type Definition
  default stress function
    Dynamic Load Management
  fill statistics
    Fill Statistics
  frame control
    Sample Code
  graphics state
    Pushing and Popping State
  hierarchy construction
    pfGroup
  highlighting
    Highlights
  hyperpipes
    Establishing the Number of Graphic Pipes
    Using Nondefault Hyperpipe Mappings to Graphics Pipes
    Using Nondefault Hyperpipe Mappings to Graphics Pipes
  intersection routines
    General Math Routine Example Program
  libpf
    Defining Virtual Functions
  libpfutil
    Process Pipeline Tuning Tips
    Draw Process Tips
  light point process
    How the Light Point Process Works
  LOD
    Level-of-Detail Range Processing
  matrices and vectors
    Matrix Operations
  MIPmap
    Texture
  Motif
    Motif
  passthrough data
    Process Callbacks and Passthrough Data
  Perfly
    Glossary
  pfASD
    Aligning Light Points Above a pfASD Surface Example
  pfBillboard
    pfBillboard Nodes
  pfCalligraphic
    Frame to Frame Control
  pfChannel
    One Window per Pipe, Multiple Channels per Window
    Using Channel Groups
    Example of Channel Use
  pfCopy()
    Copying Objects with pfCopy()
  pfDecal
    Decals
  pfDelete()
    pfDelete() and Reference Counting
  pfEarthSky()
    Using pfEarthSky
  pfFont
    pfFont
  pfGeoSet
    Fluxed Geosets
  pfGeoSets
    pfGeode Nodes
  pfGeoStates
    Applying pfGeoStates
  pfLayer
    pfLayer Nodes
  pfNode
    pfNode Cull and Draw Callbacks
  pfOverride
    State Override
  pfPartition
    pfPartition Nodes
  pfPipe
    Clones
  pfPipe use
    Example of pfPipe Use
  pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    pfPipeWindows in Action
  pfPipeWindows
    Clones
  pfScene
    An Example of Scene Creation
  pfSequence
    pfSequence Nodes
  pfString
    pfString
    pfString
  pfStrings
    pfText Nodes
  pfSwitch
    pfSequence Nodes
  pfTexture
    Texture
  pfWindow
    Creating a pfWindow
    More pfWindow Examples
    More pfWindow Examples
    More pfWindow Examples
    More pfWindow Examples
  raster callback
    Callbacks
  scene graph traverser
    Determining Ob ject Type
  static member data
    Static Member Data
  statistics
    Displaying Statistics Simply
    Setting Statistics Class Enables and Modes
  transformation inheritance
    Sample Program
  user data
    User Data
  X input
    Draw Process Tips

exceptions, floating-point
  Avoid Floating-Point Exceptions

exec()
  Shared Memory

exitView()
  Extending a pfvViewer—Module Entry Points

exitWorld()
  Extending a pfvViewer—Module Entry Points

ext_format
  ext_format, int_format, and img_format
  ext_format, int_format, and img_format

extending bounding volumes
  Creating Bounding Volumes

extensibility
  callback functions
    Defining Virtual Functions
  subclassing
    Subclassing pfObjects
  user data
    User Data

face culling
  Frontface / Backface

fade count
  Changing Levels
  Glossary

field of view
  Setting Up a Viewing Frustum

field, video
  Stage Timing Graph

file formats
  conversions
    Reading and Writing Topology Information: Using Pseudo Loaders

files
  database formats
    Supported Database Formats
  loading. See databases
    Importing Databases

fill statistics
  Fill Statistics
  See also statistics
    Fill Statistics

filter
  stress filter
    Customizing DVR

finite-precision coordinate mismatches
  Overview of Topology Tasks

fixed frame rates
  Frame Rate Management
  defined
    Glossary

flat-shaded line strip
  Primitive Connectivity

flat-shaded primitives
  pfGeoSet Draw Mode

flatten, definition
  Glossary

FLIGHT format. See formats
  MultiGen OpenFlight Format

flimmering
  Decals
  Glossary

floating phase, definition
  Glossary

floating-point exceptions
  Process Pipeline Tuning Tips
  Avoid Floating-Point Exceptions

flux sync groups
  Synchronizing pfFluxes with Flux Sync Groups

fog
  Patchy Fog and Layered Fog
  atmospheric effects
    Atmospheric Effects
  configuring
    Fog
  data structures
    Fog
    Atmospheric Effects
  enabling
    Atmospheric Effects
  performance cost
    Transform Bottlenecks

fork()
  Multiprocessing and Memory
  Shared Memory
  Initializing Shared Memory

formats
  3DS
    AutoDesk 3DS Format
  BIN
    SGI BIN Format
  BYU
    Brigham Young University BYU Format
  DWB
    Designer's Workbench DWB Format
  DXF
    AutoCAD DXF Format
  FLIGHT
    MultiGen OpenFlight Format
  GDS
    McDonnell-Douglas GDS Format
  GFO
    SGI GFO Format
  IM
    SGI IM Format
  IRTP
    AAI/Graphicon IRTP Format
  list of
    Supported Database Formats
  LSA
    Lightscape Technologies LSA and LSB Formats
  LSB
    Lightscape Technologies LSA and LSB Formats
  Maya databases
    The Maya Database Exporter
  MEDIT
    Medit Productions MEDIT Format
  NFF
    NFF Neutral File Format
  OBJ
    Wavefront Technology OBJ Format
  Open Inventor
    SGI Open Inventor Format
  PHD
    SGI PHD Format
  POLY
    Side Effects POLY Format
  PTU
    SGI PTU Format
  RPC
    ArchVision RPC Format
  SGF
    USNA Standard Graphics Format
  SGO
    SGI SGO Format
  SPF
    USNA Simple Polygon File Format
  SPONGE
    Sierpinski Sponge Loader
  STAR
    Star Chart Format
  STL
    3D Lithography STL Format
  SV
    SuperViewer SV Format
  TRI
    Geometry Center Triangle Format
  UNC
    UNC Walkthrough Format
  VRML
    SGI Open Inventor Format

FOV. See field of view
  Setting Up a Viewing Frustum

fragment programs
  Rendering Modes
  Enable / Disable
  Rendering Attributes
  Using OpenGL Performer with GPUs
  Texture Memory and Hardware Support Checking

frame accurate, definition
  Glossary

frame rate
  Maintaining Frame Rate Using D ynamic Vid eo Res olution

frame()
  Extending a pfvViewer—Module Entry Points

frames
  definition
    Glossary
  management
    Frame Rate Management
  overrun
    Fixing the Frame Rate
  synchronization
    Frame Synchronization

free()
  Allocating Memory With pfMalloc()

free-store management
  pfDelete() and Reference Counting

Frenet frame
  pfFrenetSweptSurface

frustum
  Setting Up a Viewing Frustum
  Setting Up a Viewing Frustum
  as camera. See channel
    Frusta
  as culling volume
    Frusta
  definition of
    Glossary

FSAA (See full-scene antialiasing.)
  How the Compositor Functions

full-scene antialiasing (FSAA)
  How the Compositor Functions

function callbacks
  pfNode Cull and Draw Callbacks

functions
  naming
    Naming in C and C++
  polynomials
    Polynomials
  scalar
    Classes for Scalar Functions
  See also routines and OpenGL functions.
    Naming in C and C++
  trigonometric
    Trigonometric Functions
    Trigonometric Functions

gaze vector, definition
  Glossary

GDS format. See formats
  McDonnell-Douglas GDS Format

genlock
  Video Refresh Counter (VClock)

geometric primitives
  Higher-Order Geometric Primitives
  Geometric Primitives: The Base Class pfRep and the Application repTest

geometry
  coplanar. See coplanar geometry
    pfLayer Nodes
  nodes
    pfGeode Nodes
  rotating
    pfBillboard Nodes
    Graphics and Modeling Techniques to Improve Performances
  volumes. See volumes
    Defining a Volume

getenv()
  File Search Paths

getting started
  About This Guide

GFO format. See formats
  SGI GFO Format

global attribute
  Global Attributes

global state
  Local and Global State

GLXFBConfigSGIX
  Configuring the Framebuffer of a pfWindow

GPUs (graphics processing units)
  Rendering Attributes
  Using Scalable Graphics Hardware
  Using OpenGL Performer with GPUs

graph
  defined
    Glossary
  stage timing. See stage timing graph
    Interpreting Statistics Displays

graphics
  attributes
    Immediate Mode
  load. See load management
    Load and Stress
  modes
    Immediate Mode
    Rendering Modes
  pipelines. See pipelines
    Using Pipes
  state
    Immediate Mode
  state elements, definition
    Glossary
  statistics
    Rendering Statistics
    See also statistics
      Rendering Statistics
  values
    Immediate Mode
    Rendering Values

graphics context, definition
  Glossary

graphics libraries
  database sorting
    Cull Process Tips
  input handling
    Draw Process Tips
    Draw Process Tips
  objects
    Balancing Cull and Draw Processing with Database Hierarchy
  OpenGL
    About This Guide
  See also OpenGL
    Cull Process Tips

graphics pipe
  Hyperpipe Concepts

graphics processing units (GPUs). See GPUs.
  Using Scalable Graphics Hardware

grout, digital
  Active Surface Definiton (ASD)

half-spaces
  Half-spaces (Planes)

handleEvent()
  Extending a pfvViewer—Writing Custom Modules
  Extending a pfvViewer—Module Entry Points

handling flimmering
  pfLayer Nodes

hardware composition schemes
  How the Compositor Functions

header file
  Header Files
  Header Files

header_offset
  header_offset, tiles_in_file, and tile_size

heading
  Setting Up a Viewpoint
  defined
    Glossary

heap
  Glossary
  defined
    Glossary

help
  accessing the mailing list
    Internet and Hardcopy Reading for the OpenGL Performer Series
  C++ argument passing
    Typedefed Arrays Versus Structs
  channel groups
    Using Channel Groups
  channels
    Using Channels
  clearing a channel
    Process Callbacks and Passthrough Data
  database formats
    Supported Database Formats
  database paging
    Asynchronous Database Processing
  default shared arena size
    Shared Arenas
  display lists
    pfGeoSet Draw Mode
  drawing a background
    What This Guide Contains
    Creating Visual Effects
  drawing text
    pfText Nodes
  flimmering
    Glossary
  frame rates
    Frame Rate Management
  geometry specification
    Geometry
  graphics attributes
    Immediate Mode
  inheriting transformations
    Sample Program
  instancing
    Instancing
  interfacing C and C++ code
    Interface Between C and C++ API Code
  level of detail
    Level-of-Detail Management
  morphing
    PFENG_MORPH Engines
  multiple pipelines
    The Functional Stages of a Pipeline
  multiprocess configuration
    Creating and Configuring a pfPipe
  node callback functions
    pfNode Cull and Draw Callbacks
  overview of chapter contents
    What This Guide Contains
  performance tuning
    Performance Tuning Overview
  pipes
    Using Pipes
  scene graph structure
    Organizing a Database for Efficient Culling
  scene graphs
    Scene Graph Hierarchy
  shared memory
    Memory Allocation
  traversals
    Database Traversal
  understanding process models
    Comparative Structure of Models
  understanding statistics
    Interpreting Statistics Displays
  view specification
    Setting Up a Viewpoint
  viewports
    Setting Up a Viewport
  where to start
    About This Guide
  windows
    Using pfPipeWindows
  writing a loader
    Creating an OpenGL Performer Database Converter using `libpfdu`

help process callback functions
  Process Callbacks

Hermite spline
  Hermite-Spline Curves in the Plane
  curves in space
    Hermite Spline Curves in Space
  curves in the plane
    Hermite-Spline Curves in the Plane
  surfaces
    Hermite-Spline Surfaces

higher-order geometric primitives
  Higher-Order Geometric Primitives
  Geometric Primitives: The Base Class pfRep and the Application repTest
  class hierarchy
    Geometric Primitives: The Base Class pfRep and the Application repTest

high-resolution clocks
  High-Resolution Clocks

horizontal stripes
  How the Compositor Functions

Hull parameterization
  Indexing Knot Points and the Control Hull

hyperpipe
  Hyperpipe Concepts
  Configuring Hyperpipes
  Configuring pfPipeWindows and pfChannels
  programming with
    Programming with Hyperpipes

hyperpipes
  multiple
    Establishing the Number of Graphic Pipes

I3DM modeler
  SuperViewer SV Format

icache_files
  icache_files, icache_format and icache_params
  icache_files

icache_format
  icache_files, icache_format and icache_params

icache_params
  icache_files, icache_format and icache_params

icache_size
  icache_size, mem_region_size, and tex_region_size

identity matrix, definition
  Glossary

IM format. See formats
  SGI IM Format

image cache
  Cliptexture Levels
  Configuring an Image Cache Level
  icache_files, icache_format and icache_params
  configuration
    Configuring an Image Cache
    Image Cache Configuration
    Creating Configuration Files
    Image Cache Configuration File Details
    Image Cache Configuration File Description
  levels
    `libpr` Functionality
    Configuring an Image Cache Level
    icache_files, icache_format and icache_params
  proto tile
    Configuring an Image Cache Proto Tile

image data, formatting
  Formatting Im age Data

image tile
  `libpr` Functionality
  Configuring Image Tiles

image, tiling
  Tiling an Im age

image-based rendering
  Image-Based Rendering

img_format
  ext_format, int_format, and img_format
  ext_format, int_format, and img_format

immediate mode rendering, definition
  Glossary

immediate-mode
  pfGeoSet Draw Mode

include files
  Header Files

index attributes
  When to Index Attributes

indexed pfGeoSets
  pfGeoSet (Geometry Set)

industrial simulation
  Why Use OpenGL Performer?

INF (infinite value) exception
  Avoid Floating-Point Exceptions

InfinitePerformance graphics systems
  Using OpenGL Performer with an SGI Scalable Graphics Compositor

info-performer
  Internet and Hardcopy Reading for the OpenGL Performer Series

inheriting
  attributes
    Attribute Inheritance
  classes
    Base Classes
  state
    State Inheritance

initializing
  C++ virtual functions
    Initializing Shared Memory
  pfType system
    Initializing Shared Memory

inline
  Vector Operations

in-lining math functions
  Special Coding Tips

input handling
  Draw Process Tips
  Draw Process Tips

inset
  Insets
  adding to cliptexture
    Adding Ins ets to Cliptextured Data
  and DTR
    Ins ets and DTR
  boundary
    In set Boundaries
  building
    Building Insets
  cliptexture
    Cliptexture Insets
  multiple
    Multiple Insets

inset views
  One Window per Pipe, Multiple Channels per Window

instancing
  Instancing
  cloned
    Cloned Instancing
  definition
    Glossary
  shared
    Shared Instancing

int_format
  ext_format, int_format, and img_format
  ext_format, int_format, and img_format

Interest Area
  Interest Area

internal API
  Overview

interpolation, MIPmap
  Graphics and Modeling Techniques to Improve Performances

intersections
  caching
    Efficient Intersection and Traversals
  masks
    Intersection Masks
    Intersection Masks
  performance
    Efficient Intersection and Traversals
  pipeline, definition
    Glossary
  See also discriminator callbacks
    Discriminator Callbacks
  tests
    geometry sets
      Intersecting with pfGeoSets
    planes
      Intersecting with Planes and Triangles
    point-volume
      Point-Volume Intersection Tests
    segments
      Creating and Working with Line Segments
    segment-volume
      Intersecting with Volumes
    triangles
      Intersecting with Planes and Triangles
    volume-volume
      Volume-Volume Intersection Tests
  traversals. See traversals
    Database Traversal

invalid border
  Invalid Borders
  Invalid Border
  invalid_border

I/O
  asynchronous
    Asynchronous I/O (IRIX only)
  handling
    Draw Process Tips
    Draw Process Tips

IRIS IM
  Motif

IRIS Image Vision Library
  SGI PTU Format

IRIS Inventor. See Open Inventor
  SGI Open Inventor Format

IRIX kernel
  Shared Memory

IRTP format. See formats
  AAI/Graphicon IRTP Format

islDrawAction
  Textures and Texture Coordinates
  Textures and Texture Coordinates

islShape
  Textures and Texture Coordinates
  OpenGL Shader and OpenGL Performer

.iv files
  Reading and Writing Topology Information: Using Pseudo Loaders

Kaleido , polyhedron generator
  SGI PHD Format

kernel
  Shared Memory

keyframing
  using quaternions for
    Quaternion Operations

knot points
  Hermite-Spline Curves in the Plane
  Hermite spline
    Hermite-Spline Curves in the Plane
  NURBS
    Knot Points

latency
  controlling
    Process Pipeline Tuning Tips
  defined
    Glossary

latency-critical
  definition
    Glossary
  updates
    Process Pipeline Tuning Tips

layer geometry
  Decals
  Decals
  definition
    Glossary

layered fog
  Patchy Fog and Layered Fog

level of detail
  Building a MIPmap
  Overview
  blended transitions
    Level-of-Detail Transition Blending
  cannonical channel resolution
    Level-of-Detail Range Processing
  cannonical field of view
    Level-of-Detail Range Processing
  defined
    Glossary
  stress management
    Load and Stress
  switching
    pfLOD Nodes
  use in optimization
    Cull and Intersection Optimizations

libpf
  libpf Functionality
  cliptextures
    `libpf` Support
  defined
    Glossary
  display environment
    Setting Up the Display Environment
  objects
    `libpr` and `libpf` Objects

libpfbreakup pseudo loader
  Database Operators with Pseudo Loaders

libpfcliptile pseudo loader
  Database Operators with Pseudo Loaders

libpfclosest pseudo loader
  Database Operators with Pseudo Loaders

libpfct demo loader
  `libpfdb` Support
  Cliptexture Loaders

libpfctol pseudo loader
  Retessellating a Scene Graph

libpfdb
  Overview of OpenGL Performer Database Creation and Conversion
  cliptextures
    `libpfdb` Support

libpfdu
  Overview of OpenGL Performer Database Creation and Conversion
  `libpfdu` - Utilities for Creating Efficient OpenGL Performer Run-Time Structures
  cliptextures
    `libpfdu` Support
  defined
    Glossary

libpfgeoa pseudo loader
  Database Operators with Pseudo Loaders
  Converting pfGeoSets to pfGeoArrays

libpfim cliptexture loader
  `libpfdb` Support
  Cliptexture Loaders

libpfmpk library
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

libpfrot pseudo loader
  Database Operators with Pseudo Loaders

libpfscale pseudo loader
  Database Operators with Pseudo Loaders

libpfsphere pseudo loader
  Database Operators with Pseudo Loaders

libpfspherepatch loader
  `libpfdb` Support
  Cliptexture Loaders

libpfsubdiv pseudo loader
  Database Operators with Pseudo Loaders
  The libpfsubdiv Pseudo Loader

libpftrans pseudo loader
  Database Operators with Pseudo Loaders

libpfutil
  Overview of OpenGL Performer Database Creation and Conversion
  cliptextures
    `libpfutil` Support

libpfv library
  Setting Up the Display Environment
  Building a Visual Simulation Application Using libpfv

libpfvct pseudo loader
  Database Operators with Pseudo Loaders
  `libpfdb` Support
  Cliptexture Loaders

libpr
  classes
    `libpr` Classes
    Glossary
  cliptextures
    `libpr` Support
    `libpr` Functionality
  defined
    Glossary
  graphics state
    Immediate Mode
  objects
    `libpr` and `libpf` Objects

Light Point Board
  LPB Hardware Configuration

light points
  Predefined Cull Program Instructions
  definition
    Glossary

light shafts
  Light Shafts

lighting
  overview
    Lighting

lights, bright
  Calligraphic Light Points

Lightscape Technologies
  Lightscape Technologies LSA and LSB Formats

line segments
  Creating and Working with Line Segments
  See also pfSegSet data structures
    Creating and Working with Line Segments

lines
  in space
    Lines in Space
  in the plane
    Lines in the Plane

load balancing
  Load Balancing

load control, cliptextures
  Load Cont rol

load management
  level-of-detail scaling
    Dynamic Load Management
  statistics
    Load and Stress

load, definition
  Glossary

loaders
  Creating an OpenGL Performer Database Converter using `libpfdu`

loading files. See databases
  Importing Databases

LoadLibrary()
  Finding and initializing a Converter

load-time configuration
  Load-Time Configuration

local state
  Local and Global State

locked phase, definition
  Glossary

locks, allocating
  Allocating Locks and Semaphores

LOD
  Rendering Higher-Order Primitives: Tessellators

LOD (level of detail)
  Overview
  managing
    Level-of-Detail Management
  range
    Hierarchical Structure
  reduction
    LOD Reduction
  See also level of detail
    Load and Stress
  See also load management
    Load and Stress
  user control over evaluation
    Run-Time User Control Over LOD Evaluation

lookahead cache
  Cliptexture Levels
  Image Cache

Loop subdivision
  Subdivision Surfaces
  Creating a Subdivision Surface
  Loop and Catmull-Clark Subdivisions
  The libpfsubdiv Pseudo Loader

loops
  Coons patch
    Coons Patches
  trim loop
    Defining Edges of a Parametric Surface: Trim Loops and Curves
  trim loops
    Defining Edges of a Parametric Surface: Trim Loops and Curves

LPB
  Calligraphic Light Points
  LPB Hardware Configuration

LSA. See formats
  Lightscape Technologies LSA and LSB Formats

LSB. See formats
  Lightscape Technologies LSA and LSB Formats

macros
  Special Coding Tips
  PFADD_SCALED_VEC3
    Vector Operations
  PFADD_VEC3
    Vector Operations
  PFALMOST_EQUAL_MAT
    Matrix Operations
  PFALMOST_EQUAL_VEC3
    Vector Operations
  PFCOMBINE_VEC3
    Vector Operations
  PFCONJ_QUAT
    Quaternion Operations
  PFCOPY_MAT
    Matrix Operations
  PFCOPY_VEC3
    Vector Operations
  PFDISTANCE_PT3
    Vector Operations
  PFDIV_QUAT
    Quaternion Operations
  PFDOT_VEC3
    Vector Operations
  PFEQUAL_MAT
    Matrix Operations
  PFEQUAL_VEC3
    Vector Operations
  PFGET_MAT_COL
    Matrix Operations
  PFGET_MAT_COLVEC3
    Matrix Operations
  PFGET_MAT_ROW
    Matrix Operations
  PFGET_MAT_ROWVEC3
    Matrix Operations
  PFLENGTH_QUAT
    Quaternion Operations
  PFLENGTH_VEC3
    Vector Operations
  PFMAKE_IDENT_MAT
    Matrix Operations
  PFMAKE_SCALE_MAT
    Matrix Operations
  PFMAKE_TRANS_MAT
    Matrix Operations
  PFMATRIX
    Interface Between C and C++ API Code
  PFMULT_QUAT
    Quaternion Operations
  PFNEGATE_VEC3
    Vector Operations
  PFQUAT
    Interface Between C and C++ API Code
  PFSCALE_VEC3
    Vector Operations
  PFSET_MAT_COL
    Matrix Operations
  PFSET_MAT_COLVEC3
    Matrix Operations
  PFSET_MAT_ROW
    Matrix Operations
  PFSET_MAT_ROWVEC3
    Matrix Operations
  PFSET_VEC3
    Vector Operations
  PFSQR_DISTANCE_PT3
    Vector Operations
  PFSUB_VEC3
    Vector Operations
  PFVEC2
    Interface Between C and C++ API Code
  PFVEC3
    Interface Between C and C++ API Code
  PFVEC4
    Interface Between C and C++ API Code

mailing list
  Internet and Hardcopy Reading for the OpenGL Performer Series

makeIBRimages program
  Creating Images of an Object with `makeIBRimages`

makeProxyImages program
  Creating Images of an Object with `makeProxyImages`

malloc()
  Shared Memory
  Shared Memory
  See also memory, pfMalloc()
    Shared Memory

manifolds
  Vertex Neighbors
  Binary Flags

masks, intersection
  Intersection Masks
  Intersection Masks

master cliptexture
  Making Masters and Slaves

materials
  Materials

math routines
  Vector Operations
  in-lining
    Special Coding Tips

matrices
  Matrix Class: pfRMatrix
  4 by 4
    Matrix Operations
  affine
    Matrix Operations
  composition order
    Matrix Operations
  double-precision
    pfDoubleSCS Nodes
    pfDoubleDCS Nodes
    pfDoubleFCS Nodes
  manipulating
    Graphics Library Matrix Routines
  stack functions
    Matrix Stack Operations

matrix routines
  transformations
    Matrix Operations

matrix. See transformation
  State Inheritance

matrix stack
  Matrix Stack Operations

maxlod
  Virtual Cliptextures on InfiniteReality Systems

Maya databases
  The Maya Database Exporter

measuring performance
  Performance Measurement Tools

MEDIT format. See formats
  Medit Productions MEDIT Format

MEL (Maya Embedded Language)
  Exporting a Scene Using the Maya Embedded Language (MEL)

mem region
  Cliptexture Levels

mem_region_size
  icache_size, mem_region_size, and tex_region_size

member functions
  Overview
  overloaded
    Subclassing pfObjects

memory
  allocating
    Allocating Memory With pfMalloc()
    Shared Memory
  multiprocessing
    Multiprocessing and Memory
  shared. See shared memory
    Memory Allocation

memory footprint
  and reps
    Features and Uses of Higher-Order Geometric Primitives

memory mapping, for shared arena
  Shared Arenas

memory requirements
  System Memory Estimation

Menger sponge
  Sierpinski Sponge Loader

mesh
  Active Surface Definition
  ASD Elements

methods (See routines.)
  Extending a pfvViewer—Module Entry Points

Microsoft Developer Studio
  Use the Simplest Process Model

minification
  Graphics and Modeling Techniques to Improve Performances

MIPmap
  Overview
  building
    Building a MIPmap
  filtering
    Texture Management
  interpolation functions
    Graphics and Modeling Techniques to Improve Performances
  level
    Cliptexture Levels

mode changes
  Transform Bottlenecks

modelers
  AutoCAD
    AutoCAD DXF Format
  Designer's Workbench
    Designer's Workbench DWB Format
  EasyScene
    Designer's Workbench DWB Format
  EasyT
    Designer's Workbench DWB Format
  I3DM
    SuperViewer SV Format
  Imagine
    SGI Open Inventor Format
  Kaleido
    SGI PHD Format
  Model
    Wavefront Technology OBJ Format
  ModelGen
    MultiGen OpenFlight Format
  MultiGen
    MultiGen OpenFlight Format

morph attribute, definition
  Glossary

morphing
  PFENG_MORPH Engines
  defined
    Glossary

morphing vector
  Morphing Vector
  Vertices

Motif
  Motif

MPK (See OpenGL Multipipe SDK.)
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

MPK configuration files
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

MPKConfig class
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

multibuffering
  Multiprocessing and libpf Objects

Multi-Channel Option
  One Window per Pipe, Multiple Channels per Window

multipass rendering
  The pfCullProgram Class

multiple channels
  One Window per Pipe, Multiple Channels per Window
  Using Channel Groups
  Setting Up a Viewpoint
  and ASD
    Using ASD for Multiple Channels
  rendering
    Using Multiple Channels

multiple hardware pipelines
  The Functional Stages of a Pipeline

multiple inheritance
  avoidance of
    Inheritance Graph
  definition
    Glossary

multiple pipelines. See pipelines
  Video Refresh Counter (VClock)

multiplexers
  Using Scalable Graphics Hardware

multiprocess, cliptexture
  MPClipTextures

multiprocessing
  display-list generation, forcing
    Forcing Display List Generation
  functions, invoking during
    Rules for Invoking Functions While Multiprocessing
  memory management
    Multiprocessing and Memory
  models of
    Choosing a Multiprocessing Model
    cull-overlap-draw
      Cull-Overlap-Draw Mode
    timing diagrams
      Comparative Structure of Models
  order of calls
    Order of Calls
  pipelines
    Process Callbacks
  pipelines, multiple
    Multiple Rendering Pipelines
  uses for
    Successful Multiprocessing with OpenGL Performer

multisampling
  Multisampling

multi-texture support
  Multitexture Support in pfGeoState

multithreading
  Multithreading
  defined
    Glossary

mutual exclusion, definition
  Glossary

NaN (Not a Number) exception
  Avoid Floating-Point Exceptions

neighborhood array
  Vertex Data Structure

NFF format. See formats
  NFF Neutral File Format

node draw mask
  pfNode Draw Mask

nodes
  callbacks
    pfNode Cull and Draw Callbacks
  defined
    Glossary
  pruning
    Traversal Order
  sequences
    pfSequence Nodes
  types
    pfNode

nonblocking access, definition
  Glossary

nonblocking file interface
  Asynchronous I/O (IRIX only)

non-clipped level
  Why Do These Assumptions Work?

non-degrading priorities, definition
  Glossary

notification levels for errors
  Error Handling and Notification

num_streams
  num_streams, s_streams, t_streams, and r_streams

numEffectiveLevels
  Per-Frame Setting of Virtual Cliptexture Parameters

NURBS
  and Bezier curves
    Features of NURBS and Bezier Curves
  control hull
    Control Hull
  control hull indexing
    Indexing Knot Points and the Control Hull
  control parameters
    NURBS Elements That Determine the Control Parameters
  curves
    Trimmed NURBS
  curves in space
    NURBS Curves in Space
  curves in the plane
    NURBS Curves in the Plane
  equation for curve
    Equation Used to Calculate a NURBS Curve
  equation for surface
    Equation Used to Calculate a NURBS Surface
  introduction to
    NURBS Overview
  knot points
    Knot Points
  OpenGL Performer classes
    OpenGL Performer NURBS Classes
  surfaces
    Trimmed NURBS
    NURBS Surfaces
  weights for control points
    Weights for Control Points

OBJ format. See formats
  Wavefront Technology OBJ Format

object creation
  O bject Creation

object derivation
  Base Classes

object type
  Determining Ob ject Type
  determining
    Determining Ob ject Type

occlusion culling
  definition
    Glossary
  using cull programs
    Occlusion Culling Using Cull Programs

ogldebug
  Performance Measurement Tools
  Using `ogldebug` to Observe Graphics Calls
  Using `ogldebug` to Observe Graphics Calls
  Using `ogldebug` to Observe Graphics Calls
  utility
    Using `ogldebug` to Observe Graphics Calls

Onyx RealityEngine. See RealityEngine graphics
  Multiple Rendering Pipelines

opcodes
  Predefined Cull Program Instructions

Open Inventor
  Application Traversal
  Database Loading Details
  SGI Open Inventor Format
  loader, C++ implementation
    Initialization and Type Definition

open()
  Asynchronous I/O (IRIX only)

OpenGL
  About This Guide
  functions
    glAlphaFunc()
      Alpha Function
    glBlendFunc()
      Multisampling
      Transparency
    glColorMaterial()
      Draw Stage and Graphics Pipeline Optimizations
      Transform Bottlenecks
      Other Tips
    glColorPointer()
      pfGeoArray Attribute Types
    glFinish()
      Collecting and Accessing Statistics in Your Application
    glFog()
      Layered Fog
      Fog
    glLight()
      Lighting
    glMaterial()
      Materials
    glNormalPointer()
      pfGeoArray Attribute Types
    glShadeModel()
      Transform Bottlenecks
    glStencilOp()
      Decals
    glTexCoordPointer()
      pfGeoArray Attribute Types
    glTexEnv()
      Texture
    glTexGen()
      Automatic Texture Coordinate Generation
      Automatic Texture Coordinate Generation
    glTexImage2D()
      Texture
      Texture
    glVertexAttribPointerARB()
      pfGeoArray Attribute Types
    glVertexPointer()
      pfGeoArray Attribute Types
    glXCreateContext()
      pfWindows and GL Windows
    glXQueryHyperpipeNetworkSGIX()
      Using Nondefault Hyperpipe Mappings to Graphics Pipes
    glXSwapBuffers()
      Frame Synchronization
      Programming with Hyperpipes
      Using `ogldebug` to Observe Graphics Calls

OpenGL Multipipe SDK (MPK) product
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

OpenGL Performer
  applications of
    Why Use OpenGL Performer?
  C API
    Overview
  C++ API
    Programming with C++
    Programming with C++
    accessor functions
      Overview
    header files
      Header Files
    member functions
      Overview
    new
      Creating and Deleting OpenGL Performer Objects
    object creation
      Creating and Deleting OpenGL Performer Objects
    object deletion
      Creating and Deleting OpenGL Performer Objects
    public structs
      Class Taxonomy
    reserved functions
      Overview
    static class data
      Static Member Data
    subclassing
      Subclassing pfObjects
    using both C and C++ API
      Porting from C API to C++ API
    using the C API with C++
      Porting from C API to C++ API
  differences between C and C++
    Programming with C++
  error handling
    Error Handling and Notification
  getting started
    What This Guide Contains
  introduction
    About This Guide
  mailing list
    Internet and Hardcopy Reading for the OpenGL Performer Series
  type system
    Determining Ob ject Type
    Class Taxonomy
    pfType Class
    Initialization and Type Definition

OpenGL Performer API
  General Naming Conventions

OpenGL Shader
  Shaders

opera lighting
  defined
    Glossary

operator
  delete
    Creating and Deleting OpenGL Performer Objects
  new
    Creating and Deleting OpenGL Performer Objects
    Creating and Deleting OpenGL Performer Objects

optimization
  database parameters
    Balancing Cull and Draw Processing with Database Hierarchy

organization of databases. See databases
  Database Organization

orthogonal transformations
  Matrix Operations

orthonormal transformations
  Matrix Operations
  Transforming Bounding Volumes

overlay()
  Extending a pfvViewer—Module Entry Points

overload, definition
  Glossary

overrun, definition
  Glossary

overrun, frame
  Fixing the Frame Rate

paging
  in ASD
    Paging
  multi-resolution
    Multi-resolution Paging
  order of in ASD
    Order of Paging
  preprocessing
    Preprocessing for Paging

parameterization
  cones
    pfConeSurface
  planes
    pfPlaneSurface
  spheres
    pfSphereSurface
  torus
    pfTorusSurface

parameters,virtual cliptexture
  How to Set Virtual Cliptexture Parameters

parametric circles in the plane
  Circles in the Plane

parametric curves
  in space
    Spatial Curves

parametric lines in the plane
  Lines in the Plane

parametric surfaces
  Parametric Surfaces
  Parametric Surfaces
  base class
    Base Class for Parametric Surfaces: pfParaSurface
  plane surfaces
    pfPlaneSurface
  stitching
    Creating and Maintaining Surface Topology
  tessallation
    Tessellating Parametric Surfaces

parent, of a node, defined
  Glossary

parser
  Using Configuration Files

partitions
  pfPartition Nodes

passthrough data
  Process Callbacks and Passthrough Data
  Passthrough Data
  defined
    Glossary

patchy fog
  Patchy Fog and Layered Fog

paths
  definition
    Glossary
  search paths
    File Search Paths
  through scene graph
    Paths through the Scene Graph

perfly
  Sample Code
  Interpreting Statistics Displays
  Fill Statistics
  definition
    Glossary
  sample programs
    Shell Environment Variables

Perfly application
  The Simplify Graphical User Interface (GUI)

performance
  costs
    lighting
      Transform Bottlenecks
    multisampling
      Multisampling
  EventView performance analyzer
    EventView—A Performance Analyzer
  intersection
    Efficient Intersection and Traversals
  measurement
    Performance Measurement Tools
    Performance Measurement Tools
  tuning
    database structure
      Database Concerns
    graphics pipeline
      Graphics Pipeline Tuning Tips
    guidelines, specific
      Specific Guidelines for Optimizing Performance
    optimizations, built-m
      How OpenGL Performer Helps Performance
    overview
      Performance Tuning Overview
    process pipeline
      Process Pipeline Tuning Tips
    RealityEngine graphics
      Notes on Tuning for RealityEngine Graphics

Performance Co-Pilot
  Performance Measurement Tools

Performer Terrain Utilities
  SGI PTU Format

PF_DTR_MEMLOAD
  Load Control API

PF_DTR_READSORT
  Load Control API

PF_DTR_TEXLOAD
  Load Control API

PF_MAX_ANISOTROPY
  Texture Management

pfAddMPClipTexture()
  Connecting MPcliptextures to pfPipes
  Multipipe Cliptexture API

pfAddPWinPVChan()
  Controlling the Video Output
  Creating, Configuring and Opening pfPipeWindow
  Creating a pfPipeVideoChannel
  Creating a pfPipeVideoChannel

pfAppearanceChanged()
  Setting Up Shaded pfGeoSets

pfAppFrame()
  Stage Timing Graph
  Stage Timing Graph

pfApplyDecalPlane()
  Decals

pfApplyTLOD()
  Controlling Texture LOD with pfTexLOD

pfApplyTMat()
  Video Texturing

pfASD
  Triangle Strips
  and pfEngine
    Aligning Light Points Above a pfASD Surface Example
  queries
    pfASD Queries

PFASD_COLORS
  Setting the Attributes

PFASD_NORMALS
  Setting the Attributes

PFASD_TCOORDS
  Setting the Attributes

pfASDFace
  Vertices

pfASDLODRange
  Default Evaluation Function

pfASDVert
  Vertex and Reference Point Arrays

pfAttachPWinSwapGroup()
  Multiple pfPipeWindows and Multiple pfPipes

pfAttachWin()
  Window Share Groups

pfAttachWinSwapGroup()
  Manipulating a pfWindow
  Synchronization of Buffer Swap for Multiple Windows

PFB file format
  Maximizing Database Loading and Paging Performance with PFB and PFI Formats

pfBillboard
  pfBillboard Nodes

pfBillboard nodes
  Graphics and Modeling Techniques to Improve Performances

pfBindPVChan()
  Configuring a pfPipeVideoChannel

pfBindPWinPVChans
  Configuring a pfPipeVideoChannel

pfBoundary class
  Summary of Scene Graph Topology: pfTopo

pfBox
  Axially Aligned Boxes

pfChannel data structures. See channels
  Using Channels

pfChanPixScale
  The Channel in DVR

pfChanPWinPVChanIndex()
  Controlling the Video Output
  Customizing DVR

pfChanTravMode()
  Cull Traversal

pfChoosePWinFBConfig()
  Creating, Configuring and Opening pfPipeWindow

pfCircle2d class
  declared
    Class Declaration for pfCircle2d

pfCircle3d class
  Circles in Space

pfClipTexture
  ClipTextures
  and ASD
    Combining pfClipTex ture and pfASD
    Combining pfClipTex ture and pfASD

pfCompositeCurve3d class
  declared
    Class Declaration for pfCompositeCurve3d

pfCompositeScalar class
  Class Declaration for pfScalar

pfCompositorAddChild()
  Using the pfCompositor Class

pfCompositorChannelClipped()
  Using the pfCompositor Class

pfCompositorChildFrustum()
  Using the pfCompositor Class

pfCompositorChildSubdivision()
  Using the pfCompositor Class

pfCompositorChildViewport()
  Using the pfCompositor Class

pfCompositorLoadBalancer()
  Using the pfCompositor Class

pfCompositorMasterPipe()
  Using the pfCompositor Class

pfCompositorMode()
  Using the pfCompositor Class

pfCompositorNearFar()
  Using the pfCompositor Class

pfCompositorOrtho()
  Using the pfCompositor Class

pfCompositorPerspective()
  Using the pfCompositor Class

pfCompositorReconfig()
  Using the pfCompositor Class

pfCompositorVal()
  Using the pfCompositor Class

pfCompositorViewport()
  Using the pfCompositor Class

pfCompute()
  Compute Process

pfComputeFunc()
  Compute Process

pfCone class
  declared
    Class Declaration for pfConeSurface

pfConfig()
  Importing OpenGL Multipipe SDK (MPK) Configuration Files
  Importing OpenGL Multipipe SDK (MPK) Configuration Files
  Controlling the Collection of OpenGL Performer Internal Events
  Extending a pfvViewer—Module Entry Points

pfconv
  `pfconv`

pfconv command
  Reading and Writing Topology Information: Using Pseudo Loaders

pfCoons class
  declared
    Class Declaration for pfCoonsSurface

pfCosScalar class
  Trigonometric Functions

pfctol pseudo loader
  Reading and Writing Topology Information: Using Pseudo Loaders

pfCull()
  Extending a pfvViewer—Module Entry Points

pfCullProgramAddBinParent()
  User-Defined Cull Program Instructions

pfCullProgramAddPgmInstruction()
  Predefined Cull Program Instructions

pfCullProgramAddPgmOpcode()
  Predefined Cull Program Instructions

pfCullProgramIsSubbinOf()
  User-Defined Cull Program Instructions

pfCullProgramResetBinParents()
  User-Defined Cull Program Instructions

pfCullProgramResetPgm()
  Predefined Cull Program Instructions

pfCullProgramTestPolytope()
  User-Defined Cull Program Instructions

pfCurve2d class
  Planar Curves
  Defining Edges of a Parametric Surface: Trim Loops and Curves
  Adjacency Information: pfEdge
  declared
    Class Declaration for pfCurve2d

pfCurve2d evaluator functions
  Mathematical Description of a Planar Curve

pfCurve3d class
  Spatial Curves

pfCylinder
  Cylinders

pfCylinder class
  declared
    Class Declaration for pfCylinderSurface

pfDataPool data structures
  Datapools
  multiprocessing with
    pfDataPools

pfdBreakup()
  Database Operators with Pseudo Loaders

pfdBuilder
  SGI GFO Format

pfdBuildTopologyTraverse()
  Main Features of the Methods in pfTopo
  Main Features of the Methods in pfTessellateAction

pfdConverterAttr_rpc()
  ArchVision RPC Format
  ArchVision RPC Format

pfdConverterMode_rpc()
  ArchVision RPC Format

pfdConverterVal_rpc()
  ArchVision RPC Format

pfDCS nodes
  Cull and Intersection Optimizations

pfDeleteGLHandle()
  Texture Management

pfdGetConverterAttr_rpc()
  ArchVision RPC Format

pfdGetConverterMode_rpc()
  ArchVision RPC Format

pfdGetConverterVal_rpc()
  ArchVision RPC Format

pfdInitConverter()
  pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer

pfDisCurve2d class
  declared
    Class Declaration for pfDisCurve2d

pfDisCurve3d class
  Discrete Curves in Space
  Example of Using pfDisCurve3d and pfHsplineCurve3d
  example
    Example of Using pfDisCurve3d and pfHsplineCurve3d

pfDispList
  Display Lists

pfDispList data structures
  Display Lists

pfdLoadClipTexture
  `libpfdu` Support

pfdLoadClipTextureState
  `libpfdu` Support

pfdLoadFile()
  Reading and Writing Topology Information: Using Pseudo Loaders

pfdLoadImageCache
  `libpfdu` Support

pfdLoadImageCacheState
  `libpfdu` Support

pfdLoadNeededDSOs()
  pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer

pfdLoadNeededDSOs_EXT()
  Finding and initializing a Converter

pfDoubleDCS nodes
  pfDoubleDCS Nodes

pfDoubleFCS nodes
  pfDoubleFCS Nodes

pfDoubleSCS nodes
  pfDoubleSCS Nodes

pfdProcessASDTiles
  Multi-resolution Paging

pfDraw()
  Extending a pfvViewer—Module Entry Points

pfdTessellateGeometry()
  Base Class pfTessellateAction
  Main Features of the Methods in pfTessParaSurface

pfdWriteFile
  Multi-resolution Paging

pfEdge class
  Adjacency Information: pfEdge
  pfTessParaSurfaceAction
  declared
    Class Declaration for pfEdge

pfEngine
  Replacing pfCycleBuffer with pfFlux
  and ASD
    Aligning Light Points Above a pfASD Surface Example

pfEvaluateLOD()
  Run-Time User Control Over LOD Evaluation

pfEventSampleOff()
  Controlling the Collection of OpenGL Performer Internal Events

pfEventSampleOn()
  Controlling the Collection of OpenGL Performer Internal Events

pfFilePath()
  File Search Paths

pfFilePathv()
  File Search Paths
  File Search Paths

pfFlux
  pfFlux
  pfFlux

pfFog data structures
  Fog
  Atmospheric Effects
  See also fog
    Fog

pfFont
  pfFont

pfFrame()
  Using pfPipeWindows
  pfFrame Events
  Extending a pfvViewer—Module Entry Points

pfFrameStats data structures
  Statistics
  See also pfStats data structures
    Statistics

pfFrenetSweptSurface class
  Example of Using pfDisCurve3d and pfHsplineCurve3d
  pfFrenetSweptSurface
  Details of Figure 11-2
  declared
    Class Declaration for pfFrenetSweptSurface
  example
    Example of Using pfDisCurve3d and pfHsplineCurve3d
    Making a Modulated Torus With pfFrenetSweptSurface

pfGeoArray
  pfGeoArray (Geometry Array)

pfGeode
  pfGeode Nodes
  Retessellating a Scene Graph

pfGeoSet
  pfGeoSet (Geometry Set)
  adding to pfGeode nodes
    pfDelete() and Reference Counting
    pfGeode Nodes
  and bounding volumes
    Creating and Transforming Volumes
  compilation
    pfGeoSet Draw Mode
  connectivity
    Primitive Connectivity
  draw modes
    pfGeoSet Draw Mode
  intersection mask
    Intersection Masks
  intersections with segments
    Intersecting with pfGeoSets
  optimal size
    Draw Stage and Graphics Pipeline Optimizations
  primitive types
    Primitive Types

pfGeoState data structures
  applying
    Applying pfGeoStates
  attaching to pfGeoSets
    pfGeoSets and pfGeoStates
  overview
    pfGeoState

pfGetChanOrigin()
  The Channel in DVR

pfGetChanOutputOrigin()
  The Channel in DVR

pfGetChanOutputSize()
  The Channel in DVR

pfGetChanPixScale
  The Channel in DVR

pfGetChanPWinPVChanIndex
  Customizing DVR

pfGetChanSize()
  The Channel in DVR

pfGetCompositorChannelClipped()
  Using the pfCompositor Class

pfGetCompositorChildFrustum()
  Using the pfCompositor Class

pfGetCompositorChildSubdivision()
  Using the pfCompositor Class

pfGetCompositorChildViewport()
  Using the pfCompositor Class

pfGetCompositorFrustType()
  Using the pfCompositor Class

pfGetCompositorFrustum()
  Using the pfCompositor Class

pfGetCompositorLoadBalancer()
  Using the pfCompositor Class

pfGetCompositorMode()
  Using the pfCompositor Class

pfGetCompositorNearFar()
  Using the pfCompositor Class

pfGetCompositorVal()
  Using the pfCompositor Class

pfGetCompositorViewport()
  Using the pfCompositor Class

pfGetCurCalligraphic()
  Light Point Process and Calligraphic

pfGetGSetPrimLength()
  pfGeoSet (Geometry Set)

pfGetIBRnodeProxyTexCoords()
  Creating a pfIBRnode Using a Proxy

pfGetIBRtextureDefaultTexture()
  Creating a pfIBRnode

pfGetLoadBalanceLoad()
  Load Balancing

pfGetLoadBalanceNumActive()
  Load Balancing

pfGetLoadBalanceVal()
  Load Balancing

pfGetLoadBalanceWork()
  Load Balancing

pfGetMPClipTexture()
  Connecting MPcliptextures to pfPipes

pfGetNumMPClipTextures()
  Connecting MPcliptextures to pfPipes

pfGetNumScreenPVChans()
  Multiple pfPipeVideoChannels in a pfPipeWindow

pfGetPFChanStressFilter()
  Understanding the Stre ss Filter

pfGetPVChanId
  Customizing DVR

pfGetPVChanInfo()
  Configuring a pfPipeVideoChannel

pfGetPWinNumPVChans()
  Multiple pfPipeVideoChannels in a pfPipeWindow

pfGetPWinPVChanId
  Multiple pfPipeVideoChannels in a pfPipeWindow

pfGetPWinPVChanIndex
  Multiple pfPipeVideoChannels in a pfPipeWindow

pfGetTexMultiName()
  Texture Formats

pfGetTGenMode()
  Automatic Texture Coordinate Generation

PFGS_FLAT_TRIFANS
  Attribute Bindings

PFGS_PACKED_ATTRS
  Packed Attributes

pfGSetDecalPlane()
  Decals

pfGSetMultiAttr()
  pfGeoSet (Geometry Set)
  Attributes

pfGSetOptimize()
  Marking pfGeoSets for Optimization

pfGSetQuickAttr()
  Modifying Attributes of Cloned pfGeoSets

pfGSetQuickMultiAttr()
  Modifying Attributes of Cloned pfGeoSets

pfGSetQuickPrimLengths()
  Modifying Attributes of Cloned pfGeoSets

pfHit
  Intersecting with pfGeoSets

pfHsplineCurve2d class
  Class Declaration for pfHsplineCurve2d
  Hermite Spline Curves in Space

pfHsplineCurve3 class
  Example of Using pfDisCurve3d and pfHsplineCurve3d

pfHsplineCurve3d class
  Hermite Spline Curves in Space
  example
    Example of Using pfDisCurve3d and pfHsplineCurve3d

pfHsplineSurface
  declared
    Class Declaration for pfHsplineSurface

pfHyperpipe
  Configuring pfPipeWindows and pfChannels

PFI image format
  Maximizing Database Loading and Paging Performance with PFB and PFI Formats

pfIBRnode class
  Creating a pfIBRnode
  ArchVision RPC Format

pfIBRnodeAngles()
  Creating a pfIBRnode

pfIBRnodeFlags()
  Creating a pfIBRnode Using a Proxy

pfIBRnodeIBRtexture()
  Creating a pfIBRnode

pfIBRnodeProxyTexCoords()
  Creating a pfIBRnode Using a Proxy

pfIBRtexture class
  Creating a pfIBRtexture
  ArchVision RPC Format

pfIBRtextureDirection()
  Creating a pfIBRtexture

pfIBRtextureFlags()
  Creating a pfIBRtexture
  Parameters Controlling Drawing of a pfIBRnode

pfIBRtextureIBRdirections()
  Creating a pfIBRtexture

pfIBRtextureIBRtextures()
  Creating a pfIBRtexture
  Creating a pfIBRtexture
  Creating a pfIBRtexture

pfIBRtextureLoadIBRtexture()
  Creating a pfIBRtexture
  Creating a pfIBRtexture

pfIBRtextureNumRings()
  Creating a pfIBRtexture

pfIBRtextureRing()
  Creating a pfIBRtexture

pficonv
  `pficonv`

pfiInit()
  Initializing Shared Memory

pfImageCache
  `libpr` Support

pfInitBoard()
  Customizing LPB Initialization

pfInitializeEvents()
  Controlling the Collection of OpenGL Performer Internal Events

pfIsBoardInit()
  Customizing LPB Initialization

pfIsPVChanActive()
  Creating a pfPipeVideoChannel

pfLayer
  pfLayer Nodes

pfLine2d class
  declared
    Class Declaration for pfLine2d

pfLine3d class
  Lines in Space

pfLoadBalanceBalance()
  Load Balancing

pfLoadBalanceLoad()
  Load Balancing

pfLoadBalanceNumActive()
  Load Balancing

pfLoadBalanceVal()
  Load Balancing

pfLoadGState()
  Local and Global State

pfLoadMultiTexFile()
  Texture Formats

pfLOD nodes
  pfLOD Nodes

pfLODRangeFlux()
  Arbitrary Morphing

pfLODUserEvalFunc
  Run-Time User Control Over LOD Evaluation

pfMatrix
  Matrix Operations

pfMatrix4d
  pfDoubleSCS Nodes
  pfDoubleDCS Nodes

pfMatStack
  Matrix Stack Operations

pfMPClipTexture
  MPClipTextures
  connecting to pfPipes
    Connecting MPcliptextures to pfPipes

pfMPKImportConfig()
  Importing OpenGL Multipipe SDK (MPK) Configuration Files
  Importing OpenGL Multipipe SDK (MPK) Configuration Files
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

pfMPKImportFile()
  Importing OpenGL Multipipe SDK (MPK) Configuration Files
  Importing OpenGL Multipipe SDK (MPK) Configuration Files
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

pfMPKPostConfig()
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

pfMPKPostDMConfig()
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

pfMPKPreConfig()
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

pfMQueryWin()
  Creating, Configuring and Opening pfPipeWindow

pfMultithread()
  CULL Sidekick Processes
  Configuring CULL_SIDEKICK Processes

pfMultithreadParami()
  CULL Sidekick Optimization Mask
  CULL Sidekick Synchronization Policy
  CULL Sidekick User Functions

pfNewLModel()
  Lighting

pfNewPVChan()
  Controlling the Video Output
  Creating a pfPipeVideoChannel

PFNFYLEVEL environment variable
  Error Handling and Notification

pfNode
  pfNode Attributes
  and bounding volumes
    Creating and Transforming Volumes

pfNode data structures
  Nodes
  attributes
    pfNode Attributes
  operations
    pfNode Operations

pfNurbCurve2d class
  OpenGL Performer NURBS Classes
  NURBS Curves in the Plane
  declared
    Class Declaration for pfNurbCurve2d

pfNurbCurve3d class
  OpenGL Performer NURBS Classes
  NURBS Curves in Space

pfNurbSurface class
  OpenGL Performer NURBS Classes
  NURBS Surfaces
  declared
    Class Declaration for pfNurbSurface

pfObject data structures
  Base Classes
  actual type of
    Determining Ob ject Type

pfOpenPWin()
  Creating, Configuring and Opening pfPipeWindow

pfOrientedLine3d class
  pfOrientedLine3d

pfParaSurface
  Retessellating a Scene Graph

pfParaSurface class
  Base Class for Parametric Surfaces: pfParaSurface
  pfTessParaSurfaceAction
  declared
    Class Declaration for pfParaSurface

pfPartition
  pfPartition Nodes

pfPath data structures
  Paths through the Scene Graph

PFPATH environment variable
  File Search Paths
  File Search Paths
  File Search Paths

pfPieceWisePolyCurve2d class
  declared
    Class Declaration for pfPieceWisePolyCurve

pfPipe
  configuration
    Creating and Configuring a pfPipe
  data structures. See pipelines
    Using Pipes

pfPipeScreen()
  Controlling the Video Output
  Creating a pfPipeVideoChannel

pfPipeSwapFunc()
  Creating, Configuring and Opening pfPipeWindow

pfPipeVideoChannel
  Controlling Video Displays

pfPlane
  Half-spaces (Planes)

pfPlaneSurface class
  declared
    Class Declaration for pfPlaneSurface

pfPolyScalar class
  Trigonometric Functions
  Polynomials

pfPrint
  Printing Objec ts with pfPrint()
  Printing Objec ts with pfPrint()
  Printing Objec ts with pfPrint()

pfProcessHighestPriority
  Placing Multiple OpenGL Performer Processes on a Single CPU

pfProcessPriorityUpgrade
  Placing Multiple OpenGL Performer Processes on a Single CPU

pfPVChanDVRMode()
  Maintaining Frame Rate Using D ynamic Vid eo Res olution

pfPVChanId()
  Controlling the Video Output
  Creating a pfPipeVideoChannel
  Creating a pfPipeVideoChannel

pfPVChanMaxDecScale
  Customizing DVR

pfPVChanMaxIncScale
  Customizing DVR

pfPVChanMinDecScale
  Customizing DVR

pfPVChanMinIncScale
  Customizing DVR

pfPVChanMode()
  DVR Scaling

pfPVChanOutputAreaScale()
  Use pfPipeVideoChannels to Control Frame Rate

pfPVChanOutputOrigin()
  Use pfPipeVideoChannels to Control Frame Rate

pfPVChanOutputSize()
  Use pfPipeVideoChannels to Control Frame Rate

pfPVChanStress
  Customizing DVR

pfPVChanStress()
  Understanding the Stre ss Filter

pfPVChanStressFilter
  Customizing DVR

pfPVChanStressFilter()
  Understanding the Stre ss Filter

pfPWinAddPVChan
  Multiple pfPipeVideoChannels in a pfPipeWindow

pfPWinAttach()
  Multiple pfPipeWindows and Multiple pfPipes

pfPWinRemovePVChan
  Multiple pfPipeVideoChannels in a pfPipeWindow

pfPWinRemovePVChanIndex()
  Multiple pfPipeVideoChannels in a pfPipeWindow

pfPWinShare()
  Multiple pfPipeWindows and Multiple pfPipes

pfPWinType()
  Multiple pfPipeWindows and Multiple pfPipes

pfQueryWin()
  Creating, Configuring and Opening pfPipeWindow

pfQueue
  Handling Queues

pfQuickCopyGSet()
  Modifying Attributes of Cloned pfGeoSets

pfQuickResetGSet()
  Modifying Attributes of Cloned pfGeoSets

pfRemoveMPClipTexture()
  Connecting MPcliptextures to pfPipes

pfRep class
  declared
    Class Declaration for pfRep
  moving from default position
    Geometric Primitives: The Base Class pfRep and the Application repTest

pfRep<Default class
  Geometric Primitives: The Base Class pfRep and the Application repTest

pfResetEvents()
  Controlling the Collection of OpenGL Performer Internal Events

pfRuled class
  declared
    Class Declaration for pfRuledSurface

pfSaveMultiTexFile()
  Texture Formats

pfScalar class
  Classes for Scalar Functions

pfScene nodes
  Setting Up a Scene

pfSCS
  pfSCS Nodes
  pfDoubleSCS Nodes

pfSCS nodes
  Cull and Intersection Optimizations

pfSeg
  Creating and Working with Line Segments
  and bounding volumes
    Creating and Transforming Volumes

pfSegSet
  data structure, definition
    Intersection Requests: pfSegSets
  intersection with
    Intersecting with pfGeoSets

pfSelectWin()
  Manipulating a pfWindow
  Synchronization of Buffer Swap for Multiple Windows

pfSequence
  pfSequence Nodes

pfsFace
  Triangle Data Structure

pfShaderChanged()
  Setting Up Shaded pfGeoSets

pfShaderTexApplyFunc()
  Textures and Texture Coordinates
  Textures and Texture Coordinates
  OpenGL Shader and OpenGL Performer

pfShaderTexComputeFunc()
  Textures and Texture Coordinates
  OpenGL Shader and OpenGL Performer

pfShaderTexCoordFunc()
  Textures and Texture Coordinates
  Textures and Texture Coordinates
  OpenGL Shader and OpenGL Performer

pfShadow class
  Creating a pfShadow

pfSharedMalloc()
  `evpp`—Event Pre-Processor

pfSinScalar class
  Trigonometric Functions

pfSolid class
  methods
    Class Declaration for pfSolid

pfSphere
  Spheres

pfSphere class
  declared
    Class Declaration for pfSphereSurface

pfSphereSurface class
  pfSphereSurface Example

pfState data structures
  State Management

pfString
  pfString

pfSubloadMultiTex()
  Texture Formats

pfSubloadTexMultiLevel()
  Texture Formats

pfSuperQuad3d class
  Superquadrics in Space

pfSuperQuadCurve2d class
  Superquadric Curves: pfSuperQuadCurve2d
  declared
    Class Declaration for pfSuperQuadCurve2d

pfSweptSurface class
  Swept Surfaces
  declared
    Class Declaration for pfSweptSurface

pfSwitch
  pfSwitch Nodes

pfSwitchValFlux()
  Arbitrary Morphing

pfSync()
  Stage Timing Graph
  pfSync() Events
  Extending a pfvViewer—Module Entry Points

pfTEnvMode()
  Setting the Texture Environment with pfTexEnv

pfTerrainAttr()
  Setting the Attributes
  Global Attributes

pfTessellateAction class
  declared
    Class Declaration for pfTessellateAction

pfTessParaSurface
  Main Features of the Methods in pfTessParaSurface

pfTessParaSurface class
  pfTessParaSurfaceAction

pfTessParaSurfaceAction class
  declared
    Class Declaration for pfTessParaSurfaceAction

pfTexAnisotropy()
  Texture Management

pfTexEnv data structures. See texturing
  Texture

pfTexFormat()
  Texture Formats

pfTexGen
  Attributes

pfTexImage()
  Texture Formats

pfTexLOD
  Controlling Texture LOD with pfTexLOD

pfTexMultiImage()
  Texture Formats

pfTexMultiName()
  Texture Formats

pfTexture
  Configuring a pfTexture

pfTexture data structures. See texturing
  Texture

pfTGenPoint()
  Automatic Texture Coordinate Generation

pfTopo class
  Adjacency Information: pfEdge
  Summary of Scene Graph Topology: pfTopo
  declared
    Class Declaration for pfTopo

pfTorus class
  declared
    Class Declaration for pfTorusSurface

pfttol pseudo loader
  Reading and Writing Topology Information: Using Pseudo Loaders

pfuAddMPClipTexturesToPipes
  `libpfutil` Support

pfuAddMPClipTextureToPipes
  `libpfutil` Support
  Post-Load-Time Configuration

pfuCalcSizeFinestMipLOD
  How to Choose Virt ual Cliptexture Parameters

pfuCalcVirtualClipTexParams
  How to Choose Virt ual Cliptexture Parameters

pfuChooseFBConfig()
  Configuring the Framebuffer of a pfWindow

pfuClipCenterNode
  Clipcenter Node

pfuClipTexConfig structure
  Filling in the Structures

pfuDownloadTexList()
  Texture Management

pfuFindClipTextures
  `libpfutil` Support

pfuFreeClipTexConfig
  `libpfutil` Support

pfuFreeImgCacheConfig
  `libpfutil` Support

pfuImgCacheConfig
  Filling in the Structures

pfuInit()
  Initializing Shared Memory

pfuInitClipTexConfig
  `libpfutil` Support

pfuInitImgCacheConfig
  `libpfutil` Support

pfuMakeClipTexture
  `libpfutil` Support
  `libpfdu` Support

pfuMakeImageCache
  `libpfutil` Support
  `libpfdu` Support

pfuMakeSceneTexList()
  Texture Management

pfUnbindPWinPVChans
  Configuring a pfPipeVideoChannel

pfuNewClipCenterNode
  Clipcenter Node

pfuProcessClipCenters
  `libpfutil` Support
  Post-Load-Time Configuration
  pfMPClipTexture Utilities

pfuProcessClipCentersWithChannel
  `libpfutil` Support
  Post-Load-Time Configuration
  pfMPClipTexture Utilities

pfvDisplayMngr class
  Importing OpenGL Multipipe SDK (MPK) Configuration Files

pfVec2
  Vector Operations

pfVec2 class
  New Types Required for Reps
  New Types Required for Reps

pfVec3
  Vector Operations

pfVec3 class
  New Types Required for Reps

pfVec4
  Vector Operations

pfVec4 class
  New Types Required for Reps

pfVideoChannel
  Controlling the Video Output

pfVideoChannelInfo()
  Controlling the Video Output

pfview program
  Reading XML Configuration Files

pfvInteractor class
  Picking, Selection, and Interaction

pfvmDrawStyle module
  More Sample Programs, Configuration Files, and Source Code

pfvmEarthSky module
  More Sample Programs, Configuration Files, and Source Code

pfvmLoader module
  More Sample Programs, Configuration Files, and Source Code

pfvmLogo module
  More Sample Programs, Configuration Files, and Source Code

pfvmNavigator module
  Adding Interaction to a pfvViewer Program
  More Sample Programs, Configuration Files, and Source Code

pfvmPicker module
  Adding Interaction to a pfvViewer Program
  More Sample Programs, Configuration Files, and Source Code

pfvmSnapshot module
  More Sample Programs, Configuration Files, and Source Code

pfvmStats module
  More Sample Programs, Configuration Files, and Source Code

pfvmTrackball module
  More Sample Programs, Configuration Files, and Source Code

pfvmWorldSwitcher module
  More Sample Programs, Configuration Files, and Source Code

pfVolFog class
  Patchy Fog and Layered Fog

pfvPicker class
  Picking, Selection, and Interaction

pfvSelector class
  Picking, Selection, and Interaction

pfvViewer class
  Importing OpenGL Multipipe SDK (MPK) Configuration Files
  Overview

pfWaitForVmeBus()
  Timing Issues

pfWinShare()
  Window Share Groups

pfWinSwapBarrier()
  Synchronization of Buffer Swap for Multiple Windows

pfWriteEvents()
  Controlling the Collection of OpenGL Performer Internal Events

phase
  defined
    Glossary

PHD format. See formats
  SGI PHD Format

PHIGS
  AAI/Graphicon IRTP Format

picking
  Paths through the Scene Graph
  Picking

pipe
  Hyperpipe Concepts

pipe windows
  Creating, Configuring and Opening pfPipeWindow

pipe, definition
  Glossary

pipelines
  functional stages
    The Functional Stages of a Pipeline
  multiple
    Multiple Rendering Pipelines
    Video Refresh Counter (VClock)
  multiprocessing
    Process Callbacks
  overview
    Using Pipes

pitch
  Setting Up a Viewpoint
  defined
    Glossary

pixie
  Performance Measurement Tools
  Performance Measurement Tools
  Using `pixie`, `prof`, and `gprof` to Measure Performance
  Using `pixie`, `prof`, and `gprof` to Measure Performance

planar curves
  Planar Curves
  mathematical description
    Mathematical Description of a Planar Curve

plane surfaces
  pfPlaneSurface

planes
  circles in the plane
    Circles in the Plane
  discrete curves
    Discrete Curves in the Plane
  lines in the plane
    Lines in the Plane
  NURBS curves
    NURBS Curves in the Plane
  superquadric curves in the plane
    Superquadric Curves: pfSuperQuadCurve2d

points
  New Types Required for Reps

point-volume intersection tests
  Point-Volume Intersection Tests

POLY format. See formats
  Side Effects POLY Format

polynomials
  Polynomials

polytopes
  The pfCullProgram Class
  Polytopes

popping
  definition
    Glossary
  in LOD transitions
    Level-of-Detail Transition Blending

positive rotation
  Setting Up a Viewpoint

postConfig()
  Extending a pfvViewer—Module Entry Points

postCull()
  Extending a pfvViewer—Module Entry Points

postDraw()
  Extending a pfvViewer—Module Entry Points

preConfig()
  Extending a pfvViewer—Module Entry Points

preCull()
  Extending a pfvViewer—Module Entry Points

preDraw()
  Extending a pfvViewer—Module Entry Points

previous statistics
  The pfStats Data Structure
  See also statistics
    The pfStats Data Structure

primitives
  attributes
    Attributes
  connectivity
    Primitive Connectivity
  flat-shaded
    pfGeoSet Draw Mode
  higher-order geometric primitives
    Geometric Primitives: The Base Class pfRep and the Application repTest
  orienting in reference frame
    Matrix Class: pfRMatrix
  types
    Primitive Types

printing objects
  Printing Objec ts with pfPrint()
  Printing Objec ts with pfPrint()

process callbacks
  Process Callbacks
  defined
    Glossary

process priority
  Placing Multiple OpenGL Performer Processes on a Single CPU
  Process Pipeline Tuning Tips

processor isolation
  Process Pipeline Tuning Tips

prof
  Performance Measurement Tools
  Performance Measurement Tools
  Using `pixie`, `prof`, and `gprof` to Measure Performance
  Using `pixie`, `prof`, and `gprof` to Measure Performance
  Using `pixie`, `prof`, and `gprof` to Measure Performance

profile of swept surface
  Swept Surfaces

profiling
  prof
    Using `pixie`, `prof`, and `gprof` to Measure Performance

program counter sampling
  Using `pixie`, `prof`, and `gprof` to Measure Performance

programming modules
  Overview

projective texture
  defined
    Glossary

proto tile
  `libpr` Functionality
  Configuring an Image Cache Proto Tile

prune, definition
  Glossary

pruning nodes
  Traversal Order

pseudo loaders
  libpfbreakup
    Database Operators with Pseudo Loaders
  libpfcliptile
    Database Operators with Pseudo Loaders
  libpfclosest
    Database Operators with Pseudo Loaders
  libpfctol
    Retessellating a Scene Graph
  libpfgeoa
    Database Operators with Pseudo Loaders
    Converting pfGeoSets to pfGeoArrays
  libpfrot
    Database Operators with Pseudo Loaders
  libpfscale
    Database Operators with Pseudo Loaders
  libpfsphere
    Database Operators with Pseudo Loaders
  libpfsubdiv
    Database Operators with Pseudo Loaders
    The libpfsubdiv Pseudo Loader
  libpftrans
    Database Operators with Pseudo Loaders
  libpfvct
    Database Operators with Pseudo Loaders
    `libpfdb` Support
    Cliptexture Loaders
  list of
    Database Operators with Pseudo Loaders
  OpenGL Performer implementation
    Database Operators with Pseudo Loaders
  pfctol
    Reading and Writing Topology Information: Using Pseudo Loaders
  pfttol
    Reading and Writing Topology Information: Using Pseudo Loaders

PTU format. See formats
  SGI PTU Format

public structs
  Class Taxonomy

punch through, definition
  Glossary

quaternion
  Quaternion Operations
  spherical linear interpolation
    Quaternion Operations
  use in C++ API
    Public Structs

query array
  Adding a Q uery Array

queue
  Handling Queues
  retrieving elements
    Retrieving Elements from the Queue

r_streams
  num_streams, s_streams, t_streams, and r_streams

rapid rendering, for on-air broadcast
  Why Use OpenGL Performer?

raster displays
  Calligraphic Versus Raster Displays

REACT
  Process Pipeline Tuning Tips
  Performance Measurement Tools

read function
  Read Function
  custom
    Custom Read Functions
    Custom Read Functions
  sorting
    Read Queue Sorting

read queue
  Read Queue Sorting
  Read Queue Sorting

read()
  Asynchronous I/O (IRIX only)

ReadDirect
  Custom Read Functions

ReadNormal
  Custom Read Functions

RealityEngine graphics
  pipelines, multiple
    Multiple Rendering Pipelines
  tuning
    Notes on Tuning for RealityEngine Graphics

real-time programming
  Process Pipeline Tuning Tips

real-time shadows
  Real-Time Shadows

reference count, definition
  Glossary

reference counting
  pfDelete() and Reference Counting
  pfDelete() and Reference Counting

reference counts
  pfDelete() and Reference Counting

reference frame, orienting primitive
  Matrix Class: pfRMatrix

reference point array
  Vertex and Reference Point Arrays

reference position
  Vertices

reference vertices
  Discontinuous, Neighboring LODs

refresh rate
  Fixing the Frame Rate

rendering
  modes
    Rendering Modes
  multiple channels
    Using Multiple Channels
  stages of
    Review of Rendering Stages

rendering pipelines
  definition
    Glossary
  See pipelines
    Using Pipes

rendering values
  Rendering Values

representations
  Features and Uses of Higher-Order Geometric Primitives

reps
  Features and Uses of Higher-Order Geometric Primitives
  and memory footprint
    Features and Uses of Higher-Order Geometric Primitives
  base class
    Geometric Primitives: The Base Class pfRep and the Application repTest
  using effectively
    Objects Required by Reps

repTest sample application
  Geometric Primitives: The Base Class pfRep and the Application repTest
  Parametric Surfaces
  pfSphereSurface Example
  pfSphereSurface Example
  Sample of a Trimmed pfNurbSurface From repTest
  Tessellators for Varying Levels of Detail

reserved functions
  Overview

right-hand rule
  Setting Up a Viewpoint
  defined
    Glossary

roll
  Setting Up a Viewpoint
  defined
    Glossary

rotating geometry to track eyepoint
  pfBillboard Nodes
  Graphics and Modeling Techniques to Improve Performances

rotations
  quaternion
    Quaternion Operations

routines
  Vector Operations
  enterView()
    Extending a pfvViewer—Module Entry Points
  enterWorld()
    Extending a pfvViewer—Module Entry Points
  exitView()
    Extending a pfvViewer—Module Entry Points
  exitWorld()
    Extending a pfvViewer—Module Entry Points
  for 3-Vectors
    Vector Operations
  for 4x4 Matrices
    Matrix Operations
  for quatermions
    Quaternion Operations
  frame()
    Extending a pfvViewer—Module Entry Points
  handleEvent()
    Extending a pfvViewer—Writing Custom Modules
    Extending a pfvViewer—Module Entry Points
  libpr
    pfCompositorAddChild()
      Using the pfCompositor Class
    pfCompositorChildFrustum()
      Using the pfCompositor Class
    pfCompositorChildSubdivision()
      Using the pfCompositor Class
    pfCompositorChildViewport()
      Using the pfCompositor Class
    pfCompositorLoadBalancer()
      Using the pfCompositor Class
    pfCompositorMasterPipe()
      Using the pfCompositor Class
    pfCompositorMode()
      Using the pfCompositor Class
    pfCompositorNearFar()
      Using the pfCompositor Class
    pfCompositorOrtho()
      Using the pfCompositor Class
    pfCompositorPerspective()
      Using the pfCompositor Class
    pfCompositorReconfig()
      Using the pfCompositor Class
    pfCompositorVal()
      Using the pfCompositor Class
    pfCompositorViewport()
      Using the pfCompositor Class
    pfGetCompositorChildFrustum()
      Using the pfCompositor Class
    pfGetCompositorChildSubdivision()
      Using the pfCompositor Class
    pfGetCompositorChildViewport()
      Using the pfCompositor Class
    pfGetCompositorFrustType()
      Using the pfCompositor Class
    pfGetCompositorFrustum()
      Using the pfCompositor Class
    pfGetCompositorLoadBalancer()
      Using the pfCompositor Class
    pfGetCompositorMode()
      Using the pfCompositor Class
    pfGetCompositorNearFar()
      Using the pfCompositor Class
    pfGetCompositorVal()
      Using the pfCompositor Class
    pfGetCompositorViewport()
      Using the pfCompositor Class
    pfGetLoadBalanceLoad()
      Load Balancing
    pfGetLoadBalanceNumActive()
      Load Balancing
    pfGetLoadBalanceVal()
      Load Balancing
    pfGetLoadBalanceWork()
      Load Balancing
    pfLoadBalanceBalance()
      Load Balancing
    pfLoadBalanceLoad()
      Load Balancing
    pfLoadBalanceNumActive()
      Load Balancing
    pfLoadBalanceVal()
      Load Balancing
  matrix stack
    Matrix Stack Operations
  overlay()
    Extending a pfvViewer—Module Entry Points
  pfAccumulateStats()
    Statistics Tokens
  pfAddChan()
    Multiple Channels and Multiple Windows
  pfAddChild()
    pfGroup
    pfGroup
    pfBuffer
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfAddGSet()
    pfDelete() and Reference Counting
    pfDelete() and Reference Counting
    pfGeode Nodes
    pfText Nodes
  pfAddMat()
    Matrix Operations
  pfAddScaledVec3()
    Vector Operations
  pfAddVec3()
    Vector Operations
  pfAllocChanData()
    Process Callbacks and Passthrough Data
    Passthrough Data
    Process Pipeline Tuning Tips
  pfAllocIsectData()
    Passthrough Data
  pfAlmostEqualMat()
    Matrix Operations
  pfAlmostEqualVec3()
    Vector Operations
  pfAlphaFunc()
    Immediate Mode
    Alpha Function
    Graphics and Modeling Techniques to Improve Performances
    Graphics and Modeling Techniques to Improve Performances
  pfAlphaFunction()
    Transparency
  pfAntialias()
    Antialiasing
    Creating, Configuring and Opening pfPipeWindow
    Draw Stage and Graphics Pipeline Optimizations
    Fill Bottlenecks
    Overview
  pfApp()
    Rules for Invoking Functions While Multiprocessing
  pfAppearanceChanged()
    Setting Up Shaded pfGeoSets
  pfAppFrame()
    Application Traversal
    Application Traversal
    Application Traversal
  pfApplyCtab()
    Color Tables
    Rendering Attributes
  pfApplyFog()
    Rendering Attributes
  pfApplyGState()
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
    Immediate Mode
    Local and Global State
    Applying pfGeoStates
    pfGeoSets and pfGeoStates
    pfGeoSets and pfGeoStates
  pfApplyGStateTable()
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
    pfGeoSets and pfGeoStates
  pfApplyHlight()
    Rendering Attributes
    Highlights
  pfApplyLModel()
    Rendering Attributes
  pfApplyLPState()
    Rendering Attributes
  pfApplyMtl()
    Rules for Invoking Functions While Multiprocessing
    Rendering Attributes
    Rendering Attributes
  pfApplyTEnv()
    Rendering Attributes
    Texture
  pfApplyTex()
    Rules for Invoking Functions While Multiprocessing
    Immediate Mode
    Rendering Attributes
    Texture Management
    Texture Management
    Local and Global State
    Draw Process Tips
  pfApplyTGen()
    Automatic Texture Coordinate Generation
    Rendering Attributes
  pfApplyVolFog()
    Creating Layered Fog
    Initializing a pfVolFog
    Layered Fog
  pfAsynchDelete()
    pfAsyncDelete
  pfAttachChan()
    Using Channel Groups
  pfAttachDPool()
    Datapools
  pfAttachPWin()
    Configuring pfPipeWindows and pfChannels
    Creating, Configuring and Opening pfPipeWindow
  pfAttachPWinSwapGroup()
    Configuring pfPipeWindows and pfChannels
  pfAttachPWinWin()
    Configuring pfPipeWindows and pfChannels
  pfAttachPWinWinSwapGroup()
    Configuring pfPipeWindows and pfChannels
  pfAttachWin()
    Alternate Framebuffer Configuration Windows
  pfAverageStats()
    Statistics Tokens
  pfBboardAxis()
    pfBillboard Nodes
  pfBboardMode()
    pfBillboard Nodes
  pfBboardPos()
    pfBillboard Nodes
  pfBeginSprite()
    Sprite Transformations
    Sprite Transformations
  pfBindPWinPVChans()
    Configuring pfPipeWindows and pfChannels
  pfBoxAroundBoxes()
    Creating Bounding Volumes
  pfBoxAroundPts()
    Creating Bounding Volumes
  pfBoxAroundSpheres()
    Creating Bounding Volumes
  pfBoxContainsBox()
    Volume-Volume Intersection Tests
  pfBoxContainsPt()
    Point-Volume Intersection Tests
  pfBoxExtendByBox()
    Creating Bounding Volumes
  pfBoxExtendByPt()
    Creating Bounding Volumes
  pfBoxIsectSeg()
    Intersecting with Volumes
  pfBufferAddChild()
    pfBuffer
    Glossary
  pfBufferClone()
    pfBuffer
    pfBuffer
    pfBuffer
    Glossary
  pfBufferRemoveChild()
    pfBuffer
    Glossary
  pfBuildPart()
    pfPartition Nodes
    pfPartition Nodes
  pfCBufferChanged()
    CycleBuffers
  pfCBufferConfig()
    CycleBuffers
    CycleBuffers
  pfCBufferFrame()
    CycleBuffers
    CycleBuffers
  pfChanBinOrder()
    Sorting the Scene
    Glossary
  pfChanBinSort()
    Sorting the Scene
    Glossary
  pfChanESky()
    Setting Up a Scene
    Using pfEarthSky
    Atmospheric Effects
    Atmospheric Effects
  pfChanFOV()
    Field–of–View
  pfChanGState()
    Draw Stage and Graphics Pipeline Optimizations
  pfChanLODAttr()
    Fixing the Frame Rate
  pfChanLODLODStateIndex()
    Level-of-Detail States
  pfChanLODStateList()
    Level-of-Detail States
  pfChanNearFar()
    Clipping Planes
  pfChanNodeIsectSegs()
    Testing Line Segment Intersections
  pfChanPick()
    Picking
  pfChanScene()
    Setting Up a Scene
    Setting Up a Scene
    pfScene Nodes
  pfChanShare()
    Using Channel Groups
    Using Channel Groups
    Application Traversal
    Creating, Configuring and Opening pfPipeWindow
  pfChanStatsMode()
    Displaying Statistics Simply
  pfChanStress()
    Fixing the Frame Rate
  pfChanStressFilter()
    Fixing the Frame Rate
    Dynamic Load Management
  pfChanTravFunc()
    Paths through the Scene Graph
    Process Callbacks and Passthrough Data
    Passthrough Data
  pfChanTravFuncs()
    Using pfEarthSky
  pfChanTravMask()
    pfNode Draw Mask
  pfChanTravMode()
    Visibility Testing
    Visibility Testing
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    Cull Traversal
    Cull and Intersection Optimizations
    `libpf` Databases
  pfChanView()
    Setting Up a Viewpoint
    Setting Up a Viewpoint
  pfChanViewMat()
    Setting Up a Viewpoint
    Setting Up a Viewpoint
  pfChanViewOffsets()
    Using Channel Groups
  pfChooseFBConfig()
    Configuring the Framebuffer of a pfWindow
  pfChoosePWinFBConfig()
    Configuring pfPipeWindows and pfChannels
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfChooseWinFBConfig()
    Configuring the Framebuffer of a pfWindow
  pfClear()
    Rules for Invoking Functions While Multiprocessing
  pfClearChan()
    Process Callbacks and Passthrough Data
    Using pfEarthSky
    Stage Timing Graph
    Fill Bottlenecks
  pfClearStats()
    Statistics Tokens
  pfClipSeg()
    Creating and Working with Line Segments
    Intersecting with Volumes
  pfClipTextureAllocatedLevels()
    Configuring an Image Cache Level
  pfClipTextureClipSize()
    Configuring an Image Cache Level
  pfClipTextureEffectiveLevels()
    Configuring an Image Cache Level
  pfClipTextureInvalidBorder()
    Configuring an Image Cache Level
  pfClipTextureLevel()
    Configuring an Image Cache Level
    Configuring Image Tiles
  pfClipTextureVirtualSize()
    Configuring an Image Cache Level
  pfClockMode()
    High-Resolution Clocks
  pfClockName()
    High-Resolution Clocks
  pfClone()
    pfBuffer
  pfCloseDList()
    Display Lists
  pfCloseFile()
    Asynchronous I/O (IRIX only)
  pfClosePWin()
    Creating, Configuring and Opening pfPipeWindow
    pfPipeWindows in Action
  pfClosePWinGL()
    Creating, Configuring and Opening pfPipeWindow
  pfCloseWin()
    Manipulating a pfWindow
  pfCloseWinGL()
    Alternate Framebuffer Configuration Windows
  pfCombineVec3()
    Vector Operations
  pfCompositorChannelClipped()
    Using the pfCompositor Class
  pfConfig()
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
    Creating and Configuring a pfPipe
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
    Order of Calls
    Order of Calls
    Order of Calls
    Order of Calls
    DBASE Process
    CycleBuffers
    Creating and Deleting a pfFlux
    Shared Memory
    Controlling the Collection of OpenGL Performer Internal Events
    Extending a pfvViewer—Module Entry Points
    Initializing Shared Memory
    Static Member Data
  pfConfigPWin()
    Creating, Configuring and Opening pfPipeWindow
    pfPipeWindows in Action
    pfPipeWindows in Action
    Draw Process Tips
  pfConfigStage()
    Creating and Configuring a pfPipe
    Draw Process Tips
  pfConjQuat()
    Quaternion Operations
  pfCopy()
    Copying Objects with pfCopy()
    pfGeoSet Operations
    Allocating Memory With pfMalloc()
    Copying
  pfCopyFStats()
    Statistics Class Structures
    Copying
  pfCopyGSet()
    pfGeoSet (Geometry Set)
  pfCopyGState()
    pfGeoSets and pfGeoStates
  pfCopyMat()
    Matrix Operations
  pfCopyStats()
    Statistics Class Structures
    Statistics Tokens
    Copying
  pfCopyVec3()
    Vector Operations
  pfCreateDPool()
    Datapools
    Datapools
  pfCreateFile()
    Asynchronous I/O (IRIX only)
  pfCrossVec3()
    Vector Operations
  pfCull()
    Process Callbacks and Passthrough Data
    Forcing Display List Generation
    Rules for Invoking Functions While Multiprocessing
    Stage Timing Graph
    Extending a pfvViewer—Module Entry Points
  pfCullFace()
    Frontface / Backface
    Draw Stage and Graphics Pipeline Optimizations
  pfCullPath()
    Paths through the Scene Graph
    Paths through the Scene Graph
  pfCullProgramAddBinParent()
    User-Defined Cull Program Instructions
  pfCullProgramAddPgmInstruction()
    Predefined Cull Program Instructions
  pfCullProgramAddPgmOpcode()
    Predefined Cull Program Instructions
  pfCullProgramIsSubbinOf()
    User-Defined Cull Program Instructions
  pfCullProgramResetBinParents()
    User-Defined Cull Program Instructions
  pfCullProgramResetPgm()
    Predefined Cull Program Instructions
  pfCullProgramTestPolytope()
    User-Defined Cull Program Instructions
  pfCullResult()
    pfNode Cull and Draw Callbacks
  pfCurCBufferIndex()
    CycleBuffers
  pfCylAroundSegs()
    Intersecting with pfGeoArrays
    Creating Bounding Volumes
    Efficient Intersection and Traversals
  pfCylContainsPt()
    Point-Volume Intersection Tests
  pfdAddExtAlias()
    Database Loading Details
  pfdAddNodeToMesh()
    Meshes
    Creating a Subdivision Surface
  pfDBase()
    pfAsyncDelete
    Rules for Invoking Functions While Multiprocessing
  pfDBaseFunc()
    DBASE Process
    Application Optimizations
  pfdBldrStateAttr()
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfdBldrStateMode()
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfdBldrStateVal()
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfdBreakup()
    Database Operators with Pseudo Loaders
  pfdBuildTopologyTraverse()
    Main Features of the Methods in pfTopo
    Main Features of the Methods in pfTessellateAction
  pfdCleanTree()
    Creating an OpenGL Performer Database Converter using `libpfdu`
    Cull and Intersection Optimizations
    `libpf` Databases
    Balancing Cull and Draw Processing with Database Hierarchy
  pfdConverterAttr()
    Database Loading Details
  pfdConverterAttr_rpc()
    ArchVision RPC Format
    ArchVision RPC Format
  pfdConverterMode()
    Database Loading Details
  pfdConverterMode_rpc()
    ArchVision RPC Format
  pfdConverterVal()
    Database Loading Details
  pfdConverterVal_rpc()
    ArchVision RPC Format
  pfdConvertFrom()
    pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer
  pfdConvertGeoSetToGeoArray()
    Converting pfGeoSets to pfGeoArrays
  pfdConvertNodeGeoSetsToGeoArrays()
    Converting pfGeoSets to pfGeoArrays
  pfdConvertTo()
    pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer
  pfDCSCoord()
    pfDCS Nodes
  pfDCSMat()
    pfDCS Nodes
  pfDCSRot()
    pfDCS Nodes
    PFENG_ANIMATE Engines
  pfDCSScale()
    pfDCS Nodes
    PFENG_MATRIX Engines
    PFENG_ANIMATE Engines
  pfDCSScaleXYZ()
    PFENG_MATRIX Engines
    PFENG_ANIMATE Engines
  pfDCSTrans()
    pfDCS Nodes
    PFENG_MATRIX Engines
    PFENG_ANIMATE Engines
  pfdDefaultGState()
    Draw Stage and Graphics Pipeline Optimizations
  pfDecal()
    Decals
    Local and Global State
    Draw Stage and Graphics Pipeline Optimizations
    Fill Bottlenecks
    Glossary
  pfDelete()
    pfDelete() and Reference Counting
    pfDelete() and Reference Counting
    pfAsyncDelete
    pfGeoSet (Geometry Set)
    pfGeoSet Operations
    pfFont
    pfGeoSets and pfGeoStates
    Allocating Memory With pfMalloc()
    Allocating Memory With pfMalloc()
    Datapools
    datapools
      Datapools
  pfDetachChan()
    Using Channel Groups
  pfDetachPWinSwapGroup()
    Configuring pfPipeWindows and pfChannels
  pfDetachPWinWin()
    Configuring pfPipeWindows and pfChannels
  pfdExitConverter()
    Database Loading Details
  pfdFreezeTransforms()
    Cull and Intersection Optimizations
    `libpf` Databases
    Balancing Cull and Draw Processing with Database Hierarchy
  pfdGetConverterAttr()
    Database Loading Details
  pfdGetConverterAttr_rpc()
    ArchVision RPC Format
  pfdGetConverterMode()
    Database Loading Details
  pfdGetConverterMode_rpc()
    ArchVision RPC Format
  pfdGetConverterVal()
    Database Loading Details
  pfdGetConverterVal_rpc()
    ArchVision RPC Format
  pfdInitConverter()
    Database Loading Details
    Initializing Shared Memory
  pfDisable()
    Rules for Invoking Functions While Multiprocessing
    Enable / Disable
  pfDistancePt3()
    Vector Operations
  pfDivQuat()
    Quaternion Operations
  pfdLoadBldrState()
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfdLoadClipTexture()
    Creating Configuration Files
  pfdLoadClipTextureState()
    Creating Configuration Files
  pfdLoadFile()
    pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer
    pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer
    Shell Environment Variables
    Finding and initializing a Converter
    Creating an OpenGL Performer Database Converter using `libpfdu`
    Reading and Writing Topology Information: Using Pseudo Loaders
    File Search Paths
  pfdLoadImageCache()
    Filling in the Structures
  pfdLoadImageTileFormat()
    Filling in the Structures
  pfdMakeSceneGState()
    pfScene Default Rendering State
    Draw Stage and Graphics Pipeline Optimizations
  pfdMakeSharedScene()
    pfScene Default Rendering State
    Draw Stage and Graphics Pipeline Optimizations
    `libpf` Databases
  pfdOptimizeGStateList()
    pfScene Default Rendering State
    Draw Stage and Graphics Pipeline Optimizations
  pfDotVec3()
    Vector Operations
  pfDPoolAlloc()
    Datapools
  pfDPoolAttachAddr()
    Datapools
  pfDPoolFind()
    Datapools
    Datapools
  pfDPoolLock()
    Datapools
    Datapools
  pfDPoolUnlock()
    Datapools
    Datapools
  pfdPopBldrState()
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfdPushBldrState()
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfDraw()
    Process Callbacks and Passthrough Data
    Forcing Display List Generation
    Rules for Invoking Functions While Multiprocessing
    Stage Timing Graph
    Stage Timing Graph
    Stage Timing Graph
    Fill Bottlenecks
    Draw Process Tips
    Balancing Cull and Draw Processing with Database Hierarchy
    Extending a pfvViewer—Module Entry Points
  pfDrawChanStats()
    Statistics
    Statistics
    Displaying Statistics Simply
    Statistics Class Structures
    Application Optimizations
    Balancing Cull and Draw Processing with Database Hierarchy
    Balancing Cull and Draw Processing with Database Hierarchy
    Performance Measurement Tools
    Performance Measurement Tools
    Use the Simplest Process Model
  pfDrawDList()
    pfGeoSet Operations
    Display Lists
    Local and Global State
  pfDrawFStats()
    Statistics
    Statistics
    Displaying Statistics Simply
    Statistics Class Structures
    Statistics Class Structures
  pfDrawGSet()
    Rules for Invoking Functions While Multiprocessing
    pfGeoSet (Geometry Set)
    pfGeoSet Draw Mode
    pfGeoSet Draw Mode
    pfGeoSet Operations
    pfGeoSet Operations
    Drawing pfGeoArrays
    Local and Global State
    pfGeoSets and pfGeoStates
  pfDrawHlightedGSet()
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
  pfDrawString()
    Rules for Invoking Functions While Multiprocessing
    pfString
    pfString
  pfDrawVolFog()
    Initializing a pfVolFog
    Drawing a Scene with Fog
  pfdSaveBldrState()
    Creating an OpenGL Performer Database Converter using `libpfdu`
  pfdStoreFIle()
    pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer
  pfdTessellateGeometry()
    Base Class pfTessellateAction
    Main Features of the Methods in pfTessParaSurface
  pfEarthSky()
    Process Callbacks and Passthrough Data
  pfEnable()
    Rules for Invoking Functions While Multiprocessing
    Enable / Disable
    Local and Global State
  pfEnableStatsHw()
    Collecting and Accessing Statistics in Your Application
    Statistics in `libpr` and `libpf`—pfStats Versus pfFrameStats
    Statistics Buffers
  pfEndSprite()
    Sprite Transformations
    Sprite Transformations
  pfEngineDst()
    Setting Engine Sources and Destinations
  pfEngineEvaluate()
    Coordinating pfFlux and Connected pfEngines
    Evaluating pfEngines
  pfEngineEvaluationRange()
    Setting Engine Ranges
    Evaluating pfEngines
  pfEngineIterations()
    Setting Engine Iterations
  pfEngineMask()
    Setting Engine Masks
  pfEngineMode()
    Setting Engine Types and Modes
    PFENG_MATRIX Engines
    PFENG_ANIMATE Engines
    PFENG_TIME Engines
    Setting Engine Ranges
  pfEngineSrc()
    Setting Engine Sources and Destinations
  pfEngineSrcChanged()
    Coordinating pfFlux and Connected pfEngines
  pfEngineUserFunction()
    PFENG_USER_FUNCTION Engines
  pfEqualMat()
    Matrix Operations
  pfEqualVec3()
    Vector Operations
  pfESkyAttr()
    Atmospheric Effects
  pfESkyColor()
    Atmospheric Effects
  pfESkyFog()
    Atmospheric Effects
  pfESkyMode()
    Atmospheric Effects
    Multisampling
  pfEvaluateLOD()
    Run-Time User Control Over LOD Evaluation
  pfEventSampleOff()
    Controlling the Collection of OpenGL Performer Internal Events
  pfEventSampleOn()
    Controlling the Collection of OpenGL Performer Internal Events
  pfExpQuat()
    Quaternion Operations
  pfFCSFlux()
    Animating a Geometry
  pfFeature()
    Fill Bottlenecks
    Graphics and Modeling Techniques to Improve Performances
  pfFilePath()
    File Search Paths
    File Search Paths
  pfFilePathv()
    File Search Paths
  pfFindFile()
    File Search Paths
  pfFlatten()
    pfSCS Nodes
    pfBuffer
    Creating an OpenGL Performer Database Converter using `libpfdu`
    Cull and Intersection Optimizations
    Cull and Intersection Optimizations
    Transform Bottlenecks
    `libpf` Databases
    Balancing Cull and Draw Processing with Database Hierarchy
  pfFlattenString()
    pfString
  pfFlushState()
    Applying pfGeoStates
  pfFluxCallDataFunc()
    Initializing the Buffers
    Initializing the Buffers
  pfFluxDefaultNumBuffers()
    Creating and Deleting a pfFlux
  pfFluxDisableSyncGroup()
    Enabling a Flux Sync Group
  pfFluxedGSetInit()
    Fluxed Geosets
  pfFluxEnableSyncGroup()
    Enabling a Flux Sync Group
  pfFluxEvaluate()
    Triggering pfFlux Evaluation
    Evaluating pfEngines
    Evaluating pfEngines
  pfFluxEvaluateEye()
    Triggering pfFlux Evaluation
  pfFluxFrame()
    pfFlux Buffers
  pfFluxInitData()
    Initializing the Buffers
  pfFluxMask()
    Triggering pfFlux Evaluation
  pfFluxMode()
    Reading pfFlux Buffers
  pfFluxSyncComplete()
    Evaluating a Synchronized Flux Group
  pfFluxSyncGroup()
    Synchronizing pfFluxes with Flux Sync Groups
  pfFluxSyncGroupReady()
    Evaluating a Synchronized Flux Group
    Evaluating a Synchronized Flux Group
  pfFluxWriteComplete()
    Writing to pfFlux Buffers
    Evaluating a Synchronized Flux Group
  pfFogRange()
    Fog
  pfFogType()
    Fog
  pfFontAttr()
    pfFont
  pfFontCharGSet()
    pfFont
  pfFontCharSpacing()
    pfFont
  pfFontMode()
    pfFont
  pfFrame()
    Application Traversal
    Cull Traversal
    Process Callbacks
    Process Callbacks and Passthrough Data
    Process Callbacks and Passthrough Data
    Fixing the Frame Rate
    Intersection Pipeline
    Multiple Rendering Pipelines
    DBASE Process
    Passthrough Data
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    CycleBuffers
    Stage Timing Graph
    Stage Timing Graph
    Application Optimizations
    pfFrame Events
    Extending a pfvViewer—Module Entry Points
    Overview
  pfFrameRate()
    Selecting the Frame Rate
    Fixing the Frame Rate
    Status Line
    Status Line
  pfFree()
    Memory Allocation
    Allocating Memory With pfMalloc()
    Allocating Memory With pfMalloc()
    Allocating Memory With pfMalloc()
  pfFrustContainsBox()
    Volume-Volume Intersection Tests
  pfFrustContainsCyl()
    Volume-Volume Intersection Tests
  pfFrustContainsPt()
    Point-Volume Intersection Tests
  pfFrustContainsSphere()
    Volume-Volume Intersection Tests
  pfFSatsClass()
    Statistics Rules of Use
  pfFStatsAttr()
    Setting Update Rate
  pfFStatsClass()
    Fill Statistics
    Enabling Only Statistics of Interest
  pfFStatsCountNode()
    Statistics Class Structures
    Statistics Buffers
  pfFullXformPt3()
    Vector Operations
  pfGArrayAddAttr()
    pfGeoArray Attributes
    pfGeoArray Attributes
    pfGeoArray Attributes
  pfGArrayAddAttrType()
    pfGeoArray Attribute Types
  pfGArrayAddColorAttrType()
    pfGeoArray Attribute Types
  pfGArrayAddGenericAttrType()
    pfGeoArray Attributes
    pfGeoArray Attribute Types
  pfGArrayAddNormalAttrType()
    pfGeoArray Attribute Types
  pfGArrayAddTextureAttrType()
    pfGeoArray Attributes
    pfGeoArray Attribute Types
  pfGArrayAddVertexAttrType()
    pfGeoArray Attribute Types
  pfGArrayAllowCache()
    pfGeoArray Attributes
  pfGArrayAttrPtr()
    pfGeoArray Attributes
    pfGeoArray Attributes
    pfGeoArray Attributes
  pfGArrayAttrSize()
    pfGeoArray Attributes
  pfGArrayAttrStride()
    pfGeoArray Attributes
  pfGArrayAttrType()
    pfGeoArray Attributes
  pfGArrayIndexArray()
    pfGeoArray Attributes
  pfGArrayRemoveAttr()
    pfGeoArray Attributes
  pfGArrayUpdateData()
    pfGeoArray Attributes
  pfGeoSetIsectMask()
    Writing to pfFlux Buffers
  pfGetArena()
    Allocating Memory With pfMalloc()
  pfGetBboardAxis()
    pfBillboard Nodes
  pfGetBboardMode()
    pfBillboard Nodes
  pfGetBboardPos()
    pfBillboard Nodes
  pfGetChanFStats()
    Statistics
    Statistics Rules of Use
  pfGetChanLoad()
    Fixing the Frame Rate
  pfGetChanView()
    Setting Up a Viewpoint
  pfGetChanViewMat()
    Setting Up a Viewpoint
  pfGetChanViewOffsets
    Setting Up a Viewpoint
  pfGetCompositorChannelClipped()
    Using the pfCompositor Class
  pfGetCullResult()
    pfNode Cull and Draw Callbacks
  pfGetCurGState()
    pfGeoSets and pfGeoStates
  pfGetCurWSConnection()
    pfWindows and GL Windows
    Communicating with the Window System
  pfGetDCSMat()
    pfDCS Nodes
  pfGetEngineDst()
    Setting Engine Sources and Destinations
  pfGetEngineFunction()
    Creating and Deleting Engines
  pfGetEngineIterations()
    Setting Engine Iterations
  pfGetEngineMask()
    Setting Engine Masks
  pfGetEngineMode()
    Setting Engine Types and Modes
  pfGetEngineNumSrcs()
    Setting Engine Sources and Destinations
  pfGetEngineSrc()
    Setting Engine Sources and Destinations
  pfGetEngineUserFunction()
    PFENG_USER_FUNCTION Engines
  pfGetFFlux()
    pfFlux Buffers
  pfGetFilePath()
    File Search Paths
  pfGetFileStatus()
    Asynchronous I/O (IRIX only)
  pfGetFluxClientEngine()
    Coordinating pfFlux and Connected pfEngines
  pfGetFluxCurData()
    Reading pfFlux Buffers
    Reading pfFlux Buffers
    Fluxed Coordinate Systems
  pfGetFluxDataSize()
    Creating and Deleting a pfFlux
  pfGetFluxDefaultNumBuffers()
    Creating and Deleting a pfFlux
  pfGetFluxEnableSyncGroup()
    Enabling a Flux Sync Group
  pfGetFluxFrame()
    PFENG_TIME Engines
    PFENG_STROBE Engines
  pfGetFluxMask()
    Triggering pfFlux Evaluation
  pfGetFluxMemory()
    pfFlux Buffers
  pfGetFluxNamedSyncGroup()
    Synchronizing pfFluxes with Flux Sync Groups
  pfGetFluxNumClientEngines()
    Coordinating pfFlux and Connected pfEngines
  pfGetFluxNumNamedSyncGroups()
    Synchronizing pfFluxes with Flux Sync Groups
  pfGetFluxNumSrcEngines()
    Coordinating pfFlux and Connected pfEngines
  pfGetFluxSrcEngine()
    Coordinating pfFlux and Connected pfEngines
  pfGetFluxSyncGroup()
    Synchronizing pfFluxes with Flux Sync Groups
  pfGetFluxSyncGroupName()
    Synchronizing pfFluxes with Flux Sync Groups
  pfGetFluxWritableData()
    Reading pfFlux Buffers
    Writing to pfFlux Buffers
  pfGetGSet()
    pfGeode Nodes
    pfText Nodes
  pfGetGSetClassType()
    Intersecting with pfGeoArrays
    Intersecting with pfGeoArrays
  pfGetGSetLineWidth()
    pfGeoArray Special Rendering Characteristics
  pfGetGSetPntSize()
    pfGeoArray Special Rendering Characteristics
  pfGetGSetPrimLength()
    pfGeoSet (Geometry Set)
    Primitive Type Descriptions
  pfGetGSetPrimLengths()
    Primitive Type Descriptions
  pfGetIBRnodeProxyTexCoords()
    Creating a pfIBRnode Using a Proxy
  pfGetIBRtextureDefaultTexture()
    Creating a pfIBRnode
  pfGetImageTileMemInfo ()
    Configuring an Image Cache Proto Tile
  pfGetLayerBase()
    pfLayer Nodes
  pfGetLayerDecal()
    pfLayer Nodes
  pfGetLayerMode()
    pfLayer Nodes
  pfGetLODCenter()
    pfLOD Nodes
  pfGetLODRange()
    pfLOD Nodes
  pfGetMatCol()
    Matrix Operations
  pfGetMatColVec3()
    Matrix Operations
  pfGetMatRow()
    Matrix Operations
  pfGetMatRowVec3()
    Matrix Operations
  pfGetMeshBbox()
    Meshes
  pfGetMeshFace()
    Meshes
  pfGetMeshFaceNumVerts()
    Mesh Faces
  pfGetMeshFaceVertex()
    Mesh Faces
  pfGetMeshVertex()
    Meshes
  pfGetMStack()
    Matrix Stack Operations
  pfGetMStackDepth()
    Matrix Stack Operations
    Matrix Stack Operations
  pfGetMStackTop()
    Matrix Stack Operations
  pfGetNumChildren()
    pfGroup
    pfGroup
  pfGetNumGSets()
    pfGeode Nodes
    pfText Nodes
  pfGetOrthoMatCoord()
    Matrix Operations
  pfGetOrthoMatQuat()
    Matrix Operations
  pfGetParent()
    Paths through the Scene Graph
  pfGetParentCullResult()
    pfNode Cull and Draw Callbacks
  pfGetPartAttr()
    pfPartition Nodes
    pfPartition Nodes
  pfGetPartType()
    pfPartition Nodes
  pfGetPipe()
    Creating and Configuring a pfPipe
    Using the Default Hyperpipe Mapping to Graphic Pipes
  pfGetPipeScreen()
    Creating and Configuring a pfPipe
  pfGetPipeSize()
    Creating and Configuring a pfPipe
  pfGetPWinCurOriginSize()
    Creating, Configuring and Opening pfPipeWindow
  pfGetQuatRot()
    Quaternion Operations
  pfGetRef()
    pfDelete() and Reference Counting
  pfGetSCSMat()
    pfSCS Nodes
  pfGetSemaArena()
    Shared Memory and pfInit()
    State Management
    Memory Allocation
    Allocating Locks and Semaphores
  pfGetSeqDuration()
    pfSequence Nodes
  pfGetSeqFrame()
    pfSequence Nodes
  pfGetSeqInterval()
    pfSequence Nodes
  pfGetSeqMode()
    pfSequence Nodes
  pfGetSeqTime()
    pfSequence Nodes
  pfGetSharedArena()
    Shared Memory and pfInit()
    Attributes
    Memory Allocation
    Allocating Memory With pfMalloc()
  pfGetSize()
    Allocating Memory With pfMalloc()
    Allocating Memory With pfMalloc()
  pfGetSwitchVal()
    pfSwitch Nodes
  pfGetTexMultiName()
    Texture Formats
  pfGetTGenMode()
    Automatic Texture Coordinate Generation
  pfGetTime()
    High-Resolution Clocks
  pfGetType()
    Determining Ob ject Type
  pfGetTypeName()
    Determining Ob ject Type
  pfGetUserData()
    Intersecting with pfGeoArrays
  pfGetVClock()
    Video Refresh Counter (VClock)
  pfGetVolFogTexture()
    Initializing a pfVolFog
  pfGetWinCurOriginSize()
    Creating a pfWindow
    Creating a pfWindow
  pfGetWinCurScreenOriginSize()
    Creating a pfWindow
  pfGetWinFBConfig()
    pfWindows and GL Windows
  pfGetWinGLCxt()
    pfWindows and GL Windows
  pfGetWinOrigin()
    Creating a pfWindow
  pfGetWinSize()
    Creating a pfWindow
  pfGetWinWSDrawable()
    pfWindows and GL Windows
  pfGetWinWSWindow()
    pfWindows and GL Windows
  pfGPParamsApply()
    Rendering Attributes
  pfGProgramApply()
    Rendering Attributes
  pfGSetAttr()
    pfDelete() and Reference Counting
    pfGeoSet (Geometry Set)
    Attributes
    Allocating Memory With pfMalloc()
    Animating a Geometry
  pfGSetBBox()
    pfGeoSet (Geometry Set)
    Intersecting with pfGeoArrays
  pfGSetBBoxFlux()
    Intersecting with pfGeoArrays
  pfGSetBound()
    Animating a Geometry
  pfGSetCalcTexBBox()
    Clip Texture Emulation Support
    Clip Texture Emulation Support
  pfGSetDecalPlane()
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
  pfGSetDrawBin()
    Drawing pfGeoArrays
  pfGSetDrawMode()
    pfGeoSet (Geometry Set)
    pfGeoSet Draw Mode
    pfGeoSet Draw Mode
    pfGeoSet Draw Mode
    pfGeoSet Operations
    Primitive Type Descriptions
    pfGeoArray Special Rendering Characteristics
  pfGSetDrawOrder()
    Drawing pfGeoArrays
  pfGSetGState()
    pfDelete() and Reference Counting
    pfGeoSet (Geometry Set)
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
    Clip Texture Emulation Support
    pfGeoSets and pfGeoStates
  pfGSetGStateIndex()
    pfGeoSet (Geometry Set)
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
  pfGSetHlight()
    pfDelete() and Reference Counting
    pfGeoSet (Geometry Set)
    pfGeoArrays (Geometry) and pfGeoStates (Appearance)
    Highlights
  pfGSetIsectMask()
    Enabling Caching
    pfGeoSet (Geometry Set)
    Intersecting with pfGeoArrays
    Intersection Masks
  pfGSetIsectSegs()
    pfGeoSet (Geometry Set)
    pfGeoSet Operations
    Intersecting with pfGeoArrays
    Intersecting with pfGeoArrays
    Intersecting with pfGeoSets
    Intersecting with pfGeoSets
    Intersecting with pfGeoSets
    Intersection Masks
  pfGSetLineWidth()
    pfGeoSet (Geometry Set)
    pfGeoArray Special Rendering Characteristics
  pfGSetMultiAttr()
    pfGeoSet (Geometry Set)
    Attributes
  pfGSetNumPrims()
    pfGeoSet (Geometry Set)
    Primitive Types
    Primitive Types
    Primitive Types
  pfGSetOptimize()
    Marking pfGeoSets for Optimization
    Quick Manipulation of Temporary pfGeoArrays
  pfGSetPntSize()
    pfGeoSet (Geometry Set)
    pfGeoArray Special Rendering Characteristics
  pfGSetPrimLengths()
    pfGeoSet (Geometry Set)
    Primitive Types
    Primitive Types
    Primitive Type Descriptions
  pfGSetPrimType()
    pfGeoSet (Geometry Set)
    Specifying Primitive Types
  pfGSetQuickAttr()
    Modifying Attributes of Cloned pfGeoSets
  pfGSetQuickMultiAttr()
    Modifying Attributes of Cloned pfGeoSets
  pfGSetQuickPrimLengths()
    Modifying Attributes of Cloned pfGeoSets
  pfGSetTexBBox_f()
    Clip Texture Emulation Support
  pfGSetTexBBox_i()
    Clip Texture Emulation Support
  pfGSetUpdateCteRefs()
    Clip Texture Emulation Support
  pfGStateAttr()
    pfDelete() and Reference Counting
    Local and Global State
    pfGeoSets and pfGeoStates
  pfGStateFuncs()
    pfGeoSets and pfGeoStates
  pfGStateInherit()
    Local and Global State
    pfGeoSets and pfGeoStates
  pfGStateMode()
    Rendering Modes
    Local and Global State
    pfGeoSets and pfGeoStates
  pfGStateVal()
    Rendering Values
    pfGeoSets and pfGeoStates
  pfHalfSpaceContainsBox()
    Volume-Volume Intersection Tests
  pfHalfSpaceContainsCyl()
    Volume-Volume Intersection Tests
  pfHalfSpaceContainsPt()
    Point-Volume Intersection Tests
  pfHalfSpaceContainsSphere()
    Volume-Volume Intersection Tests
  pfHalfSpaceIsectSeg()
    Intersecting with Volumes
  pfHideGSetStripPrim()
    Primitive Type Descriptions
  pfHlightColor()
    Highlights
  pfHlightLineWidth()
    Highlights
  pfHlightMode()
    Highlights
  pfHlightNormalLength()
    Highlights
  pfHlightPntSize()
    Highlights
  pfHyperpipe()
    Rules for Invoking Functions While Multiprocessing
    Establishing the Number of Graphic Pipes
    Establishing the Number of Graphic Pipes
  pfIBRnodeAngles()
    Creating a pfIBRnode
  pfIBRnodeFlags()
    Creating a pfIBRnode Using a Proxy
  pfIBRnodeIBRtexture()
    Creating a pfIBRnode
  pfIBRnodeProxyTexCoords()
    Creating a pfIBRnode Using a Proxy
  pfIBRtextureDirection()
    Creating a pfIBRtexture
  pfIBRtextureFlags()
    Creating a pfIBRtexture
    Parameters Controlling Drawing of a pfIBRnode
  pfIBRtextureIBRdirections()
    Creating a pfIBRtexture
  pfIBRtextureIBRtextures()
    Creating a pfIBRtexture
    Creating a pfIBRtexture
    Creating a pfIBRtexture
  pfIBRtextureLoadIBRtexture()
    Creating a pfIBRtexture
    Creating a pfIBRtexture
  pfIBRtextureNumRings()
    Creating a pfIBRtexture
  pfIBRtextureRing()
    Creating a pfIBRtexture
  pfIdleTex()
    Texture Management
  pfImageCacheFileStreamServer()
    Configuring an Image Cache
  pfImageCacheImageSize()
    Configuring an Image Cache
  pfImageCacheMemRegionOrigin()
    Configuring an Image Cache
  pfImageCacheMemRegionSize()
    Configuring an Image Cache
    Configuring an Image Cache
  pfImageCacheName()
    Configuring an Image Cache
  pfImageCacheProtoTile()
    Configuring an Image Cache
  pfImageCacheTex()
    Configuring an Image Cache
  pfImageCacheTexRegionOrigin()
    Configuring an Image Cache
  pfImageCacheTexRegionSize()
    Configuring an Image Cache
  pfImageCacheTexSize()
    Configuring an Image Cache
  pfImageCacheTileFileNameFormat()
    Configuring an Image Cache
  pfImageTileDefaultTile()
    Configuring the Default Tile
  pfImageTileFileImageFormat()
    Configuring Image Tiles
  pfImageTileFileImageType()
    Configuring an Image Cache Proto Tile
  pfImageTileFileName()
    Configuring an Image Cache Proto Tile
    Configuring the Default Tile
  pfImageTileHeaderOffset()
    Configuring an Image Cache Proto Tile
    Configuring Image Tiles
  pfImageTileMemImageFormat()
    Configuring Image Tiles
  pfImageTileMemImageType()
    Configuring an Image Cache Proto Tile
    Configuring Image Tiles
  pfImageTileMemInfo()
    Configuring an Image Cache Proto Tile
  pfImageTileNumFileTiles()
    Configuring an Image Cache Proto Tile
  pfImageTileReadFunc()
    Configuring an Image Cache Proto Tile
  pfImageTileReadQueue()
    Configuring an Image Cache Proto Tile
    Configuring the Default Tile
  pfImageTileSize()
    Configuring an Image Cache Proto Tile
    Configuring Image Tiles
  pfIndex()
    Stage Timing Graph
  pfInit()
    Order of Calls
    Shared Memory and pfInit()
    Shared Memory and pfInit()
    Shared Arenas
    Initializing Shared Memory
    Initializing Shared Memory
    Glossary
  pfInitArenas()
    Memory Allocation
    Allocating Memory With pfMalloc()
    Shared Arenas
    Shared Arenas
    Shared Arenas
    Allocating Locks and Semaphores
    Initializing Shared Memory
    Glossary
  pfInitCBuffer()
    CycleBuffers
  pfInitClock()
    High-Resolution Clocks
  pfInitGfx()
    pfWindows and GL Windows
    pfWindows and GL Windows
    Creating, Configuring and Opening pfPipeWindow
  pfInitializeEvents()
    Controlling the Collection of OpenGL Performer Internal Events
  pfInitState()
    State Management
    State Management
  pfInitVClock()
    Video Refresh Counter (VClock)
  pfInsertChan()
    One Window per Pipe, Multiple Channels per Window
    Multiple Channels and Multiple Windows
    Multiple Channels and Multiple Windows
  pfInsertChild()
    pfGroup
    pfGroup
  pfInsertGSet()
    pfDelete() and Reference Counting
    pfDelete() and Reference Counting
    pfGeode Nodes
    pfText Nodes
  pfInvertAffMat()
    Matrix Operations
  pfInvertFullMat()
    Matrix Operations
  pfInvertIdentMat()
    Matrix Operations
  pfInvertOrthoMat()
    Matrix Operations
  pfInvertOrthoNMat()
    Matrix Operations
  pfInvertQuat()
    Quaternion Operations
  pfIsectFunc()
    Intersection Pipeline
    Passthrough Data
    Application Optimizations
  pfisGSetStripPrimHidden()
    Primitive Type Descriptions
  pfIsOfType()
    Determining Ob ject Type
  pfIsTexLoaded()
    Texture Management
  pfLayer()
    Glossary
  pfLayerBase()
    pfLayer Nodes
  pfLayerDecal()
    pfLayer Nodes
  pfLayerMode()
    pfLayer Nodes
  pfLengthQuat()
    Quaternion Operations
  pfLengthVec3()
    Vector Operations
  pfLightAtten()
    Lighting
  pfLightOn()
    Lighting
    Rules for Invoking Functions While Multiprocessing
    Rendering Attributes
  pfLoadImageTile()
    Configuring Image Tiles
  pfLoadMatrix()
    Graphics Library Matrix Routines
  pfLoadMStack()
    Matrix Stack Operations
  pfLoadMultiTexFile()
    Texture Formats
  pfLoadState()
    State Management
  pfLoadTex()
    Texture Management
    Texture Management
  pfLoadTexFile()
    Texture
  pfLODCenter()
    pfLOD Nodes
  pfLODLODState()
    Level-of-Detail States
  pfLODLODStateIndex()
    Level-of-Detail States
  pfLODRange()
    pfLOD Nodes
  pfLODTransition()
    Level-of-Detail Transition Blending
  pfLODUserEvalFunc()
    Run-Time User Control Over LOD Evaluation
  pfLogQuat()
    Quaternion Operations
  pfMakeCoordMat()
    Matrix Operations
  pfMakeEulerMat()
    Matrix Operations
  pfMakeOrthoFrust()
    Frusta
  pfMakePerspFrust()
    Frusta
  pfMakePolarSeg()
    Creating and Working with Line Segments
  pfMakePtsSeg()
    Creating and Working with Line Segments
  pfMakeQuatMat()
    Matrix Operations
  pfMakeRotMat()
    Matrix Operations
  pfMakeRotOntoMat()
    Matrix Operations
  pfMakeRotQuat()
    Quaternion Operations
  pfMakeScaleMat()
    Matrix Operations
  pfMakeTransMat()
    Matrix Operations
  pfMalloc()
    pfDelete() and Reference Counting
    Shared Memory and pfInit()
    Attributes
    Memory Allocation
    Allocating Memory With pfMalloc()
    Allocating Memory With pfMalloc()
    Allocating Memory With pfMalloc()
    Shared Arenas
    Datapools
    `libpr` Databases
  pfMergeBuffer()
    pfBuffer
    pfBuffer
    Glossary
  pfMeshAddFace()
    Meshes
  pfMeshAddGeoSet()
    Meshes
    Meshes
    Meshes
    Meshes
  pfMeshAddTriangle()
    Meshes
  pfMeshFaceNumVerts()
    Mesh Faces
  pfMeshFaceTexCoord()
    Mesh Faces
  pfMeshFaceVertex()
    Mesh Faces
  pfMeshGridBsphere()
    Meshes
  pfMeshNumFaces()
    Meshes
  pfMeshNumVertices()
    Meshes
  pfMeshSplitVertices()
    Meshes
    Vertex Neighbors
  pfMeshUpdateMesh()
    Meshes
    Mesh Faces
  pfMeshVertexCoord()
    Vertex Coordinates
    Vertex Coordinates
  pfMeshVertexCoordPtr()
    Vertex Coordinates
    Vertex Coordinates
  pfMeshVertexNeighbor()
    Vertex Neighbors
  pfMeshVertexNumNeighbors()
    Vertex Neighbors
  pfModelMat()
    Sprite Transformations
  pfMoveChan()
    One Window per Pipe, Multiple Channels per Window
    Multiple Channels and Multiple Windows
    Multiple Channels and Multiple Windows
    Multiple Channels and Multiple Windows
  pfMovePWin()
    pfPipeWindows in Action
  pfMPKImportConfig()
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
  pfMPKImportFile()
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
  pfMPKPostConfig()
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
  pfMPKPostDMConfig()
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
  pfMPKPreConfig()
    Importing OpenGL Multipipe SDK (MPK) Configuration Files
  pfMQueryFStats()
    Statistics Tokens
    Querying
  pfMQueryGSet()
    Intersecting with pfGeoArrays
  pfMQueryHit()
    Intersection Return Data: pfHit Objects
    Intersection Return Data: pfHit Objects
    Intersecting with pfGeoSets
  pfMQueryStats()
    Statistics Tokens
    Querying
    Querying
  pfMtlColorMode()
    Materials
    Draw Stage and Graphics Pipeline Optimizations
    Transform Bottlenecks
    Other Tips
  pfMultipipe()
    Multiple Rendering Pipelines
    Multiple Rendering Pipelines
    Order of Calls
    Establishing the Number of Graphic Pipes
    Establishing the Number of Graphic Pipes
  pfMultiprocess()
    Creating and Configuring a pfPipe
    Choosing a Multiprocessing Model
    Choosing a Multiprocessing Model
    Intersection Pipeline
    Order of Calls
    Order of Calls
    DBASE Process
    Creating and Deleting a pfFlux
    Status Line
    Application Optimizations
    Use the Simplest Process Model
    Overview
    Initializing Shared Memory
  pfMultithread()
    Multithreading
    CULL Sidekick Processes
    Order of Calls
    Configuring CULL_SIDEKICK Processes
  pfMultithreadParami()
    CULL Sidekick Optimization Mask
    CULL Sidekick Synchronization Policy
    CULL Sidekick User Functions
  pfMultMat()
    Matrix Operations
  pfMultMatrix()
    Rules for Invoking Functions While Multiprocessing
    Graphics Library Matrix Routines
  pfMultQuat()
    Quaternion Operations
  pfNegateVec3()
    Vector Operations
    Vector Operations
  pfNewBboard()
    pfBillboard Nodes
  pfNewBuffer()
    pfBuffer
    Glossary
  pfNewCBuffer()
    CycleBuffers
  pfNewChan()
    Creating and Configuring a pfChannel
  pfNewClipTexture()
    Configuring an Image Cache Level
  pfNewCtab()
    Color Tables
  pfNewDCS()
    pfDCS Nodes
  pfNewDList()
    Display Lists
  pfNewDPool()
    Datapools
  pfNewESky()
    Atmospheric Effects
  pfNewFlux()
    Creating and Deleting a pfFlux
  pfNewFog()
    Fog
  pfNewFont()
    pfFont
  pfNewFrust()
    Frusta
  pfNewGArray()
    pfGeoArray (Geometry Array)
  pfNewGeode()
    pfGeode Nodes
    pfText Nodes
  pfNewGSet()
    pfGeoSet (Geometry Set)
  pfNewGState()
    pfGeoSets and pfGeoStates
  pfNewHlight()
    Highlights
  pfNewImageTile()
    Configuring an Image Cache Proto Tile
    Configuring the Default Tile
    Configuring Image Tiles
  pfNewLayer()
    pfLayer Nodes
  pfNewLight()
    Lighting
    Lighting
  pfNewLModel()
    Lighting
  pfNewLOD()
    pfLOD Nodes
  pfNewMaterial()
    Materials
  pfNewMStack()
    Matrix Stack Operations
  pfNewMtl()
    Materials
  pfNewPart()
    pfPartition Nodes
  pfNewPath()
    Paths through the Scene Graph
  pfNewPWin()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfNewScene()
    pfScene Nodes
  pfNewSCS()
    pfSCS Nodes
  pfNewSeq()
    pfSequence Nodes
  pfNewState()
    State Management
    pfWindows and GL Windows
  pfNewString()
    pfString
  pfNewSwitch()
    pfSwitch Nodes
  pfNewTex()
    Texture
  pfNewVolFog()
    Initializing a pfVolFog
  pfNewWin()
    Creating a pfWindow
  pfNextNeighborIndexMeshVertex()
    Vertex Neighbors
  pfNextNeighborMeshVertex()
    Vertex Neighbors
  pfNodeBSphere()
    Bounding Volumes
  pfNodeIsectSegs()
    Intersection Pipeline
    Testing Line Segment Intersections
    Intersection Requests: pfSegSets
    Intersection Masks
    Picking
    Intersecting with pfGeoSets
    Efficient Intersection and Traversals
  pfNodeTravData()
    Subclassing pfObjects
  pfNodeTravFuncs()
    pfNode Cull and Draw Callbacks
    Subclassing pfObjects
    Defining Virtual Functions
    Multiprocessing and libpf Objects
  pfNodeTravMask()
    pfNode Draw Mask
    Setting the Intersection Mask
    Enabling Caching
    Efficient Intersection and Traversals
  pfNormalizeVec3()
    Vector Operations
  pfNotify()
    Allocating Memory With pfMalloc()
    Error Handling and Notification
  pfNotifyHandler()
    Allocating Memory With pfMalloc()
    Error Handling and Notification
    Error Handling and Notification
  pfNotifyLevel()
    Error Handling and Notification
    Process Pipeline Tuning Tips
    Avoid Floating-Point Exceptions
  pfOpenDList()
    Display Lists
  pfOpenFile()
    Asynchronous I/O (IRIX only)
    Asynchronous I/O (IRIX only)
  pfOpenPWin()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    pfPipeWindows in Action
  pfOpenScreen()
    Creating a pfWindow
    Communicating with the Window System
  pfOpenStats()
    Statistics Buffers
  pfOpenWin()
    Creating a pfWindow
    Configuring the Framebuffer of a pfWindow
    pfWindows and GL Windows
    pfWindows and GL Windows
    Manipulating a pfWindow
    Manipulating a pfWindow
    Manipulating a pfWindow
    Alternate Framebuffer Configuration Windows
  pfOpenWSConnection()
    Communicating with the Window System
  pfOrthoXformCyl()
    Transforming Bounding Volumes
  pfOrthoXformFrust()
    Transforming Bounding Volumes
  pfOrthoXformPlane()
    Transforming Bounding Volumes
  pfOrthoXformSphere()
    Transforming Bounding Volumes
  pfOverride()
    Rendering Modes
    Rendering Attributes
    State Override
    Fill Bottlenecks
  pfPartAttr()
    pfPartition Nodes
    pfPartition Nodes
  pfPassChanData()
    Process Callbacks and Passthrough Data
    Passthrough Data
    Application Optimizations
    Process Pipeline Tuning Tips
  pfPassIsectData()
    Passthrough Data
  pfPhase()
    Fixing the Frame Rate
    Frame Synchronization
  pfPipeScreen()
    Creating and Configuring a pfPipe
    Using Nondefault Hyperpipe Mappings to Graphics Pipes
  pfPipeWSConnectionName()
    Using Nondefault Hyperpipe Mappings to Graphics Pipes
  pfPlaneIsectSeg()
    Intersecting with Planes and Triangles
  pfPopMatrix()
    pfNode Cull and Draw Callbacks
    Graphics Library Matrix Routines
  pfPopMStack()
    Matrix Stack Operations
  pfPopState()
    Pushing and Popping State
  pfPositionSprite()
    Sprite Transformations
  pfPostMultMat()
    Matrix Operations
  pfPostMultMStack()
    Matrix Stack Operations
    Matrix Stack Operations
  pfPostRotMat()
    Matrix Operations
  pfPostRotMStack()
    Matrix Stack Operations
  pfPostScaleMat()
    Matrix Operations
  pfPostScaleMStack()
    Matrix Stack Operations
    Matrix Stack Operations
  pfPostTransMat()
    Matrix Operations
  pfPostTransMStack()
    Matrix Stack Operations
  pfPreMultMat()
    Matrix Operations
  pfPreMultMStack()
    Matrix Stack Operations
    Matrix Stack Operations
  pfPreRotMat()
    Matrix Operations
  pfPreRotMStack()
    Matrix Stack Operations
  pfPreScaleMat()
    Matrix Operations
  pfPreTransMat()
    Matrix Operations
  pfPreviousNeighborIndexMeshVertex(
    Vertex Neighbors
  pfPreviousNeighborMeshVertex()
    Vertex Neighbors
  pfPrint()
    pfGeoSet (Geometry Set)
    pfGeoSet Operations
    Printing
  pfProcessHighestPriority
    Placing Multiple OpenGL Performer Processes on a Single CPU
  pfProcessPriorityUpgrade()
    Placing Multiple OpenGL Performer Processes on a Single CPU
  pfPushIdentMatrix()
    Graphics Library Matrix Routines
  pfPushMatrix()
    pfNode Cull and Draw Callbacks
    Graphics Library Matrix Routines
  pfPushMStack()
    Matrix Stack Operations
  pfPushState()
    Rules for Invoking Functions While Multiprocessing
    Pushing and Popping State
    Pushing and Popping State
  pfPWinAddPVChan()
    Configuring pfPipeWindows and pfChannels
  pfPWinConfigFunc()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinFBConfig()
    Configuring pfPipeWindows and pfChannels
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinFBConfigAttrs()
    Configuring pfPipeWindows and pfChannels
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinFBConfigData()
    Configuring pfPipeWindows and pfChannels
  pfPWinFBConfigId()
    Configuring pfPipeWindows and pfChannels
  pfPWinFullScreen()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinGLCxt()
    Configuring pfPipeWindows and pfChannels
    Creating, Configuring and Opening pfPipeWindow
  pfPWinIndex()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinList()
    Configuring pfPipeWindows and pfChannels
  pfPWinMode()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinOriginSize()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinOverlayWin()
    Configuring pfPipeWindows and pfChannels
  pfPWinPVChan()
    Configuring pfPipeWindows and pfChannels
  pfPWinRemovePVChan()
    Configuring pfPipeWindows and pfChannels
  pfPWinRemovePVChanIndex()
    Configuring pfPipeWindows and pfChannels
  pfPWinScreen()
    Configuring pfPipeWindows and pfChannels
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfPWinShare()
    Creating, Configuring and Opening pfPipeWindow
  pfPWinStatsWin()
    Configuring pfPipeWindows and pfChannels
  pfPWinSwapBarrier()
    Configuring pfPipeWindows and pfChannels
  pfPWinType()
    Creating, Configuring and Opening pfPipeWindow
  pfPWinWSConnectionName()
    Configuring pfPipeWindows and pfChannels
  pfPWinWSDrawable()
    Configuring pfPipeWindows and pfChannels
    Creating, Configuring and Opening pfPipeWindow
  pfPWinWSWindow(
    Configuring pfPipeWindows and pfChannels
  pfPWinWSWindow()
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  pfQuatMeanTangent()
    Quaternion Operations
  pfQueryFeature()
    Draw Stage and Graphics Pipeline Optimizations
  pfQueryFStats()
    Statistics Tokens
    Querying
  pfQueryGSet()
    pfGeoSet (Geometry Set)
    Intersecting with pfGeoArrays
  pfQueryHit()
    Intersection Return Data: pfHit Objects
    Intersection Return Data: pfHit Objects
    Intersecting with pfGeoSets
    Discriminator Callbacks
  pfQueryStats()
    Statistics Tokens
    Querying
    Querying
  pfQuerySys()
    Configuring the Framebuffer of a pfWindow
  pfQueryWin()
    Configuring the Framebuffer of a pfWindow
    pfWindows and GL Windows
    pfWindows and GL Windows
  pfQuickCopyGSet()
    Modifying Attributes of Cloned pfGeoSets
  pfQuickResetGSet()
    Modifying Attributes of Cloned pfGeoSets
  pfReadFile()
    Asynchronous I/O (IRIX only)
    Asynchronous I/O (IRIX only)
  pfRef()
    pfDelete() and Reference Counting
  pfReleaseDPool()
    Datapools
    Datapools
  pfRemoveChan()
    Multiple Channels and Multiple Windows
  pfRemoveChild()
    pfGroup
    pfGroup
    pfBuffer
  pfRemoveGSet()
    pfGeode Nodes
    pfText Nodes
  pfReplaceGSet()
    pfDelete() and Reference Counting
    pfDelete() and Reference Counting
    pfGeode Nodes
    pfText Nodes
  pfResetDList()
    Display Lists
  pfResetEvents()
    Controlling the Collection of OpenGL Performer Internal Events
  pfResetMStack()
    Matrix Stack Operations
  pfResetStats()
    Statistics Tokens
  pfRotate()
    Graphics Library Matrix Routines
  pfSaveMultiTexFile()
    Texture Formats
  pfScale()
    Graphics Library Matrix Routines
  pfScaleVec3()
    Vector Operations
  pfSceneGState()
    pfScene Default Rendering State
    Draw Stage and Graphics Pipeline Optimizations
  pfSeekFile()
    Asynchronous I/O (IRIX only)
  pfSegIsectPlane()
    Intersecting with Planes and Triangles
  pfSegIsectTri()
    Intersecting with Planes and Triangles
  pfSelectBuffer()
    pfBuffer
    Glossary
  pfSelectPWin()
    Configuring pfPipeWindows and pfChannels
  pfSelectState()
    State Management
  pfSelectWin()
    Creating a pfWindow
  pfSelectWSConnection()
    Communicating with the Window System
  pfSeqDuration()
    pfSequence Nodes
  pfSeqInterval()
    pfSequence Nodes
  pfSeqMode()
    pfSequence Nodes
  pfSeqTime()
    pfSequence Nodes
  pfSetMatCol()
    Matrix Operations
  pfSetMatColVec3()
    Matrix Operations
  pfSetMatRow()
    Matrix Operations
  pfSetMatRowVec3()
    Matrix Operations
  pfSetVec3()
    Vector Operations
  pfShadeModel()
    Shading Model
  pfShaderChanged()
    Setting Up Shaded pfGeoSets
  pfShaderTexApplyFunc()
    Textures and Texture Coordinates
    Textures and Texture Coordinates
    OpenGL Shader and OpenGL Performer
  pfShaderTexComputeFunc()
    Textures and Texture Coordinates
    OpenGL Shader and OpenGL Performer
  pfShaderTexCoordFunc()
    Textures and Texture Coordinates
    Textures and Texture Coordinates
    OpenGL Shader and OpenGL Performer
  pfShadow routines
    Creating a pfShadow
  pfSharedArenaSize()
    Memory Allocation
    Shared Arenas
    Shared Arenas
  pfSharedMalloc()
    `evpp`—Event Pre-Processor
  pfSlerpQuat()
    Quaternion Operations
  pfSphereAroundBoxes()
    Creating Bounding Volumes
  pfSphereAroundPts()
    Creating Bounding Volumes
  pfSphereAroundSpheres()
    Creating Bounding Volumes
  pfSphereContainsCyl()
    Volume-Volume Intersection Tests
  pfSphereContainsPt()
    Point-Volume Intersection Tests
  pfSphereContainsSphere()
    Volume-Volume Intersection Tests
  pfSphereExtendByPt()
    Creating Bounding Volumes
  pfSphereExtendBySphere()
    Creating Bounding Volumes
  pfSphereIsectSeg()
    Intersecting with Volumes
  pfSpriteAxis()
    Sprite Transformations
  pfSpriteMode()
    Sprite Transformations
    Sprite Transformations
  pfSqrDistancePt3()
    Vector Operations
  pfSquadQuat()
    Quaternion Operations
  pfStageConfigFunc()
    Creating and Configuring a pfPipe
  pfStatsClass()
    Fill Statistics
    Statistics Buffers
  pfStatsClassMode()
    Statistics Tokens
    Statistics Buffers
    Enabling Only Statistics of Interest
  pfStatsCountGSet()
    Statistics Buffers
  pfStatsHwAttr()
    Fill Statistics
    Fill Statistics
    Statistics Buffers
  pfStringColor()
    pfString
  pfStringFont()
    pfString
  pfStringMat()
    pfString
  pfStringMode()
    pfString
  pfSubdivSurface()
    Creating a Subdivision Surface
  pfSubdivSurfaceFlags()
    Creating a Subdivision Surface
  pfSubdivSurfaceMesh()
    Creating a Subdivision Surface
  pfSubdivSurfaceUpdateControlMesh()
    Dynamic Modification of Vertices
  pfSubdivSurfaceVal()
    Creating a Subdivision Surface
  pfSubloadMultiTex()
    Texture Formats
  pfSubloadTex()
    Texture Management
    Texture Management
  pfSubloadTexLevel()
    Texture Management
  pfSubloadTexMultiLevel()
    Texture Formats
  pfSubMat()
    Matrix Operations
  pfSubVec3()
    Vector Operations
  pfSwapWinBuffers()
    Programming with Hyperpipes
  pfSwitchVal()
    pfSwitch Nodes
  pfSync()
    Application Traversal
    Fixing the Frame Rate
    Stage Timing Graph
    Stage Timing Graph
    Stage Timing Graph
    Stage Timing Graph
    Application Optimizations
    pfSync() Events
    Extending a pfvViewer—Module Entry Points
  pfTEnvBlendColor()
    Setting the Texture Environment with pfTexEnv
  pfTevMode()
    Draw Stage and Graphics Pipeline Optimizations
  pfTexAnisotropy()
    Texture Management
  pfTexDetail()
    pfDelete() and Reference Counting
    Texture Management
  pfTexFilter()
    Texture Management
    Draw Stage and Graphics Pipeline Optimizations
  pfTexFormat()
    Texture Management
    Texture Management
    Texture Formats
    Configuring an Image Cache Level
    Configuring a pfTexture
    Texturing
  pfTexFrame()
    Texture Management
  pfTexImage()
    pfDelete() and Reference Counting
    Texture Formats
    Texture
    Texture
    Configuring an Image Cache Level
    Configuring a pfTexture
  pfTexLevel()
    Texture Management
  pfTexList()
    Texture Management
  pfTexLoadImage()
    Texture Management
  pfTexLoadMode()
    Texture
    Texture Management
    Texture Management
  pfTexLoadOrigin()
    Texture
  pfTexLoadSize()
    Texture Management
  pfTexMultiImage()
    Texture Formats
  pfTexMultiName()
    Texture Formats
  pfTexName()
    Configuring an Image Cache Level
  pfTexSpline()
    Texture Management
  pfTGenMode()
    Automatic Texture Coordinate Generation
  pfTGenPlane()
    Automatic Texture Coordinate Generation
  pfTranslate()
    Graphics Library Matrix Routines
  pfTransparency()
    Rules for Invoking Functions While Multiprocessing
    Immediate Mode
    Transparency
    Local and Global State
    Draw Stage and Graphics Pipeline Optimizations
    Fill Bottlenecks
  pfTransposeMat()
    Matrix Operations
  pfTriIsectSeg()
    Intersecting with Planes and Triangles
  pfuAddMPClipTexturesToPipes
    Post-Load-Time Configuration
  pfuCollideSetup()
    Cull and Intersection Optimizations
  pfuDownloadTexList()
    Programming with Hyperpipes
    Draw Process Tips
  pfuFreeClipTexConfig()
    Cliptexture Configuration
  pfuFreeImgCacheConfig()
    Image Cache Configuration
  pfuInitClipTexConfig()
    Cliptexture Configuration
  pfuInitImgCacheConfig()
    Image Cache Configuration
  pfuLockDownApp()
    Process Pipeline Tuning Tips
  pfuLockDownCull()
    Process Pipeline Tuning Tips
  pfuLockDownDraw()
    Process Pipeline Tuning Tips
  pfuLockDownProc()
    Process Pipeline Tuning Tips
  pfuMakeClipTexture()
    Cliptexture Configuration
  pfuMakeImageCache()
    Image Cache Configuration
  pfUnbindPWinPVChans()
    Configuring pfPipeWindows and pfChannels
  pfUnhideGSetStripPrim()
    Primitive Type Descriptions
  pfUnref()
    pfDelete() and Reference Counting
  pfUnrefDelete()
    pfDelete() and Reference Counting
  pfUpdatePart()
    pfPartition Nodes
    pfPartition Nodes
  pfuPrioritizeProcs()
    Process Pipeline Tuning Tips
  pfUserData()
    Subclassing pfObjects
  pfVClockSync()
    Video Refresh Counter (VClock)
  pfViewMat()
    Sprite Transformations
  pfVolFogAddChannel()
    Initializing a pfVolFog
    Initializing a pfVolFog
    Updating the View
  pfVolFogAddColoredPoint()
    Creating Layered Fog
    Initializing a pfVolFog
    Layered Fog
  pfVolFogAddNode()
    Animating Patchy Fog
    Creating Patchy Fog
    Initializing a pfVolFog
  pfVolFogAddPoint()
    Creating Layered Fog
    Initializing a pfVolFog
    Layered Fog
  pfVolFogSetAttr()
    Initializing a pfVolFog
    Layered Fog
    Patchy Fog
  pfVolFogSetColor()
    Initializing a pfVolFog
    Layered Fog
  pfVolFogSetDensity()
    Initializing a pfVolFog
  pfVolFogSetFlags()
    Initializing a pfVolFog
    Layered Fog
  pfVolFogSetVal()
    Layered Patchy Fog
    Initializing a pfVolFog
    Layered Fog
    Patchy Fog
  pfVolFogUpdateView()
    Initializing a pfVolFog
    Updating the View
  pfWinFBconfig()
    Configuring the Framebuffer of a pfWindow
    pfWindows and GL Windows
    pfWindows and GL Windows
  pfWinFBConfigAttrs()
    Configuring the Framebuffer of a pfWindow
  pfWinFullScreen()
    Creating a pfWindow
    Creating, Configuring and Opening pfPipeWindow
  pfWinGLCxt()
    pfWindows and GL Windows
    pfWindows and GL Windows
    pfWindows and GL Windows
  pfWinIndex()
    Manipulating a pfWindow
    Manipulating a pfWindow
    Alternate Framebuffer Configuration Windows
  pfWinMode()
    Manipulating a pfWindow
  pfWinOriginSize()
    Creating a pfWindow
  pfWinOverlayWin()
    Alternate Framebuffer Configuration Windows
  pfWinScreen()
    Creating a pfWindow
  pfWinShare()
    Alternate Framebuffer Configuration Windows
  pfWinStatsWin()
    Alternate Framebuffer Configuration Windows
  pfWinType()
    Creating a pfWindow
  pfWinWSDrawable()
    pfWindows and GL Windows
    pfWindows and GL Windows
    pfWindows and GL Windows
  pfWinWSWindow()
    pfWindows and GL Windows
    pfWindows and GL Windows
    Manipulating a pfWindow
    Alternate Framebuffer Configuration Windows
  pfWriteEvents()
    Controlling the Collection of OpenGL Performer Internal Events
  pfWriteFile()
    Asynchronous I/O (IRIX only)
    Asynchronous I/O (IRIX only)
  pfXformBox()
    Transforming Bounding Volumes
  pfXformPt3()
    Vector Operations
  pfXformVec3()
    Vector Operations
  postConfig()
    Extending a pfvViewer—Module Entry Points
  postCull()
    Extending a pfvViewer—Module Entry Points
  postDraw()
    Extending a pfvViewer—Module Entry Points
  preConfig()
    Extending a pfvViewer—Module Entry Points
  preCull()
    Extending a pfvViewer—Module Entry Points
  preDraw()
    Extending a pfvViewer—Module Entry Points
  sync()
    Extending a pfvViewer—Module Entry Points

RPC database format
  ArchVision RPC Format

ruled surfaces
  Ruled Surfaces

s_streams
  num_streams, s_streams, t_streams, and r_streams

sample applications
  repTest
    Geometric Primitives: The Base Class pfRep and the Application repTest
    Parametric Surfaces
    pfSphereSurface Example
    Sample of a Trimmed pfNurbSurface From repTest
  topoTest
    Summary of Topology Building Strategies

sample code
  More Sample Programs, Configuration Files, and Source Code
  repTest
    Sample of a Trimmed pfNurbSurface From repTest

sample code. See example code
  One Window per Pipe, Multiple Channels per Window

sampling, program counter
  Using `pixie`, `prof`, and `gprof` to Measure Performance

Scalable Graphics Compositor
  Using Scalable Graphics Hardware
  Using OpenGL Performer with an SGI Scalable Graphics Compositor

scalar functions
  Classes for Scalar Functions
  see functions
    Classes for Scalar Functions

scalars
  defining
    Classes for Scalar Functions

scan rate
  Fixing the Frame Rate

scene complexity, definition
  Glossary

scene graph
  defined
    Glossary
  state inheritance
    State Inheritance

scene graph topology tools
  Summary of Scene Graph Topology: pfTopo

scene graphs
  Scene Graph Hierarchy

scene, definition
  Glossary

screen-door transparency
  Transparency

SCS. See pfSCS nodes
  pfSCS Nodes
  pfDoubleSCS Nodes

search paths
  File Search Paths
  definition
    Glossary

See formats.
  Importing Databases

segments
  Creating and Working with Line Segments
  See also pfSegSet
    Creating and Working with Line Segments

self-shadowing
  Simulating Self-Shadowing in Patchy Fog

semaphores, allocating
  Allocating Locks and Semaphores

sense, definition of
  Glossary

setmon()
  Video Refresh Counter (VClock)

setrlimit()
  Shared Arenas
  Shared Arenas

setSyncGroup
  Adding a Q uery Array

SGF database format
  USNA Standard Graphics Format

SGO format. See formats
  SGI SGO Format

Shader
  flow through Performer
    OpenGL Shader and OpenGL Performer
  man pages
    Shaders

shaders
  Shaders

shading
  flat
    Shading Model
  Gouraud
    Shading Model

shadow
  Casting a Shadow

shadow map
  defined
    Glossary

shadows
  Real-Time Shadows

share groups
  Master/Slave Share Masks
  Glossary

share mask
  S hare Masks
  Master/Slave Share Masks
  Glossary

shared arena, memory mapping
  Shared Arenas

shared instancing
  Shared Instancing
  defined
    Glossary

shared memory
  allocation
    Creating and Deleting OpenGL Performer Objects
  arenas
    Allocating Memory With pfMalloc()
  datapools
    Datapools
  debugging and
    Shared Memory

sharing channel attributes
  Using Channel Groups

sharpen texture
  Graphics and Modeling Techniques to Improve Performances

shininess, definition
  Glossary

siblings, of a node, defined
  Glossary

Sierpinski sponge
  Sierpinski Sponge Loader

Silicon Graphics Object format. See formats
  SGI SGO Format

Simplify application
  The Simplify Application

simulation-based design
  Why Use OpenGL Performer?

single inheritance
  Inheritance Graph

single-precision arithmetic
  Special Coding Tips

slave cliptexture
  Making Masters and Slaves

slew table
  Slew Values

smallest_icache
  smallest_icache

Software Systems
  MultiGen OpenFlight Format

solids
  Collecting Connected Surfaces: pfSolid
  forming with surface patches
    Collecting Connected Surfaces: pfSolid

Soma cube puzzle
  Designer's Workbench DWB Format

sorting
  pfQueue Modes
  defined
    Glossary

sorting for transparency
  Transparency

source code
  database loaders
    Creating an OpenGL Performer Database Converter using `libpfdu`
    Initialization and Type Definition
  database loading
    Database Loading Details
  database processing tools
    Overview of OpenGL Performer Database Creation and Conversion
  fill statistics
    Fill Statistics
  libpfutil
    Process Pipeline Tuning Tips
    Draw Process Tips
  MIPmap
    Texture
  Perfly
    Glossary
  pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
    pfPipeWindows in Action
  pfTexture
    Texture
  See also example code
    Texture
  statistics
    Displaying Statistics Simply
    Setting Statistics Class Enables and Modes
  X input
    Draw Process Tips

spacing
  character
    pfFont
  definition
    Glossary

spatial curves
  Spatial Curves

spatial decomposition
  Hyperpipe Concepts

spatial organization
  Organizing a Database for Efficient Culling
  definition
    Glossary

specifying surface cross sections
  Planar Curves

SPF format. See formats
  USNA Simple Polygon File Format

spheres
  pfSphereSurface
  as bounding volumes
    Spheres

splines
  Hermite-Spline Curves in the Plane
  Hermite spline
    Hermite-Spline Surfaces

SPONGE format. See formats
  Sierpinski Sponge Loader

sprite
  Sprite Transformations
  defined
    Glossary

sproc()
  Multiprocessing and Memory
  Asynchronous I/O (IRIX only)
  Efficient Intersection and Traversals
  More on Shared Memory and the Type System

stage timing graph
  Interpreting Statistics Displays
  Stage Timing Graph
  See also statistics
    Interpreting Statistics Displays

stage, definition
  Glossary

stages of rendering
  Review of Rendering Stages

STAR format. See formats
  Star Chart Format

state
  changes
    Draw Stage and Graphics Pipeline Optimizations
  defined
    Glossary
  inheritance
    State Inheritance
  local and global
    Local and Global State

state elements
  Immediate Mode

state specification
  global
    Local and Global State
  local
    Local and Global State

static coordinate systems. See pfSCS nodes
  pfSCS Nodes
  pfDoubleSCS Nodes

static data in C++ classes
  Static Member Data

statistics
  Statistics
  average
    The pfStats Data Structure
  CPU
    CPU Statistics
  cumulative
    The pfStats Data Structure
  current
    The pfStats Data Structure
  data structures
    Statistics
    The pfStats Data Structure
  displaying
    Statistics
    Interpreting Statistics Displays
    Displaying Statistics Simply
  enabling
    Statistics Rules of Use
  fill
    Fill Statistics
  graphics
    Rendering Statistics
  previous
    The pfStats Data Structure
  stage timing
    defaults
      Enabling and Disabling Statistics for a Channel
    graph
      Stage Timing Graph
  use in applications
    Collecting and Accessing Statistics in Your Application

stencil decaling
  Decals
  defined
    Glossary

stereo display
  One Window per Pipe, Multiple Channels per Window

stitching surfaces
  Creating and Maintaining Surface Topology

STL format. See formats
  3D Lithography STL Format

stream
  num_streams, s_streams, t_streams, and r_streams

stress filter
  Customizing DVR

stress filter for DVR
  Understanding the Stre ss Filter

stress management
  Dynamic Load Management

stress management. See load management
  Load and Stress

stress, definition
  Glossary

structures
  libpfdu
    pfdBuilder
      SGI GFO Format

sub-bin
  Sorting the Scene

subclassing
  Subclassing pfObjects

subdivision surfaces
  Subdivision Surfaces

subgraph, definition
  Glossary

superquadric curves
  in space
    Superquadrics in Space
  in the plane
    Superquadric Curves: pfSuperQuadCurve2d

supersampled data
  Supersampled Data

SuperViewer
  SuperViewer SV Format

surface contact information
  Creating and Maintaining Surface Topology

surface edges
  Adjacency Information: pfEdge

surfaces
  adding
    Building Topology Incrementally: A Single-Traversal Build
  adjacency information
    Adjacency Information: pfEdge
  Coons patch
    Coons Patches
  defining edges
    Defining Edges of a Parametric Surface: Trim Loops and Curves
  Hermite spline
    Hermite-Spline Surfaces
  NURBS
    Trimmed NURBS
  NURBS curve
    NURBS Surfaces
  parametric
    Parametric Surfaces
  ruled surface
    Ruled Surfaces
  specifying cross sections
    Planar Curves
  swept surfaces
    Swept Surfaces

SV format. See formats
  SuperViewer SV Format

swept surfaces
  Swept Surfaces
  Frenet frame
    pfFrenetSweptSurface
  specifying cross sections
    Planar Curves

switch nodes
  pfSwitch Nodes

sync()
  Extending a pfvViewer—Module Entry Points

synchronization of frames
  Frame Synchronization

t_streams
  num_streams, s_streams, t_streams, and r_streams

tearing
  Decals

temporal decomposition
  Hyperpipe Concepts

tessalation
  illustration
    Tessellators for Varying Levels of Detail

tessellation
  adjacent surfaces
    Creating and Maintaining Surface Topology
  consistent
    Summary of Scene Graph Topology: pfTopo
  controlling cracks
    Tessellators and Topology: Managing Cracks
  deleting data
    Reading and Writing Topology Information: Using Pseudo Loaders
  parametric surfaces
    Tessellating Parametric Surfaces

tessellator
  definition
    Rendering Higher-Order Primitives: Tessellators

testing
  intersections. See intersections
    Creating and Working with Line Segments
  visibility
    Visibility Testing

tex region
  Cliptexture Levels

tex_region_size
  icache_size, mem_region_size, and tex_region_size

texel coordinates
  Overview

texel data
  Texel Data
  Formatting Im age Data

texel format
  `libpr` Functionality

texel tile
  Tiling an Im age

texel, definition
  Glossary

texload time
  Total Texload Time and Texload Time Fraction

text
  pfText Nodes

texture
  coordinate generation
    Automatic Texture Coordinate Generation
  coordinates
    Attribute Data Array
  detail
    Graphics and Modeling Techniques to Improve Performances
  loading
    Controlling Texture LOD with pfTexLOD
  magnification
    Graphics and Modeling Techniques to Improve Performances
  mapping, defined
    Glossary
  memory
    Image Cache
  minification
    Graphics and Modeling Techniques to Improve Performances
  paging
    Texture Management
  sharpen
    Graphics and Modeling Techniques to Improve Performances
  tiling
    Tiling an Im age

texturing
  overview
    Texture
  performance cost
    Transform Bottlenecks
    Multisampling
  RealityEngine graphics
    Texturing
  representing complex objects
    Graphics and Modeling Techniques to Improve Performances

tile size
  Tile Size

tile, algorithm
  Building a MIPmap

tile, default
  Configuring the Default Tile

tile, defined
  Glossary

tile, updates
  Doing Per-tile Updates

tile_base
  tile_base, tile_format and tile_params

tile_files
  tile_files

tile_format
  tile_format and tile_params
  tile_base, tile_format and tile_params

tile_params
  tile_format and tile_params
  tile_base, tile_format and tile_params

tile_size
  header_offset, tiles_in_file, and tile_size

tiles
  Cliptexture Levels

tiles_in_file
  header_offset, tiles_in_file, and tile_size

tiling an image
  Tiling an Im age

tiling, strategy
  Tiling Strategies

TIN
  Triangulated Irregular Networks

tokens
  APP_CULL_DRAW
    Using `pixie`, `prof`, and `gprof` to Measure Performance
  PF_MAX_ANISOTROPY
    Texture Management
  PF_MAX_LIGHTS
    Lighting
  PF_OFF
    Rendering Modes
    Rendering Modes
    Rendering Modes
  PFAA_OFF
    Rendering Modes
  PFAF_ALWAYS
    Rendering Modes
  PFAF_GREATER
    Alpha Function
  PFBOUND_FLUX
    Animating a Geometry
  PFBOUND_STATIC
    Bounding Volumes
  PFCF_BACK
    Frontface / Backface
  PFCF_BOTH
    Frontface / Backface
  PFCF_FRONT
    Frontface / Backface
  PFCF_OFF
    Rendering Modes
    Frontface / Backface
  PFCHAN_EARTHSKY
    Using Channel Groups
  PFCHAN_FOV
    Using Channel Groups
  PFCHAN_LOD
    Using Channel Groups
    Using Channel Groups
  PFCHAN_NEARFAR
    Using Channel Groups
  PFCHAN_SCENE
    Using Channel Groups
  PFCHAN_STRESS
    Using Channel Groups
  PFCHAN_SWAPBUFFERS
    Using Channel Groups
    Using Channel Groups
  PFCHAN_SWAPBUFFERS_HW
    Synchronization of Buffer Swap for Multiple Windows
    Multiple pfPipeWindows and Multiple pfPipes
  PFCHAN_VIEW
    Using Channel Groups
  PFCHAN_VIEW_OFFSETS
    Using Channel Groups
  PFCULL_GSET
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    pfChannel Traversal Modes
  PFCULL_IGNORE_LSOURCES
    pfChannel Traversal Modes
    pfChannel Traversal Modes
  PFCULL_PROGRAM
    pfChannel Traversal Modes
  PFCULL_SORT
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    Cull and Intersection Optimizations
  PFCULL_VIEW
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    pfChannel Traversal Modes
  PFDECAL_BASE_STENCIL
    Decals
    Decals
  PFDECAL_LAYER_STENCIL
    Decals
  PFDECAL_OFF
    Rendering Modes
    Decals
  PFDL_RING
    Display Lists
  PFDRAW_OFF
    pfChannel Traversal Modes
  PFDRAW_ON
    pfChannel Traversal Modes
  PFEN_COLORTABLE
    Enable / Disable
  PFEN_FOG
    Enable / Disable
  PFEN_FRAGPROG
    Enable / Disable
  PFEN_HIGHLIGHTING
    Enable / Disable
  PFEN_LIGHTING
    Enable / Disable
  PFEN_LPOINTSTATE
    Enable / Disable
  PFEN_TEXGEN
    Enable / Disable
  PFEN_TEXTURE
    Enable / Disable
  PFEN_VTXPROG
    Enable / Disable
  PFEN_WIREFRAME
    Enable / Disable
  PFENG_ALIGN
    Creating and Deleting Engines
  PFENG_ANIMATE
    Creating and Deleting Engines
  PFENG_ANIMATE_BASE_MATRIX
    Setting Engine Types and Modes
  PFENG_ANIMATE_ROT
    Setting Engine Types and Modes
  PFENG_ANIMATE_SCALE_UNIFORM
    Setting Engine Types and Modes
  PFENG_ANIMATE_SCALE_XYZ
    Setting Engine Types and Modes
  PFENG_ANIMATE_TRANS
    Setting Engine Types and Modes
  PFENG_BBOX
    Creating and Deleting Engines
  PFENG_BLEND
    Creating and Deleting Engines
  PFENG_MATRIX
    Creating and Deleting Engines
  PFENG_MORPH
    Creating and Deleting Engines
  PFENG_MORPH_FRAME
    PFENG_MORPH Engines
  PFENG_MORPH_SRC(n)
    PFENG_MORPH Engines
  PFENG_MORPH_WEIGHTS
    PFENG_MORPH Engines
  PFENG_RANGE_CHECK
    Evaluating pfEngines
  PFENG_STROBE
    Creating and Deleting Engines
  PFENG_TIME
    Creating and Deleting Engines
  PFENG_TRANSFORM
    Creating and Deleting Engines
  PFENG_USER_FUNCTION
    Creating and Deleting Engines
  PFES_BUFFER_CLEAR
    Using pfEarthSky
  PFES_FAST
    Atmospheric Effects
  PFES_GRND_FAR
    Using pfEarthSky
  PFES_GRND_HT
    Using pfEarthSky
  PFES_GRND_NEAR
    Using pfEarthSky
  PFES_SKY
    Atmospheric Effects
  PFES_SKY_CLEAR
    Atmospheric Effects
  PFES_SKY_GRND
    Using pfEarthSky
    Atmospheric Effects
  PFFB_ACCUM_ALPHA_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_ACCUM_BLUE_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_ACCUM_GREEN_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_ACCUM_RED_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_ALPHA_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_AUX_BUFFER
    Configuring the Framebuffer of a pfWindow
  PFFB_BLUE_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_BUFFER_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_DEPTH_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_DOUBLEBUFFER
    Configuring the Framebuffer of a pfWindow
  PFFB_GREEN_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_RED_SIZE
    Configuring the Framebuffer of a pfWindow
  PFFB_RGBA
    Configuring the Framebuffer of a pfWindow
  PFFB_STENCIL
    Configuring the Framebuffer of a pfWindow
  PFFB_STEREO
    Configuring the Framebuffer of a pfWindow
  PFFB_USE_GL
    Configuring the Framebuffer of a pfWindow
  PFFLUX_BASIC_MASK
    Triggering pfFlux Evaluation
  PFFLUX_DEFAULT_NUM_BUFFERS
    Creating and Deleting a pfFlux
  PFFLUX_ON_DEMAND
    Reading pfFlux Buffers
    Fluxed Coordinate Systems
  PFFOG_PIX_EXP
    Fog
  PFFOG_PIX_EXP2
    Fog
  PFFOG_PIX_LIN
    Fog
  PFFOG_PIX_SPLINE
    Fog
    Fog
  PFFOG_VTX_EXP
    Fog
  PFFOG_VTX_EXP2
    Fog
  PFFOG_VTX_LIN
    Fog
  PFFONT_BBOX
    pfFont
  PFFONT_CHAR_SPACING
    pfFont
  PFFONT_CHAR_SPACING_FIXED
    pfFont
  PFFONT_CHAR_SPACING_VARIABLE
    pfFont
  PFFONT_GSTATE
    pfFont
  PFFONT_NAME
    pfFont
  PFFONT_NUM_CHARS
    pfFont
  PFFONT_RETURN_CHAR
    pfFont
  PFFONT_SPACING
    pfFont
  PFGS_COLOR4
    Color Tables
  PFGS_COMPILE_GL
    pfGeoSet Draw Mode
    pfGeoSet Operations
  PFGS_COORD3
    Writing to pfFlux Buffers
  PFGS_FLAT_LINESTRIPS
    Primitive Types
    Attribute Bindings
  PFGS_FLAT_TRISTRIPS
    Primitive Types
    Attribute Bindings
  PFGS_FLATSHADE
    pfGeoSet Draw Mode
  PFGS_LINES
    Primitive Types
  PFGS_LINESTRIPS
    Primitive Types
  PFGS_OFF
    Attribute Bindings
  PFGS_OVERALL
    Attribute Bindings
  PFGS_PER_PRIM
    Attribute Bindings
  PFGS_PER_VERTEX
    Attribute Bindings
    Attribute Bindings
  PFGS_POINTS
    Primitive Types
  PFGS_POLYS
    Primitive Types
  PFGS_QUADS
    Primitive Types
    Intersecting with pfGeoSets
  PFGS_TRIS
    Primitive Types
    Intersecting with pfGeoSets
  PFGS_TRISTRIPS
    Primitive Types
    Intersecting with pfGeoSets
  PFGS_WIREFRAME
    pfGeoSet Draw Mode
  PFHL_BBOX_FILL
    Highlights
  PFHL_BBOX_LINES
    Highlights
  PFHL_FILL
    Highlights
  PFHL_FILL_R
    Highlights
  PFHL_FILLPAT
    Highlights
  PFHL_FILLPAT2
    Highlights
  PFHL_FILLTEX
    Highlights
  PFHL_LINES
    Highlights
  PFHL_LINES_R
    Highlights
  PFHL_LINESPAT
    Highlights
  PFHL_LINESPAT2
    Highlights
  PFHL_NORMALS
    Highlights
  PFHL_POINTS
    Highlights
  PFHL_SKIP_BASE
    Highlights
  PFIS_ALL_IN
    pfNode Cull and Draw Callbacks
    pfNode Cull and Draw Callbacks
    Volume-Volume Intersection Tests
    Intersecting with Volumes
  PFIS_FALSE
    pfNode Cull and Draw Callbacks
    Point-Volume Intersection Tests
    Volume-Volume Intersection Tests
    Intersecting with Planes and Triangles
  PFIS_MAYBE
    Volume-Volume Intersection Tests
    Volume-Volume Intersection Tests
    Volume-Volume Intersection Tests
    Volume-Volume Intersection Tests
    Intersecting with Volumes
    Intersecting with Volumes
  PFIS_PICK_MASK
    Picking
  PFIS_START_IN
    Intersecting with Volumes
  PFIS_TRUE
    Point-Volume Intersection Tests
    Volume-Volume Intersection Tests
    Volume-Volume Intersection Tests
    Intersecting with Volumes
    Intersecting with Volumes
    Intersecting with Planes and Triangles
  PFLUX_WRITE_ONCE
    Writing to pfFlux Buffers
  PFMP_APP_CULL_DRAW
    Choosing a Multiprocessing Model
    Multiple Rendering Pipelines
    Rules for Invoking Functions While Multiprocessing
    Multiprocessing and Memory
    Stage Timing Graph
  PFMP_APP_CULLDRAW
    Choosing a Multiprocessing Model
    Forcing Display List Generation
    Rules for Invoking Functions While Multiprocessing
  PFMP_APPCULL_DRAW
    Choosing a Multiprocessing Model
    Multiple Rendering Pipelines
  PFMP_APPCULLDRAW
    Choosing a Multiprocessing Model
    Forcing Display List Generation
    Multiple Rendering Pipelines
    Use the Simplest Process Model
  PFMP_CULL_DL_DRAW
    Choosing a Multiprocessing Model
    Forcing Display List Generation
    Draw Stage and Graphics Pipeline Optimizations
    Cull and Intersection Optimizations
  PFMP_CULLoDRAW
    Choosing a Multiprocessing Model
    Cull-Overlap-Draw Mode
    Cull-Overlap-Draw Mode
    Forcing Display List Generation
    Stage Timing Graph
  PFMP_FORK_COMPUTE
    Compute Process
  PFMP_FORK_CULL
    Choosing a Multiprocessing Model
    Choosing a Multiprocessing Model
  PFMP_FORK_DBASE
    DBASE Process
  PFMP_FORK_DRAW
    Choosing a Multiprocessing Model
    Choosing a Multiprocessing Model
    Choosing a Multiprocessing Model
    Cull-Overlap-Draw Mode
  PFMP_FORK_ISECT
    Intersection Pipeline
  PFMTL_CMODE_AD
    Transform Bottlenecks
  PFNFY_ALWAYS
    Error Handling and Notification
  PFNFY_DEBUG
    Shell Environment Variables
    Error Handling and Notification
    Avoid Floating-Point Exceptions
  PFNFY_FATAL
    Allocating Memory With pfMalloc()
    Error Handling and Notification
  PFNFY_FP_DEBUG
    Error Handling and Notification
    Error Handling and Notification
    Error Handling and Notification
  PFNFY_INFO
    Error Handling and Notification
  PFNFY_NOTICE
    Error Handling and Notification
  PFNFY_WARN
    Error Handling and Notification
  PFPB_LEVEL
    Configuring the Framebuffer of a pfWindow
  PFPHASE_FLOAT
    Frame Synchronization
  PFPHASE_FREE_RUN
    Frame Synchronization
    Creating, Configuring and Opening pfPipeWindow
  PFPHASE_LIMIT
    Frame Synchronization
  PFPHASE_LOCK
    Frame Synchronization
  PFPK_M_ALL
    Picking
  PFPK_M_NEAREST
    Picking
  PFPROC_APP
    Creating and Configuring a pfPipe
  PFPROC_CULL
    Creating and Configuring a pfPipe
  PFPROC_DBASE
    Creating and Configuring a pfPipe
  PFPROC_DRAW
    Creating and Configuring a pfPipe
  PFPROC_ISECT
    Creating and Configuring a pfPipe
  PFPVC_DVR_AUTO
    Maintaining Frame Rate Using D ynamic Vid eo Res olution
    DVR Scaling
    Use pfPipeVideoChannels to Control Frame Rate
  PFPVC_DVR_MANUAL
    DVR Scaling
    Use pfPipeVideoChannels to Control Frame Rate
  PFPWIN_TYPE_NONEVENTS
    Creating, Configuring and Opening pfPipeWindow
  PFPWIN_TYPE_NOPORT
    Creating a pfWindow
  PFPWIN_TYPE_OVERLAY
    Creating a pfWindow
  PFPWIN_TYPE_SHARE
    Creating, Configuring and Opening pfPipeWindow
    Multiple pfPipeWindows and Multiple pfPipes
  PFPWIN_TYPE_STATS
    Creating a pfWindow
    Creating, Configuring and Opening pfPipeWindow
  PFPWIN_TYPE_X
    Creating a pfWindow
    Creating, Configuring and Opening pfPipeWindow
  PFQHIT_FLAGS
    Intersection Return Data: pfHit Objects
    Intersection Return Data: pfHit Objects
  PFQHIT_GSET
    Intersection Return Data: pfHit Objects
  PFQHIT_NAME
    Intersection Return Data: pfHit Objects
  PFQHIT_NODE
    Intersection Return Data: pfHit Objects
  PFQHIT_NORM
    Intersection Return Data: pfHit Objects
  PFQHIT_PATH
    Intersection Return Data: pfHit Objects
  PFQHIT_POINT
    Intersection Return Data: pfHit Objects
  PFQHIT_PRIM
    Intersection Return Data: pfHit Objects
  PFQHIT_SEG
    Intersection Return Data: pfHit Objects
  PFQHIT_SEGNUM
    Intersection Return Data: pfHit Objects
  PFQHIT_TRI
    Intersection Return Data: pfHit Objects
  PFQHIT_VERTS
    Intersection Return Data: pfHit Objects
  PFQHIT_XFORM
    Intersection Return Data: pfHit Objects
  PFSM_FLAT
    Shading Model
  PFSM_GOURAUD
    Rendering Modes
    Shading Model
  PFSORT_BACK_TO_FRONT
    Sorting the Scene
  PFSORT_BY_STATE
    Sorting the Scene
  PFSORT_END
    Sorting the Scene
  PFSORT_FRONT_TO_BACK
    Sorting the Scene
  PFSORT_NO_ORDER
    Sorting the Scene
  PFSORT_QUICK
    Sorting the Scene
  PFSORT_STATE_BGN
    Sorting the Scene
  PFSORT_STATE_END
    Sorting the Scene
  PFSPRITE_AXIAL_ROT
    Sprite Transformations
  PFSPRITE_MATRIX_THRESHOLD
    Sprite Transformations
  PFSPRITE_POINT_ROT_EYE
    Sprite Transformations
  PFSPRITE_POINT_ROT_WORLD
    Sprite Transformations
  PFSPRITE_ROT
    Sprite Transformations
  PFSTATE_ALPHAFUNC
    Rendering Modes
  PFSTATE_ALPHAREF
    Rendering Values
  PFSTATE_ANTIALIAS
    Rendering Modes
  PFSTATE_BACKMTL
    Rendering Attributes
  PFSTATE_COLORTABLE
    Rendering Attributes
  PFSTATE_CULLFACE
    Rendering Modes
  PFSTATE_DECAL
    Rendering Modes
  PFSTATE_ENCOLORTABLE
    Rendering Modes
  PFSTATE_ENFOG
    Rendering Modes
  PFSTATE_ENFRAGPROG
    Rendering Modes
  PFSTATE_ENHIGHLIGHTING
    Rendering Modes
  PFSTATE_ENLIGHTING
    Rendering Modes
    Local and Global State
  PFSTATE_ENLPOINTSTATE
    Rendering Modes
  PFSTATE_ENTEXGEN
    Rendering Modes
  PFSTATE_ENTEXTURE
    Rendering Modes
    Local and Global State
  PFSTATE_ENVTXPROG
    Rendering Modes
  PFSTATE_ENWIREFRAME
    Rendering Modes
  PFSTATE_FOG
    Rendering Attributes
  PFSTATE_FRAGPROG
    Rendering Attributes
  PFSTATE_FRONTMTL
    Rendering Attributes
  PFSTATE_GPROGPARMS
    Rendering Attributes
  PFSTATE_HIGHLIGHT
    Rendering Attributes
  PFSTATE_LIGHTMODEL
    Rendering Attributes
  PFSTATE_LIGHTS
    Rendering Attributes
  PFSTATE_LPOINTSTATE
    Rendering Attributes
  PFSTATE_SHADEMODEL
    Rendering Modes
  PFSTATE_TEXENV
    Rendering Attributes
  PFSTATE_TEXGEN
    Rendering Attributes
  PFSTATE_TEXTURE
    Rendering Attributes
  PFSTATE_TRANSPARENCY
    Immediate Mode
    Rendering Modes
  PFSTATE_VTXPROG
    Rendering Attributes
  PFSTATS_ENGFX
    Rendering Statistics
    Rendering Statistics
  PFSTATS_ON
    Rendering Statistics
    Rendering Statistics
  PFSTR_CENTER
    pfString
  PFSTR_CHAR
    pfString
  PFSTR_CHAR_SIZE
    pfString
  PFSTR_FIRST
    pfString
  PFSTR_INT
    pfString
  PFSTR_JUSTIFY
    pfString
  PFSTR_LAST
    pfString
  PFSTR_LEFT
    pfString
  PFSTR_MIDDLE
    pfString
  PFSTR_RIGHT
    pfString
  PFSTR_SHORT
    pfString
  PFSWITCH_OFF
    pfSwitch Nodes
  PFSWITCH_ON
    pfSwitch Nodes
  PFTEX_BASE_APPLY
    Texture Management
  PFTEX_BASE_AUTO_REPLACE
    Texture Management
  PFTEX_BASE_AUTO_SUBLOAD
    Texture Management
  PFTEX_FAST
    Texture Management
  PFTEX_LIST_APPLY
    Texture Management
  PFTEX_LIST_AUTO_IDLE
    Texture Management
  PFTEX_LIST_AUTO_SUBLOAD
    Texture Management
  PFTEX_LOAD_BASE
    Texture Management
  PFTEX_LOAD_LIST
    Texture Management
  PFTEX_LOAD_SOURCE
    Texture
  PFTEX_SOURCE_FRAMEBUFFER
    Texture
  PFTEX_SOURCE_IMAGE
    Texture
  PFTEX_SOURCE_VIDEO
    Texture
  PFTEX_SUBLOAD_FORMAT
    Texture Management
  PFTG_EYE_DISTANCE_TO_LINE
    Automatic Texture Coordinate Generation
  PFTG_EYE_LINEAR
    Automatic Texture Coordinate Generation
  PFTG_EYE_LINEAR_IDENT
    Automatic Texture Coordinate Generation
  PFTG_NORMAL_MAP
    Automatic Texture Coordinate Generation
  PFTG_OBJECT_DISTANCE_TO_LINE
    Automatic Texture Coordinate Generation
  PFTG_OBJECT_LINEAR
    Automatic Texture Coordinate Generation
  PFTG_OFF
    Automatic Texture Coordinate Generation
  PFTG_REFLECTION_MAP
    Automatic Texture Coordinate Generation
  PFTG_SPHERE_MAP
    Automatic Texture Coordinate Generation
  PFTR_BLEND_ALPHA
    Transparency
  PFTR_FAST
    Transparency
  PFTR_HIGH_QUALITY
    Transparency
  PFTR_MS_ALPHA
    Transparency
  PFTR_NO_OCCLUDE
    Transparency
  PFTR_OFF
    Rendering Modes
    Transparency
  PFTR_ON
    Transparency
  PFTRAV_CONT
    pfNode Cull and Draw Callbacks
    Discriminator Callbacks
    Discriminator Callbacks
  PFTRAV_CULL
    pfChannel Traversal Modes
    pfChannel Traversal Modes
    Process Callbacks and Passthrough Data
  PFTRAV_DRAW
    Process Callbacks and Passthrough Data
  PFTRAV_IS_BCYL
    Intersection Methods for Segments
  PFTRAV_IS_CACHE
    Cull and Intersection Optimizations
  PFTRAV_IS_CLIP_END
    Line Segment Clipping
    Discriminator Callbacks
  PFTRAV_IS_CLIP_START
    Line Segment Clipping
    Discriminator Callbacks
  PFTRAV_IS_CULL_BACK
    Front Face/Back Face
  PFTRAV_IS_GEODE
    Discriminator Callbacks
  PFTRAV_IS_GSET
    Discriminator Callbacks
    Intersection Methods for Segments
    Intersecting with pfGeoSets
    Intersecting with pfGeoSets
  PFTRAV_IS_IGNORE
    Discriminator Callbacks
    Discriminator Callbacks
  PFTRAV_IS_NO_PART
    pfPartition Nodes
  PFTRAV_IS_NODE
    Intersection Methods for Segments
  PFTRAV_IS_PRIM
    Discriminator Callbacks
    Intersecting with pfGeoSets
    Intersecting with pfGeoSets
  PFTRAV_IS_UNCACHE
    Writing to pfFlux Buffers
  PFTRAV_PRUNE
    pfNode Cull and Draw Callbacks
    pfNode Cull and Draw Callbacks
    Discriminator Callbacks
    Discriminator Callbacks
  PFTRAV_TERM
    pfNode Cull and Draw Callbacks
    pfNode Cull and Draw Callbacks
    Discriminator Callbacks
    Discriminator Callbacks
  PFVCHAN_AUTO_APPLY
    Use pfPipeVideoChannels to Control Frame Rate
  PFVCHAN_SYNC
    Use pfPipeVideoChannels to Control Frame Rate
  PFVCHAN_SYNC_FIELD
    Use pfPipeVideoChannels to Control Frame Rate
  PFVFOG_3D_TEX_SIZE
    Initializing a pfVolFog
  PFVFOG_COLOR
    Initializing a pfVolFog
  PFVFOG_DENSITY
    Initializing a pfVolFog
  PFVFOG_DENSITY_BIAS
    Initializing a pfVolFog
  PFVFOG_EXP
    Patchy Fog
  PFVFOG_EXP2
    Patchy Fog
  PFVFOG_FLAG_CLOSE_SURFACES
    Initializing a pfVolFog
  PFVFOG_FLAG_FORCE_2D_TEXTURE
    Initializing a pfVolFog
  PFVFOG_FLAG_FORCE_PATCHY_PASS
    Initializing a pfVolFog
  PFVFOG_FLAG_LAYERED_PATCHY_FOG
    Initializing a pfVolFog
  PFVFOG_LAYERED_MODE
    Initializing a pfVolFog
  PFVFOG_LIGHT_SHAFT_ATTEN_SCALE
    Initializing a pfVolFog
  PFVFOG_LIGHT_SHAFT_ATTEN_TRANSLATE
    Initializing a pfVolFog
  PFVFOG_LIGHT_SHAFT_DARKEN_FACTOR
    Initializing a pfVolFog
  PFVFOG_LINEAR
    Initializing a pfVolFog
    Patchy Fog
  PFVFOG_PATCHY_MODE
    Initializing a pfVolFog
  PFVFOG_PATCHY_TEXTURE_BOTTOM
    Initializing a pfVolFog
  PFVFOG_PATCHY_TEXTURE_TOP
    Initializing a pfVolFog
  PFVFOG_RESOLUTION
    Initializing a pfVolFog
  PFVFOG_ROTATE_NODE
    Initializing a pfVolFog
  PFWIN_AUTO_RESIZE
    Manipulating a pfWindow
  PFWIN_EXIT
    Manipulating a pfWindow
  PFWIN_GFX_WIN
    Alternate Framebuffer Configuration Windows
    Creating, Configuring and Opening pfPipeWindow
    Creating, Configuring and Opening pfPipeWindow
  PFWIN_HAS_OVERLAY
    Manipulating a pfWindow
  PFWIN_HAS_STATS
    Manipulating a pfWindow
  PFWIN_NOBORDER
    Manipulating a pfWindow
  PFWIN_ORIGIN_LL
    Manipulating a pfWindow
  PFWIN_OVERLAY_WIN
    Manipulating a pfWindow
    Manipulating a pfWindow
    Alternate Framebuffer Configuration Windows
    Creating, Configuring and Opening pfPipeWindow
  PFWIN_SHARE_GL_CXT
    Window Share Groups
  PFWIN_SHARE_GL_OBJS
    Window Share Groups
  PFWIN_SHARE_STATE
    Window Share Groups
  PFWIN_STATS_WIN
    Alternate Framebuffer Configuration Windows
    Creating, Configuring and Opening pfPipeWindow
  PFWIN_TYPE_NOPORT
    Creating a pfWindow
    Creating a pfWindow
  PFWIN_TYPE_OVERLAY
    Creating a pfWindow
  PFWIN_TYPE_STATS
    Creating a pfWindow

topology
  adding to file
    Reading and Writing Topology Information: Using Pseudo Loaders
    Reading and Writing Topology Information: Using Pseudo Loaders
  information, reading and writing
    Reading and Writing Topology Information: Using Pseudo Loaders
  solids
    Collecting Connected Surfaces: pfSolid
  tools
    Summary of Scene Graph Topology: pfTopo

topology-building
  from list of surfaces
    Building Topology From a List of Surfaces
  general tasks
    Overview of Topology Tasks
  imported surfaces
    Building Topology “by Hand”: Imported Surfaces
  strategies
    Building Topology: Computing and Using Connectivity Information
  summary
    Summary of Topology Building Strategies
  two traversals
    Building Topology From All Scene Graph Surfaces: A Two-Traversal Build

topoTest sample application
  Summary of Topology Building Strategies

tori
  pfTorusSurface

toroidal loading
  Toroidal Loading

transformations
  affine
    Matrix Operations
  definied
    Glossary
  inheritance through scene graph
    State Inheritance
  order of composition
    Matrix Operations
  orthogonal
    Matrix Operations
  orthonormal
    Matrix Operations
    Transforming Bounding Volumes
  specified by matrices
    Matrix Operations

transition distance, definition
  Glossary

transparency
  Transparency
  Transparency

traversals
  activation
    Database Traversal
  application
    Application Traversal
  attributes
    Database Traversal
  culling
    Database Traversal
    Cull Traversal
    Custom Visibility Culling
    customizing
      Cull Traversal
      Custom Visibility Culling
    node pruning
      Traversal Order
    visibility testing
      Visibility Culling
  database. See databases
    Database Traversal
  definition
    Glossary
  draw
    Database Traversal
    Draw Traversal
  intersection
    Database Traversal
    Intersection Traversal
  two traversal topology
    Building Topology From All Scene Graph Surfaces: A Two-Traversal Build

TRI format. See formats
  Geometry Center Triangle Format

Triangle data structure
  Triangle Data Structure

triangle strip
  Triangle Strips
  Triangle Strips

triangulated irregular networks
  Triangulated Irregular Networks

trigger routine, definition
  Glossary

trigonometric functions
  Trigonometric Functions
  Trigonometric Functions

trim curve
  Planar Curves
  Defining Edges of a Parametric Surface: Trim Loops and Curves

trim loop
  Defining Edges of a Parametric Surface: Trim Loops and Curves

trim loops and curves
  Defining Edges of a Parametric Surface: Trim Loops and Curves

tristrip
  Triangle Strips

tsid
  Triangle Strips
  values
    Triangle Strips

two traversal topology
  Building Topology From All Scene Graph Surfaces: A Two-Traversal Build

type system
  multiprocessing implications
    More on Shared Memory and the Type System

type, actual, of objects
  Determining Ob ject Type

typographical conventions
  Conventions

UNC format. See formats
  UNC Walkthrough Format

up vector, defined
  Glossary

updatable objects
  Multiprocessing and libpf Objects

updates, latency-critical
  Process Pipeline Tuning Tips

user data
  User Data
  User Data

usinit()
  State Management

usnewlock()
  Shared Memory and pfInit()
  Shared Arenas
  Shared Arenas
  Allocating Locks and Semaphores

usnewsema()
  Shared Arenas
  Shared Arenas
  Allocating Locks and Semaphores

ussetlock()
  Shared Memory and pfInit()

usunsetlock()
  Shared Memory and pfInit()

utilities
  cliptexture configuration
    Configuration Utilities

VClock. See video counter
  Video Refresh Counter (VClock)

vector routines
  Vector Operations

vectors
  New Types Required for Reps
  2-component
    Vector Operations
  3-component
    Vector Operations
  4-component
    Vector Operations

vertex data structure
  Vertex Data Structure

vertex neighborhoods
  Vertex Data Structure

vertex programs
  Rendering Modes
  Enable / Disable
  Rendering Attributes
  Using OpenGL Performer with GPUs

vertical stripes
  How the Compositor Functions

video
  counter
    Video Refresh Counter (VClock)
  dynamic video resolution
    Maintaining Frame Rate Using D ynamic Vid eo Res olution
  field
    Stage Timing Graph
  multiple outputs
    Controlling Video Displays
  output
    Controlling Video Displays
  scan rate
    Fixing the Frame Rate

Video Digital Multiplexer (DPLEX)
  Using Scalable Graphics Hardware

video splitting
  One Window per Pipe, Multiple Channels per Window

view
  inset
    One Window per Pipe, Multiple Channels per Window
  matrix
    Setting Up a Viewpoint
  offset
    Setting Up a Viewpoint

view volume visualization, definition
  Glossary

viewing angles
  Setting Up a Viewpoint

viewing frustum
  definition
    Glossary
  intersection with
    Visibility Testing

viewing offsets
  Setting Up a Viewpoint

viewing parameters
  Setting Up a Viewing Frustum
  Setting Up a Viewpoint

viewpoint
  Setting Up a Viewpoint
  definition
    Glossary

viewports
  Setting Up a Viewport
  defined
    Glossary

virt_size
  virt_size and clip_size

virtual addresses and multiprocessing
  Virtual Address Spaces and Virtual Functions

virtual cliptexture
  Virtual Cliptextures on InfiniteReality Systems
  Virtual ClipTextures
  Virtualizing Cliptextures
  parameters
    How to Choose Virt ual Cliptexture Parameters
  set parameters
    How to Set Virtual Cliptexture Parameters

virtual functions, address space issues
  Virtual Address Spaces and Virtual Functions

virtual offset
  Virtual Cliptextures on InfiniteReality Systems

virtual reality
  Why Use OpenGL Performer?

virtual reality markup language
  Application Traversal
  See also VRML
    Application Traversal

virtual set
  Why Use OpenGL Performer?

virtualLODOffset
  Per-Tile Setting of Virtual Cliptexture Parameters

VISI bus
  Calligraphic Light Points

visibility culling
  Visibility Culling

visual priority. See coplanar geometry
  pfLayer Nodes

visual simulation
  Why Use OpenGL Performer?

visual, defined
  Glossary

VME bus
  LPB Hardware Configuration

volumes
  bounding
    Bounding Volumes
    boxes
      Creating and Transforming Volumes
    creating
      Creating Bounding Volumes
    cylinders
      Creating and Transforming Volumes
      Efficient Intersection and Traversals
    dynamic
      Bounding Volumes
    extending
      Creating Bounding Volumes
    hierarchical
      Hierarchical Bounding Volumes
    intersection testing
      Volume-Volume Intersection Tests
    spheres
      Creating and Transforming Volumes
    visibility testing
      Visibility Testing
  boxes, axially aligned
    Axially Aligned Boxes
  cylinders
    Cylinders
  geometric
    Defining a Volume
  half-spaces
    Half-spaces (Planes)
  intersections. See intersections
    Intersecting Volumes
  primitives
    Creating and Transforming Volumes
  spheres
    Spheres
  transforming
    Transforming Bounding Volumes

VRML
  Application Traversal
  SGI Open Inventor Format

VRML 2.0
  WRL Format

Wavefront
  Wavefront Technology OBJ Format

weights for NURBS control points
  Weights for Control Points

wglSwapBuffers()
  Using `ogldebug` to Observe Graphics Calls

widget, defined
  Glossary

windows
  Using pfPipeWindows
  Creating, Configuring and Opening pfPipeWindow

WindRiver
  Performance Measurement Tools

WindView
  Performance Measurement Tools

winged data structures
  Summary of Scene Graph Topology: pfTopo

wireframe
  pfGeoSet Draw Mode

workload balancing
  Load Balancing

WorkShop
  Performance Measurement Tools

write()
  Asynchronous I/O (IRIX only)

wrl format
  WRL Format

X Windows
  Motif

XCreateWindow()
  pfWindows and GL Windows

XML configuration files
  Reading XML Configuration Files
  More Sample Programs, Configuration Files, and Source Code

XSGIvc library
  Controlling Video Displays

z-fighting
  Decals

Prev | Table of Contents |
Glossary |  |