This course includes

  • 25 hours of on-demand video

  • Downloadable resources and exercises

  • Full lifetime access

  • Access on mobile and desktop

  • 14-day money back guarantee

  • Secure checkout through PayPal

Watch Intro Video

Motivations & Learning Outcomes


Before taking this course, you must have:

  • A basic understanding of programming fundamentals, such as variables, conditionals, loops, and functions.

  • An idea of what a C-style programming language looks like (for example: C++, Java, C#, JavaScript, or Swift).

  • Some experience with either Linux, Windows, or MacOS.

Is this course for you?

Did you ever wonder how 3D engines render objects on the screen? Or how graphics APIs such as OpenGL or DirectX are written? This course is a complete immersion on how CPU-based 3D engines work. We will use C to develop a complete 3D engine from scratch, pixel by pixel, triangle per triangle. This is a basic course that requires no prior knowledge, but you will probably make the most of it if you know already the basics of programming.
Buy $11.99
Is this course for you?

What you'll learn

Course overview and structure

This course is a complete journey into the world of 3D rendering. We will learn how to represent and display 3D objects without any graphics API. No OpenGL. No DirectX. No GPU. Just you, your C compiler, a smoking processor, and an array of pixel colors willing to dance 90's style. You will learn how to draw pixels, rasterize lines, triangles, complex 3D models, and understand the theory and the math behind computer graphics programming. If you want to understand how computer graphics really work, join us now!
Buy $11.99
What you'll learn
  • Activities and Discussions

    Join our community and get the most of our discussion boards

  • Direct instructor contact

    Have direct contact with your instructor at any given time during and after you complete your course

  • Money back guarantee

    We offer a 14-day money back guarantee for all our courses. No questions asked.

Course Content

  • 2
    Dependencies and Folder Structure
  • 3
    SDL Initialization and Color Buffer
    • Creating a SDL Window
    • Rendering a Window
    • Declaring a Color Buffer
    • Allocating Memory and Freeing Resources
    • SDL Texture
    • Full Screen Window
    • Drawing a Background Grid
    • Drawing a Grid (Solution)
    • Drawing a Rectangle
    • Drawing a Rectangle (Solution)
    • Background Color Patterns
  • 4
    Multiple Header Files
    • Defining Header Files
    • Implementing Header Files
  • 5
    Vectors and Points
    • The Draw Pixel Function
    • Color Buffer Quiz
    • Vectors
    • Vector Type Definition
    • Working with Structs
    • Array of Points
    • Constant Array Size Declaration
  • 6
    Projecting Points
    • Orthographic Projection
    • Isometric Projection
    • Perspective Projection
    • Implementing the Perspective Divide
    • Coordinate System Handedness
  • 7
    Linear Transformations
    • Vector Transformations
    • Review of Sine, Cosine, and Tangent
    • Trigonometric Functions Quiz
    • Rotating Vectors
    • Vector Rotation Function
    • Proof of Angle Sine Addition
    • Proposed Activity on Proving the Angle Cosine Addition
    • Proof of Angle Cosine Addition
  • 8
    Fixed Game Loop
    • Fixing our Game Loop Time Step
    • Using a Proper Delay Function
  • 9
    Triangles and Vertices
    • Triangles and 3D Meshes
    • Vertices and Triangle Faces
    • Triangle Edges
  • 10
    Line Drawing
    • Line Equation
    • DDA Line Drawing Algorithm
    • Implementing a Line Drawing Function
  • 11
    Dynamic Arrays
    • Dynamic Arrays
    • Dynamic Mesh Vertices and Faces
    • Separation of Vertex and Faces
  • 12
    OBJ Files
    • OBJ Files
    • Reading OBJ File Content
    • Loading OBJ File Information
  • 13
    Vector Operations
    • Back-face Culling Motivation
    • Back-face Culling in Games
    • Vector Magnitude
    • Vector Addition and Subtraction
    • Vector Scalar Multiplication and Division
    • Vector Cross Product
    • Finding the Normal Vector
    • Dot Product
    • Back-face Culling Algorithm
    • Back-face Culling Implementation
    • Vector Normalization
  • 14
    Triangle Rasterization
    • Triangle Fill
    • A Filled Triangle with Solid Color
    • The Flat-Bottom Triangle
    • Drawing a Flat-Bottom Triangle
    • The Flat-Top Triangle
    • Drawing the Flat-Top Triangle
    • Avoiding Division by Zero
    • Different Rendering Modes
    • Implementing Different Rendering Options
    • Colored Triangle Faces
  • 15
    Sorting Faces by Depth
    • Painter's Algorithm
    • Sorting Activity
    • Implementing a Sorting Function
  • 16
    • Matrices Overview
    • Matrix Multiplication
    • Properties of Matrix Multiplication
    • Examples of Matrix Multiplication
    • 2D Rotation Matrix
  • 17
    3D Matrix Transformations
    • 3D Matrix Transformations
    • 3D Scale Matrix
    • Matrix Type Definitions
    • Implementing a Scale Matrix
    • 3D Translation Matrix
    • Implementing a Translation Matrix
    • 3D Rotation Matrices
    • Implementing a Rotation Matrix
    • The World Matrix
  • 18
    Projection Matrix
    • Defining a Projection Matrix
    • Coding the Perspective Projection Matrix
    • Perspective Projection Matrix Review
    • Projection in OpenGL
    • Row-major and Column-major Orders
  • 19
    Light and Shading
    • Flat Shading
    • Flat Shading Implementation
    • Smooth Shading
  • 20
    Flipped Vertical Values
    • Inverted Y Values
  • 21
    Texture Mapping
    • Texture Mapping
    • Representing Texture Data
    • Texture Type Definitions
    • Textured Triangles
    • Textured Flat-Bottom Triangle
    • Textured Flat-Top Triangle
    • Barycentric Coordinates
    • Barycentric Weights (α, β, γ)
    • Drawing Texels
    • Visualizing Textured Triangles
  • 22
    Perspective Correct Interpolation
  • 23
    Decoding PNG Files
    • Decoding PNG Files
    • Using PNG Files as Textures
    • Freeing PNG Texture Resources
  • 24
    Textured OBJ Files
    • Loading OBJ Texture Attributes
    • Visualizing Textured OBJ Models
  • 25
    • Z-Buffer
    • Z-Buffer Implementation
    • Filled Triangles Z-Buffer Exercise
    • Filled Triangles Z-Buffer Implementation
    • Dynamic Memory Allocation
  • 26
    • Camera Space
    • Look At Camera Model
    • Look At Transformations
    • Look At Function
    • Implementing the Look At Model
    • Delta Time Factor
    • FPS Camera Movement
    • Implementing FPS Camera Movement
  • 27
    Conclusion and Next Steps
    • Handedness and Orientation
    • Dedicated Graphics Cards
    • Modern Graphics APIs
    • Next Steps


  • Gustavo Pezzi

    Senior Lecturer

    Gustavo Pezzi

    Gustavo teaches computer science and mathematics at BPP University, London. He researches how teaching game programming can help enhance awareness and understanding of mathematics and physics. He is also a professional software engineer with more than 10 years of experience, with an industry background in 3D systems, games, web systems, databases, and data science. His academic path includes institutions such as Pittsburg State University, City University of London, and University of Oxford.