The Official Guide to Learning OpenGL, Version 1.1 (Redbook Second Edition)

drawing a fixed: Masking Buffers, Drawing Depth-Buffered Images

background processing: Managing a Background Process

backward compatibility:

tessellation: Backward Compatibility versions: Which Version Am I Using?

basis functions: Prerequisites; Evaluators

Bernstein:

basis: Prerequisites

polynomial: Defining and Evaluating a One-Dimensional

Evaluator

billboarding: Alpha Test; Sample Uses of Blending

bitmaps: Drawing Pixels, Bitmaps, Fonts, and Images

display lists cache bitmap data: Display-List Design Philosophy distorting: Cheap Image Transformation

drawing: Drawing the Bitmap feedback mode: The Feedback Array

fonts, used for: Defining and Using a Complete Font, Bitmaps and Fonts

imaging pipeline operations: Imaging Pipeline ordering of data in: Bitmaps and Fonts

origin of: Drawing the Bitmap sample program: Bitmaps and Fonts

sample program that creates a font: Defining and Using a Complete Font

size of: Bitmaps and Fonts

bitplanes: RGBA versus Color-Index Mode

bitplanes: The Framebuffer

displayable colors, number of: RGBA Display Mode

blending: Blending; Blending

antialiasing polygons: Antialiasing Polygons coverage calculations for antialiasing: Antialiasing destination alpha: Antialiasing Polygons

enabling: The Source and Destination Factors enabling for antialiasing: Antialiasing in RGBA Mode

factors (source and destination): The Source and Destination Factors

images: Interpolating Images

ordering polygons before drawing: A Blending Example rendering pipeline stage: Fragment Operations, Fragment

Operations

sample program for three-dimensional: Three-Dimensional Blending with the Depth Buffer

sample program with blended polygons: A Blending Example texture function : Texture Functions

three dimensions, in: Three-Dimensional Blending with the

Depth Buffer

uses of: Sample Uses of Blending

buffer, See framebuffer: Selecting Color Buffers for Writing and Reading

C programming language: OpenGL Command Syntax

CAD/CAM, See computer-aided design: Orthographic Projection

camera analogy: Overview: The Camera Analogy environment mapping: Environment Mapping viewport transformations: Viewport Transformation

capping, See computational solid geometry: Stencil Examples

characters:

antialiasing: Texture-Mapping Applications

circles: Quadrics: Rendering Spheres, Cylinders, and Disks

clearing the framebuffer: Clearing Buffers; Clearing the Window affected by scissoring, dithering, and masking: Odds and

Ends, Clearing Buffers

performance tips: OpenGL Performance Tips

client-server, See networked operation: Forcing Completion of Drawing

clip coordinates: Overview: The Camera Analogy; Additional Clipping Planes

feedback mode: The Feedback Array

clipping:

viewing volume: Perspective Projection

clipping: Viewing Volume Clipping

interference regions found using clipping planes: Finding Interference Regions

overview: Viewing

primitives in rendering pipeline: Primitive Assembly, Primitive Assembly

clipping planes:

additional clipping planes: Additional Clipping Planes, Overview: The Camera Analogy

depth-buffer resolution, effect on: OpenGL Correctness Tips far: Troubleshooting Transformations, Perspective Projection near: Troubleshooting Transformations, Perspective Projection querying number of additional: Additional Clipping Planes sample program with additional clipping planes: A Clipping

Plane Code Example

color:

alpha values: Blending

background: Clearing the Window

cube showing blended RGB values: Computer Color current raster color: Choosing a Color for the Bitmap human perception: Color Perception

RGBA values for: Specifying a Color RGBA values for: Computer Color specifying: Specifying a Color

specifying for tessellation: Tessellation Callback Routines specifying in color-index mode: Specifying a Color in

Color-Index Mode

specifying in RGBA mode: Specifying a Color in RGBA Mode

color buffer: RGBA versus Color-Index Mode

color buffer: Buffers and Their Uses; Color Buffers; The Framebuffer; Computer Color

