Raycasting Engine Programming by Gustavo Pezzi

📋 Course content

1. Introduction
   • Motivations & Learning Outcomes
   • How to Take This Course
   • An High-Level Overview of the Raycasting Algorithm
   • Ray Casting or Ray Tracing?
   • Limitations of the Wolfenstein Raycasting Algorithm
2. Trigonometry Review
   • Degrees and Radians
   • Sine, Cosine, and Tangent
   • Quiz: Trig Functions
   • A Note on Different Raycasting Techniques
3. 2D Map and Player Movement
   • Defining the 2D Map Grid
   • The Map Class
   • Player Movement
   • Exercise: Map Collision
4. Casting Rays
   • Defining the Field of View
   • FOV Increments
   • Wall Hits
   • Finding Horizontal Intersections
   • Finding Vertical Intersections
   • DDA Algorithm
   • Finding Grid-Cell Intersections
   • Fixing the Intersection Offset Error
   • Orientation using Angles vs. Vectors
   • Exercise: Ray Intersections
5. Rendering Walls
   • Wall Projection
   • Computing the Wall “Strip” Height
   • Drawing the Minimap
   • Fixing the Fishbowl Distortion
   • Spherical vs. Linear Confusion
   • Exercise: Wall Shading Based on Depth
   • Bright/Dark Walls
   • Exercise: Walls with Different Colors
6. Starting our C Code
   • Compiling our C Project
   • Configuring the C Compiler on Linux
   • Configuring the C Compiler on macOS
   • Makefiles
   • Configuring Visual Studio on Windows
   • Creating an SDL Window
   • SDL Rendering and SDL Event Polling
   • Rendering SDL Rectangles
   • Quiz: C Compilation
7. Implementing a Game Loop
   • Game Loop Overview
   • Fixed Deltatime Game Loop
   • SDL Delay
   • Quiz: Game Loop
8. Map and Player Movement
   • Drawing the Map with SDL
   • Player Movement and SDL Events
   • Exercise: Wall Collision in C
9. Casting Rays in C
   • Ray Struct and Defining a Field of View
   • Finding Horizontal Intersections with C
   • Finding Vertical Intersections with C
   • Rendering Rays using SDL
10. Defining a Colorbuffer
    • The Colorbuffer
    • Coding a Colorbuffer
    • Allocating and Freeing Memory
11. Projecting Walls
    • A Function to Project and Render Walls
    • Exercise: Solid-Color Floor & Ceiling
12. Textured Walls
    • Representing Textures in Memory
    • Creating Textures Manually
    • Mapping Textures to Walls
    • Working with Multiple Textures
    • Fixed-Size Data Types in C
    • Decoding PNG Files
    • Loading External PNG Files
    • Exercise: Reading Textures from PNG Files
13. Fixing the Angle-Increment Distortion
    • Exercise: FOV Distortion
    • Understanding the Angle-Increment Distortion
    • Fixing the Angle-Increment Distortion
14. Refactoring Project Files
    • Fullscreen Window
    • Refactoring the Graphics File
    • Exercise: Drawing Rectangles
    • Refactoring the Map File
    • Refactoring the Ray and the Player File
15. Rendering Lines
    • The Line Equation
    • Rasterizing Lines
    • Implementing the DDA Algorithm
    • Exercise: Line Rendering
16. Refactoring Wall Projection
    • Refactoring the Wall Projection Function
    • Sending Pointers via Parameter
    • Refactoring the Ray-Facing Code
    • Wall Texture Color Intensity
17. Sprites
    • Raycasting Sprites
    • Sprite Typedef
    • Rendering Sprites in the Minimap
    • Identifying Visible Sprites
    • Visible Sprites in the Wolfenstein 3D Code
    • Computing Sprite Distance
    • Normalization of the Player Rotation Angle
    • Computing Sprite Projection Height
    • Computing Sprite X Position
    • Computing Sprite Rectangle Position in the Screen
    • Displaying Textured Sprite
    • Exercise: Sorting Sprites by Distance
    • Exercise: Sorting Behind Walls
    • Enemies and Sprite Animation
    • Concluding our Raycasting Implementation
18. Moving Forward and Next Steps
    • A Discussion About Look-Up Tables
    • Conclusion and Next Steps
    • Moving Forward and Extra Resources