Index
Prev |  |

## Index

-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

Prev | Table of Contents |
Appendix D. Extensions on Different Silicon Graphics Systems |  |