Hands-On C++ Game Animation Programming

Spis treści książki

• Hands-On C++ Game Animation Programming
• Why subscribe?
• Contributors
• About the author
• About the reviewer
• Packt is searching for authors like you
• Preface
  • Who this book is for
  • What this book covers
  • To get the most out of this book
    • Conventions used
  • Get in touch
    • Reviews
• Chapter 1: Creating a Game Window
  • Technical requirements
  • Creating an empty project
  • Creating the application class
  • Adding an OpenGL loader
  • Getting glad
    • Adding glad to the project
  • Creating a window
    • Global variables
    • Opening a window
    • Creating the event handler
  • Exploring the samples
  • Summary
• Chapter 2: Implementing Vectors
  • Introducing vectors
  • Creating a vector
    • Epsilon
  • Understanding component-wise operations
    • Vector addition
    • Vector subtraction
    • Scaling vectors
    • Multiplying vectors
    • Dot product
  • Understanding non-component-wise operations
    • Vector length
    • Normalizing vectors
    • The angle between vectors
    • Vector projection and rejection
    • Vector reflection
    • Cross product
  • Interpolating vectors
  • Comparing vectors
  • Exploring more vectors
  • Summary
• Chapter 3: Implementing Matrices
  • Technical requirements
  • What is a matrix?
    • Matrix storage
  • Creating a matrix
  • Common matrix operations
    • Comparing matrices
    • Adding matrices
    • Scaling a matrix
    • Matrix multiplication
  • Transforming vectors and points
  • Inverting a matrix
    • Transpose
    • Determinant and minors of lower-order matrices
  • Creating camera matrices
    • Frustum
    • Perspective
    • Orthographic
    • Look at
  • Summary
• Chapter 4: Implementing Quaternions
  • Creating quaternions
    • Angle axis
    • Creating rotations from one vector to another
  • Retrieving quaternion data
  • Common quaternion operations
  • Comparison operations
  • Dot product
  • Length and squared length
  • Unit quaternions
  • Conjugate and inverse
  • Multiplying quaternions
  • Transforming vectors
  • Interpolating quaternions
    • Neighborhood
    • Understanding the mix function
    • Understanding the nlerp function
    • Introduction to slerp
    • Power
    • Implementing slerp
  • Look rotation
  • Converting between quaternions and matrices
  • Summary
• Chapter 5: Implementing Transforms
  • Creating the transform
  • Combining transforms
  • Inverting transforms
  • Mixing transforms
  • Converting transforms to matrices
  • Converting matrices into transforms
  • Transforming points and vectors
  • Summary
• Chapter 6: Building an Abstract Renderer
  • Technical requirements
  • Working with shaders
    • The Shader class declaration
    • Implementing the Shader class
  • Working with buffers (attributes)
    • The Attribute class declaration
    • Implementing the Attribute class
  • Working with uniforms
    • The Uniform class declaration
    • Implementing the Uniform class
  • Working with index buffers
    • The IndexBuffer class declaration
    • Implementing the IndexBuffer class
  • Rendering geometry
  • Working with textures
    • Adding stb_image
    • The Texture class declaration
    • Implementing the Texture class
  • Simple shaders
    • The vertex shader
    • The fragment shader
  • Summary
• Chapter 7: Exploring the glTF File Format
  • Technical requirements
  • Exploring how glTF files are stored
    • glTF files store a scene, not a model
  • Exploring the glTF format
    • The parts you need for animation
    • The parts you dont need for animation
    • Accessing data
  • Exploring cgltf
    • Integrating cgltf
  • Exploring the sample assets
    • Exporting from Blender
  • Summary
• Chapter 8: Creating Curves, Frames, and Tracks
  • Understanding cubic Bézier splines
  • Understanding cubic Hermite splines
  • Interpolation types
  • Creating the Frame struct
  • Creating the Track class
    • Declaring the Track class
    • Implementing the Track class
  • Creating the TransformTrack class
    • Declaring the TransformTrack class
    • Implementing the TransformTrack class
  • Summary
• Chapter 9: Implementing Animation Clips
  • Implementing poses
    • Declaring the Pose class
    • Implementing the Pose class
  • Implementing clips
    • Declaring the Clip class
    • Implementing the Clip class
  • glTF loading the rest pose
  • glTF loading joint names
  • glTF loading animation clips
  • Summary
• Chapter 10: Mesh Skinning
  • Exploring meshes
  • Understanding skinning
    • Exploring rigid skinning
    • The rigid skinning pipeline
    • Exploring smooth skinning
  • Implementing skeletons
    • The Skeleton class declaration
    • The Skeleton class implementation
  • glTF loading the bind pose
  • glTF loading a skeleton
  • Implementing meshes
    • The Mesh class declaration
    • The Mesh class implementation
  • glTF loading meshes
  • Implementing GPU skinning
  • Summary
• Chapter 11: Optimizing the Animation Pipeline
  • Pre-generating the skin matrix
    • Generating the skin matrix
    • CPU skinning
    • GPU skinning
  • Storing the skin palette in a texture
  • Faster sampling
    • Optimizing the Track class
    • Converting tracks
    • Creating FastTransformTrack
    • Creating FastClip
  • The Pose palette generation
    • Changing the GetMatrixPalette function
    • Reordering joints
    • Reordering clips
    • Reordering meshes
  • Exploring Pose::GetGlobalTransform
  • Summary
• Chapter 12: Blending between Animations
  • Pose blending
    • Declaring the Blend function
    • Implementing the Blend function
  • Crossfading animations
    • Creating helper classes
    • Declaring the cross-fade controller
    • Implementing the cross-fade controller
  • Additive blending
    • Declaring additive animations
    • Implementing additive animations
  • Summary
• Chapter 13: Implementing Inverse Kinematics
  • Creating a CCD solver
    • Declaring the CCD solver
    • Implementing the CCD solver
  • Creating a FABRIK solver
    • Declaring the FABRIK solver
    • Implementing the FABRIK solver
  • Implementing constraints
    • Ball-and-socket constraint
    • Hinge constraint
  • Using IK to align a character's feet to the ground
    • Finding the foot goals
    • Interpolating the foot goals
    • Vertical character placement
    • IK pass
    • Foot alignment
  • Summary
  • Further reading
• Chapter 14: Using Dual Quaternions for Skinning
  • Introducing dual quaternions
  • Implementing dual quaternions
    • Implementing dual quaternion operations
    • Measuring, normalizing, and inverting dual quaternions
    • Converting transforms and dual quaternions
    • Transforming vectors and points
  • Skinning with dual quaternions
    • Modifying the pose class
    • Modifying the skeleton class
    • Creating new uniform types
    • Creating a dual quaternion shader
  • Understanding how to use dual quaternion skinning
  • Summary
• Chapter 15: Rendering Instanced Crowds
  • Storing data in textures
  • Reading data from textures
  • Encoding animation data
  • Exploring per-instance data
  • Creating an animation texture
    • Declaring the AnimTexture class
    • Implementing the AnimTexture class
  • Animation baker
  • Creating a crowd shader
  • Creating the Crowd utility class
    • Implementing the Crowd class
    • Using the Crowd class
  • Blending animations
  • Exploring texture formats
  • Combining animation textures
  • Optimizing texel fetches
    • Limiting influences
    • Limiting animated components
    • Not interpolating
    • Combining these optimizations
  • Summary
• Other Books You May Enjoy
  • Leave a review - let other readers know what you think

pokaż cały spis treści

ukryj recenzje