Register your product to gain access to bonus material or receive a coupon.
OpenGL ES 3.0 Programming Guide, 2nd Edition
- By Dan Ginsburg, Budirijanto Purnomo, Dave Shreiner, Aaftab Munshi
- Published Feb 28, 2014 by Addison-Wesley Professional. Part of the OpenGL series.
Book
- Sorry, this book is no longer in print.
eBook (Watermarked)
- Your Price: $38.39
- List Price: $47.99
- Includes EPUB and PDF
- About eBook Formats
This eBook includes the following formats, accessible from your Account page after purchase:
EPUB
The open industry format known for its reflowable content and usability on supported mobile devices.
PDF
The popular standard, used most often with the free Acrobat® Reader® software.
This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.
About
Features
- Teaches how to write 3D applications using OpenGL ES 3.0
- Discusses the entire the OpenGL ES graphics pipeline and best practices for development efficient OpenGL ES apps
- Gives practical examples for the reader to use in his/her own code.
- Describes in detail vertex/pixel GLSL shader development.
- Includes high-level examples highlighting the power of OpenGL ES 3.0 for more advanced programmers
Description
- Copyright 2014
- Dimensions: 7" x 9-1/8"
- Pages: 560
- Edition: 2nd
- Book
- ISBN-10: 0-321-93388-5
- ISBN-13: 978-0-321-93388-1
OpenGL® ESTM is the industry’s leading software interface and graphics library for rendering sophisticated 3D graphics on handheld and embedded devices. The newest version, OpenGL ES 3.0, makes it possible to create stunning visuals for new games and apps, without compromising device performance or battery life.
In the OpenGL® ESTM 3.0 Programming Guide, Second Edition, the authors cover the entire API and Shading Language. They carefully introduce OpenGL ES 3.0 features such as shadow mapping, instancing, multiple render targets, uniform buffer objects, texture compression, program binaries, and transform feedback.
Through detailed, downloadable C-based code examples, you’ll learn how to set up and program every aspect of the graphics pipeline. Step by step, you’ll move from introductory techniques all the way to advanced per-pixel lighting and particle systems. Throughout, you’ll find cutting-edge tips for optimizing performance, maximizing efficiency with both the API and hardware, and fully leveraging OpenGL ES 3.0 in a wide spectrum of applications.
All code has been built and tested on iOS 7, Android 4.3, Windows (OpenGL ES 3.0 Emulation), and Ubuntu Linux, and the authors demonstrate how to build OpenGL ES code for each platform.
Coverage includes
- EGL API: communicating with the native windowing system, choosing configurations, and creating rendering contexts and surfaces
- Shaders: creating and attaching shader objects; compiling shaders; checking for compile errors; creating, linking, and querying program objects; and using source shaders and program binaries
- OpenGL ES Shading Language: variables, types, constructors, structures, arrays, attributes, uniform blocks, I/O variables, precision qualifiers, and invariance
- Geometry, vertices, and primitives: inputting geometry into the pipeline, and assembling it into primitives
- 2D/3D, Cubemap, Array texturing: creation, loading, and rendering; texture wrap modes, filtering, and formats; compressed textures, sampler objects, immutable textures, pixel unpack buffer objects, and mipmapping
- Fragment shaders: multitexturing, fog, alpha test, and user clip planes
- Fragment operations: scissor, stencil, and depth tests; multisampling, blending, and dithering
- Framebuffer objects: rendering to offscreen surfaces for advanced effects
- Advanced rendering: per-pixel lighting, environment mapping, particle systems, image post-processing, procedural textures, shadow mapping, terrain, and projective texturing
- Sync objects and fences: synchronizing within host application and GPU execution
This edition of the book includes a color insert of the OpenGL ES 3.0 API and OpenGL ES Shading Language 3.0 Reference Cards created by Khronos. The reference cards contain a complete list of all of the functions in OpenGL ES 3.0 along with all of the types, operators, qualifiers, built-ins, and functions in the OpenGL ES Shading Language.
Sample Content
Online Sample Chapter
Sample Pages
Download the sample pages (includes Chapter 1 and Index)
Table of Contents
List of Figures xvii
List of Examples xxi
List of Tables xxv
Foreword xxix
Preface xxxi
Intended Audience xxxi
Organization of This Book xxxii
Example Code and Shaders xxxvi
Errata xxxvi
Acknowledgments xxxvii
About the Authors xxxix
Chapter 1: Introduction to OpenGL ES 3.0 1
OpenGL ES 3.0 3
What’s New in OpenGL ES 3.0 11
OpenGL ES 3.0 and Backward Compatibility 17
EGL 19
EGL Command Syntax 20
OpenGL ES Command Syntax 21
Error Handling 22
Basic State Management 23
Further Reading 25
Chapter 2: Hello Triangle: An OpenGL ES 3.0 Example 27
Code Framework 28
Where to Download the Examples 28
Hello Triangle Example 29
Using the OpenGL ES 3.0 Framework 34
Creating a Simple Vertex and Fragment Shader 35
Compiling and Loading the Shaders 36
Creating a Program Object and Linking the Shaders 38
Setting the Viewport and Clearing the Color Buffer 39
Loading the Geometry and Drawing a Primitive 40
Displaying the Back Buffer 41
Summary 42
Chapter 3: An Introduction to EGL 43
Communicating with the Windowing System 44
Checking for Errors 45
Initializing EGL 46
Determining the Available Surface Configurations 46
Querying EGLConfig Attributes 48
Letting EGL Choose the Configuration 51
Creating an On-Screen Rendering Area: The EGL Window 53
Creating an Off-Screen Rendering Area: EGL Pbuffers 56
Creating a Rendering Context 60
Making an EGLContext Current 62
Putting All Our EGL Knowledge Together 63
Synchronizing Rendering 66
Summary 67
Chapter 4: Shaders and Programs 69
Shaders and Programs 69
Uniforms and Attributes 80
Shader Compiler 93
Program Binaries 94
Summary 95
Chapter 5: OpenGL ES Shading Language 97
OpenGL ES Shading Language Basics 98
Shader Version Specification 98
Variables and Variable Types 99
Variable Constructors 100
Vector and Matrix Components 101
Constants 102
Structures 103
Arrays 104
Operators 104
Functions 106
Built-In Functions 107
Control Flow Statements 107
Uniforms 108
Uniform Blocks 109
Vertex and Fragment Shader Inputs/Outputs 111
Interpolation Qualifiers 114
Preprocessor and Directives 115
Uniform and Interpolator Packing 117
Precision Qualifiers 119
Invariance 121
Summary 123
Chapter 6: Vertex Attributes, Vertex Arrays, and Buffer Objects 125
Specifying Vertex Attribute Data 126
Declaring Vertex Attribute Variables in a Vertex Shader 135
Vertex Buffer Objects 140
Vertex Array Objects 150
Mapping Buffer Objects 154
Copying Buffer Objects 159
Summary 160
Chapter 7: Primitive Assembly and Rasterization 161
Primitives 161
Drawing Primitives 165
Primitive Assembly 174
Rasterization 179
Occlusion Queries 183
Summary 185
Chapter 8: Vertex Shaders 187
Vertex Shader Overview 188
Vertex Shader Examples 196
Generating Texture Coordinates 205
Vertex Skinning 207
Transform Feedback 211
Vertex Textures 214
OpenGL ES 1.1 Vertex Pipeline as an ES 3.0 Vertex Shader 215
Summary 223
Chapter 9: Texturing 225
Texturing Basics 226
Compressed Textures 262
Texture Subimage Specification 266
Copying Texture Data from the Color Buffer 269
Sampler Objects 273
Immutable Textures 276
Pixel Unpack Buffer Objects 277
Summary 278
Chapter 10: Fragment Shaders 279
Fixed-Function Fragment Shaders 280
Fragment Shader Overview 282
Implementing Fixed-Function Techniques Using Shaders 286
Summary 295
Chapter 11: Fragment Operations 297
Buffers 298
Fragment Tests and Operations 303
Blending 311
Dithering 314
Multisampled Anti-Aliasing 314
Reading and Writing Pixels to the Framebuffer 316
Multiple Render Targets 320
Summary 324
Chapter12: Framebuffer Objects 325
Why Framebuffer Objects? 325
Framebuffer and Renderbuffer Objects 327
Creating Framebuffer and Renderbuffer Objects 329
Using Renderbuffer Objects 330
Using Framebuffer Objects 335
Framebuffer Blits 342
Framebuffer Invalidation 344
Deleting Framebuffer and Renderbuffer Objects 346
Examples 348
Performance Tips and Tricks 354
Summary 355
Chapter 13: Sync Objects and Fences 357
Flush and Finish 357
Why Use a Sync Object? 358
Creating and Deleting a Sync Object 358
Waiting for and Signaling a Sync Object 359
Example 360
Summary 361
Chapter 14: Advanced Programming with OpenGL ES 3.0 363
Per-Fragment Lighting 363
Environment Mapping 370
Particle System Using Transform Feedback 380
Image Postprocessing 387
Projective Texturing 390
Noise Using a 3D Texture 397
Procedural Texturing 404
Rendering Terrain with Vertex Texture Fetch 410
Shadows Using a Depth Texture 414
Summary 420
Chapter 15: State Queries 421
OpenGL ES 3.0 Implementation String Queries 421
Querying Implementation-Dependent Limits 423
Querying OpenGL ES State 429
Hints 435
Entity Name Queries 436
Nonprogrammable Operations Control and Queries 436
Shader and Program State Queries 438
Vertex Attribute Queries 440
Texture State Queries 441
Sampler Queries 442
Asynchronous Object Queries 442
Sync Object Queries 443
Vertex Buffer Queries 444
Renderbuffer and Framebuffer State Queries 445
Summary 446
Chapter 16: OpenGL ES Platforms 447
Building for Microsoft Windows with Visual Studio 447
Building for Ubuntu Linux 449
Building for Android 4.3+ NDK (C++) 450
Building for Android 4.3+ SDK (Java) 452
Building for iOS 7 453
Summary 455
Appendix A: GL_HALF_FLOAT 457
16-Bit Floating-Point Number 458
Converting a Float to a Half-Float 459
Appendix B: Built-In Functions 463
Angle and Trigonometry Functions 465
Exponential Functions 466
Common Functions 467
Floating-Point Pack and Unpack Functions 471
Geometric Functions 472
Matrix Functions 474
Vector Relational Functions 475
Texture Lookup Functions 476
Fragment Processing Functions 483
Appendix C: ES Framework API 485
Framework Core Functions 485
Transformation Functions 490
Index 495
More Information
Other Things You Might Like
- Book $47.99