Some of the most comprehensive game programming instruction available anywhere on the planet can be found right here in this package. Designed by accomplished authors and experienced industry veterans, you will be hard pressed to find a more effective way to learn how to program games.

- Package Overview
- Game Programming
- Game Art & Animation
- Unity Development
- Software & Tools
- Testimonials

- 20 Lessons
- 2 Textbooks

- 20 Presentations
- 78 Projects

If you want to be a game programmer, this is where you'll start. Most commercial games are built using the C++ programming language and this material will guide you through the process of making your very first video game. The skills you pick up along the way will serve as a foundation for the rest of the material in the package. In addition, you will be a competent C++ programmer capable of writing many different types of application.

Goals:

- Create, compile, link and execute C++ programs.
- Find out how C++ code is transformed into machine code.
- Learn some of the basic C++ features necessary for every C++ program.
- Discover how to output and input text information to and from the user.
- Understand the concept of variables.
- Perform simple arithmetic operations in C++.

Key Topics:

- Our First C++ Program
- Creating the Project
- Adding .CPP File to the Project
- Writing the Code
- Compiling, Linking, and Executing
- Comments
- White Space
- Include Directives
- Namespaces
- The main{...} Function
- std::string
- cin and cout

- Variables
- Declarations and Definitions
- Names
- sizeof
- The unsigned Keyword
- Literal Assignments
- Type Conversions / Casts
- typedefs
- Const Variables
- Macros

- Arithmetic Operations
- Unary Arithmetic Operations
- The Modulus Operator
- Compound Arithmetic Operations
- Operator Precedence

Goals:

- Understand and evaluate logical expressions.
- Form and apply conditional, if...then, statements.
- Discover how to execute a block of code repeatedly using various kinds of loops.
- Learn how to create containers of variables and how to manipulate the individual elements in those containers.

Key Topics:

- The Relational Operators
- The Logical Operators
- Conditional Statements
- The If Statement
- The Else Clause
- Nested If...Else Statements
- The Switch Statement
- The Ternary Operator

- Repetition
- The for-loop
- The while Loop
- The do...while Loop
- Nesting Loops
- Break and Continue Keywords

- Arrays
- Array Initialization
- Iterating Over an Array
- Multidimensional Arrays

Goals:

- Understand and construct logical code groupings/tasks as functions.
- Understand the various definitions for scope as it pertains to variable declarations.
- Understand how to use code libraries for common tasks in mathematics and for random number generation.
- Understand function parameter overloading and the concept of the default parameter.

Key Topics:

- User-Defined Functions
- Functions with One Parameter
- Functions with Several Parameters

- Variable Scope
- Math Library Functions
- Random Number Library Functions
- Function Overloading
- Default Parameters

Goals:

- Become familiar with reference and pointer syntax.
- Understand how C++ passes array arguments into functions.
- Discover how to return multiple return values from a function.
- Learn how to create and destroy memory at runtime (i.e., while the program is running).

Key Topics:

- References
- Constant References

- Pointers
- Computer Memory Primer
- Pointer Initialization
- Dereferencing

- Arrays Revisited
- Arrays and Pointers
- Pointer Arithmetic
- Arrays as Function Parameters

- Multiple Function Return Values using References and Pointers
- Dynamic Memory
- Allocating Memory
- Deleting Memory
- Memory Leaks

- std::vector
- Pointers to Functions

Goals:

- Understand the problems object oriented programming attempts to solve.
- Define a class and instantiate members of that class.
- Learn some basic class design strategies.

Key Topics:

- Object Oriented Programming Ideas
- Classes and Objects
- Basic Syntax
- The Dot/Arrow Operators
- Header Files
- Inclusion Guards
- Class Definitions
- Class Implementations
- Data Hiding: Private versus Public
- Constructors and Destructors
- Copy Constructors
- Assignment Operators

Goals:

- Understand how C++ natively describes strings.
- Learn some important standard library string functions.
- Review std::string and become familiar with some of its methods.
- Become familiar with the
*this*pointer. - Learn about the friend and static keywords.
- Discover how to create your own namespaces.
- Understand what enumerated types are, how they are defined in C++, and when they would be used.

Key Topics:

- Char Strings
- String Literals
- Escape Characters
- C-String Functions
- Length (strlen)
- Equality (strcmp)
- Copying (strcpy)
- Addition (strcat)
- Formatting (sprintf)

- std::string
- Length
- Relational Operators
- Addition
- Empty Strings
- Substrings
- Inserting
- Finding
- Replacing
- Bracket Operator
- getline

- The this Pointer
- Friends
- Friend Functions
- Friend Classes

- The static Keyword
- Static Variables in Functions
- Static Data Members
- Static Methods

- Namespaces
- Variations of the "using" Clause

- Enumerated Types

Goals:

- Learn how to overload the arithmetic operators.
- Discover how to overload the relational operators.
- Overload the conversion operators.
- Understand the difference between deep copies and shallow copies.
- Find out how to overload the assignment operator and copy constructor to perform deep copies.

Key Topics:

- A Vector Class
- Constructors
- Equality
- Addition and Subtraction
- Scalar Multiplication
- Length
- Normalization
- The Dot Product
- Printing
- Accepting Input

- Overloading Arithmetic Operators
- Operator Overloading Syntax
- Overloading the Other Arithmetic Operators

- Overloading Relational Operators
- Overloading Conversion Operators
- Overloading the Extraction and Insertion Operators
- A String Class
- Assignment Operator
- Copy Constructor
- Bracket Operator
- Construction and Destruction

Goals:

- Learn how to load and save text files.
- Learn how to load and save binary files.

Key Topics:

- Streams
- Text File I/O
- Saving Data
- Loading Data

- Binary File I/O
- Saving Data
- Loading Data

Goals:

- Understand what inheritance means in C++ and why it is a useful code construct.
- Understand the syntax of polymorphism, how it works, and why it is useful.
- Learn how to create general abstract types and interfaces.

Key Topics:

- Inheritance
- Repeated Inheritance
- "isa" vs. "hasa" relationships
- Base Class/Derived Class Casting
- Public vs. Private Inheritance
- Method Overriding

- Constructors and Destructors with Inheritance
- Multiple Inheritance
- Polymorphism
- How Virtual Functions Work
- The Cost of Virtual Functions
- Abstract Classes
- Interfaces

Goals:

- Learn how to design and implement generic classes.
- Learn how to define generic functions.

Key Topics:

- Class Templates
- Class Template Definition
- Class Template Implementation
- Class Template Instantiation

- A Table Template Class
- Table Data
- Class Interface
- destroy
- resize
- The Overloaded Parenthesis Operator
- The Table Class

- Function Templates

Goals:

- Understand the method of catching errors via function return codes, and an understanding of the shortcomings of this method.
- Become familiar with the concepts of exception handling, its syntax, and its benefits.
- Learn how to write assumption verification code using asserts.

Key Topics:

- Error Codes
- Exception Handling Basics
- Assert

Goals:

- Learn how to represent numbers with the binary and hexadecimal numbering systems, how to perform basic arithmetic in these numbering systems, and how to convert between these numbering systems as well as the base ten numbering system.
- Gain an understanding of how the computer describes intrinsic C++ types internally.
- Become proficient with the various binary operations.
- Become familiar with the way in which floating-point numbers are represented internally.

Key Topics:

- Number Systems
- The Binary Number System
- Counting in Binary
- Binary and Powers of 2
- Binary Arithmetic
- Converting Binary to Decimal
- Converting Decimal to Binary

- The Hexadecimal Number System
- Counting in Hexadecimal
- Hexadecimal Arithmetic
- Converting Hexadecimal to Binary
- Converting Binary to Hexadecimal

