OpenGL Programming Guide

Contents ixBuffer Objects ...91 Creating Buffer Objects ...92 Making a Buffer Object Active ...93 Allocating and Initializing Buffer Objects with Data...93 Updating Data Values in Buffer

OpenGL ®

Programming Guide Seventh Edition

T he OpenGL graphics system is a software interface to graphics hardware (“GL” stands for “Graphics Library.”) It allows you to create interactive programs that produce color images of moving, three- dimensional objects With OpenGL, you can control computer-graphics technology to produce realistic pictures, or ones that depart from reality

in imaginative ways

The OpenGL Series from Addison-Wesley Professional comprises

tutorial and reference books that help programmers gain a practical understanding of OpenGL standards, along with the insight needed to unlock OpenGL’s full potential.

Visit informit.com /opengl for a complete list of available products

OpenGL ®

Programming Guide Seventh Edition

The Official Guide to

, Versions 3.0 and 3.1

Dave Shreiner

The Khronos OpenGL ARB Working Group

Upper Saddle River, NJ • Boston • Indianapolis • San Francisco

New York • Toronto • Montreal • London • Munich • Paris • MadridCapetown • Sydney • Tokyo • Singapore • Mexico City

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks Where those designations appear in this book, and the publisher was aware of a trademark claim, the designations have been printed with initial capital letters or

in all capitals.

The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omissions No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein.

The publisher offers excellent discounts on this book when ordered in quantity for bulk purchases or special sales, which may include electronic versions and/or custom covers and content particular to your business, training goals, marketing focus, and branding interests For more information, please contact:

U.S Corporate and Government Sales

Visit us on the Web: informit.com/aw

Library of Congress Cataloging-in-Publication Data

ISBN 978-0-321-55262-4 (pbk : alk paper)

1 Computer graphics 2 OpenGL I Title

T385.O635 2009

006.6'6—dc22

2009018793 Copyright © 2010 Pearson Education, Inc.

All rights reserved Printed in the United States of America This publication is protected by copyright, and permission must be obtained from the publisher prior to any prohibited reproduction, storage in a retrieval system, or transmission in any form or by any means, electronic, mechanical, photocopying, recording, or likewise For information regarding permissions, write to:

Pearson Education, Inc.

Rights and Contracts Department

501 Boylston Street, Suite 900

For my family—Felicity, Max, Sarah, and Scout

This page intentionally left blank

Contents

Figures xxi

Tables xxv

Examples xxix

About This Guide xxxv

What This Guide Contains xxxv

What’s New in This Edition xxxviii

What You Should Know Before Reading This Guide xl How to Obtain the Sample Code xli Errata xlii Style Conventions xlii Distinguishing Deprecated Features xliii Acknowledgments xlv 1 Introduction to OpenGL 1

What Is OpenGL? 2

A Smidgen of OpenGL Code 5

OpenGL Command Syntax 7

OpenGL as a State Machine 9

OpenGL Rendering Pipeline 10

Display Lists 11

Evaluators 11

Per-Vertex Operations 12

Primitive Assembly 12

Pixel Operations 13

Texture Assembly 13

Rasterization 14

Fragment Operations 14

OpenGL-Related Libraries 14

Include Files 15

GLUT, the OpenGL Utility Toolkit 17

Animation 22

The Refresh That Pauses 23

Motion = Redraw + Swap 24

OpenGL and Its Deprecation Mechanism 27

OpenGL Contexts 27

Accessing OpenGL Functions 29

2 State Management and Drawing Geometric Objects 31

A Drawing Survival Kit 34

Clearing the Window 34

Specifying a Color 37

Forcing Completion of Drawing 38

Coordinate System Survival Kit 40

Describing Points, Lines, and Polygons 42

What Are Points, Lines, and Polygons? 42

Specifying Vertices 46

OpenGL Geometric Drawing Primitives 47

Basic State Management 53

Displaying Points, Lines, and Polygons 55

Point Details 55

Line Details 56

Polygon Details 60

Normal Vectors 68

Vertex Arrays 70

Step 1: Enabling Arrays 72

Step 2: Specifying Data for the Arrays 73

Step 3: Dereferencing and Rendering 77

Restarting Primitives 83

Instanced Drawing 86

Interleaved Arrays 88

Contents ix

Buffer Objects 91

Creating Buffer Objects 92

Making a Buffer Object Active 93

Allocating and Initializing Buffer Objects with Data 93

Updating Data Values in Buffer Objects 96

Copying Data Between Buffer Objects 101

Cleaning Up Buffer Objects 102

Using Buffer Objects with Vertex-Array Data 102

Vertex-Array Objects 104

Attribute Groups 110

Some Hints for Building Polygonal Models of Surfaces 113

An Example: Building an Icosahedron 115

3 Viewing 123

Overview: The Camera Analogy 126

A Simple Example: Drawing a Cube 129

General-Purpose Transformation Commands 134

Viewing and Modeling Transformations 137

Thinking about Transformations 137

Modeling Transformations 140

Viewing Transformations 146

Projection Transformations 152

Perspective Projection 153

Orthographic Projection 156

Viewing Volume Clipping 158

Viewport Transformation 158

Defining the Viewport 159

The Transformed Depth Coordinate 161

Troubleshooting Transformations 162

Manipulating the Matrix Stacks 164

The Modelview Matrix Stack 167

The Projection Matrix Stack 168

Additional Clipping Planes 168

Examples of Composing Several Transformations 172

Building a Solar System 172

Building an Articulated Robot Arm 175

Reversing or Mimicking Transformations 179

4 Color 185

Color Perception 186

Computer Color 188

RGBA versus Color-Index Mode 190

RGBA Display Mode 191

Color-Index Display Mode 193

Choosing between RGBA and Color-Index Mode 195

Changing between Display Modes 196

Specifying a Color and a Shading Model 196

Specifying a Color in RGBA Mode 197

