- 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()