Action Queue & Cutscene System with SDL3 Callbacks, cglm, and OpenGL Система очереди действий и кат-сцен с SDL3 Callbacks, cglm и OpenGL

A beginner-friendly guide to implementing the Action / Command Queue Pattern in modern C++ (C++20) using the official SDL3 Callbacks API, cglm for orthographic projection, view, and MVP matrix math, and OpenGL. Learn how to sequence animations, smoothly interpolate transformations (Lerp), and create organic pulsing effects using sine wave trigonometry. Руководство для начинающих по реализации паттерна очереди действий/команд (Action / Command Queue) на современном C++ (C++20) с использованием официального SDL3 Callbacks API, библиотеки cglm для вычисления ортографической проекции, видовой матрицы и матрицы MVP, а также OpenGL. Узнайте, как выстраивать цепочки анимаций, плавно интерполировать трансформации (Lerp) и создавать органичный эффект пульсации с помощью тригонометрии синуса.

Pattern Overview Обзор паттерна

This code implements an Action Queue / Command Pattern commonly used in game engines (similar to Tweens in Godot/Unity or Actions in Cocos2d) to chain animations and scripted cutscenes sequentially without spaghetti state machines. Этот код реализует паттерн Action Queue / Command, широко применяемый в игровых движках (аналог Tweens в Godot/Unity или Actions в Cocos2d) для последовательного выстраивания анимаций и скриптовых кат-сцен без громоздких конечных автоматов.

Why the SDL3 Callbacks API & cglm? Почему именно SDL3 Callbacks API и cglm?

SDL3 Callbacks API (SDL_AppInit, SDL_AppIterate, SDL_AppEvent, SDL_AppQuit) is the official cross-platform standard in SDL3, guaranteeing seamless execution across Desktop, Mobile, and WebAssembly. Combined with cglm (a lightweight, blazing-fast mathematics library), we construct orthographic (glm_ortho), view (glm_lookat), and model transformations directly into a final uMVP matrix sent to the shader. SDL3 Callbacks API (SDL_AppInit, SDL_AppIterate, SDL_AppEvent, SDL_AppQuit) — это официальный кроссплатформенный стандарт в SDL3, гарантирующий работу на Desktop, Mobile и WebAssembly. В связке с cglm (легковесной и быстрой математической библиотекой) мы рассчитываем ортографическую проекцию (glm_ortho), камеру (glm_lookat) и трансформации модели в единую матрицу uMVP, передаваемую в шейдер.

Core Architecture: In-Depth Class Breakdown Основная архитектура: подробный разбор классов

1. enum class ActionStatus

enum class ActionStatus {
    Running,
    Finished
};
  • Purpose:Назначение: A strongly-typed state return for each action. Строго типизированный возврат статуса для каждого действия.
  • Role:Роль: Tells the ActionQueue whether the current action is still running or has completed its work and should be discarded. Сообщает ActionQueue, выполняется ли ещё текущее действие или оно завершило свою работу и должно быть удалено из очереди.

2. class Action (The Abstract Base Class)

class Action {
public:
    virtual ~Action() = default;
    virtual void on_start() {}
    virtual ActionStatus update(float dt) = 0;
};

Purpose:Назначение: The interface / contract representing any timed or progressive task. Базовый интерфейс/контракт, представляющий любую задачу, распределённую по времени.

Key Components: Ключевые компоненты:

  • virtual ~Action() = default;: Ensures that when derived classes held by std::unique_ptr<Action> are deleted, their specific destructors are invoked properly (preventing memory leaks). Гарантирует, что при удалении производных классов, управляемых std::unique_ptr<Action>, корректно вызывается их деструктор (предотвращая утечки памяти).
  • virtual void on_start(): An optional lifecycle hook called only once on the very first frame the action begins executing. This is crucial for capturing initial states (e.g., current angle or color) at runtime rather than when the action is created. Опциональный хук жизненного цикла, вызываемый ровно один раз в самый первый кадр начала выполнения действия. Он необходим для фиксации начального состояния (например, текущего угла или цвета) в рантайме, а не в момент создания объекта.
  • virtual ActionStatus update(float dt) = 0;: Pure virtual function. Every derived action must implement how it progresses over a delta-time step (dt). It returns ActionStatus::Running while active and ActionStatus::Finished when done. Чисто виртуальная функция. Каждое производное действие обязано реализовать изменение своего состояния за дельта-тайм (dt). Возвращает ActionStatus::Running во время работы и ActionStatus::Finished по завершении.