- The Binary Number System
- Bits and Memory
- Bit Operations
- AND
- Inclusive OR
- NOT
- Exclusive OR
- Shifting
- Compound Bit Operators

- Floating-Point Number Analysis

Goals:

- Discover how lists, stacks, queues, deques, and maps work internally, and in which situations they should be used.
- Become familiar with a handful of the generic algorithms the standard library provides and how to apply these algorithms on a variety of data structures.
- Learn how to create objects that act like functions, called functors, and learn how to create and use predicates with the standard library.

Key Topics:

- Linked Lists
- Stacks
- Queues
- Deques
- Maps
- Algorithms
- Functors
- Predicates

Goals:

- Learn how to create a basic Win32 application.
- Gain an understanding of the event driven programming model.

Key Topics:

- The Event Driven Programming Model
- Win32 Programming Theory
- The MSG Structure

- Overview of Creating a Windows Application
- Defining the Window Procedure
- The WNDCLASS Structure
- WNDCLASS Registration
- CreateWindow
- Showing and Updating the Window
- The Message Loop

Goals:

- Learn how to output text onto a window, and how to draw several GDI shape primitives like lines, rectangles and ellipses.
- Understand how different pens and brushes can be used to change the way GDI shapes are colored and drawn.
- Learn how to load bitmap (.bmp) images from file into our Windows programs, and how to draw them on the client area of our windows.
- Become familiar with the Visual C++ menu resource editor, and learn how to create menus.

Key Topics:

- Text Output
- The WM_PAINT Message
- The Device Context
- TextOut
- Example Program

- Shape Primitives
- Drawing Lines
- Drawing Rectangles
- Drawing Ellipses

- Bitmaps
- Loading
- Rendering
- Deleting

- Pens and Brushes
- Menus
- Creating a Menu Resource
- Loading a Menu and Attaching it to a Window
- Checking Menu Items
- Selecting Menu Items

Goals:

- Learn how to create modal and modeless dialog boxes, and how to distinguish between the two.
- Discover how to create and design dialog boxes with the Visual C++ resource editor.
- Become familiar with several Win32 controls such as static text controls, picture box controls, edit box controls, radio button controls, button controls, and combo box controls.

Key Topics:

- Modal Dialog Boxes
- Static Text Controls
- Button Controls
- Dialog Box Design

- Modeless Dialog Boxes
- Edit Controls

- Radio Buttons
- Combo Boxes

Goals:

- Learn how to use the Windows multimedia timer functions for smooth animation.
- Discover how to do basic 2D computer animation.
- Understand the technique of double buffering to avoid flicker.
- Learn how to draw complex non-rectangular 2D image bitmaps using the GDI raster operations.

Key Topics:

- Timing
- Windows Multimedia Timer Functions
- Computing Elapsed Time
- Computing Frames Per Second

- Double Buffering
- Sprites
- Theory
- Implementation
- Art Resources

Goals:

- Become familiar with the three-stage software development process of analysis, design, and implementation.
- Practice the three-stage software development process by analyzing, designing, and implementing an Air Hockey game.

Key Topics:

- Analysis
- Object Identification
- Game Behavior/Problem Solving
- Design
- Algorithms
- Mouse Velocity
- Paddle Artificial Intelligence
- Puck-Paddle Collision
- Puck-Wall Collision
- Paddle-Wall Collision
- Pausing/Un-pausing
- Keeping Score

- Software Design
- Implementation
- Main Application Code

- Introducing C++
- Conditionals, Loops, and Arrays
- Functions
- References and Pointers
- Object Oriented Programming
- Strings and Miscellaneous C++ Topics
- Operator Overloading
- File Input/Output
- Inheritance and Polymorphism
- C++ Summary I

- Templates
- Exception Handling
- Number Systems
- The Standard Template Library
- Win32 Programming I: Basic Windows Programming
- Win32 Programming II: GDI and Menus
- Win32 Programming III: Dialogs and Controls
- Sprite Animation
- Final Game
- C++ Summary II

- Experiment 1: Arithmetic Operators
- Experiment 2: Cin/Cout
- Experiment 3: Cube
- Experiment 4: Area/Circumference
- Experiment 5: Average
- Experiment 6: Bug Fixing
- Experiment 7: Logical Operator Evaluation
- Experiment 8: Navigator
- Experiment 9: Average
- Experiment 10: Factorial
- Experiment 11: Matrix Addition
- Experiment 12: ASCII
- Experiment 13: Linear Search
- Experiment 14: Selection Sort
- Experiment 15: Factorial
- Experiment 16: ToUpper/ToLower
- Experiment 17: Distance
- Experiment 18: Arc Tangent
- Experiment 19: Calculator Program
- Experiment 20: Slot Machine
- Experiment 21: Binary Search
- Experiment 22: Bubble Sort
- Experiment 23: Dice Function
- Experiment 24: Array Fill
- Experiment 25: Quadratic Equation
- Experiment 26: Gold

- Experiment 27: Character Races
- Experiment 28: Leveling Up
- Experiment 29: Magic Points
- Experiment 30: Random Encounters
- Experiment 31: Weapon/Armor Store
- Experiment 32: Magic Items
- Experiment 33: Multiple Enemies
- Experiment 34: String Reverse
- Experiment 35: To-Upper
- Experiment 36: To-Lower
- Experiment 37: Palindrome
- Experiment 38: Fraction Class
- Experiment 39: float Array Class
- Experiment 40: Line Count
- Experiment 41: Rewrite
- Experiment 42: Database
- Experiment 43: Template Array Class
- Experiment 44: Template Bubble Sort Function
- Experiment 45: Table Driver
- Experiment 46: Exception Handling
- Experiment 47: Binary Arithmetic
- Experiment 48: Hex Arithmetic
- Experiment 49: Base Conversions
- Experiment 50: Bit Operations
- Experiment 51: Binary to Decimal
- Experiment 52: Decimal to Binary

- Experiment 53: Bit Operation Calculator
- Experiment 54: Linked List
- Experiment 55: Stack
- Experiment 56: Queue
- Experiment 57: Algorithms
- Experiment 58: Exit Messages
- Experiment 59: Horizontal/Vertical Scroll Bars
- Experiment 60: Multiple Windows
- Experiment 61: Changing the Cursor
- Experiment 62: Changing the Background
- Experiment 63: Custom Icons
- Experiment 64: Changing Colors
- Experiment 65: Changing Styles
- Experiment 66: Cube Rendering
- Experiment 67: Adding an Undo Feature
- Experiment 68: List Boxes
- Experiment 69: Checkbox Controls
- Experiment 70: File Save and Open Dialogs
- Experiment 71: The Color Dialog
- Experiment 72: Colors
- Experiment 73: Drawing Order
- Experiment 74: Masking
- Experiment 75: Make Your Own Sprite
- Experiment 76: Bouncing Ball
- Experiment 77: Pong
- Experiment 78: Air Hockey

- Microsoft Visual C++ 7.0 (2002 .NET) or higher.

- 28 Lessons
- 3 Textbooks
- 23 Presentations

- 42 Projects
- 8 Supplementals

To make great games, you need to know how game engines work under the hood. Develop industry-level 3D graphics and game engine expertise that will leave you ready to take on any project. With 3000+ pages of in-depth text and over 40 hours of detailed presentations, you'll soon be an expert at writing shaders, computing lighting, and programming high-performance engine code that uses spatial trees, potential visibility sets, and more to render high quality visuals in real-time.

Goals:

