Build a 2D & 3D Game Engine with C++20, SFML & OpenGL

Explore Sfml three, a simple, fast multimedia library for 2d c++17 apps, offering windows, text, shapes, input, textures, sound, and networking.

Create a hello SFML project, fetch SFML via CMake from GitHub, build the graphics module, and run to confirm a green circle appears.

Create and configure a window with SFML render window, set size 600 by 800 and a title, run a game loop with event handling, and render with clear and display.

learn how SFML handles events via an event queue, using a non-blocking poll loop to read key presses, mouse actions, resizes, and focus changes in an event driven model.

Implement event visitation to simplify the SFML event loop by moving each event into its own handle_event function and using the event's visit with a lambda to dispatch to overloads.

Refactor your project by encapsulating window management, event handling, updating, and rendering into a dedicated application class, centralizing the game loop for a cleaner, modular 2D engine in SFML.

Create and render basic 2D shapes in SFML by using rectangle and circle shapes, customizing color, outline, and position, and building a convex shape for custom polygons.

Load textures from files with Sfml, attach them to shapes or sprites whose size comes from the texture, keep textures alive for performance, and apply color tint and smoothing.

Explore real-time keyboard and mouse input in SFML, using events for single actions and pooling for continuous movement, plus keycodes vs scancodes and basic cursor control.

Learn to move, rotate, and scale objects in SFML using Transformable, center origins for natural transformations, and read positions, rotations, and scales, with delta time to keep motion consistent.

Measure time with the SPH clock and convert elapsed time to seconds. Use delta time to keep movement, rotation, and scaling consistent across frame rates.

Detect collisions using axis-aligned bounding boxes (AaBb) by accessing getGlobalBounds and intersecting rectangles. Update player movement, block overlap by restoring position, and visually signal collisions with color changes.

Learn to display and style text in SFML: load fonts, create text objects, apply size, color, and effects, and update on-screen content like FPS and scores.

Load and play sounds and music in SFML, using sf::SoundBuffer and sf::Sound for short effects, and sf::Music for streaming long tracks, with controls for volume, pitch, looping, and real-time playback.

Learn to use SFML view to control the visible game world, enabling camera follow and zoom. Center the view on the player and render accordingly.

Conclude by integrating window creation, drawing, input, text, audio, movement, time, and camera control with SFML to build a complete 2D game. Move from isolated examples to designing mechanics, organizing the project, managing assets, and writing core gameplay logic.

Build your first game in modern C++ with SFML—a bounce game with a paddle, bouncing balls, score, sound effects, and background music; set up CMake fetch content and VSCode.

Organize your game by creating a dedicated game class to manage the game loop with process events, update, and render using the SFML render window, enabling a clean, modular design.

Create a player paddle with SFML, set size and origin, render it, and move it with arrow keys using delta time while clamping to the window.

Add a ball that bounces around the screen with a normalized direction and 250 px/s speed. The cyan circle, radius 10, starts centered and reverses direction on edge collisions.

Implement ball–paddle collision detection via bounding boxes and a collision handler; spawn multiple balls with random directions for a 2D SFML game engine in modern C++.

Create a dedicated game stats class to manage score and lives, including font-backed on-screen text, setters and getters, and a restart mechanic when lives reach zero.

Create a game audio system with a dedicated Game Sounds class using SFML audio to manage background music and bounce sound effects, and add a background image for a scene.

Add a persistent high score saved to a text file and centralize game settings in a config struct, updating and loading values across the game with SFML.

Build a modular, reusable 2D game engine in modern C++ with SFML, organizing window, rendering, input, resources, scenes, and GUI managers through a central engine context.

Set up the arcade engine project from scratch by creating engine folder for code with a content folder, subfolders core, managers, graphics, scene, utils, and Main.cpp, using sfml and cmake.

Create an engine class to power a 2d game in modern c++ with sfml, set up the main window and game loop, and handle events, updates, and rendering in core.

Design a clean, scalable event system for the engine using a SFML visitor to separate event detection from actions, keeping the loop minimal and centralizing logic in private engine methods.

Define a flexible engine config using a JSON file, centralizing window title and size in an engine_config struct; read Config.json with the Ellemann-jensen library and access values at runtime.

Add a lightweight logging system using speed log to track engine events, debug output, and performance, with cmake fetch speed log and a utils log header.

Create a shared engine context to organize core systems, acting as a container for managers like audio input, rendering, and gui scenes, enabling modular, easily passable access across the engine.

Add a random manager to the engine context to generate numbers, positions, directions, and colors with a Mersenne Twister seeded by a random device.

Implement a time manager to track delta time and elapsed time, clamp delta time with a max value from config, and allow the engine to update it each frame.