3. class ActionQueue (The Sequencer / Manager)

class ActionQueue {
public:
    void push(std::unique_ptr<Action> action);
    void update(float dt);
    bool is_empty() const;
    void clear();

private:
    std::deque<std::unique_ptr<Action>> queue;
    bool started = false;
};

Purpose:Назначение: Manages a FIFO (First-In, First-Out) sequential pipeline of polymorphic actions. Управляет последовательным конвейером полиморфных действий по принципу FIFO (первым пришел — первым ушел).

Key Mechanisms: Ключевые механизмы:

  • std::deque<std::unique_ptr<Action>>: Holds ownership of the actions. std::unique_ptr guarantees that each action is automatically deleted from memory as soon as it is popped. Владеет действиями. std::unique_ptr гарантирует, что каждый экземпляр действия автоматически удаляется из памяти сразу после извлечения из очереди.
  • push(std::unique_ptr<Action> action): Adds a new action to the back of the queue using std::move. Добавляет новое действие в конец очереди с помощью std::move.
  • update(float dt):
    • Returns immediately if the queue is empty.Немедленно возвращает управление, если очередь пуста.
    • If !started, triggers on_start() on the action at the front of the queue, then sets started = true.Если !started, вызывает on_start() у первого действия в очереди и устанавливает started = true.
    • Calls queue.front()->update(dt).Вызывает queue.front()->update(dt).
    • When update(dt) returns ActionStatus::Finished, it calls queue.pop_front() (deleting the action) and resets started = false, so the next action in line will have its on_start() invoked on the next frame.Когда update(dt) возвращает ActionStatus::Finished, вызывается queue.pop_front() (удаляя действие) и сбрасывается started = false, чтобы у следующего действия в очереди на следующем кадре сработал on_start().
  • is_empty() & clear(): Utility methods to inspect or flush the queue. Вспомогательные методы для проверки на пустоту и полной очистки очереди.

4. struct AppState (The Context / Data Store)

struct AppState {
    SDL_Window* window = nullptr;
    SDL_GLContext glContext = nullptr;

    GLuint shaderProgram = 0;
    GLuint VAO = 0;
    GLuint VBO = 0;
    GLint uMVPLoc = -1;

    // Transformation variables modified by our Action Queue
    float rotationAngle = 0.0f; // in radians
    float scale = 1.0f;
    float clearColor[3] = { 0.12f, 0.12f, 0.15f };

    uint64_t lastTicks = 0;
    ActionQueue actionQueue;
};
  • Purpose:Назначение: The central data structure holding the graphics state, window handles, render uniforms, and the ActionQueue itself. Центральная структура данных, хранящая графические дескрипторы, контекст окна, униформы шейдеров и саму ActionQueue.
  • Role with Actions:Связь с действиями: A pointer to AppState (AppState*) is passed into each concrete action so the action can directly manipulate the shared animation properties (rotationAngle, scale, clearColor). Указатель на AppState (AppState*) передаётся в каждое конкретное действие, позволяя ему напрямую изменять разделяемые анимируемые параметры (rotationAngle, scale, clearColor).

5. Concrete Action Classes

Each concrete action inherits from Action and implements a specific animation behavior: Каждое конкретное действие наследуется от Action и реализует заданное поведение анимации:

A. RotateAction (Linear Interpolation / Lerp)
  • Constructor:Конструктор: Takes target angle (targetAngleRad) and duration.Принимает целевой угол (targetAngleRad) и длительность duration.
  • on_start(): Reads current state->rotationAngle as startAngle. This ensures smooth continuity even if previous rotations left the object at an arbitrary angle.Запоминает текущий state->rotationAngle как startAngle. Это гарантирует непрерывность, даже если предыдущее вращение завершилось под произвольным углом.
  • update(float dt):
    • Accumulates elapsed time: elapsed += dt.Накапливает прошедшее время: elapsed += dt.
    • Normalizes time t ∈ [0.0, 1.0]: t = min(1.0f, elapsed / duration).Нормализует время t ∈ [0.0, 1.0]: t = min(1.0f, elapsed / duration).
    • Interpolates: state->rotationAngle = startAngle + (target - startAngle) * t.Интерполирует: state->rotationAngle = startAngle + (target - startAngle) * t.
    • Returns Finished once t ≥ 1.0f.Возвращает Finished, как только t ≥ 1.0f.
