Index

Symbols

+ (plus sign), denoting class methods in Objective-C, Subclassing UIView
- (minus sign), denoting instance methods in Objective-C, Subclassing UIView
2D rendering in OpenGL ES, Sprites and Text
4D coordinates, Associating Properties with Vertices
@ (at sign), prefixing Objective-C keywords, Subclassing UIView
@end keyword, Subclassing UIView
@interface keyword, Subclassing UIView
@property keyword, Hooking Up the Application Delegate
@synthesize keyword, Hooking Up the Application Delegate
{ } (curly braces), enclosing data fields in class declarations, Subclassing UIView

A

accelerometer support, adding to Holodeck (example), Adding accelerometer support, Adding compass support
in GLView class, Adding accelerometer support, Adding accelerometer support
phi as function of acceleration, Adding accelerometer support
AccelerometerGraph example, iPhone developer site, Adding accelerometer support
accessor methods, defining, Hooking Up the Application Delegate
additive blending, OpenGL ES 1.1 Rendering Engine and Additive Blending
alloc-init pattern in Objective-C, Subclassing UIView, Hooking Up the Application Delegate
alpha, Blending and Augmented Reality
ensuring color contains, Blending Recipe
premultiplied, Wrangle Premultiplied Alpha
setting for buttons in Holodeck HUD (example), Handling the Heads-Up Display
tweaking uniformly across entire texture, Shifting Texture Color with Per-Vertex Color
alpha combiners, Texture Combiners
arithmetic operations used for, Texture Combiners
alpha testing, Blending Caveats
using with distance fields in ES 1.1, Use Distance Fields Under ES 1.1 with Alpha Testing
altitude, Holodeck Sample
ambient lighting, Lighting Up
ambient occlusion, Baked Lighting
in OpenGL, Ho-Hum Ambiance
animations, Animation, Animating Rotation with Quaternions
animating rotation with quaternions, Animating Rotation with Quaternions
Core Animation framework, Quick-Start Guide
heads-up display (HUD), Handling the Heads-Up Display
interpolation techniques, Interpolation Techniques
texture coordinates, Texture Coordinates Revisited
transition animation in wireframe viewer, Animating the Transition, Animating the Transition
using sprite sheets, Animation with Sprite Sheets
vertex skinning, Optimizing Animation with Vertex Skinning, Skinning: Common Code, Skinning: Common Code
generating weights and indices, Generating Weights and Indices
OpenGL ES 1.1, Skinning with OpenGL ES 1.1, Skinning with OpenGL ES 1.1
OpenGL ES 2.0, Skinning with OpenGL ES 2.0, Skinning with OpenGL ES 2.0
problems with pinching, Watch Out for Pinching
anisotropic filtering, Anisotropic Filtering: Textures on Steroids
anti-aliasing, Blending and Augmented Reality
rendering anti-aliased lines with textures, Rendering Anti-Aliased Lines with Textures, Rendering Anti-Aliased Lines with Textures
using offscreen FBOs, Anti-Aliasing Tricks with Offscreen FBOs, Other FBO Effects
jittering, Jittering, Jittering
supersampling, A Super Simple Sample App for Supersampling, A Super Simple Sample App for Supersampling
Apple
iPhone developer site, Getting Started
OpenGL ES Programming Guide, Further Reading
Apple Macintosh, transitioning to, Transitioning to Apple Technology
application delegate, Hooking Up the Application Delegate, Hooking Up the Application Delegate
ApplicationEngine class, Designing the Interfaces
consuming IResourceManager from, Managing Resource Files
implementation for SpringyStars (example), ApplicationEngine Implementation, ApplicationEngine Implementation
implementation with tab bar, Poor Man’s Tab Bar, Poor Man’s Tab Bar
implementation with transition animation, Animating the Transition, Animating the Transition
WireframeApplicationEngine implementation (example), Handling Trackball Rotation, Handling Trackball Rotation
ApplyOrtho method, RenderingEngine Implementation
ApplyRotation method, RenderingEngine Implementation
arrow shape, drawing in OpenGL ES, HelloArrow with Fixed Function
assembly line metaphor, The Assembly Line Metaphor
atan2 function, Adding accelerometer support
attribute storage qualifier, Shaders Demystified
augmented reality, Blending and Augmented Reality
Holodeck (example), Holodeck Sample, Wrapping Up
geodesic dome, Application Skeleton
heads-up display (HUD), Handling the Heads-Up Display, Handling the Heads-Up Display
Interfaces file, Application Skeleton
overlaying with live camera image, Overlaying with a Live Camera Image, Wrapping Up
rendering dome, clouds, and text, Rendering the Dome, Clouds, and Text, Handling the Heads-Up Display
replacing buttons with orientation sensors, Replacing Buttons with Orientation Sensors, Adding compass support
axis-angle notation, Animating Rotation with Quaternions
azimuth, Holodeck Sample

B

baked lighting, OpenGL Initialization and Cone Tessellation, Baked Lighting
Banks, David, Acknowledgments, Anisotropic Filtering: Textures on Steroids
basis vectors, Another Foray into Linear Algebra
generating, Generating Basis Vectors
batching, draw call, Batch, Batch, Batch, Batch, Batch, Batch
bell curve, Image-Processing Example: Bloom
bilinear filtering, Fight Aliasing with Filtering
issues with, Crisper Text with Distance Fields, Anisotropic Filtering: Textures on Steroids
use in crude bloom algorithm, Image-Processing Example: Bloom
binding points for VBOs, Boosting Performance with Vertex Buffer Objects
blending, Blending and Augmented Reality, Anti-Aliasing Tricks with Offscreen FBOs
additive, OpenGL ES 1.1 Rendering Engine and Additive Blending
blending equation, Blending Recipe
configuration for jittering, Jittering
extensions and their uses, Blending Extensions and Their Uses, Why Is Blending Configuration Useful?
blending configuration, Why Is Blending Configuration Useful?
glBlendFunc function, Blending Recipe
premultiplied alpha, Wrangle Premultiplied Alpha
steps in, Blending Recipe
vertex skinning, Optimizing Animation with Vertex Skinning
warnings about, Blending Caveats
block compression, Texture Compression with PVRTC
bloom, Advanced Lighting and Texturing, Image-Processing Example: Bloom, Sample Code for Gaussian Bloom
algorithm for crude bloom, Image-Processing Example: Bloom
example code for Gaussian bloom, Sample Code for Gaussian Bloom, Sample Code for Gaussian Bloom
Gaussian, Image-Processing Example: Bloom
hybrid approach to improve performance, Better Performance with a Hybrid Approach
bone indices and bone weights, Optimizing Animation with Vertex Skinning
generating, Generating Weights and Indices
bounding volume hierarchy (BVH), CPU-Based Clipping
box filter, Image-Processing Example: Bloom
bump mapping and DOT3 lighting, Bump Mapping and DOT3 Lighting, Reflections with Cube Maps
basis vectors, Another Foray into Linear Algebra
generating basis vectors, Generating Basis Vectors
generating normal maps in object space, Generating Object-Space Normal Maps, Reflections with Cube Maps
normal mapping with OpenGL ES 1.1, Normal Mapping with OpenGL ES 1.1, Normal Mapping with OpenGL ES 1.1
normal mapping with OpenGL ES 2.0, Normal Mapping with OpenGL ES 2.0, Normal Mapping with OpenGL ES 1.1
BVH (bounding volume hierarchy), CPU-Based Clipping

C