- Understand how 3D game objects are represented geometrically and how they are drawn.
- Master the mathematics of the transformation pipeline, from model space through to screen space.
- Review basic transformations such as scaling, rotation, and translation.
- Be able to move points from one coordinate space to another.
- Get comfortable with the specific math operations and data types we will use in future lessons.
- Examine vectors, planes, and matrices and understand their roles in the transformation pipeline and in other common cases.
- Review dot and cross products, normalization, and matrix and vector multiplication.
- Learn the D3DX equivalent data types and functions for the operations discussed.
- Understand perspective projection and how the matrix is constructed.
- Learn how arbitrary fields of view can be created to model different camera settings.

Key Topics:

- Geometric Modeling
- 2D/3D Coordinate Systems
- Meshes
- Vertices
- Winding Order

- The Transformation Pipeline
- Translation
- Rotation
- Viewing Transformations
- Perspective Projection
- Screen Space Mapping

- 3D Mathematics Primer
- Vectors
- Magnitude
- Addition & Subtraction
- Scalar Multiplication
- Normalization
- Cross Product
- Dot Product

- Planes
- Matrices
- Matrix/Matrix Multiplication
- Vector/Matrix Multiplication
- 3D Rotation Matrices
- Identity Matrices
- Scaling and Shearing
- Concatenation
- Homogenous Coordinates

- Vectors

- D3DX Math
- Data Types
- D3DXMATRIX
- D3DXVECTOR
- D3DXPLANE

- Matrix and Transformation Functions
- D3DXMatrixMultiply
- D3DXMatrixRotation{XYZ}
- D3DXMatrixTranslation
- D3DXMatrixRotationYawPitchRoll
- D3DXVecTransform{...}

- Vector Functions
- Cross Product
- Dot Product
- Magnitude
- Normalization

- Data Types
- The Transformation Pipeline II
- The World Matrix
- The View Matrix
- The Perspective Projection Matrix
- Field of View
- Aspect Ratio

Goals:

- Begin examining the DirectX Graphics pipeline and see how the different pieces relate to what we have already learned.
- Study the COM programming model to better understand the low-level processes involved when working with the DirectX API.
- Learn how to properly initialize the DirectX environment.
- Create a rendering device for output.
- Understand important device resources like window settings, front and back buffers, depth buffers, swap chains, and surface formats.
- Use presentation parameters for device setup.
- Develop strategies to handle lost devices.

Key Topics:

- The Component Object Model (COM)
- Interfaces/IUnknown
- GUIDS
- COM and DirectX Graphics

- Initializing DirectX Graphics
- The Direct3D Device
- Pipeline Overview
- Device Memory
- The Front/Back Buffer(s)
- Swap Chains

- Window Settings
- Fullscreen vs. Windowed Mode

- Depth Buffers
- The Z-Buffer / W-Buffer

- Surface Formats
- Adapter Formats
- Frame Buffer Formats

- Device Creation
- Presentation Parameters
- Lost Devices

Goals:

- Learn how to render 3D objects as wireframe or solid objects.
- Examine how to apply various forms of shading.
- Learn about flexible vertex formats, triangle data, and the DrawPrimitive function.
- Look at core device render states used when drawing - depth buffering, lighting and shading, back face culling, etc.
- Talk about transformation states and learn how to pass matrices to the device for use in the transformation pipeline.
- Learn how to clear buffers, begin and end scene rendering, and present rendered results to the viewer.
- Start to examine more optimal rendering strategies in DirectX.
- Get comfortable with creating, filling, and drawing vertex and index buffers.
- Look at indexed and non-indexed mesh rendering for static and dynamic (animated) geometry.
- Understand device memory pools and know which is appropriate for a given job.
- Examine indexed triangle strip generation and the role of degenerate triangles.

Key Topics:

- Primitive Rendering
- Fill Modes
- Point
- Wireframe
- Solid

- Shading Modes
- Flat
- Gouraud

- Vertex Data and the FVF
- DrawPrimitiveUP

- Fill Modes
- Device States
- Render States
- Z - Buffering
- Lighting/Shading/Dithering
- Backface Culling

- Transformation States
- World/View/Projection Matrices

- Render States

- Scene Rendering
- Frame/Depth Buffer Clearing
- Begin/End Scene
- Presenting the Frame

- Device Memory Pools and Resources
- Video/AGP/System Memory

- Vertex Buffers
- Creating Vertex Buffers
- Vertex Buffer Memory Pools
- Vertex Buffer Performance
- Filling Vertex Buffers
- Vertex Stream Sources
- DrawPrimitive

- Index Buffers
- Creating Index Buffers
- DrawIndexedPrimitive/DrawIndexedPrimitiveUP
- Indexed Triangle Strips/Degenerate Triangles

Goals:

- Take a more detailed look at the view transformation and its associated matrix.
- Create first person, third person, and spacecraft camera types.
- Learn how to use rendering viewports and see what role matrices play in that process.
- Use a camera's clipping planes (frustum) to optimize scene rendering.

Key Topics:

- The View Matrix
- Vectors, Matrices, and Planes
- The View Space Planes
- The View Space Transformation
- The Inverse Translation Vector

- Vectors, Matrices, and Planes
- Viewports
- The Viewport Matrix
- Viewport Aspect Ratios

- Camera Systems
- Vector Regeneration
- First Person Cameras
- Third Person Cameras

- The View Frustum
- Camera Space Frustum Plane Extraction
- World Space Frustum Plane Extraction
- Frustum Culling an AABB

Goals:

- Understand the fixed-function DirectX Graphics vertex lighting pipeline and its advantages/disadvantages.
- Examine the primary lighting (ambient/diffuse/specular/emissive) modeled in real-time games.
- Get comfortable with the most common light types (point/spot/directional) and see how to setup their properties.
- Configure the lighting pipeline to use our light sources.
- Learn the role of vertex normals and how to calculate them when necessary.
- Discuss materials and how they define a surface's interact lights in the environment.

Key Topics:

- Lighting Models
- Indirect Lighting
- Emissive/Ambient Illumination

- Direct Lighting
- Diffuse/Specular Light

- Indirect Lighting
- The Lighting Pipeline
- Enabling DirectX Graphics Lighting
- Enabling Specular Highlights
- Enabling Global Ambient Lighting
- Lighting Vertex Formats and Normals
- Setting Lights and Light Limits

- Light Types
- Point/Spot/Directional

- Materials
- Colors, Specular and Power
- Material Sources

- Vertex Lighting Advantages/Disadvantages

Goals:

- Understand what textures are and how they are defined in memory.
- Understand mip maps, how they relate to anti-aliasing, memory footprint, and bandwidth.
- Look at the various options for loading textures from disk or memory.
- Learn how to set a texture for rendering.
- Understand the relationship between texture coordinates and addressing modes.
- Talk about aliasing and common artifacts and how to use filters to improve visual quality.
- Learn how to configure the texture pipeline for single and multi-texturing operations.
- Examine texture compression as a means for reducing memory requirements and improving performance.
- Use transformation matrices to animate texture coordinates.
- Get familiar with DirectX texture and surface types and their associated utility functions.

Key Topics:

- Texture Memory Pools
- Texture Formats
- Validating Texture Formats
- Surface Formats

- MIP Maps
- Loading Textures
- Setting Textures
- Texture Coordinates
- Sampler States
- Texture Addressing Modes
- Wrap
- Mirror/Mirror
- Border
- Clamp

- Texture Coordinate Wrapping
- Texture Filtering
- Magnification & Minification
- Point
- Bilinear
- Trilinear
- Anisotropic

- Texture Addressing Modes

- Texture Stages
- Texture Color
- Texture Stage States

