Course description

c++ game engine

This course is a gentle and comprehensive introduction to the fundamentals of 2D game engine architecture. We'll discuss several of the most popular programming patterns used in game development and try to put all the theory we learn into context by coding a small 2D game engine using modern C++, SDL, and Lua.

c++ ecs

We will write, together, a small ECS framework from scratch to manage our entities, components, and systems. We will discuss how engine programmers design their code and how we should think of organizing game objects in memory with performance in mind.

The tools you'll need

c++ game engine tools
  • C++ is a powerful compiled language
  • SDL2 is a library for cross-platform rendering and input
  • GLM is a math helper library
  • Dear ImGui is a library to create UI for engine tooling
  • Sol is a binding library for modern C++ & Lua
  • Lua is fast and easy to use scripting language

We'll try to write most of our engine code from scratch. All these libraries and tools are cross-platform, so you'll be able to code along with either Windows, macOS, or Linux!

c++ game engine platform

Is this course for you?

The target audience for this course are beginner programmers that wish to learn more about how C++ works in the context of game development. Therefore, students must already know how to code and be familiar with basic concepts of programming and logic. You should be able to write if-else statements, loops, functions, and classes using simple OOP.

You do not need to know C++ before enrolling; many successful students have a background in web, mobile, and game development, working with languages like Java, Python, Ruby, Go, Swift, JavaScript, Ada, Zig, Kotlin, and many others.

How is this course different?

This course is not just a simple tutorial on how to create a game with C++. This is the opportunity for you to think about the abstraction of what a "game" really is and all the pieces that need to interact to make them happen. More than that, this course allows you to write from scratch the code of a small C++ engine that can be used to create many types of games.

We will also touch other important topics like ECS, data-oriented design, STL containers, C++ templates, game loop, SDL rendering, event systems, asset management, memory management, and performance. And finally, we'll also learn how to embed the Lua language into our native C++ code to add scripting power to our engine.

lua game scriptingr

While there are other resources about game engine development out there, they are either too theoretical or overwhelmingly long. If you are looking for a gentle introduction to the world of game engine programming and want to learn how games really work under the hood, then you should definitely take this course!

About the instructor

gustavo pezzi

Gustavo Pezzi is a university lecturer in London, UK. He has won multiple education awards as a teacher and is also the founder of

Gustavo teaches fundamentals of computer science and mathematics; his academic path includes institutions such as Pittsburg State University, City University of London, and University of Oxford.

teaching certification
higher education academy
pgclt teaching certification
bpp university award

Course content

30 hours total length 27 Chapters Last updated January 2024
  • Motivations & Learning Outcomes
  • How to Take This Course
  • Project Technologies and Libraries
  • Configuring Linux Dependencies
  • Configuring macOS Dependencies
  • Compilation
  • Linking
  • Makefiles
  • Configuring Visual Studio on Windows
  • Quiz: Compilation and Linking
  • Static vs. Dynamic Libraries
  • Game Loop
  • Game Class
  • Creating an SDL Window
  • Polling SDL Events
  • Rendering the SDL Window
  • Fullscreen SDL Window
  • Fake Fullscreen vs. Real Fullscreen
  • SDL GPU Acceleration and VSync
  • Quiz: SDL Window
  • Drawing an SDL Rectangle
  • Double-Buffered Rendering
  • Loading PNG Textures
  • Quiz: Game Loop and SDL Window
  • Object Movement and Velocity Vectors
  • Fixed Game Framerate
  • SDL Delay
  • Variable Delta Time
  • Uncapped Framerate
  • Game Loop and Determinism
  • Quiz: Game Loop Timestep
  • Logger Class
  • Exercise: Logging Game Information
  • Coding the Logger Class
  • Popular C++ Logger Libraries
  • Quiz: Logger
  • Project Subfolders
  • Makefile Variables
  • Creating C++ Objects
  • Examples of C++ Object Creation
  • Organizing Game Objects
  • Object Inheritance Design
  • Quiz: C++ Objects
  • Component-Based Design
  • Entity-Component-System Design
  • ECS Folder Structure
  • System Component Signature
  • Working with C++ Templates
  • Component Type Template
  • Understanding Component<T>
  • Exercise: System Functions
  • Adding and Removing Entities from Systems
  • The Erase-Remove Idiom
  • Operator Overloading for Entities
  • Quiz: ECS Design
  • Pool of Components
  • The Pool Class
  • Coding the Pool Class
  • Registry Systems & Entity Signatures
  • Entity Creation
  • Adding Components
  • Removing Components
  • Implementing System Functions
  • Quiz: ECS Implementation
  • Creating our First Entity
  • Smart Pointers
  • Converting ECS Code to Use Smart Pointers
  • Raw Pointers for SDL
  • Quiz: Smart Pointers
  • Adding our First Component
  • Careful with Types size_t and int
  • Exercise: Entity Class Managing Components
  • Entity Class Managing Components
  • Warning About Cyclic Dependency
  • Movement System
  • Movement System and Delta Time
  • Render System
  • Managing Game Assets
  • The Asset Store
  • Displaying Textures in our Render System
  • Exercise: Displaying the Tilemap
  • Displaying the Tilemap
  • Rendering Order
  • Sorting Sprites by Z-Index
  • Animated Sprites
  • Animation System
  • Identifying Animations By Name
  • Entity Collision Check
  • Implementing the Collision System
  • Exercise: Rendering a Collider Rectangle
  • Quiz: 2D Collision
  • Killing Entities and Re-Using IDs
  • Implementing Entity Removal
  • Introduction to Event System
  • Event System Design Options
  • Event Handlers
  • Emitting Events & Subscribing to Events
  • Exercise: Key Pressed Event
  • Event System Design Patterns
  • Quiz: Event System
  • Keyboard Control System
  • Camera Follow System
  • Sprites with Fixed Position
  • Projectile Emitter Component
  • Projectile Duration
  • Health Component
  • Exercise: Shooting Projectiles
  • DRY Code
  • Tags & Groups
  • Optimizing Access of Tags & Groups
  • Projectiles Colliding with Player/li>
  • Projectiles Colliding with Enemies
  • Compilation Times
  • Data-Oriented Design
  • Cache Hits and Cache Misses
  • Avoiding Data Gaps
  • Packed Pool of Components
  • Array of Structs vs. Struct of Arrays
  • Cache Profiling with Valgrind
  • Popular C++ ECS Libraries
  • Adding Fonts to the Asset Store
  • Render Text System
  • Exercise: Rendering Health Value
  • Introduction to Dear ImGui
  • Dear ImGui and SDL
  • Dear ImGui Demo Window
  • Immediate-Mode GUI Paradigm
  • Render GUI System/li>
  • Button to Spawn Enemies
  • Exercise: Customization of New Enemies
  • Quiz: Dear ImGui
  • Killing Entities Outside Map Limits
  • Flipping Sprites on Collision
  • Invisible Entities & Obstacles
  • Exercise: Keeping the Player Inside the Map
  • Culling Sprites Outside Camera View
  • Game Scripting
  • The Lua Scripting Language
  • Using Sol as a C++ Lua Wrapper
  • Lua State
  • Reading Lua Tables
  • Fetching Missing Table Values with Sol
  • Lua Functions
  • Level Loader Class
  • Reading Assets from a Lua Table
  • Handling Multiple Objects in a Lua Level
  • Scripting for Night/Day Tilemap
  • Scripting Entity Behavior with Lua
  • Script System
  • Lua Bindings
  • Binding Multiple Lua Functions
  • Loading Different Lua Levels
  • Division of C++ and Lua Code
  • Quiz: Lua Scripting
  • Finishing our Code
  • Next Steps
  • Proposed Project: Tilemap Editor
  • Moving Forward
  • Copyright & Content Distribution

