Анимация в C: руководство по созданию графики с SDL и OpenGL

#include <stdio.h>
#include <stdbool.h>

int main() {
// Инициализация
if (!initialize()) {
return 1;
}

bool running = true;
while (running) {
// Обработка ввода
processInput(&running);

// Обновление состояния
update();

// Отрисовка
render();

// Контроль времени
controlFrameRate();
}

// Освобождение ресурсов
cleanup();
return 0;
}

gcc -o myprog main.c -lSDL2 -lGL

#include <SDL2/SDL.h>
#include <GL/gl.h>
#include <stdbool.h>
#include <stdio.h>

SDL_Window *window = NULL;
SDL_GLContext glContext;

bool initialize() {
// Инициализация SDL
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
printf("SDL не смог инициализироваться: %s\n", SDL_GetError());
return false;
}

// Настройка атрибутов OpenGL
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);

// Создание окна
window = SDL_CreateWindow(
"Анимация с SDL и OpenGL",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
800, 600,
SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN
);

if (window == NULL) {
printf("Окно не может быть создано: %s\n", SDL_GetError());
return false;
}

// Создание контекста OpenGL
glContext = SDL_GL_CreateContext(window);
if (glContext == NULL) {
printf("Контекст OpenGL не может быть создан: %s\n", SDL_GetError());
return false;
}

// Инициализация настроек OpenGL
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

return true;
}

void drawSimpleShapes(SDL_Renderer *renderer) {
// Установка цвета (красный)
SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);

// Рисование линии
SDL_RenderDrawLine(renderer, 100, 100, 300, 300);

// Рисование прямоугольника (синий)
SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
SDL_Rect rect = { 400, 100, 100, 200 };
SDL_RenderFillRect(renderer, &rect);

// Рисование точек (зеленый)
SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
for (int i = 0; i < 100; i += 5) {
SDL_RenderDrawPoint(renderer, 50 + i, 400);
}
}

#include <GL/glew.h> // Необходим для расширений OpenGL

void initializeOpenGLTriangle() {
// Вершины треугольника
float vertices[] = {
0.0f, 0.5f, 0.0f, // вершина
-0.5f, -0.5f, 0.0f, // левый нижний угол
0.5f, -0.5f, 0.0f // правый нижний угол
};

// Создание и привязка буфера вершин
GLuint VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

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

glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}

void drawOpenGLTriangle() {
// Очистка буфера цвета
glClear(GL_COLOR_BUFFER_BIT);

// Использование программы шейдеров и привязка VAO
glUseProgram(shaderProgram); // предполагается, что shaderProgram уже создан
glBindVertexArray(VAO);

// Отрисовка треугольника
glDrawArrays(GL_TRIANGLES, 0, 3);
}

SDL_Texture* loadTexture(SDL_Renderer *renderer, const char *path) {
SDL_Surface *surface = SDL_LoadBMP(path);
if (!surface) {
printf("Не удалось загрузить изображение: %s\n", SDL_GetError());
return NULL;
}

SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);
SDL_FreeSurface(surface); // Освобождаем поверхность, она больше не нужна

if (!texture) {
printf("Не удалось создать текстуру: %s\n", SDL_GetError());
return NULL;
}

return texture;
}

void renderTexture(SDL_Renderer *renderer, SDL_Texture *texture, int x, int y) {
SDL_Rect dest = { x, y, 0, 0 };
SDL_QueryTexture(texture, NULL, NULL, &dest.w, &dest.h);
SDL_RenderCopy(renderer, texture, NULL, &dest);
}

typedef struct {
float x, y; // Позиция
float velX, velY; // Скорость
SDL_Texture *texture;
int width, height;
} AnimatedObject;

void initObject(AnimatedObject *obj, SDL_Renderer *renderer, const char *imagePath) {
// Загрузка текстуры
obj->texture = loadTexture(renderer, imagePath);

// Получение размеров текстуры
SDL_QueryTexture(obj->texture, NULL, NULL, &obj->width, &obj->height);

// Начальная позиция
obj->x = 100.0f;
obj->y = 100.0f;

// Начальная скорость
obj->velX = 200.0f; // пикселей в секунду
obj->velY = 150.0f;
}