- Multi-Texturing and Color Blending
- Compressed Textures
- Compressed Texture Formats
- Pre-Multiplied Alpha

- Texture Compression Interpolation
- Compressed Data Blocks - Color/Alpha Data Layout

- Compressed Texture Formats
- Texture Coordinate Transformation
- The IDirect3DTexture Interface
- The IDirect3DSurface Interface
- D3DX Texture Functions

Goals:

- Understand the general blending equation and the related concept of 'alpha' blending.
- Know where transparency data can be stored (vertices, materials, textures) and the associated pros and cons.
- Learn how to configure the transformation and texture pipelines to do blending operations.
- Use alpha testing and alpha surfaces to reject specific texels during rendering (e.g., for chain link fences).
- Study front-to-back sorting algorithms for transparent polygon rendering.
- Add colored fog to a scene using both vertex and pixel level computations.
- Learn the traditional equations for global fog effects: linear, exponential, and exponential squared).

Key Topics:

- Alpha Components
- Vertex Alpha & Pre-Lit/Unlit Vertices
- Material Alpha
- Constant Alpha & Per-Stage Constant Alpha
- Texture Alpha

- The Texture Stage Alpha Pipeline
- Frame Buffer Alpha Blending
- Alpha Testing
- Transparent Polygon Sorting
- Sorting Algorithms and Criteria
- Bubble Sort
- Quick Sort
- Hash Table Sort

- Alpha Surfaces
- Fog
- Enabling Fog and Setting the Fog Color
- Vertex/Pixel Fog
- Fog Factor Formulas
- Linear/Exponential/Exponential Squared

Goals:

- Introduce the mesh containers in the D3DX library.
- Use scene level attribute batching and subset rendering to improve performance.
- Learn optimization techniques to speed up rendering on modern hardware.
- Look at how to import X file geometry.
- Learn how to construct and fill mesh internal buffers manually.
- Discussion cloning (copying) of mesh data and some of the features available during the process.
- Learn how to manage geometric level of detail (LOD) using view-independent progressive meshes.
- Look at how to construct and use progressive meshes and see how they work algorithmically.
- Examine mesh simplification and assorted other useful mesh utility functions.

Key Topics:

- ID3DXMesh Interface
- Vertex/Index/Adjacency Buffers
- Attribute Buffers and Subset Rendering

- Mesh Optimization
- ID3DXBuffer
- Mesh Loading
- Manual Mesh Creation
- Mesh Cloning
- ID3DXPMesh Interface
- View Independent Progressive Meshes (VIPM)
- Data Validation and Cleaning
- Setting LOD
- LOD Trimming
- Vertex History

- ID3DXSPMesh Interface
- Global Mesh Utility Functions

Goals:

- Look at how to import and manage more complex 3D models and scenes.
- Introduce frames of reference and parent-child hierarchical relationships.
- Use hierarchies to build more complex scenery consisting of independent, animation-ready meshes.
- Study X file templates to see how scene data is stored and learn how to load custom data chunks.
- Examine the D3DXLoadMeshHierarchyFromX function in detail, including callback mechanisms and memory management.
- Understand how to traverse, transform, and render a hierarchy of meshes.
- Introduce a simple animation controller to prepare for the next set of topics.

Key Topics:

- Hierarchies
- Frame of Reference
- Parent/Child Relationships

- X File Templates
- Open/Closed/Restricted Templates
- Hierarchical X Files

- D3DXLoadMeshHierarchyFromX
- ID3DXAllocateHierarchy Interface
- Allocating/De-allocating Frames

- ID3DXMeshContainer Interface
- Allocating/De-allocating Mesh Containers

- Extending Hierarchy Data Types
- ID3DXLoadUserData Interface
- Loading Custom Top-Level Data
- Loading Customer Child Data

- Hierarchy Traversal and Rendering
- Simple Hierarchy Animation

Goals:

- Understand the fundamentals of animating game scenes.
- Use keyframe data to animate the hierarchies introduced previously.
- Learn the representations of X file animation data and and how it translates to D3DX data structures in the application.
- Understand how an animation controller interpolates keyframe data and how it can be controlled.
- Construct a custom animation set object that can be plugged into the D3DX animation system.
- Learn how to use the animation mixer to blend multiple simultaneous animation tracks.
- Synchronize the animation timeline with events (e.g., playing sound effects or triggering code).

Key Topics:

- Keyframes
- SRT vs. Matrix Animation Data

- Interpolation
- X Files and Animation
- Timing Data

- D3DX Animation System
- ID3DXKeyframedAnimationSet
- ID3DXAnimationController
- Hierarchy Animation

- Keyframe Data
- Animation Blending
- The Animation Mixer
- Setting Track Weight, Speed, Priority
- Enabling & Disabling Tracks

- Priority Blending

- The Animation Mixer
- Animation Controller Cloning
- The Animation Sequencer
- Registering Events
- Event Handles

- The Animation Callback System
- Callback Keys and Animation Sets
- Executing Callback Functions
- ID3DXAnimationCallbackHandler Interface

Goals:

- Learn how skinning and skeletal animation provides realistic visual results.
- Understand skins, bones, and skeletons and how they are constructed, animated, and rendered.
- Look at skinning related X file data templates and the matching game data structures.
- Examine software and hardware skinning.
- Examine non-indexed and palette-driven indexed skinning techniques.
- Integrate animated characters into our experimental framework.
- Construct a skeleton and skin model programmatically.
- Generate simple animated trees for demonstration purposes.
- Extend our lab project middle-tier to include data-driven support for animation switching and blending.

Key Topics:

- Vertex Tweening
- Segmented Models and Animation
- Bone Hierarchies/Skeletons
- Vertex Blending
- Skinning
- X File Templates for Skinning
- The Bone Offset Matrix
- Software Skinning
- ID3DXSkinInfo Interface
- Non-Indexed Skinning
- Setting multiple world matrices
- Enabling/disabling vertex blending
- ConvertToBlendedMesh

- Indexed Skinning
- Determining Support
- Matrix Palette Indices
- ConvertToIndexedBlendedMesh

- Transforming and Rendering Skinned Characters
- Trees
- Procedural Skins and Skeletons
- Procedural Keyframe Animation

- The Animation Middle Layer
- Data Driven File Support
- Animation Set Blending
- Controller Configuration
- Playing Back Complex Animations

Goals:

- Understand broad and narrow phase collision detection algorithms.
- Develop a collision detection and response system based on ellipsoids.
- Understand the mathematics of ellipsoid space.
- Examine intersection algorithms for the narrow phase.
- Test rays against common game primitives.
- Test spheres against triangle interiors.
- Test swept spheres against the edges and vertices of triangles.
- Review solving quadratic equations and their role in the detection phase.
- Learn how to support dynamic objects in terms of detection and response.

Key Topics:

- Collision Systems Overview
- Broad Phase vs. Narrow Phase Collision Detection
- Collision Responses
- Sliding

- Ray Intersection Testing
- Ray vs. Plane
- Ray vs. Polygon

- Ellipsoids, Unit Spheres, and Ellipsoid Space
- Swept sphere vs. Triangle
- Quadratic Equations
- Swept Sphere Intersection Testing
- Swept Sphere vs. Edge
- Swept Sphere vs. Vertex

- Animation and the Collision Geometry Database
- Dynamic Object Collision Support

Goals:

- Examine axis-aligned hierarchical spatial partitioning data structures like quadtrees, octrees, and kD-trees.
- Implement broad phase collision detection using spatial partitioning to improve performance.
- Examine hardware-friendly rendering of spatial trees.
- Use hierarchical frustum culling to speed up scene rendering.
- Use frame coherence to improve rendering performance.

