(Ebook) iPhone 3D Programming Developing Graphical Applications with OpenGL ES 1st Edition by Philip Rideout, Serban Porumbescu ISBN 9780596804824 0596804822

Chapter 1. Quick-Start Guide

Transitioning to Apple Technology

Objective-C

A Brief History of OpenGL ES

Choosing the Appropriate Version of OpenGL ES

Getting Started

Installing the iPhone SDK

Building the OpenGL Template Application with Xcode

Deploying to Your Real iPhone

HelloArrow with Fixed Function

Layering Your 3D Application

Starting from Scratch

Linking in the OpenGL and Quartz Libraries

Subclassing UIView

Hooking Up the Application Delegate

Setting Up the Icons and Launch Image

Dealing with the Status Bar

Defining and Consuming the Rendering Engine Interface

Implementing the Rendering Engine

Handling Device Orientation

Animating the Rotation

HelloArrow with Shaders

Shaders

Frameworks

GLView

RenderingEngine Implementation

Wrapping Up

Chapter 2. Math and Metaphors

The Assembly Line Metaphor

Assembling Primitives from Vertices

Associating Properties with Vertices

The Life of a Vertex

The Photography Metaphor

Setting the Model Matrix

Scale

Translation

Rotation

Setting the View Transform

Setting the Projection Transform

Saving and Restoring Transforms with Matrix Stacks

Animation

Interpolation Techniques

Animating Rotation with Quaternions

Vector Beautification with C++

HelloCone with Fixed Function

RenderingEngine Declaration

OpenGL Initialization and Cone Tessellation

Smooth Rotation in Three Dimensions

Render Method

HelloCone with Shaders

Wrapping Up

Chapter 3. Vertices and Touch Points

Reading the Touchscreen

Saving Memory with Vertex Indexing

Boosting Performance with Vertex Buffer Objects

Creating a Wireframe Viewer

Parametric Surfaces for Fun

Designing the Interfaces

Handling Trackball Rotation

Implementing the Rendering Engine

Poor Man’s Tab Bar

Animating the Transition

Wrapping Up

Chapter 4. Adding Depth and Realism

Examining the Depth Buffer

Beware the Scourge of Depth Artifacts

Creating and Using the Depth Buffer

Filling the Wireframe with Triangles

Surface Normals

Feeding OpenGL with Normals

The Math Behind Normals

Normal Transforms Aren’t Normal

Generating Normals from Parametric Surfaces

Lighting Up

Ho-Hum Ambiance

Matte Paint with Diffuse Lighting

Give It a Shine with Specular

Adding Light to ModelViewer

Using Light Properties

Shaders Demystified

Adding Shaders to ModelViewer

New Rendering Engine

Per-Pixel Lighting

Toon Shading

Better Wireframes Using Polygon Offset

Loading Geometry from OBJ Files

Managing Resource Files

Implementing ISurface

Wrapping Up

Chapter 5. Textures and Image Capture

Adding Textures to ModelViewer

Enhancing IResourceManager

Generating Texture Coordinates

Enabling Textures with ES1::RenderingEngine

Enabling Textures with ES2::RenderingEngine

Texture Coordinates Revisited

Fight Aliasing with Filtering

Boosting Quality and Performance with Mipmaps

Modifying ModelViewer to Support Mipmaps

Texture Formats and Types

Hands-On: Loading Various Formats

Texture Compression with PVRTC

The PowerVR SDK and Low-Precision Textures

Generating and Transforming OpenGL Textures with Quartz

Dealing with Size Constraints

Scaling to POT

Creating Textures with the Camera

CameraTexture: Rendering Engine Implementation

Wrapping Up

Chapter 6. Blending and Augmented Reality

Blending Recipe

Wrangle Premultiplied Alpha

Blending Caveats

Blending Extensions and Their Uses

Why Is Blending Configuration Useful?

Shifting Texture Color with Per-Vertex Color

Poor Man’s Reflection with the Stencil Buffer

Rendering the Disk to Stencil Only

Rendering the Reflected Object with Stencil Testing

Rendering the “Real” Object

Rendering the Disk with Front-to-Back Blending

Stencil Alternatives for Older iPhones

Anti-Aliasing Tricks with Offscreen FBOs

A Super Simple Sample App for Supersampling

Jittering

Other FBO Effects

Rendering Anti-Aliased Lines with Textures

Holodeck Sample

Application Skeleton

Rendering the Dome, Clouds, and Text

Handling the Heads-Up Display

Replacing Buttons with Orientation Sensors

Adding accelerometer support

Adding compass support

Overlaying with a Live Camera Image

Wrapping Up

Chapter 7. Sprites and Text

Text Rendering 101: Drawing an FPS Counter

Generating a Glyphs Texture with Python

Rendering the FPS Text

Stabilizing the counter with a low-pass filter

Fleshing out the FpsRenderer class

Simplify with glDrawTexOES

Crisper Text with Distance Fields

Generating Distance Fields with Python

Use Distance Fields Under ES 1.1 with Alpha Testing

Adding Text Effects with Fragment Shaders

Smoothing and Derivatives

Implementing Outline, Glow, and Shadow Effects

Animation with Sprite Sheets

Image Composition and a Taste of Multitexturing

Mixing OpenGL ES and UIKit

Rendering Confetti, Fireworks, and More: Point Sprites

Chapter Finale: SpringyStars

Physics Diversion: Mass-Spring System

C++ Interfaces and GLView

ApplicationEngine Implementation

OpenGL ES 1.1 Rendering Engine and Additive Blending

Point Sprites with OpenGL ES 2.0

Wrapping Up

Chapter 8. Advanced Lighting and Texturing

Texture Environments under OpenGL ES 1.1

Texture Combiners

Bump Mapping and DOT3 Lighting

Another Foray into Linear Algebra

Generating Basis Vectors

Normal Mapping with OpenGL ES 2.0

Normal Mapping with OpenGL ES 1.1

Generating Object-Space Normal Maps

Reflections with Cube Maps

Render to Cube Map

Anisotropic Filtering: Textures on Steroids

Image-Processing Example: Bloom

Better Performance with a Hybrid Approach

Sample Code for Gaussian Bloom

Wrapping Up

Chapter 9. Optimizing

Instruments

Understand the CPU/GPU Split

Vertex Submission: Above and Beyond VBOs

Batch, Batch, Batch

Interleaved Vertex Attributes

Optimize Your Vertex Format

Use the Best Topology and Indexing

Lighting Optimizations

Object-Space Lighting

DOT3 Lighting Revisited

Baked Lighting

Texturing Optimizations

Culling and Clipping

Polygon Winding

User Clip Planes

CPU-Based Clipping

Shader Performance

Conditionals

Fragment Killing

Texture Lookups Can Hurt!

Optimizing Animation with Vertex Skinning

Skinning: Common Code

Skinning with OpenGL ES 2.0

Skinning with OpenGL ES 1.1

Generating Weights and Indices

Watch Out for Pinching

Further Reading

Appendix. C++ Vector Library

Disclaimer Regarding Performance

Vector.hpp

Matrix.hpp

Quaternion.hpp

Index