Index
Prev |  |

## Index

accumulation buffer
  clearing
    Clearing the Window

accumulation buffer
  The Accumulation Buffer
  Accumulation Buffer
  Buffers and Their Uses
  clearing
    Clearing Buffers
  depth-of-field effect, use for
    Depth of Field
  examples of use
    The Accumulation Buffer
  full range for best results, use
    OpenGL Correctness Tips
  motion blur, use for
    Motion Blur
  sample program with depth-of-field effect
    Depth of Field
  sample program with full-scene antialiasing
    Scene Antialiasing
  scene antialiasing, use for
    Scene Antialiasing

AGL
  AGL: OpenGL Extension to the Apple Macintosh
  aglChoosePixelFmt()
    Initialization
    Initialization
  aglCopyContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  aglCreateAGLPixmap()
    Controlling Rendering
    Off-screen Rendering
  aglCreateContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  aglDestroyAGLPixmap()
    Off-screen Rendering
    Controlling Rendering
  aglDestroyContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  aglGetConfig()
    Initialization
    Initialization
  aglGetCurrentContext()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  aglGetCurrentDrawable()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  aglGetError()
    Error Handling
    Controlling Rendering
  aglListPixelFmts()
    Initialization
    Initialization
  aglMakeCurrent()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  aglQueryVersion()
    Initialization
    Initialization
  aglSetOptions()
    Controlling Rendering
    On-screen Rendering
  aglSwapBuffers()
    Swapping Buffers
    Controlling Rendering
  aglUpdateCurrent()
    Controlling Rendering
    Updating the Rendering Buffers
  aglUseFont()
    Using an Apple Macintosh Font
    Controlling Rendering

airbrushing
  Alternative Uses for glDrawPixels() and glCopyPixels()

Akeley, Kurt
  The Accumulation Buffer

aliasing, See antialiasing
  Antialiasing

alpha
  Blending
  destination alpha
    Antialiasing Polygons
  material properties
    Defining Material Properties
  texture image data type
    Texture Functions

alpha blending, See blending
  Blending

alpha test
  Alpha Test
  querying current values
    Alpha Test
  rendering pipeline stage
    Fragment Operations
    Fragment Operations

ambient
  contribution to lighting equation
    Ambient Term
  global light
    Global Ambient Light
    Scaled Global Ambient Light
  light
    Real-World and OpenGL Lighting
    Ambient, Diffuse, and Specular Light
    Color
  material properties
    Material Colors
    Diffuse and Ambient Reflection

animation
  Animation
  OpenGL Correctness Tips

antialiasing
  Antialiasing
  accumulation buffer used for
    Scene Antialiasing
  characters (by masking)
    Antialiased Characters
  characters (by texturing)
    Texture-Mapping Applications
  color-index mode
    Antialiasing in Color-Index Mode
  coverage values
    Antialiasing
  enabling for points or lines
    Antialiasing Points or Lines
  enabling for polygons
    Antialiasing Polygons
  lines
    Antialiasing Points or Lines
    Antialiasing
  lines (by texturing)
    Texture-Mapping Applications
  points
    Drawing Round Points
    Antialiasing Points or Lines
  polygons
    Antialiasing Polygons
  RGBA mode
    Antialiasing in RGBA Mode
  sample program in color-index mode
    Antialiasing in Color-Index Mode
  sample program in RGBA mode
    Antialiasing in RGBA Mode
  sample program of filled polygons
    Antialiasing Polygons
  scene, with the accumulation buffer
    Scene Antialiasing

architectural applications
  orthographic parallel projection, use of
    Orthographic Projection

arcs
  Quadrics: Rendering Spheres, Cylinders, and Disks

aspect ratio
  perspective projection
    Perspective Projection
  viewport transformation
    Defining the Viewport

atmospheric effects, See fog
  Fog

attribute groups
  Attribute Groups
  client
    Attribute Groups
  list of
    OpenGL State Variables
  performance tips
    OpenGL Performance Tips
  server
    Attribute Groups
  stack depth, obtaining
    Attribute Groups
  stacks
    Attribute Groups

auxiliary buffers
  Color Buffers
  Selecting Color Buffers for Writing and Reading

Bézier
  basis
    Evaluators
    Prerequisites
  curve
    Defining and Evaluating a One-Dimensional Evaluator
  sample program using mesh for surface
    Defining Evenly Spaced Coordinate Values in Two Dimensions
  sample program which draws curve
    One-Dimensional Example: A Simple Bézier Curve
  sample program which draws surface
    Two-Dimensional Example: A Bézier Surface
  surface
    Two-Dimensional Evaluators

back-facing polygons
  Reversing and Culling Polygon Faces

back-facing polygons
  culling
    Reversing and Culling Polygon Faces
  material property, specifying
    Defining Material Properties
  two-sided lighting
    Two-sided Lighting

background
  Clearing the Window
  color
    Clearing the Window
  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
  sharing among rendering contexts
    Managing an OpenGL Rendering Context
    Managing an OpenGL Rendering Context
  state variables saved and restored
    Managing State Variables with Display Lists
  tessellation, use with
    Tessellator Performance Tips
  uses for
    Display-List Design Philosophy
    Encapsulating Mode Changes
  vertex-array data
    What's Stored in a Display List
  what can be stored in
    What's Stored in a Display List

distorted images
  Cheap Image Transformation
  texture images
    Computing Appropriate Texture Coordinates

dithering
  Dithering
  OpenGL Correctness Tips
  Dithering
  and clearing
    Clearing Buffers
  rendering pipeline stage
    Fragment Operations
    Fragment Operations

dot product
  lighting calculations, use in
    Spotlight Effect

double-buffering
  Animation
  automatic glFlush()
    Forcing Completion of Drawing
  changing between single-buffering and
    Changing between Display Modes
  object selection using the back buffer
    Object Selection Using the Back Buffer
  querying its presence
    Color Buffers
  sample program
    Motion = Redraw + Swap

drawing
  forcing completion of
    Forcing Completion of Drawing
  points
    OpenGL Geometric Drawing Primitives
  polygons
    OpenGL Geometric Drawing Primitives
    Polygons as Points, Outlines, or Solids
  rectangles
    Rectangles

drawing
  clearing the window
    Clearing the Window
  icosahedron
    An Example: Building an Icosahedron
  preparing for
    A Drawing Survival Kit
  spheres, cylinders, and disks
    Quadrics: Rendering Spheres, Cylinders, and Disks

drawing pixel data, See pixel data
  Drawing Pixels, Bitmaps, Fonts, and Images

Duff, Tom
  Sample Uses of Blending

edge flags
  Marking Polygon Boundary Edges
  tessellated polygons generate
    Tessellation Callback Routines
  vertex arrays, specifying values with
    Step 2: Specifying Data for the Arrays

emission
  Material Emission
  Emission
  Material Colors

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

front-facing polygons
  Reversing and Culling Polygon Faces

front-facing polygons
  specifying material property for
    Defining Material Properties
  two-sided lighting
    Two-sided Lighting

frustum
  Perspective Projection

ftp (file-transfer protocol) site
  GLUT source code
    How to Obtain the Sample Code
  GLX specification
    GLX: OpenGL Extension for the X Window System
  OpenGL Programming Guide
    How to Obtain the Sample Code

Fundamentals of Computer Aided Geometric Design
  Prerequisites

Fundamentals of Three-Dimensional Computer Graphics
  Texture Mapping

Game of Life
  Life in the Stencil Buffer

gamma correction
  RGBA versus Color-Index Mode

Gardner, Martin
  Life in the Stencil Buffer

geometric primitives
  Describing Points, Lines, and Polygons
  Overview
  performance when specifying
    OpenGL Performance Tips
  rendering pipeline stage
    Primitive Assembly

geosciences
  use of texturing in applications
    Automatic Texture-Coordinate Generation

giraffe
  Color-Index Display Mode

GLU
  tessellation
    Polygon Tessellation

glAccum()
  The Accumulation Buffer

glAlphaFunc()
  Alpha Test

glAreTexturesResident()
  A Working Set of Resident Textures

glArrayElement()
  Dereference a Single Array Element
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

Glassner, Andrew S.
  What You Should Know Before Reading This Guide

glBegin()
  OpenGL Geometric Drawing Primitives
  OpenGL Geometric Drawing Primitives
  Tessellation Callback Routines
  restrictions
    Restrictions on Using glBegin() and glEnd()

glBindTexture()
  A Sample Program
  Creating and Using Texture Objects

glBitmap()
  Drawing the Bitmap
  Bitmaps and Fonts
  feedback mode
    The Feedback Array
  fonts, used for
    Defining and Using a Complete Font
  imaging pipeline operations
    Imaging Pipeline
  pixel-storage modes effect
    Controlling Pixel-Storage Modes

glBlendFunc()
  The Source and Destination Factors

glCallList()
  Executing a Display List
  Creating and Executing a Display List
  An Example of Using a Display List
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

glCallLists()
  Executing Multiple Display Lists
  fonts, use for
    Fonts and Display Lists
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()
  sample program
    Defining and Using a Complete Font

glClear()
  Clearing the Window
  Odds and Ends
  Clearing Buffers
  Clearing the Window
  depth buffer, clearing the
    A Hidden-Surface Removal Survival Kit

glClearAccum()
  Clearing the Window
  Clearing Buffers

glClearColor()
  Clearing the Window
  Clearing the Window
  Clearing Buffers

glClearDepth()
  Clearing Buffers
  Clearing the Window

glClearIndex()
  Clearing the Window
  Specifying a Color in Color-Index Mode
  Clearing Buffers
  fog, use with
    Fog in Color-Index Mode

glClearStencil()
  Clearing Buffers
  Clearing the Window

glClipPlane()
  Additional Clipping Planes

glColor*()
  Specifying a Color
  Specifying a Color in RGBA Mode
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

glColorMask()
  Clearing Buffers
  Masking Buffers

glColorMaterial()
  Changing Material Properties
  performance tips
    OpenGL Performance Tips

glColorPointer()
  Step 2: Specifying Data for the Arrays

glCopyPixels()
  Copying Pixel Data within the Frame Buffer
  Reading, Writing, and Copying Pixel Data
  alternative uses
    Alternative Uses for glDrawPixels() and glCopyPixels()
  dithering, turn off
    OpenGL Correctness Tips
  feedback mode
    The Feedback Array
  glReadBuffer() effect
    Selecting Color Buffers for Writing and Reading
  imaging pipeline operations
    Imaging Pipeline
  pixel-transfer modes effect
    Pixel-Transfer Operations

glCopyTexImage1D()
  One-Dimensional Textures
  glReadBuffer() effect
    Selecting Color Buffers for Writing and Reading
  pixel-transfer modes effect
    Pixel-Transfer Operations

glCopyTexImage2D()
  Specifying the Texture
  glReadBuffer() effect
    Selecting Color Buffers for Writing and Reading
  pixel-transfer modes effect
    Pixel-Transfer Operations

