OpenGL ES 2.0 Programming Guide

by Munshi, Aaftab; Ginsburg, Dan; Shreiner, Dave

• ISBN13: 9780321502797
• ISBN10: 0321502795
• Edition: 1st
• Format: Paperback
• Copyright: 2008-07-24
• Publisher: Addison-Wesley Professional

Summary

The first comprehensive guide to developing 3D graphic applications on mobile devices, from the leading authorities on OpenGL ES.

Author Biography

Aaftab Munshi is the spec editor for the OpenGL ES 1.1 and 2.0 specifications. Now at Apple, he was formerly senior architect in ATI’s handheld group.

Dan Ginsburg is senior member of technical staff at AMD. At AMD and ATI, he has worked in a variety of roles, including the development of OpenGL drivers, the creation of desktop and handheld 3D demos, and the development of handheld GPU developer tools.

Dave Shreiner is one of the world’s foremost authorities on OpenGL. He is a systems architect at ARM, Inc., and the lead author of the official OpenGL® Programming Guide, Sixth Edition (Addison-Wesley, 2007) and series editor for the Addison-Wesley OpenGL Series.

Table of Contents

List of Figures	p. xiii
List of Examples	p. xv
List of Tables	p. xix
Foreword xxi Preface	p. xxiii
Acknowledgments	p. xxix
About the Authors	p. xxxi
Introduction to OpenGL ES 2.0 1 What Is OpenGL ES?	p. 1
OpenGL ES 2.0 3 Vertex Shader	p. 4
Primitive Assembly	p. 6
Rasterization	p. 7
Fragment Shader	p. 7
Per-Fragment Operations	p. 9
OpenGL ES 2.0 and OpenGL ES 1.x Backward Compatibility	p. 11
EGL	p. 12
Programming with OpenGL ES 2.0 13 Further Reading	p. 18
Hello Triangle: An OpenGL ES 2.0 Example	p. 19
Code Framework	p. 20
Where to Download the Examples	p. 20
Hello Triangle Example	p. 21
Building and Running the Examples	p. 25
Using the OpenGL ES 2.0 Framework	p. 26
Creating a Simple Vertex and Fragment Shader	p. 27
Compiling and Loading the Shaders	p. 29
Creating a Program Object and Linking the Shaders	p. 30
Setting the Viewport and Clearing the Color Buffer	p. 32
Loading the Geometry and Drawing a Primitive	p. 33
Displaying the Back Buffer	p. 33
An Introduction to EGL	p. 35
Communicating with the Windowing System	p. 36
Checking for Errors	p. 37
Initializing EGL	p. 37
Determining the Available Surface Configurations	p. 38
Querying EGLConfig Attributes	p. 39
Letting EGL Choose the Config	p. 39
Creating an On-Screen Rendering Area: The EGL Window	p. 43
Creating an Off-Screen Rendering Area: EGL Pbuffers	p. 46
Creating a Rendering Context	p. 50
Making an EGLContext Current	p. 52
Putting All Our EGL Knowledge Together	p. 52
Synchronizing Rendering	p. 54
Shaders and Programs	p. 57
Shaders and Programs	p. 57
Uniforms and Attributes	p. 67
Shader Compiler and Shader Binaries	p. 72
OpenGL ES Shading Language	p. 77
OpenGL ES Shading Language Basics	p. 78
Variables and Variable Types	p. 78
Variable Constructors	p. 79
Vector and Matrix Components	p. 81
Constants	p. 82
Structures	p. 82
Arrays	p. 83
Operators	p. 84
Functions	p. 85
Built-In Functions	p. 86
Control Flow Statements	p. 87
Uniforms 88 Attributes	p. 89
Varyings	p. 90
Preprocessor and Directives	p. 92
Uniform and Varying Packing	p. 94
Precision Qualifiers 96 Invariance	p. 97
Vertex Attributes, Vertex Arrays, and Buffer Objects	p. 101
Specifying Vertex Attribute Data	p. 102
Declaring Vertex Attribute Variables in a Vertex Shader	p. 110
Vertex Buffer Objects	p. 115
Mapping Buffer Objects	p. 124
Primitive Assembly and Rasterization	p. 127
Primitives	p. 127
Drawing Primitives	p. 131
Primitive Assembly	p. 136
Rasterization	p. 141
Vertex Shaders	p. 147
Vertex Shader Overview	p. 148
Vertex Shader Examples	p. 159
Generating Texture Coordinates	p. 167
Vertex Skinning	p. 168
OpenGL ES 1.1 Vertex Pipeline as an ES 2.0 Vertex Shader	p. 173
Texturing	p. 181
Texturing Basics	p. 181
Compressed Textures	p. 201
Texture Subimage Specification	p. 202
Copying Texture Data from the Color Buffer	p. 204
Optional Extensions	p. 207
Fragment Shaders	p. 215
Fixed Function Fragment Shaders	p. 216
Fragment Shader Overview	p. 218
Implementing Fixed Function Techniques Using Shaders	p. 222
Fragment Operations	p. 233
Buffers	p. 234
Fragment Tests and Operations	p. 238
Blending	p. 246
Dithering	p. 249
Multisampled Antialiasing	p. 249
Reading and Writing Pixels to the Framebuffer	p. 250
Framebuffer Objects	p. 253
Why Framebuffer Objects	p. 253
Framebuffer and Renderbuffer Objects	p. 255
Creating Framebuffer and Renderbuffer Objects	p. 258
Using Renderbuffer Objects 259 Using Framebuffer Objects	p. 262
Deleting Framebuffer and Renderbuffer Objects	p. 269
Examples	p. 271
Performance Tips and Tricks	p. 277
Advanced Programming with OpenGL ES 2.0	p. 279
Per-Fragment Lighting	p. 279
Environment Mapping	p. 286
Particle System with Point Sprites	p. 290
Image Postprocessing	p. 296
Projective Texturing
Table of Contents provided by Publisher. All Rights Reserved.