Specifying a Color in Color-Index Mode 199

Specifying a Shading Model 200

5 Lighting 203

A Hidden-Surface Removal Survival Kit 205

Real-World and OpenGL Lighting 207

Ambient, Diffuse, Specular, and Emissive Light 208

Material Colors 209

RGB Values for Lights and Materials 209

A Simple Example: Rendering a Lit Sphere 210

Creating Light Sources 214

Color 216

Position and Attenuation 217

Spotlights 219

Multiple Lights 220

Controlling a Light’s Position and Direction 221

Selecting a Lighting Model 227

Global Ambient Light 228

Local or Infinite Viewpoint 229

Two-Sided Lighting 229

Secondary Specular Color 230

Enabling Lighting 231

Defining Material Properties 231

Diffuse and Ambient Reflection 233

Specular Reflection 234

Emission 234

Contents xi

Changing Material Properties 235

Color Material Mode 237

The Mathematics of Lighting 240

Material Emission 241

Scaled Global Ambient Light 242

Contributions from Light Sources 242

Putting It All Together 244

Secondary Specular Color 245

Lighting in Color-Index Mode 246

The Mathematics of Color-Index Mode Lighting 247

6 Blending, Antialiasing, Fog, and Polygon Offset 249

Blending 251

The Source and Destination Factors 252

Enabling Blending 255

Combining Pixels Using Blending Equations 255

Sample Uses of Blending 258

A Blending Example 260

Three-Dimensional Blending with the Depth Buffer 263

Antialiasing 267

Antialiasing Points or Lines 269

Antialiasing Geometric Primitives with Multisampling 275

Antialiasing Polygons 279

Fog 280

Using Fog 281

Fog Equations 284

Point Parameters 291

Polygon Offset 293

7 Display Lists 297

Why Use Display Lists? 298

An Example of Using a Display List 299

Display List Design Philosophy 302

Creating and Executing a Display List 305

Naming and Creating a Display List 306

What’s Stored in a Display List? 307

Executing a Display List 309

Hierarchical Display Lists 310

Managing Display List Indices 311

Executing Multiple Display Lists 312

Managing State Variables with Display Lists 318

Encapsulating Mode Changes 319

8 Drawing Pixels, Bitmaps, Fonts, and Images 321

Bitmaps and Fonts 323

The Current Raster Position 325

Drawing the Bitmap 327

Choosing a Color for the Bitmap 328

Fonts and Display Lists 329

Defining and Using a Complete Font 331

Images 333

Reading, Writing, and Copying Pixel Data 333

Imaging Pipeline 343

Pixel Packing and Unpacking 346

Controlling Pixel-Storage Modes 347

Pixel-Transfer Operations 351

Pixel Mapping 354

Magnifying, Reducing, or Flipping an Image 356

Reading and Drawing Pixel Rectangles 359

The Pixel Rectangle Drawing Process 359

Using Buffer Objects with Pixel Rectangle Data 362

Using Buffer Objects to Transfer Pixel Data 363

Using Buffer Objects to Retrieve Pixel Data 365

Tips for Improving Pixel Drawing Rates 366

Imaging Subset 367

Color Tables 369

Convolutions 374

Color Matrix 382

Histogram 383

Minmax 387

Contents xiii

9 Texture Mapping 389

An Overview and an Example 395

Steps in Texture Mapping 395

A Sample Program 397

Specifying the Texture 400

Texture Proxy 406

Replacing All or Part of a Texture Image 408

One-Dimensional Textures 412

Three-Dimensional Textures 414

Texture Arrays 419

Compressed Texture Images 420

Using a Texture’s Borders 423

Mipmaps: Multiple Levels of Detail 423

Filtering 434

Texture Objects 437

Naming a Texture Object 438

Creating and Using Texture Objects 438

Cleaning Up Texture Objects 441

A Working Set of Resident Textures 442

Texture Functions 444

Assigning Texture Coordinates 448

Computing Appropriate Texture Coordinates 450

Repeating and Clamping Textures 452

Automatic Texture-Coordinate Generation 457

Creating Contours 458

Sphere Map 463

Cube Map Textures 465

Multitexturing 467

Texture Combiner Functions 472

The Interpolation Combiner Function 477

Applying Secondary Color after Texturing 478

Secondary Color When Lighting Is Disabled 478

Secondary Specular Color When Lighting Is Enabled 479

Point Sprites 479

The Texture Matrix Stack 481

Depth Textures 483

Creating a Shadow Map 483

Generating Texture Coordinates and Rendering 485

10 The Framebuffer 489

Buffers and Their Uses 492

Color Buffers 493

Clearing Buffers 495

Selecting Color Buffers for Writing and Reading 497

Masking Buffers 499

Testing and Operating on Fragments 501

Scissor Test 502

Alpha Test 502

Stencil Test 504

Depth Test 510

Occlusion Query 511

Conditional Rendering 514

Blending, Dithering, and Logical Operations 515

The Accumulation Buffer 518

Motion Blur 520

Depth of Field 520

Soft Shadows 525

Jittering 525

Framebuffer Objects 526

Renderbuffers 529

Copying Pixel Rectangles 539

11 Tessellators and Quadrics 541

Polygon Tessellation 542

Creating a Tessellation Object 544

Tessellation Callback Routines 544

Tessellation Properties 549

Polygon Definition 554

Deleting a Tessellation Object 557

Tessellation Performance Tips 557

Describing GLU Errors 557

Backward Compatibility 558

Contents xv

Quadrics: Rendering Spheres, Cylinders, and Disks 559

Managing Quadrics Objects 560

Controlling Quadrics Attributes 561

Quadrics Primitives 563

12 Evaluators and NURBS 569

Prerequisites 571

Evaluators 572

One-Dimensional Evaluators 572

Two-Dimensional Evaluators 578

Using Evaluators for Textures 584