glCopyTexSubImage1D()
  One-Dimensional Textures
  One-Dimensional Textures
  glReadBuffer() effect
    Selecting Color Buffers for Writing and Reading
  pixel-transfer modes effect
    Pixel-Transfer Operations

glCopyTexSubImage2D()
  Replacing All or Part of a Texture Image
  glReadBuffer() effect
    Selecting Color Buffers for Writing and Reading
  pixel-transfer modes effect
    Pixel-Transfer Operations

glCullFace()
  Reversing and Culling Polygon Faces

glDeleteLists()
  Fonts and Display Lists
  Managing Display List Indices

glDeleteTextures()
  Cleaning Up Texture Objects

glDepthFunc()
  Depth Test

glDepthMask()
  Masking Buffers
  blending opaque and translucent objects
    Three-Dimensional Blending with the Depth Buffer

glDepthRange()
  The Transformed Depth Coordinate
  gluUnProject(), relationship to
    Reversing or Mimicking Transformations

glDisable()
  Basic State Management
  OpenGL as a State Machine

glDisableClientState()
  Step 1: Enabling Arrays

glDrawArrays()
  Dereference a Sequence of Array Elements

glDrawBuffer()
  Writing Pixel Data from Processor Memory to Frame Buffer
  Copying Pixel Data within the Frame Buffer
  Selecting Color Buffers for Writing and Reading

glDrawElements()
  Dereference a List of Array Elements

glDrawPixels()
  Drawing Depth-Buffered Images
  Writing Pixel Data from Processor Memory to Frame Buffer
  Reading, Writing, and Copying Pixel Data
  Stencil Examples
  alternative uses
    Alternative Uses for glDrawPixels() and glCopyPixels()
  feedback mode
    The Feedback Array
  pixel-storage modes effect
    Controlling Pixel-Storage Modes
  pixel-transfer modes effect
    Pixel-Transfer Operations

glEdgeFlag*()
  Marking Polygon Boundary Edges
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

glEdgeFlagPointer()
  Step 2: Specifying Data for the Arrays

glEnable()
  Basic State Management
  Create, Position, and Enable One or More Light Sources
  also see enabling
    Reversing and Culling Polygon Faces

glEnableClientState()
  Restrictions on Using glBegin() and glEnd()
  Step 1: Enabling Arrays

glEnd()
  Tessellation Callback Routines
  OpenGL Geometric Drawing Primitives
  OpenGL Geometric Drawing Primitives
  restrictions
    Restrictions on Using glBegin() and glEnd()

glEndList()
  An Example of Using a Display List
  Naming and Creating a Display List
  Creating and Executing a Display List

glEvalCoord*()
  Defining and Evaluating a One-Dimensional Evaluator
  Defining and Evaluating a Two-Dimensional Evaluator
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()
  used instead of glVertex*()
    One-Dimensional Example: A Simple Bézier Curve
    Evaluators

glEvalMesh*()
  Defining Evenly Spaced Coordinate Values in One Dimension
  Defining Evenly Spaced Coordinate Values in Two Dimensions

glEvalPoint*()
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

glFeedbackBuffer()
  Feedback
  glRenderMode(), use with
    The Basic Steps

glFinish()
  Forcing Completion of Drawing

glFlush()
  Forcing Completion of Drawing
  Forcing Completion of Drawing
  OpenGL Correctness Tips

glFog*()
  Fog Equations

glFrontFace()
  Reversing and Culling Polygon Faces

glFrustum()
  The Projection Transformation
  Perspective Projection
  Odds and Ends
  Perspective Projection

glGenLists()
  An Example of Using a Display List
  Naming and Creating a Display List
  fonts, use for
    Fonts and Display Lists

glGenTextures()
  Naming A Texture Object
  A Sample Program

glGetBooleanv()
  Basic State Management
  OpenGL as a State Machine
  OpenGL State Variables
  double-buffering support, querying
    Color Buffers
  stereo support, querying
    Color Buffers

glGetClipPlane()
  The Query Commands

glGetDoublev()
  Basic State Management
  OpenGL as a State Machine
  OpenGL State Variables

glGetError()
  The Query Commands
  Error Handling
  OpenGL as a State Machine

glGetFloatv()
  OpenGL as a State Machine
  Basic State Management
  OpenGL State Variables
  line width attributes, obtaining
    Wide Lines
  point size attributes, obtaining
    Point Details

glGetIntegerv()
  OpenGL State Variables
  Basic State Management
  OpenGL as a State Machine
  alpha test information, obtaining
    Alpha Test
  attribute stack depth, obtaining
    Attribute Groups
  clipping planes, obtaining number of additional
    Additional Clipping Planes
  color resolution, obtaining
    RGBA versus Color-Index Mode
  display list nesting limit, obtaining
    Hierarchical Display Lists
  matrix stack depth, obtaining
    The Modelview Matrix Stack
  maximum texture size, obtaining
    Texture Proxy
  name stack depth, obtaining
    Creating the Name Stack
  pixel map information, obtaining
    Pixel Mapping
  rendering mode, obtaining current
    The Basic Steps
  stencil-related values, obtaining
    Stencil Queries

glGetLight*()
  The Query Commands
  OpenGL as a State Machine

glGetMap*()
  The Query Commands

glGetMaterial*()
  The Query Commands

glGetPixelMap*()
  The Query Commands

glGetPointerv()
  OpenGL State Variables
  Basic State Management
  OpenGL as a State Machine

glGetPolygonStipple()
  OpenGL as a State Machine
  The Query Commands

glGetString()
  The Query Commands
  Which Version Am I Using?

glGetTexEnv*()
  The Query Commands

glGetTexGen*()
  The Query Commands

glGetTexImage()
  The Query Commands
  pixel-storage modes effect
    Controlling Pixel-Storage Modes
  pixel-transfer modes effect
    Pixel-Transfer Operations

glGetTexLevelParameter*()
  Texture Proxy
  The Query Commands

glGetTexParameter*()
  The Query Commands
  texture residency, obtaining
    A Working Set of Resident Textures

glHint()
  Antialiasing
  fog use
    Using Fog
  texture use
    A Sample Program

glIndex*()
  Specifying a Color in Color-Index Mode
  fog, use with
    Fog in Color-Index Mode
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

glIndexMask()
  Clearing Buffers
  Masking Buffers

glIndexPointer()
  Step 2: Specifying Data for the Arrays

glInitNames()
  Creating the Name Stack
  Creating the Name Stack
  The Basic Steps

glInterleavedArrays()
  Interleaved Arrays

glIsEnabled()
  OpenGL State Variables
  Basic State Management
  OpenGL as a State Machine

glIsList()
  Managing Display List Indices

glIsTexture()
  Naming A Texture Object

glLight*()
  Creating Light Sources
  Create, Position, and Enable One or More Light Sources
  Creating Light Sources
  Multiple Lights

glLightModel*()
  Selecting a Lighting Model

glLineStipple()
  Stippled Lines

glLineWidth()
  Wide Lines

glListBase()
  Executing Multiple Display Lists
  fonts, use for
    Fonts and Display Lists
  sample program
    Defining and Using a Complete Font

glLoadIdentity()
  Odds and Ends
  The Projection Transformation
  General-Purpose Transformation Commands
  A Modeling Transformation Code Example
  performance tips
    OpenGL Performance Tips
  viewing transformations, use before
    The Viewing Transformation

glLoadMatrix*()
  General-Purpose Transformation Commands
  General-Purpose Transformation Commands
  General-Purpose Transformation Commands
  Odds and Ends

glLoadName()
  Creating the Name Stack
  Creating the Name Stack

glLogicOp()
  Logical Operations

glMap*()
  Defining and Evaluating a Two-Dimensional Evaluator
  Defining and Evaluating a One-Dimensional Evaluator
  One-Dimensional Example: A Simple Bézier Curve

glMapGrid*()
  Defining Evenly Spaced Coordinate Values in Two Dimensions
  Defining Evenly Spaced Coordinate Values in One Dimension

glMaterial*()
  Defining Material Properties
  Define Material Properties for the Objects in the Scene
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()
  performance tips
    OpenGL Performance Tips

glMatrixMode()
  The Projection Transformation
  General-Purpose Transformation Commands
  use with matrix stacks
    Manipulating the Matrix Stacks

glMultMatrix*()
  General-Purpose Transformation Commands
  Odds and Ends
  General-Purpose Transformation Commands
  performance tips
    OpenGL Performance Tips

glNewList()
  Creating and Executing a Display List
  An Example of Using a Display List
  Naming and Creating a Display List

glNormal*()
  Normal Vectors
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

glNormalPointer()
  Step 2: Specifying Data for the Arrays

glOrtho()
  Odds and Ends
  Orthographic Projection
  picking matrix use
    Picking

glPassThrough()
  Using Markers in Feedback Mode
  Feedback

glPixelMap*()
  Pixel Mapping

glPixelStore*()
  Controlling Pixel-Storage Modes
  cannot be stored in display lists
    What's Stored in a Display List
  polygon stippling
    Stippling Polygons
  texture image data, effect on
    Replacing All or Part of a Texture Image
    One-Dimensional Textures
    Specifying the Texture
    Replacing All or Part of a Texture Image
    One-Dimensional Textures
    Specifying the Texture

glPixelTransfer*()
  Drawing Depth-Buffered Images
  Pixel-Transfer Operations
  texture image data, effect on
    Specifying the Texture
    One-Dimensional Textures
    Replacing All or Part of a Texture Image
    Replacing All or Part of a Texture Image
    Specifying the Texture
    One-Dimensional Textures

glPixelZoom()
  Magnifying, Reducing, or Flipping an Image
  Cheap Image Transformation

glPointSize()
  Point Details

glPolygonMode()
  Polygons as Points, Outlines, or Solids
  antialiasing, effect on
    Antialiasing Polygons
  polygon offset, use with
    Polygon Offset

glPolygonOffset()
  Polygon Offset

glPolygonStipple()
  Stippling Polygons
  pixel-storage modes effect
    Controlling Pixel-Storage Modes

glPopAttrib()
  OpenGL as a State Machine
  Managing State Variables with Display Lists
  Attribute Groups
  OpenGL State Variables

glPopClientAttrib()
  OpenGL as a State Machine
  Attribute Groups
  OpenGL State Variables

glPopMatrix()
  Manipulating the Matrix Stacks
  Independently Moving the Light
  Managing State Variables with Display Lists
  Building an Articulated Robot Arm
  restore orientation of coordinate systems
    Building an Articulated Robot Arm
  selection, use with
    The Basic Steps

glPopName()
  Creating the Name Stack
  Creating the Name Stack

glPrioritizeTextures()
  Texture Residence Strategies

glPushAttrib()
  Attribute Groups
  OpenGL as a State Machine
  Managing State Variables with Display Lists
  OpenGL State Variables

glPushClientAttrib()
  Attribute Groups
  OpenGL State Variables
  OpenGL as a State Machine

