SGI Techpubs Library

The new home for SGI documentation is the SGI Customer Portal, This site will be redirected to the new location later this month.

Techpubs Library
Books by Product
What's New

IRIX 6.5 Linux Hardware Freeware (IRIX) Windows
To further optimize your search, select from the following options:
 Search only in:
Search only titles    Show only 1 hit/book      Results/page:

IRIX 6.5  »  Books  »  Developer  »  
OpenGL Performer™  Programmer's Guide
(document number: 007-1680-100  /  published: 2004-12-07)   additional info | download

This guide describes a programming interface (with ANSI C and C++ bindings) for creating real-time graphics applications with high-performance rendering in an easy-to-use 3D graphics toolkit. OpenGL Performer interfaces with the OpenGL library and runs on the IRIX, Linux, or Microsoft Windows operating system. Topics covered include an overview of real-time image generation and OpenGL Performer, information on application and scene-graph structure, details of database traversal, hints on load management and special effects, a description of the dozens of file loaders provided with OpenGL Performer, and information about the low-level libpr rendering library, math tools, statistics gathering and reporting, application tuning, and the C++ programmer's API.

table of contents (expand all | collapse all)  |  list of figures  |  list of tables  |  list of examples  |  list of procedures  |  

   Front Matter
   New Features in This Guide
 - About This Guide
       Why Use OpenGL Performer?
       What You Should Know Before Reading This Guide
     - How to Use This Guide
           What This Guide Contains
           Sample Applications
       Internet and Hardcopy Reading for the OpenGL Performer Series
       Reader Comments
 - Chapter 1. OpenGL Performer Programming Interface
     - General Naming Conventions
           Header Files
           Naming in C and C++
           Macros, Tokens, and Enums
     - Class API
           O bject Creation
           Set Routines
         - Get Routines
               Getting Current In-Use Values
           Action Routines
           Enable and Disable of Modes
           Mode, Attribute, or Value
     - Base Classes
           Inheritance Graph
           libpr and libpf Objects
           User Data
           pfDelete() and Reference Counting
           Copying Objects with pfCopy()
           Printing Objec ts with pfPrint()
           Determining Ob ject Type
 - Chapter 2. Setting Up the Display Environment
     - Using Pipes
           The Functional Stages of a Pipeline
           Creating and Configuring a pfPipe
           Example of pfPipe Use
     - Using Channels
           Creating and Configuring a pfChannel
           Setting Up a Scene
           Setting Up a Viewport
         - Setting Up a Viewing Frustum
               Clipping Planes
           Setting Up a Viewpoint
           Example of Channel Use
       Controlling the Video Output
     - Using Multiple Channels
           One Window per Pipe, Multiple Channels per Window
     - Using Channel Groups
           Multiple Channels and Multiple Windows
       Importing OpenGL Multipipe SDK (MPK) Configuration Files
 - Chapter 3. Nodes and Node Types
     - Nodes
         - Attribute Inheritance
         - pfNode
               pfNode Attributes
               pfNode Operations
               An Example of Scene Creation
     - Working with Nodes
         - Instancing
               Shared Instancing
               Cloned Instancing
           Bounding Volumes
     - Node Types
         - pfScene Nodes
               pfScene Default Rendering State
           pfSCS Nodes
           pfDCS Nodes
           pfFCS Nodes
           pfDoubleSCS Nodes
           pfDoubleDCS Nodes
           pfDoubleFCS Nodes
           pfSwitch Nodes
           pfSequence Nodes
           pfLOD Nodes
           pfASD Nodes
           pfLayer Nodes
           pfGeode Nodes
           pfText Nodes
           pfBillboard Nodes
           pfPartition Nodes
       Sample Program
 - Chapter 4. Database Traversal
     - Scene Graph Hierarchy
           Database Traversals
           State Inheritance
           Database Organization
       Application Traversal
     - Cull Traversal
           Traversal Order
         - Visibility Culling
               Hierarchical Bounding Volumes
               Visibility Testing
               Visibility Culling Example
         - Organizing a Database for Efficient Culling
               Custom Visibility Culling
           Sorting the Scene
           Paths through the Scene Graph
     - Draw Traversal
           Optimizing the Drawing of Sub-bins
           Bin Draw Callbacks
     - Controlling and Customizing Traversals
           pfChannel Traversal Modes
         - Cull Programs
               The pfCullProgram Class
               Predefined Cull Program Instructions
               User-Defined Cull Program Instructions
               Cull Traversal
               Occlusion Culling Using Cull Programs
               Small-Feature Culling Using Cull Programs
           pfNode Draw Mask
           pfNode Cull and Draw Callbacks
     - Process Callbacks
           Process Callbacks and Passthrough Data
     - Intersection Traversal
           Testing Line Segment Intersections
           Intersection Requests: pfSegSets
           Intersection Return Data: pfHit Objects
         - Intersection Masks
               Setting the Intersection Mask
               Specifying Different Classes of Geometry
           Discriminator Callbacks
           Line Segment Clipping
           Traversing Special Nodes
         - Performance
               Performance Trade-offs
               Front Face/Back Face
               Enabling Caching
           Intersection Methods for Segments
 - Chapter 5. Frame and Load Control
     - Frame Rate Management
           Selecting the Frame Rate
           Achieving the Frame Rate
         - Fixing the Frame Rate
               Frame Synchronization
               Free-Running Frame-Rate Control
               Fixed Frame-Rate Control
               Frame Skipping
               Sample Code
     - Level-of-Detail Management
           Level-of-Detail Models
           Level-of-Detail States
           Level-of-Detail Range Processing
           Level-of-Detail Transition Blending
           Run-Time User Control Over LOD Evaluation
         - Terrain Level-of-Detail
               Active Surface Definiton (ASD)
               Arbitrary Morphing
     - Maintaining Frame Rate Using D ynamic Vid eo Res olution
           The Channel in DVR
           DVR Scaling
           Customizing DVR
           Understanding the Stre ss Filter
       Dynamic Load Management
     - Successful Multiprocessing with OpenGL Performer
           Review of Rendering Stages
         - Choosing a Multiprocessing Model
               Cull-Overlap-Draw Mode
               Forcing Display List Generation
               Intersection Pipeline
               Compute Process
               Multiple Rendering Pipelines
               CULL Sidekick Processes
               Order of Calls
               Comparative Structure of Models
         - Asynchronous Database Processing
               DBASE Process
           Placing Multiple OpenGL Performer Processes on a Single CPU
           Rules for Invoking Functions While Multiprocessing
           Multiprocessing and Memory
           Shared Memory and pfInit()
           Passthrough Data
     - CULL Process Optimizations
           Cull Sidekick Processes
           Configuring CULL_SIDEKICK Processes
           CULL Sidekick Optimization Mask
           CULL Sidekick Synchronization Policy
           CULL Sidekick User Functions
           Modifying Attributes of Cloned pfGeoSets
           Marking pfGeoSets for Optimization
 - Chapter 6. Creating Visual Effects
       Using pfEarthSky
       Atmospheric Effects
     - Patchy Fog and Layered Fog
           Creating Layered Fog
           Creating Patchy Fog
           Initializing a pfVolFog
           Updating the View
           Drawing a Scene with Fog
           Deleting a pfVolFog
         - Specifying Fog Parameters
               Layered Fog
               Patchy Fog
         - Advanced Features of Layered Fog and Patchy Fog
               Enabling Self-Shadowing of a Layered Fog and Scene Darkening
               Animating Patchy Fog
               Selecting a Different Type of Patchy Fog Algorithm
               Simulating Self-Shadowing in Patchy Fog
               Layered Patchy Fog
               Light Shafts
           Performance Considerations and Limitations
     - Real-Time Shadows
           Creating a pfShadow
           Drawing a Scene with Shadows
           Specifying Shadow Parameters
           Assigning Data with Directions
           Limitations of Real-Time Shadows
     - Image-Based Rendering
           Creating a pfIBRnode
           Creating a pfIBRnode Using a Proxy
           Creating a pfIBRtexture
           Parameters Controlling Drawing of a pfIBRnode
         - The Simplify Application
               The Simplify Graphical User Interface (GUI)
               Making a Proxy of an Object
               Simplifying an Object
         - Creating Images of an Object with makeProxyImages
               Command-Line Options for makeProxyImages
               Packing Additional Textures Pieces
               Fine Tuning Texture Rendering
               Potential Problems
           Creating Images of an Object with makeIBRimages
 - Chapter 7. Importing Databases
       Overview of OpenGL Performer Database Creation and Conversion
     - libpfdu - Utilities for Creating Efficient OpenGL Performer Run-Time Structures
         - pfdLoadFile - Loading Arbitrary Databases into OpenGL Performer
               Loading Process Internals
               Loader Name
               Shell Environment Variables
         - Database Loading Details
               Finding and initializing a Converter
     - Developing Custom Importers
           Structure and Interpretation of the Database File Format
           Scene Graph Creation Using Nodes as Defined in libpf
           Defining Geometry and Graphics State for libpr
           Creating an OpenGL Performer Database Converter using libpfdu
     - Maximizing Database Loading and Paging Performance with PFB and PFI Formats
         - pfconv
               Example Conversion
       Supported Database Formats
     - Description of Supported Formats
           AutoDesk 3DS Format
           SGI BIN Format
           Side Effects POLY Format
           Brigham Young University BYU Format
           Optimizer CSB Format
           Virtual Cliptexture CT Loader
           Designer's Workbench DWB Format
           AutoCAD DXF Format
           MultiGen OpenFlight Format
           McDonnell-Douglas GDS Format
           SGI GFO Format
           SGI IM Format
           AAI/Graphicon IRTP Format
           SGI Open Inventor Format
           Lightscape Technologies LSA and LSB Formats
           Medit Productions MEDIT Format
           NFF Neutral File Format
           Wavefront Technology OBJ Format
         - SGI PFB Format
               Converting to the PFB Format
         - SGI PFI Format
               Creating PFI Files
           SGI PHD Format
           SGI PTU Format
           ArchVision RPC Format
           USNA Standard Graphics Format
           SGI SGO Format
           USNA Simple Polygon File Format
           Sierpinski Sponge Loader
           Star Chart Format
           3D Lithography STL Format
           SuperViewer SV Format
           Geometry Center Triangle Format
           UNC Walkthrough Format
           WRL Format
       Database Operators with Pseudo Loaders
     - The Maya Database Exporter
           Installation Requirements
           Exporting a Scene Using the Graphical Interface
           Exporting a Scene Using the Maya Embedded Language (MEL)
         - Translation Details
               Supported Maya Features
 - Chapter 8. Geometry
     - pfGeoSet (Geometry Set)
           Primitive Types
         - pfGeoSet Draw Mode
               Packed Attributes
           Primitive Connectivity
           Attribute Bindings
         - Indexed Arrays
               When to Index Attributes
           pfGeoSet Operations
     - pfGeoArray (Geometry Array)
           Creating pfGeoArrays
           pfGeoArray Attributes
           pfGeoArray Attribute Types
           pfGeoArray Primitive Types
           Example Code
           Converting pfGeoSets to pfGeoArrays
     - Optimizing Geometry for Rendering
           Function pfdMergeGraph()
           Function pfdStripGraph()
           Function pfdSpatializeGraph()
           The Optimization Pipeline
           Using the libpfgopt Pseudo Loader
     - Rendering 3D Text
 - Chapter 9. Higher-Order Geometric Primitives
     - Features and Uses of Higher-Order Geometric Primitives
           Reps and the Rendering Process
           Trimmed NURBS
     - Objects Required by Reps
           New Types Required for Reps
         - Classes for Scalar Functions
               Class Declaration for pfScalar
               Class Declaration for pfCompositeScalar
               Main Features of the Methods in pfCompositeScalar
               Trigonometric Functions
               Class Declaration for pfPolyScalar
           Matrix Class: pfRMatrix
     - Geometric Primitives: The Base Class pfRep and the Application repTest
           Class Declaration for pfRep
           Main Features of the Methods in pfRep
     + Planar Curves
     - Spatial Curves
         - Lines in Space
           Circles in Space
           Superquadrics in Space
           Hermite Spline Curves in Space
           NURBS Curves in Space
         - Curves on Surfaces: pfCompositeCurve3d
               Class Declaration for pfCompositeCurve3d
               Main Features of the Methods in pfCompositeCurve3d
           Discrete Curves in Space
           Example of Using pfDisCurve3d and pfHsplineCurve3d
     - Parametric Surfaces
           Mathematical Description of a Parametric Surface
           Defining Edges of a Parametric Surface: Trim Loops and Curves
         - Adjacency Information: pfEdge
               Class Declaration for pfEdge
         - Base Class for Parametric Surfaces: pfParaSurface
               Class Declaration for pfParaSurface
               Main Features of the Methods in pfParaSurface
         - pfPlaneSurface
               Class Declaration for pfPlaneSurface
               Main Features of the Methods in pfPlaneSurface
         - pfSphereSurface
               Class Declaration for pfSphereSurface
               Main Features of the Methods in pfSphereSurface
               pfSphereSurface Example
         - pfCylinderSurface
               Class Declaration for pfCylinderSurface
               Main Features of the Methods in pfCylinderSurface
         - pfTorusSurface
               Class Declaration for pfTorusSurface
               Main Features of the Methods in pfTorusSurface
         - pfConeSurface
               Class Declaration for pfConeSurface
               Main Features of the Methods in pfConeSurface
         - Swept Surfaces
               Orientation of the Cross Section
               Class Declaration for pfSweptSurface
               Main Features of the Methods in pfSweptSurface
         - pfFrenetSweptSurface
               Class Declaration for pfFrenetSweptSurface
               Main Features of the Methods in pfFrenetSweptSurface
               Making a Modulated Torus With pfFrenetSweptSurface
         - Ruled Surfaces
               Class Declaration for pfRuledSurface
         - Coons Patches
               Class Declaration for pfCoonsSurface
         - NURBS Surfaces
               Class Declaration for pfNurbSurface
               Main Features of the Methods in pfNurbSurface
               Indexing Knot Points and the Control Hull
               Equation Used to Calculate a NURBS Surface
               Alternative Equation for a NURBS Surface
               Sample of a Trimmed pfNurbSurface From repTest
         - Hermite-Spline Surfaces
               Class Declaration for pfHsplineSurface
               Main Features of the Methods in pfHsplineSurface
     - Meshes
           Mesh Faces
         - Mesh Vertices
               Vertex Coordinates
               Vertex Neighbors
               Binary Flags
     - Subdivision Surfaces
           Creating a Subdivision Surface
           Loop and Catmull-Clark Subdivisions
           Dynamic Modification of Vertices
           The libpfsubdiv Pseudo Loader
           Special Notes
 - Chapter 10. Creating and Maintaining Surface Topology
       Overview of Topology Tasks
     - Summary of Scene Graph Topology: pfTopo
         - Building Topology: Computing and Using Connectivity Information
               Building Topology Incrementally: A Single-Traversal Build
               Building Topology From All Scene Graph Surfaces: A Two-Traversal Build
               Building Topology From a List of Surfaces
               Building Topology “by Hand”: Imported Surfaces
               Summary of Topology Building Strategies
           Reading and Writing Topology Information: Using Pseudo Loaders
           Class Declaration for pfTopo
           Main Features of the Methods in pfTopo
     - Collecting Connected Surfaces: pfSolid
           Class Declaration for pfSolid
           Main Features of the Methods in pfSolid
 - Chapter 11. Rendering Higher-Order Primitives: Tessellators
     - Features of Tessellators
         - Tessellators for Varying Levels of Detail
               Details of
           Tessellators Act on a Whole Graph or Single Node
           Tessellators and Topology: Managing Cracks
     - Base Class pfTessellateAction
           Retessellating a Scene Graph
           Class Declaration for pfTessellateAction
           Main Features of the Methods in pfTessellateAction
     - Tessellating Parametric Surfaces
         - pfTessParaSurfaceAction
               Class Declaration for pfTessParaSurfaceAction
               Main Features of the Methods in pfTessParaSurface
           Sample From repTest: Tessellating and Rendering a Sphere
 - Chapter 12. Graphics State
     - Immediate Mode
         - Rendering Modes
               Shading Model
               Alpha Function
               Frontface / Backface
           Rendering Values
           Enable / Disable
         - Rendering Attributes
               Video Texturing
               Texture Management
               Texture Formats
               Controlling Texture LOD with pfTexLOD
               Setting the Texture Environment with pfTexEnv
               Automatic Texture Coordinate Generation
               Color Tables
           Graphics Library Matrix Routines
           Sprite Transformations
         - Display Lists
               Combining Display Lists
         - State Management
               Pushing and Popping State
           State Override
         - pfGeoState
               Local and Global State
               Applying pfGeoStates
               pfGeoSets and pfGeoStates
               Multitexture Support in pfGeoState
 - Chapter 13. Shaders
     - The pfShaderProgram Class
           Allocating Memory for a Shader Program
         - Creating a Shader Program
               Adding pfShaderObjects to a Shader program
               Specifying Uniform Variables (optional)
               Adding Uniform Variables to Shader Programs
               Clamping Uniform Variables (optional)
               Normalizing Uniform Variables (optional)
           Applying Shader Programs
     - The pfShaderObject Class
           Creating New Shader Objects
           Specifying Shader Objects
           Specifying the Object Type
           Compiling Shader Objects
       Example Code
 - Chapter 14. Using Scalable Graphics Hardware
     - Using OpenGL Performer with a DPLEX
           Hyperpipe Concepts
         - Configuring Hyperpipes
               Establishing the Number of Graphic Pipes
               Using the Default Hyperpipe Mapping to Graphic Pipes
               Using Nondefault Hyperpipe Mappings to Graphics Pipes
         - Configuring pfPipeWindows and pfChannels
           Programming with Hyperpipes
     - Using OpenGL Performer with an SGI Scalable Graphics Compositor
           How the Compositor Functions
           The pfCompositor Class
           Querying the System for Hardware Compositors
           Creating a pfCompositor
           Querying pfCompositors
           Load Balancing
           Setting Compositor Modes
           Querying Compositor Modes
           Managing Screen Space, Channel Clipping, and Antialiasing
     - Using OpenGL Performer with GPUs
           The pfGProgram Class
           The pfGProgramParms Class
           The pfVertexProgram and pfFragmentProgram Classes
 - Chapter 15. ClipTextures
     - Overview
           Cliptexture Levels
         - Cliptexture Assumptions
               Why Do These Assumptions Work?
           Image Cache
         - Toroidal Loading
               Invalid Borders
           Updating the Clipce nter
           Virtual Cliptextures on InfiniteReality Systems
         - Cliptexture Support Requirements
               Texel Data
         - Special Features
               Virtualization on InfiniteReality Systems
               Multiple Pipe Support
         - How Cliptextures Interact with the Rest of the System
         - Cliptexture Support in OpenGL Performer
               libpr Support
               libpf Support
               libpfutil Support
               libpfdu Support
               libpfdb Support
               Sample Applications
         - Cliptexture Manipulation
               Load Cont rol
               Invalid Border
               S hare Masks
               Read Function
               Read Queue Sorting
       Cliptexture API
     - Preprocessing ClipTextures
           Building a MIPmap
           Formatting Im age Data
         - Tiling an Im age
               Tile Size
     - Cliptexture Configuration
           Configuration Considerations
           Load-Time Configuration
           Post-Load-Time Configuration
     - Configuration API
         - libpr Functionality
               Configuring an Image Cache Level
               Configuring an Image Cache Proto Tile
               Configuring an Image Cache
               Configuring a pfTexture
               Configuring the Default Tile
               Configuring Image Tiles
         - Configuration Utilities
               Cliptexture Configuration
               Image Cache Configuration
               Filling in the Structures
         - Configuration Files
               Using Configuration Files
               Creating Configuration Files
               Configuration File Tips
               Cliptexture Loaders
               Image Cache Configuration File Details
               Configuration Fields
               Image Cache Configuration File Description
               ext_format, int_format, and img_format
               icache_size, mem_region_size, and tex_region_size
               tile_format and tile_params
               header_offset, tiles_in_file, and tile_size
               num_streams, s_streams, t_streams, and r_streams
               Cliptexture Configuration File Details
               Configuration Fields
               Cliptexture Configuration File Description
               ext_format, int_format, and img_format
               virt_size and clip_size
               icache_files, icache_format and icache_params
               header_offset, tiles_in_file, and tile_size
               tile_base, tile_format and tile_params
               Optional Image Cache Configuration Files
     - Post-Scene Graph Load Configuration
         - MPClipTextures
               Connecting MPcliptextures to pfPipes
               libpf Functionality
         - pfMPClipTexture Utilities
               Clipcenter Node
         - Using Cliptextures with Multiple Pipes
               Making Masters and Slaves
               Multipipe Cliptexture API
               Multipipe Utilities
               Master/Slave Share Masks
           Texture Memory and Hardware Support Checking
     - Manipulating Cliptextures
         - Cliptexture Load Control
               Dynamic Texture Resolution
               Load Control API
               Download Time
               Cost Tables
               Changing Levels
               Total Texload Time and Texload Time Fraction
               Read Queue Sorting
           Invalidating Cliptextures
         - Virtual ClipTextures
               Selecting the Levels
               How to Set Virtual Cliptexture Parameters
               Per-Frame Setting of Virtual Cliptexture Parameters
               Per-Tile Setting of Virtual Cliptexture Parameters
               Tiling Strategies
               Doing Per-tile Updates
               How to Choose Virt ual Cliptexture Parameters
           Custom Read Functions
     - Using Cliptextures
         - Cliptexture Insets
               Adding Ins ets to Cliptextured Data
               Ins ets and DTR
               Building Insets
               In set Boundaries
               Supersampled Data
               Multiple Insets
         - Estimating Cliptexture Memory Usage
               System Memory Estimation
               Example of Estimating System Memory Requirements
               Texture Memory Estimation
               Texture Memory Usage: A Further Complication
         - Using Cliptextures in Multipipe Applications
               When to Make Master/Slave Cliptexture Groups
               Slave Cliptextures with Offset Centers
           Virtualizing Cliptextures
           Customizing Load Control
           Custom Read Functions
         - Cliptexture Sample Code
               Test and Demo Pro grams
               OpenGL Performer Cliptexture Applications
               Loaders that Support Cliptextures
               Cliptexture Utility Code
 - Chapter 16. Windows
       Creating a pfWindow
       Configuring the Framebuffer of a pfWindow
       pfWindows and GL Windows
     - Manipulating a pfWindow
           Alternate Framebuffer Configuration Windows
           Window Share Groups
           Synchronization of Buffer Swap for Multiple Windows
       Communicating with the Window System
       More pfWindow Examples
 - Chapter 17. pfPipeWindows and pfPipeVideoChannels
     - Using pfPipeWindows
           Creating, Configuring and Opening pfPipeWindow
         - pfPipeWindows in Action
               Multiple pfPipeWindows and Multiple pfPipes
     - Controlling Video Displays
           Creating a pfPipeVideoChannel
           Multiple pfPipeVideoChannels in a pfPipeWindow
           Configuring a pfPipeVideoChannel
           Use pfPipeVideoChannels to Control Frame Rate
 - Chapter 18. Managing Nongraphic System Tasks
     - Handling Queues
           Queue Contents
         - Adding or Retrieving Elements
               Retrieving Elements from the Queue
               Related Methods
         - pfQueue Modes
               NonSorting Mode
               Sorting the pfQueue
               Sorting Function
               Input and Output Ranges
               Triggering the Sort
           Running the Sort Process on a Different CPU
     - High-Resolution Clocks
           Video Refresh Counter (VClock)
     - Memory Allocation
           Allocating Memory With pfMalloc()
           Shared Arenas
           Allocating Locks and Semaphores
       Asynchronous I/O (IRIX only)
       Error Handling and Notification
       File Search Paths
 - Chapter 19. Dynamic Data
     - pfFlux
           Creating and Deleting a pfFlux
           Initializing the Buffers
         - pfFlux Buffers
               Reading pfFlux Buffers
               Writing to pfFlux Buffers
         - Coordinating pfFlux and Connected pfEngines
               Triggering pfFlux Evaluation
         - Synchronized Flux Evaluation
               Synchronizing pfFluxes with Flux Sync Groups
               Enabling a Flux Sync Group
               Evaluating a Synchronized Flux Group
           Fluxed Geosets
           Fluxed Coordinate Systems
         - Replacing pfCycleBuffer with pfFlux
               pfFlux Differences
               Converting to pfFlux
     - pfEngine
           Creating and Deleting Engines
         - Setting Engine Types and Modes
               PFENG_SUM Engines
               PFENG_MORPH Engines
               PFENG_BLEND Engines
               PFENG_TRANSFORM Engines
               PFENG_ALIGN Engines
               PFENG_MATRIX Engines
               PFENG_ANIMATE Engines
               PFENG_BBOX Engines
               PFENG_TIME Engines
               PFENG_STROBE Engines
               PFENG_USER_FUNCTION Engines
           Setting Engine Sources and Destinations
           Setting Engine Masks
           Setting Engine Iterations
           Setting Engine Ranges
           Evaluating pfEngines
       Animating a Geometry
 - Chapter 20. Active Surface Definition
     - Using ASD
         - LOD Reduction
               Triangulated Irregular Networks
           Hierarchical Structure
       ASD Solution Flow Chart
     - A Very Simple ASD
           Morphing Vector
           A Very Complex ASD
     - ASD Elements
           Evaluation Function
     - Data Structures
         - Triangle Data Structure
               Triangle IDs and LOD Levels
               Discontinuous, Neighboring LODs
               Triangle Strips
               Vertex and Reference Point Arrays
         - Attribute Data Array
               Setting the Attributes
               Global Attributes
           Vertex Data Structure
         - Default Evaluation Function
               Overriding the Default Evaluation Function
     - pfASD Queries
         - Aligning an Object to the Surface
               Casting a Shadow
               Generating Decals
           Adding a Q uery Array
     - Using ASD for Multiple Channels
           Connecting Channels
       Combining pfClipTex ture and pfASD
     - ASD Evaluation Function Timing
           Query Results
           Aligning a Geometry With a pfASD Surface Example
           Aligning Light Points Above a pfASD Surface Example
     - Paging
           Interest Area
         - Preprocessing for Paging
               Order of Paging
           Multi-resolution Paging
 - Chapter 21. Light Points
       Uses of Light Points
       Creating a Light Point
     - Setting the Behavior of Light Points
         - Directionality
               Enabling Directionality
         - Emanation Shape
         - Attenuation through Fog
               Enabling Punch-Through
         - Size
               Size Limitations
               Limiting Size Calculations
               Enabling Perspective
         - Fading
               Fading Calculation
               Enabling Fading
     - Callbacks
         - Multisample, Size, and Alpha
               Minimum Number of Multisamples
       Reducing CPU Processing Using Textures
     - Preprocessing Light Points
         - Stage Configuration Callbacks
           How the Light Point Process Works
     - Calligraphic Light Points
         - Calligraphic Versus Raster Displays
               Display Modes
               Maximum Number of Calligraphic Lights
           LPB Hardware Configuration
           Visibility Information
         - Required Steps For Using Calligraphic Lights
               Customizing LPB Initialization
         - Accounting for Projector Differences
               Slew Values
               Color Correction
           Frame to Frame Control
           Defocussing Calligraphic Objects
     - Using pfCalligraphic Without pfChannel
           Timing Issues
           Light Point Process and Calligraphic
       Debugging Calligrap hic Lights on Non-Calligraphic Systems
       Calligraphic Light Example
 - Chapter 22. Math Routines
       Vector Operations
       Matrix Operations
       Quaternion Operations
       Matrix Stack Operations
     - Creating and Transforming Volumes
         - Defining a Volume
               Axially Aligned Boxes
               Half-spaces (Planes)
           Creating Bounding Volumes
           Transforming Bounding Volumes
     - Intersecting Volumes
           Point-Volume Intersection Tests
           Volume-Volume Intersection Tests
     - Creating and Working with Line Segments
           Intersecting with Volumes
           Intersecting with Planes and Triangles
         - Intersecting with pfGeoSets
               Intersection Masks
               Discriminator Callbacks
       General Math Routine Example Program
 - Chapter 23. Statistics
     - Interpreting Statistics Displays
           Status Line
           Stage Timing Graph
           Load and Stress
         - CPU Statistics
               RTMon Statistics (IRIX Only)
           Rendering Statistics
           Fill Statistics
     - Collecting and Accessing Statistics in Your Application
           Displaying Statistics Simply
           Enabling and Disabling Statistics for a Channel
         - Statistics in libpr and libpf—pfStats Versus pfFrameStats
               Statistics Class Structures
         - Statistics Rules of Use
               Statistics Tokens
               Statistics Buffers
         - Reducing the Cost of Statistics
               Enabling Only Statistics of Interest
               Controlling Update Rate
         - Statistics Output
           Customizing Displays
           Setting Update Rate
           The pfStats Data Structure
           Setting Statistics Class Enables and Modes
 - Chapter 24. Performance Tuning and Debugging
       Performance Tuning Overview
     - How OpenGL Performer Helps Performance
           Draw Stage and Graphics Pipeline Optimizations
           Cull and Intersection Optimizations
           Application Optimizations
     - Specific Guidelines for Optimizing Performance
         - Graphics Pipeline Tuning Tips
               Host Bottlenecks
               Transform Bottlenecks
               Fill Bottlenecks
         - Process Pipeline Tuning Tips
               Cull Process Tips
               Draw Process Tips
               Efficient Intersection and Traversals
         - Database Concerns
               libpr Databases
               libpf Databases
               Balancing Cull and Draw Processing with Database Hierarchy
               Graphics and Modeling Techniques to Improve Performances
           Special Coding Tips
     - Performance Measurement Tools
           Using pixie, prof, and gprof to Measure Performance
           Using ogldebug to Observe Graphics Calls
     - Guidelines for Debugging
           Shared Memory
           Use the Simplest Process Model
           Avoid Floating-Point Exceptions
           When the Debugger Will Not Give You a Stack Trace
           Tracing Members of OpenGL Performer Objects
     - Memory Corruption and Leaks
           libdmalloc (IRIX only)
     - Notes on Tuning for RealityEngine Graphics
           Other Tips
     - EventView—A Performance Analyzer
           Viewing Events—evanalyzer
           Controlling the Collection of OpenGL Performer Internal Events
         - Sample Use of EventView
               The Simplest Case
               A More Complex Case
         - Using EventView Tools
               evpp—Event Pre-Processor
               evanalyzer—EventView Graphical Analysis Program
               evhist—Histogram Generator
               evgraph—Event Information Plotter
         - Understanding OpenGL Performer Internal Events
               pfSync() Events
               pfFrame Events
               CULL Process Events
               DRAW Process Events
               Other Events
 - Chapter 25. Building a Visual Simulation Application Using libpfv
       The Simplest pfvViewer Program
       Adding Interaction to a pfvViewer Program
       Reading XML Configuration Files
       Module Scoping, Multiple Worlds and Multiple Views
       Extending a pfvViewer—Writing Custom Modules
       Extending a pfvViewer—Module Entry Points
       Picking, Selection, and Interaction
       More Sample Programs, Configuration Files, and Source Code
 - Chapter 26. Programming with C++
     - Class Taxonomy
           Public Structs
           libpr Classes
           libpf Classes
           pfType Class
     - Programming Basics
           Header Files
           Creating and Deleting OpenGL Performer Objects
           Invoking Methods on OpenGL Performer Objects
           Passing Vectors and Matrices to Other Libraries
     - Porting from C API to C++ API
           Typedefed Arrays Versus Structs
           Interface Between C and C++ API Code
     - Subclassing pfObjects
           Initialization and Type Definition
           Defining Virtual Functions
           Accessing Parent Class Data Members
     - Multiprocessing and Shared Memory
         - Initializing Shared Memory
               More on Shared Memory and the Type System
               Virtual Address Spaces and Virtual Functions
         - Data Members and Shared Memory
               Non-static Member Data
               Static Member Data
           Multiprocessing and libpf Objects
     - Performance Hints
           Constructor Overhead
           Math Operators

Home    •     What's New    •     Help    •     Terms of Use    •     Privacy Policy    •

© 2009 - 2015 Silicon Graphics International Corp. All Rights Reserved.