Game and Graphics Programming for iOS and Android with OpenGL ES 2.0.pdf

DownLoad Book

Published: 2018-03-17 Author:Bieber 37 Browses

Tags: game graphics ios android es


书名: Game and Graphics Programming for iOS and Android with OpenGL ES 2.0

作者: Romain Marucchi-Foino

出版日期: February 21, 2012

页数: 312 pages

ISBN: 978-1119975915

Extracting password :d4c1d775a8be7241

ffirs.indd iffirs.indd i 12/30/11 12:05:23 PM12/30/11 12:05:23 PM
ES 2.0
INTRODUCTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xvii
CHAPTER 1 Getting Started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .1
CHAPTER 2 Setting Up Your Graphic Projections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
CHAPTER 3 Dealing with Complex Geometry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
CHAPTER 4 Building a Scene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
CHAPTER 5 Optimization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .81
CHAPTER 6 Real-Time Physics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
CHAPTER 7 Camera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
CHAPTER 8 Pathfi nding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
CHAPTER 9 Audio and Other Cool Game Programming Stu . . . . . . . . . . . . . . . . . . . 171
CHAPTER 10 Advanced Lighting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
CHAPTER 11 Advanced FX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
CHAPTER 12 Skeletal Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
ffirs.indd iffirs.indd i 1/11/12 8:20:58 AM1/11/12 8:20:58 AM
ffirs.indd iiffirs.indd ii 1/11/12 8:20:59 AM1/11/12 8:20:59 AM
Game and Graphics Programming
for iOS and Android
with OpenGL
ES 2.0
ffirs.indd iiiffirs.indd iii 1/11/12 8:21:00 AM1/11/12 8:21:00 AM
ffirs.indd ivffirs.indd iv 1/11/12 8:21:00 AM1/11/12 8:21:00 AM
Game and Graphics Programming
for iOS and Android
with OpenGL
ES 2.0
Romain Marucchi-Foino
John Wiley & Sons, Inc.
ffirs.indd vffirs.indd v 1/11/12 8:21:00 AM1/11/12 8:21:00 AM
Game and Graphics Programming for iOS and Android® with OpenGL® ES 2.0
This edition fi rst published 2012
Copyright ©2012 Romain Marucchi-Foino
Registered of ce
John Wiley & Sons Ltd, The Atrium, Southern Gate, Chichester, West Sussex, PO19 8SQ, United Kingdom
For details of our global editorial of ces, for customer services and for information about how to apply for permission to
reuse the copyright material in this book please see our web site at
The right of the author to be identifi ed as the author of this work has been asserted in accordance with the Copyright,
Designs and Patents Act 1988.
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, except as permitted by the UK
Copyright, Designs and Patents Act 1988, without the prior permission of the publisher.
Wiley also publishes its books in a variety of electronic formats. Some content that appears in print may not be available
in electronic books.
Designations used by companies to distinguish their products are often claimed as trademarks. All brand names and
product names used in this book are trade names, service marks, trademarks or registered trademarks of their respective
owners. The publisher is not associated with any product or vendor mentioned in this book. This publication is designed
to provide accurate and authoritative information in regard to the subject matter covered. It is sold on the understanding
that the publisher is not engaged in rendering professional services. If professional advice or other expert assistance is
required, the services of a competent professional should be sought.
978-1-119-97626-4 (ebk)
978-1-119-97627-1 (ebk)
978-1-119-97628-8 (ebk)
A catalogue record for this book is available from the British Library.
ffirs.indd viffirs.indd vi 1/11/12 8:21:02 AM1/11/12 8:21:02 AM
ROMAIN MARUCCHI-FOINO is the original author and founder of the popular mobile game engine
SIO2 ( Formerly a game engine developer, Romain has dedicated
his efforts to build a state-of-the-art game engine for mobile devices using OpenGL ES since the
arrival of the iPhone. He is currently working as the lead 3D programmer for
, the of cial developer of the SIO2 Engine, which powers thousands of games and 3D
applications throughout the App Store and the Android market. His experience in the mobile game
industry has led him to contribute his work to many online communities, publications, and blogs.
EFFIE C. LEE is a self-employed game and graphics designer who has been working in the game
industry for the last 4 years. With a bachelor’s degree in Computer Science and a real passion
for electronic games and computer graphics, she has been involved in multiple mobile game
productions. With her wide range of knowledge in the game development process, she has been
professionally working as a 2D and 3D graphics designer, game programmer (scripting), and web
designer for game sites, as well as managing game quality assurance and localization. If you would
like to reach her, send an email to
ffirs.indd viiffirs.indd vii 1/11/12 8:21:02 AM1/11/12 8:21:02 AM
ffirs.indd viiiffirs.indd viii 1/11/12 8:21:02 AM1/11/12 8:21:02 AM
Michelle Leete
Martin Tribe
Chris Webb
Chris Katsaropoulos
Ellie Scott
Louise Breinholt
Kate Parrett
Jodi Jensen
Sara Shlaer
Kathryn Duggan
E e C. Lee
Debra Banninger
Nancy Carrasco
Robert Swanson
LeAndra Young
© iStock / Vladislav Ociacia
ffirs.indd ixffirs.indd ix 1/11/12 8:21:02 AM1/11/12 8:21:02 AM
ffirs.indd xffirs.indd x 1/11/12 8:21:03 AM1/11/12 8:21:03 AM
Software Requirements 2
For iOS Developers 2
For Android Developers 2
Downloading the Book’s SDK 4
Importing Projects 5
For iOS Developers 5
For Android Developers 5
The Template 7
Summary 8
The Three Basic Types of Projections 10
Orthographic 2D Projection 11
Program and Project Initialization 12
Vertex and Fragment Shader 14
Linking a Shader Program 17
The Drawing Code 19
Orthographic Projection 23
Getting Orthographic 23
Perspective Projection 26
Summary 27
The Wavefront File Format 29
Cube.obj 30
Cube.mtl 31
Preparing the OBJ Viewer Code 31
Loading an OBJ 32
Building the Shaders 35
The Vertex Shader 35
The Fragment Shader 36
Vertex Bu er Object 36
Storing the Vertex Data 37
ftoc.indd xiftoc.indd xi 12/30/11 8:28:31 AM12/30/11 8:28:31 AM
Building the Vertex Data Array VBO 38
Building the Element Array VBO 39
Building the VAO 40
Rendering Momo 42
Handling Touche 44
Per-Vertex Lighting 46
Vertex Shader Light Calculation 46
Modifying the Fragment Shader 47
More Uniforms 48
Making Momo Furrier 50
Loading the Texture 50
Adjusting the Vertex Data 51
Adding UV Support to the Vertex Shader 52
Adding Texture Support to Your Fragment Shader 53
Binding the Texture 53
Summary 54
Handling Multiple Objects 58
The Code Structure 58
Loading and Drawing the Scene 59
The Shaders Code 63
The Di erent Object Types 64
The Drawing Sequence 64
Fixing the Scene 65
Uber Shader 65
Using Your Uber Shader 66
Render Loop Objects Categorization 69
Double-Sided 71
Per-Pixel Lighting 73
Making the Vertex Shader Even Fatter 73
Getting the Fragment Shader More Uber 74
Wrapping Up the Implementation 76
Summary 79
The Base App 82
Triangles to Triangle Strips 82
Building Triangle Strips 83
Texture Optimization 84
Adding 16-Bit Texture Conversion 85
ftoc.indd xiiftoc.indd xii 12/30/11 8:28:32 AM12/30/11 8:28:32 AM
PVR Texture Compression 86
Faking Details 87
Bump Mapping Implementation 87
Precision Qualifi ers Optimization 88
The Normal Map Lighting Calculation 90
Adding Specularity 91
Geometry and Shaders LOD 92
Texture Atlas 93
Managing States in Software 94
Automatic Shader Optimization 94
Summary 95
Types of Physical Objects 98
Physics Shapes 98
Using Bullet 100
Hello Physics 100
Collision Callbacks, Triggers, and Contacts 105
Contact-Added Callback 105
Near Callback 107
Contact Points 108
2D Physics 110
More Shapes! 110
Building the Physical Objects 113
Camera Tracking 114
User Interactions 116
The Game Logic 117
3D Physics 120
The Bullet File Format 120
3D Pinball Game 122
Summary 127
Touch and Go! 130
The Camera Frustum 132
How to Build the Frustum 133
Frustum Clipping Implementation 134
More Clipping Functions 135
Camera Fly Mode 136
First-Person Camera with Collision Detection 140
3D Camera Tracking 143
ftoc.indd xiiiftoc.indd xiii 12/30/11 8:28:33 AM12/30/11 8:28:33 AM
Third-Person Camera with Collision 145
Summary 149
Recast and Detour 151
Navigation 152
Creating the Navigation Mesh 153
3D Physics Picking 155
Player’s Auto Drive 159
Visualizing the Way Points 161
Catch Me If You Can! 163
Know Your Enemy 165
Game State Logic 167
Summary 170
OpenAL 172
OGG Vorbis 173
Hello World OpenAL Style 174
Initializing OpenAL 174
Static In-Memory Sound Playback 175
Positional Sound Source 176
Piano Game 178
Loading a Static and Streamed Sound 178
Color Picking 182
Piano Game Logic 185
Final Adjustments 188
Rolling Ball Game 190
GFX Shaders 190
Linking the Positional Sound Sources 191
Accelerometer-Driven Camera 195
Cheap FX 198
Game Logic and Tweaks 200
Summary 205
Types of Lamps 208
Let There Be Light 208
Directional Lamp Shader 211
Struct as Uniforms 214
ftoc.indd xivftoc.indd xiv 12/30/11 8:28:33 AM12/30/11 8:28:33 AM
Point Light 217
Point Light Shader Code 218
Light Attenuation 221
Point Light with Attenuation Code 222
The Attenuation Uniforms 223
Spherical Point Light 224
Tweaking the Point Light Code 225
Spot Light 227
Spot Light Shader Code 229
Multiple Lights 231
Making the Shader Program Dynamic 233
Summary 234
Render to Texture 238
Post-Processing E ects 238
First Rendering Pass 241
Second Pass 242
Fullscreen Pass and Blur Shader 243
Projected Texture 246
Projector Shader 249
Projected Real-Time Shadows 250
Casting Shadows Using the Depth Texture 253
A Few More Words about the Frame Bu er Object 254
Particles 255
Summary 257
Traditional vs. Modern Animation Systems 260
The MD5 File Format 261
Loading an MD5 Mesh 261
Animating the Mesh 264
LERP 266
Blending Animation 267
Additive Blending 269
Summary 271
ftoc.indd xvftoc.indd xv 12/30/11 8:28:33 AM12/30/11 8:28:33 AM
flast.indd xviflast.indd xvi 12/31/11 9:40:22 AM12/31/11 9:40:22 AM
WELCOME TO Game and Graphics Programming for iOS and Android with OpenGL ES 2.0. This
book is not your usual “OpenGL Hello Triangle” book — it’s not meant to explain the “why”
(Google is there for that), but rather, to show you the “how.” This book will strictly teach you what
works and what doesn’t when it comes to game and graphics programming.
Using more than 50 unique tutorials (which also include some full game frameworks), this book
adopts a straightforward practical approach (probably never seen before) that only focuses on what
you need to learn to insure that you will be able to create
a game.
You will learn all the necessary elements in order to create a full-fl edged game with rich 3D graphics.
If you are looking for an aggressive teaching method that enables you to quickly move forward to
create your dream game, this book is for you!
Be aware that this is not a beginner book. It is an intermediate-level book that assumes you
are familiar with linear algebra (matrices, vectors, and quaternions), you have a strong C/C++
programming background, you have at least touched base with OpenGL or OpenGL ES, and you
basically know how computer graphics work in general.
If you have this necessary knowledge, and want to make lightning-fast progress in game and
graphics programming, then you have found the right publication. This book is written for people
who want to learn the hardcore stuff fast in order to be able to create and push a full- edged game
on the App Store and the Android Market.
Basically everything you need to know in order to create a full game is included in this book. You
will learn about all aspects of creating a game, such as loading 3D geometries and textures; how to
handle materials, shaders, sounds, cameras, clipping, physics, AI, path nding, skeletal animations;
and a lot more.
By the end of this book you will be able to apply the knowledge you’ve learned and combine the
different tutorials you’ve completed to create your own state-of-the-art game.
This book is structured in such a way that pretty much all chapters depend on each other. Each
chapter shows you progressively how to master the necessary techniques to be able to handle the
next chapter.
flast.indd xviiflast.indd xvii 12/31/11 9:40:23 AM12/31/11 9:40:23 AM
Here is a list of all the chapters and what will be covered in each of them:
Chapter 1, “Getting Started” — You will learn how to set up your development
environment, download this book’s SDK, import and re-compile the tutorials, and deal with
the template project that you will be using throughout this publication.
Chapter 2, “Setting Up Your Graphic Projections” — Since you have a running template,
I will show you how to set up the necessary projection matrix to be able to handle 2D,
2.5D, or 3D. You will also learn how to draw simple geometry onscreen and handle a
camera matrix.
Chapter 3, “Dealing with Complex Geometry” — You will create a Wavefront OBJ viewer
that will allow you to learn how to load complex geometry from disk. You will also learn
how to load and create textures, deal with basic lighting, and respond to touch events.
Chapter 4, “Building a Scene” — This chapter will extend the knowledge that you’ve
learned in Chapter 3 and will explain how to handle a more complex scene. You will learn
about drawing sequences and how to create reusable shaders.
Chapter 5, “Optimization” — In this chapter, I will show you techniques that will allow
you to optimize the performance of your drawing. You will touch base with texture
compression and shader optimization, and learn how to convert triangles to triangle strips
as well as other tips and tricks to get better FPS.
Chapter 6, “Real-Time Physics” — Since you will know by now how to handle a scene
properly, this chapter is about adding real-time physics behaviors to your scene using Bullet.
I will show you how to create a physical world and add physical entities to it. You will then
learn how to handle in code different techniques that will allow you to add logic upon
collision callbacks or based on the contact points between two or more physical entities.
Chapter 7, “Camera” — This chapter will focus entirely on cameras. You will learn to build
frustum planes and will be able to determine the visibility of each object of your scene in the
eld of view of a camera. I will then show you how to implement multiple types of cameras,
including a full-fl edged fi rst- and third-person camera with collision, ready to be used in
your own apps.
Chapter 8, “Pathfi nding” — Artifi cial intelligence (AI) and pathfi nding will play an important
role inside your games, and that’s what this chapter is all about. You will learn how to use the
Recast and Detour libraries to build a navigation mesh and have entities moving automatically
in the scene. In this chapter, I will also demonstrate how to use True Type Font to generate a
font texture and draw dynamic text onscreen.
Chapter 9, “Audio and Other Cool Game Programming Stuff” — This one is all about
audio using OpenAL. In this chapter, you will learn how to load OGG Vorbis sound fi les
and either stream them from memory in real time or statically store them in audio memory.
I will also introduce how to create 3D positional and ambient sound sources and will touch
base on how to use the accelerometer, along with how to animate textures and create other
miscellaneous effects.
flast.indd xviiiflast.indd xviii 12/31/11 9:40:23 AM12/31/11 9:40:23 AM
Chapter 10, “Advanced Lighting” — This chapter will teach you how to apply dynamic
lighting, probably one of the hardest things to master in game and graphics programming.
You will create multiple types of lights from directional to spot lights and will learn how to
handle them in real time.
Chapter 11, “Advanced FX” — This chapter is all about special effects. You will learn how
to create fullscreen post-processing effects, project textures, and real-time shadows, as well
as how to handle particles.
Chapter 12, “Skeletal Animation — Last but not least, you will learn how to handle
skeletal animation using the MD5 fi le format. I will teach you how to load and draw a mesh
attached to a skeleton. You will then load action fi les and learn how to mix them using
different types of blending methods.
You will fi nd that this book will not simply show you the theory, but it will also show you how to
apply the knowledge that you gain in each chapter to real game scenarios.
As you can see, this book is packed full of useful knowledge that you will need on a daily basis
while programming games or 3D applications. There is plenty enough content in here to get you
started with real game and graphics programming in no time!
If you are planning to develop for iOS, all you need is a Mac that can support the latest version
of the iOS SDK (for more information, visit An iDevice is optional
since the iOS SDK provides out-of-the-box an iPhone/iPod Touch and iPad simulator, which you
can use to develop and test your application. And it is fully compatible with everything contained
in this book.
If you are planning to develop for Android, what you need is a Mac or a PC with an operating system
that is supported by the Android SDK (for more information, visit
). Also, you will need an Android device with OpenGL ES 2.0 support, because the simulator
bundled with the Android SDK only supports OpenGL ES 1.0.
In addition, this book uses Blender as its 3D modeling software (because it is free and open source).
So to be able to test, tweak, and re-export all the test scenes used in the books SDK, go grab a copy
To help you get the most from the text and keep track of whats happening, the following
conventions are used throughout this book:
New terms and important words are in italics.
File names, URLs, variables, and code within text are shown like this: templateApp.cpp.
flast.indd xixflast.indd xix 12/31/11 9:40:24 AM12/31/11 9:40:24 AM
Code blocks are shown like this:
#include “templateApp.h”
TEMPLATEAPP templateApp = { templateAppInit,
templateAppDraw };
The offi cial SDK used in this book is available at for download (packaged as a .zip
le). The SDK contains the fi nal end results of all the tutorials covered in this publication. It also
includes the full source code of the SDK and all the original assets used in the tutorials, so you will
have access to the 2D/3D scenes and can recompile them from scratch freely.
Because many books have similar titles, you may fi nd it easiest to search by ISBN;
this books ISBN is 978-1-119-97591-5.
In addition, I also personally maintain the book’s
SDK (using GIT version control system) on the
of cial website of the GFX 3D Engine (the free
and open source mini 3D game and graphics
engine that you’ll be using in this book, featured
in Figure 1), which is available at the following
The latest SDK revisions of the book along with
all quick bug fi xes can be found at the GFX 3D
Engine site instantly since it’s easier for me to just
update the source code using version control.
It might take a bit more time for the offi cial SDK
at to be updated since this of cial
SDK version is carefully maintained by the publisher, but you could just be patient and wait for the
of cial release. It’s up to you.
It is also worth mentioning that on the GFX 3D Engine site (,
you can fi nd support forums for this books SDK as well as the latest version of the GFX 3D engine.
This website also provides other 3D game and graphics-related demos, tutorials, and other materials
that are fully compatible with this books SDK.
FIGURE 1: GFX 3D Engine
Models and textures generously provided by
Ken Beyer ( and David
Radford (
flast.indd xxflast.indd xx 12/31/11 9:40:24 AM12/31/11 9:40:24 AM
We make every effort to ensure that there are no errors in the text or in the code. However, no one
is perfect, and mistakes do occur. If you fi nd an error in one of our books, like a spelling mistake or
faulty piece of code, we would be very grateful for your feedback. By sending in errata you may save
another reader hours of frustration and at the same time you will be helping us provide even higher
quality information.
To nd the errata page for this book, go to and locate the title using the Search box
or one of the title lists. Then, on the book details page, click the Book Errata link. On this page you
can view all errata that has been submitted for this book and posted by Wrox editors. A complete
book list including links to each books errata is also available at
If you don’t spot “your” error on the Book Errata page, go to
and complete the form there to send us the error you have found. We’ll check
the information and, if appropriate, post a message to the book’s errata page and fi x the problem in
subsequent editions of the book.
For author and peer discussion, join the P2P forums at The forums are a Web-based
system for you to post messages relating to Wrox books and related technologies and interact with
other readers and technology users. The forums offer a subscription feature to e-mail you topics
of interest of your choosing when new posts are made to the forums. Wrox authors, editors, other
industry experts, and your fellow readers are present on these forums.
At you will fi nd a number of different forums that will help you not only as
you read this book, but also as you develop your own applications. To join the forums, just follow
these steps:
1. Go to and click the Register link.
2. Read the terms of use and click Agree.
3. Complete the required information to join as well as any optional information you wish to
provide and click Submit.
4. You will receive an e-mail with information describing how to verify your account and
complete the joining process.
You can read messages in the forums without joining P2P but in order to post your
own messages, you must join.
flast.indd xxiflast.indd xxi 12/31/11 9:40:44 AM12/31/11 9:40:44 AM
Once you join, you can post new messages and respond to messages other users post. You can
read messages at any time on the Web. If you would like to have new messages from a particular
forum e-mailed to you, click the Subscribe to this Forum icon by the forum name in the forum
For more information about how to use the Wrox P2P, be sure to read the P2P FAQs for answers to
questions about how the forum software works as well as many common questions specifi c to P2P
and Wrox books. To read the FAQs, click the FAQ link on any P2P page.
flast.indd xxiiflast.indd xxii 12/31/11 9:40:50 AM12/31/11 9:40:50 AM
Getting Started
Learning about the software used in this book
Downloading the book’s SDK
Understanding the SDK architecture
Importing projects into your IDE
Understanding this book’s template application
Learning how to work with the template code structure
In this chapter, you will fi rst start by setting up your development environment to be able to
work with this books tutorials and examples.
You will then receive a quick introduction about this book’s SDK and where to download it,
and learn about the different directories it contains. Then you will learn how to import this
books existing SDK projects and templates into your favorite IDE, as you will do throughout
this book when following the different tutorials.
Moving on to the last section of this chapter, you will learn about this book’s cross-platform
template project. And fi nally, this chapter concludes with a quick tutorial that will help you to
get familiar with the events of the template, as well as with the tone that will be used for all the
tutorials in this book.
c01.indd 1c01.indd 1 12/31/11 8:53:28 AM12/31/11 8:53:28 AM
This book’s content is built to run on iOS 5.x+ as well as for Android 2.x+, the latest and most
stable versions of these two mobile operating systems at the time this book was written.
For iOS Developers
To use this book for iOS, all you have to do is to grab a copy of the latest iOS SDK available at, and install it on your Mac.
Out-of-the-box the iOS SDK provides a simulator with full GLES v2 support, so even if you do not
have an iOS device, or do not have an of cial iOS Developer Certifi cation from Apple, you can still
make full use of this book.
For Android Developers
To set up your environment for Android, it is unfortunately not as easy as for iOS. First go to and follow the instructions to install the
Android SDK, Eclipse, and the ADT plug-in. Please note that the Android SDK version used for this
book was v2.3.4, but later versions should also work as well.
All the code in this book uses C/C++, which means that you will have to install Android Native
Code support. To fi nalize the installation of your development environment, follow these steps:
1. Grab a copy of the Android NDK at the following address:
. The version used at the time of writing this book was r5c,
but all examples and tutorials should work on later versions as well. Download the
Android NDK zip package and decompress it on your machine where you have read and
write access.
2. In order to compile and debug native code using Eclipse, you will need to install the
Sequoyah plug-in. To do this, fi rst enable the repository that is located (from the Eclipse
main menu) in: Help Install New Software Available Software Sites Sequoyah
Metadata Repository. Then select the entry from the Work With combo box, and once the
repository data is loaded, select and install the Sequoyah Android Native Code Support, as
shown in Figure 1-1.
3. Once Sequoyah is installed, go to (from the main menu): Eclipse Preferences Android
Native Development and specify the location where you extracted the Android NDK in step 1,
as shown in Figure 1-2.
c01.indd 2c01.indd 2 12/31/11 8:53:33 AM12/31/11 8:53:33 AM
Software Requirements
FIGURE 1-1: Sequoyah Native Code Support plug-in
FIGURE 1-2: Specify the location of the Android NDK
c01.indd 3c01.indd 3 12/31/11 8:53:33 AM12/31/11 8:53:33 AM
Congratulations — your Android development environment is now all set! However, please note that
in order to use this book with Android you will need an actual device with OpenGL ES 2.0 support.
The emulator provided by the Android SDK supports only OpenGL ES 1.x, not OpenGL ES 2.0.
So local deployment on the simulator is not possible on Android; only device deployment is
supported when using GLES 2.
Once your development environment is set up, you should now grab a copy of this books
SDK. The offi cial SDK is available for download at Alternatively,
if you wish to download it through GIT, go to the offi cial GFX 3D engine website,
, where you can fi nd detailed instructions.
If you have downloaded the zip fi le, simply decompress it in a directory that you have read and write
access to. If you have downloaded it using GIT, all the fi les and the SDK architecture are already
available on your drive.
The architecture of this book’s SDK is very simple. For more information, please refer to the
following directory list:
_chapter#-#: Contains the fi nal result that you should reproduce by reading the tutorials
in the book. At any time while reading this book, if you feel that the instructions are not
clear, or if you are unsure where to insert some code, or even if you simply want to preview
the fi nal result of a tutorial, open this directory. Inside the directory, you can then fi nd at
the root the source fi les used by the tutorial (respectively named
templateApp.cpp and
templateApp.h) and two directories
that contain the project fi les for iOS and
Android. You can then load the project
into your IDE and rebuild it from scratch.
common: Contains the free and open
source GFX 3D engine (the mini game
and graphics engine that you will be
using in this book) source code of the
version that was used to create the
templates and tutorials for this book,
along with the source of the libraries the
engine depends on. The GFX 3D engine
is a very small and lightweight graphic
engine that is built with bits and pieces of my own professional engine. It is very small, fast,
exible, and scalable; and will allow you to render state-of-the-art graphics on your mobile
device, as shown in Figure 1-3.
data: In this directory, you can fi nd all the original assets that were used in each tutorial.
These assets are either linked dynamically to the projects (in the case of iOS) or simply
duplicated inside the
assets directory of each Android tutorial. Please note that all the
Available for
download on
Available for
download on
FIGURE 1-3: An FPS demo using the GFX 3D engine
Models and textures are generously provided by
David Radford (
c01.indd 4c01.indd 4 12/31/11 8:53:34 AM12/31/11 8:53:34 AM
Importing Projects
original project 3D scenes are available as .blend (the default fi le extension of Blender).
It is not mandatory, but highly suggested that you download a copy of Blender for your
platform, which is available at This will enable you to study the way
the scenes are built and how the assets are linked and exported to the Wavefront OBJ (the
of cial 3D model exchange format used in the book).
EULA: In here, you can fi nd all the End User License Agreements for the different libraries
that this book’s SDK relies on. If you plan to release a commercial application using this
books SDK, make sure that your application complies with all of these licenses.
glsloptimizerCL: Contains the source to a simple yet powerful command line program that
you can use to optimize your GLSL code (as demonstrated in Chapter 5, “Optimization”).
md5_exporter: A python script for Blender (v2.6x) that allows you to export bone animation
sequences created in Blender to the MD5 version 10 fi le format (script generously provided by
Paul Zirkle).
template: The original template project that you will be using when creating a new project
from scratch.
template_chapter#-#: In order to speed up and avoid redundancies, you will duplicate
these directories by following the tutorials throughout the book. This will give you a head
start and save you from having to rebuild everything from scratch using the default template
This book has over 50 tutorials, varying from the demonstration of a single technique to full-fl edged
games. To be able load and rebuild the projects from this book into your IDE, you will have to
import them. To do this, just follow the instructions in the subsection that corresponds to the type
of developer you are.
For iOS Developers
As usual for iOS developers, importing fi les is very easy. All you have to do to import a project
into XCode is simply double-click the
.xcodeproj le. To compile, simply click the Build & Run
For Android Developers
Things are a little bit more tedious if you’re using Eclipse. You need to import this book’s
projects as instructed in the following procedure. Of course, this procedure assumes that you
have properly installed and con gured Android SDK, Android NDK, Eclipse Classic, the ADT
plug-in, and the Sequoyah Android Native Development plug-in (as described at the beginning of
this chapter).
c01.indd 5c01.indd 5 12/31/11 8:53:35 AM12/31/11 8:53:35 AM
Once you have con gured all the necessary prerequisite fi les, follow these steps to import this
books project fi les:
1. From the Eclipse main menu, select File New Android Project. The New Android
Project dialog should appear.
2. In the Project name text box, enter the project name. Example: chapter2-1.
3. Select the Create Project From Existing Source option.
4. Click the Browse button, and then select the existing Android directory inside the chapter
or template project. Example:
5. Click the Finish button at the bottom of the dialog box.
Figure 1-4 illustrates each of these steps.
FIGURE 1-4: Importing an Android project into Eclipse
c01.indd 6c01.indd 6 12/31/11 8:53:35 AM12/31/11 8:53:35 AM