glPushMatrix()
  Managing State Variables with Display Lists
  Manipulating the Matrix Stacks
  Independently Moving the Light
  Building an Articulated Robot Arm
  save orientation of coordinate systems
    Building an Articulated Robot Arm
  selection, use with
    The Basic Steps

glPushName()
  Creating the Name Stack
  The Basic Steps
  Creating the Name Stack

glRasterPos*()
  The Current Raster Position
  Bitmaps and Fonts
  images, for positioning
    Reading, Writing, and Copying Pixel Data
  selection hits, can cause
    The Hit Record

glReadBuffer()
  Selecting Color Buffers for Writing and Reading
  Copying Pixel Data within the Frame Buffer
  Writing Pixel Data from Processor Memory to Frame Buffer

glReadPixels()
  Reading Pixel Data from Frame Buffer to Processor Memory
  Reading, Writing, and Copying Pixel Data
  glReadBuffer() effect
    Selecting Color Buffers for Writing and Reading
  pixel-storage modes effect
    Controlling Pixel-Storage Modes
  pixel-transfer modes effect
    Pixel-Transfer Operations

glRect*()
  Rectangles

glRenderMode()
  The Basic Steps
  The Hit Record
  Feedback
  The Basic Steps

glRotate*()
  Building an Articulated Robot Arm

glRotate*()
  Rotate
  Odds and Ends
  Building a Solar System
  performance tips
    OpenGL Performance Tips

glScale*()
  Building an Articulated Robot Arm

glScale*()
  The Modeling Transformation
  Odds and Ends
  Scale
  performance tips
    OpenGL Performance Tips

glScissor()
  Scissor Test

glSelectBuffer()
  The Basic Steps
  The Basic Steps
  display lists, cannot be stored in
    What's Stored in a Display List

glShadeModel()
  Specifying a Shading Model

glStencilFunc()
  Stencil Test

glStencilMask()
  Masking Buffers

glStencilOp()
  Stencil Test

glTexCoord*()
  A Sample Program
  Assigning Texture Coordinates
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()

glTexCoordPointer()
  Step 2: Specifying Data for the Arrays

glTexEnv*()
  Texture Functions
  A Sample Program

glTexGen*()
  Automatic Texture-Coordinate Generation
  environment mapping
    Environment Mapping

glTexImage1D()
  One-Dimensional Textures
  pixel-storage modes effect
    Controlling Pixel-Storage Modes
  pixel-transfer modes effect
    Pixel-Transfer Operations

glTexImage2D()
  Specifying the Texture
  A Sample Program
  pixel-storage modes effect
    Controlling Pixel-Storage Modes
  pixel-transfer modes effect
    Pixel-Transfer Operations
  specifying mipmaps
    Multiple Levels of Detail

glTexParameter*()
  A Sample Program
  Repeating and Clamping Textures
  specifying filtering methods
    Filtering

glTexSubImage1D()
  One-Dimensional Textures
  pixel-storage modes effect
    Controlling Pixel-Storage Modes
  pixel-transfer modes effect
    Pixel-Transfer Operations

glTexSubImage2D()
  Replacing All or Part of a Texture Image
  pixel-storage modes effect
    Controlling Pixel-Storage Modes
  pixel-transfer modes effect
    Pixel-Transfer Operations

glTranslate*()
  Building a Solar System

glTranslate*()
  Odds and Ends
  Building an Articulated Robot Arm
  Translate
  performance tips
    OpenGL Performance Tips

GLU
  What Is OpenGL?
  OpenGL-Related Libraries
  Tessellators and Quadrics
  drawing spheres, cylinders, and disks
    Quadrics: Rendering Spheres, Cylinders, and Disks
  error string description
    Error Handling
  obsolete routines
    gluBeginPolygon()
      Backward Compatibility
    gluEndPolygon()
      Backward Compatibility
    gluNextContour()
      Backward Compatibility
  quadrics
    Quadrics: Rendering Spheres, Cylinders, and Disks
  tessellation
    Polygons
  version numbers, obtaining
    Utility Library Version

gluBeginCurve()
  A Simple NURBS Example
  Create a NURBS Curve or Surface

gluBeginSurface()
  A Simple NURBS Example
  Create a NURBS Curve or Surface

gluBeginTrim()
  Trim a NURBS Surface

gluCylinder()
  Quadrics: Rendering Spheres, Cylinders, and Disks
  Quadrics Primitives

gluDeleteNurbsRenderer()
  Manage a NURBS Object

gluDeleteQuadric()
  Quadrics: Rendering Spheres, Cylinders, and Disks
  Manage Quadrics Objects

gluDeleteTess()
  Deleting a Tessellator Object
  Backward Compatibility

gluDisk()
  Quadrics Primitives
  Quadrics: Rendering Spheres, Cylinders, and Disks

gluEndCurve()
  A Simple NURBS Example
  Create a NURBS Curve or Surface

gluEndSurface()
  Create a NURBS Curve or Surface
  A Simple NURBS Example

gluEndTrim()
  Trim a NURBS Surface

gluErrorString()
  Error Handling
  Handle NURBS Errors
  Manage Quadrics Objects
  polygon tessellation
    Tessellation Callback Routines

gluGetNurbsProperty()
  The Query Commands
  Control NURBS Rendering Properties

gluGetString()
  Utility Library Version
  The Query Commands

gluGetTessProperty()
  The Query Commands
  Other Tessellation Property Routines

gluLoadSamplingMatrices()
  Control NURBS Rendering Properties

gluLookAt()
  Building a Solar System

gluLookAt()
  Using the gluLookAt() Utility Routine
  The Viewing Transformation
  A Simple Example: Drawing a Cube

gluNewNurbsRenderer()
  Manage a NURBS Object
  A Simple NURBS Example

gluNewQuadric()
  Manage Quadrics Objects
  Quadrics: Rendering Spheres, Cylinders, and Disks

gluNewTess()
  Create a Tessellation Object
  Backward Compatibility

gluNurbsCallback()
  A Simple NURBS Example
  Handle NURBS Errors

gluNurbsCurve()
  Create a NURBS Curve or Surface
  A Simple NURBS Example

gluNurbsProperty()
  A Simple NURBS Example
  Control NURBS Rendering Properties

gluNurbsSurface()
  Create a NURBS Curve or Surface
  A Simple NURBS Example

gluOrtho2D()
  Orthographic Projection
  OpenGL Correctness Tips
  resized windows, use with
    Coordinate System Survival Kit

gluPartialDisk()
  Quadrics Primitives
  Quadrics: Rendering Spheres, Cylinders, and Disks

gluPerspective()
  Building a Solar System

gluPerspective()
  Perspective Projection
  The Projection Transformation
  picking matrix use
    Picking

gluPickMatrix()
  Picking

gluProject()
  Reversing or Mimicking Transformations

gluPwlCurve()
  Trim a NURBS Surface

gluQuadricCallback()
  Manage Quadrics Objects
  Quadrics: Rendering Spheres, Cylinders, and Disks

gluQuadricDrawStyle()
  Quadrics: Rendering Spheres, Cylinders, and Disks
  Control Quadrics Attributes

gluQuadricNormals()
  Control Quadrics Attributes
  Quadrics: Rendering Spheres, Cylinders, and Disks

gluQuadricOrientation()
  Control Quadrics Attributes
  Quadrics: Rendering Spheres, Cylinders, and Disks

gluQuadricTexture()
  Quadrics: Rendering Spheres, Cylinders, and Disks
  Control Quadrics Attributes

gluScaleImage()
  Specifying the Texture

gluSphere()
  Quadrics: Rendering Spheres, Cylinders, and Disks
  Quadrics Primitives

GLUT
  Basics of GLUT: The OpenGL Utility Toolkit
  OpenGL-Related Libraries
  basic functions
    GLUT, the OpenGL Utility Toolkit
  event management
    Handling Input Events
  glutCreateWindow()
    Initializing and Creating a Window
    Window Management
  glutDisplayFunc()
    Handling Window and Input Events
    The Display Callback
    The Display Callback
  glutIdleFunc()
    Managing a Background Process
    Managing a Background Process
  glutInit()
    Initializing and Creating a Window
    Window Management
  glutInitDisplayMode()
    Window Management
    Initializing and Creating a Window
  glutInitWindowPosition()
    Window Management
    Initializing and Creating a Window
  glutInitWindowSize()
    Window Management
    Initializing and Creating a Window
  glutKeyboardFunc()
    Handling Input Events
    Handling Window and Input Events
  glutMainLoop()
    Running the Program
    Running the Program
  glutMotionFunc()
    Handling Window and Input Events
    Handling Input Events
  glutMouseFunc()
    Handling Window and Input Events
    Handling Input Events
  glutPostRedisplay()
    An Example of Using a Display List
    Handling Window and Input Events
    The Display Callback
  glutReshapeFunc()
    Handling Window and Input Events
    Handling Input Events
    simple example
      Coordinate System Survival Kit
  glutSetColor()
    Loading the Color Map
    Specifying a Color in Color-Index Mode
    Window Management
    Lighting in Color-Index Mode
    smooth shading, use for
      Specifying a Shading Model
  glutSolidCone()
    Initializing and Drawing Three-Dimensional Objects
  glutSolidCube()
    Initializing and Drawing Three-Dimensional Objects
    Drawing Three-Dimensional Objects
  glutSolidDodecahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutSolidIcosahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutSolidOctahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutSolidSphere()
    Drawing Three-Dimensional Objects
    Initializing and Drawing Three-Dimensional Objects
  glutSolidTeapot()
    Initializing and Drawing Three-Dimensional Objects
  glutSolidTetrahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutSolidTorus()
    Initializing and Drawing Three-Dimensional Objects
  glutSwapBuffers()
    Motion = Redraw + Swap
  glutWireCone()
    Initializing and Drawing Three-Dimensional Objects
  glutWireCube()
    Drawing Three-Dimensional Objects
    Initializing and Drawing Three-Dimensional Objects
  glutWireDodecahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutWireIcosahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutWireOctahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutWireSphere()
    Initializing and Drawing Three-Dimensional Objects
    Drawing Three-Dimensional Objects
    Building a Solar System
  glutWireTeapot()
    Initializing and Drawing Three-Dimensional Objects
  glutWireTetrahedron()
    Initializing and Drawing Three-Dimensional Objects
  glutWireTorus()
    Initializing and Drawing Three-Dimensional Objects
  sample program introducing GLUT
    Running the Program
  window management
    Window Management
    Coordinate System Survival Kit

gluTessBeginContour()
  Polygon Definition

gluTessBeginPolygon()
  Polygon Definition

gluTessCallback()
  Backward Compatibility
  Tessellation Callback Routines
  Polygon Definition

gluTessEndContour()
  Polygon Definition

gluTessEndPolygon()
  Polygon Definition

gluTessNormal()
  Other Tessellation Property Routines
  Tessellator Performance Tips
  CSG Uses for Winding Rules