clearing: Clearing the Window masking: Masking Buffers

color map: Color-Index Display Mode; Computer Color loading for antialiasing: Antialiasing in Color-Index Mode loading for smooth shading: Specifying a Shading Model loading, using GLUT: Loading the Color Map

size of: Color-Index Display Mode

color-index mode:

choosing between RGBA mode and: Choosing between RGBA and Color-Index Mode

color-index mode: Color-Index Display Mode

changing between RGBA mode and: Changing between Display Modes

coverage calculations for antialiasing: Antialiasing dithering: Dithering

layering with writemasks: Masking Buffers lighting: Lighting in Color-Index Mode

lighting calculations in: The Mathematics of Color-Index Mode Lighting

texturing limitations: Specifying the Texture, Steps in Texture Mapping

vertex arrays, specifying values with: Step 2: Specifying Data for the Arrays

command syntax: OpenGL Command Syntax

compositing images: Sample Uses of Blending

compositing transformations: Examples of Composing Several Transformations

computational solid geometry: CSG Uses for Winding Rules capping: Stencil Examples

difference of several contours: CSG Uses for Winding Rules interference regions: Finding Interference Regions intersection of two contours: CSG Uses for Winding Rules

union of several contours: CSG Uses for Winding Rules

Computer Graphics:

Principles and Practice: Homogeneous Coordinates and Transformation Matrices, RGBA versus Color-Index Mode, What You Should Know Before Reading This Guide

computer-aided design:

orthographic parallel projection, use of: Orthographic Projection

concave polygons:

GLU tessellation: Polygon Tessellation

stencil buffer, drawing with the: Drawing Filled, Concave Polygons Using the Stencil Buffer

cones: Quadrics: Rendering Spheres, Cylinders, and Disks; Initializing and Drawing Three-Dimensional Objects

improving rendering of: Dirichlet Domains

constant attenuation: Position and Attenuation

contours: Creating Contours

control points: One-Dimensional Example: A Simple Bézier Curve; A Simple NURBS Example; Two-Dimensional Evaluators; Evaluators and NURBS

convex polygons: Polygons

Conway, John: Life in the Stencil Buffer

coordinate systems:

local: Using glTranslate*() and glRotate*(), Grand, Fixed Coordinate System

coordinate systems:

grand, fixed: Building a Solar System, Using glTranslate*() and glRotate*(), Grand, Fixed Coordinate System

local: Building a Solar System, Building an Articulated Robot Arm

simple 2D: Coordinate System Survival Kit

coordinates:

See clip coordinates, depth coordinates, eye coordinates, homogeneous coordinates, normalized device coordinates, object coordinates, q texture coordinates, texture coordinates, w coordinates, or window coordinates: Grand, Fixed Coordinate System

coverage, pixel: Antialiasing

Coxeter, H. S. M.: Homogeneous Coordinates and Transformation

Matrices

cross product: Using the gluLookAt() Utility Routine; Finding Normals for Analytic Surfaces

CSG, See computational solid geometry: CSG Uses for Winding Rules

culling: Reversing and Culling Polygon Faces

rendering pipeline stage: Primitive Assembly, Primitive Assembly

curves and curved surfaces: Curves and Curved Surfaces aaa: Evaluators and NURBS

Curves and Surfaces for Computer-Aided Geometric Design: Prerequisites

cylinders: Quadrics: Rendering Spheres, Cylinders, and Disks

data types:

RGBA color conversion: Specifying a Color in RGBA Mode special OpenGL: OpenGL Command Syntax

texture data: Specifying the Texture

warning about data type conversions: OpenGL Correctness Tips

decals: Making Decals; Alpha Test polygon offset used for: Polygon Offset texture function: Texture Functions

depth buffer:

clearing: Clearing the Window

depth buffer: Depth Buffer; A Hidden-Surface Removal Survival Kit; Buffers and Their Uses

aaa: A Hidden-Surface Removal Survival Kit