C language, Objective-C
C++, How to Read This Book
advantages of, Objective-C
ApplicationEngine class, Designing the Interfaces
defining interfaces, Defining and Consuming the Rendering Engine Interface
.hpp file extension, Defining and Consuming the Rendering Engine Interface
Standard Template Library (STL), deciding whether to use, RenderingEngine Declaration
vector beautification with, Vector Beautification with C++, Vector Beautification with C++
vector library, C++ Vector Library, Quaternion.hpp
CADisplayLink class, Defining and Consuming the Rendering Engine Interface
Cairo library, Generating a Glyphs Texture with Python
explanation of CreateNumerals (example), Generating a Glyphs Texture with Python
camera
controlling for Holodeck (example), Holodeck Sample
creating textures with, Creating Textures with the Camera, CameraTexture: Rendering Engine Implementation
rendering engine implementation, CameraTexture: Rendering Engine Implementation, CameraTexture: Rendering Engine Implementation
overlaying Holodeck (example) with live camera image, Overlaying with a Live Camera Image, Wrapping Up
adding camera support to GLView, Overlaying with a Live Camera Image, Overlaying with a Live Camera Image
creating camera view controller, Overlaying with a Live Camera Image
render engine support of camera underlay, Overlaying with a Live Camera Image
cancellation, touch events, Reading the Touchscreen
cell shading, Toon Shading
CFData objects, Enhancing IResourceManager
CFDataRef objects, Texture Compression with PVRTC
CGBitmapInfo mask, Wrangle Premultiplied Alpha
CGContext, Wrangle Premultiplied Alpha
CGContextDrawImage function, Generating and Transforming OpenGL Textures with Quartz
CGContextRotateCTM function, Creating Textures with the Camera
CGImage objects, Enhancing IResourceManager
class declarations in Objective-C, Subclassing UIView
class methods in Objective-C, Subclassing UIView, Subclassing UIView
class templates in C++, Vector Beautification with C++
clip space, The Life of a Vertex
clipping
CPU-based, CPU-Based Clipping
user clip frames, User Clip Planes
CLLocationManager objects, Adding compass support
Cocoa, Quick-Start Guide
Cocoa Touch, Quick-Start Guide
COLLADA file format, Loading Geometry from OBJ Files
color
determining final color with and without lighting, Adding Light to ModelViewer
diffuse color, Matte Paint with Diffuse Lighting, Adding Shaders to ModelViewer
per-vertex color, Shifting Texture Color with Per-Vertex Color, Texture Environments under OpenGL ES 1.1
representing vector as, Bump Mapping and DOT3 Lighting
color attribute, Associating Properties with Vertices
color material, Adding Light to ModelViewer
column vectors, The Photography Metaphor
compass support, adding to Holodeck (example), Adding compass support, Adding compass support
conditionals, shader performance and, Conditionals
cone parameterization, Parametric Surfaces for Fun
cone tessellation, OpenGL Initialization and Cone Tessellation
indexed, Saving Memory with Vertex Indexing
cone vertices, generating, OpenGL Initialization and Cone Tessellation
confetti, rendering, Rendering Confetti, Fireworks, and More: Point Sprites
context creation (EAGL), Subclassing UIView
Core Graphics, Quick-Start Guide
functions extracting texture format and type, Hands-On: Loading Various Formats
Core Location API, Adding compass support
Core OS Mac, Quick-Start Guide
Core Services, Quick-Start Guide
CPU bottlenecks, Understand the CPU/GPU Split
CPU-based clipping, CPU-Based Clipping
CreateFromVectors method, Handling Trackball Rotation
cross product, The Math Behind Normals
cross-platform OpenGL ES application, Layering Your 3D Application
cube maps, Advanced Lighting and Texturing, Reflections with Cube Maps, Anisotropic Filtering: Textures on Steroids
creating, Reflections with Cube Maps
fragment shader for cube map reflection, Reflections with Cube Maps
rendering to, Render to Cube Map
testing for incorrect face orientation, Reflections with Cube Maps
uploading faces individually in OpenGL, Reflections with Cube Maps
vertex shader for cube map reflection, Reflections with Cube Maps
cubic filtering, Crisper Text with Distance Fields
culling, face culling, Polygon Winding

D

damping force, Physics Diversion: Mass-Spring System
data types
denoted by OpenGL ES function endings, The Photography Metaphor
textures, Texture Formats and Types
vertex attributes, Associating Properties with Vertices
dealloc method, Subclassing UIView
defocus transition with jitter, Jittering
depth buffers, Examining the Depth Buffer, Creating and Using the Depth Buffer
avoiding depth artifacts, Beware the Scourge of Depth Artifacts
clearing to value of 1.0 or other value, Creating and Using the Depth Buffer
creating and using, Creating and Using the Depth Buffer
ModelViewer (example), Examining the Depth Buffer
depth of field effect, Other FBO Effects
depth testing, Examining the Depth Buffer
configuring, Creating and Using the Depth Buffer
disabling in blending, Blending Recipe
derivatives, Smoothing and Derivatives
desktop managers, Mac OS X, Installing the iPhone SDK
destination and source color (blending equation), Blending Recipe
device orientation, Defining and Consuming the Rendering Engine Interface
handling, Handling Device Orientation
new orientations in HelloCone (example), Render Method
dFdx function, Smoothing and Derivatives
dFdy function, Smoothing and Derivatives
diffuse color, Matte Paint with Diffuse Lighting, Adding Shaders to ModelViewer
diffuse factor (df), Matte Paint with Diffuse Lighting
diffuse lighting, Lighting Up
calculating, Matte Paint with Diffuse Lighting, Matte Paint with Diffuse Lighting
infinite light source model, Adding Shaders to ModelViewer
dimensions of a matrix, The Photography Metaphor
disk vertices, generating in HelloCone (example), OpenGL Initialization and Cone Tessellation
distance fields, Crisper Text with Distance Fields, Animation with Sprite Sheets
generating with Python, Generating Distance Fields with Python, Generating Distance Fields with Python
outline, glow, and shadow effects, Implementing Outline, Glow, and Shadow Effects, Animation with Sprite Sheets
representing in OpenGL textures, Crisper Text with Distance Fields
smoothing and derivatives, Smoothing and Derivatives, Implementing Outline, Glow, and Shadow Effects
using under ES 1.1 with alpha testing, Use Distance Fields Under ES 1.1 with Alpha Testing
.dmg files, Installing the iPhone SDK
dot product, Matte Paint with Diffuse Lighting
dot product combiners, Texture Combiners
DOT3 lighting, Advanced Lighting and Texturing, Bump Mapping and DOT3 Lighting, DOT3 Lighting Revisited
(see also bump mapping and DOT3 lighting)
defined, Normal Mapping with OpenGL ES 1.1
generating object-space normal maps, Generating Object-Space Normal Maps, Reflections with Cube Maps
draw call batching, Batch, Batch, Batch, Batch, Batch, Batch
drawView method, Subclassing UIView

E

EAGL, Quick-Start Guide, Subclassing UIView
headers, Defining and Consuming the Rendering Engine Interface
initialization code for GLView class (example), Subclassing UIView
EAGLContext objects, Subclassing UIView
version of OpenGL, Subclassing UIView, GLView
ease-in-out equation, Interpolation Techniques
easing equations, Interpolation Techniques
errors in OpenGL ES, A Super Simple Sample App for Supersampling
example code for this book, Creating a Wireframe Viewer
extensions
blending extensions in OpenGL ES 1.1, Blending Extensions and Their Uses
GL_APPLE_texture_2D_limited_npot, Dealing with Size Constraints
GL_EXT_texture_filter_anisotropic extension, Anisotropic Filtering: Textures on Steroids
GL_IMG_texture_format_BGRA8888, Texture Formats and Types
GL_OES_blend_equation_separate, Blending Extensions and Their Uses
GL_OES_blend_func_separate, Blending Extensions and Their Uses
GL_OES_blend_subtract, Blending Extensions and Their Uses
GL_OES_draw_texture, Sprites and Text, Simplify with glDrawTexOES
GL_OES_matrix_palette, Skinning with OpenGL ES 1.1
GL_OES_packed_depth_stencil, Poor Man’s Reflection with the Stencil Buffer
GL_OES_point_sprite, Sprites and Text, Rendering Confetti, Fireworks, and More: Point Sprites
GL_OES_standard_derivatives, Smoothing and Derivatives
GL_OES_stencil8, Poor Man’s Reflection with the Stencil Buffer
GL_OES_texture_mirrored_repeat, Texture Coordinates Revisited
readable extension strings, Dealing with Size Constraints
eye space, The Life of a Vertex, Bump Mapping and DOT3 Lighting
transforming normals to, Normal Transforms Aren’t Normal
EyeVector uniform, Normal Mapping with OpenGL ES 2.0

F

face parameter, glMaterialf and glMaterialfv functions, Adding Light to ModelViewer
faceted effect, Better Wireframes Using Polygon Offset
factor argument, glPolygonOffset function, Better Wireframes Using Polygon Offset
FBOs (see framebuffer objects)
fboTheta, A Super Simple Sample App for Supersampling
field of view, Setting the Projection Transform
file format for storing geometry, Loading Geometry from OBJ Files
fill rate bound applications, Lighting Optimizations
filtering, Textures and Image Capture, Fight Aliasing with Filtering, Texture Formats and Types
anisotropic, Anisotropic Filtering: Textures on Steroids
bilinear and cubic texture filtering, Crisper Text with Distance Fields
bilinear texture filtering, Fight Aliasing with Filtering
low-pass filter for accelerometer, Adding accelerometer support
nearest, bilinear, and trilinear texture filters, Fight Aliasing with Filtering
stabilizing FPS counter with low-pass filter, Stabilizing the counter with a low-pass filter
finger up, finger down and finger move methods for IRenderEngine, Reading the Touchscreen
fireworks, rendering, Rendering Confetti, Fireworks, and More: Point Sprites
fixed-function graphics pipeline, Choosing the Appropriate Version of OpenGL ES
fixed-point numbers, Optimize Your Vertex Format
flat shading, Better Wireframes Using Polygon Offset
flipping animation, A Super Simple Sample App for Supersampling
clearing color buffer, A Super Simple Sample App for Supersampling
objectTheta and fboTheta, A Super Simple Sample App for Supersampling
floating-point numbers, vertex attributes, Optimize Your Vertex Format
floating-point precision in third-generation devices, Shaders Demystified
ForceES1 constant, GLView
ForceES1 switch, Render Method
formats for textures, Texture Formats and Types
compressed formats, Texture Compression with PVRTC
loading various formats, Hands-On: Loading Various Formats, Hands-On: Loading Various Formats
low-precision uncompressed formats, The PowerVR SDK and Low-Precision Textures, Generating and Transforming OpenGL Textures with Quartz
FPS (frames-per-second) counter, Text Rendering 101: Drawing an FPS Counter, Simplify with glDrawTexOES
rendering text, Rendering the FPS Text, Simplify with glDrawTexOES
simplifying with glDrawTexOES, Simplify with glDrawTexOES, Crisper Text with Distance Fields
stabilizing counter with low-pass filter, Stabilizing the counter with a low-pass filter
fragment shaders, Shaders, Shaders Demystified, Generating Object-Space Normal Maps
(see also shaders)
built-in variables, Shaders Demystified
gl_FragColor variable, Shaders Demystified
OES_standard_derivatives extension, Smoothing and Derivatives
precision qualifiers, Shaders Demystified
texture lookups and performance, Texture Lookups Can Hurt!
frame rate, Text Rendering 101: Drawing an FPS Counter, Instruments
framebuffer objects (FBOs), Subclassing UIView
anti-aliasing tricks with offscreen FBOs, Anti-Aliasing Tricks with Offscreen FBOs, Other FBO Effects
jittering, Jittering, Jittering
supersampling, A Super Simple Sample App for Supersampling, A Super Simple Sample App for Supersampling
attaching stencil buffer, Poor Man’s Reflection with the Stencil Buffer
Gaussian bloom with ten FBOs, Image-Processing Example: Bloom
gl_FragColor variable, Shaders Demystified
image postprocessing effects, Image-Processing Example: Bloom
initializing, Implementing the Rendering Engine
promotion to core API in OpenGL ES 2.0, RenderingEngine Implementation
setting up in HelloCone (example), OpenGL Initialization and Cone Tessellation
setup code in HelloCone (example), Examining the Depth Buffer
simulating stencil buffer with framebuffer alpha, Stencil Alternatives for Older iPhones, Anti-Aliasing Tricks with Offscreen FBOs
frameworks
defined, Linking in the OpenGL and Quartz Libraries
referencing 3.1 (or greater) version of SDK, Frameworks
frustum for field of view, Setting the Projection Transform, Beware the Scourge of Depth Artifacts
function suffixes in OpenGL ES, The Photography Metaphor
fwidth function, Smoothing and Derivatives