gluTessProperty()
  Tessellation Properties
  Polygon Definition

gluTessVertex()
  Backward Compatibility
  Polygon Definition

gluUnProject()
  Reversing or Mimicking Transformations
  Reversing or Mimicking Transformations

glVertex*()
  Specifying Vertices
  legal between glBegin() and glEnd()
    Restrictions on Using glBegin() and glEnd()
  using glEvalCoord*() instead
    Evaluators

glVertexPointer()
  Restrictions on Using glBegin() and glEnd()
  Step 2: Specifying Data for the Arrays

glViewport()
  The Viewport Transformation
  Defining the Viewport
  using with resized windows
    Coordinate System Survival Kit

GLX
  GLX: OpenGL Extension for the X Window System
  OpenGL-Related Libraries
  OpenGL-Related Libraries
  ftp site for GLX specification
    GLX: OpenGL Extension for the X Window System
  glXChooseVisual()
    GLX Tips
    Initialization
    Initialization
  glXCopyContext()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  glXCreateContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  glXCreateGLXPixmap()
    Controlling Rendering
    Off-Screen Rendering
  glXDestroyContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  glXDestroyGLXPixmap()
    Off-Screen Rendering
    Controlling Rendering
  glXGetClientString()
    Initialization
    Initialization
  glXGetConfig()
    Initialization
    Buffers and Their Uses
    Initialization
  glXGetCurrentContext()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  glXGetCurrentDisplay()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  glXGetCurrentDrawable()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  glXIsDirect()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  glXMakeCurrent()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  glXQueryExtension()
    Initialization
    Initialization
  glXQueryExtensionsString()
    Initialization
    Initialization
  glXQueryServerString()
    Initialization
    Initialization
  glXQueryVersion()
    Initialization
    Initialization
  glXSwapBuffers()
    Swapping Buffers
    Motion = Redraw + Swap
    Controlling Rendering
  glXUseXFont()
    Using an X Font
    Controlling Rendering
  glXWaitGL()
    Controlling Rendering
    Synchronizing Execution
    performance tips
      GLX Tips
  glXWaitX()
    Synchronizing Execution
    Controlling Rendering
    performance tips
      GLX Tips

Gouraud shading, See smooth shading
  Specifying a Shading Model

Haeberli, Paul
  The q Coordinate
  The Accumulation Buffer

haze, See fog
  Fog

header file
  Include Files

hidden-line removal
  Hidden-Line Removal
  polygon offset used for
    Polygon Offset

hidden-surface removal
  Depth Test
  A Hidden-Surface Removal Survival Kit

hierarchical models
  Manipulating the Matrix Stacks
  Hierarchical Display Lists
  picking
    Picking with Multiple Names and a Hierarchical Model

highlights, See specular
  Specular Reflection

hints
  Antialiasing
  fog
    Using Fog
  perspective correction
    A Sample Program
    Antialiasing
    A Sample Program

hits (selection), See selection (hit records)
  The Hit Record

holes in polygons
  Polygons
  Drawing Filled, Concave Polygons Using the Stencil Buffer

homogeneous coordinates
  Points
  Homogeneous Coordinates

Hoschek, Josef
  Prerequisites

Hughes, John F.
  What You Should Know Before Reading This Guide
  Homogeneous Coordinates and Transformation Matrices

IBM OS/2 Presentation Manager to OpenGL Interface, see PGL
  OpenGL-Related Libraries

icosahedron, drawing
  An Example: Building an Icosahedron

identity matrix
  A Modeling Transformation Code Example
  The Viewing Transformation
  OpenGL Performance Tips
  General-Purpose Transformation Commands

illumination, See lighting
  Real-World and OpenGL Lighting

images
  Drawing Pixels, Bitmaps, Fonts, and Images
  Images
  also see pixel data
    Drawing Pixels, Bitmaps, Fonts, and Images
  blending
    Interpolating Images
  compositing
    Blending
  distorted
    Cheap Image Transformation
  imaging pipeline
    Reading, Writing, and Copying Pixel Data
    Imaging Pipeline
  interpolating between
    Interpolating Images
  magnifying or reducing
    Magnifying, Reducing, or Flipping an Image
  nonrectangular
    Sample Uses of Blending
  projecting
    Texture-Mapping Applications
  sample code which draws an image
    Writing Pixel Data from Processor Memory to Frame Buffer
  sample program which draws, copies, and zooms an image
    Magnifying, Reducing, or Flipping an Image
  scaling and rotating
    Texture-Mapping Applications
  sources of
    Images
  superimposing
    Making Decals
  transposing
    Alternative Uses for glDrawPixels() and glCopyPixels()
    Alternative Uses for glDrawPixels() and glCopyPixels()
  warping
    Texture-Mapping Applications

imaging pipeline, See images (imaging pipeline)
  Imaging Pipeline

immediate mode
  State Management and Drawing Geometric Objects
  Display Lists
  display lists, mixing with
    Executing a Display List

infinite light source
  Position and Attenuation

input events
  handling, using GLUT
    Handling Input Events

intensity
  texture image data type
    Texture Functions

Interactive Inspection of Solids
  Cross-sections and Interferences
    Finding Interference Regions

interference regions
  Finding Interference Regions

interleaved arrays
  Interleaved Arrays

interpolating
  color values and texture coordinates
    Antialiasing
    Assigning Texture Coordinates

invariance
  of an OpenGL implementation
    OpenGL Invariance
    OpenGL Correctness Tips

Inventor, see Open Inventor
  OpenGL-Related Libraries

jaggies
  Antialiasing

jittering
  Scene Antialiasing
  Scene Antialiasing
  Jittering
  accFrustum() routine
    Scene Antialiasing
  accPerspective() routine
    Scene Antialiasing
  sample code to jitter projection transformations
    Scene Antialiasing
  sample program with orthographic projection
    Scene Antialiasing

Kilgard, Mark
  How to Obtain the Sample Code
  OpenGL-Related Libraries
  Basics of GLUT: The OpenGL Utility Toolkit
  GLX: OpenGL Extension for the X Window System

Korobkin, Carl
  The q Coordinate

Lasser, Dieter
  Prerequisites

layers, drawing
  Displaying Layers

Life, Game of
  Life in the Stencil Buffer

light sources
  Creating Light Sources
  ambient light
    Ambient, Diffuse, and Specular Light
    Color
  contribution to lighting equation
    Contributions from Light Sources
  diffuse light
    Color
    Ambient, Diffuse, and Specular Light
  directional
    Position and Attenuation
  display lists cache values
    Display-List Design Philosophy
  infinite light source
    Position and Attenuation
  local light source
    Position and Attenuation
  maximum number of sources
    Create, Position, and Enable One or More Light Sources
  moving along with the viewpoint
    Moving the Light Source Together with Your Viewpoint
  moving light sources
    Controlling a Light's Position and Direction
  multiple light sources
    Multiple Lights
  performance tips
    Create, Position, and Enable One or More Light Sources
  positional
    Position and Attenuation
  rendering pipeline stage
    Per-Vertex Operations
    Per-Vertex Operations
  RGBA values
    RGB Values for Lights and Materials
  sample program that moves the light source
    Independently Moving the Light
  specifying a light source
    Create, Position, and Enable One or More Light Sources
  specular light
    Ambient, Diffuse, and Specular Light
  spotlights
    Spotlights
  stationary
    Keeping the Light Stationary

lighting
  enabling
    Some Important Notes

lighting:also see light sources, material properties
  Material Colors
  ambient light
    Real-World and OpenGL Lighting
  approximation of the real world
    Real-World and OpenGL Lighting
  calculations in color-index mode
    The Mathematics of Color-Index Mode Lighting
  color-index mode
    Lighting in Color-Index Mode
  default values, using
    Some Important Notes
  display lists cache values
    Display-List Design Philosophy
  enabling
    Create, Position, and Enable One or More Light Sources
    Create, Position, and Enable One or More Light Sources
  enabling and disabling
    Enabling Lighting
  equation that calculates lighting
    The Mathematics of Lighting
  global ambient light
    Global Ambient Light
    Scaled Global Ambient Light
  lighting model
    Selecting a Lighting Model
  lighting model, specifying a
    Select a Lighting Model
  rendering pipeline stage
    Per-Vertex Operations
    Per-Vertex Operations
  sample program introducing lighting
    A Simple Example: Rendering a Lit Sphere
  steps to perform
    A Simple Example: Rendering a Lit Sphere
  two-sided materials
    Two-sided Lighting
  viewer, local or infinite
    Local or Infinite Viewpoint

line segment
  Lines

linear attenuation
  Position and Attenuation

lines
  Lines
  antialiasing
    Texture-Mapping Applications
    Antialiasing Points or Lines
  connected closed loop, specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  connected strip, specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  feedback mode
    The Feedback Array
  querying line width
    Wide Lines
  sample program with wide, stippled lines
    Stippled Lines
  specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  stippling
    Stippled Lines
  tessellated polygons decomposed into
    Tessellation Callback Routines
  width
    Wide Lines

local light source
  Position and Attenuation

logical operations
  rendering pipeline stage
    Fragment Operations
    Fragment Operations
  transposing images, using for
    Alternative Uses for glDrawPixels() and glCopyPixels()

lookup table, See color map
  Color-Index Display Mode

luminance
  Reading Pixel Data from Frame Buffer to Processor Memory
  The Pixel Rectangle Reading Process
  pixel data formats for
    Reading Pixel Data from Frame Buffer to Processor Memory
    Pixel Packing and Unpacking
  texture image data type
    Texture Functions

magnifying images
  Magnifying, Reducing, or Flipping an Image

masking
  Masking Buffers
  antialiasing characters
    Antialiased Characters
  layers, drawing
    Displaying Layers
  rendering pipeline stage
    Fragment Operations
    Fragment Operations

material properties
  Defining Material Properties
  Define Material Properties for the Objects in the Scene
  ambient
    Diffuse and Ambient Reflection
    Material Colors
  changing a single parameter with glColorMaterial()
    Changing Material Properties
  changing material properties
    Changing Material Properties
  diffuse
    Diffuse and Ambient Reflection
    Material Colors
  display lists cache values
    Display-List Design Philosophy
  emission
    Emission
    Material Colors
    Material Emission
  enabling color material properties mode
    Changing Material Properties
  performance when changing
    OpenGL Performance Tips
  rendering pipeline stage
    Per-Vertex Operations
    Per-Vertex Operations
  RGBA values
    RGB Values for Lights and Materials
  sample program which changes material properties
    Changing Material Properties
  sample program which uses glColorMaterial()
    Changing Material Properties
  shininess
    Specular Reflection
  specular
    Specular Reflection
    Material Colors
  two-sided lighting
    Two-sided Lighting

matrix
  column-major ordering
    General-Purpose Transformation Commands