Key Topics:

- Spatial Partitioning Data Structures/Algorithms
- Quadtrees
- Octrees
- kD Trees

- Polygon Clipping
- Polygon Database Intersection Querying
- Ray/AABB/Sphere testing

- Broad Phase Implementation for Collision System
- Frame Coherence
- Hardware Friendly Rendering
- Static vs. Dynamic Solutions
- Polygon Caches (Pros/Cons)

- Hierarchical Frustum Culling/Rendering

Goals:

- Understand the Binary Space Partitioning (BSP) tree.
- Learn how to compile BSP node trees and use them for pixel-perfect transparent polygon sorting.
- Create BSP leaf trees and examine how to add solid and empty space information to our BSP tree representation.
- Use BSP trees to perform constructive solid geometry (CSG).
- Learn how to use CSG to merge geometric objects and carve shapes out of other shapes.

Key Topics:

- Node BSP Trees
- Transparent Polygon Sorting

- Solid Leaf BSP Trees
- Rendering
- Line of Sight Tests

- Constructive Solid Geometry (CSG)
- Union Operation
- Intersection Operation
- Difference Operation

Goals:

>- Understand and learn how to calculate potential visibility sets (PVS).
- Discuss portal generation and clipping.
- Examine penumbras and anti-penumbras to see how volumetric lighting techniques can be used as visibility proxies.
- Model the flow of light through the scene for visibility.
- Learn how to compress PVS information.
- Use PVS to efficiently render complex scenes.
- Learn now to avoid problems caused by illegal geometry during BSP compilation.

Key Topics:

- Portals
- Portal Clipping

- Potential Visibility Sets
- Zero Run Length Encoding
- Scene Rendering

- Anti-Penumbras
- Generator Portal Visibility
- Portal Flow

Goals:

- Understand how to use effects to manage state and organize scene rendering.
- Learn how to load and compile effects from files, resources, and memory buffers.
- Learn how to send custom data to the graphics pipeline for state management and as prelude to our coming shader discussions.

Key Topics:

- Effect File Components
- Parameters
- Techniques
- Passes
- Functions

- Effects and Device States
- Render States
- Texture Stage States
- Sampler States
- Transform States
- Light States
- Material States

- Integrating Effect Files
- Loading and Creating Effects
- D3DXCreateEffect
- D3DXCreateEffectFromFile
- D3DXCreateEffectFromResource
- Macros
- Includes
- Extended Functions
- The ID3DXInclude Interface
- The Effect Compiler
- Custom State Managers

- Rendering with Effects
- Beginning and Ending Techniques
- Beginning and Ending Passes
- CommitChanges

- Handling Lost Devices
- Getting and Setting Effect Parameters
- Parameter Blocks
- Semantics
- Annotations
- Effect Pools and Parameter Sharing

- Loading and Creating Effects

Goals:

- Understand shader hardware architecture and the concept of shader models.
- Learn how to use vertex and pixel shaders to replace fixed-function rendering techniques.
- See how to use HLSL with effect files to simplify shader integration into our code framework.
- Understand how data is passed from our application to shader programs running on the GPU.
- Convert our vertex lighting model to a per-pixel model that supports bump maps and real-time shadows.
- Introduce render target textures and deferred rendering.
- Learn how to use pixel shaders to process images to accomplish various effects.

Key Topics:

- The Evolution of Programmable Shaders
- Shader Models
- Vertex and Pixel Shader Overview
- Shader Programs and the GPU
- Shader Hardware Architecture
- The Vertex Shader Unit
- The Pixel Shader Unit
- Registers

- HLSL Shaders
- Compiling Shaders
- HLSL Shaders with Effects
- HLSL Shaders without Effects
- Shader Semantics
- Vertex Declarations
- Structures for Input/Output
- Uniform Inputs
- HLSL Keywords
- Intrinsic Functions
- Effects and The Pre-Shader

- Transformation & Lighting with Shaders
- Vertex Transformation and Lighting
- Vertex Blending and Skinning
- Texturing and Samplers
- Per-Pixel Diffuse and Specular Lighting
- Per-Pixel Normal Mapped Lighting
- Creating Normal Maps
- Tangent Space

- Per-Pixel Lighting with Shadows
- Shadow Maps
- Shadow Map Aliasing
- Parallel Split Shadow Maps

- Deferred Rendering
- Render Targets
- Geometry Buffers
- Lighting vs. Shading

- Image Processing (In-Development)
- Processing Chain
- Color Manipulation
- Resampling
- Blurs

- High Dynamic Range (HDR) Lighting (In-Development)
- sRGB and Linear Lighting
- Tone Mapping
- HDR Texture Compression

- 3D Graphics Fundamentals I
- 3D Graphics Fundamentals II
- DirectX Graphics Fundamentals I
- DirectX Graphics Fundamentals II
- Primitive Rendering I
- Primitive Rendering II
- Camera Systems
- Lighting
- Texture Mapping I
- Texture Mapping II
- Alpha Blending
- Meshes

- Frame Hierarchies
- Keyframe Animation I
- Keyframe Animation II
- Skinning I
- Skinning II
- Collision Systems I
- Collision Systems II
- Spatial Partitioning I
- Spatial Partitioning II
- Spatial Partitioning III
- Spatial Partitioning IV

- Lab Project 1: Wireframe Renderer
- Lab Project 2: DirectX Graphics Initialization
- Lab Project 3: Device Enumeration
- Lab Project 4: Static Vertex Buffers
- Lab Project 5: Simple Terrain Renderer
- Lab Project 6: Dynamic Vertex Buffers
- Lab Project 7: Dynamic Lights
- Lab Project 8: Scene Lighting
- Lab Project 9: Simple Texturing
- Lab Project 10: Terrain Detail Texturing
- Lab Project 11: Scene Texturing
- Lab Project 12: GDI and Textures
- Lab Project 13: Offscreen Surfaces
- Lab Project 14: Vertex Alpha
- Lab Project 15: Alpha Testing
- Lab Project 16: Alpha Sorting
- Lab Project 17: Texture Splatting
- Lab Project 18: Mesh Viewer
- Lab Project 19: Level of Detail
- Lab Project 20: Mesh Hierarchies
- Lab Project 21: Mesh Animation

- Lab Project 22: Animation Splitter
- Lab Project 23: Skin Viewer
- Lab Project 24: Animation Splitter II
- Lab Project 25: Tree Generation I
- Lab Project 26: Tree Generation II
- Lab Project 27: Skinned Characters
- Lab Project 28: Collision Detection
- Lab Project 29: Spatial Partitioning I
- Lab Project 30: Spatial Partitioning II
- Lab Project 31: Solid Leaf BSP Compiler
- Lab Project 32: Portal & PVS Compiler
- Lab Project 33: Basic Effect Files
- Lab Project 34: Effect Driven Terrain
- Lab Project 35: Effect Compilation & Enumeration
- Lab Project 36: Shared Effect Parameters
- Lab Project 37: Per Pixel Lighting
- Lab Project 38: Deferred Shading
- Lab Project 39: Deferred Lighting
- Lab Project 40: Shadow Mapping
- Lab Project 41: Hardware Shadow Maps
- Lab Project 42: Shadow Map Caching System

- Microsoft Visual C++ 9.0 (2008) or higher.
- Microsoft DirectX SDK (latest).

- 15 Lessons
- 1 Textbook
- 11 Presentations

- 74 Projects
- 1 Supplemental