G

game logic, separation from rendering engine, Layering Your 3D Application
Gaussian bloom, Image-Processing Example: Bloom, Image-Processing Example: Bloom
example code, Sample Code for Gaussian Bloom, Sample Code for Gaussian Bloom
Gaussian filter, Image-Processing Example: Bloom
gcc compiler, Disclaimer Regarding Performance
generic attribute, Associating Properties with Vertices
geometry
loading from OBJ files, Loading Geometry from OBJ Files, Wrapping Up
implementing ISurface, Implementing ISurface
managing resource files, Managing Resource Files, Implementing ISurface
gl*Pointer functions, Boosting Performance with Vertex Buffer Objects
glActiveTexture function, Image Composition and a Taste of Multitexturing
glAlphaFunc function, Blending Caveats
glBindBuffer function, Boosting Performance with Vertex Buffer Objects
glBindRenderbuffer function, Creating and Using the Depth Buffer
glBlendColor function, Blending Recipe
glBlendEquation function, Blending Extensions and Their Uses
glBlendEquationSeparate function, Blending Extensions and Their Uses
glBlendFunc function, Blending Recipe
adjusting to handle premultiplied alpha, Wrangle Premultiplied Alpha
sfactor and dfactor arguments, Blending Recipe
glBufferData function, Boosting Performance with Vertex Buffer Objects
glBufferSubData function, Boosting Performance with Vertex Buffer Objects
glCheckFramebufferStatus function, A Super Simple Sample App for Supersampling
glClear command, Render Method
glClearDepthf function, Creating and Using the Depth Buffer
glClipPlanef function, User Clip Planes
glColor4f function, Saving Memory with Vertex Indexing
adjusting vertex color, Shifting Texture Color with Per-Vertex Color
glColorMask function, Rendering the Disk to Stencil Only
glCompressedTexImage2D function, Texture Compression with PVRTC
glDeleteBuffers function, Enabling Textures with ES1::RenderingEngine
glDepthFunc function, Creating and Using the Depth Buffer
glDepthMask function, Rendering the Disk to Stencil Only
glDepthRangef function, The Life of a Vertex
glDrawArrays function, Implementing the Rendering Engine, Saving Memory with Vertex Indexing
glDrawElements function, Saving Memory with Vertex Indexing, Saving Memory with Vertex Indexing
indices parameter, Boosting Performance with Vertex Buffer Objects
glDrawTexOES function, Simplify with glDrawTexOES, Crisper Text with Distance Fields, Image Composition and a Taste of Multitexturing
glFramebufferTexture2D function, A Super Simple Sample App for Supersampling
glFrustumf command, Setting the Projection Transform
glGenBuffers function, Boosting Performance with Vertex Buffer Objects
glGenerateMipmap function, Modifying ModelViewer to Support Mipmaps
glGetError function, A Super Simple Sample App for Supersampling
glLightfv function, Using Light Properties
glLightModelf function, Using Light Properties
glMaterialf function, Adding Light to ModelViewer
glMaterialfv function, Adding Light to ModelViewer
glMatrixMode function, Setting the Projection Transform, Skinning with OpenGL ES 1.1
glOrthof function, Implementing the Rendering Engine
orthographic projection, Setting the Projection Transform
glow effect, Implementing Outline, Glow, and Shadow Effects
glPointSize function, OpenGL ES 1.1 Rendering Engine and Additive Blending
glPolygonOffset function, Better Wireframes Using Polygon Offset
glPushMatrix and glPopMatrix methods, Handling Device Orientation
glRotatef function, Rotation
glRotatef method, Handling Device Orientation
glScalef function, Scale, Reading the Touchscreen
GLSL (OpenGL Shading Language), Shaders
resources for further information, Further Reading
storage qualifiers, Shaders Demystified
translating lighting pseudocode to, Adding Shaders to ModelViewer
glStencilFunc function, Rendering the Disk to Stencil Only
glStencilOp function, Rendering the Disk to Stencil Only
glTexCoordPointer function, Enabling Textures with ES1::RenderingEngine
glTexEnv function, Rendering Confetti, Fireworks, and More: Point Sprites, Point Sprites with OpenGL ES 2.0, Texture Environments under OpenGL ES 1.1
pname and param values, Texture Environments under OpenGL ES 1.1
setting up texturing state for bump mapping example, Normal Mapping with OpenGL ES 1.1
target parameter, Texture Environments under OpenGL ES 1.1
glTexImage2D function, Enabling Textures with ES1::RenderingEngine, Fight Aliasing with Filtering, Reflections with Cube Maps
texture formats, Texture Formats and Types
type parameter, Texture Formats and Types
uploading mipmaps levels to OpenGL, Boosting Quality and Performance with Mipmaps
glTexParameter function
anisotropic texturing enumerant, Anisotropic Filtering: Textures on Steroids
texture wrap modes, Texture Coordinates Revisited
glTranslatef function, Translation
GLubyte indices, Saving Memory with Vertex Indexing
GLuint type, Subclassing UIView
object handles in OpenGL, Boosting Performance with Vertex Buffer Objects
glUniformMatrix4fv function, RenderingEngine Implementation, HelloCone with Shaders
GLushort indices, Saving Memory with Vertex Indexing
glVertexAttrib function, Adding Light to ModelViewer
glVertexAttrib4f function, Image Composition and a Taste of Multitexturing
glVertexAttribPointer function, Enabling Textures with ES2::RenderingEngine, Skinning with OpenGL ES 2.0
GLView class, Subclassing UIView, Subclassing UIView
adding UIKit control, Mixing OpenGL ES and UIKit, Mixing OpenGL ES and UIKit
CameraTexture program (example), Creating Textures with the Camera
drawView method, Creating Textures with the Camera
UIImagePickerControllerDelegate implementation, Creating Textures with the Camera
Hello Arrow with shaders (example), GLView
Holodeck (example), Handling the Heads-Up Display, Handling the Heads-Up Display
adding accelerometer support, Adding accelerometer support, Adding accelerometer support
adding camera support, Overlaying with a Live Camera Image, Overlaying with a Live Camera Image
adding compass support, Adding compass support, Adding compass support
SpringyStars (example), C++ Interfaces and GLView
glViewport function, Implementing the Rendering Engine, The Life of a Vertex
glyph metrics, Text Rendering 101: Drawing an FPS Counter
glyphs, Sprites and Text
generating glyphs texture with Python, Generating a Glyphs Texture with Python, Generating a Glyphs Texture with Python
GL_APPLE_texture_2D_limited_npot extension (ES 1.1), Dealing with Size Constraints
GL_ARRAY_BUFFER, Boosting Performance with Vertex Buffer Objects
GL_COMBINE, Texture Environments under OpenGL ES 1.1
GL_COMBINE_ALPHA, Texture Combiners
GL_COMBINE_RGB, Texture Combiners
GL_DOT3_RGB, Normal Mapping with OpenGL ES 1.1
GL_DYNAMIC_DRAW, Boosting Performance with Vertex Buffer Objects
GL_ELEMENT_ARRAY_BUFFER, Boosting Performance with Vertex Buffer Objects
GL_EXT_texture_filter_anisotropic extension, Anisotropic Filtering: Textures on Steroids
gl_FragColor variable, Shaders Demystified
GL_INTERPOLATE, Texture Combiners
GL_LINES, Assembling Primitives from Vertices, Creating a Wireframe Viewer
GL_LINE_LOOP, Assembling Primitives from Vertices
GL_LINE_STRIP, Assembling Primitives from Vertices
GL_MODELVIEW matrix mode, Setting the Projection Transform
GL_NORMALIZE state, Feeding OpenGL with Normals
GL_OES_blend_equation_separate extension, Blending Extensions and Their Uses
GL_OES_blend_func_separate extension, Blending Extensions and Their Uses
GL_OES_blend_subtract extension, Blending Extensions and Their Uses
GL_OES_draw_texture extension, Sprites and Text, Simplify with glDrawTexOES
GL_OES_matrix_palette extension, Skinning with OpenGL ES 1.1
GL_OES_packed_depth_stencil extension, Poor Man’s Reflection with the Stencil Buffer
GL_OES_point_sprite extension, Sprites and Text, Rendering Confetti, Fireworks, and More: Point Sprites
GL_OES_standard_derivatives extension, Smoothing and Derivatives
GL_OES_stencil8 extension, Poor Man’s Reflection with the Stencil Buffer
GL_OES_texture_mirrored_repeat extension, Texture Coordinates Revisited
gl_PointCoord variable, Point Sprites with OpenGL ES 2.0
GL_POINTS, Assembling Primitives from Vertices
gl_PointSize variable, Point Sprites with OpenGL ES 2.0
gl_Position variable, Shaders Demystified
GL_STATIC_DRAW, Boosting Performance with Vertex Buffer Objects
GL_STENCIL_TEST, enabling, Rendering the Disk to Stencil Only
GL_STREAM_DRAW (ES 2.0), Boosting Performance with Vertex Buffer Objects
GL_TEXTURE_CROP_RECT_OES parameter, Simplify with glDrawTexOES
GL_TEXTURE_ENV_MODE, Texture Environments under OpenGL ES 1.1
GL_TRIANGLES, Assembling Primitives from Vertices, Saving Memory with Vertex Indexing
GL_TRIANGLE_FAN, Assembling Primitives from Vertices
GL_TRIANGLE_STRIP, Assembling Primitives from Vertices, OpenGL Initialization and Cone Tessellation, Saving Memory with Vertex Indexing
GPU (graphics processing unit) bottlenecks, Understand the CPU/GPU Split
grayscale texture, Baked Lighting
creating to simulate lighting, OpenGL Initialization and Cone Tessellation