matrix:also see matrix stack
  Odds and Ends
  choosing which matrix is current
    General-Purpose Transformation Commands
  current
    The Viewing Transformation
  danger of extensive changes
    OpenGL Correctness Tips
  display lists cache matrix operations
    Display-List Design Philosophy
  identity
    OpenGL Performance Tips
    General-Purpose Transformation Commands
    The Viewing Transformation
    A Modeling Transformation Code Example
  loading
    General-Purpose Transformation Commands
  modelview
    General-Purpose Transformation Commands
    Overview: The Camera Analogy
  multiplying matrices
    General-Purpose Transformation Commands
  NURBS, specifying for sampling
    Control NURBS Rendering Properties
  orthographic parallel projection
    Orthographic Projection
  perspective projection
    Perspective Projection
  projection
    The Projection Transformation
    General-Purpose Transformation Commands
  rotation
    Rotation
  row-major ordering
    General-Purpose Transformation Commands
  scaling
    Scaling
  texture
    The Texture Matrix Stack
  transformation pipeline
    Overview: The Camera Analogy
  transformations of homogeneous coordinates
    Transforming Vertices
  translation
    Translation

matrix stack
  Manipulating the Matrix Stacks
  choosing which matrix stack is current
    Manipulating the Matrix Stacks
  current matrix stack
    Odds and Ends
  modelview
    The Modelview Matrix Stack
  popping
    Manipulating the Matrix Stacks
  projection
    The Projection Matrix Stack
  pushing
    Manipulating the Matrix Stacks
  querying stack depth
    The Modelview Matrix Stack
  texture
    The Texture Matrix Stack

Megahed, Abe
  Finding Interference Regions

Microsoft
  Microsoft Win32, See Win32
    WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
  Microsoft Windows
    OpenGL-Related Libraries
  Microsoft Windows 95
    WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
  Microsoft Windows NT
    How to Obtain the Sample Code
  Microsoft Windows to OpenGL interface, See WGL
    OpenGL-Related Libraries

mipmapping
  texture objects for mipmaps
    Creating and Using Texture Objects

mipmapping
  Multiple Levels of Detail
  minification filters
    Filtering

mirroring objects, See scaling
  Scale

modeling transformations
  Viewing and Modeling Transformations

modeling transformations
  Modeling Transformations
  The Modeling Transformation
  camera analogy
    Overview: The Camera Analogy
  connection to viewing transformations
    The Modeling Transformation
  example
    A Modeling Transformation Code Example
  rotation
    Rotate
  rotation matrix
    Rotation
  sample program
    A Modeling Transformation Code Example
  scaling
    Scale
  scaling matrix
    Scaling
  translation
    Translate
  translation matrix
    Translation

models
  rendering wireframe and solid
    Drawing Three-Dimensional Objects
    Initializing and Drawing Three-Dimensional Objects

modelview matrix
  General-Purpose Transformation Commands
  Overview: The Camera Analogy
  arbitrary clipping planes, effect on
    Additional Clipping Planes
  stack
    The Modelview Matrix Stack

motion blur
  Motion Blur
  stippling, with
    An Easy Fade Effect

motion, See animation
  Animation

movie clips
  Alternative Uses for glDrawPixels() and glCopyPixels()

multiple layers
  displaying with overlap
    Displaying Layers

name stack
  The Basic Steps
  creating
    Creating the Name Stack
  initializing
    Creating the Name Stack
  loading
    Creating the Name Stack
  multiple names
    Picking with Multiple Names and a Hierarchical Model
  popping
    Creating the Name Stack
  pushing
    Creating the Name Stack
  querying maximum depth
    Creating the Name Stack

networked operation
  Forcing Completion of Drawing
  attribute groups, saving and restoring
    Attribute Groups
  display lists
    What's Stored in a Display List
  versions
    Which Version Am I Using?

Non-Uniform Rational B-Splines, see NURBS
  OpenGL-Related Libraries

nonplanar polygons
  Polygons

normal vectors
  normalized
    Normal Vectors

normal vectors
  Define Normal Vectors for Each Vertex of Every Object
  Normal Vectors
  calculating
    Calculating Normal Vectors
  calculating for analytic surfaces
    Finding Normals for Analytic Surfaces
  calculating for polygonal data
    Finding Normals from Polygonal Data
  calculating length
    Normal Vectors
  cross product, calculating normalized
    Calculating Normal Vectors for a Surface
  enabling automatic unit length division
    Normal Vectors
  inverse matrix generated
    Odds and Ends
  matrix transformations
    Overview: The Camera Analogy
  NURBS, generating for
    Create a NURBS Curve or Surface
  quadrics, generated for
    Control Quadrics Attributes
  rendering pipeline stage
    Per-Vertex Operations
    Per-Vertex Operations
  specifying
    Normal Vectors
  tessellation, specifying for
    Tessellation Callback Routines
  transformations
    Transforming Normals
  unit length optimizes performance
    OpenGL Performance Tips
  vertex arrays, specifying values with
    Step 2: Specifying Data for the Arrays

normal, See normal vectors
  Normal Vectors

normalized device coordinates
  Overview: The Camera Analogy

NURB Curves and Surfaces (book title)
  Prerequisites

NURBS
  The GLU NURBS Interface
  creating a NURBS curve or surface
    Create a NURBS Curve or Surface
  creating a NURBS object
    Manage a NURBS Object
  culling
    Control NURBS Rendering Properties
  deleting a NURBS object
    Manage a NURBS Object
  display list use
    An Example of Using a Display List
  error handling
    Handle NURBS Errors
  method of display (lines or filled polygons)
    Control NURBS Rendering Properties
  normal vectors, generating
    Create a NURBS Curve or Surface
  properties, controlling NURBS
    Control NURBS Rendering Properties
  querying property value
    Control NURBS Rendering Properties
  references
    Prerequisites
  sample program which draws a lit NURBS surface
    A Simple NURBS Example
  sample program with a trimmed surface
    Trim a NURBS Surface
  sampling precision
    Control NURBS Rendering Properties
  source for matrices
    Control NURBS Rendering Properties
  steps to use
    A Simple NURBS Example
  texture coordinate generation
    Create a NURBS Curve or Surface
  trimming
    Trim a NURBS Surface

NURBS Book, The
  Prerequisites

NURBS for Curve and Surface Design
  Prerequisites

object coordinates
  Overview: The Camera Analogy
  texture coordinate generation
    Automatic Texture-Coordinate Generation

objects, See models
  Drawing Three-Dimensional Objects

opacity
  Blending

Open Inventor
  OpenGL-Related Libraries
  What Is OpenGL?

OpenGL Extension to the X Window System, see GLX
  OpenGL-Related Libraries

OpenGL Programming for the X Window System
  OpenGL-Related Libraries
  GLUT, the OpenGL Utility Toolkit
  Basics of GLUT: The OpenGL Utility Toolkit
  How to Obtain the Sample Code
  GLX: OpenGL Extension for the X Window System

OpenGL Reference Manual
  GLX: OpenGL Extension for the X Window System

OpenGL Reference Manual
  Order of Operations
  What You Should Know Before Reading This Guide
  The Query Commands

OpenGL Utility Library, see GLU
  OpenGL-Related Libraries

OpenGL Utility Toolkit, see GLUT
  OpenGL-Related Libraries

orthographic parallel projection
  The Projection Transformation
  Orthographic Projection
  jittering
    Scene Antialiasing
  matrix
    Orthographic Projection
  specifying with integer coordinates
    OpenGL Correctness Tips

outlined polygons
  Marking Polygon Boundary Edges
  Polygons as Points, Outlines, or Solids
  polygon offset solution
    Polygon Offset

overlapping objects
  Finding Interference Regions

painting
  Blending
  Alternative Uses for glDrawPixels() and glCopyPixels()
  Sample Uses of Blending

partial disks
  Quadrics: Rendering Spheres, Cylinders, and Disks

pass-through markers
  Using Markers in Feedback Mode

performance tips
  light sources, effect of additional
    Create, Position, and Enable One or More Light Sources

performance tips
  clearing the window
    Clearing the Window
  display lists
    An Example of Using a Display List
  flat shading
    OpenGL Performance Tips
  flushing the pipeline
    Forcing Completion of Drawing
  fog
    Fog
  GLX tips
    GLX Tips
  hints
    Antialiasing
  light source attenuation, effect of
    Position and Attenuation
  list of general tips
    OpenGL Performance Tips
  material properties, changing
    OpenGL Performance Tips
  NURBS and display lists
    An Example of Using a Display List
  pixel data alignment
    Controlling Pixel-Storage Modes
  pixel data, drawing
    Tips for Improving Pixel Drawing Rates
  polygon restrictions
    Polygons
  polygon subdivision
    Some Hints for Building Polygonal Models of Surfaces
  pushing and popping attribute groups
    OpenGL Performance Tips
  rasterization and fragment operations for pixel data
    OpenGL Performance Tips
  removing hidden surfaces
    A Hidden-Surface Removal Survival Kit
  specifying geometric primitives
    OpenGL Performance Tips
  tessellation and display lists
    An Example of Using a Display List
  tessellation, use of
    Tessellator Performance Tips
  texture images, internal format of
    Specifying the Texture
  texture objects
    OpenGL Performance Tips
    Texture Objects
  texture subimages
    OpenGL Performance Tips
  two-sided lighting
    Two-sided Lighting
  unit-length normal vectors
    OpenGL Performance Tips
  vector and scalar forms of commands
    OpenGL Performance Tips
  vertex arrays
    OpenGL Performance Tips

perspective projection
  Perspective Projection
  correction hint
    A Sample Program
    A Sample Program
    Antialiasing
  depth coordinates, effect on
    The Transformed Depth Coordinate
  jittering
    Scene Antialiasing
  matrix
    Perspective Projection
  perspective division
    Overview: The Camera Analogy

PGL
  pglIsIndirect()
    Managing an OpenGL Rendering Context

PGL
  PGL: OpenGL Extension for IBM OS/2 Warp
  OpenGL-Related Libraries
  pglChooseConfig()
    Initialization
    Initialization
  pglCopyContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  pglCreateContext()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  pglDestroyContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  pglGetCurrentContext()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  pglGetCurrentWindow()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  pglGrabFrontBitmap()
    Controlling Rendering
    Access the Bitmap of the Front Buffer
  pglIsIndirect()
    Controlling Rendering
  pglMakeCurrent()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  pglQueryCapability()
    Initialization
    Initialization
  pglQueryConfigs()
    Initialization
    Initialization
  pglQueryVersion()
    Initialization
    Initialization
  pglReleaseFrontBitmap()
    Controlling Rendering
    Access the Bitmap of the Front Buffer
  pglSelectColorIndexPalette()
    Controlling Rendering
    When you are running in 8-bit (256 color) mode, you have to worry about color palette management. For windows with a color index Visual Configuration, call pglSelectColorIndexPalette() to tell OpenGL what color-index palette you want to use with your context. A color palette must be selected before the context is initially bound to a window. In RGBA mode, OpenGL sets up a palette automatically.
  pglSwapBuffers()
    Controlling Rendering
    Swapping Buffers
  pglUseFont()
    Using an OS/2 Logical Font
    Controlling Rendering
  pglWaitGL()
    Controlling Rendering
    Synchronizing Execution
  pglWaitPM()
    Synchronizing Execution
    Controlling Rendering

