iPhone 3D Programming

Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

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

Z

Z-fighting, Beware the Scourge of Depth Artifacts