Full Table of Contents

Contents

About This Guide

What This Guide Contains

What You Should Know Before Reading This Guide

Background Reading

OpenGL and Associated Tools and Libraries

X Window System: Xlib, X Toolkit, and OSF/Motif

Other Sources

Conventions Used in This Guide

Typographical Conventions

Function Naming Conventions

1. - OpenGL on Silicon Graphics Systems

Using OpenGL With the X Window System

The GLX Extension to the X Window System

Libraries, Tools, Toolkits, and Widget Sets

RapidApp

Open Inventor

IRIS ViewKit

The IRIS IM Widget Set

The Xlib Library

A Note to IRIS GL Users

Extensions to OpenGL

Debugging and Performance Optimization

Debugging Your Program

Tuning Your OpenGL Application

Maximizing Performance With IRIS Performer

Location of Example Source Code

2. - OpenGL and X: Getting Started

Background and Terminology

The X Window System on Silicon Graphics Systems

The Silicon Graphics X Server

The GLX Extension to X

Compiling With the GLX Extension

X Window System Concepts

Visuals

Drawables

Rendering Contexts

Resources

Colormaps

Libraries, Toolkits, and Tools

Widgets and the Xt Library

The Xt Library

For More Information

Other Toolkits and Tools

Integrating Your OpenGL Program With IRIS IM

Simple Motif Example Program

Looking at the Example Program

Opening the X Display

Selecting a Visual

Creating a Rendering Context

Creating the Window

Binding the Context to the Window

Mapping the Window

Summary

Compiling With OpenGL and Related Libraries

Link Lines for Individual Libraries

Link Lines for Groups of Libraries

3. - OpenGL and X: Examples

Using Widgets

What are OpenGL Drawing-Area Widgets?

Drawing-Area Widget Setup and Creation

Setting Up Fallback Resources

Creating the Widgets

Choosing the Visual for the Drawing-Area Widget

Creating Multiple Widgets With Identical Characteristics

Using Drawing-Area Widget Callbacks

Input Handling With Widgets and Xt

Background Information

Using the Input Callback

Using Actions and Translations

Creating Colormaps

Widget Troubleshooting

Keyboard Input Disappears

Inheritance Issues

Using Xlib

Simple Xlib Example Program

Creating a Colormap and a Window

Installing the Colormap

Xlib Event Handling

Handling Mouse Events

Exposing a Window

Using Fonts and Strings

4. - OpenGL and X: Advanced Topics

Using Animations

Swapping Buffers

Controlling an Animation With Workprocs

General Workproc Information

Workproc Example

Controlling an Animation With Timeouts

Using Overlays

Introduction to Overlays

A Note for IRIS GL Users

How to Create Overlays

Overlay Troubleshooting

Rubber Banding

Using Popup Menus With the GLwMDrawingArea Widget

Using Visuals

Some Background on Visuals

Running OpenGL Applications Using a Single Visual

Using Colormaps

Background Information About Colormaps

Color Variation Across Colormaps

Multiple Colormap Issues

Choosing Which Colormap to Use

Colormap Example

Stereo Rendering

Stereo Rendering Background Information

Quad Buffer Stereo

Divided-Screen Stereo

For More Information

How to Do Stereo Rendering

Performing Stereo Rendering on High-End Systems

Performing Stereo Rendering on Low-End and Mid-Range Systems

Using Pixmaps

Creating and Using Pixmaps

Direct and Indirect Rendering

Performance Considerations for X and OpenGL

Portability

5. - Introduction to OpenGL Extensions

Determining Extension Availability

How to Check for OpenGL Extension Availability

Example Program: Checking for Extension Availability

Checking for GLX Extension Availability

Finding Information About Extensions

6. - Texturing Extensions

The Texture Extension

Why Use the Texture Extension?

Using the Texture Extension

The Texture Extension Proxy Mechanism

Extended Functions

The Texture Object Extension

How Texture Objects Work

Using Texture Objects

Texture Object Names

Editing and Querying Texture Objects

Texture Priorities and Residency

Default Textures

New and Extended Functions

The Subtexture Extension

Why Use the Subtexture Extension?

Using Subtextures

Using Null Images With Subtextures

New Functions

The Copy Texture Extension

Why Use the Copy Texture Extension?

Copying Texture Images

New Functions

The 3D Texture Extension

Why Use the 3D Texture Extension?

Using 3D Textures

3D Texture Example Program