Excerpts

OpenGL ES 2.0 is a software interface for rendering sophisticated 3D graphics on handheld and embedded devices. OpenGL ES 2.0 is the primary graphics library for handheld and embedded devices with programmable 3D hardware including cell phones, PDAs, consoles, appliances, vehicles and avionics. With OpenGL ES 2.0, the full programmability of shaders has made its way onto small and portable devices. This book details the entire OpenGL ES 2.0 API and pipeline with detailed examples in order to provide a guide for developing a wide range of high performance 3D applications for handheld devices. Intended Audience This book is intended for programmers interested in learning OpenGL ES 2.0. We expect the reader to have a solid grounding in computer graphics. We will explain many of the relevant graphics concepts as they relate to various parts of OpenGL ES 2.0, but we do expect the reader to understand basic 3D concepts. The code examples in the book are all written in C. We assume that the reader is familiar with C or C++ and will only be covering language topics where they are relevant to OpenGL ES 2.0. This book covers the entire OpenGL ES 2.0 API along with all Khronos-ratified extensions. The reader will learn about setting up and programming every aspect of the graphics pipeline. The book details how to write vertex and fragment shaders and how to implement advanced rendering techniques like per-pixel lighting and particle systems. In addition, the book provides performance tips and tricks for efficient use of the API and hardware. After finishing the book, the reader will be ready to write OpenGL ES 2.0 applications that fully harness the programmable power of embedded graphics hardware. Organization of the Book This book is organized to cover the API in a sequential fashion, building up your knowledge of OpenGL ES 2.0 as we go. Chapter 1 - Introduction to OpenGL ES 2.0 This chapter gives an introduction to OpenGL ES followed by an overview of the OpenGL ES 2.0 graphics pipeline. We discuss the philosophies and constraints that went into the design of OpenGL ES 2.0. Finally, the chapter covers some general conventions and types used in OpenGL ES 2.0. Chapter 2 - Hello Triangle: An OpenGL ES 2.0 Example This chapter walks through a simple OpenGL ES 2.0 example program that draws a triangle. Our purpose here is to show what an OpenGL ES 2.0 program looks like, introduce the reader to some API concepts, and describe how to build and run an example OpenGL ES 2.0 program. Chapter 3 - An Introduction to the EGL This chapter presents EGL, the API for creating surfaces and rendering contexts for OpenGL ES 2.0. The chapter describes how to communicate with the native windowing system, choose a configuration and create EGL rendering contexts and surfaces. We teach you enough EGL to so that you can do everything you will need to do to get up and rendering with OpenGL ES 2.0. Chapter 4 - Shaders and Programs Shader objects and program objects form the most fundamental objects in OpenGL ES 2.0. In this chapter, we describe how to create a shader object, compile a shader, and check for compile errors. The chapter also covers how to create a program object, attach shader objects to it, and link a final program object. We discuss how to query the program object for information and how to load uniforms. In addition, you will learn about the difference between source and binary shaders and how to use each. Chapter 5 - OpenGL ES Shading Language This chapter covers the shading language basics needed for writing shaders. The shading language basics described are variables and types, constructors, structures, arrays, attributes, uniforms, and varyings. This chapter also describes some more nuanced parts of the language such as precision qualifiers and invariance.. Chapter 6 - Vertex Attributes, Vertex Arrays, and Buffer Obj