The GLU NURBS Interface 586

A Simple NURBS Example 587

Managing a NURBS Object 591

Creating a NURBS Curve or Surface 595

Trimming a NURBS Surface 601

13 Selection and Feedback 605

Selection 606

The Basic Steps 607

Creating the Name Stack 608

The Hit Record 610

A Selection Example 611

Picking 614

Hints for Writing a Program That Uses Selection 625

Feedback 627

The Feedback Array 629

Using Markers in Feedback Mode 630

A Feedback Example 630

14 Now That You Know 635

Error Handling 637

Which Version Am I Using? 639

Utility Library Version 641

Window System Extension Versions 641

Extensions to the Standard 641

Extensions to the Standard for Microsoft Windows (WGL) 643

Cheesy Translucency 644

An Easy Fade Effect 645

Object Selection Using the Back Buffer 646

Cheap Image Transformation 647

Displaying Layers 649

Antialiased Characters 650

Drawing Round Points 653

Interpolating Images 653

Making Decals 653

Drawing Filled, Concave Polygons Using the Stencil Buffer 655

Finding Interference Regions 656

Shadows 658

Hidden-Line Removal 659

Hidden-Line Removal with Polygon Offset 659

Hidden-Line Removal with the Stencil Buffer 660

Texture Mapping Applications 661

Drawing Depth-Buffered Images 662

Dirichlet Domains 662

Life in the Stencil Buffer 664

Alternative Uses for glDrawPixels() and glCopyPixels() 665

15 The OpenGL Shading Language 667

The OpenGL Graphics Pipeline and Programmable Shading 668

Vertex Processing 670

Fragment Processing 671

Using GLSL Shaders 672

A Sample Shader 672

OpenGL / GLSL Interface 673

The OpenGL Shading Language 681

Creating Shaders with GLSL 681

The Starting Point 681

Declaring Variables 682

Aggregate Types 684

Uniform Blocks 692

Specifying Uniform Variables Blocks in Shaders 693

Accessing Uniform Blocks from Your Application 695

Computational Invariance 701

Contents xvii

Statements 702

Functions 706

Using OpenGL State Values in GLSL Programs 707

Accessing Texture Maps in Shaders 707

Shader Preprocessor 711

Preprocessor Directives 712

Macro Definition 712

Preprocessor Conditionals 713

Compiler Control 713

Extension Processing in Shaders 714

Vertex Shader Specifics 715

Transform Feedback 722

Fragment Shader Specifics 727

Rendering to Multiple Output Buffers 729

A Basics of GLUT: The OpenGL Utility Toolkit 731

Initializing and Creating a Window 732

Handling Window and Input Events 733

Loading the Color Map 735

Initializing and Drawing Three-Dimensional Objects 735

Managing a Background Process 736

Running the Program 737

B State Variables 739

The Query Commands 740

OpenGL State Variables 743

Current Values and Associated Data 744

Vertex Array Data State (Not Included in Vertex Array Object State) 746

Vertex Array Object State .746

Transformation 753

Coloring 755

Lighting 756

Rasterization 758

Multisampling 760

Texturing 761

Pixel Operations 768

Framebuffer Control 771

Framebuffer Object State 772

Renderbuffer Object State 775

Pixels 776

Evaluators 783

Shader Object State 784

Program Object State 785

Query Object State 789

Transform Feedback State 789

Vertex Shader State 791

Hints 791

Implementation-Dependent Values 792

Implementation-Dependent Pixel Depths 800

Miscellaneous 800

C Homogeneous Coordinates and Transformation Matrices 803

Homogeneous Coordinates 804

Transforming Vertices 804

Transforming Normals 805

Transformation Matrices 805

Translation 806

Scaling 806

Rotation 806

Perspective Projection 807

Orthographic Projection 808

D OpenGL and Window Systems 809

Accessing New OpenGL Functions 810

GLEW: The OpenGL Extension Wrangler 811

GLX: OpenGL Extension for the X Window System 812

Initialization 813

Controlling Rendering 814

GLX Prototypes 816

AGL: OpenGL Extensions for the Apple Macintosh 819

Initialization 820

Rendering and Contexts 820

Contents xix

Managing an OpenGL Rendering Context 820

On-Screen Rendering 821

Off-Screen Rendering 821

Full-Screen Rendering 821

Swapping Buffers 821

Updating the Rendering Buffers 821

Using an Apple Macintosh Font 822

Error Handling 822

AGL Prototypes 822

WGL: OpenGL Extension for Microsoft Windows 95/98/NT/ME/2000/XP 824

Initialization 825

Controlling Rendering 825

WGL Prototypes 827

Glossary 831

Index 857

The following appendices are available online at

http://www.opengl-redbook.com/appendices/

E Order of Operations

F Programming Tips

G OpenGL Invariance

H Calculating Normal Vectors

I Built-In OpenGL Shading Language Variables and Functions

J Floating-Point Formats for Textures, Framebuffers, and Renderbuffers

K RGTC Compressed Texture Format

L std140 Uniform Buffer Layout

This page intentionally left blank

Figures

Figure 1-1 White Rectangle on a Black Background 6

Figure 1-2 Order of Operations 11

Figure 1-3 Double-Buffered Rotating Square 25

Figure 2-1 Coordinate System Defined by w = 50, h = 50 41

Figure 2-2 Two Connected Series of Line Segments 43

Figure 2-3 Valid and Invalid Polygons 44

Figure 2-4 Nonplanar Polygon Transformed to Nonsimple Polygon 45

Figure 2-5 Approximating Curves 46

Figure 2-6 Drawing a Polygon or a Set of Points 47

Figure 2-7 Geometric Primitive Types 49

Figure 2-8 Stippled Lines 58

Figure 2-9 Wide Stippled Lines 58

Figure 2-10 Constructing a Polygon Stipple Pattern 64

Figure 2-11 Stippled Polygons 65