background, using masking for a common: Masking Buffers blending, use for three-dimensional: Three-Dimensional

Blending with the Depth Buffer

clearing: A Hidden-Surface Removal Survival Kit clearing: Clearing Buffers

decals, for: Making Decals

Dirichlet domains, for: Dirichlet Domains

drawing static backgrounds: Drawing Depth-Buffered Images masking: Masking Buffers

near frustum plane effect on resolution: OpenGL Correctness Tips

pixel data: Pixel-Transfer Operations, Copying Pixel Data within the Frame Buffer

depth coordinates: The Transformed Depth Coordinate; Overview: The Camera Analogy

perspective division: The Transformed Depth Coordinate picking use: Picking and Depth Values

polygon offset: Polygon Offset

rendering pipeline stage for depth-range operations: Primitive Assembly, Primitive Assembly

sample program with picking: Picking and Depth Values selection hit records: The Hit Record

depth test: Depth Test aaa: Depth Test

rendering pipeline stage: Fragment Operations, Fragment Operations

depth-cuing, See fog: Fog

depth-of-field effect: Depth of Field sample program: Depth of Field

destination factor, See blending: The Source and Destination Factors

diffuse:

contribution to lighting equation: Diffuse Term light: Color, Ambient, Diffuse, and Specular Light

material properties: Diffuse and Ambient Reflection, Material Colors

directional light source: Position and Attenuation

Dirichlet domains: Dirichlet Domains

disks: Quadrics: Rendering Spheres, Cylinders, and Disks

display lists: State Management and Drawing Geometric Objects nesting: Hierarchical Display Lists

display lists: An Example of Using a Display List changing mode settings: Encapsulating Mode Changes compiling: Naming and Creating a Display List creating: Creating and Executing a Display List deleting: Managing Display List Indices

disadvantages: Executing a Display List, Display-List Design Philosophy

error handling: OpenGL Correctness Tips, Creating and Executing a Display List

executing: Executing a Display List

executing: Creating and Executing a Display List executing multiple: Executing Multiple Display Lists font creation: Fonts and Display Lists, Executing Multiple

Display Lists

hierarchical: Hierarchical Display Lists

immediate mode, mixing with: Executing a Display List indices for, obtaining: Naming and Creating a Display List naming: Naming and Creating a Display List

nesting limit, querying: Hierarchical Display Lists networked operation: What's Stored in a Display List performance tips: OpenGL Performance Tips

querying use of an index: Managing Display List Indices rendering pipeline stage: Display Lists

sample program creating a font: Executing Multiple Display Lists sample program for creating: An Example of Using a Display

List, Creating and Executing a Display List

enabling:

alpha test: Alpha Test

antialiasing of points or lines: Antialiasing Points or Lines antialiasing polygons: Antialiasing Polygons

blending: The Source and Destination Factors

color material properties mode: Changing Material Properties depth test: Depth Test

dithering: Dithering, Dithering

evaluators: One-Dimensional Example: A Simple Bézier Curve, Defining and Evaluating a Two-Dimensional Evaluator

fog: Using Fog

lighting: Enabling Lighting line stippling: Stippled Lines

logical operations: Logical Operations

normal vectors for evaluated surfaces, automatic generation of: A Simple NURBS Example, Defining and Evaluating a Two-Dimensional Evaluator

polygon offset: Polygon Offset polygon stippling: Stippling Polygons stencil test: Stencil Test

texture coordinate generation: Creating Contours texturing: Enable Texture Mapping, A Sample Program unit length normal vectors ensured: Normal Vectors

endianness: Controlling Pixel-Storage Modes

environment mapping: Environment Mapping

error handling: Error Handling

error string description: Error Handling recommended usage: OpenGL Correctness Tips

evaluators: Evaluators

basis functions: Prerequisites, Defining and Evaluating a One-Dimensional Evaluator

evenly spaced values: Defining Evenly Spaced Coordinate Values in One Dimension, Defining Evenly Spaced Coordinate Values in Two Dimensions