picking
  Picking
  back buffer for, using the
    Object Selection Using the Back Buffer
  depth coordinates
    Picking and Depth Values
  hierarchical models
    Picking with Multiple Names and a Hierarchical Model
  projection matrix, special
    Picking
  sample program
    Picking
  sample program with depth coordinates
    Picking and Depth Values
  strategies
    Hints for Writing a Program That Uses Selection
  sweep selection
    Hints for Writing a Program That Uses Selection

Piegl, Les
  Prerequisites

pipeline
  geometric processing
    Geometric Operations
  imaging
    Reading, Writing, and Copying Pixel Data
    Imaging Pipeline
  rendering
    OpenGL Rendering Pipeline
  vertex transformation
    Overview: The Camera Analogy

pixel
  coverage
    Antialiasing

pixel data
  Drawing Pixels, Bitmaps, Fonts, and Images
  Images
  aaa
    Pixel Operations
  byte alignment
    Controlling Pixel-Storage Modes
  byte ordering
    Controlling Pixel-Storage Modes
  copying within the framebuffer
    Imaging Pipeline
    Copying Pixel Data within the Frame Buffer
    Pixel Operations
    Pixel Operations
    Reading, Writing, and Copying Pixel Data
  depth buffer pixel data
    Pixel-Transfer Operations
    Copying Pixel Data within the Frame Buffer
  drawing or reading a subrectangle of
    Controlling Pixel-Storage Modes
  drawing process in detail
    The Pixel Rectangle Drawing Process
  endianness
    Controlling Pixel-Storage Modes
  feedback mode
    The Feedback Array
  formats for reading or drawing
    Reading Pixel Data from Frame Buffer to Processor Memory
  formats for storing in memory
    Reading Pixel Data from Frame Buffer to Processor Memory
    Pixel Packing and Unpacking
  mapping
    Pixel Operations
    Pixel Operations
    Pixel Mapping
  packing into processor memory
    Pixel Operations
    Pixel Packing and Unpacking
    Pixel Operations
  performance tips
    Tips for Improving Pixel Drawing Rates
  pipeline operations
    Imaging Pipeline
    Pixel Operations
    Reading, Writing, and Copying Pixel Data
    Pixel Operations
  pixel zoom
    Magnifying, Reducing, or Flipping an Image
  querying pixel mapping information
    Pixel Mapping
  reading from the framebuffer
    Reading, Writing, and Copying Pixel Data
    Reading Pixel Data from Frame Buffer to Processor Memory
  reading process in detail
    The Pixel Rectangle Reading Process
  sample code which draws an image
    Writing Pixel Data from Processor Memory to Frame Buffer
  sample program which draws, copies, and zooms pixel data
    Magnifying, Reducing, or Flipping an Image
  stencil buffer pixel data
    Pixel-Transfer Operations
    Reading Pixel Data from Frame Buffer to Processor Memory
  storage modes
    Controlling Pixel-Storage Modes
  transfer modes
    Pixel Operations
    Pixel Operations
    Texture Functions
    Pixel-Transfer Operations
  unpacking from processor memory
    Pixel Operations
    Pixel Packing and Unpacking
    Pixel Operations
  writing to the framebuffer
    Reading, Writing, and Copying Pixel Data
    Writing Pixel Data from Processor Memory to Frame Buffer

points
  drawing
    OpenGL Geometric Drawing Primitives

point light source, See positional light source
  Position and Attenuation

points
  Points
  antialiasing
    Antialiasing Points or Lines
    Drawing Round Points
  feedback mode
    The Feedback Array
  querying point size
    Point Details
  round
    Antialiasing Points or Lines
    Drawing Round Points
  size
    Point Details
  specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives

polygons
  culling the faces
    Reversing and Culling Polygon Faces
  polygon mode
    Polygons as Points, Outlines, or Solids
  reversing the faces
    Reversing and Culling Polygon Faces
  stippling
    Stippling Polygons

polygon offset
  Polygon Offset
  depth slope of a polygon
    Polygon Offset
  enabling
    Polygon Offset
  hidden-line removal
    Hidden-Line Removal with Polygon Offset

polygonal approximations to surfaces
  Some Hints for Building Polygonal Models of Surfaces

polygons
  Polygons
  boundary edges
    Marking Polygon Boundary Edges
  concave, drawing filled
    Drawing Filled, Concave Polygons Using the Stencil Buffer
    Polygon Tessellation
  convex
    Polygons
  drawing
    OpenGL Geometric Drawing Primitives
  drawing as points, lines, or filled
    Polygons as Points, Outlines, or Solids
  feedback mode
    The Feedback Array
  front and back faces
    Reversing and Culling Polygon Faces
  holes in
    Polygons
  non-convex
    Polygons
    Marking Polygon Boundary Edges
  nonplanar
    Polygons
  polygon mode
    Primitive Assembly
    OpenGL Performance Tips
    Primitive Assembly
  sample program with stippled polygons
    Stippling Polygons
  self-intersecting
    Tessellation Callback Routines
  simple
    Polygons
  specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  tessellation, specifying for
    Polygon Definition
  Voronoi
    Dirichlet Domains

positional light source
  Position and Attenuation

primitives
  geometric
    Describing Points, Lines, and Polygons
  raster
    Drawing Pixels, Bitmaps, Fonts, and Images

priority of texture objects
  Texture Residence Strategies

Procedural Elements for Computer Graphics
  Quadrics: Rendering Spheres, Cylinders, and Disks

programs
  aaindex.c
    Antialiasing in Color-Index Mode
  aapoly.c
    Antialiasing Polygons
  aargb.c
    Antialiasing in RGBA Mode
  accanti.c
    Scene Antialiasing
  accpersp.c
    Scene Antialiasing
  alpha.c
    A Blending Example
  alpha3D.c
    Three-Dimensional Blending with the Depth Buffer
  bezcurve.c
    One-Dimensional Example: A Simple Bézier Curve
  bezmesh.c
    Defining Evenly Spaced Coordinate Values in Two Dimensions
  bezsurf.c
    Two-Dimensional Example: A Bézier Surface
  checker.c
    A Sample Program
  clip.c
    A Clipping Plane Code Example
  colormat.c
    Changing Material Properties
  cube.c
    A Simple Example: Drawing a Cube
  dof.c
    Depth of Field
  double.c
    Motion = Redraw + Swap
  drawf.c
    Bitmaps and Fonts
  feedback.c
    A Feedback Example
  fog.c
    Using Fog
  fogindex.c
    Fog in Color-Index Mode
  font.c
    Defining and Using a Complete Font
  ftp site
    How to Obtain the Sample Code
  hello.c
    Running the Program
  image.c
    Magnifying, Reducing, or Flipping an Image
  light.c
    A Simple Example: Rendering a Lit Sphere
  lines.c
    Stippled Lines
  list.c
    Creating and Executing a Display List
  material.c
    Changing Material Properties
  mipmap.c
    Multiple Levels of Detail
  model.c
    A Modeling Transformation Code Example
  movelight.c
    Independently Moving the Light
  pickdepth.c
    Picking and Depth Values
  picksquare.c
    Picking
  planet.c
    Building a Solar System
  polys.c
    Stippling Polygons
  quadric.c
    Quadrics Primitives
  robot.c
    Building an Articulated Robot Arm
  select.c
    A Selection Example
  smooth.c
    Specifying a Shading Model
  stencil.c
    Stencil Examples
  stroke.c
    Executing Multiple Display Lists
  surface.c
    A Simple NURBS Example
  tess.c
    Tessellation Callback Routines
    Tessellation Callback Routines
    Polygon Definition
  texbind.c
    Creating and Using Texture Objects
  texgen.c
    Creating Contours
  texsub.c
    Replacing All or Part of a Texture Image
  texturesurf.c
    Using Evaluators for Textures
  torus.c, using a display list
    An Example of Using a Display List
  trim.c
    Trim a NURBS Surface
  unproject.c
    Reversing or Mimicking Transformations
  varray.c
    Step 2: Specifying Data for the Arrays

projecting images
  Texture-Mapping Applications

projection matrix
  The Projection Transformation
  General-Purpose Transformation Commands
  matrix stack
    The Projection Matrix Stack
  orthographic parallel projection matrix
    Orthographic Projection
  perspective projection matrix
    Perspective Projection
  shadows created with
    Shadows

projection transformations
  The Projection Transformation
  Projection Transformations
  camera lens analogy
    Overview: The Camera Analogy
  collapsing geometry to a single plane
    OpenGL Correctness Tips
  jittering
    Scene Antialiasing
    Scene Antialiasing
  orthographic parallel
    OpenGL Correctness Tips
    The Projection Transformation
    Orthographic Projection
  perspective
    Perspective Projection
  picking
    Picking
  texturing effects
    The q Coordinate
  two-dimensional
    Orthographic Projection

proxy textures
  Texture Proxy

q texture coordinates
  The q Coordinate
  avoiding negative values
    OpenGL Correctness Tips

quadratic attenuation
  Position and Attenuation

quadrics
  Quadrics: Rendering Spheres, Cylinders, and Disks
  creating an object
    Manage Quadrics Objects
  destroying an object
    Manage Quadrics Objects
  drawing as points, lines, and filled polygons
    Control Quadrics Attributes
  error handling
    Manage Quadrics Objects
  normal vectors, generating
    Control Quadrics Attributes
  orientation
    Control Quadrics Attributes
  quadratic equation
    Quadrics: Rendering Spheres, Cylinders, and Disks
  sample program
    Quadrics Primitives
  steps to use
    Quadrics: Rendering Spheres, Cylinders, and Disks
  texture coordinates, generating
    Control Quadrics Attributes

quadrilateral
  specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  strip, specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives

raster position
  The Current Raster Position
  after drawing a bitmap
    Drawing the Bitmap
  current
    Odds and Ends
    The Current Raster Position
  current raster color
    Choosing a Color for the Bitmap
  current, obtaining the
    The Current Raster Position
  transformation of
    The Current Raster Position

rasterization
  Computer Color
  The Framebuffer
  exact, two-dimensional
    OpenGL Correctness Tips
  rendering pipeline stage
    Rasterization

reading pixel data, See pixel data
  Drawing Pixels, Bitmaps, Fonts, and Images

Real Projective Plane, The
  Homogeneous Coordinates and Transformation Matrices

rectangles
  specifying
    Rectangles

reducing images
  Magnifying, Reducing, or Flipping an Image

reflecting objects, See scaling
  Scale

reflection, See material properties
  Material Colors

reflective objects, See environment mapping
  Environment Mapping

refresh, screen
  Animation

removing hidden surfaces, See hidden-surface removal
  A Hidden-Surface Removal Survival Kit