Figure 2-12 Subdividing a Nonconvex Polygon 67

Figure 2-13 Outlined Polygon Drawn Using Edge Flags 68

Figure 2-14 Six Sides, Eight Shared Vertices 71

Figure 2-15 Cube with Numbered Vertices 79

Figure 2-16 Modifying an Undesirable T-Intersection 114

Figure 2-17 Subdividing to Improve a Polygonal Approximation

to a Surface 118

Figure 3-1 The Camera Analogy 127

Figure 3-2 Stages of Vertex Transformation 128

Figure 3-3 Transformed Cube 129

Figure 3-4 Rotating First or Translating First 138

Figure 3-5 Translating an Object 141

Figure 3-6 Rotating an Object 142

Figure 3-7 Scaling and Reflecting an Object 143

Figure 3-8 Modeling Transformation Example 144

Figure 3-9 Object and Viewpoint at the Origin 147

Figure 3-10 Separating the Viewpoint and the Object 147

Figure 3-11 Default Camera Position 149

Figure 3-12 Using gluLookAt() 150

Figure 3-13 Perspective Viewing Volume Specified by glFrustum() 154

Figure 3-14 Perspective Viewing Volume Specified

by gluPerspective() 155

Figure 3-15 Orthographic Viewing Volume 157

Figure 3-16 Viewport Rectangle 159

Figure 3-17 Mapping the Viewing Volume to the Viewport 160

Figure 3-18 Perspective Projection and Transformed

Depth Coordinates 161

Figure 3-19 Using Trigonometry to Calculate the Field of View 163

Figure 3-20 Modelview and Projection Matrix Stacks 165

Figure 3-21 Pushing and Popping the Matrix Stack 166

Figure 3-22 Additional Clipping Planes and the Viewing Volume 169

Figure 3-23 Clipped Wireframe Sphere 170

Figure 3-24 Planet and Sun 173

Figure 3-25 Robot Arm 176

Figure 3-26 Robot Arm with Fingers 179

Figure 4-1 The Color Cube in Black and White 189

Figure 4-2 RGB Values from the Bitplanes 191

Figure 4-3 Dithering Black and White to Create Gray 193

Figure 4-4 A Color Map 194

Figure 4-5 Using a Color Map to Paint a Picture 194

Figure 5-1 A Lit and an Unlit Sphere 204

Figure 5-2 GL_SPOT_CUTOFF Parameter 219

Figure 6-1 Creating a Nonrectangular Raster Image 260

Figure 6-2 Aliased and Antialiased Lines 267

Figure 6-3 Determining Coverage Values 268

Figure 6-4 Fog-Density Equations 285

Figures xxiii

Figure 6-5 Polygons and Their Depth Slopes 295

Figure 7-1 Stroked Font That Defines the Characters A, E, P, R, S 314

Figure 8-1 Bitmapped F and Its Data 324

Figure 8-2 Bitmap and Its Associated Parameters 327

Figure 8-3 Simplistic Diagram of Pixel Data Flow 334

Figure 8-4 Component Ordering for Some Data Types

and Pixel Formats 340

Figure 8-5 Imaging Pipeline 343

Figure 8-6 glCopyPixels() Pixel Path 344

Figure 8-7 glBitmap() Pixel Path 345

Figure 8-8 glTexImage*(), glTexSubImage*(), and

glGetTexImage() Pixel Paths 345

Figure 8-9 glCopyTexImage*() and

glCopyTexSubImage*() Pixel Paths 346

Figure 8-10 Byte Swap Effect on Byte, Short, and Integer Data 349

Figure 8-11 *SKIP_ROWS, *SKIP_PIXELS, and

*ROW_LENGTH Parameters 350

Figure 8-12 Drawing Pixels with glDrawPixels() 359

Figure 8-13 Reading Pixels with glReadPixels() 361

Figure 8-14 Imaging Subset Operations 368

Figure 8-15 The Pixel Convolution Operation 375

Figure 9-1 Texture-Mapping Process 391

Figure 9-2 Texture-Mapped Squares 397

Figure 9-3 Texture with Subimage Added 409

Figure 9-4 *IMAGE_HEIGHT Pixel-Storage Mode 418

Figure 9-5 *SKIP_IMAGES Pixel-Storage Mode 419

Figure 9-6 Mipmaps 424

Figure 9-7 Using a Mosaic Texture 431

Figure 9-8 Texture Magnification and Minification 435

Figure 9-9 Texture-Map Distortion 451

Figure 9-10 Repeating a Texture 453

Figure 9-11 Comparing GL_REPEAT to GL_MIRRORED_REPEAT 454

Figure 9-12 Clamping a Texture 454

Figure 9-13 Repeating and Clamping a Texture 454

Figure 9-14 Multitexture Processing Pipeline 467

Figure 9-15 Comparison of Antialiased Points and Textured

Point Sprites 480

Figure 9-16 Assignment of Texture Coordinates Based on the

Setting of GL_POINT_SPRITE_COORD_ORIGIN 481

Figure 10-1 Region Occupied by a Pixel 490

Figure 10-2 Motion-Blurred Object 521

Figure 10-3 Jittered Viewing Volume for Depth-of-Field Effects 522

Figure 11-1 Contours That Require Tessellation 543

Figure 11-2 Winding Numbers for Sample Contours 551

Figure 11-3 How Winding Rules Define Interiors 552

Figure 12-1 Bézier Curve 573

Figure 12-2 Bézier Surface 580

Figure 12-3 Lit, Shaded Bézier Surface Drawn with a Mesh 583

Figure 12-4 NURBS Surface 588

Figure 12-5 Parametric Trimming Curves 602

Figure 12-6 Trimmed NURBS Surface 603

Figure 14-1 Antialiased Characters 651

Figure 14-2 Concave Polygon 655

Figure 14-3 Dirichlet Domains 663