Create a save manager that stores and loads data via JSON files, preserving scores, unlock levels, and player settings; it auto-saves on shutdown using a constructor and destructor.

Add a clipboard manager to the 2D game engine, exposing setString and getString to access the system clipboard via the SFML clipboard API, enabling text copy, paste, and menu input.

Create a centralized resource manager to load and reuse textures, sounds, fonts, and music, storing each in hash maps from file names and providing on-demand fetch methods with optional music.

Implement an audio manager to control global volume and 3d sound settings with SFML, using vector3 positions, listener position and direction for spatial audio in a 2d engine.

Define input types and set up gamepad mappings for a flexible input manager that binds actions, using keyboard, mouse, and axis with a threshold, including PlayStation and Xbox mappings.

Develop a flexible input manager that binds actions to keyboard keys, mouse buttons, gamepad inputs, and axes using a multimap and variant-based dispatch for unified input handling.

Build a render manager that draws to an offscreen texture, then renders that texture via a sprite to the window for a controlled pipeline and future shader effects.

Create a screenshot manager that captures the render window, saves a timestamped PNG to content/screenshots, and triggers via Ctrl+Shift+S, with engine integration and logging.

Develop a configurable SFML cursor manager that works with mouse and gamepad, drawing a customizable circle, with joystick deadzone handling and bounds clamping inside the window.

Set up the Ptgui gui library on top of sfml to power the engine's gui manager and its widgets. Configure theming, fonts, and input handling to enable responsive widget interaction.

Add a scene manager to control active game scene, with next_scene optional and fetch logic to switch or restart, integrating with the engine to handle scene change and menu return.

Create a base scene class and inheritance to organize each game—from menu to space invader scenes—with entities, logic, and settings, using the engine context and virtual update and render methods.

Implement a lightweight cooldown class using the SFML clock to cap action frequency, with a timer and duration, and methods to start, stop, restart, set/get duration, and get elapsed time.

Add a small verify macro to make code safer in both debug and release builds, using assert in debug and void in release to ensure execution and avoid unused warnings.

Learn how to build a reusable scene utilities header in C++ with SFML, including inline helper functions for bounds checks, intersection, distance, contains tests, lerp, and a global default font.

Build a scene factory that creates and registers all scenes in a single unordered map owned by the engine, using unique_ptr and enabling update, render, event handling, and scene switching.

The overlay adds a pause menu over the game with a darkened background and four buttons, including resume and quit, accessible via escape or the controller.

Rebuild bounce inside the arcade engine as a modular scene, using a centralized config and types structure, with input, rendering, audio, and save system for a reusable game template.

Learn how to add post-processing effects to your engine using shaders, integrating a render manager pipeline, and chaining invert, glitch, bloom, and monitor filters with time-based animation.

Add a focus check to the engine to pause updates when the window is not focused, reducing CPU usage with a small sleep in the main loop.

Complete the 2D game engine, turning simple ideas into a solid, flexible framework that handles window input, audio, time-saving GUI, and scenes for real games.

Use the engine to build complete 2D games, exploring new mechanics and technical challenges as the library expands with regular new projects.

Build a fast reaction clicker inside the arcade engine, featuring a teleporting target, a 20-second timer, and score-driven gameplay with best time saved.

Create a memory game with face-down color cards that players flip to reveal and match, using a mismatch cooldown and increasing levels that add more cards.

Build a tic tac toe game on a 3x3 grid where the player X competes against an AI O. Implement two player play, an AI, and a restart cooldown.

Create an eight by eight minesweeper game that reveals cells, shows adjacent mine counts, expands zero areas, supports flags, and restarts after a win or loss.

Create a 2d side-scrolling runner using jumping, crouching, and fast-falling mechanics. Obstacles spawn from the right and move left as speed rises from 200 to 800, with a distance counter.

Build a Tetris game in a C++20 SFML engine by implementing tetromino shapes, rotations, and line clears on a 10 by 20 grid, with scoring, cooldowns, and a next-piece system.

Build a Pong game in a C++20 SFML engine, configuring two paddles and a ball, with player or AI control, collision-based bouncing, scoring to a target, and visual center line.

Build the breakout arcade game by configuring paddle, ball, bricks, and bonuses, including magnet effects. Register the game in the scene factory and implement update, render, and collisions.

Builds a Flappy Bird clone and extends it with a genetic algorithm that evolves a population of birds by mutating weights, improving survival and score across generations.

Build a 4x4 2048 puzzle in SFML with C++20, using config, types, header, source, and registering in the scene factory. Animate tile moves and merges toward 2048, with new tiles.

Create a menu scene that presents a grid of buttons, each loading a scene by name and revealing a controls overlay via right-click or gamepad.