2D Engine from Scratch

Justin Martin

Home

Projects

About Me

Contact

Justin Martin

Gameplay Showcase — Video Placeholder

C/C++ — SDL2 & OPENGL

Custom Rendering Pipeline

View Code

WHAT IT DOES

A fully custom 2D game built without any existing game engine. The rendering pipeline draws every sprite directly through raw OpenGL calls, coordinated by a fixed-timestep game loop that keeps physics and logic deterministic regardless of frame rate.

HOW IT’S BUILT

Wrote a thin abstraction over SDL2 for window/input handling, with OpenGL owning all draw calls. GLSL shaders handle sprite batching and color effects, while manual memory management in C/C++ keeps allocations explicit and predictable.

TECHNOLOGIES

C / C++

SDL2

OpenGL

GLSL

Screenshot Placeholder

GIF Placeholder

C++ — RENDER LOOP

Close code

Game Loop

Renderer Init

Shader Bind

Example

1void Engine::Run()
2{
3    const double fixedDeltaTime = 1.0 / 60.0;
4    double accumulator = 0.0;
5    double lastTime = GetTime();
6 
7    while (m_isRunning)
8    {
9        double currentTime = GetTime();
10        double frameTime = currentTime - lastTime;
11        lastTime = currentTime;
12        accumulator += frameTime;
13 
14        ProcessInput();
15 
16        // Fixed-timestep updates keep physics deterministic
17        while (accumulator >= fixedDeltaTime)
18        {
19            UpdatePhysics(fixedDeltaTime);
20            UpdateLogic(fixedDeltaTime);
21            accumulator -= fixedDeltaTime;
22        }
23 
24        Render();
25        SDL_GL_SwapWindow(m_window);
26    }
27}

ARCHITECTURAL CHOICE

A fixed-timestep loop decouples simulation from rendering: physics and logic always advance in stable 1/60s steps, while rendering happens as fast as the display allows, keeping gameplay consistent across hardware.

Close code

Game Loop

Renderer Init

Shader Bind

Example

1void Engine::Run()
2{
3    const double fixedDeltaTime = 1.0 / 60.0;
4    double accumulator = 0.0;
5    double lastTime = GetTime();
6 
7    while (m_isRunning)
8    {
9        double currentTime = GetTime();
10        double frameTime = currentTime - lastTime;
11        lastTime = currentTime;
12        accumulator += frameTime;
13 
14        ProcessInput();
15 
16        // Fixed-timestep updates keep physics deterministic
17        while (accumulator >= fixedDeltaTime)
18        {
19            UpdatePhysics(fixedDeltaTime);
20            UpdateLogic(fixedDeltaTime);
21            accumulator -= fixedDeltaTime;
22        }
23 
24        Render();
25        SDL_GL_SwapWindow(m_window);
26    }
27}

ARCHITECTURAL CHOICE

Close code

Game Loop

Renderer Init

Shader Bind

Example

1void Engine::Run()
2{
3    const double fixedDeltaTime = 1.0 / 60.0;
4    double accumulator = 0.0;
5    double lastTime = GetTime();
6 
7    while (m_isRunning)
8    {
9        double currentTime = GetTime();
10        double frameTime = currentTime - lastTime;
11        lastTime = currentTime;
12        accumulator += frameTime;
13 
14        ProcessInput();
15 
16        // Fixed-timestep updates keep physics deterministic
17        while (accumulator >= fixedDeltaTime)
18        {
19            UpdatePhysics(fixedDeltaTime);
20            UpdateLogic(fixedDeltaTime);
21            accumulator -= fixedDeltaTime;
22        }
23 
24        Render();
25        SDL_GL_SwapWindow(m_window);
26    }
27}

ARCHITECTURAL CHOICE

ROLE & TIMELINE

Role: Solo Developer · Month Year – Month Year

CHALLENGES & SOLUTIONS

Without an engine, there is no built-in scene graph or asset pipeline — everything from texture loading to input polling had to be written and debugged manually. The biggest challenge was keeping the render loop stable across frame-rate spikes; solving it meant separating simulation time from render time entirely via the fixed-timestep architecture above.