Figure 14-4 Six Generations from the Game of Life 664

Figure 15-1 Overview of the OpenGL Fixed-Function Pipeline 668

Figure 15-2 Vertex Processing Pipeline 670

Figure 15-3 Fragment Processing Pipeline 671

Figure 15-4 Shader Creation Flowchart 674

Figure 15-5 GLSL Vertex Shader Input and Output Variables 716

Figure 15-6 Fragment Shader Built-In Variables 727

Tables

Table 1-1 Command Suffixes and Argument Data Types 8

Table 2-1 Clearing Buffers 36

Table 2-2 Geometric Primitive Names and Meanings 48

Table 2-3 Valid Commands between glBegin() and glEnd() 51

Table 2-4 Vertex Array Sizes (Values per Vertex) and Data Types 75

Table 2-5 Variables That Direct glInterleavedArrays() 90

Table 2-6 Values for usage Parameter of glBufferData() 95

Table 2-7 Values for the access Parameter of glMapBufferRange() 99

Table 2-8 Attribute Groups 111

Table 2-9 Client Attribute Groups 113

Table 4-1 Converting Color Values to Floating-Point Numbers 198

Table 4-2 Values for Use with glClampColor() 199

Table 4-3 How OpenGL Selects a Color for the ith

Flat-Shaded Polygon 202

Table 5-1 Default Values for pname Parameter of glLight*() 215

Table 5-2 Default Values for pname Parameter of glLightModel*() 228

Table 5-3 Default Values for pname Parameter of glMaterial*() 232

Table 6-1 Source and Destination Blending Factors 254

Table 6-2 Blending Equation Mathematical Operations 256

Table 6-3 Values for Use with glHint() 269

Table 7-1 OpenGL Functions That Cannot Be

Stored in Display Lists 308

Table 8-1 Pixel Formats for glReadPixels() or glDrawPixels() 335

Table 8-2 Data Types for glReadPixels() or glDrawPixels() 336

Table 8-3 Valid Pixel Formats for Packed Data Types 338

Table 8-4 glPixelStore() Parameters 348

Table 8-5 glPixelTransfer*() Parameters 352

Table 8-6 glPixelMap*() Parameter Names and Values 354

Table 8-7 When Color Table Operations Occur in the

Imaging Pipeline 369

Table 8-8 Color Table Pixel Replacement 370

Table 8-9 How Convolution Filters Affect RGBA

Pixel Components 376

Table 9-1 Mipmapping Level Parameter Controls 432

Table 9-2 Mipmapping Level-of-Detail Parameter Controls 433

Table 9-3 Filtering Methods for Magnification and Minification 435

Table 9-4 Deriving Color Values from Different Texture Formats 445

Table 9-5 Replace, Modulate, and Decal Texture Functions 446

Table 9-6 Blend and Add Texture Functions 447

Table 9-7 glTexParameter*() Parameters 455

Table 9-8 Texture Environment Parameters If target Is

GL_TEXTURE_ENV 473

Table 9-9 GL_COMBINE_RGB and GL_COMBINE_ALPHA

Functions 474

Table 9-10 Default Values for Some Texture Environment Modes 478

Table 10-1 Query Parameters for Per-Pixel Buffer Storage 493

Table 10-2 glAlphaFunc() Parameter Values 503

Table 10-3 Query Values for the Stencil Test 506

Table 10-4 Sixteen Logical Operations 518

Table 10-5 Sample Jittering Values 525

Table 10-6 Framebuffer Attachments 532

Table 10-7 Errors returned by glCheckFramebufferStatus() 539

Table 12-1 Types of Control Points for glMap1*() 576

Table 13-1 glFeedbackBuffer() type Values 628

Table 13-2 Feedback Array Syntax 629

Table 14-1 OpenGL Error Codes 638

Table 14-2 Eight Combinations of Layers 649

Table 15-1 Basic Data Types in GLSL 682

Table 15-2 GLSL Vector and Matrix Types 684

Table 15-3 Vector Component Accessors 686

Tables xxvii

Table 15-4 GLSL Type Modifiers 688

Table 15-5 Additional in Keyword Qualifiers (for Fragment Shader

Inputs) 689

Table 15-6 Layout Qualifiers for Uniform Blocks 694

Table 15-7 GLSL Operators and Their Precedence 702

Table 15-8 GLSL Flow-Control Statements 705

Table 15-9 GLSL Function Parameter Access Modifiers 707

Table 15-10 Fragment Shader Texture Sampler Types 708

Table 15-11 GLSL Preprocessor Directives 712

Table 15-12 GLSL Preprocessor Predefined Macros 713

Table 15-13 GLSL Extension Directive Modifiers 715

Table 15-14 Vertex Shader Attribute Global Variables 717

Table 15-15 Vertex Shader Special Global Variables 720

Table 15-16 Vertex Shader Varying Global Variables 721

Table 15-17 Transform Feedback Primitives and Their Permitted

OpenGL Rendering Types 724

Table 15-18 Fragment Shader Varying Global Variables 728

Table 15-19 Fragment Shader Output Global Variables 728

Table B-1 State Variables for Current Values and Associated Data 744

Table B-2 Vertex Array Data State Variables 746

Table B-3 Vertex Array Object State Variables 746

Table B-4 Vertex Buffer Object State Variables 752

Table B-5 Transformation State Variables 753

Table B-6 Coloring State Variables 755

Table B-7 Lighting State Variables 756

Table B-8 Rasterization State Variables 758

Table B-9 Multisampling 760

Table B-10 Texturing State Variables 761

Table B-11 Pixel Operations 768

Table B-12 Framebuffer Control State Variables 771

Table B-13 Framebuffer Object State Variables 772

Table B-14 Renderbuffer Object State Variables 775

Table B-15 Pixel State Variables 776

Table B-16 Evaluator State Variables 783

Table B-17 Shader Object State Variables 784