H

half-angle, Give It a Shine with Specular
handles, generation by glGenBuffers, Boosting Performance with Vertex Buffer Objects
height map, Bump Mapping and DOT3 Lighting
high-pass filtering, Image-Processing Example: Bloom
fragment shader for, Sample Code for Gaussian Bloom
homogeneous coordinates, Associating Properties with Vertices
Hooke’s law of elasticity, Physics Diversion: Mass-Spring System
.hpp file extension, Defining and Consuming the Rendering Engine Interface
HUD (heads-up display)
Holodeck example, Handling the Heads-Up Display, Handling the Heads-Up Display
adding buttons, Handling the Heads-Up Display
detecting button presses and maintaining azimuth/altitude angles, Handling the Heads-Up Display, Handling the Heads-Up Display
sprites used for rendering interactive widgets, Mixing OpenGL ES and UIKit
hypot function, Adding accelerometer support

I

icons, setting up for application, Setting Up the Icons and Launch Image
identifiers (OpenGL), Subclassing UIView
identity transform, The Photography Metaphor
image file formats
PNG, Adding Textures to ModelViewer
PVR, Texture Compression with PVRTC
image files, loading optimization techniques, Texturing Optimizations
image processing (bloom example), Image-Processing Example: Bloom, Sample Code for Gaussian Bloom
crude bloom algorithm, Image-Processing Example: Bloom
Gaussian bloom, Image-Processing Example: Bloom
Gaussian bloom, sample code for, Sample Code for Gaussian Bloom, Sample Code for Gaussian Bloom
Imagination Technology, PowerVR SDK, Texture Compression with PVRTC
#import directive, Subclassing UIView
#include directive, using to embed shaders, Shaders
index buffers, Saving Memory with Vertex Indexing
indexing (vertex), saving memory with, Saving Memory with Vertex Indexing, Saving Memory with Vertex Indexing
number of required vertices for cone shape, generating, Saving Memory with Vertex Indexing
TouchCone (example) index generation code, Saving Memory with Vertex Indexing
indexing, performance and, Use the Best Topology and Indexing
indices
bone indices in vertex skinning, Optimizing Animation with Vertex Skinning, Generating Weights and Indices
generating line indices for parametric surface, Parametric Surfaces for Fun
generating triangle indices for parametric surface, Filling the Wireframe with Triangles
loading from OBJ file, Implementing ISurface
indices parameter, glDrawElements function, Boosting Performance with Vertex Buffer Objects
infinite light source, Matte Paint with Diffuse Lighting, Adding Shaders to ModelViewer
infinite viewer, Give It a Shine with Specular, Adding Shaders to ModelViewer
initializer methods (Objective-C), Subclassing UIView
instance methods in Objective-C, Subclassing UIView
Instruments tool, Instruments
Interface Builder, Starting from Scratch
interfaces
conventions for, Defining and Consuming the Rendering Engine Interface
defining in C++, Defining and Consuming the Rendering Engine Interface
designing for wireframe viewer, Designing the Interfaces, Designing the Interfaces
interleaved data, Interleaved Vertex Attributes
interpolation techniques, Interpolation Techniques
quaternions, Animating Rotation with Quaternions
inverse-transpose of model-view matrix, Normal Transforms Aren’t Normal
iPhone
deploying your application to, Deploying to Your Real iPhone
graphics technologies, Quick-Start Guide
public APIs, layers, Quick-Start Guide
iPhone Developer Program, Getting Started
iPhone SDK, downloading and installing, Installing the iPhone SDK
iPhone Simulator, Getting Started
IRenderingEngine interface, Layering Your 3D Application, Defining and Consuming the Rendering Engine Interface, Defining and Consuming the Rendering Engine Interface
CameraTexture program (example), Creating Textures with the Camera
changing for OpenGL ES 2.0 application, GLView
SpringyStars (example), C++ Interfaces and GLView
for TouchCone (example), Reading the Touchscreen
IResourceManager interface, Managing Resource Files
enhancing for ResourceManager decoding of PNG files, Enhancing IResourceManager
format support for textures, Hands-On: Loading Various Formats
iSimulate (accelerometer simulation), Adding accelerometer support
isotropic, Anisotropic Filtering: Textures on Steroids
ISurface interface
enhancing to support indices for triangles, Filling the Wireframe with Triangles
implementing in ObjSurface class, Implementing ISurface
modifying with support for normals, Generating Normals from Parametric Surfaces
ivec2 type, Vector Beautification with C++
coordinates added to finger methods, Reading the Touchscreen

J

jittering, Jittering, Jittering
popular jitter offsets, Jittering

K

kCGImageAlphaPremultipliedLast flag, Wrangle Premultiplied Alpha
keyframes, interpolation of values between, Animation
keywords in Objective-C, Subclassing UIView
Khronos Group, Quick-Start Guide
website, official specification for OpenGL ES, Further Reading
kill instruction for fragment shaders, Fragment Killing

L

Lambertian reflection, Matte Paint with Diffuse Lighting
landscape orientation, Application Skeleton
launch image, Setting Up the Icons and Launch Image
layered 3D applications, Layering Your 3D Application
lazy instantiation, Overlaying with a Live Camera Image
light blooming (see bloom)
light maps, Baked Lighting
light parameter, glLightfv function, Using Light Properties
light sources, Adding Light to ModelViewer
lighting, Adding Depth and Realism, Lighting Up, Using Light Properties
adding to ModelViewer (example), Adding Light to ModelViewer, Using Light Properties
ambient lighting in OpenGL, Ho-Hum Ambiance
diffuse lighting, matte paint with, Matte Paint with Diffuse Lighting, Matte Paint with Diffuse Lighting
DOT3 (see bump mapping and DOT3 lighting)
models, Lighting Up
optimizations, Lighting Optimizations
per-pixel, Per-Pixel Lighting, Per-Pixel Lighting
shaders (see shaders)
simulating with grayscale, OpenGL Initialization and Cone Tessellation
specular, Give It a Shine with Specular
using light properties, Using Light Properties
LightVector uniform, Normal Mapping with OpenGL ES 2.0
line anti-aliasing with textured triangle strips, Rendering Anti-Aliased Lines with Textures, Rendering Anti-Aliased Lines with Textures
line extrusion, Rendering Anti-Aliased Lines with Textures
algorithm for, Rendering Anti-Aliased Lines with Textures
initialization methods, Rendering Anti-Aliased Lines with Textures
line indices for parametric surface, Parametric Surfaces for Fun
line primitives, Assembling Primitives from Vertices
LoadPngImage function, Enhancing IResourceManager
local viewer, Give It a Shine with Specular
LookAt function, Setting the View Transform

M