Math is the foundation of all video games. Although mathematics cannot be avoided, it doesn't have to be a dreadful experience either. Our training combines the depth of knowledge necessary to build realistic video games with a friendly approach that reduces much of the struggle. Whether you're programming your own game engine from scratch or using a third-party engine like Carbon or Unity, you'll be in great shape for the computational challenges ahead.

Goals:

- Understand how the real numbers (integers, rational & irrational numbers) are used and the operations we can perform on them.
- Ensure a common "language" with a study of number lines and basic interval notation.
- Discuss equations and their properties (reflexive, symmetric, transitive, substitution).
- Get comfortable with fractions and exponents.

Key Topics:

- Introduction to Real Numbers
- Use of Real Numbers
- Number lines and interval notation
- Equations and their properties
- Operations
- Order of Operations

- Fractions
- Exponents

Goals:

- Review the principles of high school level algebra.
- Understand the concept of a variable and how variables are used to form equations.
- Discuss the fundamental algebraic rules for solving single-variable and multi-variable equations.
- Solve linear equations and non-linear equations such as quadratics.
- Nail down the methods for simplifying and rearranging equations.
- Look at some of the common functions used in game development.
- Discuss domain, range, sets, inverse functions, square roots, exponentials, and logarithms.

Key Topics:

- Algebra
- Variables
- Solving single-variable equations
- Solving multi-variable linear equations
- Solving non-linear equations
- Simplifying/Rearranging
- Collecting Like Terms
- Factoring
- Expanding (FOIL)

- Functions
- Set Theory Basics
- Square Roots
- The Quadratic Equation

- Exponential Functions
- Logarithmic Functions

Goals:

- Understand the basics of analytic geometry.
- Learn about the Cartesian coordinate system and the notion of graphing points.
- Examine lines, planes, and spheres and their equations in 2D and 3D.
- Learn how to find the intersections of the shapes introduced previously.

Key Topics:

- Analytic Geometry
- The Cartesian Coordinate System
- Graphing equations and functions

- Equations of Geometric objects
- Lines/planes/spheres

- Intersecting geometric objects
- Line/line and line/sphere

- The Cartesian Coordinate System

Goals:

- Understand the basics of set theory and its symbols.
- Learn how entities are grouped into sets.
- Conduct various operations on sets, such as unions and intersections (i.e., the algebra of sets).
- Introduce the relationship between functions and sets to set the stage for the next conversation.

Key Topics:

- Introduction to Set Theory
- The Language of Set Theory
- Set Membership
- Subsets, Supersets, and Equality
- The Algebra of Set Theory
- Set Theory and Functions

Goals:

- Understand the role of functions in mathematics and in games.
- Look at the concept of mapping values between domain and range.
- Spend time visualizing various kinds of functions using graphs.
- Discuss some of the popular functions (absolute value, exponential, logarithmic) used in game development.
- Model game phenomena like fog and weapon damage using functions.
- Design a custom function and develop a means for selecting appropriate values that reflect the desired outcome.

Key Topics:

- Mathematical Functions
- Graphs
- Single-Variable Functions
- Two-Variable Functions

- Families of Functions
- Absolute Value Function
- Exponential Functions
- Fog Density
- Damage Calculations

- Logarithmic Functions
- Using the Log Function for Game Development

Goals:

- Examine the algebra of polynomials.
- Study graphs for various kinds of polynomial functions.
- Learn how to apply different kinds of polynomials in game development projects.
- See how to use linear interpolation to draw polygons on the display.
- Learn how to use polynomials to approximate the behavior of complex functions too costly to compute in real-time games.
- Learn how to use polynomials to predict the future values of variables.

Key Topics:

- Polynomial Algebra (Single Variable)
- Addition/Subtraction
- Scalar Multiplication
- Multiplication/Division

- Quadratic Equations
- Graphing Polynomials
- Using Polynomials
- Linear Interpolation
- Approximating Functions
- Prediction

Goals:

- Develop a firm grasp of the properties of triangles, and right triangles in particular.
- Look at the relationships that exist between the internal angles and the lengths of triangle sides.
- Understand the most commonly used trigonometric functions (sine, cosine, tangent) that relate triangle properties to unit circles.
- See how to use triangle properties and functions to solve a number of issues related to graphics programming.
- Create an animated wave function that might be used for a water or cloth simulation.
- Examine how to use trigonometric concepts to render circles and ellipses on the display.
- Look at how inverse trig functions (arcsin, arcos, arctan) can be used to determine angle values.
- Get comfortable with the core trig identities, such as the reduction and double angle identities.
- Learn how to use trig identities as a means for deriving mathematical proofs.
- Use trigonometry to rotate points in two and three dimensions.
- Construct a proper field-of-view for an in-game camera system.

Key Topics:

- Angles
- Common Angles
- The Polar Coordinate System

- Triangles
- Properties
- Right Triangles

- Introduction to Trigonometry
- The Trigonometric Functions
- Applications of Basic Trigonometry
- Solving Triangle Problems

- Modeling Phenomena
- Modeling Waves
- Drawing Circles and Ellipses
- Projection

- Trig Functions
- Derivative Trigonometric Functions
- Inverse Trig Functions
- Identities
- Pythagorean Identities
- Reduction Identities
- Angle Sum/Difference Identities
- Double-Angle Identities
- Sum-To-Product Identities
- Product-to-Sum Identities
- Triangle Laws

- Applications
- Point Rotation
- Field-of-View

Goals:

- Learn the basics of analytic geometry.
- Use functions and polynomials to mathematically represent points, lines, planes and ellipses.
- Understand 2D lines and their various forms, including the all-important parametric representation.
- Look at intersection and distance formulas with respect to lines, points, and planes.
- Briefly examine ellipsoidal intersections.

Key Topics:

- Points and Lines
- Two-Dimensional Lines
- Parametric Representation
- Parallel and Perpendicular Lines
- Intersection of Two Lines
- Distance from a Point to a Line
- Angles between Lines
- Three-Dimensional Lines
- Ellipses and Ellipsoids
- Intersecting Lines with Ellipses
- Intersecting Lines with Spheres

- Planes
- Intersecting Lines with Planes

Goals:

- Get very comfortable with vectors, the mathematical heart of all 3D game engines.
- Learn vector addition and subtraction, scalar multiplication, and the all-important dot and cross products.
- Examine the use of vectors in games.
- Discuss the relationship between vectors and planes and the plane representation.
- Revisit distance calculations using vectors.
- Learn how to rotate and scale geometry using vector representations of mesh vertices.

Key Topics:

- Elementary Vector Math
- Linear Combinations
- Vector Representations
- Addition/Subtraction
- Scalar Multiplication/Division
- Vector Magnitude
- The Dot Product
- Vector Projection
- The Cross Product

- Applications of Vectors
- Directed Lines
- Vectors and Planes
- Back-face Culling
- Vector-based Plane Representation
- Distance Calculations (Points, Planes, Lines)
- Point Rotation, Scaling, Skewing

Goals:

- Get very comfortable with matrices, one of the other core components of every 3D game engine.
- Understand matrices from a purely mathematical perspective.
- Know what matrices are and what problems they are intended to solve.
- Examine important matrix mathematics -- addition and subtraction, multiplication by scalars and/or by other matrices.
- Learn how to use matrices to solve systems of linear equations with Gaussian elimination.
- Understand the idea of linear transformations.
- Learn how 4D homogenous coordinates can make the non-linear translation operation compliant with matrix operations.
- Examine a number of common matrices used to effect transformations in 3D games (projection, rotation, translation, scaling, skewing).
- See how to perform rotations around all three coordinate axes.
- Study the vector/matrix transformation operation (multiplication) at the heart of all 3D graphics rendering pipelines.

Key Topics:

- Matrices
- Matrix Relations
- Matrix Operations
- Addition/Subtraction
- Scalar Multiplication
- Matrix Multiplication
- Transpose
- Determinant
- Inverse

- Systems of Linear Equations
- Gaussian Elimination

- Linear Transformations
- Computing Linear Transformation Matrices
- Translation and Homogeneous Coordinates
- Transformation Matrices
- The Scaling Matrix
- The Skewing Matrix
- The Translation Matrix
- The Rotation Matrices
- The Projection Matrix

- Linear Transformations in 3D Games

Goals:

- Examine the concept of imaginary numbers and the various arithmetical operations that can be performed on them.
- Discuss the similarities and differences between imaginary and real numbers.
- Study complex numbers and the algebra involved in working with them.
- Examine the quaternion and its associated algebra.
- Look at applications of the quaternion in game development.
- Understand how to use quaternions to perform rotations about arbitrary axes.
- Solve the gimbal lock problem encountered with Euler angles.
- Create an updated world-to-view space transformation matrix that is derived from a quaternion after rotation has taken place.

Key Topics:

- Imaginary Numbers
- Powers
- Multiplication/Division
- Addition/Subtraction

- Complex Numbers
- Addition/Subtraction
- Multiplication/Division
- Powers
- Complex Conjugates
- Magnitude

- Quaternions
- Addition/Subtraction
- Multiplication
- Complex Conjugates
- Magnitude
- Inverse
- Rotations
- World-to-View Transformation

Goals:

- Spend time focusing on some practical applications of mathematics in games.
- Look at how analytic geometry plays an important role in a number of different areas of game development.
- Learn how to design a simple collision/response system in 2D using lines and planes (e.g., a billiards simulation).
- Find a way to detect collision between two convex polygons of arbitrary shape.
- Use vectors and planes to create reflections such as might be seen in a mirror.
- See how to use of a convex volume to create shadows in a game world.
- Take a look how vector dot products can be used to determine the lighting and shading of points across a surface.

Key Topics:

- 2D Collisions
- Reflections
- Polygon/Polygon Intersection
- Shadow Casting
- Lighting

- Set Theory
- Functions
- Polynomials
- Basic Trigonometry I
- Basic Trigonometry II
- Analytic Geometry I

- Vector Mathematics
- Matrix Mathematics I
- Matrix Mathematics II
- Quaternion Mathematics
- Analytic Geometry II

Numerous mathematical exercises related to the topics covered are included at the end of each textbook chapter. (Solutions also available for separate download.)

- Microsoft Visual C++ 7.0 (2002 .NET) or higher.

- 10 Lessons
- 1 Textbook
- 8 Presentations

- 5 Projects
- 2 Supplementals

Just about all video games require non-player characters that provide the illusion of intelligent thought. This material will teach you how to program AI entities capable of navigating their environments, both individually and in groups, while displaying appropriate and customizable levels of decision making ability. Artificial intelligence is often the determining factor between games that are engrossing and fun to play and those that are destined for the bargain bin.

Goals:

- Layout a few guidelines for AI in games.
- Learn about some of the different types of AI that exist.
- Introduce the fundamentals of pathfinding and explore the different types available.
- Work through some specific pathfinding examples.

Key Topics:

- General Principles of AI
- The KISS Method
- Hard != Fun
- Play Fair

- Fundamental AI Types
- Decision Making
- Classification
- Life Systems
- Pathfinding

- Types of Pathfinding
- Non-Look-Ahead Iterative Traversals
- Look-Ahead Iterative Traversals
- Look-Ahead Recursive Traversals

- Non-Look-Ahead Iterative Traversals
- Random Backstepping
- Obstacle Tracing

Goals:

- Examine look-ahead iterative traversals for pathfinding.
- Understand Breadth-First Search, Best-First Search, and Dijkstra's search.
- Learn about the Depth-First Search.

Key Topics:

- Look-Ahead Iterative Traversals
- Breadth First Search
- Best First Search
- Dijkstra's Search

- Look-Ahead Recursive Traversals
- Depth First Search

Goals:

- Discover the famous A* search algorithm -- how it works, its limitations, and how to make it more efficient.
- Use the concept of heuristics to produce better traversal results.
- Talk about how we might apply A* to a simple RTS game.
- Introduce hierarchical pathfinding and discuss some possible use cases.

Key Topics:

- A* Search
- How A* works.
- Limitations of A*
- Making A* more efficient
- Heuristics

- Hierarchical Pathfinding

Goals:

- Complete our pathfinding studies with a look at pathfinding on non-gridded maps.
- Discuss methods for dealing with non-gridded worlds.
- Examine the design strategy used for the Pathfinding Demo, and see how the interface can be extended for your own use.

Key Topics:

- Grid It
- Visibility Points / Waypoint Networks
- Radial Basis
- Cost Fields
- Quad-Trees
- Mesh Navigation

Goals:

- Introduce the concept of decision making in AI.
- Examine various types of behavior-based movement to control single and grouped AI entities.
- Study a traditional implementation of flocking that demonstrates various behaviors for movement.

Key Topics:

- Separation
- Cohesion
- Alignment
- Avoidance
- Separation
- Cohesion
- Alignment
- Avoidance
- Cruising
- Stay Within Sphere

Goals:

- Examine the different types of decision making commonly used in game AI systems.
- Discuss state machines in detail -- one of the most popular types of decision making systems.
- Develop an understanding of transition diagrams and see how they can be used for state machines.

Key Topics:

- Decision Making
- Decision Trees
- State Machines
- Rule Base
- Squad Behaviors

- Finite State Machines
- Transition Diagrams
- Uses for State Machines
- A.I.
- Animation
- Game State
- Save File System

Goals:

- Discuss scripting and why it is important when developing an AI system.
- Learn how to integrate Python, a popular scripting language, into the state machine we developed earlier.

Key Topics:

- Scripting Basics
- Introdution to Python
- Default Types and Built-ins
- Classes
- Functions
- Control Statements
- Importing Packages

- Embedding Python
- Boost.Python
- Scripting Engines

Goals:

- Learn how to create waypoint networks and how to load and store them in our AI engine.
- Examine some of the different kinds of data that can be stored at waypoints to help the AI make decisions.
- Traverse a waypoint network using our pathfinding methods for the purposes of navigating around in the environment.

Key Topics:

- Waypoint Networks
- Loading and Storing Waypoints
- Edges
- Unidirectional vs. Bidirectional
- Cost Modifiers

- Waypoints and Decision Making
- State Machine Updates
- Waypoint Orientation

- Waypoints and Navigation
- A* Traversals

- Introduction to AI and Pathfinding
- Look-Ahead Iterative Methods of Pathfinding
- Data Structures
- Non-Gridded Pathfinding and The Pathfinding Demo

- Flocking
- Decision Making
- Scripting
- Waypoint Networks

- Lab Project 1: Pathfinding
- Lab Project 2: Behaviors
- Lab Project 3: State Machines
- Lab Project 4: Waypoint Networks
- Lab Project 5: Final Demo

- Microsoft Visual C++ 7.0 (2002 .NET) or higher.
- Microsoft DirectX SDK (latest).
- ActiveState Python 2.3 or higher.

- 12 Lessons
- 1 Textbook

- 12 Presentations
- 36 Projects

Learn how to design and build your own video game console and then program games for it. Beyond the thrill of accomplishment that comes from doing it all yourself, these projects offer a fun and interesting way to pick up some useful hardware engineering experience. Understanding the fundamentals of game hardware (consoles, handhelds, video cards, etc.) will in turn make you a better programmer, armed with a deeper understanding of what goes on under the hood.

