- -g compiler option
- CPU Tuning: Basics
- -mips3
- CPU Tuning: Basics
- -S compiler option
- Examining Assembly Code
- -sync flag
- Inheritance Issues
- 3D texture extension
- pixel storage modes
- Using 3D Textures
- 3D texture extension
- EXT_texture3D—The 3D Texture Extension
- mipmapping
- Using 3D Textures
- 4D texture extension
- SGIS_texture4D—The 4D Texture Extension
- 4Dwm
- Using OpenGL With the X Window System
- 60-Hz monitor
- How Frame Rate Determines Animation Speed
- ABGR extension
- EXT_abgr—The ABGR Extension
- accumulated multisampling
- Accumulating Multisampled Images
- accumulation buffer
- Choosing Features for Optimum Performance
- actions and translations
- Using Actions and Translations
- Using Actions and Translations
- Background Information
- adding callbacks
- Using Drawing-Area Widget Callbacks
- advanced multisampling options
- Using Advanced Multisampling Options
- AllocAll
- Creating a Colormap and a Window
- AllocNone
- Creating a Colormap and a Window
- alpha blending
- Choosing Features for Optimum Performance
- alpha blending
- Using Expensive Per-Fragment Operations Efficiently
- Optimizing Per-Fragment Operations on Mid-Range Systems
- alpha component
- representing complex geometry
- Advanced Transform-Limited Tuning Techniques
- alpha function
- Choosing Features for Optimum Performance
- alpha value used as multisample mask
- Using Advanced Multisampling Options
- alpha-blending transparency
- Optimizing Multisampling and Transparency
- ancillary buffers
- GLX and Overloaded Visuals
- PBuffers and Pixmaps
- Less-Rigid Similarity Requirements When Matching Context and Drawable
- Creating a PBuffer
- animations
- avoiding flickering
- Using Animations
- benchmarking
- Achieving Accurate Timing Measurements
- clear operations
- How Frame Rate Determines Animation Speed
- controlling with workprocs
- Controlling an Animation With Workprocs
- double buffering
- Tuning Animation
- glXSwapBuffers
- Optimizing Frame Rate Performance
- swapping buffers
- Swapping Buffers
- animations
- Using Animations
- debugging
- Animation Problems
- frame rate
- How Frame Rate Determines Animation Speed
- optimizing frame rates
- Optimizing Frame Rate Performance
- speed
- How Frame Rate Determines Animation Speed
- tuning
- Tuning Animation
- ANSI C
- See also compiling.
- Examples for Optimizing Program Structure
- ANSI C
- prototyping subroutines
- Examples for Optimizing Program Structure
- antialiased lines. See antialiasing.
- General Tips for Performance Improvement
- antialiasing
- lines
- Some IRIS GL Functionality and OpenGL Equivalents
- lines
- Optimizing Line Drawing
- antialiasing
- lines
- Choosing Features for Optimum Performance
- Multisampled Lines
- Optimizing Rasterization
- General Tips for Performance Improvement
- Optimizing Geometry Operations on Mid-Range Systems
- multisampling
- SGIS_multisample—The Multisample Extension
- app-defaults file
- Using the Input Callback
- Setting Up Fallback Resources
- Choosing the Visual for the Drawing-Area Widget
- arrays, traversal
- Examples for Optimizing Data Structures for Drawing
- assembly code
- Using Specialized Drawing Subroutines and Macros
- Examining Assembly Code
- Athena widget set
- Widgets and the Xt Library
- attributes
- of widgets
- Setting Up Fallback Resources
- attributes
- of drawing-area widget
- Choosing the Visual for the Drawing-Area Widget
- available extensions
- Silicon Graphics X Server
- backbuffer (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- backdrop
- Mixing Computation With Graphics
- backface removal
- Using Backface/Frontface Removal
- Using Backface/Frontface Removal
- backing store
- Exposing a Window
- BadAlloc error
- Creating a PBuffer
- Overlay Troubleshooting
- BadMatch error
- Creating a Colormap and a Window
- Creating and Using Pixmaps
- Inheritance Issues
- Creating a PBuffer
- finding problem
- Inheritance Issues
- make current read extension
- Possible Match Errors
- benchmarking
- clock resolution
- Achieving Accurate Timing Measurements
- loops
- Achieving Accurate Timing Measurements
- benchmarking
- Taking Timing Measurements
- and glFinish()
- Achieving Accurate Timing Measurements
- background processes
- Achieving Accurate Timing Measurements
- basics
- Benchmarking Basics
- example program
- Benchmarks
- instruments extension
- SGIX_instruments—The Instruments Extension
- libraries
- Libraries for Benchmarking
- static frames
- Achieving Accurate Timing Measurements
- billboards
- sprite extension
- SGIX_sprite—The Sprite Extension
- billboards
- Modeling to the Graphics Pipeline
- binding context to window
- Binding the Context to the Window
- bitmap fonts
- Using Fonts and Strings
- BlackPixel() color macro
- Color Variation Across Colormaps
- blank window
- Blank Window
- blend subtract extension
- Blend Subtract Extension
- blendcolor (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- blendfunction (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- blending
- and multisampling
- Using Advanced Multisampling Options
- See also minmax blending extension, logical operator blending, constant color blending, alpha blending.
- Minmax Blending Extension
- blending
- constant color
- Constant Color Blending Extension
- extensions
- Blending Extensions
- blending factors
- Using Constant Colors for Blending
- Using Constant Colors for Blending
- block counting
- Measuring Cache-Miss and Page-Fault Overhead
- border clamping
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- border pixel
- Creating a Colormap and a Window
- bottlenecks
- geometry subsystem
- Isolating Bottlenecks in Your Application: Overview
- See also optimizing.
- About Pipeline Tuning
- tuning
- About Pipeline Tuning
- bottlenecks
- CPU
- Optimizing the Data Organization
- definition
- About Pipeline Tuning
- finding
- Isolating Bottlenecks in Your Application: Overview
- raster subsystem
- Isolating Bottlenecks in Your Application: Overview
- buffers
- accessed by loops
- Examples for Optimizing Program Structure
- accumulation
- Choosing Features for Optimum Performance
- depth
- Choosing Features for Optimum Performance
- instrument extension
- Specifying the Buffer
- See also ancillary buffers
- Accumulating Multisampled Images
- stencil
- Choosing Features for Optimum Performance
- synchronizing swaps
- SGIX_swap_group—The Swap Group Extension
- buffer clobber events
- Creating a PBuffer
- Directing the Buffer Clobber Event
- Rendering to a GLXPbuffer
- buffer swaps, synchronizing
- SGIX_swap_group—The Swap Group Extension
- buffers
- accumulation buffer for multisampling
- Accumulating Multisampled Images
- avoiding simultaneous traversal
- Minimizing Cache Misses
- pbuffer
- About GLXPbuffers
- swapping
- Swapping Buffers
- cache
- determining size
- Minimizing Cache Misses
- immediate mode drawing
- Optimizing the Data Organization
- cache
- definition
- Memory Organization
- minimizing misses
- Minimizing Cache Misses
- miss
- Memory Organization
- Optimizing the Data Organization
- calculating expected performance
- Benchmarking Basics
- Call Count menu command
- Using the Information Menu to Access Information
- callbacks
- expose
- Creating Overlays
- callbacks
- adding
- Using Drawing-Area Widget Callbacks
- drawing-area widget
- Using Drawing-Area Widget Callbacks
- expose
- Mapping the Window
- Using Drawing-Area Widget Callbacks
- init
- Mapping the Window
- Using Drawing-Area Widget Callbacks
- input
- Using Drawing-Area Widget Callbacks
- input
- Creating Overlays
- Using Drawing-Area Widget Callbacks
- resize
- Using Drawing-Area Widget Callbacks
- resize
- Using Drawing-Area Widget Callbacks
- Creating Overlays
- callbacks
- and current context
- Using Drawing-Area Widget Callbacks
- drawing-area widget
- Using Drawing-Area Widget Callbacks
- for NURBS object
- Using the NURBS Tessellator Extension
- in overlay
- Creating Overlays
- changing framezoom factor
- Low-End Specific Extensions
- character strings
- Using Fonts and Strings
- checking for extensions
- How to Check for OpenGL Extension Availability
- choosing colormaps
- Choosing Which Colormap to Use
- choosing visuals
- Selecting a Visual
- clamping
- border clamping
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- edge clamping
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- clear
- and multisampling
- Optimizing Multisampling and Transparency
- for debugging
- Blank Window
- optimizing on low-end systems
- Using the Pipeline Effectively
- optimizing on mid-range systems
- Optimizing Per-Fragment Operations on Mid-Range Systems
- performance tuning
- Mixing Computation With Graphics
- clearing bitplanes
- Using Clear Operations
- clipmaps
- clipped level
- Why Do the Clipmap Constraints Work?
- invalid borders
- Invalid Borders
- nonclipped level
- Why Do the Clipmap Constraints Work?
- tiles
- Moving the Clip Center
- toroidal loading
- Toroidal Loading
- updating stacks
- Updating the Clipmap Stack
- clipmap extension
- SGIX_clipmap—The Clipmap Extension
- clipmaps
- center
- Clipmap Textures and Plain Textures
- component diagram
- Clipmap Overview
- how to set up stack
- Setting Up the Clipmap Stack
- virtual
- Virtual Clipmaps
- clipped level
- Why Do the Clipmap Constraints Work?
- clipping
- debugging
- Blank Window
- mid-range systems
- Optimizing Geometry Operations on Mid-Range Systems
- optimizing on IMPACT
- General Tips for Performance Improvement
- clock resolution
- Achieving Accurate Timing Measurements
- color blending extension
- Constant Color Blending Extension
- color buffer clear
- with depth buffer clear
- Using Clear Operations
- color buffer clear
- influence on performance
- Benchmarking Basics
- color lookup tables
- 4D textures
- SGIS_texture4D—The 4D Texture Extension
- pixel texture
- SGIX_pixel_texture—The Pixel Texture Extension
- color macros
- Color Variation Across Colormaps
- color matrix
- and identity matrix
- Tuning the Imaging Pipeline
- color matrix
- and color mask
- Tuning the Imaging Pipeline
- extension
- SGI_color_matrix—The Color Matrix Extension
- color space conversions
- IMPACT
- Accelerating Color Space Conversion
- color table extension
- SGI_color_table—The Color Table Extension
- and copy texture
- Using Framebuffer Image Data for Color Tables
- color-index mode
- Background Information About Colormaps
- colormaps
- and drawing-area widget
- X Window Colormaps
- choosing
- Choosing Which Colormap to Use
- retrieving default
- Multiple Colormap Issues
- colormaps
- Color Variation Across Colormaps
- and overlays
- Overlay Troubleshooting
- creating
- Creating a Colormap and a Window
- default
- Color Variation Across Colormaps
- definition
- X Window Colormaps
- Background Information About Colormaps
- flashing
- Multiple Colormap Issues
- Running OpenGL Applications Using a Single Visual
- installing
- Installing the Colormap
- multiple
- Multiple Colormap Issues
- transparent cell
- Introduction to Overlays
- Xlib
- Colormap Example
- compiling
- -float option
- CPU Tuning: Basics
- -g option
- CPU Tuning: Basics
- -mips3, -mips4
- CPU Tuning: Basics
- display lists
- Immediate Mode Drawing Versus Display Lists
- CPU Tuning: Display Lists
- with -S
- Examining Assembly Code
- compiling
- -O2 option
- CPU Tuning: Basics
- optimizing
- CPU Tuning: Basics
- complex structures
- Immediate Mode Drawing Versus Display Lists
- concave polygons, optimizing
- Using Peak Performance Primitives for Drawing
- conditional statements
- Examples for Optimizing Program Structure
- configuration file for ogldebug
- Using a Configuration File
- constant color blending extension
- Constant Color Blending Extension
- constant color blending extension
- blending factors
- Using Constant Colors for Blending
- container widgets
- Creating the Widgets
- contexts
- current
- Rendering Contexts
- retrieving current display
- Retrieving Display and Context Information
- See also rendering contexts
- Creating a Rendering Context
- contexts
- and visuals
- Less-Rigid Similarity Requirements When Matching Context and Drawable
- binding to window
- Binding the Context to the Window
- created with GLXFBConfig
- Rendering to a GLXPbuffer
- convolution extension
- filter image height
- Retrieving Convolution State Parameters
- filter image width
- Retrieving Convolution State Parameters
- filter scale factors
- Retrieving Convolution State Parameters
- maximum filter image height
- Retrieving Convolution State Parameters
- maximum filter image width
- Retrieving Convolution State Parameters
- convolution extension
- EXT_convolution—The Convolution Extension
- and texture images
- Separable and General Convolution Filters
- border mode
- Retrieving Convolution State Parameters
- example
- Performing Convolution
- filter bias factors
- Retrieving Convolution State Parameters
- filter image width
- Retrieving Convolution State Parameters
- filter scale factors
- Retrieving Convolution State Parameters
- maximum filter image width
- Retrieving Convolution State Parameters
- on O2 systems
- Imaging Pipeline Using ICE
- separable filter
- Separable and General Convolution Filters
- convolution kernels
- Performing Convolution
- on IMPACT systems
- Using Images
- convolve (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- coordinate system
- X Window System Problems
- cpack IRIS GL format
- EXT_abgr—The ABGR Extension
- CPU bottlenecks
- checking in example program
- Testing for CPU Limitation
- eliminating from example program
- Using the Profiler
- from hierarchical data structures
- Optimizing the Data Organization
- memory paging
- Memory Organization
- testing for
- Isolating Bottlenecks in Your Application: Overview
- CPU stage of the pipeline
- Three-Stage Model of the Graphics Pipeline
- CPU usage bar
- Isolating Bottlenecks in Your Application: Overview
- creating drawing-area widgets
- About OpenGL Drawing-Area Widgets
- creating pixmaps
- Using Pixmaps
- creating rendering contexts
- Creating a Rendering Context
- Creating a Rendering Context
- culling
- Advanced Transform-Limited Tuning Techniques
- Optimizing the Data Organization
- current context
- Rendering Contexts
- customizing detail texture
- Customizing the Detail Function
- customizing sharpen texture
- Customizing the LOD Extrapolation Function
- data
- expansion in display lists
- Immediate Mode Drawing Versus Display Lists
- preprocessing
- Preprocessing Drawing Data: Introduction
- storage self-managed by display lists
- Immediate Mode Drawing Versus Display Lists
- word-aligned
- General Performance Tips
- data organization
- Optimizing the Data Organization
- balancing hierarchy
- Optimizing the Data Organization
- disadvantages of hierarchies
- Optimizing the Data Organization
- data traversal
- CPU Tuning: Basics
- remote rendering
- Immediate Mode Drawing Versus Display Lists
- data types used by packed pixels extension
- Using Packed Pixels
- database
- optimizing by preprocessing
- Preprocessing Drawing Data: Introduction
- optimizing traversal
- Optimizing Database Rendering Code
- DBE
- Swapping Buffers
- debugger See ogldebug.
- Using a Configuration File
- debugging
- ogldebug—the OpenGL Debugger
- animations
- Animation Problems
- blank window
- Blank Window
- depth testing
- Depth Buffering Problems
- glOrtho()
- Blank Window
- glPerspective()
- Blank Window
- lighting
- Lighting Problems
- projection matrix
- Blank Window
- default colormaps
- Multiple Colormap Issues
- DefaultVisual() Xlib macro
- Some Background on Visuals
- deleting unneeded display lists
- CPU Tuning: Display Lists
- depth buffer clear
- Benchmarking Basics
- depth buffering
- clearing depth and color buffer
- Using Clear Operations
- debugging
- Depth Buffering Problems
- depth buffering
- Choosing Features for Optimum Performance
- Using Expensive Per-Fragment Operations Efficiently
- Getting the Optimum Fill Rates
- Benchmarking Libraries: libpdb and libisfast
- in example program
- Testing Again for Fill Limitation
- lines
- Optimizing Line Drawing
- optimizing
- Using Depth-Buffering Efficiently
- depth testing
- Depth Buffering Problems
- depth-queueing
- Choosing Features for Optimum Performance
- depth-queueing
- lines
- Optimizing Line Drawing
- DepthBufferingIsFast()
- Using libisfast
- detail texture
- customizing
- Customizing the Detail Function
- example program
- Detail Texture Example Program
- LOD interpolation function
- Customizing the Detail Function
- magnification filters
- Creating a Detail Texture and a Low-Resolution Texture
- detail texture
- SGIS_detail_texture—The Detail Texture Extension
- Optimizing Rasterization
- and texture objects
- Using Detail Texture and Texture Object
- how computed
- Detail Texture Computation
- determining cache size
- Minimizing Cache Misses
- Developer Toolbox
- Example Programs
- direct rendering and pbuffers
- PBuffers and Pixmaps
- direct rendering contexts
- Direct and Indirect Rendering
- DirectColor visuals
- Some Background on Visuals
- DirectColor visuals
- Less-Rigid Match of GLX Visual and X Visual
- dis command
- Examining Assembly Code
- displacepolygon (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- display lists
- complex structures
- Immediate Mode Drawing Versus Display Lists
- contrasted with immediate mode
- Immediate Mode Drawing Versus Display Lists
- dependent on context
- X Window System Problems
- DMA
- DMA Display Lists on Indigo2 IMPACT Systems
- IMPACT systems
- Using Display Lists Effectively
- list priority extension
- SGIX_list_priority—The List Priority Extension
- display lists
- appropriate use
- CPU Tuning: Display Lists
- compiling
- Immediate Mode Drawing Versus Display Lists
- deleting unneeded
- CPU Tuning: Display Lists
- duplication
- CPU Tuning: Display Lists
- fonts and strings
- Using Fonts and Strings
- for X bitmap fonts
- Using Fonts and Strings
- on O2 systems
- Optimizing Geometry Operations
- optimizing
- CPU Tuning: Display Lists
- sharing
- X Window System Problems
- tuning
- CPU Tuning: Display Lists
- display lists on InfiniteReality systems
- Miscellaneous Performance Hints
- display lists vs. texture objects
- Managing Textures on InfiniteReality Systems
- displays, retrieving information
- Retrieving Display and Context Information
- dither (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- dithering
- Choosing Features for Optimum Performance
- dithering
- disabling
- Optimizing Per-Fragment Operations on Mid-Range Systems
- mid-range systems
- Optimizing Per-Fragment Operations on Mid-Range Systems
- divided-screen stereo
- Divided-Screen Stereo
- DMA
- pixel formats on low-end systems
- Using Pixel Operations Effectively
- DM_IMAGE_PACKING_RGB332
- Pixel Formats
- DM_IMAGE_PACKING_RGBA
- Image Layouts
- Image Layouts
- Pixel Formats
- DM_IMAGE_PACKING_XRGB5551
- Image Layouts
- Image Layouts
- Pixel Formats
- DMA
- Using Pixel Operations Effectively
- display lists
- DMA Display Lists on Indigo2 IMPACT Systems
- DMbuffers
- OpenGL rendering
- OpenGL Rendering to DMbuffers
- DMparams structure
- example for creating
- Creating DMParams Structure and DMBuffer Pool
- double buffering
- Using Animations
- double buffering
- Tuning Animation
- double buffering X extension
- Swapping Buffers
- drawables
- GLXVideoSourceSGIX()
- SGIX_video_source—The Video Source Extension
- read drawable
- Read and Write Drawables
- write drawable
- Read and Write Drawables
- drawables
- and GLXFBConfig
- Describing a Drawable With a GLXFBConfigSGIX Construct
- creating
- Using Pixmaps
- definition
- GLX Drawables—Windows and Pixmaps
- drawing
- fast pixel drawing
- Drawing Pixels Fast
- lines
- Optimizing Line Drawing
- drawing
- avoiding after screen clear
- Optimizing Frame Rate Performance
- location in call tree
- Using Specialized Drawing Subroutines and Macros
- optimizing
- Tuning the Geometry Subsystem
- drawing-area widgets
- attributes
- Choosing the Visual for the Drawing-Area Widget
- creating
- About OpenGL Drawing-Area Widgets
- drawing-area widgets
- About OpenGL Drawing-Area Widgets
- and colormaps
- X Window Colormaps
- callbacks
- Using Drawing-Area Widget Callbacks
- Using Drawing-Area Widget Callbacks
- creating
- Creating the Widgets
- DUAL* formats
- Using the Texture Select Extension
- edge clamping
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- effective levels
- Virtual Clipmaps
- Elan
- fill operations
- Using Expensive Per-Fragment Operations Efficiently
- Elan
- performance tuning
- Optimizing Performance on Mid-Range Systems
- end conditions of loops
- Examples for Optimizing Program Structure
- error handling
- Choosing the Visual for the Drawing-Area Widget
- errors, calling glGetError()
- General Tips for Debugging Graphics Programs
- estimating performance
- Achieving Accurate Benchmarking Results
- events
- Handling Mouse Events
- buffer clobber
- Directing the Buffer Clobber Event
- events
- processing with callbacks
- Background Information
- Xlib
- Xlib Event Handling
- example programs
- benchmarking
- Benchmarks
- motif
- Simple Motif Example Program
- pdbMeasureRate()
- Example for pdbRead
- pdbWriteRate()
- Example for pdbMeasureRate()
- popup menu
- Using Popup Menus With the GLwMDrawingArea Widget
- sharpen texture extension
- Sharpen Texture Example Program
- video source extension
- SGIX_video_source—The Video Source Extension
- workproc
- Workproc Example
- Xlib
- Simple Xlib Example Program
- Xlib event handling
- Handling Mouse Events
- example programs
- checking for extensions
- Example Program: Checking for Extension Availability
- colormaps
- Colormap Example
- default colormap
- Multiple Colormap Issues
- detail texture
- Detail Texture Example Program
- drawing pixels fast
- Drawing Pixels Fast
- event handling with Xlib
- Handling Mouse Events
- fonts and strings
- Using Fonts and Strings
- location
- Example Programs
- location
- Location of Example Source Code
- mouse motion events
- Using the Input Callback
- tuning example
- Tuning Example
- expensive modes
- Choosing Modes Wisely
- expose callback
- Using Drawing-Area Widget Callbacks
- expose callback
- Creating Overlays
- Mapping the Window
- Expose events
- Mapping the Window
- Exposing a Window
- batching
- Performance Considerations for X and OpenGL
- exposing windows
- Exposing a Window
- EXT suffix
- Extensions to OpenGL
- EXT_abgr
- EXT_abgr—The ABGR Extension
- EXT_blend_color
- Constant Color Blending Extension
- EXT_blend_minmax
- Minmax Blending Extension
- EXT_blend_subtract
- Blend Subtract Extension
- EXT_convolution
- EXT_convolution—The Convolution Extension
- EXT_histogram
- EXT_histogram—The Histogram and Minmax Extensions
- EXT_import_context
- EXT_import_context—The Import Context Extension
- EXT_packed_pixels
- EXT_packed_pixels—The Packed Pixels Extension
- EXT_texture3D
- EXT_texture3D—The 3D Texture Extension
- EXT_visual_info
- EXT_visual_info—The Visual Info Extension
- EXT_visual_rating
- EXT_visual_rating—The Visual Rating Extension
- extensions
- 3D texture
- EXT_texture3D—The 3D Texture Extension
- 4D texture
- SGIS_texture4D—The 4D Texture Extension
- ABGR
- EXT_abgr—The ABGR Extension
- blend subtract
- Blend Subtract Extension
- clipmaps
- SGIX_clipmap—The Clipmap Extension
- color blending
- Constant Color Blending Extension
- color matrix
- SGI_color_matrix—The Color Matrix Extension
- color table
- SGI_color_table—The Color Table Extension
- convolution
- EXT_convolution—The Convolution Extension
- detail texture
- SGIS_detail_texture—The Detail Texture Extension
- dmbuffer
- SGIX_dm_pbuffer—The Digital Media Pbuffer Extension
- filter4 parameters
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- frame buffer configuration
- SGIX_fbconfig—The Framebuffer Configuration Extension
- GLX extension to X
- Silicon Graphics X Server
- impact pixel texture
- Platform Issues
- import context
- EXT_import_context—The Import Context Extension
- instruments
- SGIX_instruments—The Instruments Extension
- list priority
- SGIX_list_priority—The List Priority Extension
- make current read
- EXT_make_current_read—The Make Current Read Extension
- minmax blending
- Minmax Blending Extension
- multisampling
- SGIS_multisample—The Multisample Extension
- NURBS tesselator
- GLU_EXT_NURBS_tessellator—The NURBS Tessellator Extension
- object space tess
- GLU_EXT_object_space—The Object Space Tess Extension
- packed pixels
- EXT_packed_pixels—The Packed Pixels Extension
- pixel buffer
- SGIX_pbuffer—The Pixel Buffer Extension
- pixel texture
- SGIX_pixel_texture—The Pixel Texture Extension
- point parameter
- SGIS_point_parameters—The Point Parameters Extension
- specification
- Example Programs
- sprite
- SGIX_sprite—The Sprite Extension
- swap barrier
- SGIX_swap_barrier—The Swap Barrier Extension
- swap control
- SGI_swap_control—The Swap Control Extension
- swap group
- SGIX_swap_group—The Swap Group Extension
- texture border clamp
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- texture color table
- SGI_texture_color_table—The Texture Color Table Extension
- texture edge clamp
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- texture environment add
- SGIX_texture_add_env—The Texture Environment Add Extension
- texture filter4
- SGIS_texture_filter4—The Texture Filter4 Extensions
- texture LOD
- SGIS_texture_lod—The Texture LOD Extension
- texture LOD bias
- SGIX_texture_lod_bias—The Texture LOD Bias Extension
- texture multibuffer
- SGIX_texture_multi_buffer—The Texture Multibuffer Extension
- texture select
- SGIS_texture_select—The Texture Select Extension
- texture_scale_bias
- SGIX_texture_scale_bias—The Texture Scale Bias Extension
- video resize
- SGIX_video_resize—The Video Resize Extension
- video source
- SGIX_video_source—The Video Source Extension
- video sync
- SGI_video_sync—The Video Synchronization Extension
- visual info
- EXT_visual_info—The Visual Info Extension
- visual rating
- EXT_visual_rating—The Visual Rating Extension
- extensions
- checking for availability
- How to Check for OpenGL Extension Availability
- hardware-accelerated on mid-range systems
- General Performance Tips
- histogram
- EXT_histogram—The Histogram and Minmax Extensions
- interlace
- SGIX_interlace—The Interlace Extension
- resource
- Resource Control Extensions
- sharpen texture
- SGIS_sharpen_texture—The Sharpen Texture Extension
- supported on O2 systems
- Extensions Supported by O2 Systems
- video
- Video Extensions
- extensions available
- Silicon Graphics X Server
- Extreme graphics
- fill operations
- Using Expensive Per-Fragment Operations Efficiently
- performance tuning
- Optimizing Performance on Mid-Range Systems
- eye point orientation
- SGIX_sprite—The Sprite Extension
- fading with constant color blending
- Using Constant Colors for Blending
- fallback resources
- Setting Up Fallback Resources
- Setting Up Fallback Resources
- fallback resources
- Setting Up Fallback Resources
- fbsubtexload (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- File menu (ogldebug)
- Using the File Menu to Interact With ogldebug
- fill rates
- Benchmarking Basics
- fill rates
- optimizing
- Getting the Optimum Fill Rates
- fill-limited code
- definition
- Isolating Bottlenecks in Your Application: Overview
- IMPACT systems
- General Tips for Performance Improvement
- in example program
- Testing for Fill Limitation
- filter4 parameters extension
- Lagrange interpolation
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- Mitchell-Netravali scheme
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- filter4 parameters extension
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- filters
- texture filter4
- SGIS_texture_filter4—The Texture Filter4 Extensions
- finding bottlenecks
- Isolating Bottlenecks in Your Application: Overview
- findvis
- Some Background on Visuals
- GLX and Overloaded Visuals
- finowt bar (gr_osview)
- Using the Pipeline Effectively
- fiwt bar (gr_osview
- Using the Pipeline Effectively
- flat shading
- Smooth Shading Versus Flat Shading
- flat shading
- Using Expensive Per-Fragment Operations Efficiently
- Using Expensive Per-Fragment Operations Efficiently
- Choosing Modes Wisely
- flickering in animations
- Using Animations
- flight simulators
- Using Depth-Buffering Efficiently
- floating-point parameters
- Using Geometry Operations Effectively
- flushing
- explicit
- General Performance Tips
- flushing
- and performance
- General Performance Tips
- implicit
- General Performance Tips
- fog
- Choosing Features for Optimum Performance
- fog
- Choosing Modes Wisely
- on O2 systems
- Optimizing Geometry Operations
- optimizing
- Optimizing Per-Fragment Operations on Mid-Range Systems
- fonts
- Using Fonts and Strings
- Using Fonts and Strings
- fonts
- Using Fonts and Strings
- form widget
- Creating Overlays
- form widget
- Creating the Widgets
- frame rates
- preferred by viewers
- Swapping Buffers
- tuning
- How Frame Rate Determines Animation Speed
- frame widget
- Creating the Widgets
- frame widget
- Creating Overlays
- framebuffer configuration extension
- SGIX_fbconfig—The Framebuffer Configuration Extension
- framebuffer configurations on O2 systems
- Framebuffer Configurations
- framebuffer, efficient use
- Tuning the Imaging Pipeline
- framezoom extension
- Low-End Specific Extensions
- framezoom factor
- Low-End Specific Extensions
- frontbuffer (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- frontface removal
- Using Backface/Frontface Removal
- functions affected by imaging extension
- Functions Affected by Imaging Extensions
- gamma (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- genlocked pipelines
- Why Use the Swap Barrier Extension?
- geometry-limited code
- finding bottlenecks
- Isolating Bottlenecks in Your Application: Overview
- tuning
- Tuning the Geometry Subsystem
- geometry-limited code
- in example program
- Working on a Geometry-Limited Program
- getColormap()
- Multiple Colormap Issues
- getgdesc (IRIS GL)
- Benchmarking Libraries: libpdb and libisfast
- gethgram (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- getminmax (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- gettimeofday()
- Achieving Accurate Timing Measurements
- gfxf bar (gr_osview)
- Using the Pipeline Effectively
- gfxinfo
- System-Specific Tuning
- gfxinit
- SGI_video_sync—The Video Synchronization Extension
- GLX
- GLX Extension to X
- header
- Compiling With the GLX Extension
- GL_(UN)PACK_IMAGE_HEIGHT_EXT
- Using 3D Textures
- GL_1PASS_SGIS
- Accumulating Multisampled Images
- GL_2PASS_0_SGIS
- Accumulating Multisampled Images
- GL_4PASS_0_SGIS
- Accumulating Multisampled Images
- GL_ABGR_EXT
- EXT_abgr—The ABGR Extension
- on low-end systems
- Using Pixel Operations Effectively
- GL_BLEND
- Blending Extensions
- GL_CLAMP_TO_BORDER_SGIS
- Why Use the Texture Clamp Extensions?
- GL_CLAMP_TO_EDGE_SGIS
- Why Use the Texture Clamp Extensions?
- GL_COMPILE_AND_EXECUTE
- CPU Tuning: Display Lists
- GL_CONVOLUTION_BORDER_MODE_EXT
- Retrieving Convolution State Parameters
- GL_CONVOLUTION_FILTER_BIAS_EXT
- Retrieving Convolution State Parameters
- GL_CONVOLUTION_FILTER_SCALE_EXT
- Retrieving Convolution State Parameters
- GL_CONVOLUTION_FORMAT_EXT
- Retrieving Convolution State Parameters
- GL_CONVOLUTION_HEIGHT_EXT
- Retrieving Convolution State Parameters
- GL_CONVOLUTION_WIDTH_EXT
- Retrieving Convolution State Parameters
- GL_CULL_FACE
- Getting the Optimum Fill Rates
- GL_DEPTH_TEST
- Depth Buffering Problems
- GL_INTERLACE_SGIX
- Using the Interlace Extension
- GL_LINE_SMOOTH
- Multisampled Lines
- Some IRIS GL Functionality and OpenGL Equivalents
- GL_LINE_SMOOTH_HINT
- General Tips for Performance Improvement
- GL_LINEAR_DETAIL_ALPHA_SGIS
- Creating a Detail Texture and a Low-Resolution Texture
- GL_LINEAR_DETAIL_COLOR_SGIS
- Creating a Detail Texture and a Low-Resolution Texture
- GL_LINEAR_DETAIL_SGIS
- Creating a Detail Texture and a Low-Resolution Texture
- GL_LINEAR_SHARPEN_ALPHA_SGIS
- How to Use the Sharpen Texture Extension
- GL_LINEAR_SHARPEN_COLOR_SGIS
- How to Use the Sharpen Texture Extension
- GL_LINEAR_SHARPEN_SGIS
- How to Use the Sharpen Texture Extension
- GL_MAX_CONVOLUTION_HEIGHT_EXT
- Retrieving Convolution State Parameters
- GL_MAX_CONVOLUTION_WIDTH_EXT
- Retrieving Convolution State Parameters
- GL_POINT_FADE_THRESHOLD_SIZE_SGIS
- SGIS_point_parameters—The Point Parameters Extension
- GL_POINT_SIZE_MAX_SGIS
- SGIS_point_parameters—The Point Parameters Extension
- GL_POINT_SIZE_MIN_SGIS
- SGIS_point_parameters—The Point Parameters Extension
- GL_POST_COLOR_MATRIX_*_BIAS_SGI
- SGI_color_matrix—The Color Matrix Extension
- GL_POST_COLOR_MATRIX_*_SCALE_SGI
- SGI_color_matrix—The Color Matrix Extension
- GL_RENDERER
- System-Specific Tuning
- Example Program: Checking for Extension Availability
- GL_RGB5_A1_EXT
- Image Layouts
- Pixel Formats
- Tuning the Imaging Pipeline
- GL_RGBA
- Image Layouts
- Pixel Formats
- GL_SAMPLE_ALPHA_TO_MASK_SGIS
- Using Advanced Multisampling Options
- GL_SAMPLE_MASK_SGIS
- Using a Multisample Mask to Fade Levels of Detail
- GL_SHININESS
- Lighting Operations With Noticeable Performance Costs
- GL_SPRITE_AXIAL_SGIX
- Available Sprite Modes
- GL_SPRITE_EYE_ALIGNED_SGIX
- Available Sprite Modes
- GL_SPRITE_OBJECT_ALIGNED_SGIX
- Available Sprite Modes
- GL_TEXTURE_CLIPMAP_CENTER_SGIX
- Setting Up the Clipmap Stack
- GL_TEXTURE_CLIPMAP_OFFSET_SGIX
- Setting Up the Clipmap Stack
- GL_TEXTURE_COLOR_TABLE_SGI
- Using Texture Color Tables
- GL_TEXTURE_LOD_BIAS_*_SGIX
- Using the Texture LOD Bias Extension
- GL_TEXTURE_MAG_FILTER
- Creating a Detail Texture and a Low-Resolution Texture
- GL_TEXTURE_MAX_LOD_SGIS
- Specifying a Minimum or Maximum Level of Detail
- GL_TEXTURE_MIN_LOD_SGIS
- Specifying a Minimum or Maximum Level of Detail
- GL_TEXTURE_WRAP_R_EXT
- Using 3D Textures
- Using 3D Textures
- GL_UNPACK_ALIGNMENT
- Pixel and Texture Write Problems
- GL_UNSIGNED_BYTE_3_3_2_EXT
- Using Packed Pixels
- GL_UNSIGNED_BYTE_3_3_3_EXT
- Pixel Formats
- GL_UNSIGNED_INT_10_10_10_2_EXT
- Using Packed Pixels
- GL_UNSIGNED_INT_8_8_8_8_EXT
- Using Packed Pixels
- GL_UNSIGNED_SHORT_4_4_4_4_EXT
- Using Packed Pixels
- GL_UNSIGNED_SHORT_5_5_5_1_EXT
- Using Packed Pixels
- GL_VERSION
- Example Program: Checking for Extension Availability
- glAlphaFunc()
- Advanced Transform-Limited Tuning Techniques
- glAreTexturesResidentEXT()
- Some IRIS GL Functionality and OpenGL Equivalents
- glBegin()
- Examples for Optimizing Program Structure
- glBlendColorEXT()
- Using Constant Colors for Blending
- glBlendEquationEXT()
- Minmax Blending Extension
- glBlendFunc()
- Using Constant Colors for Blending
- glCallList()
- CPU Tuning: Display Lists
- glCallLists()
- Using Fonts and Strings
- glClear()
- Mixing Computation With Graphics
- glClear()
- Blank Window
- glColorMaterial()
- Lighting Operations With Noticeable Performance Costs
- glColorTableSGI()
- Specifying a Color Table
- Using Texture Color Tables
- glcompat (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- glConvolutionFilter*DEXT()
- Performing Convolution
- glCopyColorTableSGI()
- Using Framebuffer Image Data for Color Tables
- glCopyConvolutionFilter*DEXT()
- Separable and General Convolution Filters
- glCopyPixels() and minmax extension
- Using the Minmax Part of the Histogram Extension
- glCopyPixels() for scrolling
- Using Pixel Operations Effectively
- glDeleteLists()
- CPU Tuning: Display Lists
- glDepthRange()
- Choosing Modes Wisely
- glDetailTexFuncSGIS()
- Customizing the Detail Function
- glDrawPixels(), optimizing
- Drawing Pixels Fast
- glEnd()
- Examples for Optimizing Program Structure
- glFinish()
- Achieving Accurate Timing Measurements
- Achieving Accurate Timing Measurements
- glFrameZoomSGIX()
- Low-End Specific Extensions
- glGetConvolutionFilterEXT()
- Separable and General Convolution Filters
- glGetError()
- General Tips for Debugging Graphics Programs
- glGetError()
- General Tips for Debugging Graphics Programs
- glGetHistogramEXT()
- Using the Histogram Extension
- Some IRIS GL Functionality and OpenGL Equivalents
- glGetMinMaxExt()
- Using the Minmax Part of the Histogram Extension
- glGetMinmaxParameterEXT()
- Using the Minmax Part of the Histogram Extension
- glGetString()
- System-Specific Tuning
- Example Program: Checking for Extension Availability
- How to Check for OpenGL Extension Availability
- glHint()
- GL_TEXTURE_MULTI_BUFFER_HINT_SGIX
- How to use the Texture Multibuffer Extension
- glHistogramEXT()
- Some IRIS GL Functionality and OpenGL Equivalents
- Using the Histogram Extension
- glInstrumentsBufferSGIX()
- Specifying the Buffer
- glintro
- Extensions to OpenGL
- glListBase()
- Using Fonts and Strings
- glListParameter*SGIX()
- Using the List Priority Extension
- glLoadIdentity()
- Achieving Peak Geometry Performance
- glLoadMatrix()
- Achieving Peak Geometry Performance
- glLogicOp()
- Choosing Features for Optimum Performance
- glMaterial()
- Lighting Operations With Noticeable Performance Costs
- glMinmaxEXT()
- Using the Minmax Part of the Histogram Extension
- glOrtho()
- Blank Window
- glOrtho() performance
- Using Geometry Operations Effectively
- glPerspective()
- Blank Window
- glPixelMaps()
- Using Images
- glPixelTexGenSGIX()
- Platform Issues
- SGIX_pixel_texture—The Pixel Texture Extension
- glPollInstrumentsSGIX()
- Retrieving Information
- glRect()
- Getting the Optimum Fill Rates
- glSampleAlphaToMaskSGIS()
- Using a Multisample Mask to Fade Levels of Detail
- glSampleMaskSGIS()
- Using Advanced Multisampling Options
- Using a Multisample Mask to Fade Levels of Detail
- glSamplePatternSGIS()
- Accumulating Multisampled Images
- glSeparableFilter2DEXT()
- Performing Convolution
- Separable and General Convolution Filters
- glShadeModel()
- for performance tuning
- Choosing Modes Wisely
- glShadeModel()
- Getting the Optimum Fill Rates
- glSharpenTexFuncSGIS()
- Customizing the LOD Extrapolation Function
- glTagSampleBufferSGIX()
- Multisample Rasterization of Pixels and Bitmaps
- Optimizing Multisampling and Transparency
- glTexFilterFuncSGIS()
- Specifying the Filter Function
- glTexGen()
- Optimizing Geometry Performance
- glTexImage2D() and interlacing
- SGIX_interlace—The Interlace Extension
- glTexImage3DEXT
- Using 3D Textures
- glTexSubImage() for clipmap loading
- Updating the Clipmap Stack
- GLU header
- Compiling With the GLX Extension
- GLU include files
- Silicon Graphics X Server
- GLU NURBS
- General Tips for Performance Improvement
- GLU_EXT_nurbs_tessellator
- GLU_EXT_NURBS_tessellator—The NURBS Tessellator Extension
- GLU_EXT_object_space_tess
- GLU_EXT_object_space—The Object Space Tess Extension
- GLU_LAGRANGIAN_SGI
- Using the Filter4 Parameters Extension
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- GLU_MITCHELL_NETRAVALI_SGI
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- GLU_OBJECT_PARAMETRIC_ERROR_EXT
- GLU_EXT_object_space—The Object Space Tess Extension
- GLU_OBJECT_PATH_LENGTH_EXT
- GLU_EXT_object_space—The Object Space Tess Extension
- gluNurbsCallbackDataEXT()
- Callbacks Defined by the Extension
- gluNurbsProperty()
- GLU_EXT_object_space—The Object Space Tess Extension
- glUseXFont()
- X Window System Problems
- glVertex3fv () performance
- Using Geometry Operations Effectively
- GLwCreateMDrawingArea()
- About OpenGL Drawing-Area Widgets
- GLwDrawingAreaMakeCurrent()
- Binding the Context to the Window
- GLwDrawingAreaSwapBuffers()
- Swapping Buffers
- GLwMDrawingArea widget
- and popup
- Rubber Banding
- GLwMDrawingArea widget
- About OpenGL Drawing-Area Widgets
- menus
- Using Popup Menus With the GLwMDrawingArea Widget
- overlays
- Introduction to Overlays
- GLwMDrawingArea widget See also drawing-area widgets
- Choosing the Visual for the Drawing-Area Widget
- GLwMDrawingAreaMakeCurrent()
- About OpenGL Drawing-Area Widgets
- Using Drawing-Area Widget Callbacks
- GLwMDrawingAreaSwapBuffers()
- About OpenGL Drawing-Area Widgets
- GLwNexposeCallback
- Using Drawing-Area Widget Callbacks
- GLwNginitCallback
- Using Drawing-Area Widget Callbacks
- GLwNinputCallback
- Using Drawing-Area Widget Callbacks
- GLwNresizeCallback
- Using Drawing-Area Widget Callbacks
- GLX
- Compiling With the GLX Extension
- Silicon Graphics X Server
- GLX Extension to the X Window System
- GLX Extension to the X Window System
- checking support
- Opening the X Display
- importing indirect context
- Importing a Context
- systems supporting GLX 1.0
- Opening the X Display
- systems supporting GLX 1.1
- Opening the X Display
- using glXQueryExtension()
- Opening the X Display
- GLX 1.2
- Opening the X Display
- GLX drawable
- GLX Drawables—Windows and Pixmaps
- GLX extension See GLX.
- GLX Extension to X
- GLX pixmaps
- Creating and Using Pixmaps
- GLX Drawables—Windows and Pixmaps
- and exposing windows
- Exposing a Window
- GLX visual
- GLX and Overloaded Visuals
- GLX_BUFFER_SIZE
- Creating and Using Pixmaps
- GLX_CONTENTS_PRESERVED_SGIX
- Creating a PBuffer
- GLX_DRAWABLE_TYPE_SGIX
- Choosing a GLXFBConfigSGIX Construct
- GLX_FBCONFIG_ID_SGIX
- Choosing a GLXFBConfigSGIX Construct
- GLX_GET_LARGEST_PBUFFER_SGIX
- Creating a PBuffer
- GLX_GRAY_SCALE_EXT
- Using the Visual Info Extension
- GLX_PSEUDO_COLOR
- Using the Visual Info Extension
- GLX_RENDER_TYPE_SGIX
- Choosing a GLXFBConfigSGIX Construct
- GLX_SAMPLE_BUFFERS_SGIS
- Using the Multisample Extension
- GLX_SAMPLES_SGIS
- Using the Multisample Extension
- GLX_SCREEN_EXT
- Retrieving Display and Context Information
- GLX_SHARE_CONTEXT_EXT
- Retrieving Display and Context Information
- GLX_SLOW_EXT
- Using the Visual Rating Extension
- GLX_STATIC_COLOR_EXT
- Using the Visual Info Extension
- GLX_STATIC_GRAY_EXT
- Using the Visual Info Extension
- GLX_TRUE_COLOR_EXT
- Using the Visual Info Extension
- GLX_VISUAL_CAVEAT_EXT
- Using the Visual Rating Extension
- How an FBConfig Is Selected
- GLX_VISUAL_ID_EXT
- Retrieving Display and Context Information
- GLX_X_RENDERABLE_SGIX
- Choosing a GLXFBConfigSGIX Construct
- GLX_X_VISUAL_TYPE_EXT
- Using the Visual Info Extension
- glXBindSwapBarriersSGIX()
- Using the Swap Barrier Extension
- glXChannelRectSyncSGIX()
- Controlling When the Video Resize Update Occurs
- glXChooseFBConfigSGIX()
- How an FBConfig Is Selected
- glXChooseFBConfigSGIX()
- Choosing a GLXFBConfigSGIX Construct
- Choosing a GLXFBConfigSGIX Construct
- glXChooseVisual()
- Selecting a Visual
- glXChooseVisual()
- Using the Visual Rating Extension
- Using the Visual Info Extension
- Some Background on Visuals
- Choosing the Visual for the Drawing-Area Widget
- and multisampling
- Using the Multisample Extension
- Using the Multisample Extension
- using FBConfig instead
- Why Use the Framebuffer Configuration Extension?
- GLXContext
- Rendering Contexts
- glXCreateContext()
- Creating a Rendering Context
- glXCreateContextWithConfigSGIX()
- New Functions
- glXCreateContextWithConfigSGIX()
- Retrieving FBConfig Attribute Values
- glXCreateGLXPbufferSGIX()
- Creating a PBuffer
- New Functions
- glXCreateGLXPixmap()
- Creating and Using Pixmaps
- glXCreateGLXPixmapWithConfigSGIX()
- New Functions
- Retrieving FBConfig Attribute Values
- glXCreateGLXVideoSourceSGIX()
- SGIX_video_source—The Video Source Extension
- Some IRIS GL Functionality and OpenGL Equivalents
- glXDestroyGLXPbufferSGIX()
- New Functions
- glXDestroyGLXPbufferSGIX()
- Rendering to a GLXPbuffer
- glXDestroyGLXVideoSourceSGIX()
- SGIX_video_source—The Video Source Extension
- GLXFBConfig
- Describing a Drawable With a GLXFBConfigSGIX Construct
- GLXFBConfig
- GLXFBConfigSGIX Constructs
- attributes
- Choosing a GLXFBConfigSGIX Construct
- how selected
- How an FBConfig Is Selected
- glXFreeGLXContext()
- Importing a Context
- glXGetCurrentDisplayEXT()
- Retrieving Display and Context Information
- glXGetFBConfigAttribSGIX()
- Retrieving FBConfig Attribute Values
- Choosing a GLXFBConfigSGIX Construct
- How an FBConfig Is Selected
- glXGetGLXContextIDEXT()
- Importing a Context
- glXGetGLXPbufferConfigSGIX()
- New Functions
- glXGetGLXPbufferStatusSGIX()
- New Functions
- glXGetLargestGLXPbufferSGIX()
- New Functions
- glXGetVideoSyncSGI()
- Using the Video Sync Extension
- glXGetVisualFromFBConfigSGIX()
- Choosing a GLXFBConfigSGIX Construct
- glXImportGLXContextEXT()
- Importing a Context
- Importing a Context
- glxinfo
- GLX and Overloaded Visuals
- glXJoinSwapGroupSGIX()
- Why Use the Swap Group Extension?
- glXMakeCurrent()
- Binding the Context to the Window
- Using Drawing-Area Widget Callbacks
- Less-Rigid Similarity Requirements When Matching Context and Drawable
- See also MakeCurrentRead extension
- Read and Write Drawables
- glXMakeCurrentReadSGI()
- Some IRIS GL Functionality and OpenGL Equivalents
- EXT_make_current_read—The Make Current Read Extension
- GLXPbuffer
- SGIX_pbuffer—The Pixel Buffer Extension
- glXQueryContextInfoEXT()
- Retrieving Display and Context Information
- glXQueryExtension()
- Opening the X Display
- Opening the X Display
- glXQueryExtensionsString()
- Checking for GLX Extension Availability
- glXSelectEventSGIX()
- Directing the Buffer Clobber Event
- glXSwapBuffers()
- Mixing Computation With Graphics
- Swapping Buffers
- Achieving Accurate Timing Measurements
- and tuning animations
- Optimizing Frame Rate Performance
- glXSwapIntervalSGI()
- SGI_swap_control—The Swap Control Extension
- glXUseXFont()
- Using Fonts and Strings
- GLXVideoSourceSGIX()
- SGIX_video_source—The Video Source Extension
- glXWaitGL()
- Performance Considerations for X and OpenGL
- glXWaitVideoSyncSGI()
- Using the Video Sync Extension
- glXWaitX()
- Performance Considerations for X and OpenGL
- glyphs
- Using Fonts and Strings
- Gouraud shading
- Using Expensive Per-Fragment Operations Efficiently
- gr_osview
- Using the Pipeline Effectively
- GrayScale visuals
- Some Background on Visuals
- GrayScale visuals
- Using the Visual Info Extension
- Less-Rigid Match of GLX Visual and X Visual
- ground plane
- Mixing Computation With Graphics
- grouping primitives
- Using Peak Performance Primitives for Drawing
- hardware configuration
- System-Specific Tuning
- hardware-supported features (low-end)
- Choosing Features for Optimum Performance
- header
- for OpenGL, GLU, GLX
- Compiling With the GLX Extension
- hgram (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- hierarchy
- data organization
- Optimizing the Data Organization
- hierarchy
- memory
- Memory Organization
- High IMPACT
- Optimizing Performance on Indigo2 IMPACT and OCTANE Systems
- high-performance drawing
- Tuning the Geometry Subsystem
- hints
- GL_NICEST smooth hint
- Multisampled Points
- GL_TEXTURE_MULTI_BUFFER_HINT_SGIX
- How to use the Texture Multibuffer Extension
- hinv command
- Minimizing Cache Misses
- histogram extension
- EXT_histogram—The Histogram and Minmax Extensions
- example
- Using the Histogram Extension
- O2 systems
- Imaging Pipeline Using ICE
- using proxy histograms
- Using Proxy Histograms
- hot spots
- About Pipeline Tuning
- Optimizing Database Rendering Code
- ICE
- Imaging Pipeline Using ICE
- Optimizing Performance on O2™ Systems
- identity matrix
- Achieving Peak Geometry Performance
- identity matrix
- Tuning the Imaging Pipeline
- if-else-if statements
- Examples for Optimizing Program Structure
- ilbuffer (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- ildraw (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- image width on O2 systems
- Imaging Pipeline Using ICE
- images on IMPACT
- Using Images
- Imaging and Compression Engine
- Imaging Pipeline Using ICE
- Optimizing Performance on O2™ Systems
- imaging extensions
- Imaging Extensions
- affected functions
- Functions Affected by Imaging Extensions
- imaging pipeline
- tuning
- Tuning the Imaging Pipeline
- imaging pipeline
- Introduction to Imaging Extensions
- location of color table
- Lookup Tables in the Image Pipeline
- optimizing
- Optimizing the Imaging Pipeline
- overview
- Convolution, Histogram, and Color Table in the Pipeline
- immediate mode
- machine dependencies
- Using libisfast
- immediate mode
- contrasted with display lists
- Immediate Mode Drawing Versus Display Lists
- tuning
- CPU Tuning: Immediate Mode Drawing
- ImmediateModeIsFast()
- Using libisfast
- Using libisfast
- IMPACT
- color space conversion
- Accelerating Color Space Conversion
- convolution kernels
- Using Images
- images
- Using Images
- quad strips
- Achieving Peak Geometry Performance
- textures
- Using Textures
- triangle strips
- Achieving Peak Geometry Performance
- IMPACT
- display lists
- Using Display Lists Effectively
- performance tuning
- Optimizing Performance on Indigo2 IMPACT and OCTANE Systems
- pixel texture
- Platform Issues
- Impact Pixel Texture extension
- Platform Issues
- import context extension
- shareable information
- Importing a Context
- import context extension
- EXT_import_context—The Import Context Extension
- include files for OpenGL and X
- Compiling With the GLX Extension
- Indigo2 XL performance tuning
- Optimizing Performance on Low-End Graphics Systems
- indirect rendering
- Direct and Indirect Rendering
- pbuffers
- PBuffers and Pixmaps
- indirect rendering contexts
- sharing with import context
- EXT_import_context—The Import Context Extension
- Indy
- comparative performance costs
- Using Expensive Per-Fragment Operations Efficiently
- performance tuning
- Optimizing Performance on Low-End Graphics Systems
- InfiniteReality systems
- display lists
- Miscellaneous Performance Hints
- pbuffers
- Offscreen Rendering and Framebuffer Management
- Miscellaneous Performance Hints
- texture subimages
- Managing Textures on InfiniteReality Systems
- textures
- Managing Textures on InfiniteReality Systems
- InfiniteReality systems
- clipmaps
- SGIX_clipmap—The Clipmap Extension
- performance tuning
- Optimizing Performance on InfiniteReality Systems
- sprite extension
- SGIX_sprite—The Sprite Extension
- texture select extension
- Why Use the Texture Select Extension?
- video resize extension
- Controlling When the Video Resize Update Occurs
- inheritance issues
- Inheritance Issues
- init callback
- Using Drawing-Area Widget Callbacks
- init callback
- Mapping the Window
- input callbacks
- Using Drawing-Area Widget Callbacks
- input callbacks
- Using Drawing-Area Widget Callbacks
- Creating Overlays
- Using the Input Callback
- example
- Using the Input Callback
- private state
- Background Information
- when called
- Using the Input Callback
- input disappears
- Keyboard Input Disappears
- input events
- and overlays
- Overlay Troubleshooting
- input extension (X)
- Xlib Event Handling
- input handling
- actions and translations
- Background Information
- input handling
- Input Handling With Widgets and Xt
- Background Information
- instruments extension
- SGIX_instruments—The Instruments Extension
- interlace extension
- SGIX_interlace—The Interlace Extension
- interleaving computation with graphics
- Mixing Computation With Graphics
- internal formats
- texture select
- Why Use the Texture Select Extension?
- Intrinsics
- Xt Library
- invalid borders
- Invalid Borders
- IRIS GL
- backbuffer
- Some IRIS GL Functionality and OpenGL Equivalents
- blendcolor
- Some IRIS GL Functionality and OpenGL Equivalents
- blendfunction
- Some IRIS GL Functionality and OpenGL Equivalents
- convolve
- Some IRIS GL Functionality and OpenGL Equivalents
- cpack format
- EXT_abgr—The ABGR Extension
- displacepolygon
- Some IRIS GL Functionality and OpenGL Equivalents
- dither
- Some IRIS GL Functionality and OpenGL Equivalents
- fbsubtexload
- Some IRIS GL Functionality and OpenGL Equivalents
- frontbuffer
- Some IRIS GL Functionality and OpenGL Equivalents
- gamma
- Some IRIS GL Functionality and OpenGL Equivalents
- getdesc
- Benchmarking Libraries: libpdb and libisfast
- gethgram
- Some IRIS GL Functionality and OpenGL Equivalents
- getminmax
- Some IRIS GL Functionality and OpenGL Equivalents
- glcompat
- Some IRIS GL Functionality and OpenGL Equivalents
- hgram
- Some IRIS GL Functionality and OpenGL Equivalents
- ilbuffer
- Some IRIS GL Functionality and OpenGL Equivalents
- ildraw
- Some IRIS GL Functionality and OpenGL Equivalents
- istexloaded
- Some IRIS GL Functionality and OpenGL Equivalents
- leftbuffer
- Some IRIS GL Functionality and OpenGL Equivalents
- libsphere
- Some IRIS GL Functionality and OpenGL Equivalents
- linesmooth
- Some IRIS GL Functionality and OpenGL Equivalents
- minmax
- Some IRIS GL Functionality and OpenGL Equivalents
- msalpha
- Some IRIS GL Functionality and OpenGL Equivalents
- msmask
- Some IRIS GL Functionality and OpenGL Equivalents
- mspattern
- Some IRIS GL Functionality and OpenGL Equivalents
- mssize
- Some IRIS GL Functionality and OpenGL Equivalents
- mswapbuffers
- Some IRIS GL Functionality and OpenGL Equivalents
- pixelmap
- Some IRIS GL Functionality and OpenGL Equivalents
- pixmode
- Some IRIS GL Functionality and OpenGL Equivalents
- pntsize
- Some IRIS GL Functionality and OpenGL Equivalents
- polymode
- Some IRIS GL Functionality and OpenGL Equivalents
- polysmooth
- Some IRIS GL Functionality and OpenGL Equivalents
- popup planes
- Some IRIS GL Functionality and OpenGL Equivalents
- readcomponent
- Some IRIS GL Functionality and OpenGL Equivalents
- RGBwritemask
- Some IRIS GL Functionality and OpenGL Equivalents
- rightbuffer
- Some IRIS GL Functionality and OpenGL Equivalents
- setmonitor
- Some IRIS GL Functionality and OpenGL Equivalents
- setvideo
- Some IRIS GL Functionality and OpenGL Equivalents
- swapinterval()
- SGI_swap_control—The Swap Control Extension
- tevbind
- Some IRIS GL Functionality and OpenGL Equivalents
- tevdef
- Some IRIS GL Functionality and OpenGL Equivalents
- texbind
- Some IRIS GL Functionality and OpenGL Equivalents
- texdef
- Some IRIS GL Functionality and OpenGL Equivalents
- texture management
- Some IRIS GL Functionality and OpenGL Equivalents
- tlutbind
- Some IRIS GL Functionality and OpenGL Equivalents
- tlutdef
- Some IRIS GL Functionality and OpenGL Equivalents
- IRIS GL
- Note to IRIS GL Users
- Note for IRIS GL Users
- porting
- What This Guide Contains
- IRIS IM
- and Xt
- Xt Library
- integrating with OpenGL
- Integrating Your OpenGL Program With IRIS IM
- IRIS IM
- Using OpenGL With the X Window System
- example program
- Simple Motif Example Program
- keyboard traversal
- About OpenGL Drawing-Area Widgets
- troubleshooting
- Keyboard Input Disappears
- widgets
- Widgets and the Xt Library
- widgets
- Xt Library
- IRIS Performer
- SGIX_clipmap—The Clipmap Extension
- Maximizing Performance With IRIS Performer
- IRIS Performer API
- swap barrier
- Why Use the Swap Barrier Extension?
- IsFastOpenXDisplay()
- Using libisfast
- istexloaded (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- key bindings
- Using Actions and Translations
- keyboard focus
- Keyboard Input Disappears
- keyboard traversal
- Keyboard Input Disappears
- keyboard traversal
- About OpenGL Drawing-Area Widgets
- keyboards
- virtual key bindings
- Using Actions and Translations
- Lagrange interpolation (filter4 parameters extension)
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- leftbuffer (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- libisfast
- Libraries for Benchmarking
- Using libisfast
- libpdb
- Libraries for Benchmarking
- libraries
- how to link
- Link Lines for Individual Libraries
- OpenGL and X
- Compiling With the GLX Extension
- libsphere (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- light points
- SGIS_point_parameters—The Point Parameters Extension
- lighting
- Choosing Features for Optimum Performance
- nonlocal viewing
- Optimizing Lighting Performance
- shininess
- Lighting Operations With Noticeable Performance Costs
- single-sided
- Optimizing Lighting Performance
- lighting
- and material parameters
- Lighting Operations With Noticeable Performance Costs
- debugging
- Lighting Problems
- mid-range systems
- Optimizing Per-Fragment Operations on Mid-Range Systems
- optimizing
- Optimizing Lighting Performance
- performance penalty of advanced features
- Optimizing Lighting Performance
- lines
- antialiased
- Optimizing Line Drawing
- Optimizing Rasterization
- General Tips for Performance Improvement
- Optimizing Geometry Operations on Mid-Range Systems
- Some IRIS GL Functionality and OpenGL Equivalents
- depth-buffering
- Optimizing Line Drawing
- depth-queued
- Optimizing Line Drawing
- patterned
- Optimizing Line Drawing
- shaded
- Optimizing Line Drawing
- line strips
- Using Peak Performance Primitives for Drawing
- lines
- Optimizing Line Drawing
- optimizing for low-end systems
- Optimizing Line Drawing
- linesmooth (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- link lines
- Link Lines for Individual Libraries
- OpenGL and X
- Link Lines for Individual Libraries
- list priority extension
- SGIX_list_priority—The List Priority Extension
- LOD
- clipmaps
- SGIX_clipmap—The Clipmap Extension
- texture LOD bias extension
- SGIX_texture_lod_bias—The Texture LOD Bias Extension
- texture LOD extension
- SGIS_texture_lod—The Texture LOD Extension
- load monitoring with instruments
- About SGIX_instruments
- loading
- optimizing
- Tuning the Imaging Pipeline
- location of example programs
- Example Programs
- location of example source code
- Location of Example Source Code
- location of specifications
- Example Programs
- LOD
- multisampling
- Using a Multisample Mask to Fade Levels of Detail
- specifying minimum/maximum level
- Specifying a Minimum or Maximum Level of Detail
- LOD extrapolation function
- Customizing the LOD Extrapolation Function
- LOD interpolation curve
- Customizing the Detail Function
- lookup tables
- pixel texture
- SGIX_pixel_texture—The Pixel Texture Extension
- loops
- accessing buffers
- Examples for Optimizing Program Structure
- for benchmarking
- Achieving Accurate Timing Measurements
- loops
- optimizing
- Examples for Optimizing Program Structure
- Examples for Optimizing Program Structure
- unrolling
- Examples for Optimizing Program Structure
- low-end systems
- hardware-supported features
- Choosing Features for Optimum Performance
- scissoring
- Using Pixel Operations Effectively
- software-supported features
- Choosing Features for Optimum Performance
- low-end systems
- optimizing lines
- Optimizing Line Drawing
- machine configuration
- System-Specific Tuning
- macros
- Using Specialized Drawing Subroutines and Macros
- magnification filters
- detail texture
- Creating a Detail Texture and a Low-Resolution Texture
- sharpen texture
- How to Use the Sharpen Texture Extension
- magnification of textures
- SGIS_sharpen_texture—The Sharpen Texture Extension
- make current read extension
- BadMatch error
- Possible Match Errors
- RealityEngine
- Possible Match Errors
- make current read extension
- EXT_make_current_read—The Make Current Read Extension
- mapping windows
- Mapping the Window
- masks
- multisample mask
- Using a Multisample Mask to Fade Levels of Detail
- material parameters
- Lighting Operations With Noticeable Performance Costs
- Maximum IMPACT
- Optimizing Performance on Indigo2 IMPACT and OCTANE Systems
- maxlod
- Virtual Clipmaps
- memory
- paging
- Memory Organization
- memory
- limitations with display lists
- Immediate Mode Drawing Versus Display Lists
- optimizing display lists
- CPU Tuning: Display Lists
- paging caused by hierarchical data structures
- Optimizing the Data Organization
- savings using several visuals
- Running OpenGL Applications Using a Single Visual
- structure of
- Memory Organization
- menus
- GLwMDrawingArea widget
- Using Popup Menus With the GLwMDrawingArea Widget
- menus
- multi-visual applications
- Running OpenGL Applications Using a Single Visual
- meshes
- Preprocessing Meshes Into Fixed-Length Strips
- mid-range systems
- alpha blending
- Optimizing Per-Fragment Operations on Mid-Range Systems
- dithering
- Optimizing Per-Fragment Operations on Mid-Range Systems
- hardware-acccelerated extensions
- General Performance Tips
- lighting
- Optimizing Per-Fragment Operations on Mid-Range Systems
- optimizing clear operations
- Optimizing Per-Fragment Operations on Mid-Range Systems
- texture mapping
- Optimizing Per-Fragment Operations on Mid-Range Systems
- mid-range systems
- performance tuning
- Optimizing Performance on Mid-Range Systems
- General Performance Tips
- minimizing cache misses
- Minimizing Cache Misses
- minmax (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- minmax blending extension
- Minmax Blending Extension
- minmax extension
- Using the Minmax Part of the Histogram Extension
- mipmapping
- and 3D textures
- Using 3D Textures
- mipmapping
- and texture LOD bias extension
- Background: Texture Maps and LODs
- texture LOD extension
- SGIS_texture_lod—The Texture LOD Extension
- mipmapping See Also texture filter4 extension
- SGIS_texture_filter4—The Texture Filter4 Extensions
- mipmaps and clipmaps
- Clipmap Overview
- Mitchell-Netravali scheme (filter4 parameters extension)
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- mode changes
- fast on RealityEngine
- Optimizing Geometry Performance
- slow on RealityEngine
- Optimizing Geometry Performance
- mode settings
- Benchmarking Basics
- model view matrix and sprite extension
- SGIX_sprite—The Sprite Extension
- Motif
- Using OpenGL With the X Window System
- Motif
- and Xt
- Xt Library
- See also IRIS IM, widgets
- Simple Motif Example Program
- motif/simplest.c example program
- Simple Motif Example Program
- mouse events
- Handling Mouse Events
- Using the Input Callback
- msalpha (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- msmask (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- mspattern (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- mssize (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- mswapbuffers (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- multipass multisampling
- Accumulating Multisampled Images
- Accumulating Multisampled Images
- multiple colormaps
- Multiple Colormap Issues
- multiple processes
- Minimizing Cache Misses
- multiple processors
- Using Additional Processors for Complex Scene Management
- multiple processors and sprite extension
- SGIX_sprite—The Sprite Extension
- multiple visuals
- Running OpenGL Applications Using a Single Visual
- multisample extension
- SGIS_multisample—The Multisample Extension
- multisample mask
- Using a Multisample Mask to Fade Levels of Detail
- multisample points and GL_POINT_FADE_THRESHOLD_SIZE_SGIS
- SGIS_point_parameters—The Point Parameters Extension
- multisampling
- advanced options
- Using Advanced Multisampling Options
- choosing visual
- Using the Multisample Extension
- clear
- Optimizing Multisampling and Transparency
- defining mask
- Using a Multisample Mask to Fade Levels of Detail
- GL_LINE_SMOOTH
- Multisampled Lines
- multipass multisampling
- Accumulating Multisampled Images
- Accumulating Multisampled Images
- performance costs
- Optimizing Multisampling and Transparency
- polygons
- Multisampled Polygons
- multisampling
- SGIS_multisample—The Multisample Extension
- and blending
- Using Advanced Multisampling Options
- comparative performance cost
- Using Expensive Per-Fragment Operations Efficiently
- introduction
- Introduction to Multisampling
- on RealityEngine systems
- Optimizing Multisampling and Transparency
- points
- Multisampled Points
- screen-door transparency
- Color Blending and Screen-Door Transparency
- when to use
- When to Use Multisampling
- n32 OpenGL version
- Optimizing Geometry Operations
- nonclipped level
- Why Do the Clipmap Constraints Work?
- nonlocal viewing
- Optimizing Lighting Performance
- normals
- Using Geometry Operations Effectively
- NURBS
- General Tips for Performance Improvement
- NURBS object
- callback
- Using the NURBS Tessellator Extension
- NURBS tessellator extension
- GLU_EXT_NURBS_tessellator—The NURBS Tessellator Extension
- O2 compiler option
- CPU Tuning: Basics
- O2 systems
- convolution
- Imaging Pipeline Using ICE
- histogram extension
- Imaging Pipeline Using ICE
- image width
- Imaging Pipeline Using ICE
- supported extensions
- Extensions Supported by O2 Systems
- texture objects
- Using Textures
- O2 systems
- framebuffer configurations
- Framebuffer Configurations
- performance
- Optimizing Performance on O2™ Systems
- texture memory
- Texture Mapping
- o32 OpenGL version
- Optimizing Geometry Operations
- object space tess extension
- GLU_EXT_object_space—The Object Space Tess Extension
- ogldebug
- File menu
- Using the File Menu to Interact With ogldebug
- Options menu
- Using the Commands Menu to Interact With Your Program
- References menu
- Using the References Menu for Background Information
- trace file
- Creating a Trace File to Discover OpenGL Problems
- ogldebug
- configuration file
- Using a Configuration File
- setup
- Setting Up ogldebug
- starting
- Starting ogldebug
- ogldebug tool
- ogldebug—the OpenGL Debugger
- one-dimensional arrays
- Examples for Optimizing Data Structures for Drawing
- Open Inventor
- Open Inventor
- OpenGL
- coordinate system
- X Window System Problems
- header
- Compiling With the GLX Extension
- rendering mode
- Some Background on Visuals
- speed considerations with X
- Mapping the Window
- visual
- GLX and Overloaded Visuals
- OpenGL
- include files
- Compiling With the GLX Extension
- integrating with IRIS IM
- Integrating Your OpenGL Program With IRIS IM
- OpenGL Porting Guide
- What This Guide Contains
- opening X displays
- Opening the X Display
- optimizing
- conditional statements
- Examples for Optimizing Program Structure
- depth buffering
- Using Depth-Buffering Efficiently
- fill rates
- Getting the Optimum Fill Rates
- fog
- Optimizing Per-Fragment Operations on Mid-Range Systems
- frame rates
- Optimizing Frame Rate Performance
- glDrawPixels()
- Drawing Pixels Fast
- imaging pipeline
- Optimizing the Imaging Pipeline
- loading
- Tuning the Imaging Pipeline
- pixel drawing
- Drawing Pixels Fast
- polygons
- Optimizing Triangles and Polygons
- rasterization on RealityEngine
- Optimizing Rasterization
- RealityEngine performance
- Optimizing Performance on RealityEngine Systems
- texture mapping
- Getting the Optimum Fill Rates
- zooming
- Using Pixel Operations Effectively
- optimizing
- compilation
- CPU Tuning: Basics
- concave polygons
- Using Peak Performance Primitives for Drawing
- database by preprocessing
- Preprocessing Drawing Data: Introduction
- database traversal
- Optimizing Database Rendering Code
- display lists
- CPU Tuning: Display Lists
- drawing
- Tuning the Geometry Subsystem
- lighting
- Optimizing Lighting Performance
- loops
- Examples for Optimizing Program Structure
- rendering data
- Optimizing the Data Organization
- rendering loops
- Optimizing Database Rendering Code
- Options menu (ogldebug)
- Using the Commands Menu to Interact With Your Program
- OS/2
- Using OpenGL With the X Window System
- OSF/Motif
- and Xt
- Xt Library
- OSF/Motif
- Using OpenGL With the X Window System
- See also widgets, IRIS IM.
- Widgets and the Xt Library
- osview
- Isolating Bottlenecks in Your Application: Overview
- Achieving Accurate Timing Measurements
- Minimizing Lookup
- Measuring Cache-Miss and Page-Fault Overhead
- overlays
- colormaps
- Overlay Troubleshooting
- GLwMDrawingArea widget
- Introduction to Overlays
- using XRaiseWindow()
- Creating Overlays
- overlays
- Using Overlays
- Introduction to Overlays
- clipped
- Overlay Troubleshooting
- input events
- Overlay Troubleshooting
- transparency
- Introduction to Overlays
- troubleshooting
- Overlay Troubleshooting
- window hierarchy
- Overlay Troubleshooting
- overloaded visuals
- GLX and Overloaded Visuals
- packed pixels extension
- pixel types
- Using Packed Pixels
- packed pixels extension
- EXT_packed_pixels—The Packed Pixels Extension
- paging
- Memory Organization
- parameters determining performance
- Benchmarking Basics
- patterned lines
- Optimizing Line Drawing
- pbuffers
- direct rendering
- PBuffers and Pixmaps
- indirect rendering
- PBuffers and Pixmaps
- preserved
- Volatile and Preserved Pbuffers
- Creating a PBuffer
- volatile
- Volatile and Preserved Pbuffers
- volatile, preserved pbuffer
- Creating a PBuffer
- pbuffers
- SGIX_pbuffer—The Pixel Buffer Extension
- and GLXFBConfig
- Choosing a GLXFBConfigSGIX Construct
- on InfiniteReality systems
- Miscellaneous Performance Hints
- Offscreen Rendering and Framebuffer Management
- PC sampling
- Measuring Cache-Miss and Page-Fault Overhead
- pdb routines
- Libraries for Benchmarking
- pdbClose()
- Using libpdb
- pdbMeasureRate()
- Example for pdbRead
- pdbOpen()
- Using libpdb
- Using libpdb
- pdbWriteRate()
- Example for pdbMeasureRate()
- per-fragment operations
- efficient use
- Using Expensive Per-Fragment Operations Efficiently
- per-pixel operations
- Isolating Bottlenecks in Your Application: Overview
- per-polygon operations
- finding bottlenecks
- Isolating Bottlenecks in Your Application: Overview
- perf.c discussion
- Tuning Example
- perf.c example program
- Benchmarks
- performance
- InfiniteReality systems
- Optimizing Performance on InfiniteReality Systems
- instruments
- SGIX_instruments—The Instruments Extension
- O2 systems
- Optimizing Performance on O2™ Systems
- performance
- clearing bitplanes
- Using Clear Operations
- determining parameters
- Benchmarking Basics
- estimates
- Benchmarking Basics
- Achieving Accurate Benchmarking Results
- influencing factors
- Factors Influencing Performance
- measurements
- SGIX_instruments—The Instruments Extension
- multisampling
- Optimizing Multisampling and Transparency
- penalties with lighting
- Optimizing Lighting Performance
- Performance DataBase(pdb) routines
- Libraries for Benchmarking
- performance See low-end systems, mid-range systems, IMPACT systems, RealityEngine, O2 systems, InfiniteReality systems.
- Choosing Features for Optimum Performance
- pipeline
- performance factors
- Factors Influencing Performance
- pipeline
- 3-stage model
- Three-Stage Model of the Graphics Pipeline
- CPU stage
- Three-Stage Model of the Graphics Pipeline
- raster subsystem
- Isolating Bottlenecks in Your Application: Overview
- tuning
- About Pipeline Tuning
- pixels
- optimizing drawing
- Drawing Pixels Fast
- transparent
- EXT_visual_info—The Visual Info Extension
- pixel buffer extension
- SGIX_pbuffer—The Pixel Buffer Extension
- SGIX_dm_pbuffer—The Digital Media Pbuffer Extension
- pixel drawing
- optimizing with framezoom
- Low-End Specific Extensions
- pixel formats
- using DMA on low-end systems
- Using Pixel Operations Effectively
- pixel path tuning
- Tuning the Imaging Pipeline
- pixel path. See also imaging pipeline.
- Optimizing the Imaging Pipeline
- pixel storage modes
- Using 3D Textures
- EXT_packed_pixels—The Packed Pixels Extension
- and import context
- Importing a Context
- pixel texture extension
- SGIX_pixel_texture—The Pixel Texture Extension
- pixel types using packed pixels
- Using Packed Pixels
- pixelmap (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- pixmaps
- Creating and Using Pixmaps
- and exposing windows
- Exposing a Window
- as resources
- Resources As Server Data
- See also X pixmaps, GLX pixmaps.
- Creating and Using Pixmaps
- pixmaps
- Using Pixmaps
- and exposing windows
- Exposing a Window
- and GLXFBConfig
- Describing a Drawable With a GLXFBConfigSGIX Construct
- Retrieving FBConfig Attribute Values
- and pbuffer
- PBuffers and Pixmaps
- creating
- Using Pixmaps
- pixmode (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- planes
- overlay
- Using Overlays
- popup
- Note for IRIS GL Users
- pntsize (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- points
- and multisampling
- Multisampled Points
- point parameter extension
- SGIS_point_parameters—The Point Parameters Extension
- points
- GL_NICEST smooth hint
- Multisampled Points
- polling instruments
- Retrieving Information
- polygons
- grouping primitives
- Using Peak Performance Primitives for Drawing
- large
- Mixing Computation With Graphics
- optimizing
- Modeling to the Graphics Pipeline
- RealityEngine
- Optimizing Geometry Performance
- polygons
- antialiasing
- General Tips for Performance Improvement
- influencing performance
- Benchmarking Basics
- multisampling
- Multisampled Polygons
- optimizing
- Examples for Optimizing Program Structure
- Optimizing Triangles and Polygons
- optimizing large polygons
- Using Depth-Buffering Efficiently
- optimum size
- Balancing Polygon Size and Pixel Operations
- reducing number in example program
- Reducing the Number of Polygons
- polymode (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- polysmooth (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- popup menus
- GLwMDrawingArea widget
- Rubber Banding
- popup menus
- Rubber Banding
- code fragment
- Using Popup Menus With the GLwMDrawingArea Widget
- popup planes
- Note for IRIS GL Users
- IRIS GL
- Some IRIS GL Functionality and OpenGL Equivalents
- porting
- Portability
- What This Guide Contains
- porting to Windows NT
- Portability
- preprocessing
- meshes
- Preprocessing Meshes Into Fixed-Length Strips
- vertex loops
- Preprocessing Vertex Loops
- preprocessing
- introduction
- Preprocessing Drawing Data: Introduction
- preserved pbuffer
- Volatile and Preserved Pbuffers
- buffer clobber event
- Directing the Buffer Clobber Event
- primitive length
- RealityEngine
- Optimizing Geometry Performance
- prof sample output
- Using the Profiler
- profiler
- Using the Profiler
- projection matrix debugging
- Blank Window
- prototyping subroutines
- in ANSI C
- Examples for Optimizing Program Structure
- proxy mechanism
- proxy histograms
- Using Proxy Histograms
- proxy textures
- Using 3D Textures
- PseudoColor visuals
- Some Background on Visuals
- PseudoColor visuals
- Choosing Which Colormap to Use
- Less-Rigid Match of GLX Visual and X Visual
- quad buffer stereo
- Quad Buffer Stereo
- quad strips
- Using Peak Performance Primitives for Drawing
- quad strips
- IMPACT
- Achieving Peak Geometry Performance
- QUAD* formats
- Using the Texture Select Extension
- quads on RealityEngine
- Optimizing Geometry Performance
- raster subsystem. See fill-limited code.
- Isolating Bottlenecks in Your Application: Overview
- rasterization
- optimizing on RealityEngine
- Optimizing Rasterization
- read drawable
- Read and Write Drawables
- readcomponent (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- RealityEngine
- fast and slow mode changes
- Optimizing Geometry Performance
- multisampling
- Optimizing Multisampling and Transparency
- optimizing rasterization
- Optimizing Rasterization
- polygons
- Optimizing Geometry Performance
- primitive length
- Optimizing Geometry Performance
- quads
- Optimizing Geometry Performance
- transparency
- Optimizing Multisampling and Transparency
- RealityEngine
- make current read extension
- Possible Match Errors
- optimizing performance
- Optimizing Performance on RealityEngine Systems
- optimizing vertex arrays
- Optimizing Use of the Vertex Arrays
- References menu (ogldebug)
- Using the References Menu for Background Information
- refresh rate of screen
- How Frame Rate Determines Animation Speed
- remote rendering
- data traversal
- Immediate Mode Drawing Versus Display Lists
- remote rendering
- advantage of display lists
- Immediate Mode Drawing Versus Display Lists
- removing backfacing polygons
- Using Backface/Frontface Removal
- rendering
- direct and indirect
- Direct and Indirect Rendering
- optimizing data
- Optimizing the Data Organization
- optimizing loops
- Optimizing Database Rendering Code
- rendering contexts
- creating
- Creating a Rendering Context
- rendering contexts
- creating
- Creating a Rendering Context
- definition
- Rendering Contexts
- rendering extensions
- Rendering Extensions
- resize callback
- Using Drawing-Area Widget Callbacks
- Creating Overlays
- resize callback
- Using Drawing-Area Widget Callbacks
- resources
- widget properties
- Setting Up Fallback Resources
- resource extensions
- Resource Control Extensions
- Resource Manager
- Resources As Server Data
- resources
- Setting Up Fallback Resources
- Resources As Server Data
- definition
- Resources As Server Data
- fallback
- Setting Up Fallback Resources
- two meanings of term
- Resources As Server Data
- RGBA mode
- Background Information About Colormaps
- and GLXFBConfig
- Less-Rigid Match of GLX Visual and X Visual
- RGBwritemask (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- rightbuffer (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- rotation
- Rotation and Translation Problems
- rubber banding
- Rubber Banding
- RunTest()
- Tuning Example
- scene graph
- Optimizing the Data Organization
- CPU Tuning: Basics
- scissoring
- Choosing Features for Optimum Performance
- scissoring
- on low-end systems
- Using Pixel Operations Effectively
- screen clear and animations
- How Frame Rate Determines Animation Speed
- screen refresh time
- How Frame Rate Determines Animation Speed
- screen-door transparency
- Optimizing Multisampling and Transparency
- Color Blending and Screen-Door Transparency
- scrolling and glCopyPixels()
- Using Pixel Operations Effectively
- separable convolution filter
- Separable and General Convolution Filters
- setmon command
- Some IRIS GL Functionality and OpenGL Equivalents
- Performing Stereo Rendering on High-End Systems
- setmonitor (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- setting up ogldebug
- Setting Up ogldebug
- setting window properties
- Creating a Colormap and a Window
- setvideo (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- SGI suffix
- Extensions to OpenGL
- SGI_color_matrix
- SGI_color_matrix—The Color Matrix Extension
- SGI_color_table
- SGI_color_table—The Color Table Extension
- SGI_make_current_read
- EXT_make_current_read—The Make Current Read Extension
- SGI_swap_control
- SGI_swap_control—The Swap Control Extension
- SGI_texture_color_table
- SGI_texture_color_table—The Texture Color Table Extension
- SGI_video_sync
- SGI_video_sync—The Video Synchronization Extension
- SGIS suffix
- Extensions to OpenGL
- SGIS_detail_texture
- SGIS_detail_texture—The Detail Texture Extension
- SGIS_filter4_parameters
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- SGIS_multisample
- SGIS_multisample—The Multisample Extension
- SGIS_point_parameters
- SGIS_point_parameters—The Point Parameters Extension
- SGIS_sharpen_texture
- SGIS_sharpen_texture—The Sharpen Texture Extension
- SGIS_texture_border_clamp
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- SGIS_texture_edge_clamp
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- SGIS_texture_filter4
- SGIS_texture_filter4—The Texture Filter4 Extensions
- SGIS_texture_lod
- SGIS_texture_lod—The Texture LOD Extension
- SGIX suffix
- Extensions to OpenGL
- SGIX_clipmap
- SGIX_clipmap—The Clipmap Extension
- SGIX_dmbuffer
- SGIX_dm_pbuffer—The Digital Media Pbuffer Extension
- SGIX_fbconfig
- SGIX_fbconfig—The Framebuffer Configuration Extension
- SGIX_framezoom
- Low-End Specific Extensions
- SGIX_instruments
- SGIX_instruments—The Instruments Extension
- SGIX_interlace
- SGIX_interlace—The Interlace Extension
- SGIX_list_priority
- SGIX_list_priority—The List Priority Extension
- SGIX_pbuffer
- SGIX_pbuffer—The Pixel Buffer Extension
- SGIX_pixel_texture
- SGIX_pixel_texture—The Pixel Texture Extension
- SGIX_sprite
- SGIX_sprite—The Sprite Extension
- SGIX_swap_barrier
- SGIX_swap_barrier—The Swap Barrier Extension
- SGIX_swap_group
- SGIX_swap_group—The Swap Group Extension
- SGIX_texture4D
- SGIS_texture4D—The 4D Texture Extension
- SGIX_texture_add_env
- SGIX_texture_add_env—The Texture Environment Add Extension
- SGIX_texture_lod_bias
- SGIX_texture_lod_bias—The Texture LOD Bias Extension
- SGIX_texture_multi_buffer
- SGIX_texture_multi_buffer—The Texture Multibuffer Extension
- SGIX_texture_scale_bias
- SGIX_texture_scale_bias—The Texture Scale Bias Extension
- SGIX_texture_select
- SGIS_texture_select—The Texture Select Extension
- SGIX_video_resize
- SGIX_video_resize—The Video Resize Extension
- SGIX_video_source
- SGIX_video_source—The Video Source Extension
- shaded lines
- Optimizing Line Drawing
- shading
- Smooth Shading Versus Flat Shading
- Using Expensive Per-Fragment Operations Efficiently
- sharing resources
- Resources As Server Data
- sharpen texture extension
- customizing
- Customizing the LOD Extrapolation Function
- magnification filters
- How to Use the Sharpen Texture Extension
- sharpen texture extension
- SGIS_sharpen_texture—The Sharpen Texture Extension
- example program
- Sharpen Texture Example Program
- Reality Engine systems
- Optimizing Rasterization
- sheared image
- Pixel and Texture Write Problems
- Silicon Graphics X server
- Silicon Graphics X Server
- simple lighting model
- Optimizing Lighting Performance
- single-buffer mode
- Optimizing Frame Rate Performance
- single-channel visuals
- Choosing a GLXFBConfigSGIX Construct
- single-sided lighting
- Optimizing Lighting Performance
- Sirius video
- Some IRIS GL Functionality and OpenGL Equivalents
- smoke
- Modeling to the Graphics Pipeline
- smooth shading
- Smooth Shading Versus Flat Shading
- software-supported features (low-end)
- Choosing Features for Optimum Performance
- Solid Impact
- Using Textures
- source code for examples
- Location of Example Source Code
- specification location
- Example Programs
- specifying minimum/maximum LOD
- Specifying a Minimum or Maximum Level of Detail
- speed considerations
- Mapping the Window
- sphere example
- Tuning Example
- sprite extension
- SGIX_sprite—The Sprite Extension
- and multiple processors
- SGIX_sprite—The Sprite Extension
- stack trace
- Inheritance Issues
- starting ogldebug
- Starting ogldebug
- StaticColor visuals
- Some Background on Visuals
- StaticColor visuals
- Using the Visual Info Extension
- Less-Rigid Match of GLX Visual and X Visual
- StaticGray visuals
- Some Background on Visuals
- StaticGray visuals
- Using the Visual Info Extension
- Less-Rigid Match of GLX Visual and X Visual
- stencil buffer
- Choosing Features for Optimum Performance
- StencillingIsFast()
- Using libisfast
- stereo rendering
- Stereo Rendering
- strings
- Using Fonts and Strings
- strings
- Using Fonts and Strings
- strips
- Preprocessing Meshes Into Fixed-Length Strips
- subimage
- Creating a Detail Texture and a Low-Resolution Texture
- swap barrier extension
- SGIX_swap_barrier—The Swap Barrier Extension
- swap control extension
- SGI_swap_control—The Swap Control Extension
- swap group extension
- SGIX_swap_group—The Swap Group Extension
- swap groups, synchronizing
- SGIX_swap_barrier—The Swap Barrier Extension
- swapinterval (IRIS GL)
- SGI_swap_control—The Swap Control Extension
- swapping buffers
- Swapping Buffers
- switch statements
- Examples for Optimizing Program Structure
- synchronizing buffer swaps
- SGIX_swap_group—The Swap Group Extension
- synchronizing swap groups
- SGIX_swap_barrier—The Swap Barrier Extension
- synchronizing video
- SGI_video_sync—The Video Synchronization Extension
- tessellation
- General Tips for Performance Improvement
- Some IRIS GL Functionality and OpenGL Equivalents
- tessellation, object space
- GLU_EXT_object_space—The Object Space Tess Extension
- tessellations, retrieving
- GLU_EXT_NURBS_tessellator—The NURBS Tessellator Extension
- Test()
- Tuning Example
- tevbind (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- tevdef (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- texbind (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- texdef (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- text handling
- Using Fonts and Strings
- textures
- 4D texture extension
- SGIS_texture4D—The 4D Texture Extension
- filter4 parameters extension
- SGIS_filter4_parameters—The Filter4 Parameters Extension
- interlacing
- SGIX_interlace—The Interlace Extension
- optimizing
- Choosing Modes Wisely
- texture filter4 extension
- SGIS_texture_filter4—The Texture Filter4 Extensions
- texture LOD extension
- SGIS_texture_lod—The Texture LOD Extension
- texture multi buffer extension
- SGIX_texture_multi_buffer—The Texture Multibuffer Extension
- texture border clamp extension
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- texture borders
- Managing Textures on InfiniteReality Systems
- texture color table extension
- SGI_texture_color_table—The Texture Color Table Extension
- texture edge clamp extensions
- SGIS_texture_edge/border_clamp—Texture Clamp Extensions
- texture environment add extension
- SGIX_texture_add_env—The Texture Environment Add Extension
- texture extensions
- Texturing Extensions
- texture filter4 extension
- SGIS_texture_filter4—The Texture Filter4 Extensions
- texture generation
- Optimizing Geometry Performance
- texture images
- and convolution extension
- Separable and General Convolution Filters
- texture internal formats
- texture select
- Why Use the Texture Select Extension?
- texture LOD bias extension
- SGIX_texture_lod_bias—The Texture LOD Bias Extension
- texture LOD extension
- SGIS_texture_lod—The Texture LOD Extension
- texture magnification
- SGIS_sharpen_texture—The Sharpen Texture Extension
- texture mapping
- Using libisfast
- texture mapping
- mid-range systems
- Optimizing Per-Fragment Operations on Mid-Range Systems
- optimizing
- Getting the Optimum Fill Rates
- texture memory
- DMA Display Lists on Indigo2 IMPACT Systems
- texture memory on O2 systems
- Texture Mapping
- texture memory, efficient use
- SGIS_texture_select—The Texture Select Extension
- texture multibuffer extension
- SGIX_texture_multi_buffer—The Texture Multibuffer Extension
- texture objects
- and detail texture
- Using Detail Texture and Texture Object
- texture objects
- on O2 systems
- Using Textures
- texture objects vs. display lists
- Managing Textures on InfiniteReality Systems
- texture select extension
- SGIS_texture_select—The Texture Select Extension
- texture subimages on InfiniteReality
- Managing Textures on InfiniteReality Systems
- texture wrap modes
- Using 3D Textures
- texture_scale_bias extension
- SGIX_texture_scale_bias—The Texture Scale Bias Extension
- textured polygons
- Modeling to the Graphics Pipeline
- TextureMappingIsFast()
- Using libisfast
- textures
- IMPACT systems
- Using Textures
- on Indigo2 and OCTANE systems
- Using Textures
- on InifiniteReality systems
- Managing Textures on InfiniteReality Systems
- switching
- Choosing Modes Wisely
- texturing
- Choosing Features for Optimum Performance
- See also textures
- Using Expensive Per-Fragment Operations Efficiently
- texturing
- Using Expensive Per-Fragment Operations Efficiently
- performance cost
- Optimizing Multisampling and Transparency
- three-stage model of the graphics pipeline
- Three-Stage Model of the Graphics Pipeline
- tiles
- Moving the Clip Center
- timing
- background processes
- Achieving Accurate Timing Measurements
- glFinish()
- Achieving Accurate Timing Measurements
- measurements
- Taking Timing Measurements
- timing
- loops
- Achieving Accurate Timing Measurements
- measurements
- Achieving Accurate Timing Measurements
- TLB
- Memory Organization
- tlutbind (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- tlutdef (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- top-level widget
- Creating the Widgets
- toroidal loading
- Toroidal Loading
- trace files
- Creating a Trace File to Discover OpenGL Problems
- TRAM
- DMA Display Lists on Indigo2 IMPACT Systems
- transform rate
- Benchmarking Basics
- transform-limited code
- finding bottlenecks
- Isolating Bottlenecks in Your Application: Overview
- optimizing
- Getting the Optimum Fill Rates
- tuning
- Tuning the Geometry Subsystem
- translation-lookaside buffer. See TLB.
- Memory Organization
- translations. See actions and translations.
- Using Actions and Translations
- transparency
- in overlays
- Introduction to Overlays
- on RealityEngine
- Optimizing Multisampling and Transparency
- transparency
- Other Considerations
- transparent pixels
- Creating a Colormap and a Window
- EXT_visual_info—The Visual Info Extension
- traversal
- About OpenGL Drawing-Area Widgets
- traversal
- Keyboard Input Disappears
- remote rendering
- Immediate Mode Drawing Versus Display Lists
- traversal of data
- CPU Tuning: Basics
- triangle fans
- Using Peak Performance Primitives for Drawing
- triangle strips
- Optimizing Triangles and Polygons
- Using Peak Performance Primitives for Drawing
- Preprocessing Vertex Loops
- on IMPACT
- Achieving Peak Geometry Performance
- troubleshooting
- IRIS IM input disappears
- Keyboard Input Disappears
- overlays
- Overlay Troubleshooting
- troubleshooting
- widgets
- Widget Troubleshooting
- TrueColor visuals
- Less-Rigid Match of GLX Visual and X Visual
- Installing the Colormap
- Choosing Which Colormap to Use
- Some Background on Visuals
- tuning
- animations
- Tuning Animation
- Elan graphics
- Optimizing Performance on Mid-Range Systems
- examining assembly code
- Examining Assembly Code
- example program
- Tuning Example
- Extreme graphics
- Optimizing Performance on Mid-Range Systems
- IMPACT systems
- Optimizing Performance on Indigo2 IMPACT and OCTANE Systems
- Indigo2 XL
- Optimizing Performance on Low-End Graphics Systems
- Indy
- Optimizing Performance on Low-End Graphics Systems
- pipeline
- About Pipeline Tuning
- single-buffer mode
- Optimizing Frame Rate Performance
- using textured polygons
- Modeling to the Graphics Pipeline
- tuning
- advanced
- CPU Tuning: Advanced Techniques
- clear
- Mixing Computation With Graphics
- display lists
- CPU Tuning: Display Lists
- fundamentals
- Tuning Graphics Applications: Fundamentals
- immediate mode
- CPU Tuning: Immediate Mode Drawing
- pixel path
- Tuning the Imaging Pipeline
- reducing frame rate
- How Frame Rate Determines Animation Speed
- transform-limited code
- Tuning the Geometry Subsystem
- tuning with instruments
- About SGIX_instruments
- TV_COMPONENT_SELECT (IRIS GL)
- Some IRIS GL Functionality and OpenGL Equivalents
- underlay planes
- Introduction to Overlays
- unrolling
- Examples for Optimizing Program Structure
- Preprocessing Vertex Loops
- updating clipmap stack
- Updating the Clipmap Stack
- using Xlib
- Using Xlib
- vertex array extension
- optimizing for RealityEngine
- Optimizing Use of the Vertex Arrays
- vertex arrays
- Using Vertex Arrays
- vertex fogging
- Optimizing Geometry Operations
- vertex loops
- preprocessing
- Preprocessing Vertex Loops
- vertical retrace
- How Frame Rate Determines Animation Speed
- Mixing Computation With Graphics
- video
- dithering
- Some IRIS GL Functionality and OpenGL Equivalents
- interlace extension
- SGIX_interlace—The Interlace Extension
- video
- stereo rendering
- Stereo Rendering
- video device control
- Some IRIS GL Functionality and OpenGL Equivalents
- video extensions
- Video Extensions
- video resize extension
- SGIX_video_resize—The Video Resize Extension
- video source extension
- SGIX_video_source—The Video Source Extension
- example program
- SGIX_video_source—The Video Source Extension
- video sync extension
- SGI_video_sync—The Video Synchronization Extension
- virtual clipmaps
- Virtual Clipmaps
- virtual key bindings
- Using Actions and Translations
- virtual offset
- Virtual Clipmaps
- visuals
- and colormaps
- Creating a Colormap and a Window
- and contexts
- Less-Rigid Similarity Requirements When Matching Context and Drawable
- colormaps
- Some Background on Visuals
- for multisampling
- Using the Multisample Extension
- gray scale
- Using the Visual Info Extension
- memory savings
- Running OpenGL Applications Using a Single Visual
- mutiple-visual applications
- Running OpenGL Applications Using a Single Visual
- static color
- Using the Visual Info Extension
- static gray
- Using the Visual Info Extension
- visual info extension
- EXT_visual_info—The Visual Info Extension
- used in overlay example
- Creating Overlays
- visual rating extension
- EXT_visual_rating—The Visual Rating Extension
- visuals
- Some Background on Visuals
- Some Background on Visuals
- choosing
- Using Visuals
- definition
- GLX and Overloaded Visuals
- definition
- GLX and Overloaded Visuals
- OpenGL visual
- GLX and Overloaded Visuals
- overloaded
- GLX and Overloaded Visuals
- selecting
- Selecting a Visual
- single-channel
- Choosing a GLXFBConfigSGIX Construct
- single-visual applications
- Running OpenGL Applications Using a Single Visual
- visual info extension
- EXT_visual_info—The Visual Info Extension
- VL_PACKING_ABGR8
- Pixel Formats
- VL_PACKING_ARGB_1555
- Pixel Formats
- VL_PACKING_X444_332
- Pixel Formats
- volatile pbuffers
- Volatile and Preserved Pbuffers
- Creating a PBuffer
- buffer clobber event
- Directing the Buffer Clobber Event
- volume rendering
- Why Use the 3D Texture Extension?
- and texture color table
- Why Use a Texture Color Table?
- WhitePixel color macro
- Color Variation Across Colormaps
- widgets
- Widgets and the Xt Library
- callbacks
- Using Drawing-Area Widget Callbacks
- container
- Creating the Widgets
- error handling
- Choosing the Visual for the Drawing-Area Widget
- form
- Creating Overlays
- frame
- Creating Overlays
- IRIS IM
- Xt Library
- Widgets and the Xt Library
- properties
- Setting Up Fallback Resources
- troubleshooting
- Widget Troubleshooting
- XmPrimitive
- About OpenGL Drawing-Area Widgets
- widget sets
- Widgets and the Xt Library
- widgets
- definition
- Widgets and the Xt Library
- drawing-area
- About OpenGL Drawing-Area Widgets
- input handling
- Background Information
- mapping window
- Mapping the Window
- with identical characteristics
- Creating Multiple Widgets With Identical Characteristics
- windows
- as resources
- Resources As Server Data
- window manager
- 4Dwm
- Using OpenGL With the X Window System
- window properties
- setting
- Creating a Colormap and a Window
- window systems
- NT
- Using OpenGL With the X Window System
- window systems
- OS/2
- Using OpenGL With the X Window System
- windows
- mapping
- Mapping the Window
- Windows NT
- Using OpenGL With the X Window System
- Portability
- word-aligned data
- General Performance Tips
- work procedures. See workprocs.
- Controlling an Animation With Workprocs
- workprocs
- adding
- General Workproc Information
- removing
- General Workproc Information
- workprocs
- Controlling an Animation With Workprocs
- Controlling an Animation With Workprocs
- example program
- Workproc Example
- wrap modes for textures
- Using 3D Textures
- write drawable
- Read and Write Drawables
- X
- bitmap fonts
- Using Fonts and Strings
- color macros
- Color Variation Across Colormaps
- coordinate system
- X Window System Problems
- fallback resources
- Setting Up Fallback Resources
- opening display
- Opening the X Display
- pixmaps
- Creating and Using Pixmaps
- resources
- Resources As Server Data
- speed considerations
- Mapping the Window
- X double buffering extension
- Swapping Buffers
- X extensions
- double buffering
- Swapping Buffers
- GLX
- Silicon Graphics X Server
- X input extension
- Xlib Event Handling
- X server on Silicon Graphics systems
- Silicon Graphics X Server
- X visual See visuals
- GLX and Overloaded Visuals
- X window and channel
- Using the Video Resize Extension
- X Window System
- introduction
- X Window System on Silicon Graphics Systems
- swap group
- Swap Group Details
- terminology
- Background and Terminology
- XCreateColormap()
- Creating a Colormap and a Window
- Creating a Colormap and a Window
- Overlay Troubleshooting
- XCreatePixmap().
- Creating and Using Pixmaps
- XCreateWindow()
- Creating a Colormap and a Window
- xdpyinfo
- Some Background on Visuals
- Silicon Graphics X Server
- GLX and Overloaded Visuals
- XFree()
- Using the Visual Info Extension
- XGetVisualInfo()
- Selecting a Visual
- Some Background on Visuals
- XID
- Resources As Server Data
- Importing a Context
- for pbuffer
- Creating a PBuffer
- XInstallColormap()
- Installing the Colormap
- Xlib
- event handling
- Handling Mouse Events
- Xlib
- colormaps
- Colormap Example
- example program
- Simple Xlib Example Program
- XMapWindow()
- Mapping the Window
- XMatchVisualInfo()
- Some Background on Visuals
- XmCreateSimplePopupMenu()
- Using Popup Menus With the GLwMDrawingArea Widget
- XmPrimitive widget
- About OpenGL Drawing-Area Widgets
- XOpenDisplay()
- Opening the X Display
- Opening the X Display
- XRaiseWindow()
- Introduction to Overlays
- Creating Overlays
- XSetWMColormapWindows()
- Overlay Troubleshooting
- Multiple Colormap Issues
- Choosing Which Colormap to Use
- Installing the Colormap
- XSetWMProperties()
- Creating a Colormap and a Window
- Creating a Colormap and a Window
- XSGIvc extension
- Some IRIS GL Functionality and OpenGL Equivalents
- Some IRIS GL Functionality and OpenGL Equivalents
- Divided-Screen Stereo
- XStoreName()
- Creating a Colormap and a Window
- XSynchronize()
- Inheritance Issues
- Xt
- Xt Library
- Xt Library
- XtAddCallback()
- Using Drawing-Area Widget Callbacks
- XtAppAddWorkProc()
- General Workproc Information
- XtCreateManagedChild()
- Mapping the Window
- XtCreateManagedWidget()
- Selecting a Visual
- XtOpenApplication()
- Opening the X Display
- Setting Up Fallback Resources
- Setting Up Fallback Resources
- XtOpenApplication()
- Opening the X Display
- XtRealizeWidget()
- Mapping the Window
- XtRemoveWorkProc()
- General Workproc Information
- z axis
- Rotation and Translation Problems
- zooming
- Using Pixel Operations Effectively