New Functions

The Texture Color Table Extension

Why Use a Texture Color Table?

Using Texture Color Tables

The Sharpen Texture Extension

Using the Sharpen Texture Extension

How to Use the Sharpen Texture Extension

How Sharpen Texture Works

Customizing the LOD Extrapolation Function

Using Sharpen Texture and Texture Object

Sharpen Texture Example Program

New Functions

The Detail Texture Extension

Using the Detail Texture Extension

Creating a Detail Texture and a Low-Resolution Texture

How Detail Texture Is Computed

Customizing the Detail Function

Using Detail Texture and Texture Object

Detail Texture Example Program

New Functions

Texture Clamp Extensions

Texture Clamping Background Information

Why Use the Texture Clamp Extensions?

Using the Texture Clamp Extensions

The Texture LOD Extension

Specifying a Minimum or Maximum Level of Detail

Specifying Image Array Availability

7. - Imaging and Blending Extensions

Introduction to Imaging and Blending Extensions

Where Extensions Are in the Imaging Pipeline

Functions Affected by Imaging Extensions

The ABGR Extension

The Packed Pixels Extension

Why Use the Packed Pixels Extension?

Using Packed Pixels

What the Different Pixel Types Mean

The Color Matrix Extension

The Convolution Extension

Performing Convolution

Separable and General Convolution Filters

New Functions

The Histogram and Minmax Extensions

Using the Histogram Extension

Using the Minmax Part of the Histogram Extension

Using Proxy Histograms

New Functions

The Color Table Extension

Why Use the Color Table Extension?

Specifying a Color Table

Using Framebuffer Image Data for Color Tables

Where Are the Lookup Tables in the Image Pipeline?

New Functions

The Interlace Extension

Using the Interlace Extension

How to Use Interlace and Copy Texture Together

Blending Extensions

The Constant Color Blending Extension

Using Constant Colors for Blending

New Functions

The Minmax Blending Extension

Using a Blend Equation

New Functions

The Logical Operation Blending Extension

The Blend Subtract Extension

8. - Miscellaneous OpenGL Extensions

The Polygon Offset Extension

Polygon Offset Example Program

New Functions

The Vertex Array Extension

Why and When to Use the Vertex Array Extension

How the Vertex Array Extension Works

Specifying Arrays for Different Kinds of Data

Rendering the Arrays

New Functions

The Multisample Extension

Introduction to Multisampling

When to Use Multisampling

Using the Multisample Extension

Using Advanced Multisampling Options

Color Blending and Screen-Door Transparency

Using a Multisample Mask to Fade Levels of Detail

Accumulating Multisampled Images

How Multisampling Affects Different Primitives

Multisampled Points

Multisampled Lines

Multisampled Polygons

Multisample Rasterization of Pixels and Bitmaps

New Functions

9. - Extensions to GLX

The Make Current Read Extension

Possible Match Errors

New Functions

The Visual Info Extension

Using the Visual Info Extension

Using Transparent Pixels

The Visual Rating Extension

Using the Visual Rating Extension

The Video Synchronization Extension

New Functions

The Swap Control Extension

New Functions

The Import Context Extension

Importing a Context

Retrieving Display and Context Information

New Functions

The Framebuffer Configuration Extension

Why Use the Framebuffer Configuration Extension?

Describing a Drawable With a GLXFBConfig Construct

Less-Rigid Similarity Requirements When Matching Context and Drawable

Less-Rigid Match of GLX Visual and X Visual

The GLXFBConfig Construct

Choosing a GLXFBConfig Construct

Retrieving GLXFBConfig Attribute Values

How a GLXFBConfig Is Selected

New Functions

The Pixel Buffer Extension

Rendering to a GLXPbuffer

Directing the Buffer Clobber Event

New Functions

The Video Source Extension

New Functions

10. - Debugging OpenGL Programs

Ogldebug Overview

How ogldebug Operates

Setting Up ogldebug

Using a Configuration File

Basic Debugging With ogldebug

Starting ogldebug

Creating a Trace File to Discover OpenGL Problems

Interacting With ogldebug

Commands for Basic Interaction

Understanding Display Areas

Using Checkboxes

Control-Flow Checkboxes

Trace Checkboxes

Fast Mode Checkboxes

Using Menus to Interact With ogldebug

Using the File Menu to Interact With ogldebug

Using the Commands Menu to Interact With Your Program