repeatability
  OpenGL Invariance

resident textures
  Texture Proxy
  A Working Set of Resident Textures
  management strategies
    Texture Residence Strategies
  querying residence status
    A Working Set of Resident Textures

RGBA mode
  RGBA Display Mode
  changing between color-index mode and
    Changing between Display Modes
  choosing between color-index mode and
    Choosing between RGBA and Color-Index Mode
  coverage calculations for antialiasing
    Antialiasing
  data type conversion
    Specifying a Color in RGBA Mode
  light source colors
    RGB Values for Lights and Materials
  lighting calculations in
    The Mathematics of Lighting
  material property values
    RGB Values for Lights and Materials
  vertex arrays, specifying values with
    Step 2: Specifying Data for the Arrays

robot arm example
  Building an Articulated Robot Arm

Rogers, David
  Quadrics: Rendering Spheres, Cylinders, and Disks

Rossignac, Jarek
  Finding Interference Regions

rotating images
  Texture-Mapping Applications

rotation
  Rotate
  matrix
    Rotation

sample programs, See programs
  Running the Program

scaling
  Scale
  matrix
    Scaling

scaling images
  Texture-Mapping Applications

Schneider, Bengt-Olaf
  Finding Interference Regions

Scientific American
  Life in the Stencil Buffer

scissor test
  Scissor Test
  and clearing
    Clearing Buffers
  rendering pipeline stage
    Fragment Operations
    Fragment Operations

Segal, Mark
  The q Coordinate

selection
  Selection
  back buffer for, using the
    Object Selection Using the Back Buffer
  hit records
    The Hit Record
  programming tips
    Hints for Writing a Program That Uses Selection
  querying current rendering mode
    The Basic Steps
  rendering pipeline stage
    Primitive Assembly
  sample program
    A Selection Example
  steps to perform
    The Basic Steps
  sweep selection
    Hints for Writing a Program That Uses Selection

shading
  flat
    Specifying a Shading Model
  smooth
    Specifying a Shading Model

shading
  performance tips
    OpenGL Performance Tips
  sample program with smooth shading
    Specifying a Shading Model
  specifying shading model
    Specifying a Shading Model

shadows
  The Mathematics of Lighting
  Soft Shadows
  Shadows

shininess
  Specular Reflection
  aaa
    Environment Mapping

silhouette edges
  Some Hints for Building Polygonal Models of Surfaces

smoke, See fog
  Fog

smooth shading
  Specifying a Shading Model

solar system example
  Building a Solar System

source factor, See blending
  The Source and Destination Factors

specular
  contribution to lighting equation
    Specular Term
  light
    Ambient, Diffuse, and Specular Light
  material properties
    Material Colors
    Specular Reflection

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

split-screen
  multiple viewports
    Defining the Viewport

spotlights, See light sources
  Spotlights

state machine
  OpenGL as a State Machine

state variables
  Basic State Management
  attribute groups
    Attribute Groups
  display list execution, effect of
    Managing State Variables with Display Lists
  enable and disable states
    Basic State Management
  list of
    OpenGL State Variables
  performance of storing and restoring
    OpenGL Performance Tips
  querying
    Basic State Management

stencil buffer
  clearing
    Clearing the Window

stencil buffer
  Stencil Buffer
  Buffers and Their Uses
  clearing
    Clearing Buffers
  concave polygons, for drawing
    Drawing Filled, Concave Polygons Using the Stencil Buffer
  decals, for
    Making Decals
  Dirichlet domains, for
    Dirichlet Domains
  Game of Life, for the
    Life in the Stencil Buffer
  hidden-line removal
    Hidden-Line Removal with the Stencil Buffer
  masking
    Masking Buffers
  pixel data
    Pixel-Transfer Operations
    Reading Pixel Data from Frame Buffer to Processor Memory

stencil test
  Stencil Test
  examples of using
    Stencil Examples
  interference regions found using clipping planes
    Finding Interference Regions
  querying stencil parameters
    Stencil Queries
  rendering pipeline stage
    Fragment Operations
    Fragment Operations
  sample program
    Stencil Examples

stereo
  Selecting Color Buffers for Writing and Reading
  Color Buffers
  querying its presence
    Color Buffers

stippling
  lines
    Stippled Lines

stippling
  display lists cache stipple patterns
    Display-List Design Philosophy
  enabling line stippling
    Stippled Lines
  enabling polygon stippling
    Stippling Polygons
  fade effect, use for
    An Easy Fade Effect
  line pattern reset
    Stippled Lines
  line pattern reset
    A Feedback Example
    The Feedback Array
  polygons
    Stippling Polygons
  sample program with line stipple
    Stippled Lines
  sample program with polygon stippling
    Stippling Polygons
  stencil test, use of
    Stencil Examples
  translucency, use to simulate
    Cheesy Translucency

stitching
  Polygon Offset

stretching objects, See scaling
  Scale

stride
  vertex arrays
    Interleaved Arrays
    Stride

subdivision
  Some Hints for Building Polygonal Models of Surfaces
  generalized
    Generalized Subdivision
  icosahedron example
    Improving the Model
  recursive
    Improving the Model

subimages
  One-Dimensional Textures
  Replacing All or Part of a Texture Image

superimposing images
  Making Decals

surface normals, See normal vectors
  Normal Vectors

surfaces, See evaluators or NURBS
  Evaluators and NURBS

swapping buffers, See double-buffering
  Animation

syntax, See command syntax
  OpenGL Command Syntax

Terminator 2
  Environment Mapping

tessellation
  Polygon Tessellation
  Polygons
  backward compatibility with obsolete routines
    Backward Compatibility
  begin and end callback routines
    Tessellation Callback Routines
  callback routines
    Tessellation Callback Routines
  combine callback routine
    Tessellation Callback Routines
    Tessellation Callback Routines
  computational solid geometry, winding rules used for
    CSG Uses for Winding Rules
  contours, specifying
    Polygon Definition
  converting code to use the GLU 1.2 tessellator
    Backward Compatibility
  creating an object
    Create a Tessellation Object
  decomposition into geometric primitives
    Tessellation Callback Routines
  deleting objects
    Deleting a Tessellator Object
  display list use
    An Example of Using a Display List
  edge flag generation
    Tessellation Callback Routines
  error handling
    Tessellation Callback Routines
  evaluators used to perform
    OpenGL Performance Tips
  interior and exterior, determining
    Winding Numbers and Winding Rules
  intersecting contours combined
    Tessellation Callback Routines
    Tessellation Callback Routines
  performance tips
    Tessellator Performance Tips
  polygons, specifying
    Polygon Definition
  properties
    Tessellation Properties
  reuse of objects
    Tessellator Performance Tips
    Create a Tessellation Object
  reversing winding direction
    Other Tessellation Property Routines
  sample code
    Polygon Definition
    Tessellation Callback Routines
    Tessellation Callback Routines
  user-specified data
    User-Specified Data
  vertices, specifying
    Polygon Definition
    Tessellation Callback Routines
  winding rules
    Winding Numbers and Winding Rules

texels
  Fragment Operations
  Texture Mapping

text, see characters
  Texture-Mapping Applications

texture coordinates
  A Sample Program
  Assigning Texture Coordinates
  assigning manually
    Assigning Texture Coordinates
  avoiding negative q values
    OpenGL Correctness Tips
  clamping
    Repeating and Clamping Textures
  computing manually
    Computing Appropriate Texture Coordinates
  enabling automatic generation of
    Creating Contours
  environment mapping, automatic generation for
    Environment Mapping
  evaluators, generated by
    Using Evaluators for Textures
  generating automatically
    Automatic Texture-Coordinate Generation
  NURBS, generating for
    Create a NURBS Curve or Surface
  q coordinate
    The q Coordinate
  quadrics, generated for
    Control Quadrics Attributes
  reference planes, specifying
    Automatic Texture-Coordinate Generation
  rendering pipeline stage
    Per-Vertex Operations
    Per-Vertex Operations
  repeating
    Repeating and Clamping Textures
  sample program with texture coordinate generation
    Creating Contours
  tessellation, specifying for
    Tessellation Callback Routines
  vertex arrays, specifying values with
    Step 2: Specifying Data for the Arrays
  wrapping modes
    Repeating and Clamping Textures

texture functions
  Texture Functions
  blend
    Texture Functions
  blending color
    Texture Functions
  decal
    Texture Functions
    A Sample Program
  fragment operations
    Texture Functions
  modulate
    Texture Functions
  pixel-transfer modes effect
    Texture Functions
  replace
    Texture Functions
  texture internal format, interaction with
    Texture Functions

texture images
  alpha data
    Texture Functions
  borders
    Repeating and Clamping Textures
    Using a Texture's Borders
  components
    Specifying the Texture
  data types
    Specifying the Texture
  distorting
    Computing Appropriate Texture Coordinates
  framebuffer as a source of
    One-Dimensional Textures
    Specifying the Texture
    Replacing All or Part of a Texture Image
  imaging pipeline operations
    Imaging Pipeline
  intensity data
    Texture Functions
  internal format
    Specifying the Texture
  luminance data
    Texture Functions
  mipmaps
    Multiple Levels of Detail
  one-dimensional
    One-Dimensional Textures
  performance affected by internal format
    Specifying the Texture
  performance of texture subimages
    OpenGL Performance Tips
  power of 2 size restriction
    Specifying the Texture
  proxy textures
    Texture Proxy
  querying maximum size
    Texture Proxy
  residence status
    A Working Set of Resident Textures
  resident textures
    A Working Set of Resident Textures
    Texture Proxy
  resident textures, management strategies of
    Texture Residence Strategies
  sample program with mipmaps
    Multiple Levels of Detail
  sample program with subimages
    Replacing All or Part of a Texture Image
  specifying
    Specifying the Texture
  subimages
    Replacing All or Part of a Texture Image
    One-Dimensional Textures
  working set of textures
    Texture Proxy
    Texture Objects
    A Working Set of Resident Textures

texture mapping, see texturing
  Texture Mapping

texture matrix
  The Texture Matrix Stack
  rendering pipeline stage
    Per-Vertex Operations

texture objects
  A Sample Program
  Texture Objects
  binding
    Creating and Using Texture Objects
  creating
    Creating and Using Texture Objects
  data which can be stored in
    Creating and Using Texture Objects
  deleting
    Cleaning Up Texture Objects
  fragmentation of texture memory
    Texture Residence Strategies
  least-recently used (LRU) strategy
    Texture Residence Strategies
  mipmaps
    Creating and Using Texture Objects
  naming
    Naming A Texture Object
  performance tips
    OpenGL Performance Tips
    Texture Objects
  priority
    Texture Residence Strategies
  rendering pipeline
    Texture Memory
    Texture Assembly
  sample program
    A Sample Program
  sample program with multiple texture objects
    Creating and Using Texture Objects
  sharing among rendering contexts
    Managing an OpenGL Rendering Context
    Managing an OpenGL Rendering Context
  steps to perform
    Texture Objects
  using
    Creating and Using Texture Objects