B. PulseAction (Mathematical / Sinusoidal Wave)
  • Constructor:Конструктор: Takes maxScale and duration.Принимает maxScale и длительность duration.
  • update(float dt):

    Uses the half-period of a sine wave: state->scale = 1.0f + (maxScale - 1.0f) * std::sin(t * 3.14159265f); where t ∈ [0.0, 1.0].Использует полупериод синусоиды: state->scale = 1.0f + (maxScale - 1.0f) * std::sin(t * 3.14159265f); где t ∈ [0.0, 1.0].

    • At t = 0.0: sin(0) = 0.0 → scale = 1.0 (Original sizeИсходный размер)
    • At t = 0.5: sin(π / 2) = 1.0 → scale = maxScale (Peak scaleПиковый масштаб)
    • At t = 1.0: sin(π) = 0.0 → scale = 1.0 (Original sizeИсходный размер)
    Smoothly scales up and down back to original size in a single action. Плавно увеличивает и уменьшает объект обратно до исходного размера в рамках одного действия.
C. FadeColorAction (RGB Vector Interpolation)
  • Constructor:Конструктор: Takes target RGB values (targetR, targetG, targetB) and duration.Принимает целевые значения цвета RGB (targetR, targetG, targetB) и duration.
  • on_start(): Captures current background colors: startR = state->clearColor[0], etc.Фиксирует текущий цвет фона: startR = state->clearColor[0] и т.д.
  • update(float dt): Simultaneously lerps each of the red, green, and blue components from their starting values to the target values over duration.Синхронно интерполирует каждую из составляющих (красную, зелёную и синюю) от начальных к целевым значениям за время duration.

How They Tie Together in the Game Loop Связка компонентов в игровом цикле

[setupCutscene(state)]
    Pushes: RotateAction -> PulseAction -> FadeColorAction -> RotateAction -> FadeColorAction

[Every Frame in SDL_AppIterate()]
    1. dt = (currentTicks - lastTicks)
    2. state->actionQueue.update(dt)
       ├── Frame 1 of an Action: calls on_start()
       ├── Every Frame: calls update(dt) -> modifies state->rotationAngle, scale, or clearColor
       └── Last Frame: returns Finished -> ActionQueue pops it -> moves to next
    3. If actionQueue.is_empty(), setupCutscene(state) is called again to loop.
    4. cglm calculates ortho, view, model -> multiplies into uMVP.
    5. Render pipeline passes uMVP and draws geometry.

Architectural Highlights Ключевые преимущества архитектуры

  • Separation of Concerns:Разделение ответственности: Rendering logic in SDL_AppIterate doesn't care how properties change; it just transforms and draws whatever values are stored in AppState. Логика отрисовки в SDL_AppIterate не заботится о том, как меняются параметры; она просто трансформирует и рисует актуальные значения из AppState.
  • Extensibility:Расширяемость: Adding new actions (e.g., TranslateAction, WaitAction, PlaySoundAction) requires only subclassing Action without altering ActionQueue or OpenGL rendering code. Добавление новых действий (например, TranslateAction, WaitAction, PlaySoundAction) требует лишь создания нового наследника Action без изменения ActionQueue или кода рендеринга.
  • Safe Memory Management:Безопасное управление памятью: Using std::unique_ptr with std::deque eliminates manual new/delete calls for dynamic action instances. Использование std::unique_ptr вместе с std::deque полностью исключает ручные вызовы new/delete для динамических экземпляров действий.

Step 1: Create Project Directory Structure Шаг 1: Создание структуры директории проекта

Create your workspace directory for the project and a src subdirectory for C++ source files: Создайте рабочую директорию проекта и подпапку src для исходных файлов C++:

Windows (Command Prompt / PowerShell)

mkdir C:\projects\action-queue-cutscene-sdl3-opengl-desktop
mkdir C:\projects\action-queue-cutscene-sdl3-opengl-desktop\src
cd C:\projects\action-queue-cutscene-sdl3-opengl-desktop

