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:
  • For additional (related) books, see the Hardware collection...

  • Linux  »  Books  »  Developer  »  
    OpenGLŪ on Silicon Graphics Systems
    (document number: 007-2392-003  /  published: 2005-03-31)   additional info | download

    OpenGL on Silicon Graphics Systems describes how to use the OpenGL graphics library on Silicon Graphics visualization systems. The guide expands the description of OpenGL programming presented in the OpenGL Programming Guide. This guide describes integrating OpenGL programs with the X Window System, using OpenGL extensions, debugging OpenGL programs, and achieving maximum performance on different hardware. This version of the guide has been updated for OpenGL 1.3 and includes new extensions and performance tips for new 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
           Silicon Graphics Visualization Systems
           What This Guide Contains
           What You Should Know Before Reading This Guide
           Background Reading
           OpenGL and Associated Tools and Libraries
           X Window System: Xlib, X Toolkit, and OSF/Motif
           Other Sources
           Obtaining Publications
         - Conventions Used in This Guide
               Typographical Conventions
               Function Naming Conventions
           Reader Comments
     - Chapter 1. OpenGL on Silicon Graphics Systems
         - Using OpenGL with the X Window System
               GLX Extension to the X Window System
             - Libraries, Tools, Toolkits, and Widget Sets
                   Open Inventor
                   IRIS ViewKit
                   IRIS IM Widget Set
                   Xlib Library
               Porting Applications between IRIX and Linux
           Extensions to OpenGL
         - Debugging and Performance Optimization
               Debugging Your Program
               Maximizing Performance With OpenGL Performer
           Location of Example Source Code (IRIX-Specific)
     - Chapter 2. OpenGL and X: Getting Started
         - Background and Terminology
             - X Window System on Silicon Graphics Systems
                   Silicon Graphics X Servers
                   GLX Extension to X
                   Compiling With the GLX Extension
             - X Window System Concepts
                   GLX and Overloaded Visuals
                   GLX Drawables—Windows and Pixmaps
                   Rendering Contexts
                   Resources As Server Data
                   X Window Colormaps
         - Libraries, Toolkits, and Tools
             - Widgets and the Xt Library
                   Xt Library
                   For More Information About Xt
               Other Toolkits and Tools
         - Integrating Your OpenGL Program With IRIS IM
               Simple Motif Example Program
             - Looking at the Example Program
                   Opening the X Display
                   Selecting a Visual
                   Creating a Rendering Context
                   Creating the Window
                   Binding the Context to the Window
                   Mapping the Window
           Integrating OpenGL Programs With X—Summary
         - Compiling With OpenGL and Related Libraries
               Link Lines for Individual Libraries
               Link Lines for Groups of Libraries
     - Chapter 3. OpenGL and X: Examples
         - Using Widgets
               About OpenGL Drawing-Area Widgets
             - Drawing-Area Widget Setup and Creation
                   Setting Up Fallback Resources
                   Creating the Widgets
                   Choosing the Visual for the Drawing-Area Widget
                   Creating Multiple Widgets With Identical Characteristics
                   Using Drawing-Area Widget Callbacks
             - Input Handling With Widgets and Xt
                   Background Information
                   Using the Input Callback
                   Using Actions and Translations
               Creating Colormaps
             - Widget Troubleshooting
                   Keyboard Input Disappears
                   Inheritance Issues
         - Using Xlib
               Simple Xlib Example Program
             - Creating a Colormap and a Window
                   Installing the Colormap
             - Xlib Event Handling
                   Handling Mouse Events
                   Exposing a Window
           Using Fonts and Strings
     - Chapter 4. OpenGL and X: Advanced Topics
         - Using Animations
               Swapping Buffers
             - Controlling an Animation With Workprocs
                   General Workproc Information
                   Workproc Example
               Controlling an Animation With Timeouts
         - Using Overlays
               Introduction to Overlays
               Creating Overlays
               Overlay Troubleshooting
               Rubber Banding
               Using Popup Menus With the GLwMDrawingArea Widget
         - Using Visuals and Framebuffer Configurations
               Some Background on Visuals
               Running OpenGL Applications Using a Single Visual
             - Using Framebuffer Configurations
                   Describing a Drawable With a GLXFBConfig Construct (FBConfig)
                   Less-Rigid Similarity Requirements When Matching Context and Drawable
                   Less-Rigid Match of GLX Visual and X Visual
                   FBConfig Constructs
                   How an FBConfig Is Selected
               Related Functions
         - Using Colormaps
             - Background Information About Colormaps
                   Color Variation Across Colormaps
                   Multiple Colormap Issues
               Choosing Which Colormap to Use
               Colormap Example
         - Stereo Rendering
               Stereo Rendering Background Information
               Performing Stereo Rendering
         + Using Pixel Buffers
         - Using Pixmaps
               Creating and Using Pixmaps
               Direct and Indirect Rendering
           Performance Considerations for X and OpenGL
           Portability
     - Chapter 5. Introduction to OpenGL Extensions
         - Determining Extension Availability
               How to Check for OpenGL Extension Availability
               Example Program: Checking for Extension Availability
               Checking for GLX Extension Availability
         - ARB_get_proc_address—The Dynamic Query-Function-Pointer Extension
               The glXGetProcAddressARB() Function
               Extension Wrapper Libraries and Portability Notes
         - Finding Information About Extensions
               Man Pages
               Example Programs
               Extension Specifications
     - Chapter 6. Resource Control Extensions
         - EXT_import_context—The Import Context Extension
               Importing a Context
               Retrieving Display and Context Information
               New Functions
         - SGI_make_current_read—The Make Current Read Extension
               Read and Write Drawables
               Possible Match Errors
               Retrieving the Current Drawable's Name
               New Functions
         - EXT_visual_info—The Visual Info Extension
               Using the Visual Info Extension
               Using Transparent Pixels
         - EXT_visual_rating—The Visual Rating Extension
               Using the Visual Rating Extension
           SGIX_fbconfig—The Framebuffer Configuration Extension
           SGIX_pbuffer—The Pixel Buffer Extension
     - Chapter 7. Vertex Processing Extensions
         - ARB_vertex_buffer_object—The Vertex Buffer Object Extension
               Why Use Buffer Objects?
               Alternatives to Buffer Objects
               Disadvantages of Buffer Objects
             - Using Buffer Objects
                   Defining Buffer Objects
                   Defining and Editing Buffer Object Contents
                   Mapping Buffer Objects to Application Memory
                   Using Buffer Objects as Vertex Array Sources
                   Using Buffer Objects as Array Indices
                   Querying Data in Buffer Objects
                   Sample Code
               New Functions
         - ARB_window_pos—The Window-Space Raster Position Extension
               Why Use the Window-Space Raster Position Extension?
               Using the Window-Space Raster Position Extenstion
               New Functions
         - EXT_clip_volume_hint—The Clip Volume Hint Extension
               Why Use Clip Volume Hints?
               Using Clip Volume Hints
         - EXT_compiled_vertex_array—The Compiled Vertex Array Extension
               Why Use Compiled Vertex Arrays?
               Using Compiled Vertex Arrays
               New Functions
         - EXT_fog_coord—The Fog Coordinate Extension
               Why Use Fog Coordinates?
               Using Fog Coordinates
               Querying the Fog Coordinate State
               New Functions
         - EXT_multi_draw_arrays—The Multiple Draw Arrays Extension
               Why Use Multiple Draw Arrays?
               Using Multiple Draw Arrays
               New Functions
         - EXT_secondary_color—The Secondary Color Extension
               Why Use Secondary Color?
               Using Secondary Color
               Querying the Secondary Color State
               New Functions
         - The Vertex Array Object Extensions (Legacy)
               New Functions
           The Texture Coordinate Generation Extensions (Legacy)
     - Chapter 8. Texturing Extensions
         - ATI_texture_env_combine3—New Texture Combiner Operations Extension
               Why Use Texture Combiners?
               Using The New Texture Combiner Operations
         - ATI_texture_float—The Floating Point Texture Extension
               Why Use Floating Point Textures?
               Using Floating Point Textures
         - ATI_texture_mirror_once—The Texture Mirroring Extension
               Why Use Texture Mirroring?
               Using Texture Mirroring
         - EXT_texture_compression_s3tc—The S3 Compressed Texture Format Extension
               Why Use S3TC Texture Formats?
               Using S3TC Texture Formats
               Constraints on S3TC Texture Formats
         - EXT_texture_filter_anisotropic—The Anisotropic Texture Filtering Extension
               Why Use Anisotropic Texturing?
               Using Anisotropic Texturing
         - EXT_texture_rectangle—The Rectangle Texture Extension
               Why Use Rectangle Textures?
               Using Rectangle Textures
         - EXT_texture3D—The 3D Texture Extension
               Why Use the 3D Texture Extension?
               Using 3D Textures
               3D Texture Example Program
               New Functions
         - SGI_texture_color_table—The Texture Color Table Extension
               Why Use a Texture Color Table?
               Using Texture Color Tables
               Texture Color Table and Internal Formats
               Using Texture Color Table On Different Platforms
         - SGIS_detail_texture—The Detail Texture Extension
             - Using the Detail Texture Extension
                   Creating a Detail Texture and a Low-Resolution Texture
                   Detail Texture Computation
                   Customizing the Detail Function
                   Using Detail Texture and Texture Object
               Detail Texture Example Program
               New Functions
         - SGIS_filter4_parameters—The Filter4 Parameters Extension
               Using the Filter4 Parameters Extension
         - SGIS_point_line_texgen—The Point or Line Texture Generation Extension
               Why Use Point or Line Texture Generation
         - SGIS_sharpen_texture—The Sharpen Texture Extension
             - About the Sharpen Texture Extension
                   How to Use the Sharpen Texture Extension
                   How Sharpen Texture Works
                   Customizing the LOD Extrapolation Function
                   Using Sharpen Texture and Texture Object
               Sharpen Texture Example Program
               New Functions
         - SGIS_texture_edge/border_clamp—Texture Clamp Extensions
               Texture Clamping Background Information
               Why Use the Texture Clamp Extensions?
               Using the Texture Clamp Extensions
         - SGIS_texture_filter4—The Texture Filter4 Extensions
             - Using the Texture Filter4 Extension
                   Specifying the Filter Function
                   Determining the weights Array
                   Setting Texture Parameters
               New Functions
         - SGIS_texture_lod—The Texture LOD Extension
               Specifying a Minimum or Maximum Level of Detail
               Specifying Image Array Availability
         - SGIS_texture_select—The Texture Select Extension
               Why Use the Texture Select Extension?
               Using the Texture Select Extension
         - SGIX_clipmap—The Clipmap Extension
             - Clipmap Overview
                   Clipmap Constraints
                   Why Do the Clipmap Constraints Work?
                   Clipmap Textures and Plain Textures
             - Using Clipmaps From OpenGL
                   Setting Up the Clipmap Stack
                   Updating the Clipmap Stack
             - Clipmap Background Information
                   Moving the Clip Center
                   Invalid Borders
                   Toroidal Loading
               Virtual Clipmaps
           SGIX_texture_add_env—The Texture Environment Add Extension
         - SGIX_texture_lod_bias—The Texture LOD Bias Extension
               Background: Texture Maps and LODs
               Why Use the LOD Bias Extension?
               Using the Texture LOD Bias Extension
           SGIX_texture_scale_bias—The Texture Scale Bias Extension
     - Chapter 9. Rendering Extensions
         - ATI_draw_buffers—The Multiple Draw Buffers Extension
               Why Use Multiple Draw Buffers?
               Using Multiple Draw Buffers
               New Function
         - ATI_separate_stencil—The Separate Stencil Extension
               Why Use the Separate Stencil Extension?
               Using the Separate Stencil Extension
               New Functions
         - NV_point_sprite—The Point Sprite Extension
               Why Use Point Sprites?
               Using Point Sprites
         - NV_occlusion_query—The Occlusion Query Extension
               Why Use Occlusion Queries?
               Using the NV_occlusion_query Extension
               New Functions
         - Blending Extensions
             - Constant Color Blending Extension
                   Using Constant Colors for Blending
                   New Functions
             - Minmax Blending Extension
                   Using a Blend Equation
                   New Functions
               Blend Subtract Extension
         - SGIS_fog_function—The Fog Function Extension
               FogFunc Example Program
               New Function
           SGIS_fog_offset—The Fog Offset Extension
         - The Multisample Extension
             - Introduction to Multisampling
                   When to Use Multisampling
               Using the Multisample Extension
             - Using Advanced Multisampling Options
                   Color Blending and Screen Door Transparency
                   Using a Multisample Mask to Fade Levels of Detail
                   Accumulating Multisampled Images
             - How Multisampling Affects Different Primitives
                   Multisampled Points
                   Multisampled Lines
                   Multisampled Polygons
                   Multisample Rasterization of Pixels and Bitmaps
               New Functions
         - The Point Parameters Extension
               Using the Point Parameters Extension
               Point Parameters Example Code
               Point Parameters Background Information
               New Procedures and Functions
         - SGIX_reference_plane—The Reference Plane Extension
               Why Use the Reference Plane Extension?
               Using the Reference Plane Extension
               New Function
         - The Shadow Extensions
               Shadow Extension Overview
               Creating the Shadow Map
               Rendering the Application From the Normal Viewpoint
               Using the Shadow Ambient Extension
         - SGIX_sprite—The Sprite Extension
               Available Sprite Modes
               Using the Sprite Extension
               New Function
     - Chapter 10. Imaging Extensions
         - Introduction to Imaging Extensions
               Platform Dependencies
               Where Extensions Are in the Imaging Pipeline
             - Pixel Transfer Paths
                   Convolution, Histogram, and Color Table in the Pipeline
                   Interlacing and Pixel Texture in the Pipeline
               Merging the Geometry and Pixel Pipeline
               Pixel Pipeline Conversion to Fragments
               Functions Affected by Imaging Extensions
           EXT_abgr—The ABGR Extension
         - EXT_convolution—The Convolution Extension
               Performing Convolution
               Retrieving Convolution State Parameters
               Separable and General Convolution Filters
               New Functions
         - EXT_histogram—The Histogram and Minmax Extensions
               Using the Histogram Extension
               Using the Minmax Part of the Histogram Extension
               Using Proxy Histograms
               New Functions
         - EXT_packed_pixels—The Packed Pixels Extension
               Why Use the Packed Pixels Extension?
               Using Packed Pixels
               Pixel Type Descriptions
           SGI_color_matrix—The Color Matrix Extension
         - SGI_color_table—The Color Table Extension
               Why Use the Color Table Extension?
               Specifying a Color Table
               Using Framebuffer Image Data for Color Tables
               Lookup Tables in the Image Pipeline
               New Functions
         - SGIX_interlace—The Interlace Extension
               Using the Interlace Extension
         - SGIX_pixel_texture—The Pixel Texture Extension
               Platform Issues
               New Functions
     - Chapter 11. Video Extensions
         - SGI_swap_control—The Swap Control Extension
               New Functions
         - SGI_video_sync—The Video Synchronization Extension
               Using the Video Sync Extension
               New Functions
         - SGIX_swap_barrier—The Swap Barrier Extension
               Why Use the Swap Barrier Extension?
             - Using the Swap Barrier Extension
                   Buffer Swap Conditions
               New Functions
         - SGIX_swap_group—The Swap Group Extension
               Why Use the Swap Group Extension?
               Swap Group Details
               New Function
         - SGIX_video_resize—The Video Resize Extension
               Controlling When the Video Resize Update Occurs
               Using the Video Resize Extension
               Example
               New Functions
     - Chapter 12. Miscellaneous OpenGL Extensions
         - GLU_EXT_NURBS_tessellator—The NURBS Tessellator Extension
               Using the NURBS Tessellator Extension
               Callbacks Defined by the Extension
           GLU_EXT_object_space—The Object Space Tess Extension
         - SGIX_list_priority—The List Priority Extension
               Using the List Priority Extension
               New Functions
         - SGIX_instruments—The Instruments Extension
               Why Use SGIX_instruments?
             - Using the Extension
                   Specifying the Buffer
                   Enabling, Starting, and Stopping Instruments
                   Measurement Format
                   Retrieving Information
               Instruments Example Pseudo Code
               New Functions
     - Chapter 13. Vertex and Fragment Program Extensions
         - The Vertex and Fragment Program Extensions
               Why Use Pipeline Programs?
               Alternatives to Pipeline Programs
         - Using Pipeline Programs
             - Managing Pipeline Programs
                   Binding Programs
                   Defining and Enabling Programs
               How Programs Replace Fixed Functionality
             - Structure of Pipeline Programs
                   Program Options
                   Naming Statements
                   Program Instructions
               Pipeline Program Input and Output
             - Vertex and Fragment Attributes
                   Vertex Attributes
                    Fragment Attributes
             - Vertex and Fragment Program Parameters
                   Program Environment and Local Parameters
                   OpenGL State Parameters
             - Vertex and Fragment Program Output
                   Vertex Program Output
                   Fragment Program Output
               Program Parameter Specification
             - Generic Vertex Attribute Specification
                   Commands
                   Attribute Aliasing
               Generic Program Matrix Specification
             - Program Instruction Summary
                   Fragment and Vertex Program Instructions
                   Fragment Program Instructions
                   Vertex Program Instructions
               Program Resource Limits and Usage
             - Other Program Queries
                   Program String Length, Program String Format, and Program String Name
                   Source Text
                   Parameters of the Generic Vertex Attribute Array Pointers
             - Sample Code
                   Sample Vertex Program
                   Sample Fragment Programs
               Errors
               New Functions
         - The Legacy Vertex and Fragment Program Extensions
               How to Use the Legacy Extensions
               New Functions
     - Chapter 14. OpenGL Tools
           Platform Notes
         - ogldebug—The OpenGL Debugger
             - ogldebug Overview
                   How ogldebug Operates
             - Getting Started With ogldebug
                   Setting Up ogldebug
                   ogldebug Command-Line Options
                   Starting ogldebug
             - Interacting With ogldebug
                   Commands for Basic Interaction
                   Using Check boxes
               Creating a Trace File to Discover OpenGL Problems
               Using a Configuration File
             - Using Menus to Interact With ogldebug
                   Using the File Menu to Interact With ogldebug
                   Using the Commands Menu to Interact With Your Program
                   Using the Information Menu to Access Information
                   Using the References Menu for Background Information
           The OpenGL Character Renderer (GLC)
         - The OpenGL Stream Utility (GLS)
               OpenGL Stream Utility Overview
               glscat Utility
           glxinfo—The glx Information Utility
     - Chapter 15. Tuning Graphics Applications: Fundamentals
           General Tips for Debugging Graphics Programs
         - Specific Problems and Troubleshooting
               Blank Window
               Rotation and Translation Problems
               Depth Buffering Problems
               Animation Problems
               Lighting Problems
               X Window System Problems
               Pixel and Texture Write Problems
               System-Specific Problems
         - About Pipeline Tuning
               A Three-Stage Model of the Graphics Pipeline
               Isolating Bottlenecks in Your Application: Overview
               Factors Influencing Performance
         - Taking Timing Measurements
               Benchmarking Basics
               Achieving Accurate Timing Measurements
               Achieving Accurate Benchmarking Results
         - Tuning Animation
               How Frame Rate Determines Animation Speed
               Optimizing Frame Rate Performance
     - Chapter 16. Tuning the Pipeline
         - CPU Tuning: Basics
               Immediate Mode Drawing Versus Display Lists and Vertex Buffer Objects
           CPU Tuning: Display Lists
         - CPU Tuning: Immediate Mode Drawing
               Optimizing the Data Organization
             - Optimizing Database Rendering Code
                   Examples for Optimizing Data Structures for Drawing
                   Examples for Optimizing Program Structure
                   Using Specialized Drawing Subroutines and Macros
                   Preprocessing Drawing Data (Meshes and Vertex Loops)
         - Optimizing Cache and Memory Use
               Memory Organization
             - Minimizing Paging
                   Minimizing Lookups
                   Minimizing Cache Misses
                   Measuring Cache-Miss and Page-Fault Overhead
         - CPU Tuning: Advanced Techniques
               Mixing Computation With Graphics
               Examining Assembly Code
               Using Additional Processors for Complex Scene Management
               Modeling to the Graphics Pipeline
         - Tuning the Geometry Subsystem
               Using Peak-Performance Primitives for Drawing
               Using Vertex Arrays
               Using Display Lists Appropriately
               Storing Data Efficiently
               Minimizing State Changes
               Optimizing Transformations
             - Optimizing Lighting Performance
                   Lighting Operations With Noticeable Performance Costs
               Choosing Modes Wisely
               Advanced Transform-Limited Tuning Techniques
         - Tuning the Raster Subsystem
               Using Backface/Frontface Removal
             - Minimizing Per-Pixel Calculations
                   Avoiding Unnecessary Per-Fragment Operations
                   Organizing Drawing to Minimize Computation
                   Using Expensive Per-Fragment Operations Efficiently
                   Using Depth Buffering Efficiently
                   Balancing Polygon Size and Pixel Operations
                   Other Considerations
               Using Clear Operations
               Optimizing Texture Mapping
           Tuning the Imaging Pipeline
     - Chapter 17. Tuning Graphics Applications: Examples
           Drawing Pixels Fast
         - Tuning Example
             - Testing for CPU Limitation
                   Using the Profiler
               Testing for Fill Limitation
             - Working on a Geometry-Limited Program
                   Smooth Shading Versus Flat Shading
                   Reducing the Number of Polygons
               Testing Again for Fill Limitation
     - Chapter 18. System-Specific Tuning
           Introduction to System-Specific Tuning
         - Optimizing Performance on InfiniteReality Systems
               Managing Textures on InfiniteReality Systems
               Offscreen Rendering and Framebuffer Management
               Optimizing State Changes
               Miscellaneous Performance Hints
         - Optimizing Performance on Onyx4 and Silicon Graphics Prism Systems
               Geometry Optimizations: Drawing Vertices
               Texturing Optimizations: Loading and Rendering Texture Images
               Pixel Optimizations: Reading and Writing Pixel Data
               Differences Between Onyx4 and Silicon Graphics Prism Systems
       Appendix A. Benchmarks
     - Appendix B. Benchmarking Libraries: libpdb and libisfast
           Libraries for Benchmarking
         - Using libpdb
               Example for pdbReadRate()
               Example for pdbMeasureRate()
               Example for pdbWriteRate()
           Using libisfast
     - Appendix C. System Support for OpenGL Versions and Extensions
           OpenGL Core Versions
           OpenGL Extensions
           GLX Extensions
     - Appendix D. XFree86 Configuration Specifics
         - Configuring a System for Stereo
               Example “Device” Section for Stereo
               Sample Stereo Mode Entries
               Example “Monitor” Section for Stereo
               Example “Screen” Section for Stereo
         - Configuring a System for Full-Scene Antialiasing
               Example “Device” Section for Full-Scene Antialiasing
         - Configuring a System for Dual-Channel Operation
               Example “Device” Section for Dual Channel
         - Enabling Overlay Planes
               Example “Device” Section to Enable Overlay Planes
           Configuring a System for External Genlock or Framelock
         - Configuring Monitor Positions
               Example “ServerLayout” Section for Four Monitors in a Line
               Example “ServerLayout” Section for Four Monitors in a Square
         - Configuring Monitor Types
               Example “Device” Section for Use With Two Analog Monitors
         - Configuring a System for Multiple X Servers
               Identifying Event Devices
             - Creating a Multi-Seat XF86Config File
                   Creating a New XF86Config File
                   Configuring the Input Devices
                   Configuring the New ServerLayout Sections
               Example “ServerLayout” Sections for Three X Servers
               Pointing X to the New XF86Config-Nserver File
               Example /etc/X11/xdm/gdm.conf Servers Section for Three X Servers
       Index


    home/search | what's new | help