The specific series at hand is an excellent starting point for learning about the different aspects of the theory associated with a raycasting engine similar to the one used in Wolfenstein 3D, the series being “Raycasting Engine Programming - Gustavo Pezzi.” Split into two accurate sections, the primer of the course starts with JavaScript as the foundation of thinking and the presentation of the raycasting algorithm mathematics. JavaScript is an easy language to program at a high level, so it remains clear how the program is running while incorporating the problems of complexity and functional programming only insofar as they are helpful, not as hurdles to understanding the problems.
Moving to the second part of the course, “Raycasting Engine Programming - Gustavo Pezzi,” we go through the power of C programming language to get a compiled version of Raycaster. This phase involves using textured walls, sprites, and optimum techniques. From C, we obtain the sphere of performance enhancement, guaranteeing our raycasting engine is optimized to perfection. Having only a web browser with the support of JavaScript and a simple C compiler as the tools, participants can easily switch between both languages and solve the tasks in various environments.
This course, Raycasting Engine Programming - Gustavo Pezzi, is open to everyone and does not require prior knowledge. Any mathematical and implementation aspect is described in the most thorough manner possible, which results in a complex-free gradual learning process. The virtue that should be underscored in this course is the comprehensiveness of the actions made and the clarity of the information shared; every formula and line of code is presented and explained in detail, and the participants get the opportunity to see how the project unfolds step by step.
Raycasting Engine Programming - Gustavo Pezzi Table of Contents:
- 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
- Trigonometry Review
- Degrees and Radians
- Sine, Cosine, and Tangeng
- 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
- 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
- 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
- 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
- Implementing a Game Loop
- Game Loop Overview
- Fixed Deltatime Game Loop
- SDL Delay
- Quiz: Game Loop
- Map and Player Movement
- Drawing the Map with SDL
- Player Movement and SDL Events
- Exercise: Wall Collision in C
- 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
- Defining a Colorbuffer
- The Colorbuffer
- Coding a Colorbuffer
- Allocating and Freeing Memory
- Projecting Walls
- A Function to Project and Render Walls
- Exercise: Solid-Color Floor & Ceiling
- 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
- Fixing the Angle-Increment Distortion
- Exercise: FOV Distortion
- Understanding the Angle-Increment Distortion
- Fixing the Angle-Increment Distortion
- Refactoring Project Files
- Fullscreen Window
- Refactoring the Graphics File
- Exercise: Drawing Rectangles
- Refactoring the Map File
- Refactoring the Ray and the Player File
- Rendering Lines
- The Line Equation
- Rasterizing Lines
- Implementing the DDA Algorithm
- Exercise: Line Rendering
- Refactoring Wall Projection
- Refactoring the Wall Projection Function
- Sending Pointers via Parameter
- Refactoring the Ray-Facing Code
- Wall Texture Color Intensity
- 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
- Moving Forward and Next Steps
- A Discussion About Look-Up Tables
- Conclusion and Next Steps
- Moving Forward and Extra Resources
Who is this course for?
- New players are willing to learn about ray casting without having to know how to do it themselves.
- There are specific demands regarding the presentation of the basic theory and the demonstration of the algorithm.
- The target group of audience would be programmers who want to have the best of both worlds by using JavaScript and C virtually in their games.