void updateObject(AnimatedObject *obj, float deltaTime, int windowWidth, int windowHeight) {
// Обновление позиции
obj->x += obj->velX * deltaTime;
obj->y += obj->velY * deltaTime;

// Проверка столкновения с краями экрана
if (obj->x < 0 || obj->x + obj->width > windowWidth) {
obj->velX = -obj->velX; // Изменение направления по X
}

if (obj->y < 0 || obj->y + obj->height > windowHeight) {
obj->velY = -obj->velY; // Изменение направления по Y
}
}

void renderObject(AnimatedObject *obj, SDL_Renderer *renderer) {
SDL_Rect destRect = {
(int)obj->x, 
(int)obj->y, 
obj->width, 
obj->height
};

SDL_RenderCopy(renderer, obj->texture, NULL, &destRect);
}

typedef struct {
float x, y;
SDL_Texture *spritesheet;
int frameWidth, frameHeight;
int currentFrame;
int totalFrames;
float frameTime; // время на один кадр в секундах
float timer; // аккумулятор времени
} SpriteAnimation;

void initSpriteAnimation(SpriteAnimation *anim, SDL_Renderer *renderer, 
const char *spritesheetPath, int frameWidth, int frameHeight, 
int totalFrames, float frameRate) {
anim->spritesheet = loadTexture(renderer, spritesheetPath);
anim->frameWidth = frameWidth;
anim->frameHeight = frameHeight;
anim->currentFrame = 0;
anim->totalFrames = totalFrames;
anim->frameTime = 1.0f / frameRate;
anim->timer = 0.0f;
anim->x = 200.0f;
anim->y = 200.0f;
}

void updateSpriteAnimation(SpriteAnimation *anim, float deltaTime) {
// Обновление таймера
anim->timer += deltaTime;

// Если прошло достаточно времени, переходим к следующему кадру
if (anim->timer >= anim->frameTime) {
anim->currentFrame = (anim->currentFrame + 1) % anim->totalFrames;
anim->timer -= anim->frameTime; // Сбросить таймер, сохраняя остаток
}
}

void renderSpriteAnimation(SpriteAnimation *anim, SDL_Renderer *renderer) {
// Определяем прямоугольник для текущего кадра на спрайт-листе
SDL_Rect srcRect = {
anim->currentFrame * anim->frameWidth,
0,
anim->frameWidth,
anim->frameHeight
};

// Определяем позицию и размер на экране
SDL_Rect destRect = {
(int)anim->x,
(int)anim->y,
anim->frameWidth,
anim->frameHeight
};

SDL_RenderCopy(renderer, anim->spritesheet, &srcRect, &destRect);
}

int main() {
// Инициализация SDL и создание окна, рендерера
if (!initSDL()) return 1;

// Создание и инициализация объектов анимации
AnimatedObject ball;
initObject(&ball, renderer, "ball.bmp");

SpriteAnimation character;
initSpriteAnimation(&character, renderer, "character_sheet.bmp", 64, 64, 8, 12.0f);

// Переменные для управления временем
Uint32 lastTime = SDL_GetTicks();

// Основной цикл
bool running = true;
while (running) {
// Обработка событий
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = false;
}
}

// Расчет времени кадра
Uint32 currentTime = SDL_GetTicks();
float deltaTime = (currentTime – lastTime) / 1000.0f;
lastTime = currentTime;

// Обновление анимаций
updateObject(&ball, deltaTime, WINDOW_WIDTH, WINDOW_HEIGHT);
updateSpriteAnimation(&character, deltaTime);

// Отрисовка
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);

renderObject(&ball, renderer);
renderSpriteAnimation(&character, renderer);

SDL_RenderPresent(renderer);
}

