SGI Techpubs Library
Techpubs Library
Home/Search
Books by Product
What's New
Help


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
       Conventions
       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
                   Flying
                   Trackball
                   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
                   Display
                   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
                   Intersections
                   Color Tables (pfColortable)
                   Light Points
                   pfObjects
                   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
                   Antialiasing
             - Texture Mapping
                   Surface Appearance
                   Environment Mapping
                   Sophisticated Shading
                   Projective Texture
             - Character Animation
                   Morphing
                   Generalized Morphing
                   Skeleton Animation
                   Total Animation
               Database Construction
 - Part II. Programming with OpenGL Performer
     - Chapter 3. OpenGL Performer Programming Interface
         - General Naming Conventions
               Prefixes
               Header Files
               Naming in C and C++
               Abbreviations
               Macros, Tokens, and Enums
         - Class API
               O bject Creation
               Set Routines
             + Get Routines
               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
               Setting the Attributes
               Attribute Bindings
               Indexed Arr ays
               Packed Attributes
               Drawing and Printing a pfGeoSet
           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
                   pfTransparency
                   pfDecal
                   pfAlphaFunc
                   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
                   pfFlatten
                   pfdCleanTree
     - Chapter 10. Controlling Frame Rate
           Double Buffering
         - Specifying a Target Frame Rate
               pfFrameRate
               pfFieldRate
         - 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()
               Setting the Mode
               Intersection Masks
               Creating the Segment Array
               The pfSegSet Bound
         - 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
               pfconv
               pficonv
 - Appendix A. Building a Visual Simulation Application Using libpf
       Overview
     - 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
       Performance
     - 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
       Overview
       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
   Glossary
   Index


home/search | what's new | help