one-dimensional: One-Dimensional Evaluators rendering pipeline stage: Evaluators

sample program using mesh for 2D Bézier surface: Defining Evenly Spaced Coordinate Values in Two Dimensions

sample program which draws 1D Bézier curve: One-Dimensional Example: A Simple Bézier Curve

sample program which draws 2D Bézier

surface: Two-Dimensional Example: A Bézier Surface sample program which generates texture coordinates: Using

Evaluators for Textures

tessellation usage: OpenGL Performance Tips

texture coordinates, generating: Using Evaluators for Textures two-dimensional: Two-Dimensional Example: A Bézier

Surface, Two-Dimensional Evaluators

event management, using GLUT: Handling Input Events

example programs, See programs: Running the Program

extensions:

vendor-specific: Extensions to the Standard

eye coordinates: Additional Clipping Planes; Overview: The Camera Analogy

texture coordinate generation: Automatic Texture-Coordinate Generation, Creating Contours

fade effect: An Easy Fade Effect

Farin, Gerald E.: Prerequisites

feedback: Feedback

array contents: A Feedback Example

pass-through markers: Using Markers in Feedback Mode querying current rendering mode: The Basic Steps returned data: The Feedback Array

sample program: A Feedback Example steps to perform: Feedback

tessellation, obtaining vertex data after: Tessellator Performance Tips

Feiner, Steven K.: What You Should Know Before Reading This Guide; Homogeneous Coordinates and Transformation Matrices

field of view: The Projection Transformation

field of view:

calculate, using trigonometry to: Troubleshooting Transformations

filtering: Filtering

mipmapped textures: Multiple Levels of Detail, Filtering texture border colors: Repeating and Clamping Textures

flat shading: Specifying a Shading Model

flight simulation: fog, use of: Fog

flushing: OpenGL Correctness Tips; Forcing Completion of Drawing

fog: Fog

blending factors: Fog Equations

color-index mode: Fog in Color-Index Mode density: Fog Equations

enabling: Using Fog equations: Fog Equations hints: Using Fog

RGBA mode: Fog in RGBA Mode

sample program in color-index mode: Fog in Color-Index Mode sample program in RGBA mode: Using Fog

Foley, James D.: What You Should Know Before Reading This Guide; RGBA versus Color-Index Mode; Homogeneous Coordinates and Transformation Matrices

fonts:

X fonts, using: Using an X Font

fonts: Fonts and Display Lists

antialiased characters (by masking): Antialiased Characters antialiased characters (by texturing): Texture-Mapping

Applications

bitmapped: Defining and Using a Complete Font

creating with display lists: Executing Multiple Display Lists drawing: Drawing the Bitmap

drawing as bitmaps: Bitmaps and Fonts multi-byte: Fonts and Display Lists

same program: Defining and Using a Complete Font

sample program using multiple display lists: Executing Multiple Display Lists

Foran, Jim: The q Coordinate

foreshortening, perspective: Perspective Projection

fragments: The Framebuffer alpha test: Alpha Test blending: Blending

depth test: Depth Test

rendering pipeline operations: Fragment Operations, Fragment Operations

scissor test: Scissor Test

tests: Testing and Operating on Fragments texture functions: Texture Functions

framebuffer: The Framebuffer; RGBA versus Color-Index Mode capacity per pixel: Buffers and Their Uses

clearing: Clearing Buffers

copying pixel data within: Imaging Pipeline, Copying Pixel Data within the Frame Buffer, Reading, Writing, and Copying Pixel Data

enabling for reading: Selecting Color Buffers for Writing and Reading

enabling for writing: Selecting Color Buffers for Writing and Reading

minimum configuration with the X Window System: Buffers and Their Uses

querying color resolution: RGBA versus Color-Index Mode reading pixel data from: Reading, Writing, and Copying Pixel

Data, Reading Pixel Data from Frame Buffer to Processor Memory writing pixel data to: Writing Pixel Data from Processor Memory

to Frame Buffer, Reading, Writing, and Copying Pixel Data