SGI Techpubs Library

The new home for SGI documentation is the SGI Customer Portal, This site, http://techpubs., will be redirected to the new location starting later this December 2015.

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™ Getting Started Guide
(document number: 007-3560-005  /  published: 2004-12-07)   additional info | download

The OpenGL Performer Getting Started Guide introduces the most important concepts and classes in the OpenGL Performer library. For further reference, the OpenGL Performer Programmer's Guide contains a full explanation of all Performer classes. Use the OpenGL Getting Started Guide to quick-start your programming using the OpenGL Performer API. OpenGL Performer provides a programming interface (with ANSI C and C++ bindings) for creating real-time graphics applications and offers high-perfomrance rendering in an easy- to-use 3D graphics toolkit. OpenGL Performer interfaces to the OpenGL graphics library; this library combined with the IRIX, Linux, or Microsoft Windows operating system forms the foundation of a powerful suite of tools and features for creating real-time 3D graphics applications on SGI systems.

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
       What Is OpenGL Performer?
       Why Use OpenGL Performer?
       What You Should Know Before Reading This Guide
     - What This Guide Contains
           Part One: Overview of OpenGL Performer
           Part Two: Programming with OpenGL Performer
       Internet and Hardcopy Reading for the OpenGL Performer Series
       Reader Comments
 - Part I. Overview of OpenGL Performer
     - Chapter 1. Getting Acquainted with OpenGL Performer
           Installing the Software
         - Exploring the OpenGL Performer Sample Scenes with Perfly
               Locations of Perfly and Example Source Code
               Starting and Quitting Perfly
               Basic Perfly Controls
               Looking Around
               Approaching the Building
               More Controls
             - Other Motion Models
                   Motion Using Paths
               The Use of Instances
           Loading Databases into OpenGL Performer
           Going Beyond Visual Simulation
     - Chapter 2. OpenGL Performer Basics
           OpenGL Performer Applications
         - Library Structure of OpenGL Performer
             - Library Features
                   High-Performance Rendering Library (libpr)
                   Visual Simulation Application Library (libpf)
                   Geometry Builder Library (libpfdu)
                   Utility Library (libpfutil)
                   User Interface Library (libpfui)
                   A Graphical Viewer Library (libpfv)
                   A Configuration-Import Library (libpfmpk)
                   Database Loader Library (libpfdb)
         - Overview of the OpenGL Performer Library Structure
             - libpf—Visual Simulation Library
                   Multiprocessing Framework
                   Frame Control
                   Visual Database (pfScene)
                   Special Features (pfEarthSky, pfSequence, pfASD)
             -  libpr—High-Performance Rendering Library
                   High-Performance Geometry Rendering
                   Efficient Graphics State Management
                   Graphics State Encapsulation
                   Display Lists
                   Math Support
                   Color Tables (pfColortable)
                   Light Points
                   Asynchronous File I/O (pfFile)
                   Memory Allocation (pfDataPool)
                   High-Resolution and Video-Rate Clocks (pfGetTime,)
                   The pfWindow Windowing Functions
             -  libpfdu—Geometry Builder Library
                   Database Builder
               libpfv—A Graphical Viewer Library
               libpfmpk—A Configuration-Import Library
           X and IRIS IM
           Porting from IRIS GL to OpenGL
         - Survey of Visual Simulation Techniques
               Low-Latency Image Generation
               Consistent Frame Rates
             - Rich Scene Content
                   Level of Detail Selection
                   Billboard Objects
                   Animation Sequences
             - Texture Mapping
                   Surface Appearance
                   Environment Mapping
                   Sophisticated Shading
                   Projective Texture
             - Character Animation
                   Generalized Morphing
                   Skeleton Animation
                   Total Animation
               Database Construction
 - Part II. Programming with OpenGL Performer
     - Chapter 3. 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 Clas ses
               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 4. Introduction to OpenGL Performer Concepts
         - Scene-to-Screen Path
             - Scene Graph
                   Scene Graph Hierarchy
                   Scene Graph Traversers
             - Channels
                   Pipe and Window
                   Starting the Stages
                   Rendering the Scene
                   Display Lists
         - Parts of a Performer Application
             - Initializing Performer
                   Shared Memory Arena
               Creating the Pipe, Channel, and Pipe Window
               Loading the Scene Graph
               Positioning the Channel
               Creating the Simulation Loop
         - Inputting and Reading User Events
             - Implementing User Input with Window Events
                   Initializing the Utility Library
                   Enabling User Input
               Retrieving User Events
     - Chapter 5. Creating a Display with pfChannel
         - Creating and Configuring a pfChannel
               Acquiring a pfPipe
               Creating a pfChannel Rendered by a pfPipe
               Creating and Configuring a pfPipeWindow
               Attaching a pfScene to the pfChannel
               Configuring a Viewport for the pfChannel
               Creating a Background for a pfChannel
         - Initializing the pfChannel View
               Bounding Volumes
             - Defining the Viewing Frustum
                   Near and Far Clip Planes
                   Height and Width of the View Frustum
                   Direction and Position of the View
         - Channel Callbacks
               Using Passthrough Data
               Channel Callback Example
         - Using Multiple Channels
               Grouping Channels
             - Choosing the Attributes to Share
                   Attribute Mask
               Using View Offsets
         - Multiple Pipes
               Setting the Multiprocessing Configuration
               Creating Multiple pfPipes
     - Chapter 6. Creating Scene Graphs
         - What Is a Node?
               Node Attributes
         - Scene Graph Nodes
             - Group Nodes
                   OpenGL Performer Group Nodes
               Leaf Nodes
         - Creating a Scene Graph
               Creating and Attaching the pfScene Node
               Adding Nodes in a Scene Graph
               Removing Nodes from a Scene Graph
               Arrangement of Nodes
         - Loading a Scene Graph
               Finding Scene Graph Files
           Saving a Scene Graph
         - Scene Graph Traversals
               Pipelined Traversals
               Traversal Order
         - Customizing OpenGL Performer Traversals
             - Setting Up Node Callbacks
                   Passing Data to Traversal Callback Functions
                   Return Values for Traversal Callback Functions
               Sample Customized Traversals
     - Chapter 7. Creating Geometry with pfGeoSets
           pfGeoSet Overview
         - Creating a pfGeoSet
               Creating a pfGeoSet Object
               Setting the Primitive Type
               Setting the Number of Primitives
               Setting the Number of Vertices Per Stripped Primitive
         + Attributes of pfGeoSet Primitives
           Placing Geometry in a Scene Graph
         - Creating Common Geometric Objects
               Utilities to Create Common Geometric Objects
     - Chapter 8. Specifying the Appearance of Geometry with pfState and pfGeoState
         - Setting the Graphics State
               Global State
             - Defining a pfGeoState
                   Setting pfGeoState Values for a Scene
                   pfGeoStates and pfGeoSets
                   Optimizing Graphics State Changes
             - Setting Modal pfGeoState Values
                   Alpha Func Modes
               Setting pfGeoState Attributes
         - Using Textures
               Enabling Texture Mapping
               Creating a Texture Object
             - Loading an Image as a Texture
                   Preloading Textures
               Specifying Texture Attribute
               Specifying Texture Formats
               Setting the Texture Environment
               Setting the Texture Coordinates
         - Specifying the Material
             - Specifying the Color and Shininess
                   Color Mode
                   Material Side
           Specifying Lighting
     - Chapter 9. Placing Geometry in a Scene
         - World Space and Object Space
               Transformation Node Isolation
               World Space
         - Transformation Nodes
               Transformation Node Functionality
               Ordering Transformation Nodes in the Scene Graph
         - Using pfFCS
               pfFCS, pfFlux, and pfEngine Example
         - Using DCS Nodes
               Creating a DCS Node
             - Setting the DCS Node
                   Using pfDCSCoord
               Optimizing the Use of DCS Nodes
         - Using SCS Nodes
               Creating a SCS Node
             - Setting the SCS Node
                   Setting the First Transformation Matrix
                   Setting the Remaining Transformation Matrices
             - Optimizing SCS Transformations
     - Chapter 10. Controlling Frame Rate
           Double Buffering
         - Specifying a Target Frame Rate
         - Frame Synchronization
               Phase Control
         - Adjusting the Frame Rate Automatically
               Stress Filters
             - Dynamic Video Resolution
                   Setting the DVR Stress Filter
     - Chapter 11. Multiprocessing
         - OpenGL Performer Stages
             - Optional, Asynchronous Stages
                   ISECT Stage
                   DBASE Stage
                   COMPUTE Stage
           Benefits of Multiprocessing
           Shared Memory
           Printing Process States
         - Setting Up Multiprocessing
               Multiprocessing Models
               Common Multiprocessing Models
             - Default Processing Models
                   One pfPipe
                   Multiple pfPipes
               Choosing a Multiprocessing Model
           Automatic Multiprocessing
     - Chapter 12. Database Paging
           Anticipating Paging
         - Database Process
               Handling Memory for the DBASE Process
             - Changing the Scene Graph
                   Caching Scene Graph Changes
                   Linking Buffer Changes to the Scene Graph
                   Deleting Old Data
                   Merging Changes
                   Cleaning Up the Cache
     - Chapter 13. Intersection Testing
           Creating an ISECT Process
         + Constructing a Segment Set for pfNodeIsectSegs()
         - Testing for Intersections
             - Intersection Information
                   Determining If a Segment Was Hit
                   Testing for Valid Information
                   Retrieving the Intersection Location
     - Chapter 14. Creating a User Interface
         - Traveling through a Scene
               Creating a Transformer
               Initializing the Transformer
               Setting Up Transformer Input and Output
               Updating the Channel
               Scaling the Motion
           Example of Implementing User Interaction
     - Chapter 15. Optimizing Performance
         - General Performance Tips
               Displaying Statistics
               Rendering the Statistics Tool
               Specifying the Statistics to Gather
               Reducing Bottlenecks
         - Culling Unseen Shapes
             - CULL Process
                   Evaluating Bounding Spheres
                   Optimizing the CULL Process
               Face Culling
             - Rendering Slices of Shapes
                   Rotating the Slice
         - Maintaining Frame Rate Using D VR
               DVR Scaling
         - Level of Detail Reduced for Performance
             - Choosing a Child Node Based on Range
                   Setting the Range
                   Disregarding LODs
             - Transitioning Between Levels of Detail
                   Enabling Fading
                   Customizing the Fade
               Customizing LOD Actions
               Scaling LOD Ranges
               Overriding Stress Effects
               Selecting LODs Based on Viewport
         - Reducing System Stress
             - Setting the Stress Filter
                   Stress Volatility
                   Dividing Rendering Time
                   Setting the Stress Value Explicitly
         - Optimizing Geometry Performance
               Using the Scene Graph Optimizer
               Using Display Lists
         - Optimizing Graphics State Changes
               Sharing Common pfGeoStates
               Computing the Optimal, Global Graphics State
           Optimizing Texture Handling
         - Optimizing File Loading
 - Appendix A. Building a Visual Simulation Application Using libpf
     - Setting Up the Basic Elements
           Using OpenGL Performer Header Files
         - Initializing and Configuring OpenGL Performer
               Initializing Shared Memory
               Initializing Processes
           Setti ng Up a Pipe
           Frame Rate and Synchronization
           Setting Up a Channel
         - Creating and Loading a Scene Graph
               Creating a Database
               Setting the Search Path for Database Files
           Simulation Loop
     - Compiling and Linking OpenGL Performer Applications
           Required Libraries
           Dynamic Shared Objects (DSOs)
           Debug and Static Libraries
           Using Compiler Flags
           MIPS-3, MIPS-4, and 64-Bit Compilation
           Using OpenGL Performer From C++
 - Appendix B. 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
   Appendix C. Image Gallery

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

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