Using the Options Menu to Access Information

Using the References Menu for Background Information

Tips for Debugging Graphics Programs

General Debugging Tips

Specific Problems and Troubleshooting

Blank Window

Rotation and Translation Problems

Depth Buffering Problems

Animation Problems

Lighting Problems

X Window System Problems

Pixel and Texture Write Problems

System-Specific Problems

11. - Tuning Graphics Applications: Fundamentals

Why Is Tuning Useful?

What Is Pipeline Tuning?

Three-Stage Model of the Graphics Pipeline

Isolating Bottlenecks in the Pipeline: Overview

Factors Influencing Performance

Tuning Animation

Factors Contributing to Animation Speed

Optimizing Frame Rate Performance

Optimizing Cache and Memory Use

How Memory Is Organized

How to Minimize Memory Paging

Minimizing Lookup

Minimizing Cache Misses

Measuring Cache-Miss and Page-Fault Overhead

Taking Timing Measurements

Benchmarking Basics

Achieving Accurate Timing Measurements

Achieving Accurate Benchmarking Results

12. - Tuning the Pipeline

CPU Tuning: Basics

Immediate Mode Drawing Versus Display Lists

CPU Tuning: Immediate Mode Drawing

Optimizing the Data Organization

Optimizing Database Rendering Code

Examples for Optimizing Data Structures for Drawing

Examples for Optimizing Program Structure

Using Specialized Drawing Subroutines and Macros

Preprocessing Drawing Data: Introduction

Preprocessing Meshes Into Fixed-Length Strips

Preprocessing Vertex Loops

CPU Tuning: Display Lists

CPU Tuning: Advanced Techniques

Mixing Computation With Graphics

Examining Assembly Code

Using Additional Processors for Complex Scene Management

Modeling to the Graphics Pipeline

Tuning the Geometry Subsystem

Using Fast Drawing Modes

Using Peak Performance Primitives for Drawing

Optimizing Lighting Performance

Lighting Operations With Noticeable Performance Costs

Lighting Operations With Significant Performance Costs

Practices to Avoid

Using Expensive Modes Efficiently

Advanced Transform-Limited Tuning Techniques

Tuning the Raster Subsystem

Using Backface/Frontface Removal

Using Expensive Per-Fragment Operations Efficiently

Using Depth-Buffering Efficiently

Other Considerations

Balancing Polygon Size and Pixel Operations

Clearing the Color and Depth Buffers Simultaneously

Tuning the Imaging Pipeline

13. - Tuning Graphics Applications: Examples

Drawing Pixels Fast

Tuning Example

Testing for CPU Limitation

Using the Profiler

Testing for Fill Limitation

Working on a Geometry-Limited Program

Smooth Shading Versus Flat Shading

Reducing the Number of Polygons

Testing Again for Fill Limitation

14. - System-Specific Tuning

Optimizing Performance on Low-End Graphics Systems

Choosing Features for Optimum Performance

Using the Pipeline Effectively

Using Geometry Operations Effectively

Optimizing Line-Drawing

Optimizing Triangles and Polygons

Using Per-Fragment Operations Effectively

Getting the Optimum Fill Rates

Using Per-Fragment Operations Effectively

Low-End Specific Extensions

Optimizing Performance on Mid-Range Systems

General Performance Tips

Optimizing Geometry Operations on Mid-Range Systems

Optimizing Per-Fragment Operations on Mid-Range Systems

Optimizing Performance on Indigo2 IMPACT Systems

General Tips for Performance Improvement

Achieving Peak Geometry Performance

Using Textures

Using Images

Accelerating Color Space Conversion

Using Display Lists Effectively

Display List Compilation on Indigo2 IMPACT Hardware

DMA Display Lists on Indigo2 IMPACT Systems

Offscreen Rendering Capabilities

Optimizing Performance on RealityEngine Systems

Optimizing Geometry Performance

Optimizing Rasterization

Optimizing Use of the Vertex Array Extension

Optimizing Multisampling and Transparency

Optimizing the Imaging Pipeline

Using the Color Matrix and the Color Writemask

A. - OpenGL and IRIS GL

Some IRIS GL Functionality and OpenGL Equivalents

B. - Benchmarks

C. - Benchmarking Libraries: libpdb and libisfast

Libraries for Benchmarking

Using libpdb

Example for pdbRead

Example for pdbMeasureRate()

Example for pdbWriteRate()

Using libisfast

Index