SDL Resources

A quick tour of ten useful techniques in C++, covering dates, randomness, attributes and more

Learn how to create and customize windows, covering initialization, window management, and rendering

Step-by-step guide on creating the SDL2 application and event loops for interactive games

Learn to precisely control image display using source and destination rectangles.

Learn to render and manipulate text in SDL2 applications using the official SDL_ttf extension

Learn to create, render, and interact with basic rectangles using the SDL_Rect and SDL_Color types.

Discover how to organize SDL components using manager classes, inheritance, and polymorphism for cleaner code.

Learn to create interactive buttons in SDL2 and manage communication between different UI components.

An introduction to C++ package managers, and a step-by-step guide to installing vcpkg on Windows and Visual Studio.

Using Tick() functions to update game objects independently of events

An introduction to the SDL library, the problem it solves, and why we're using it to learn C++

Learn how to implement core snake game mechanics including movement, controls, and state management

Learn to load, manipulate, and save various image formats using SDL_Image.

Learn how to use callbacks with SDL_AddTimer() to provide functions that are executed on time-based intervals

Learn how to create and manage your own game-specific events using SDL's event system.

Implement win/loss detection and add a restart feature to complete the game loop

Implement flag placement and tracking to complete your Minesweeper project.

Learn how to manage multiple windows, and practical examples using utility windows.

Updating our TransformComponent and ImageComponent to support positioning and rendering

Integrate basic physics simulation into entities using a dedicated component

Enable entities to detect collisions using bounding boxes managed by a dedicated component.

Make entities react realistically to collisions, stopping, bouncing, and interacting based on type.

Begin building a Breakout clone by integrating our level editor and engine into a new game project.

This lesson focuses on creating the Ball class, customizing our physics engine, and launching the ball.

We'll add invisible walls around the play area and write the collision response code to make the ball bounce.

We'll build the player's paddle, hook it up to keyboard controls, and keep it from moving off-screen.

We'll add detailed collision logic to the paddle, giving the player control over the ball's trajectory.

Add breakable bricks to the game by loading and parsing level files saved from our level editor.

Implement the core gameplay loop of destroying blocks and advancing through levels using SDL events.

Learn to manage game states for winning, losing, and pausing, and prepare the final game for distribution.

Learn to create flexible game entities using the Type Object pattern for data-driven design.

Learn to load game object types and instances from external text files

Establish the core structure for our level editor, including window, scene, and asset management.

This lesson focuses on creating the UI panel for Actors and adding the first concrete Actor type.

Implement clicking and dragging actors from the menu, showing a tooltip that follows the mouse cursor.

Build the level container, add logic for placing actors via drag-and-drop, including visual hints.

Add core interactions: drag actors to reposition them, click to select, and press delete to remove them.

Convert the freeform placement to a grid-based system with snapping and single-actor cell limits

Implement footer buttons and binary serialization to save and load your custom game levels to disk.

Complete the save/load cycle by implementing level deserialization using SDL_RWops and actor factories.

Create the C++ framework for adding, retrieving, and removing components from game entities.

Discover how to process mouse input, including position tracking and button presses

A step-by-step tutorial on configuring SDL2, SDL_image and SDL_ttf in a Visual Studio C++ project on Windows

This step-by-step guide shows you how to set up SDL2 in an Xcode or CMake project on macOS

A step-by-step guide on setting up SDL2 and useful extensions in a project that uses CMake as its build system

This guide walks you through the process of compiling SDL2, SDL_image, and SDL_ttf libraries from source

Explore SDL surfaces, the canvases for drawing, understand pixel formats, colors, and set your window's background.

Discover techniques for detecting and responding to SDL runtime errors

Learn the essentials of double buffering in C++ with practical examples and SDL2 specifics to improve your graphics projects

Learn to implement coordinate space conversions in C++ to position game objects correctly on screen.

Learn how to handle floating point precision issues when programming game physics and transformations between coordinate spaces.

Create camera systems that follow characters, respond to player input, and properly frame your game scenes.

Implement player controls and AI actions cleanly using the Command pattern

Learn how composition helps build complex objects by combining smaller components

Explore component communication, dependency management, and specialized entity types within your ECS

Display graphics by creating an ImageComponent that loads files and renders them via SDL_image.

Optimize image loading using shared pointers and an asset manager for better memory use and simpler code.

Add width, height, and scaling modes to our entities and images

Discover bounding boxes: what they are, why we use them, and how to create them

Optimize games by checking object intersections with functions like SDL_HasIntersection().

Implement bounding box collision detection and response between game objects

Learn the basics of writing and using functions in C++, including syntax, parameters, return types, and scope rules.

A quick introduction to namespaces in C++, alongside the standard library and how we can access it

Learn the fundamentals of controlling program flow in C++ using if statements, for loops, while loops, continue, and break