Goals:

- Develop an understanding of analog circuits.
- Learn some of the fundamentals of electronics including: electron motion, Ohm's law, Kirchoff's laws.
- Understand some of the common circuit solving techniques.
- Become familiar with common engineering tools such as solderless breadboards, digital multi-meters, and more.
- Create a 5 Volt regulator that will be used for all additional hardware experiments.
- Turn blinking lights (LEDs) on and off with a few simple components.
- Learn about the relationships between capacitors, inductors, transformers, and transistors.
- Test circuit designs in software using a circuit simulator.

Key Topics:

- Understanding electronic signals (analog vs. digital)
- Voltage and current definitions
- Ohms Law
- Power Equations
- Resistors, Capacitors, Inductors, Transformers
- Testing Equipment
- Kirchoff's Laws
- Voltage Dividers
- 5 Volt Regulator
- Mechanical Switches

- Potentiometers
- Capacitor Equations
- Low and High Pass Filters
- Inductor Equations
- Rectifiers
- Transistor Switching
- Building Inverters
- Clock Generation
- SPICE simulations

Goals:

- Learn about digital circuits.
- Understand concepts such as Boolean logic, truth tables, logic voltage levels, and basic gates.
- Become comfortable with binary math.
- Learn advanced digital design concepts that are required for building game consoles.
- Learn about glue logic and logic simplification through techniques like K-maps and ones looping.
- Examine more complicated digital chips like shift registers that are used on the XGS micro-edition for reading joysticks and the SRAM.
- Get familiar with state machines.
- Design, on paper, a full state machine with inputs and outputs and then finish the design in hardware with LEDs and switches.

Key Topics:

- Logic Symbols
- Truth Tables
- Boolean Algebra
- DeMorgan's Theorem
- Datasheets
- Loading Concepts
- DIP Packages
- Half/Full Bit Adders
- Logic Simplification
- Bubble Pushing
- Minterms/Maxterms
- K-Maps
- Decoders, 7 Segment Displays, Muxes
- Flip Flops
- State Machine Design

Goals:

- Learn about microprocessors and microcontrollers.
- Understand the general ideas behind building your own simple computer.
- Know the inner workings of a processor.
- Learn how assembly language and machine code comes together to control inputs and outputs.
- Work with a microprocessor entirely in simulation by writing some basic code.
- Learn how to run and save your programs without having to touch a single piece of hardware.
- Perform experiments with the sx-28 microcontroller (the heart of the Pico XGS).

Key Topics:

- Microprocessors & Microcontrollers
- Von Neumann vs. Harvard
- Endianess
- External/Internal Architecture
- Pipelining
- Addressing Modes
- Interrupts
- Memory Types
- Intro to the SX-28 Microcontroller

Goals:

- Study the early generation game consoles.
- Examine ideas implemented by other video game console designers, to better understand how all the pieces fit together.
- Do a series of experiments with sound.
- Experiment with input devices like the Nintendo controller.
- Draw video to a TV screen.

Key Topics:

- SX-28 Overview
- Jump Tables
- Accessing RAM
- SX Registers
- Assembly Programming the SX-28
- XGameStation Prototypes
- D/A Converters
- Game Console Sound
- PWM Signals
- Display Technologies
- Raster Graphics

- NTSC Basics
- Adding Color
- RGB/VGA Basics
- Vector Graphics
- Game Controller Inputs
- Atari, Sega, NES Controllers Examined
- Serial Communications
- RS-232 Communications
- Game Cartridges
- Assembly Overview of Video Generation on the SX chip

Goals:

- Assemble a working video game console on a breadboard.
- Play your first games on a TV with sound and input.

Key Topics:

- Game Console Schematic
- 5 Volt Regulator Construction
- SX-28 Circuit
- Clock Circuit
- LED Output Port
- Video Out Circuit
- Audio Out Circuit
- Joystick Port

Goals:

- Make a more permanent game console by soldering it onto a prefabricated printed circuit board (PCB).
- Learn about the different components of a PCB like silk screen, solder mask, copper traces, through holes, and more.
- Get comfortable with various soldering techniques.

Key Topics:

- Soldering Iron Usage
- 5 Volt Power Supply
- Filtering and Pull Up Resistors
- Current Limiting Resistors
- Directional Pad and LEDs
- 7 Segment LEDs
- Audio and Video R2R Ladders
- DIP Socket Headers
- Expansion, RCA, and Joystick Headers

Goals:

- Gain confidence in programming the game console by making small changes (hacks) to existing assembly language demos.

Key Topics:

- Starfield Hack
- Character Tiles Hack
- Game Text Hack
- Racer Hack
- Sound Hack

Goals:

- Develop games for the console you've built.
- Experiment with tile engines to build the game world.
- Add your own customizations to provided samples.
- Show off your new games to friends and family :)

Key Topics:

- Game Components Required
- Organizing Code and Art into System ROM Space
- Organizing RAM
- Using the Real Time Clock Counter
- Creating the Title Screen
- Creating the Game Boards
- Game Screen Layout
- Creating the Game Screen

Goals:

- Use emulators and simulators to reduce game development time and increase your productivity.

Key Topics:

- Emulators and Simulators
- XGS Emu Overview
- SXSim Overview
- Launching the SXSim
- Breakpoints
- Measuring Clock Cycles
- Code Organizing
- Macro Expansion

- Introduction to Analog Circuitry
- Advanced Analog Circuitry
- Introduction to the Digital Realm
- Advanced Digital Design
- Computer Architecture
- Designing Game Systems I
- Designing Game Systems II
- Game Console on a Breadboard
- Game Console on a PCB
- Hacking Demos
- Creating Games for the Console
- Emulators and Simulators

- Experiment 1: Creating the 5 Volt Regulator
- Experiment 2: Power LED
- Experiment 3: Measuring with the Multimeter
- Experiment 4: Voltage Divider Circuit
- Experiment 5: Introduction to the Potentiometer
- Experiment 6: Playing with Switches
- Experiment 7: Simulation and Hardware Verification
- Experiment 8: Diode Experiment
- Experiment 9: Capacitor Charging and Discharging
- Experiment 10: Playing with Transistors
- Experiment 11: Introduction to the AND Gate
- Experiment 12: Introduction to the OR Gate
- Experiment 13: More Complex Circuit
- Experiment 14: Playing with the XOR Gate
- Experiment 15: Building a Half Bit Adder
- Experiment 16: 555 Timer and Binary Counter
- Experiment 17: 7 Segment Display
- Experiment 18: LED State Machine Design

- Experiment 19: Pattern Detector Design
- Experiment 20: Microprocessor Simulators
- Experiment 21: Intro to the SX-28
- Experiment 22: SX-28 Controlling the 7 Segment LED
- Experiment 23: SX Pong
- Experiment 24: Digital Organ
- Experiment 25: PWM Generated Sound
- Experiment 26: PCM Digitized Sound
- Experiment 27: Read Nintendo Controller
- Experiment 28: Mono Color Bar Demo
- Experiment 29: Color Bar Demo
- Experiment 30: Drawing a Star Field
- Experiment 31: Assembly of the Game Console onto a Breadboard
- Experiment 32: Numerous Demos to Verify Working Console
- Experiment 33: Assembly of the Game Console onto a PCB
- Experiment 34: Numerous Demos to Verify Working Console
- Experiment 35: Modifying Source Code with Hacks
- Experiment 36: Programming Game Console with Final Course Game

- The XGS Pico Edition Kit is required (sold separately) if you wish to build the hardware. For more details about the necessary hardware kit, and to purchase directly, visit the XGS Game Console Starter Kit 2.0 website.