Ubuntu / WSL (Terminal)

mkdir -p ~/projects/action-queue-cutscene-sdl3-opengl-desktop/src
cd ~/projects/action-queue-cutscene-sdl3-opengl-desktop

Step 2: Create Source Files (src/main.cpp & CMakeLists.txt) Шаг 2: Создание исходных файлов (src/main.cpp и CMakeLists.txt)

Windows (Terminal / Notepad)

notepad src\main.cpp
notepad CMakeLists.txt

Ubuntu (Terminal / Nano)

nano src/main.cpp
nano CMakeLists.txt

1. File Contents for src/main.cpp (SDL3 Callbacks API + cglm) 1. Содержимое файла src/main.cpp (SDL3 Callbacks API + cglm)

#define SDL_MAIN_USE_CALLBACKS 1
#include <glad/glad.h>
#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <cglm/cglm.h>

#include <vector>
#include <deque>
#include <memory>
#include <cmath>
#include <algorithm>

// ============================================================================
// Action / Command Queue System
// ============================================================================

enum class ActionStatus {
    Running,
    Finished
};

class Action {
public:
    virtual ~Action() = default;
    virtual void on_start() {}
    virtual ActionStatus update(float dt) = 0;
};

class ActionQueue {
public:
    void push(std::unique_ptr<Action> action) {
        queue.push_back(std::move(action));
    }

    void update(float dt) {
        if (queue.empty()) return;

        if (!started) {
            queue.front()->on_start();
            started = true;
        }

        if (queue.front()->update(dt) == ActionStatus::Finished) {
            queue.pop_front();
            started = false; // Next action will call on_start() on next frame
        }
    }

    bool is_empty() const { return queue.empty(); }
    void clear() { queue.clear(); started = false; }

private:
    std::deque<std::unique_ptr<Action>> queue;
    bool started = false;
};

// ============================================================================
// Application & Render State
// ============================================================================

struct AppState {
    SDL_Window* window = nullptr;
    SDL_GLContext glContext = nullptr;

    GLuint shaderProgram = 0;
    GLuint VAO = 0;
    GLuint VBO = 0;
    GLint uMVPLoc = -1;

    // Transformation variables modified by our Action Queue
    float rotationAngle = 0.0f; // in radians
    float scale = 1.0f;
    float clearColor[3] = { 0.12f, 0.12f, 0.15f };

    uint64_t lastTicks = 0;
    ActionQueue actionQueue;
};

// ============================================================================
// Concrete Cutscene Actions
// ============================================================================

class RotateAction : public Action {
public:
    RotateAction(AppState* state, float targetAngleRad, float duration)
        : state(state), target(targetAngleRad), duration(duration) {}

    void on_start() override {
        startAngle = state->rotationAngle;
        elapsed = 0.0f;
    }

    ActionStatus update(float dt) override {
        elapsed += dt;
        float t = (duration > 0.0f) ? std::min(1.0f, elapsed / duration) : 1.0f;
        state->rotationAngle = startAngle + (target - startAngle) * t;
        return (t >= 1.0f) ? ActionStatus::Finished : ActionStatus::Running;
    }

private:
    AppState* state;
    float startAngle = 0.0f;
    float target;
    float duration;
    float elapsed = 0.0f;
};

class PulseAction : public Action {
public:
    PulseAction(AppState* state, float maxScale, float duration)
        : state(state), maxScale(maxScale), duration(duration) {}

    ActionStatus update(float dt) override {
        elapsed += dt;
        float t = std::min(1.0f, elapsed / duration);
        state->scale = 1.0f + (maxScale - 1.0f) * std::sin(t * 3.14159265f);
        return (t >= 1.0f) ? ActionStatus::Finished : ActionStatus::Running;
    }

private:
    AppState* state;
    float maxScale;
    float duration;
    float elapsed = 0.0f;
};

class FadeColorAction : public Action {
public:
    FadeColorAction(AppState* state, float r, float g, float b, float duration)
        : state(state), targetR(r), targetG(g), targetB(b), duration(duration) {}

    void on_start() override {
        startR = state->clearColor[0];
        startG = state->clearColor[1];
        startB = state->clearColor[2];
        elapsed = 0.0f;
    }