Table B-18 Program Object State Variables 785

Table B-19 Query Object State Variables 789

Table B-20 Transform Feedback State Variables 789

Table B-21 Vertex Shader State Variables 791

Table B-22 Hint State Variables 791

Table B-23 Implementation-Dependent State Variables 792

Table B-24 Implementation-Dependent Pixel-Depth

State Variables 800

Table B-25 Miscellaneous State Variables 800

Examples

Example 1-1 Chunk of OpenGL Code 6

Example 1-2 Simple OpenGL Program Using GLUT: hello.c 19

Example 1-3 Double-Buffered Program: double.c 25

Example 1-4 Creating an OpenGL Version 3.0 Context Using GLUT 28

Example 2-1 Reshape Callback Function 41

Example 2-2 Legal Uses of glVertex*() 46

Example 2-3 Filled Polygon 47

Example 2-4 Other Constructs between glBegin() and glEnd() 52

Example 2-5 Line Stipple Patterns: lines.c 59

Example 2-6 Polygon Stipple Patterns: polys.c 65

Example 2-7 Marking Polygon Boundary Edges 68

Example 2-8 Surface Normals at Vertices 69

Example 2-9 Enabling and Loading Vertex Arrays: varray.c 75

Example 2-10 Using glArrayElement() to Define Colors and Vertices 77

Example 2-11 Using glDrawElements() to Dereference Several

Array Elements 79

Example 2-12 Compacting Several glDrawElements() Calls into One 80

Example 2-13 Two glDrawElements() Calls That Render Two

Line Strips 80

Example 2-14 Use of glMultiDrawElements(): mvarray.c 81

Example 2-15 Using glPrimitiveRestartIndex() to Render Multiple

Triangle Strips: primrestart.c 84

Example 2-16 Effect of glInterleavedArrays(format, stride, pointer) 89

Example 2-17 Using Buffer Objects with Vertex Data 103

Example 2-18 Using Vertex-Array Objects: vao.c 106

Example 2-19 Drawing an Icosahedron 115

Example 2-20 Generating Normal Vectors for a Surface 117

Example 2-21 Calculating the Normalized Cross Product of

Two Vectors 117

Example 2-22 Single Subdivision 119

Example 2-23 Recursive Subdivision 120

Example 2-24 Generalized Subdivision 121

Example 3-1 Transformed Cube: cube.c 130

Example 3-2 Using Modeling Transformations: model.c 145

Example 3-3 Calculating Field of View 163

Example 3-4 Pushing and Popping the Matrix 166

Example 3-5 Wireframe Sphere with Two Clipping Planes: clip.c 170

Example 3-6 Planetary System: planet.c 173

Example 3-7 Robot Arm: robot.c 177

Example 3-8 Reversing the Geometric Processing Pipeline:

unproject.c 180

Example 4-1 Drawing a Smooth-Shaded Triangle: smooth.c 200

Example 5-1 Drawing a Lit Sphere: light.c 210

Example 5-2 Defining Colors and Position for a Light Source 215

Example 5-3 Second Light Source 221

Example 5-4 Stationary Light Source 222

Example 5-5 Independently Moving Light Source 223

Example 5-6 Moving a Light with Modeling Transformations:

movelight.c 224

Example 5-7 Light Source That Moves with the Viewpoint 226

Example 5-8 Different Material Properties: material.c 235

Example 5-9 Using glColorMaterial(): colormat.c 238

Example 6-1 Demonstrating the Blend Equation Modes:

blendeqn.c 256

Example 6-2 Blending Example: alpha.c 261

Example 6-3 Three-Dimensional Blending: alpha3D.c 264

Example 6-4 Antialiased Lines: aargb.c 270

Example 6-5 Antialiasing in Color-Index Mode: aaindex.c 272

Example 6-6 Enabling Multisampling: multisamp.c 276

Example 6-7 Five Fogged Spheres in RGBA Mode: fog.c 281

Examples xxxi

Example 6-8 Fog in Color-Index Mode: fogindex.c 286

Example 6-9 Fog Coordinates: fogcoord.c 289

Example 6-10 Point Parameters: pointp.c 292

Example 6-11 Polygon Offset to Eliminate Visual Artifacts: polyoff.c 296

Example 7-1 Creating a Display List: torus.c 299

Example 7-2 Using a Display List: list.c 305

Example 7-3 Hierarchical Display List 311

Example 7-4 Defining Multiple Display Lists 313

Example 7-5 Multiple Display Lists to Define a Stroked

Font: stroke.c 314

Example 7-6 Persistence of State Changes after Execution of a

Display List 318

Example 7-7 Restoring State Variables within a Display List 319

Example 7-8 The Display List May or May Not Affect drawLine() 319

Example 7-9 Display Lists for Mode Changes 320

Example 8-1 Drawing a Bitmapped Character: drawf.c 324

Example 8-2 Drawing a Complete Font: font.c 331

Example 8-3 Use of glDrawPixels(): image.c 341

Example 8-4 Drawing, Copying, and Zooming Pixel Data: image.c 357

Example 8-5 Drawing, Copying, and Zooming Pixel Data Stored

in a Buffer Object: pboimage.c 364

Example 8-6 Retrieving Pixel Data Using Buffer Objects 365

Example 8-7 Pixel Replacement Using Color Tables: colortable.c 371

Example 8-8 Using Two-Dimensional Convolution Filters:

Example 9-1 Texture-Mapped Checkerboard: checker.c 398

Example 9-2 Querying Texture Resources with a Texture Proxy 408

Example 9-3 Replacing a Texture Subimage: texsub.c 410

Example 9-4 Three-Dimensional Texturing: texture3d.c 415

Example 9-5 Mipmap Textures: mipmap.c 426

Example 9-6 Setting Base and Maximum Mipmap Levels 433

Example 9-7 Binding Texture Objects: texbind.c 439