Mac OS X
desktop managers, Installing the iPhone SDK
and iPhone programming stacks, Quick-Start Guide
Xcode development environment, Transitioning to Apple Technology
magnification and minification filters of textures, Fight Aliasing with Filtering
MapToSphere method, Handling Trackball Rotation
mass-spring system, Physics Diversion: Mass-Spring System, C++ Interfaces and GLView
matrices, The Photography Metaphor, The Photography Metaphor
multiplication, The Photography Metaphor
orthogonal, Normal Transforms Aren’t Normal
setting the model matrix, Setting the Model Matrix, Rotation
using matrix stacks to save and restore transforms, Saving and Restoring Transforms with Matrix Stacks, Saving and Restoring Transforms with Matrix Stacks
matrix mode, Setting the Projection Transform
Matrix.hpp file, Vector Beautification with C++
Media Services, Quick-Start Guide
methods
declaration in Objective-C, Subclassing UIView
sending to objects in Objective-C, Subclassing UIView
minification filter of textures, Fight Aliasing with Filtering
mipmaps, Fight Aliasing with Filtering, Boosting Quality and Performance with Mipmaps, Boosting Quality and Performance with Mipmaps
generation by OpenGL, Boosting Quality and Performance with Mipmaps
modifying ModelViewer (example) to support, Modifying ModelViewer to Support Mipmaps
uploading data for PVR files, Texture Compression with PVRTC
uploading levels to OpenGL, Boosting Quality and Performance with Mipmaps
mix function, Implementing Outline, Glow, and Shadow Effects
model matrix, The Photography Metaphor, Setting the Model Matrix, Rotation, Bump Mapping and DOT3 Lighting
rotation, Rotation
scale, Scale
translation, Translation
model space, The Life of a Vertex
model-view matrices in vertex skinning, Optimizing Animation with Vertex Skinning, Skinning: Common Code
model-view matrix, The Photography Metaphor
inverse-transpose of, Normal Transforms Aren’t Normal
Mona’s Cooking, The Photography Metaphor
motion blur effect, Other FBO Effects
multitexturing, Image Composition and a Taste of Multitexturing, Texture Environments under OpenGL ES 1.1

N

namespaces for renderers, New Rendering Engine
nearest filtering, Fight Aliasing with Filtering
nonlit color, Adding Light to ModelViewer
nonphotorealistic (NPR) effects, Better Wireframes Using Polygon Offset
nonuniform scale, Scale
normal attribute, Associating Properties with Vertices
normal mapping, Bump Mapping and DOT3 Lighting
(see also bump mapping and DOT3 lighting)
tools for generating normal maps, Bump Mapping and DOT3 Lighting
normal transforms, Normal Transforms Aren’t Normal
normalize argument (ES 2.0), Feeding OpenGL with Normals
normalized device coordinates, The Life of a Vertex
normals (see surface normals)
NPOT (non-power-of-two) textures, Dealing with Size Constraints, A Super Simple Sample App for Supersampling
OpenGL ES 2.0 specification, Dealing with Size Constraints
NSData objects, Texture Compression with PVRTC
NSTimer class, Defining and Consuming the Rendering Engine Interface

O

OBJ files, Parametric Surfaces for Fun
loading geometry from, Loading Geometry from OBJ Files, Wrapping Up
implementing ISurface, Implementing ISurface
resource file management, Managing Resource Files, Implementing ISurface
object coordinates, The Life of a Vertex
object handles in OpenGL, Boosting Performance with Vertex Buffer Objects
object space, The Life of a Vertex, Bump Mapping and DOT3 Lighting
generating normal maps in, Generating Object-Space Normal Maps, Reflections with Cube Maps
lighting, Object-Space Lighting
Objective-C, How to Read This Book
@ prefix for keywords, Starting from Scratch
adopting a protocol, Layering Your 3D Application
class declaration notation used to adopt protocols, Creating Textures with the Camera
classes in iPhone SDK analogous to C++ STL, RenderingEngine Declaration
HelloArrowAppDelegate (example), Hooking Up the Application Delegate, Hooking Up the Application Delegate
memory management in, Subclassing UIView
methods, Subclassing UIView
outputting diagnostic information, RenderingEngine Implementation
stringWithContentsOfFile method, Shaders
subclassing UIView, Subclassing UIView, Subclassing UIView
use of, Objective-C
objectTheta, A Super Simple Sample App for Supersampling
OES appended to end of functions, HelloCone with Shaders, Blending Extensions and Their Uses
_OES, appending to constants in ES 1.1, HelloCone with Shaders, Blending Extensions and Their Uses
OES_standard_derivatives extension, Smoothing and Derivatives
offscreen surfaces, Anti-Aliasing Tricks with Offscreen FBOs
offsetof macro, Skinning with OpenGL ES 2.0
OnFingerDown method, Reading the Touchscreen
OnFingerMove method, Reading the Touchscreen, Reading the Touchscreen
OnFingerUp method, Reading the Touchscreen
OnRotate method
implementing, Handling Device Orientation
modifying to change desired angle rather than current angle, Animating the Rotation
using in HelloCone (example), Smooth Rotation in Three Dimensions
oolong library, Disclaimer Regarding Performance
opacity, Blending and Augmented Reality
opaque property in EAGL layer, Overlaying with a Live Camera Image
opaque property on layers, Subclassing UIView
OpenGL, How to Read This Book, Quick-Start Guide
OpenGL ES, Quick-Start Guide
assembly line, The Assembly Line Metaphor
brief history, A Brief History of OpenGL ES
building template application with Xcode, Building the OpenGL Template Application with Xcode
choosing appropriate version, Choosing the Appropriate Version of OpenGL ES
cross-platform application, Layering Your 3D Application
differences in ES 1.1 and ES 2.0, HelloArrow with Shaders, RenderingEngine Implementation
drawing arrow shape from two triangles, HelloArrow with Fixed Function
errors, A Super Simple Sample App for Supersampling
function endings, The Photography Metaphor
initialization and cone tessellation (HelloCone example), OpenGL Initialization and Cone Tessellation, Smooth Rotation in Three Dimensions
initialization in GLView class (example), Subclassing UIView
iPhone application supporting ES 1.1 and 2.0, Layering Your 3D Application
linking in OpenGL and Quartz libraries, Linking in the OpenGL and Quartz Libraries
mixing with UIKit, Mixing OpenGL ES and UIKit, Mixing OpenGL ES and UIKit
normals, Feeding OpenGL with Normals
photography metaphor, The Photography Metaphor
resources for further information, Further Reading
vertex attributes, Associating Properties with Vertices
OpenGL for Embedded Systems (see OpenGL ES)
OpenGL Shading Language (see GLSL; shaders)
operator overloading in C++, Vector Beautification with C++
optimizations, Optimizing, Further Reading
animations, optimizing with vertex skinning, Optimizing Animation with Vertex Skinning, Watch Out for Pinching
generating weights and indices, Generating Weights and Indices
problems with pinching, Watch Out for Pinching
skinning in OpenGL ES 1.1, Skinning with OpenGL ES 1.1, Skinning with OpenGL ES 1.1
skinning in OpenGL ES 2.0, Skinning with OpenGL ES 2.0, Skinning with OpenGL ES 2.0
animations, vertex skinning
common code for OpenGL ES 1.1 and 2.0, Skinning: Common Code, Skinning: Common Code
CPU versus GPU bottlenecks, Understand the CPU/GPU Split
culling and clipping, Culling and Clipping, CPU-Based Clipping
CPU-based clipping, CPU-Based Clipping
user clip frames, User Clip Planes
Instruments performance analysis tool, Instruments
lighting, Lighting Optimizations
maximum optimizations enabled, gcc compiler, Disclaimer Regarding Performance
shader performance, Shader Performance
texturing, Texturing Optimizations
vertex submission, Vertex Submission: Above and Beyond VBOs, Use the Best Topology and Indexing
batching, Batch, Batch, Batch, Batch, Batch, Batch
interleaved vertex attributes, Interleaved Vertex Attributes, Interleaved Vertex Attributes
vertex format, Optimize Your Vertex Format
orientation sensors, Replacing Buttons with Orientation Sensors, Adding compass support
adding accelerometer support, Adding accelerometer support, Adding compass support
adding compass support, Adding compass support, Adding compass support
orthogonal matrices, Normal Transforms Aren’t Normal
orthographic projections, Setting the Projection Transform
orthonormal basis, Another Foray into Linear Algebra
outline effect, Implementing Outline, Glow, and Shadow Effects

P

