OpenGL ES 2 for Android: a quick-start guide

330 Pages·2013·30.61 MB·English

by  Kevin Brothaler

Early praise for
OpenGL ES 2.0 for Android
Kevin’s book is stuffed full of useful code and explanations, to the point of being inspirational.
The math/matrix stuff is the best I have ever read on the topic. If you already know Java
well and want to break into 3D graphics, this book is perfect.
➤ John Horton
HadronWebDesign.com and author of the Android math league app Math Legends
Cuts out the academic fluff and teaches you what you need to become productive quickly.
I wish I had access to such a clear, concise, and humorous book when I first learned OpenGL.
➤ Mark F. Guerra
Developer, GLWallpaperService library for OpenGL
An amazing introduction to Android graphics programming, covering all the topics that give
headaches to OpenGL beginners with such extensive detail that you’ll be perfectly prepared
to implement your own ideas.
➤ Carsten Haubold
Maintainer, NeHe OpenGL tutorials
I wish I had this book when I first started programming Android games. It’s well written
and up-to-date.
➤ Owen Alanzo Hogarth
President, Team Blubee, Inc.
I am greatly impressed by this book and would gladly recommend it to any programming
enthusiast or anyone who’s ever dreamed of making a game.
➤ Tibor Simic
OpenGL ES 2 for Android
A Quick-Start Guide
Kevin Brothaler
The Pragmatic Bookshelf
Dallas, Texas • Raleigh, North Carolina
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 Pragmatic
Programmers, LLC was aware of a trademark claim, the designations have been printed in
initial capital letters or in all capitals. The Pragmatic Starter Kit, The Pragmatic Programmer,
Pragmatic Programming, Pragmatic Bookshelf, PragProg and the linking g device are trade-
marks of The Pragmatic Programmers, LLC.
Every precaution was taken in the preparation of this book. However, the publisher assumes
no responsibility for errors or omissions, or for damages that may result from the use of
information (including program listings) contained herein.
Our Pragmatic courses, workshops, and other products can help you and your team create
better software and have more fun. For more information, as well as the latest Pragmatic
titles, please visit us at http://pragprog.com.
The Android robot is reproduced from work created and shared by Google and is used
according to terms described in the Creative Commons 3.0 Attribution License
(http://creativecommons.org/licenses/by/3.0/us/legalcode).
The unit circle image in Figure 43, from http://en.wikipedia.org/wiki/File:Unit_circle.svg, is used according
to the terms described in the Creative Commons Attribution-ShareAlike license, located at
http://creativecommons.org/licenses/by-sa/3.0/legalcode.
Day skybox and night skybox courtesy of Jockum Skoglund, also known as hipshot,
[email protected],http://www.zfight.com.
The image of the trace capture button is created and shared by the Android Open Source
Project and is used according to terms described in the Creative Commons 2.5 Attribution
License.
Copyright © 2013 The Pragmatic Programmers, LLC.
All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system, or
transmitted, in any form, or by any means, electronic, mechanical, photocopying,
recording, or otherwise, without the prior consent of the publisher.
Printed in the United States of America.
ISBN-13: 978-1-937785-34-5
Encoded using the finest acid-free high-entropy binary digits.
Book version: P1.0—June 2013
To Anne and my Oma
You have brought so much joy and wonder
into my life. Thank you for making it all
possible.
Contents
Foreword . . . . . . . . . . . . . . xi
Acknowledgments . . . . . . . . . . . xiii
Welcome to OpenGL ES for Android! . . . . . . . xv
1. Getting Started . . . . . . . . . . . . 1
1.1 Installing the Tools 1
1.2 Creating Our First Program 4
1.3 Initializing OpenGL 6
1.4 Creating a Renderer Class 11
1.5 Using Static Imports 14
1.6 A Review 15
Part I — A Simple Game of Air Hockey
2. Defining Vertices and Shaders . . . . . . . . 19
2.1 Why Air Hockey? 19
2.2 Don’t Start from Scratch 21
2.3 Defining the Structure of Our Air Hockey Table 22
2.4 Making the Data Accessible to OpenGL 26
2.5 Introducing the OpenGL Pipeline 28
2.6 The OpenGL Color Model 34
2.7 A Review 35
3. Compiling Shaders and Drawing to the Screen . . . . 37
3.1 Loading Shaders 37
3.2 Compiling Shaders 39
3.3 Linking Shaders Together into an OpenGL Program 44
3.4 Making the Final Connections 46
3.5 Drawing to the Screen 51
Contents • viii
3.6 A Review 57
3.7 Exercises 58
4. Adding Color and Shade . . . . . . . . . . 59
4.1 Smooth Shading 60
4.2 Introducing Triangle Fans 61
4.3 Adding a New Color Attribute 63
4.4 Rendering with the New Color Attribute 71
4.5 A Review 75
4.6 Exercises 75
5. Adjusting to the Screen’s Aspect Ratio . . . . . . 77
5.1 We Have an Aspect Ratio Problem 78
5.2 Working with a Virtual Coordinate Space 80
5.3 Linear Algebra 101 83
5.4 Defining an Orthographic Projection 87
5.5 Adding an Orthographic Projection 89
5.6 A Review 94
5.7 Exercises 94
6. Entering the Third Dimension . . . . . . . . 95
6.1 The Art of 3D 95
6.2 Transforming a Coordinate from the Shader to the
Screen 96
6.3 Adding the W Component to Create Perspective 99
6.4 Moving to a Perspective Projection 101
6.5 Defining a Perspective Projection 103
6.6 Creating a Projection Matrix in Our Code 105
6.7 Switching to a Projection Matrix 107
6.8 Adding Rotation 111
6.9 A Review 114
6.10 Exercises 114
7. Adding Detail with Textures . . . . . . . . 115
7.1 Understanding Textures 116
7.2 Loading Textures into OpenGL 119
7.3 Creating a New Set of Shaders 126
7.4 Creating a New Class Structure for Our Vertex Data 127
7.5 Adding Classes for Our Shader Programs 133
7.6 Drawing Our Texture 137
7.7 A Review 139
7.8 Exercises 139
Contents • ix
8. Building Simple Objects . . . . . . . . . 141
8.1 Combining Triangle Strips and Triangle Fans 142
8.2 Adding a Geometry Class 143
8.3 Adding an Object Builder 145
8.4 Updating Our Objects 153
8.5 Updating Shaders 155
8.6 Integrating Our Changes 156
8.7 A Review 161
8.8 Exercises 161
9. Adding Touch Feedback: Interacting with Our Air Hockey
Game . . . . . . . . . . . 165
9.1 Adding Touch Support to Our Activity 165
9.2 Adding Intersection Tests 168
9.3 Moving Around an Object by Dragging 177
9.4 Adding Collision Detection 181
9.5 A Review and Wrap-Up 185
9.6 Exercises 186
Part II — Building a 3D World
10. Spicing Things Up with Particles . . . . . . . 191
10.1 Creating a Set of Shaders for a Simple Particle System 193
10.2 Adding the Particle System 197
10.3 Drawing the Particle System 201
10.4 Spreading Out the Particles 204
10.5 Adding Gravity 206
10.6 Mixing the Particles with Additive Blending 208
10.7 Customizing the Appearance of Our Points 209
10.8 Drawing Each Point as a Sprite 211
10.9 A Review 214
10.10 Exercises 214
11. Adding a Skybox . . . . . . . . . . . 217
11.1 Creating a Skybox 218
11.2 Loading a Cube Map into OpenGL 219
11.3 Creating a Cube 221
11.4 Adding a Skybox Shader Program 224
11.5 Adding the Skybox to Our Scene 227
11.6 Panning the Camera Around the Scene 228
Contents • x
11.7 A Review 232
11.8 Exercises 232
12. Adding Terrain . . . . . . . . . . . . 233
12.1 Creating a Height Map 233
12.2 Creating Vertex and Index Buffer Objects 234
12.3 Loading in the Height Map 237
12.4 Drawing the Height Map 241
12.5 Occluding Hidden Objects 245
12.6 A Review 250
12.7 Exercises 251
13. Lighting Up the World . . . . . . . . . . 253
13.1 Simulating the Effects of Light 253
13.2 Implementing a Directional Light with Lambertian
Reflectance 255
13.3 Adding Point Lights 264
13.4 A Review 272
13.5 Exercises 272
14. Creating a Live Wallpaper . . . . . . . . . 275
14.1 Implementing the Live Wallpaper Service 275
14.2 Playing Nicely with the Rest of the System 283
14.3 A Review 286
14.4 Exercises 286
15. Taking the Next Step . . . . . . . . . . 289
15.1 Looking Toward Other Platforms 289
15.2 Learning About More Advanced Techniques 291
15.3 Sharing Your Artistic Vision with the World 295
A1. The Matrix Math Behind the Projections . . . . . 297
A1.1 The Math Behind Orthographic Projections 297
A1.2 The Math Behind Perspective Projections 300
A2. Debugging . . . . . . . . . . . . . 305
A2.1 Debugging with glGetError 305
A2.2 Using Tracer for OpenGL ES 306
A2.3 Pitfalls to Watch Out For 308
Bibliography . . . . . . . . . . . . 311
Index . . . . . . . . . . . . . . 313