    ActionStatus update(float dt) override {
        elapsed += dt;
        float t = (duration > 0.0f) ? std::min(1.0f, elapsed / duration) : 1.0f;
        state->clearColor[0] = startR + (targetR - startR) * t;
        state->clearColor[1] = startG + (targetG - startG) * t;
        state->clearColor[2] = startB + (targetB - startB) * t;
        return (t >= 1.0f) ? ActionStatus::Finished : ActionStatus::Running;
    }

private:
    AppState* state;
    float startR = 0, startG = 0, startB = 0;
    float targetR, targetG, targetB;
    float duration;
    float elapsed = 0.0f;
};

static void setupCutscene(AppState* state) {
    // Step 1: Rotate 360 degrees (2*PI) in 1.5 seconds
    state->actionQueue.push(std::make_unique<RotateAction>(state, 6.2831853f, 1.5f));

    // Step 2: Pulse scale up to 1.8x and back in 1.0 second
    state->actionQueue.push(std::make_unique<PulseAction>(state, 1.8f, 1.0f));

    // Step 3: Shift background to vibrant purple over 1.0 second
    state->actionQueue.push(std::make_unique<FadeColorAction>(state, 0.35f, 0.10f, 0.45f, 1.0f));

    // Step 4: Rotate back to 0 in 1.2 seconds
    state->actionQueue.push(std::make_unique<RotateAction>(state, 0.0f, 1.2f));

    // Step 5: Shift background back to dark slate in 1.0 second
    state->actionQueue.push(std::make_unique<FadeColorAction>(state, 0.12f, 0.12f, 0.15f, 1.0f));
}

// ============================================================================
// OpenGL Shaders
// ============================================================================

const char* vertexShaderSource = 
    "#version 330 core\n"
    "layout (location = 0) in vec2 aPos;\n"
    "layout (location = 1) in vec3 aColor;\n"
    "uniform mat4 uMVP;\n"
    "out vec3 vColor;\n"
    "void main() {\n"
    "    gl_Position = uMVP * vec4(aPos, 0.0, 1.0);\n"
    "    vColor = aColor;\n"
    "}\0";

const char* fragmentShaderSource = 
    "#version 330 core\n"
    "in vec3 vColor;\n"
    "out vec4 FragColor;\n"
    "void main() {\n"
    "    FragColor = vec4(vColor, 1.0);\n"
    "}\0";

static GLuint compileShader(GLenum type, const char* source) {
    GLuint shader = glCreateShader(type);
    glShaderSource(shader, 1, &source, nullptr);
    glCompileShader(shader);
    return shader;
}

// ============================================================================
// SDL3 Callbacks
// ============================================================================

