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, передаваемую в шейдер.
- Installing cglm C/C++ Mathematics Library Установка математической C/C++ библиотеки cglm
- Installing GLAD OpenGL Loader Library Установка библиотеки-загрузчика OpenGL GLAD
- Building SDL3 Static Library for Windows (MinGW & CMake) Сборка статической библиотеки SDL3 для Windows (MinGW и CMake)
- Building SDL3 Static Library for Ubuntu (GCC, CMake & Ninja) Сборка статической библиотеки SDL3 для Ubuntu (GCC, CMake и Ninja)
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
ActionQueuewhether 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 bystd::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 returnsActionStatus::Runningwhile active andActionStatus::Finishedwhen 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_ptrguarantees 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 usingstd::move. Добавляет новое действие в конец очереди с помощьюstd::move. -
update(float dt):- Returns immediately if the queue is empty.Немедленно возвращает управление, если очередь пуста.
- If
!started, triggerson_start()on the action at the front of the queue, then setsstarted = true.Если!started, вызываетon_start()у первого действия в очереди и устанавливаетstarted = true. - Calls
queue.front()->update(dt).Вызываетqueue.front()->update(dt). - When
update(dt)returnsActionStatus::Finished, it callsqueue.pop_front()(deleting the action) and resetsstarted = false, so the next action in line will have itson_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
ActionQueueitself. Центральная структура данных, хранящая графические дескрипторы, контекст окна, униформы шейдеров и саму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) andduration.Принимает целевой угол (targetAngleRad) и длительностьduration. on_start(): Reads currentstate->rotationAngleasstartAngle. 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
Finishedoncet ≥ 1.0f.ВозвращаетFinished, как толькоt ≥ 1.0f.
- Accumulates elapsed time:
B. PulseAction (Mathematical / Sinusoidal Wave)
- Constructor:Конструктор: Takes
maxScaleandduration.Принимает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);wheret ∈ [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Исходный размер)
- At t = 0.0:
C. FadeColorAction (RGB Vector Interpolation)
- Constructor:Конструктор: Takes target RGB values (
targetR, targetG, targetB) andduration.Принимает целевые значения цвета 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 overduration.Синхронно интерполирует каждую из составляющих (красную, зелёную и синюю) от начальных к целевым значениям за время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_AppIteratedoesn't care how properties change; it just transforms and draws whatever values are stored inAppState. Логика отрисовки вSDL_AppIterateне заботится о том, как меняются параметры; она просто трансформирует и рисует актуальные значения изAppState. -
Extensibility:Расширяемость:
Adding new actions (e.g.,
TranslateAction,WaitAction,PlaySoundAction) requires only subclassingActionwithout alteringActionQueueor OpenGL rendering code. Добавление новых действий (например,TranslateAction,WaitAction,PlaySoundAction) требует лишь создания нового наследникаActionбез измененияActionQueueили кода рендеринга. -
Safe Memory Management:Безопасное управление памятью:
Using
std::unique_ptrwithstd::dequeeliminates manualnew/deletecalls 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:
- Rotate: Full 360-degree rotation clockwise over 1.5s.Полный оборот на 360 градусов по часовой стрелке за 1.5 секунды.
- Pulse: Smoothly expands to 1.8x scale and returns to normal size over 1.0s.Плавно вырастает до 1.8x и возвращается к исходному размеру за 1.0 секунду.
- Fade In Color: The background shifts to vibrant purple over 1.0s.Фон плавно переходит в глубокий фиолетовый за 1.0 секунду.
- Rotate Back: Rotates back to 0 radians over 1.2s.Вращается обратно в исходное положение за 1.2 секунды.
- 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 Смотреть на GitHubSupport My Work Поддержать проект
If these tutorials helped you, consider buying me a coffee! Если эти туториалы вам помогли, вы можете поддержать автора.
Sberbank (Russia only) Сбербанк (только для РФ)
Direct transfer via phone number (Russia only) Перевод по номеру телефона (только для РФ)
USDT TRC20
Support via Cryptocurrency Поддержка криптовалютой