A crash tour on how we can create custom types in C++ using classes, structs and enums

Learn the fundamentals of the C++ build process, including the roles of the preprocessor, compiler, and linker.

Learn the fundamentals of references, pointers, and the const keyword in C++ programming.

Discover operator overloading, allowing us to define custom behavior for operators when used with our custom types

Learn how to write flexible and extensible C++ code using polymorphism, virtual functions, and dynamic casting

Learn the foundations of vector math to work with positions and movements, and create a custom type to apply these concepts

Create realistic object movement by applying fundamental physics concepts

Learn how to implement realistic forces like gravity, friction, and drag in our physics simulations

Add explosions and jumping to your game by mastering momentum-based impulse forces

Learn the fundamentals of C++ programming: declaring variables, using built-in data types, and performing operations with operators

Learn how to control display brightness and gamma correction using SDL's window management functions

Create a scene management system that converts world space coordinates to screen space for 2D games.

Explore how to use vectors for representing positions, directions, and implementing speed-limited movement in games.

Learn how C++ represents numbers and data in memory using binary, decimal, and hexadecimal systems.

Understand the math foundations needed for game programming in C++, including power and root functions.

Learn the fundamentals of coordinate systems and vectors to create spatial representations

Learn key geometry concepts like angles, triangles, and vectors to implement distance calculations.

Introducing the foundational components for our game and setting up the project

Build the foundational grid structure that will power our Snake game's movement and collision systems.

Allowing our snake to eat apples, and grow longer each time it does

Giving our Snake game the ability to pause itself, and adding a clickable button for restarting the game

Add game-ending logic to our Snake game with custom events, state management, and visual cues for player feedback.

Build a dynamic score counter that tracks the player's progress and displays it with custom graphics and text.

Learn to animate the snake's movement across cells for a smooth, dynamic visual effect.

Learn how to control cursor visibility, switch between default system cursors, and create custom cursors

Learn how to read, parse, and use config files in your game using std::string and SDL_RWops

Learn to write and append data to files using SDL2's I/O functions.

Learn how to manipulate the read/write offset of an SDL_RWops object to control stream interactions.

Learn how to track mouse movements and button states across your entire application, even when the mouse leaves your window.

Learn techniques for managing game data, including save systems, configuration, and networked multiplayer.

Learn how to handle byte order in using SDL's endianness functions

Learn how memory alignment affects data serialization and how to handle it safely

Learn how to create and manage fullscreen windows in SDL, including desktop and exclusive fullscreen modes.

Learn how to manage screen resolutions and refresh rates in SDL games using display modes.

Learn how to create SDL applications that look great on modern displays across different platforms

An introduction to managing SDL2 window decorations, borders, and client areas.

Learn how to set, get, and update window titles dynamically

Discover how to use SDL2 functions for controlling and retrieving window transparency settings.

Learn how to handle multiple monitors in SDL, including creating windows on specific displays.

Explore window creation, configuration, and event handling using SDL's windowing system

Discover how to monitor and respond to window state changes in SDL applications

Learn how to control and monitor the position of SDL windows on screen

Learn how to resize, constrain, and manage SDL2 windows

Learn how to control the visibility of SDL2 windows, including showing, hiding, minimizing, and more

Implement mouse constraints in SDL2 to control cursor movement using window grabs and rectangular bounds

Learn how to restrict cursor movement to a window whilst capturing mouse motion continuously.

Learn how to detect and respond to keyboard input events in your SDL-based applications. This lesson covers key events, key codes, and modifier keys.

Learn how to manage and control window input focus in SDL applications, including how to create, detect, and manipulate window focus states.

Learn how to detect and handle keyboard input in SDL2 using both event-driven and polling methods. This lesson covers obtaining and interpreting the keyboard state array.

Learn how to detect and handle mouse scroll wheel events in SDL2, including vertical and horizontal scrolling, as well as scroll wheel button events.

Learn how to track and respond to mouse focus events in SDL2, including handling multiple windows and customizing focus-related click behavior.

Learn how to monitor mouse position and button states in real-time using SDL's state query functions

An overview of the options we have for building flexible notification systems between game components

Learn how to create smooth, time-aware game loops that behave consistently across different hardware configurations

Learn to measure time intervals with high accuracy in your games

Learn to create flexible and modular code with function pointers

Explore advanced techniques for working with class member functions

Learn how to read and parse game data stored in external files using SDL_RWops

An introduction to the generic engine classes we'll use to create the game

Learn how to load, display, and optimize image rendering in your applications

Learn techniques for scaling images and working with aspect ratios

Explore advanced techniques for optimizing and controlling text rendering when using SDL_ttf

Building a two-dimensional grid of interactive minesweeper cells

Updating the game to to place bombs randomly in the grid and render them when cells are cleared.

Implement the techniques for detecting nearby bombs and clearing empty cells automatically.