palette matrices, Skinning with OpenGL ES 1.1, Skinning with OpenGL ES 1.1
parametric surfaces, Parametric Surfaces for Fun, Designing the Interfaces
button bar in wireframe viewer, Poor Man’s Tab Bar
generating normals from, Generating Normals from Parametric Surfaces, Generating Normals from Parametric Surfaces
generating texture coordinates, Generating Texture Coordinates, Generating Texture Coordinates
header file (ParametricSurface.hpp), Parametric Surfaces for Fun
implementation of ParametricSurfaces class, Parametric Surfaces for Fun
parametric equations, Parametric Surfaces for Fun
ParametricSurface class, Generating Basis Vectors
rendering with triangles, Filling the Wireframe with Triangles, Surface Normals
tangent plane, The Math Behind Normals
tangent support in ParametricSurface, Generating Basis Vectors
using in texturing of ModelViewer (example), Adding Textures to ModelViewer
ParametricInterval structure, texture repetitions, Generating Texture Coordinates
per-pixel lighting, Per-Pixel Lighting, Per-Pixel Lighting
shaders for, Normal Mapping with OpenGL ES 2.0
per-vertex colors, Texture Environments under OpenGL ES 1.1
perspective projections, Setting the Projection Transform
perspective transform, Associating Properties with Vertices
phi as function of acceleration, Adding accelerometer support
photography metaphor, The Photography Metaphor
physics
mass-spring system, Physics Diversion: Mass-Spring System, C++ Interfaces and GLView
PIL (Python Imaging Library), Generating a Glyphs Texture with Python
pinching, Watch Out for Pinching
ping-ponged FBOs, Image-Processing Example: Bloom
planes in viewing frustum, Beware the Scourge of Depth Artifacts
pname parameter
glLightfv function, Using Light Properties
glMaterialf and glMaterialfv functions, Adding Light to ModelViewer
PNG files, Setting Up the Icons and Launch Image, Adding Textures to ModelViewer
decoding using resource manager, Enhancing IResourceManager, Generating Texture Coordinates
Quartz decoder, alignment of image data, Dealing with Size Constraints
texture formats supported, Texture Formats and Types
POD (plain old data) type, Implementing the Rendering Engine
point size attribute, Associating Properties with Vertices
point sprites, Rendering Confetti, Fireworks, and More: Point Sprites
order-dependency problem from blending equations, OpenGL ES 1.1 Rendering Engine and Additive Blending
setting width and height, OpenGL ES 1.1 Rendering Engine and Additive Blending
using with OpenGL ES 2.0 in SpringyStars (example), Point Sprites with OpenGL ES 2.0, Wrapping Up
Pointer( ) method, Render Method
points, Assembling Primitives from Vertices
polygon offset, Better Wireframes Using Polygon Offset
polygon winding, Polygon Winding
position attribute, Associating Properties with Vertices, Associating Properties with Vertices
positional light source, Matte Paint with Diffuse Lighting
POT (power-of-two) textures, Dealing with Size Constraints
scaling to, Scaling to POT
slicing iPhone screen into, Dealing with Size Constraints
power-of-two textures (see POT textures)
PowerVR SDK
incorporating files into Xcode project, Texture Compression with PVRTC
low-precision textures and, The PowerVR SDK and Low-Precision Textures, Generating and Transforming OpenGL Textures with Quartz
precision qualifier, fragment shader floating-point declarations, Shaders Demystified
premultiplied alpha, Wrangle Premultiplied Alpha
vertex color, Shifting Texture Color with Per-Vertex Color
primitive topologies, Assembling Primitives from Vertices
using the best, Use the Best Topology and Indexing
primitives, assembling from vertices, Assembling Primitives from Vertices, Associating Properties with Vertices
programmable graphics pipeline, Choosing the Appropriate Version of OpenGL ES
projection matrix, Implementing the Rendering Engine, The Photography Metaphor, Beware the Scourge of Depth Artifacts
using two matrices to draw object upside down, Rendering the Reflected Object with Stencil Testing
projection transform, setting, Setting the Projection Transform, Setting the Projection Transform
properties
associating with vertices, Associating Properties with Vertices, Associating Properties with Vertices
declaring, Hooking Up the Application Delegate
optimizing vertex properties, Optimize Your Vertex Format
Provisioning Assistant applet, Deploying to Your Real iPhone
PVRTC compression, Texture Compression with PVRTC, The PowerVR SDK and Low-Precision Textures
adding support to ResourceManager, Texture Compression with PVRTC
creating compressed texture object in rendering engine, Texture Compression with PVRTC, Texture Compression with PVRTC
formats, Texture Compression with PVRTC
generating PVRTC data from uncompressed image with texturetool, Texture Compression with PVRTC
PVRTexTool, The PowerVR SDK and Low-Precision Textures, Generating a Glyphs Texture with Python
dealing with premultiplied alpha, Wrangle Premultiplied Alpha
generating normal map, Bump Mapping and DOT3 Lighting
location of, Generating a Glyphs Texture with Python
pycairo library, Generating a Glyphs Texture with Python
Python
distance field generation with, Generating Distance Fields with Python, Generating Distance Fields with Python
generating glyphs texture, Generating a Glyphs Texture with Python, Generating a Glyphs Texture with Python
installing Python modules, Generating a Glyphs Texture with Python
modules for imaging manipulation, Generating a Glyphs Texture with Python

Q

quadratic easing equations, Interpolation Techniques
Quartz
generating and transforming OpenGL textures, Generating and Transforming OpenGL Textures with Quartz, Generating and Transforming OpenGL Textures with Quartz
linking in library with OpenGL library, Linking in the OpenGL and Quartz Libraries
scaling textures to POT, Scaling to POT
Quartz 2D rendering engine, Quick-Start Guide
Quaternion.hpp file, Vector Beautification with C++
quaternions, Animating Rotation with Quaternions
handling trackball-like behavior, Handling Trackball Rotation
rotation state in HelloCone (example), RenderingEngine Declaration
use in HelloCone (example), RenderingEngine Declaration

R

reflect function, Reflections with Cube Maps
reflection with stencil buffer, Poor Man’s Reflection with the Stencil Buffer, Rendering the Disk with Front-to-Back Blending
rendering disk to stencil only, Rendering the Disk to Stencil Only, Rendering the Disk to Stencil Only
rendering disk with front-to-back blending, Rendering the Disk with Front-to-Back Blending
rendering real object, Rendering the “Real” Object
rending reflected object with stencil testing, Rendering the Reflected Object with Stencil Testing
reflections with cube maps, Reflections with Cube Maps, Anisotropic Filtering: Textures on Steroids
rendering to cube map, Render to Cube Map
reflective surfaces, creating, Advanced Lighting and Texturing
Render method
implementing for HelloCone (example), Render Method
for vertex skinning, Skinning with OpenGL ES 2.0
for vertex skinning in OpenGL ES 1.1, Skinning with OpenGL ES 1.1
renderbuffers, Subclassing UIView
rendering engine
augmented reality Holodeck (example)
modifying to support camera underlay, Overlaying with a Live Camera Image
bloom (example), Sample Code for Gaussian Bloom, Sample Code for Gaussian Bloom
bump mapping example, ES 2.0, Normal Mapping with OpenGL ES 2.0
changing implementation for OpenGL 2.0 application, RenderingEngine Implementation, RenderingEngine Implementation
declaration in HelloCone (example), RenderingEngine Declaration, RenderingEngine Declaration
defining and consuming interface, Defining and Consuming the Rendering Engine Interface, Defining and Consuming the Rendering Engine Interface
enabling textures in ES 1.1, Enabling Textures with ES1::RenderingEngine, Enabling Textures with ES1::RenderingEngine
enabling textures in ES 2.0, Enabling Textures with ES2::RenderingEngine, Enabling Textures with ES2::RenderingEngine
formats for textures, Hands-On: Loading Various Formats, Hands-On: Loading Various Formats
handling device orientation, Handling Device Orientation, Animating the Rotation
implementing, Implementing the Rendering Engine, Handling Device Orientation
passing resource manager to during construction, Enhancing IResourceManager
Quartz texture loading code, Generating and Transforming OpenGL Textures with Quartz
Render method for HelloCone (example), Render Method
separation from application engine, Layering Your 3D Application
with shaders in HelloCone (example), HelloCone with Shaders
Render method, HelloCone with Shaders
resource files
image file for grid cell in ModelViewer texturing, Adding Textures to ModelViewer
managing, Managing Resource Files, Implementing ISurface
ResourceManager class, Managing Resource Files
adding PVRTC support, Texture Compression with PVRTC
creating and passing to rendering engine during construction, Enhancing IResourceManager
format for textures, Hands-On: Loading Various Formats
low-precision uncompressed texture formats, The PowerVR SDK and Low-Precision Textures
with PNG loading, Enhancing IResourceManager
Quartz generation of texture, Generating and Transforming OpenGL Textures with Quartz
Quartz texture loading code, Generating and Transforming OpenGL Textures with Quartz
texture scaling to power-of-two, Scaling to POT, Scaling to POT
RGB combiners, Texture Combiners
list of arithmetic operations used for, Texture Combiners
<operand> arguments, Texture Combiners
RGB, reason for using, Lighting Up
right-hand rule (cross product), The Math Behind Normals
rotation
animating, Animating the Rotation, Animating the Rotation
animating with quaternions, Animating Rotation with Quaternions
responding to changes in device orientation, Handling Device Orientation
smooth, in three dimensions, Smooth Rotation in Three Dimensions
trackball rotation in wireframe viewer, Handling Trackball Rotation, Handling Trackball Rotation
rotation transform, Rotation
row vectors, The Photography Metaphor

S