texturing:also see texture coordinates, texture functions, texture images, texture matrix, and texture objects
  Steps in Texture Mapping
  antialiasing characters
    Texture-Mapping Applications
  antialiasing lines
    Texture-Mapping Applications
  blending
    Sample Uses of Blending
  border colors, treatment of
    Repeating and Clamping Textures
  color-index mode limitations
    Specifying the Texture
    Steps in Texture Mapping
  creating contours
    Creating Contours
  decals with alpha testing
    Alpha Test
  display lists cache texture data
    Display-List Design Philosophy
  enabling
    Enable Texture Mapping
    A Sample Program
  environment mapping
    Environment Mapping
  filtering
    Filtering
  image transformations
    Texture-Mapping Applications
  mipmapping
    Multiple Levels of Detail
    Filtering
  perspective correction hint
    A Sample Program
    A Sample Program
  rendering pipeline stage
    Texture Assembly
    Texture Memory
  sample program
    A Sample Program
  sample program with evaluated, Bézier surface
    Using Evaluators for Textures
  sample program with mipmapping
    Multiple Levels of Detail
  sample program with texture coordinate generation
    Creating Contours
  sample uses for
    Texture-Mapping Applications
  simulating shadows or spotlights
    The q Coordinate
  steps to perform
    Steps in Texture Mapping
  what's new in release 1.1
    Texture Mapping

3D models, rendering
  Initializing and Drawing Three-Dimensional Objects
  Drawing Three-Dimensional Objects
  What You Should Know Before Reading This Guide

Tiller, Wayne
  Prerequisites

tips, programming
  Programming Tips
  aaa
    Programming Tips
  error handling
    OpenGL Correctness Tips
  selection and picking
    Hints for Writing a Program That Uses Selection
  transformations
    Troubleshooting Transformations

transformations
  display lists cache transformations
    Display-List Design Philosophy
  modeling
    Viewing and Modeling Transformations
  projection
    The Projection Transformation
  viewing
    Viewing and Modeling Transformations
  viewport
    The Viewport Transformation

transformations:also see modeling transformations, projection transformations, viewing transformations, and viewport transformations
  Overview: The Camera Analogy
  combining multiple
    Examples of Composing Several Transformations
  general-purpose commands
    General-Purpose Transformation Commands
  matrices
    Transformation Matrices
  mimicking the geometric processing pipeline
    Reversing or Mimicking Transformations
  modeling
    Modeling Transformations
  ordering correctly
    Thinking about Transformations
  overview
    Viewing
  performance tips
    OpenGL Performance Tips
  projection
    Projection Transformations
  reversing the geometric processing pipeline
    Reversing or Mimicking Transformations
  sample program
    A Simple Example: Drawing a Cube
  sample program combining modeling transformations
    Building an Articulated Robot Arm
    Building a Solar System
  sample program for modeling transformations
    A Modeling Transformation Code Example
  sample program showing reversal of transformation pipeline
    Reversing or Mimicking Transformations
  troubleshooting
    Troubleshooting Transformations
  units
    Perspective Projection
  viewing
    Viewing Transformations
  viewport
    Viewport Transformation

translation
  Translate
  matrix
    Translation

translucent objects
  Blending
  Cheesy Translucency
  stencil test, creating with the
    Stencil Examples

transparent objects
  Blending
  creating with the alpha test
    Alpha Test

transposing images
  Alternative Uses for glDrawPixels() and glCopyPixels()
  Alternative Uses for glDrawPixels() and glCopyPixels()

triangle
  fan, specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  strip, specifying
    OpenGL Geometric Drawing Primitives
    OpenGL Geometric Drawing Primitives
  tessellated polygons decomposed into
    Tessellation Callback Routines

trimming
  curves and curved surfaces
    Trim a NURBS Surface
  sample program
    Trim a NURBS Surface

two-sided lighting
  Two-sided Lighting

up-vector
  The Viewing Transformation

Utility Library, OpenGL, see GLU
  OpenGL-Related Libraries

Utility Toolkit, OpenGL, see GLUT
  OpenGL-Related Libraries

van Dam, Andries
  What You Should Know Before Reading This Guide
  RGBA versus Color-Index Mode
  Homogeneous Coordinates and Transformation Matrices

van Widenfelt, Rolf
  The q Coordinate

vendor-specific extensions
  Extensions to the Standard

versions
  Which Version Am I Using?
  GLU
    Utility Library Version

vertex
  Describing Points, Lines, and Polygons
  aaa
    Vertex Arrays
  evaluators, generating with
    Evaluators
  feedback mode
    The Feedback Array
  per-vertex operations pipeline stage
    Per-Vertex Operations
    Per-Vertex Operations
  specifying
    Specifying Vertices
  tessellation, specifying for
    Polygon Definition
    Tessellation Callback Routines
  transformation pipeline
    Overview: The Camera Analogy

vertex arrays
  Vertex Arrays
  dereference a list of array elements
    Dereference a List of Array Elements
  dereference a sequence of array elements
    Dereference a Sequence of Array Elements
  dereference a single element
    Dereference a Single Array Element
  disabling
    Step 1: Enabling Arrays
  display list use
    What's Stored in a Display List
  enabling
    Step 1: Enabling Arrays
  interleaved arrays
    Interleaved Arrays
  interleaved arrays, specifying
    Interleaved Arrays
  performance tips
    OpenGL Performance Tips
  querying
    OpenGL State Variables
  reuse of vertices
    Dereference a List of Array Elements
  sample program
    Step 2: Specifying Data for the Arrays
  specifying data
    Step 2: Specifying Data for the Arrays
  steps to use
    Vertex Arrays
  stride between data
    Interleaved Arrays
    Stride

video
  fake
    Alternative Uses for glDrawPixels() and glCopyPixels()
  flipping an image with glPixelZoom()
    Magnifying, Reducing, or Flipping an Image
  textured images
    Replacing All or Part of a Texture Image

viewing
  camera analogy
    Overview: The Camera Analogy

viewing transformations
  The Viewing Transformation
  Viewing and Modeling Transformations
  Viewing Transformations
  The Viewing Transformation
  connection to modeling transformations
    The Modeling Transformation
  default position
    The Viewing Transformation
  pilot view
    Creating a Custom Utility Routine
  polar view
    Creating a Custom Utility Routine
  tripod analogy
    Overview: The Camera Analogy
  up-vector
    The Viewing Transformation

viewing volume
  clipping
    Viewing Volume Clipping

viewing volume
  Perspective Projection
  clipping
    Additional Clipping Planes
  jittering
    Scene Antialiasing
    Scene Antialiasing

viewpoint
  lighting, for
    Local or Infinite Viewpoint

viewport transformations
  Viewport Transformation
  The Viewport Transformation
  Overview: The Camera Analogy
  photograph analogy
    Overview: The Camera Analogy
  rendering pipeline stage
    Primitive Assembly
    Primitive Assembly

visual simulation
  fog, use of
    Fog

Voronoi polygons
  Dirichlet Domains

w coordinates
  Points
  Drawing the Scene
  Overview: The Camera Analogy
  avoiding negative values
    OpenGL Correctness Tips
  lighting, use with
    Position and Attenuation
  perspective division
    The Transformed Depth Coordinate
    Primitive Assembly

warping images
  Texture-Mapping Applications

Watt, Alan
  Texture Mapping

web sites
  IBM OS/2 software and documentation
    PGL: OpenGL Extension for IBM OS/2 Warp
  Microsoft Developer Network
    WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
  Silicon Graphics' OpenGL
    How to Obtain the Sample Code
  Template Graphics Software
    AGL: OpenGL Extension to the Apple Macintosh

WGL
  OpenGL-Related Libraries
  WGL: OpenGL Extension for Microsoft Windows NT and Windows 95
  wglCopyContext()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  wglCreateContext()
    Controlling Rendering
    Managing an OpenGL Rendering Context
    Initialization
  wglCreateLayerContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  wglDeleteContext()
    Controlling Rendering
  wglDescribeLayerPlane()
    Initialization
    Initialization
  wglDestroyContext()
    Managing an OpenGL Rendering Context
  wglGetCurrentContext()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  wglGetCurrentDC()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  wglGetLayerPaletteEntries()
    Controlling Rendering
    Finding a Color Palette
  wglMakeCurrent()
    Managing an OpenGL Rendering Context
    Controlling Rendering
  wglRealizeLayerPalette()
    Finding a Color Palette
    Controlling Rendering
  wglShareLists()
    Controlling Rendering
    Managing an OpenGL Rendering Context
  wglSwapLayerBuffers()
    Swapping Buffers
    Controlling Rendering
  wglUseFontBitmaps()
    Controlling Rendering
    Using a Bitmap or Outline Font
  wglUseFontOutlines()
    Using a Bitmap or Outline Font
    Controlling Rendering

Williams, Lance
  Multiple Levels of Detail

Win32
  ChoosePixelFormat()
    Initialization
    Initialization
  CreateDIBitmap()
    OpenGL Rendering to a Bitmap
    Controlling Rendering
  CreateDIBSection()
    Controlling Rendering
    OpenGL Rendering to a Bitmap
  DeleteObject()
    OpenGL Rendering to a Bitmap
    Controlling Rendering
  DescribePixelFormat()
    Initialization
    Initialization
  GetVersion()
    Initialization
    Initialization
  GetVersionEx()
    Initialization
    Initialization
  SetPixelFormat()
    Initialization
    Initialization
  SwapBuffers()
    Controlling Rendering
    Swapping Buffers

winding rules
  Winding Numbers and Winding Rules
  computational solid geometry, used for
    CSG Uses for Winding Rules
  reversing winding direction
    Other Tessellation Property Routines

window coordinates
  Viewport Transformation
  Overview: The Camera Analogy
  feedback mode
    The Feedback Array
  polygon offset
    Polygon Offset

window management
  glViewport() called, when window resized
    Defining the Viewport
  using GLUT
    Coordinate System Survival Kit
    Window Management

working set of textures
  A Working Set of Resident Textures
  Texture Proxy
  Texture Objects
  fragmentation of texture memory
    Texture Residence Strategies

writemask, See masking (buffers)
  Masking Buffers

writing pixel data, See pixel data (drawing)
  Drawing Pixels, Bitmaps, Fonts, and Images

X Window System
  GLX: OpenGL Extension for the X Window System
  OpenGL-Related Libraries
  client-server rendering
    What Is OpenGL?
  minimum framebuffer configuration
    Buffers and Their Uses
  X Visual
    GLX: OpenGL Extension for the X Window System
    Changing between Display Modes

z buffer, See depth buffer
  Depth Buffer

z coordinates, See depth coordinates
  The Transformed Depth Coordinate

zooming images
  Magnifying, Reducing, or Flipping an Image
  filtered
    Alternative Uses for glDrawPixels() and glCopyPixels()

Prev | Table of Contents |
Glossary |  |