How to Take this Course

Working with Makefiles

The Compilation Flow

Project Folder Structure

A Quick Note for Windows Users

Words of Encouragement

Allocating Memory and Freeing Resources

Exercise Drawing a Background Grid

Configuring Visual Studio on Windows

Creating an SDL Window

Fullscreen Window

Exercise Drawing Rectangles

Drawing a Background Grid

Introduction and Learning Outcomes

Declaring a Vector Type

Creating a Function to Draw Rectangles

Implementing the Perspective Divide

SDL Texture

Coordinate System Handedness

Project Dependencies

Array of Points

Review of C Structs

The Draw Pixel Function

Orthographic Projection

Rendering an SDL Window

Coding New Header Files

Vector Rotation Function

Vector Transformations

Review of Sine Cosine and Tangent

Using a Delay Function

Triangle Edges

Proof of Angle Cosine Addition

Defining Header Files

Perspective Projection

Vectors

Triangles and Meshes

Rotating Vectors

Proof of Angle Sine Addition

Vertices and Triangle Faces

Dynamic Arrays

Exercise Loading OBJ File Content

Line Equation

Dynamic Mesh Vertices and Faces

Fixing our Game Loop Time Step

Vector Scalar Multiplication and Division

Back-face Culling Motivation

Coding a Function to Draw Lines

Vector Addition and Subtraction

OBJ Files

Vector Magnitude

Finding the Normal Vector

Vector Cross Product

Declaring a Color Buffer

DDA Line Drawing Algorithm

Loading OBJ File Content

Activity Find Triangle Midpoint

Flat-Bottom & Flat-Top Technique

Triangle Fill

Back-face Culling Code

Back-face Culling Algorithm

Avoiding Division by Zero

Flat-Top Triangle Code

Vector Normalization

Flat-Bottom Triangle Code

Flat-Top Triangle Algorithm

Solution to the Triangle Midpoint

Different Rendering Options Solution

Colored Triangle Faces

Dot Product

Flat-Bottom Triangle Algorithm

Painter's Algorithm

Properties of Matrix Multiplication

Coding the Triangle Midpoint Computation

Matrix Typedef

D Rotation Matrix

Translation Matrix Code

Matrices Overview

Examples of Matrix Multiplication

Order of Transformations

D Matrix Transformations

Matrix Operations

D Translation Matrix

Rotation Matrix Code

D Scale Matrix

Exercise Projecting Negative Values

The World Matrix

Populating our Perspective Projection Matrix

D Rotation Matrices

Coding a Sorting Function

Inverted Vertical Screen Values

Projecting Negative Values

Translation is Not a Linear Transformation

Row-major and Column-major Orders

Smooth Shading Techniques

Coding the Perspective Projection Matrix

Coding Flat Shading & Light

Textured Triangles

Textured Flat-Top Triangle

Texture Mapping

PS1 Games and Affine Texture Mapping

Function to Compute (α, β, γ)

Inverted Cube UV Coordinates

Texture Typedef

Freeing PNG Textures

Representing Textures in Memory

Defining a Projection Matrix

Flat Shading

Textured Flat-Bottom Triangle

Decoding PNG Files

Visualizing Textured OBJ Models

Loading PNG File Content

Visualizing Textured Triangles

Barycentric Weights (α, β, γ)

Preventing Texture Buffer Overflow

Exercise Z-Buffer for Filled Triangles

Implementing a Z-Buffer for Filled Triangles

Perspective Correct Interpolation Code

Loading OBJ Texture Attributes

Z-Buffer Code

Z-Buffer

Exercise Right Frustum Plane Point & Normal

The LookAt Function

Barycentric Coordinates

Planes

Variable Delta-time

Coding the LookAt Function

Look At Camera Model

Initializing an Array of Frustum Planes

Coding a Simple FPS Camera Movement

A Simple FPS Camera Movement

Perspective Correct Interpolation

Frustum Clipping

Look At Transformations

Defining Points Inside and Outside Planes

Converting Polygons Back Into Triangles

A Discussion on Dynamic Memory Allocation

Camera Space

Horizontal & Vertical FOV Angles

Working with Static Variables

Refactoring Light Globals

Coding the Function to Clip Polygons Against Planes

Polygon Typedef

Visualizing Clipped Triangles

Simulating Low-Resolution Displays

Exercise Camera Pitch Rotation

Implementing the Camera Pitch Rotation

A Function to Clip Polygon Against Planes

Declaring Multiple Meshes

Clipping a Polygon Against a Plane

Reading OBJ Quads

Defining Frustum Planes Points & Normals

Clipping Texture UV Coordinates

Implementing Multiple Textures

Refactoring SDL Globals

Pineda's Rasterization Algorithm

Exercise Reading OBJ Quads

Clipping Space

Intersection Between Line & Plane

Function to Process Pipeline Stages

Non-Fullscreen SDL Window

Dedicated Graphics Cards

Edge Function & Barycentric Weights

Implementing Multiple Meshes

Subpixel Rasterization

Mouse Motion (Camera Pitch & Yaw)

Mouse Wheel (Camera Front & Back)

Determining Point Inside Triangle

Signed Area & Backface Culling

Top-Left Rasterization Rule

Edge Function & Constant Increments

Subpixel Flat-Shaded Triangles

Modern Graphics APIs & Shaders

Subpixel Textured Triangles

Revisiting Handedness & Orientation

Exercise Subpixel Rasterizer

Next Steps

Subpixel Line Drawing