samplerCube type, Reflections with Cube Maps
sampling, Textures and Image Capture
supersampling, A Super Simple Sample App for Supersampling, A Super Simple Sample App for Supersampling
tweaking for mipmaps levels, Boosting Quality and Performance with Mipmaps
scale transform, Scale
for model matrix, Scale
SDK references, changing, Frameworks
shaders, HelloArrow with Shaders, RenderingEngine Implementation, Shaders
adding to ModelViewer (example), Adding Shaders to ModelViewer, Better Wireframes Using Polygon Offset
per-pixel lighting, Per-Pixel Lighting, Per-Pixel Lighting
rendering engine, New Rendering Engine, New Rendering Engine
toon shading, Toon Shading
wireframes using polygon offset, Better Wireframes Using Polygon Offset
bump mapping support in fragment shader, Normal Mapping with OpenGL ES 2.0
bump mapping support in vertex shader, Normal Mapping with OpenGL ES 2.0
console I/O for shader compiler errors, RenderingEngine Implementation
cube map reflection, fragment shader, Reflections with Cube Maps
cube map reflection, vertex shader, Reflections with Cube Maps
distance-field übershader, Implementing Outline, Glow, and Shadow Effects, Animation with Sprite Sheets
embedding through use of #include, Shaders
for object-space normal map generator, Generating Object-Space Normal Maps
fragment, Shaders
fragment shader with textures, Enabling Textures with ES2::RenderingEngine
fragment shaders for distance field smoothing, Smoothing and Derivatives, Implementing Outline, Glow, and Shadow Effects
fundamentals of, Shaders Demystified, Shaders Demystified
Gaussian blur fragment shader, Sample Code for Gaussian Bloom
HelloCone (example) with, HelloCone with Shaders
high-pass filter fragment shader, Sample Code for Gaussian Bloom
per-pixel lighting, vertex and fragment shaders, Normal Mapping with OpenGL ES 2.0
performance, Shader Performance
SpringyStars (example), Point Sprites with OpenGL ES 2.0
transforming normals from tangent space to object space, Another Foray into Linear Algebra
uniform variables consumed by, The Photography Metaphor
using fragment shaders with distance fields, Adding Text Effects with Fragment Shaders
vertex, Shaders
vertex shader with textures, Enabling Textures with ES2::RenderingEngine
for vertex skinning, Skinning with OpenGL ES 2.0
shading language, A Brief History of OpenGL ES
shadow effect, Implementing Outline, Glow, and Shadow Effects
signed distance fields, Crisper Text with Distance Fields
single-instruction, multiple-data architecture (SIMD), Conditionals
size parameter in gl*Pointer functions, Boosting Performance with Vertex Buffer Objects
slerp equation, Animating Rotation with Quaternions
smoothing factor, Stabilizing the counter with a low-pass filter
smoothing, using distance fields, Smoothing and Derivatives, Implementing Outline, Glow, and Shadow Effects
smoothstep function (GLSL), Smoothing and Derivatives
source color and destination color (blending equation), Blending Recipe
spaces, Bump Mapping and DOT3 Lighting
vertex position and normal vectors, Normal Transforms Aren’t Normal
specular lighting, Lighting Up, Give It a Shine with Specular
infinite viewer model, Adding Shaders to ModelViewer
sphere parameterization, Parametric Surfaces for Fun
splash screen, Setting Up the Icons and Launch Image
SpringBoard program, Setting Up the Icons and Launch Image
sprites, Sprites and Text
animation with sprite sheets, Animation with Sprite Sheets
image composition and multitexturing, Image Composition and a Taste of Multitexturing, Image Composition and a Taste of Multitexturing
mixing OpenGL ES and UIKit, Mixing OpenGL ES and UIKit, Mixing OpenGL ES and UIKit
point sprites, Rendering Confetti, Fireworks, and More: Point Sprites
SpringyStars (example), Chapter Finale: SpringyStars, Wrapping Up
ApplicationEngine implementation, ApplicationEngine Implementation, ApplicationEngine Implementation
C++ interfaces and GLView, C++ Interfaces and GLView
mass-spring system, Physics Diversion: Mass-Spring System, C++ Interfaces and GLView
OpenGL ES 1.1 rendering engine and additive blending, OpenGL ES 1.1 Rendering Engine and Additive Blending, OpenGL ES 1.1 Rendering Engine and Additive Blending
point sprites with OpenGL ES 2.0, Point Sprites with OpenGL ES 2.0, Wrapping Up
square shape, drawing using two triangles, Assembling Primitives from Vertices
standard basis, Another Foray into Linear Algebra
status bar (iPhone), hiding in your application, Dealing with the Status Bar
stencil buffer, Poor Man’s Reflection with the Stencil Buffer, Rendering the “Real” Object
(see also reflection with stencil buffer)
faking for older iPhones, Stencil Alternatives for Older iPhones, Anti-Aliasing Tricks with Offscreen FBOs
interleaving depth buffer with into single renderbuffer, Poor Man’s Reflection with the Stencil Buffer
stenciling support on iPhone, Poor Man’s Reflection with the Stencil Buffer
STL (Standard Template Library) in C++, RenderingEngine Declaration
storage qualifiers (GLSL), Shaders Demystified
STRINGIFY macro, Shaders, Adding Shaders to ModelViewer
strings
converting UTF-8 string to NSString using alloc-init pattern, Subclassing UIView
reading shader from file into monolithic string, Shaders
supersampling, A Super Simple Sample App for Supersampling, A Super Simple Sample App for Supersampling
surface local space, Bump Mapping and DOT3 Lighting
surface normals, Surface Normals, Generating Normals from Parametric Surfaces
computing vertex normals from facets, Implementing ISurface
generating from parametric surfaces, Generating Normals from Parametric Surfaces, Generating Normals from Parametric Surfaces
math behind, The Math Behind Normals
modifying rendering engine to use, Adding Light to ModelViewer
normal mapping, Bump Mapping and DOT3 Lighting
normal transforms, Normal Transforms Aren’t Normal
OBJ file with vertex normals, Loading Geometry from OBJ Files
in OpenGL ES, Feeding OpenGL with Normals
in per-pixel lighting fragment shader, Per-Pixel Lighting
transformation by shaders from tangent to object space, Another Foray into Linear Algebra

T

tab bar, creating for wireframe viewer, Poor Man’s Tab Bar, Poor Man’s Tab Bar
tangent plane, The Math Behind Normals
tangent space, Bump Mapping and DOT3 Lighting
support for computing tangent in ParametricSurface, Generating Basis Vectors
target parameter for binding buffered data, Boosting Performance with Vertex Buffer Objects
tessellation, OpenGL Initialization and Cone Tessellation
cone tessellation, indexed, Saving Memory with Vertex Indexing
lighting and, Per-Pixel Lighting
parametric surfaces, Parametric Surfaces for Fun
texels, Textures and Image Capture
text rendering, Sprites and Text, Animation with Sprite Sheets
crisper text with distance fields, Crisper Text with Distance Fields, Animation with Sprite Sheets
adding effects with fragment shaders, Adding Text Effects with Fragment Shaders
generating distance fields with Python, Generating Distance Fields with Python, Generating Distance Fields with Python
outline, flow, and shadow effects, Implementing Outline, Glow, and Shadow Effects, Animation with Sprite Sheets
smoothing and derivatives, Smoothing and Derivatives, Implementing Outline, Glow, and Shadow Effects
using in ES 1.1 with alpha testing, Use Distance Fields Under ES 1.1 with Alpha Testing
drawing FPS counter, Text Rendering 101: Drawing an FPS Counter, Simplify with glDrawTexOES
generating glyphs texture with Python, Generating a Glyphs Texture with Python, Generating a Glyphs Texture with Python
rendering FPS text, Rendering the FPS Text, Simplify with glDrawTexOES
simple text layout algorithm, Text Rendering 101: Drawing an FPS Counter
simplifying with glDrawTexOES, Simplify with glDrawTexOES, Crisper Text with Distance Fields
texture combiners, Advanced Lighting and Texturing, Texture Combiners, Texture Combiners
GL_DOT3_RGB, Normal Mapping with OpenGL ES 1.1
texture coordinate attribute, Associating Properties with Vertices
texture environments, Texture Environments under OpenGL ES 1.1
texture lookups
anisotropic filtering, Anisotropic Filtering: Textures on Steroids
limiting number of, Image-Processing Example: Bloom, Image-Processing Example: Bloom
shader performance and, Texture Lookups Can Hurt!
texture2D function, Enabling Textures with ES2::RenderingEngine
textureCube function, Reflections with Cube Maps
textures, Textures and Image Capture, Enabling Textures with ES2::RenderingEngine
adding to ModelViewer (example), Adding Textures to ModelViewer, Enabling Textures with ES2::RenderingEngine
generating texture coordinates, Generating Texture Coordinates, Generating Texture Coordinates
rendering engine (ES 1.1), Enabling Textures with ES1::RenderingEngine, Enabling Textures with ES1::RenderingEngine
rendering engine (ES 2.0), Enabling Textures with ES2::RenderingEngine, Enabling Textures with ES2::RenderingEngine
alpha, Wrangle Premultiplied Alpha
anisotropic filtering, Anisotropic Filtering: Textures on Steroids
compression with PVRTC, Texture Compression with PVRTC, The PowerVR SDK and Low-Precision Textures
creating with the camera, Creating Textures with the Camera, CameraTexture: Rendering Engine Implementation
rendering image implementation, CameraTexture: Rendering Engine Implementation, CameraTexture: Rendering Engine Implementation
enabling mipmapping in ModelViewer (example), Modifying ModelViewer to Support Mipmaps
fighting aliasing with filtering, Fight Aliasing with Filtering
formats and types, Texture Formats and Types, Hands-On: Loading Various Formats
loading formats, Hands-On: Loading Various Formats, Hands-On: Loading Various Formats
generating and transforming OpenGL textures with Quartz, Generating and Transforming OpenGL Textures with Quartz, Generating and Transforming OpenGL Textures with Quartz
generating glyphs texture with Python, Generating a Glyphs Texture with Python, Generating a Glyphs Texture with Python
improving quality and performance with mipmaps, Boosting Quality and Performance with Mipmaps, Boosting Quality and Performance with Mipmaps
line anti-aliasing with, Rendering Anti-Aliased Lines with Textures, Rendering Anti-Aliased Lines with Textures
low-precision, and PowerVR SDK, The PowerVR SDK and Low-Precision Textures, Generating and Transforming OpenGL Textures with Quartz
multitexturing, Image Composition and a Taste of Multitexturing
normal maps, Bump Mapping and DOT3 Lighting
reducing binding operations, Batch, Batch, Batch
representing distance fields in, Crisper Text with Distance Fields
shifting color with per-vertex color, Shifting Texture Color with Per-Vertex Color
size constraints, Dealing with Size Constraints, Scaling to POT
scaling to POT, Scaling to POT, Scaling to POT
sprite sheets, Animation with Sprite Sheets
texture combiners in OpenGL ES 1.1, Texture Combiners, Texture Combiners
texture coordinates, Texture Coordinates Revisited
texture environments in OpenGL ES 1.1, Texture Environments under OpenGL ES 1.1, Texture Combiners
texturing optimizations, Texturing Optimizations
texturetool, Texture Compression with PVRTC
encoding argument, Texture Compression with PVRTC
explanation of parameters, Texture Compression with PVRTC
making automatic step in Xcode build process, Texture Compression with PVRTC
third-order texture filtering, Crisper Text with Distance Fields
toon shading, Toon Shading
Touch, Quick-Start Guide
touch points, Vertices and Touch Points
touchesBegan method, Reading the Touchscreen
touchesEnded method, Reading the Touchscreen
CameraTextures (example), Creating Textures with the Camera
touchesMoved method, Reading the Touchscreen
touchscreen, reading, Reading the Touchscreen, Reading the Touchscreen
IRenderingEngine interface for TouchCone (example), Reading the Touchscreen
rendering engine implementation (ES 1.1) for TouchCone, Reading the Touchscreen, Reading the Touchscreen
rendering engine implementation (ES 2.0) for TouchCone, Reading the Touchscreen, Reading the Touchscreen
touch event methods of UIView class, overriding, Reading the Touchscreen
trackball rotation, handling in wireframe viewer, Handling Trackball Rotation, Handling Trackball Rotation
transforms, The Life of a Vertex
identity transform, The Photography Metaphor
normal, Normal Transforms Aren’t Normal
perspective transform, Associating Properties with Vertices
projection, view, and model, The Photography Metaphor
rotation, Rotation
saving and restoring with matrix stacks, Saving and Restoring Transforms with Matrix Stacks, Saving and Restoring Transforms with Matrix Stacks
scale, Scale
translation, Translation
viewport transform, The Life of a Vertex
transition animation in wireframe viewer, Animating the Transition, Animating the Transition
translation transform, Translation
triangle winding, Polygon Winding
triangles, Assembling Primitives from Vertices
drawing square using two triangles, Assembling Primitives from Vertices
rendering parametric surfaces with, Filling the Wireframe with Triangles, Surface Normals
strips versus separate triangles, Use the Best Topology and Indexing
triangulation, OpenGL Initialization and Cone Tessellation
trigonometry, calculating rotation angle in OnFingerMove method, Reading the Touchscreen
trilinear filtering, Fight Aliasing with Filtering
tweening, Interpolation Techniques
two-sided lighting, Using Light Properties
types (see data types)