73% of our students come back for another course

We don't offer discounts on our courses. Ever.

What students are saying

5 star
4 star
3 star
2 star
1 star
Darius Balan
"Great course!! Gustavo Pezzi's game engine course is fantastic! It's well-structured and super informative, perfect for diving into game development. Gustavo explains everything clearly, and the hands-on project was really engaging. Definitely 5 stars!"
15 Jul 2024
Zhila S.
Software Engineer
"Enjoyed my first pikuma course!

Overall a positive learning experience. I was already familiar with the ECS architecture from watching Comp 4300 on youtube, so it was good to use this architecture again while learning new libraries like SDL and especially Dear imGUI and sol.

Some areas I feel could be improved : The audio quality is really bad, with annoying crackling sounds, but I managed to learn to ignore them. (A bit disappointing though given the price of the course.) While Professor Gustavo did highlight it himself several times, some of the coding decisions were not the most efficient choices. It was a bit odd that we refactored the component pools data structure in the middle of the course, which seemed like poor planning, but was also beneficial to get some 'real world' experience of having to make a significant code change on a project midway. I am also still unclear on what the alternative is to using C++ templates, since it was mentioned that some game studios ban them because they are inefficient, but we used them a significant amount in this course.

Now for the highlights : Great teacher that you can tell has a passion for the topic, which always makes learning fun! There's also an awesome community of students, it was nice to see the discussions in the lecture sidebars, with past students and even the professor remaining active to answer questions, despite this being one of the older courses. The online platform itself is very nice, it's easy to catch up where you left off and see your progress.

The quality of the content is impressive; I haven't seen any other online course that teaches you how to connect so many different technologies to build a little game engine, but the true test will be if I can manage to do the bonus map tool in C++ and SDL. :)

Thank you Professor Gustavo!"
08 Jul 2024
David Foster
"I wish this person can teach me everything my entire life! Perfect teacher, if teachers around the world were half as good the world problems would be solved."
04 Jul 2024
"Great course!"
03 Jul 2024
Ben _
"Great course! Wonderful course, goes over a lot of essential things in C++ but doesn't go too deep to make it its primary goal which is to create a game engine and introduce some of the major aspects of this area. If you read this and think about starting the course I immensely recommend, and have a small tip to give you for once you start - for every lecture you watch read the posts of other students at the end, they will help you both fix errors you might be having and sometimes even help you understand better some things that were shown in the lecture but you didn't quite fully understand yet(I know it happened to me a few times xD)."
20 Jun 2024

Other similar courses

3D Computer Graphics Programming

35 hours
  • Create a 3D software renderer from scratch using the C programming language.
raycasting texture c

Raycasting Engine Programming with C

18 hours
  • Write a raycasting engine with textures and sprites using the C programming language.

Game Physics Engine Programming

35 hours
  • Learn how to create a 2D rigid-body game physics engine from scratch with C++.