iPhone 3D Programming. Developing Graphical Applications with OpenGL ES

Spis treści ebooka

• iPhone 3D Programming
  • SPECIAL OFFER: Upgrade this ebook with OReilly
  • A Note Regarding Supplemental Files
  • Foreword
  • Preface
    • How to Read This Book
    • Conventions Used in This Book
    • Using Code Examples
    • Safari Books Online
    • How to Contact Us
    • Acknowledgments
  • 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
  • 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
  • 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 Mans Tab Bar
      • Animating the Transition
    • Wrapping Up
  • 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 Arent 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
  • 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
  • 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 Mans 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
  • 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
  • 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
  • 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
  • A. C++ Vector Library
    • Disclaimer Regarding Performance
    • Vector.hpp
    • Matrix.hpp
    • Quaternion.hpp
  • Index
  • About the Author
  • Colophon
  • SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści

ukryj recenzje