U

UIApplicationDelegate protocol, Layering Your 3D Application
UIDevice.h header, Defining and Consuming the Rendering Engine Interface
UIImage objects, Enhancing IResourceManager
UIImagePickerController protocol, Creating Textures with the Camera
UIImagePickerControllerDelegate protocol, Overlaying with a Live Camera Image
implementing in GLView in CameraTexture (example), Creating Textures with the Camera
UIInterfaceOrientation property, Application Skeleton
UIKit, Quick-Start Guide
mixing with OpenGL ES, Mixing OpenGL ES and UIKit, Mixing OpenGL ES and UIKit
OpenGL and, Starting from Scratch
rendering iPhone look-alike controls, Mixing OpenGL ES and UIKit
UINavigationControllerDelegate protocol, Creating Textures with the Camera, Overlaying with a Live Camera Image
UITabBar widget, Poor Man’s Tab Bar
UIView class
GLView class derived from, Mixing OpenGL ES and UIKit
subclassing, Subclassing UIView, Subclassing UIView
touchesBegan, touchesEnded and touchesMoved methods, Reading the Touchscreen
UIViewController class, Animating the Rotation
UIViewController pointer for camera interface, Creating Textures with the Camera
UIWindow class, Hooking Up the Application Delegate
uniform storage qualifier, Shaders Demystified
uniform variables, RenderingEngine Implementation, The Photography Metaphor
UpdateAnimation method, Animating the Rotation
calling Slerp on rotation quaternion, Smooth Rotation in Three Dimensions
usage parameter, glBufferData function, Boosting Performance with Vertex Buffer Objects
user clip frames, User Clip Planes

V

varying storage qualifier, Shaders Demystified
VBOs (see vertex buffer objects)
Vector.hpp file, Vector Beautification with C++, Vector Beautification with C++
vectors
basis vectors, Another Foray into Linear Algebra
beautification with C++, Vector Beautification with C++, Vector Beautification with C++
C++ library, C++ Vector Library, Quaternion.hpp
normal, transformation of, Normal Transforms Aren’t Normal
representing as colors, Bump Mapping and DOT3 Lighting
row vs. column notation, The Photography Metaphor
in tangent plane, The Math Behind Normals
vertex blending (see vertex skinning)
vertex buffer objects (VBOs), Boosting Performance with Vertex Buffer Objects, Boosting Performance with Vertex Buffer Objects
augmented reality Holodeck (example), Rendering the Dome, Clouds, and Text
putting all buttons in single VBO, Handling the Heads-Up Display
creating and populating, Boosting Performance with Vertex Buffer Objects
code for, Boosting Performance with Vertex Buffer Objects
modifying contents of existing VBO, Boosting Performance with Vertex Buffer Objects
rendering engine with VBOs (ES 1.1), Boosting Performance with Vertex Buffer Objects
rendering engine with VBOs (ES 2.0, Boosting Performance with Vertex Buffer Objects
vertex submission optimizations, Vertex Submission: Above and Beyond VBOs
vertex normals, Surface Normals, Loading Geometry from OBJ Files
(see also surface normals)
computing from facets, Implementing ISurface
vertex shaders, Shaders, Shaders Demystified, Generating Object-Space Normal Maps
(see also shaders)
built-in variables, Shaders Demystified
precision qualifiers, Shaders Demystified
simple (example), Shaders Demystified
texture2D function, Enabling Textures with ES2::RenderingEngine
vertex skinning, Skinning with OpenGL ES 2.0
vertex skinning, Optimizing Animation with Vertex Skinning
common code for OpenGL ES 1.1 and 2.0, Skinning: Common Code, Skinning: Common Code
generating weights and indices, Generating Weights and Indices
OpenGL ES 1.1, Skinning with OpenGL ES 1.1, Skinning with OpenGL ES 1.1
OpenGL ES 2.0, Skinning with OpenGL ES 2.0, Skinning with OpenGL ES 2.0
pinching issue, Watch Out for Pinching
vertices
assembling primitives from, Assembling Primitives from Vertices, Associating Properties with Vertices
associating properties with, Associating Properties with Vertices, Associating Properties with Vertices
data in RenderingEngine construction, Implementing the Rendering Engine
generation of cone vertices in HelloCone (example), OpenGL Initialization and Cone Tessellation
generation of disk vertices in HelloCone (example), OpenGL Initialization and Cone Tessellation
indexing, saving memory with, Saving Memory with Vertex Indexing, Saving Memory with Vertex Indexing
life of, The Life of a Vertex
metamorphosis into pixels, The Assembly Line Metaphor
vertex submission, optimization techniques, Vertex Submission: Above and Beyond VBOs, Use the Best Topology and Indexing
batching, Batch, Batch, Batch, Batch, Batch, Batch
interleaved vertex attributes, Interleaved Vertex Attributes
topologies and indexing, Use the Best Topology and Indexing
vertex format, Optimize Your Vertex Format
vertex transformation state, Implementing the Rendering Engine
VFP unit, Disclaimer Regarding Performance
view matrix, The Photography Metaphor, Bump Mapping and DOT3 Lighting
view transform, Setting the View Transform
viewport transform, Implementing the Rendering Engine, The Life of a Vertex

W

web page for this book, How to Contact Us
window space, The Life of a Vertex
Window-Based Application template, Hooking Up the Application Delegate
wireframe viewer, creating, Creating a Wireframe Viewer, Animating the Transition
designing interfaces, Designing the Interfaces, Designing the Interfaces
handling trackball rotation, Handling Trackball Rotation, Handling Trackball Rotation
implementing rendering engine, Implementing the Rendering Engine, Implementing the Rendering Engine
tab bar, Poor Man’s Tab Bar, Poor Man’s Tab Bar
transition animation for button swapping, Animating the Transition, Animating the Transition
using parametric surfaces, Parametric Surfaces for Fun, Designing the Interfaces
wireframes, better, using polygon offset, Better Wireframes Using Polygon Offset
world space, Bump Mapping and DOT3 Lighting

X

Xcode, Transitioning to Apple Technology
Active SDK, Device configuration, Instruments
building OpenGL template application, Building the OpenGL Template Application with Xcode
bundled with Interface Builder, Starting from Scratch
Debugger Console window, RenderingEngine Implementation
incorporating files from PowerVR SDK into project, Texture Compression with PVRTC
making texturetool automatic step in build code, Texture Compression with PVRTC
Optimization Level option, Code Generation, Disclaimer Regarding Performance
pretty print of extensions list, Dealing with Size Constraints
viewing provisioned iPhone in Provisioning Profiles, Deploying to Your Real iPhone