Example 9-8 Automatic Texture-Coordinate Generation: texgen.c 459

Example 9-9 Generating Cube Map Texture Coordinates:

cubemap.c 466

Example 9-10 Initializing Texture Units for Multitexturing:

multitex.c 469

Example 9-11 Specifying Vertices for Multitexturing 471

Example 9-12 Reverting to Texture Unit 0 472

Example 9-13 Setting the Programmable Combiner Functions 474

Example 9-14 Setting the Combiner Function Sources 475

Example 9-15 Using an Alpha Value for RGB Combiner Operations 476

Example 9-16 Interpolation Combiner Function: combiner.c 477

Example 9-17 Configuring a Point Sprite for Texture Mapping: sprite.c 481

Example 9-18 Rendering Scene with Viewpoint at Light Source:

shadowmap.c 484

Example 9-19 Calculating Texture Coordinates: shadowmap.c 485

Example 9-20 Rendering Scene Comparing r Coordinate:

shadowmap.c 486

Example 10-1 Using the Stencil Test: stencil.c 507

Example 10-2 Rendering Geometry with Occlusion Query: occquery.c 512

Example 10-3 Retrieving the Results of an Occlusion Query:

occquery.c 513

Example 10-4 Rendering Using Conditional Rendering: condrender.c 515

Example 10-5 Depth-of-Field Effect: dof.c 522

Example 10-6 Creating an RGBA Color Renderbuffer: fbo.c 532

Example 10-7 Attaching a Renderbuffer for Rendering: fbo.c 533

Example 10-8 Attaching a Texture Level as a Framebuffer

Attachment: fbotexture.c 536

Example 11-1 Registering Tessellation Callbacks: tess.c 546

Example 11-2 Vertex and Combine Callbacks: tess.c 548

Example 11-3 Polygon Definition: tess.c 556

Example 11-4 Quadrics Objects: quadric.c 565

Example 12-1 Bézier Curve with Four Control Points: bezcurve.c 573

Example 12-2 Bézier Surface: bezsurf.c 580

Examples xxxiii

Example 12-3 Lit, Shaded Bézier Surface Using a Mesh: bezmesh.c 582

Example 12-4 Using Evaluators for Textures: texturesurf.c 584

Example 12-5 NURBS Surface: surface.c 588

Example 12-6 Registering NURBS Tessellation Callbacks: surfpoints.c 599

Example 12-7 The NURBS Tessellation Callbacks: surfpoints.c 600

Example 12-8 Trimming a NURBS Surface: trim.c 603

Example 13-1 Creating a Name Stack 609

Example 13-2 Selection Example: select.c 611

Example 13-3 Picking Example: picksquare.c 616

Example 13-4 Creating Multiple Names 619

Example 13-5 Using Multiple Names 620

Example 13-6 Picking with Depth Values: pickdepth.c 621

Example 13-7 Feedback Mode: feedback.c 631

Example 14-1 Querying and Printing an Error 639

Example 14-2 Determining if an Extension Is Supported

(Prior to GLU 1.3) 643

Example 14-3 Locating an OpenGL Extension with

wglGetProcAddress() 644

Example 15-1 A Sample GLSL (Version 1.30) Vertex Shader 673

Example 15-2 The Same GLSL Vertex Shader (Version 1.40) 673

Example 15-3 Creating and Liking GLSL shaders 678

Example 15-4 Obtaining a Uniform Variable’s Index and

Assigning Values 692

Example 15-5 Declaring a Uniform Variable Block 693

Example 15-6 Initializing Uniform Variables in a Named Uniform

Block: ubo.c 697

Example 15-7 Associating Texture Units with Sampler Variables 709

Example 15-8 Sampling a Texture Within a GLSL Shader 709

Example 15-9 Dependent Texture Reads in GLSL 710

Example 15-10Using Transform Feedback to Capture Geometric

Primitives: xfb.c 724

This page intentionally left blank

About This Guide xxxv

The OpenGL graphics system is a software interface to graphics hardware

“GL” stands for “Graphics Library.” It allows you to create interactive

programs that produce color images of moving, three-dimensional objects

With OpenGL, you can control computer-graphics technology to produce

realistic pictures, or ones that depart from reality in imaginative ways This

guide explains how to program with the OpenGL graphics system to deliver

the visual effect you want

What This Guide Contains

This guide has 15 chapters The first five chapters present basic information

that you need to understand to be able to draw a properly colored and lit

three-dimensional object on the screen

• Chapter 1, “Introduction to OpenGL,” provides a glimpse into the

kinds of things OpenGL can do It also presents a simple OpenGL

pro-gram and explains essential propro-gramming details you need to know for

subsequent chapters

• Chapter 2, “State Management and Drawing Geometric Objects,”

explains how to create a three-dimensional geometric description of an

object that is eventually drawn on the screen

• Chapter 3, “Viewing,” describes how such three-dimensional models

are transformed before being drawn on a two-dimensional screen You

can control these transformations to show a particular view of a model

• Chapter 4, “Color,” describes how to specify the color and shading

method used to draw an object

• Chapter 5, “Lighting,” explains how to control the lighting

condi-tions surrounding an object and how that object responds to light (that is, how it reflects or absorbs light) Lighting is an important topic, since objects usually don’t look three-dimensional until they’re lit The remaining chapters explain how to optimize or add sophisticated features to your three-dimensional scene You might choose not to take advantage of many of these features until you’re more comfortable with OpenGL Particularly advanced topics are noted in the text where they occur

• Chapter 6, “Blending, Antialiasing, Fog, and Polygon Offset,”

describes techniques essential to creating a realistic scene—alpha blending (to create transparent objects), antialiasing (to eliminate jagged edges), atmospheric effects (to simulate fog or smog), and polygon offset (to remove visual artifacts when highlighting the edges of filled polygons)

• Chapter 7, “Display Lists,” discusses how to store a series of OpenGL