// Очистка ресурсов
SDL_DestroyTexture(ball.texture);
SDL_DestroyTexture(character.spritesheet);

// Завершение работы SDL
cleanupSDL();

return 0;
}

// Вершины куба (позиции и цвета)
GLfloat vertices[] = {
// Позиции // Цвета
-0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
// ... (остальные вершины)
};

// Индексы для рисования куба
GLuint indices[] = {
0, 1, 2,
2, 3, 0,
// ... (остальные индексы)
};

// Переменные для VBO, VAO и EBO
GLuint VBO, VAO, EBO;

// Идентификатор шейдерной программы
GLuint shaderProgram;

// Загрузка и компиляция шейдеров
void initShaders() {
// ... код для создания и компиляции шейдерных программ
}

// Инициализация ресурсов OpenGL
void initOpenGL() {
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

// Позиции
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

// Цвета
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);

initShaders();

// Настройка OpenGL
glEnable(GL_DEPTH_TEST);
}

// Рендеринг сцены
void renderOpenGL(float rotationAngle) {
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// Используем нашу шейдерную программу
glUseProgram(shaderProgram);

// Создаем матрицы трансформации
mat4 model = mat4_identity();
mat4 view = mat4_identity();
mat4 projection = mat4_identity();

// Вращение куба
model = mat4_rotate(model, rotationAngle, (vec3){0.5f, 1.0f, 0.0f});

// Отодвигаем сцену от камеры
view = mat4_translate(view, (vec3){0.0f, 0.0f, -3.0f});

// Создаем перспективную проекцию
projection = mat4_perspective(45.0f, (float)WINDOW_WIDTH / WINDOW_HEIGHT, 0.1f, 100.0f);

// Получаем uniform-переменные в шейдере
GLint modelLoc = glGetUniformLocation(shaderProgram, "model");
GLint viewLoc = glGetUniformLocation(shaderProgram, "view");
GLint projLoc = glGetUniformLocation(shaderProgram, "projection");

// Передаем матрицы в шейдер
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, (GLfloat*)&model);
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, (GLfloat*)&view);
glUniformMatrix4fv(projLoc, 1, GL_FALSE, (GLfloat*)&projection);

// Отрисовка куба
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
}

// Вершинный шейдер
const char* vertexShaderSource = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"layout (location = 1) in vec3 aColor;\n"
"out vec3 ourColor;\n"
"uniform mat4 model;\n"
"uniform mat4 view;\n"
"uniform mat4 projection;\n"
"void main()\n"
"{\n"
" gl_Position = projection * view * model * vec4(aPos, 1.0);\n"
" ourColor = aColor;\n"
"}\0";

// Фрагментный шейдер
const char* fragmentShaderSource = "#version 330 core\n"
"in vec3 ourColor;\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
" FragColor = vec4(ourColor, 1.0);\n"
"}\0";

int main() {
// Инициализация SDL и OpenGL
initSDLWithOpenGL();
initOpenGL();

// Угол вращения и скорость
float rotation = 0.0f;
float rotationSpeed = 50.0f; // градусов в секунду

// Временные переменные
Uint32 lastTime = SDL_GetTicks();

// Основной цикл
bool running = true;
while (running) {
// Обработка событий
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = false;
}
}

// Расчет времени кадра
Uint32 currentTime = SDL_GetTicks();
float deltaTime = (currentTime – lastTime) / 1000.0f;
lastTime = currentTime;

// Обновление анимации
rotation += rotationSpeed * deltaTime;

// Рендеринг
renderOpenGL(rotation);

// Обмен буферами
SDL_GL_SwapWindow(window);
}

// Очистка ресурсов
glDeleteVertexArrays(1, &VAO);
glDeleteBuffers(1, &VBO);
glDeleteBuffers(1, &EBO);
glDeleteProgram(shaderProgram);

// Завершение работы
SDL_GL_DeleteContext(glContext);
SDL_DestroyWindow(window);
SDL_Quit();

return 0;
}