SDL_AppResult SDL_AppInit(void** appstate, int argc, char* argv[]) {
    if (!SDL_Init(SDL_INIT_VIDEO)) {
        SDL_Log("Unable to initialize SDL: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    auto* state = new AppState();
    *appstate = state;

    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

    state->window = SDL_CreateWindow(
        "Action Queue Cutscene Demo (SDL3 Callbacks + cglm)",
        800, 600,
        SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE
    );

    if (!state->window) {
        SDL_Log("Failed to create window: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    state->glContext = SDL_GL_CreateContext(state->window);
    if (!state->glContext) {
        SDL_Log("Failed to create OpenGL context: %s", SDL_GetError());
        return SDL_APP_FAILURE;
    }

    SDL_GL_MakeCurrent(state->window, state->glContext);
    SDL_GL_SetSwapInterval(1);

    if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress)) {
        SDL_Log("Failed to initialize GLAD");
        return SDL_APP_FAILURE;
    }

    GLuint vs = compileShader(GL_VERTEX_SHADER, vertexShaderSource);
    GLuint fs = compileShader(GL_FRAGMENT_SHADER, fragmentShaderSource);

    state->shaderProgram = glCreateProgram();
    glAttachShader(state->shaderProgram, vs);
    glAttachShader(state->shaderProgram, fs);
    glLinkProgram(state->shaderProgram);

    glDeleteShader(vs);
    glDeleteShader(fs);

    state->uMVPLoc = glGetUniformLocation(state->shaderProgram, "uMVP");

    float vertices[] = {
         0.0f,  0.5f,   1.0f, 0.2f, 0.2f, // top (red)
        -0.5f, -0.5f,   0.2f, 1.0f, 0.2f, // bottom-left (green)
         0.5f, -0.5f,   0.2f, 0.4f, 1.0f  // bottom-right (blue)
    };

    glGenVertexArrays(1, &state->VAO);
    glGenBuffers(1, &state->VBO);

    glBindVertexArray(state->VAO);
    glBindBuffer(GL_ARRAY_BUFFER, state->VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(2 * sizeof(float)));
    glEnableVertexAttribArray(1);

    state->lastTicks = SDL_GetTicksNS();
    setupCutscene(state);

    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void* appstate, SDL_Event* event) {
    if (event->type == SDL_EVENT_QUIT) {
        return SDL_APP_SUCCESS;
    }
    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppIterate(void* appstate) {
    auto* state = static_cast<AppState*>(appstate);

    uint64_t currentTicks = SDL_GetTicksNS();
    float dt = static_cast<float>(currentTicks - state->lastTicks) / 1e9f;
    state->lastTicks = currentTicks;

    // 1. Advance the Action Queue
    state->actionQueue.update(dt);

    // If the sequence finished, loop it again
    if (state->actionQueue.is_empty()) {
        setupCutscene(state);
    }

    // 2. Render Frame
    int w, h;
    SDL_GetWindowSizeInPixels(state->window, &w, &h);
    glViewport(0, 0, w, h);

    glClearColor(state->clearColor[0], state->clearColor[1], state->clearColor[2], 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(state->shaderProgram);

    // 3. Matrix Math using cglm
    float aspect = (h > 0) ? static_cast<float>(w) / static_cast<float>(h) : 1.0f;

    mat4 proj, view, model, vp, mvp;

    // Orthographic projection preserving aspect ratio
    glm_ortho(-aspect, aspect, -1.0f, 1.0f, -1.0f, 1.0f, proj);

    // Standard view matrix (camera looking down -Z axis)
    vec3 eye = {0.0f, 0.0f, 1.0f};
    vec3 center = {0.0f, 0.0f, 0.0f};
    vec3 up = {0.0f, 1.0f, 0.0f};
    glm_lookat(eye, center, up, view);

    // Model transformation: rotation around Z axis + uniform scale
    glm_mat4_identity(model);
    vec3 axisZ = {0.0f, 0.0f, 1.0f};
    glm_rotate(model, state->rotationAngle, axisZ);
    glm_scale_uni(model, state->scale);

    // Multiply: MVP = Projection * View * Model
    glm_mat4_mul(proj, view, vp);
    glm_mat4_mul(vp, model, mvp);

    // Send the combined MVP matrix to the shader uniform
    glUniformMatrix4fv(state->uMVPLoc, 1, GL_FALSE, (const GLfloat*)mvp);

    glBindVertexArray(state->VAO);
    glDrawArrays(GL_TRIANGLES, 0, 3);

    SDL_GL_SwapWindow(state->window);
    return SDL_APP_CONTINUE;
}

void SDL_AppQuit(void* appstate, SDL_AppResult result) {
    if (appstate) {
        auto* state = static_cast<AppState*>(appstate);
        if (state->VAO) glDeleteVertexArrays(1, &state->VAO);
        if (state->VBO) glDeleteBuffers(1, &state->VBO);
        if (state->shaderProgram) glDeleteProgram(state->shaderProgram);
        if (state->glContext) SDL_GL_DestroyContext(state->glContext);
        if (state->window) SDL_DestroyWindow(state->window);
        delete state;
    }
    SDL_Quit();
}

2. File Contents for CMakeLists.txt 2. Содержимое файла CMakeLists.txt

cmake_minimum_required(VERSION 3.21)

if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE "Debug")
endif()

project(action-queue-cutscene-sdl3-opengl-desktop CXX C)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(OpenGL REQUIRED)

if(WIN32)
    set(SDL3_DIR "C:/libs/sdl3-3.4.16-mingw/lib/cmake/SDL3")
    set(CGLM_INCLUDE_DIR "C:/libs/cglm-0.9.6/include")
    set(GLAD_INCLUDE_DIR "C:/libs/glad-0.1.36/opengl-3.3/include")
    set(GLAD_SOURCE "C:/libs/glad-0.1.36/opengl-3.3/src/glad.c")
else()
    set(SDL3_DIR "$ENV{HOME}/libs/sdl3-3.4.16-ubuntu/lib/cmake/SDL3")
    set(CGLM_INCLUDE_DIR "$ENV{HOME}/libs/cglm-0.9.6/include")
    set(GLAD_INCLUDE_DIR "$ENV{HOME}/libs/glad-0.1.36/opengl-3.3/include")
    set(GLAD_SOURCE "$ENV{HOME}/libs/glad-0.1.36/opengl-3.3/src/glad.c")
endif()

find_package(SDL3 REQUIRED CONFIG)

add_executable(app
    src/main.cpp
    ${GLAD_SOURCE}
)

target_include_directories(app PRIVATE
    ${CGLM_INCLUDE_DIR}
    ${GLAD_INCLUDE_DIR}
)

if(WIN32)
    target_compile_options(app PRIVATE -Os)
    target_link_options(app PRIVATE -static -s -static-libgcc)

    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
        target_link_options(app PRIVATE -mconsole)
    else()
        target_link_options(app PRIVATE -mwindows)
    endif()

    target_link_libraries(app PRIVATE
        SDL3::SDL3-static
        OpenGL::GL
    )
else()
    target_link_libraries(app PRIVATE
        SDL3::SDL3-static
        OpenGL::GL
    )
endif()

Step 3: Create Build & Execution Scripts Шаг 3: Создание скриптов сборки и запуска

Windows (MinGW / Batch Scripts)

config-win.bat

cmake -G Ninja -S . -B dist/win

build-win.bat

cmake --build dist/win

run-win.bat

@echo off
.\dist\win\app.exe

Run sequentially in Command Prompt or PowerShell: Последовательно запустите в командной строке или PowerShell:

config-win.bat
build-win.bat
run-win.bat

Ubuntu (Bash Scripts)

config-linux.sh

#!/usr/bin/env bash
set -e
cmake -G Ninja -S . -B dist/linux

build-linux.sh

#!/usr/bin/env bash
set -e
cmake --build dist/linux

run-linux.sh

#!/usr/bin/env bash
set -e
./dist/linux/app

Grant execution permissions and execute on Ubuntu: Предоставьте права на запуск и выполните под Ubuntu:

chmod +x config-linux.sh build-linux.sh run-linux.sh
./config-linux.sh
./build-linux.sh
./run-linux.sh

Step 4: Expected Output Шаг 4: Ожидаемый результат

Upon execution, a window will appear rendering an RGB triangle that executes the full 5-stage cutscene loop in a continuous sequence, transformed via cglm's MVP matrix: После запуска приложения откроется окно с RGB-треугольником, последовательно и непрерывно выполняющим 5 этапов кат-сцены и трансформируемым с помощью матрицы MVP из cglm:

  1. Rotate: Full 360-degree rotation clockwise over 1.5s.Полный оборот на 360 градусов по часовой стрелке за 1.5 секунды.
  2. Pulse: Smoothly expands to 1.8x scale and returns to normal size over 1.0s.Плавно вырастает до 1.8x и возвращается к исходному размеру за 1.0 секунду.
  3. Fade In Color: The background shifts to vibrant purple over 1.0s.Фон плавно переходит в глубокий фиолетовый за 1.0 секунду.
  4. Rotate Back: Rotates back to 0 radians over 1.2s.Вращается обратно в исходное положение за 1.2 секунды.
  5. Fade Out Color: Background returns to dark slate over 1.0s, and the queue loops automatically.Фон возвращается к тёмно-сланцевому цвету за 1.0 секунду, после чего очередь автоматически перезапускается.

Complete unified source code and scripts are available on GitHub: Полный исходный код и скрипты сборки доступны на GitHub:

View on GitHub Смотреть на GitHub

Support My Work Поддержать проект

If these tutorials helped you, consider buying me a coffee! Если эти туториалы вам помогли, вы можете поддержать автора.

Sberbank (Russia only) Сбербанк (только для РФ)

Sberbank SBP QR Code

Direct transfer via phone number (Russia only) Перевод по номеру телефона (только для РФ)

+7 (917) 212-29-59

USDT TRC20

USDT TRC20 QR Code

Support via Cryptocurrency Поддержка криптовалютой

TMtY1YifNf6FKvgeFmqKGQR4NStKr3csGp