commands for execution at a later time You’ll want to use this feature

to increase the performance of your OpenGL program

• Chapter 8, “Drawing Pixels, Bitmaps, Fonts, and Images,” discusses

how to work with sets of two-dimensional data as bitmaps or images One typical use for bitmaps is describing characters in fonts

• Chapter 9, “Texture Mapping,” explains how to map one-, two-, and

three-dimensional images called textures onto three-dimensional

objects Many marvelous effects can be achieved through texture mapping

• Chapter 10, “The Framebuffer,” describes all the possible buffers that

can exist in an OpenGL implementation and how you can control them You can use the buffers for such effects as hidden-surface elimi-nation, stenciling, masking, motion blur, and depth-of-field focusing

• Chapter 11, “Tessellators and Quadrics,” shows how to use the

tessellation and quadrics routines in the GLU (OpenGL Utility Library)

• Chapter 12, “Evaluators and NURBS,” gives an introduction to

advanced techniques for efficient generation of curves or surfaces

• Chapter 13, “Selection and Feedback,” explains how you can use

OpenGL’s selection mechanism to select an object on the screen Additionally, the chapter explains the feedback mechanism, which allows you to collect the drawing information OpenGL produces, rather than having it be used to draw on the screen

About This Guide xxxvii

• Chapter 14, “Now That You Know,” describes how to use OpenGL

in several clever and unexpected ways to produce interesting results

These techniques are drawn from years of experience with both

OpenGL and the technological precursor to OpenGL, the Silicon

Graphics IRIS Graphics Library

• Chapter 15, “The OpenGL Shading Language,” discusses the changes

that occurred starting with OpenGL Version 2.0 This includes an

introduction to the OpenGL Shading Language, also commonly called

the “GLSL,” which allows you to take control of portions of OpenGL’s

processing for vertices and fragments This functionality can greatly

enhance the image quality and computational power of OpenGL

There are also several appendices that you will likely find useful:

• Appendix A, “Basics of GLUT: The OpenGL Utility Toolkit,”

dis-cusses the library that handles window system operations GLUT is

portable and it makes code examples shorter and more comprehensible

• Appendix B, “State Variables,” lists the state variables that OpenGL

maintains and describes how to obtain their values

• Appendix C, “Homogeneous Coordinates and Transformation

Matrices,” explains some of the mathematics behind matrix

transformations

• Appendix D, “OpenGL and Window Systems,” briefly describes the

routines available in window-system-specific libraries, which are

extended to support OpenGL rendering Window system interfaces

to the X Window System, Apple’s Mac OS, and Microsoft Windows are

discussed here

Finally, an extensive Glossary defines the key terms used in this guide

In addition, the appendices listed below are available at the following Web site:

http://www.opengl-redbook.com/appendices/

• Appendix E, “Order of Operations,” gives a technical overview of the

operations OpenGL performs, briefly describing them in the order in

which they occur as an application executes

• Appendix F, “Programming Tips,” lists some programming tips based

on the intentions of the designers of OpenGL that you might find

useful

• Appendix G, “OpenGL Invariance,” describes when and where an

OpenGL implementation must generate the exact pixel values described

in the OpenGL specification

• Appendix H, “Calculating Normal Vectors,” tells you how to

calculate normal vectors for different types of geometric objects

• Appendix I, “Built-In OpenGL Shading Language Variables and

Functions,” describes the built-in variables and functions available in

the OpenGL Shading Language

• Appendix J, “Floating-Point Formats for Textures, Framebuffers,

and Renderbuffers,” documents the various floating-point and

shared-exponent pixel and texel formats

• Appendix K, “RGTC Compressed Texture Format,” describes

the texture format for storing one- and two-component compressed textures

• Appendix L, “std140 Uniform Buffer Layout,” documents the

standard memory layout of uniform-variable buffers for GLSL 1.40

What’s New in This Edition

This seventh edition of the OpenGL Programming Guide includes new and

updated material covering OpenGL Versions 3.0 and 3.1 With those versions, OpenGL—which is celebrating its eighteenth birthday the year of this writing—has undergone a drastic departure from its previous revisions

Version 3.0 added a number of new features as well as a depreciation model,

which sets the way for antiquated features to be removed from the library Note that only new features were added to Version 3.0, making it

completely source and binary backward compatible with previous versions

However, a number of features were marked as deprecated, indicating that

they may potentially be removed from future versions of the API

Updates related to OpenGL Version 3.0 that are discussed in this edition include the following items:

• New features in OpenGL:

– An update to the OpenGL Shading Language, creating version 1.30

of GLSL– Conditional rendering– Finer-grained access to mapping buffer objects’ memory for update and reading

– Floating-point pixel formats for framebuffers in addition to texture map formats (which were added in OpenGL Version 2.1)

About This Guide xxxix

– Framebuffer and renderbuffer objects

– Compact floating-point representations for reducing the memory

storage usage for small dynamic-range data

– Improved support for multisample buffer interactions when

copying data

– Non-normalized integer values in texture maps and renderbuffers

whose values retain their original representation, as compared to

OpenGL’s normal operation of mapping those values into the

range [0,1]

– One- and two-dimensional texture array support

– Additional packed-pixel formats allowing access to the new

renderbuffer support

– Separate blending and writemask control for multiple rendering

targets

– Texture compression format

– Single- and double-component internal formats for textures

– Transform feedback

– Vertex-array objects

– sRGB framebuffer format

• An in-depth discussion of the deprecation model

• Bug fixes and updated token names

And for OpenGL Version 3.1:

• Identification of features removed due to deprecation in Version 3.0

• New features:

– An update to the OpenGL Shading Language, creating version 1.40

of GLSL

– Instanced rendering

– Efficient server-side copies of data between buffers

– Rendering of multiple similar primitives within a single draw call

using a special (user-specified) token to indicate when to restart a

primitive

– Texture buffer objects