OpenGL и C: базовые принципы создания 2D и 3D графики

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <stdio.h>

int main() {
// Инициализация GLFW
if (!glfwInit()) {
printf("Ошибка при инициализации GLFW\n");
return -1;
}

// Настройка GLFW
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

// Создание окна
GLFWwindow* window = glfwCreateWindow(800, 600, "OpenGL Window", NULL, NULL);
if (window == NULL) {
printf("Ошибка при создании окна GLFW\n");
glfwTerminate();
return -1;
}

// Установка контекста OpenGL
glfwMakeContextCurrent(window);

// Загрузка функций OpenGL
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
printf("Ошибка при инициализации GLAD\n");
return -1;
}

// Основной цикл
while (!glfwWindowShouldClose(window)) {
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);

// Обмен буферов и обработка событий
glfwSwapBuffers(window);
glfwPollEvents();
}

// Очистка ресурсов
glfwTerminate();
return 0;
}

gcc -o opengl_window main.c -I include -L lib -lglfw3 -lopengl32 -lgdi32

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

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

// Координаты вершин треугольника в нормализованном пространстве устройства
float vertices[] = {
-0.5f, -0.5f, 0.0f, // Левая нижняя
0.5f, -0.5f, 0.0f, // Правая нижняя
0.0f, 0.5f, 0.0f // Верхняя
};

// Создание и компиляция шейдеров
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);

unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);

// Создание шейдерной программы
unsigned int shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

// Очистка
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

// Создание VAO, VBO
unsigned int VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);

// Привязка VAO
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);

// В цикле рендеринга
glUseProgram(shaderProgram);
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLES, 0, 3);

float vertices[] = {
0.5f, 0.5f, 0.0f, // верхняя правая
0.5f, -0.5f, 0.0f, // нижняя правая
-0.5f, -0.5f, 0.0f, // нижняя левая
-0.5f, 0.5f, 0.0f // верхняя левая
};
unsigned int indices[] = { // обратите внимание, что мы начинаем с 0!
0, 1, 3, // первый треугольник
1, 2, 3 // второй треугольник
};

unsigned int VBO, VAO, EBO;
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, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);

// Отвязка VBO
glBindBuffer(GL_ARRAY_BUFFER, 0);

// НЕ отвязывайте EBO, пока VAO активен
// VAO хранит привязку к EBO

// Отвязка VAO
glBindVertexArray(0);

// В цикле рендеринга
glUseProgram(shaderProgram);
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

void generateCircleVertices(float* vertices, int segments, float radius) {
const float PI = 3.14159265359f;
for (int i = 0; i <= segments; i++) {
float angle = 2.0f * PI * i / segments;
vertices[i * 3] = radius * cosf(angle); // x
vertices[i * 3 + 1] = radius * sinf(angle); // y
vertices[i * 3 + 2] = 0.0f; // z
}
}

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

// Загрузка текстуры
unsigned int loadTexture(const char* path) {
unsigned int textureID;
glGenTextures(1, &textureID);

int width, height, nrChannels;
unsigned char *data = stbi_load(path, &width, &height, &nrChannels, 0);
if (data) {
GLenum format;
if (nrChannels == 1)
format = GL_RED;
else if (nrChannels == 3)
format = GL_RGB;
else if (nrChannels == 4)
format = GL_RGBA;

glBindTexture(GL_TEXTURE_2D, textureID);
glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);

// Настройка параметров
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

stbi_image_free(data);
} else {
printf("Ошибка при загрузке текстуры: %s\n", path);
stbi_image_free(data);
}

return textureID;
}

float vertices[] = {
// позиции // текстурные координаты
0.5f, 0.5f, 0.0f, 1.0f, 1.0f, // верхняя правая
0.5f, -0.5f, 0.0f, 1.0f, 0.0f, // нижняя правая
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f, // нижняя левая
-0.5f, 0.5f, 0.0f, 0.0f, 1.0f // верхняя левая
};

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

const char* fragmentShaderSource = 
"#version 330 core\n"
"out vec4 FragColor;\n"
"in vec2 TexCoord;\n"
"uniform sampler2D texture1;\n"
"void main()\n"
"{\n"
" FragColor = texture(texture1, TexCoord);\n"
"}\0";

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

// Фрагментный шейдер
const char* fragmentShaderSource = 
"#version 330 core\n"
"out vec4 FragColor;\n"
"in vec3 FragPos;\n"
"in vec3 Normal;\n"
"uniform vec3 lightPos;\n"
"uniform vec3 viewPos;\n"
"uniform vec3 lightColor;\n"
"uniform vec3 objectColor;\n"
"void main()\n"
"{\n"
" // Фоновое освещение\n"
" float ambientStrength = 0.1;\n"
" vec3 ambient = ambientStrength * lightColor;\n"
"\n"
" // Диффузное освещение\n"
" vec3 norm = normalize(Normal);\n"
" vec3 lightDir = normalize(lightPos – FragPos);\n"
" float diff = max(dot(norm, lightDir), 0.0);\n"
" vec3 diffuse = diff * lightColor;\n"
"\n"
" // Зеркальное отражение\n"
" float specularStrength = 0.5;\n"
" vec3 viewDir = normalize(viewPos – FragPos);\n"
" vec3 reflectDir = reflect(-lightDir, norm);\n"
" float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32);\n"
" vec3 specular = specularStrength * spec * lightColor;\n"
"\n"
" vec3 result = (ambient + diffuse + specular) * objectColor;\n"
" FragColor = vec4(result, 1.0);\n"
"}\0";

#include <math.h>

// В цикле рендеринга
float currentTime = glfwGetTime();
float rotationAngle = currentTime * 50.0f; // Угол в градусах

// Создание матрицы модели с вращением
mat4 model = mat4_identity();
model = mat4_rotate(model, rotationAngle * (M_PI / 180.0f), (vec3){0.5f, 1.0f, 0.0f});

// Отправка матрицы модели в шейдер
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, (float*)&model);

float radius = 5.0f;
float currentTime = glfwGetTime();
float x = radius * cos(currentTime);
float z = radius * sin(currentTime);

mat4 model = mat4_identity();
model = mat4_translate(model, (vec3){x, 0.0f, z});

// Обработка ввода в цикле рендеринга
void processInput(GLFWwindow* window, Camera* camera, float deltaTime) {
if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
glfwSetWindowShouldClose(window, 1);

float cameraSpeed = 2.5f * deltaTime;
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
camera->position = vec3_add(camera->position, vec3_scale(camera->front, cameraSpeed));
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
camera->position = vec3_sub(camera->position, vec3_scale(camera->front, cameraSpeed));
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
camera->position = vec3_sub(camera->position, vec3_scale(vec3_normalize(vec3_cross(camera->front, camera->up)), cameraSpeed));
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
camera->position = vec3_add(camera->position, vec3_scale(vec3_normalize(vec3_cross(camera->front, camera->up)), cameraSpeed));
}

// Глобальные переменные для отслеживания движения мыши
float lastX = 400, lastY = 300;
float yaw = -90.0f, pitch = 0.0f;
bool firstMouse = true;

// Функция обратного вызова для движения мыши
void mouse_callback(GLFWwindow* window, double xpos, double ypos) {
if (firstMouse) {
lastX = xpos;
lastY = ypos;
firstMouse = false;
}

float xoffset = xpos – lastX;
float yoffset = lastY – ypos; // Обратный порядок, т.к. y-координаты идут снизу вверх
lastX = xpos;
lastY = ypos;

float sensitivity = 0.1f;
xoffset *= sensitivity;
yoffset *= sensitivity;

yaw += xoffset;
pitch += yoffset;

// Ограничение угла обзора
if (pitch > 89.0f)
pitch = 89.0f;
if (pitch < -89.0f)
pitch = -89.0f;

// Обновление направления камеры
vec3 direction;
direction.x = cos(radians(yaw)) * cos(radians(pitch));
direction.y = sin(radians(pitch));
direction.z = sin(radians(yaw)) * cos(radians(pitch));
camera.front = vec3_normalize(direction);
}

// Регистрация функции обратного вызова
glfwSetCursorPosCallback(window, mouse_callback);

// Функция для создания луча выбора
Ray createRayFromMouse(float mouseX, float mouseY, int screenWidth, int screenHeight, 
mat4 projection, mat4 view) {
// Преобразование в нормализованные координаты устройства
float x = (2.0f * mouseX) / screenWidth – 1.0f;
float y = 1.0f – (2.0f * mouseY) / screenHeight;
float z = 1.0f; // Дальний план

// Создание точки в пространстве отсечения
vec4 clipCoords = {x, y, -1.0f, 1.0f};

// Преобразование в пространство камеры (eye space)
mat4 projInv = mat4_inverse(projection);
vec4 eyeCoords = mat4_mulv4(projInv, clipCoords);
eyeCoords.z = -1.0f;
eyeCoords.w = 0.0f;

// Преобразование в мировое пространство
mat4 viewInv = mat4_inverse(view);
vec4 worldCoords = mat4_mulv4(viewInv, eyeCoords);
vec3 rayDirection = vec3_normalize((vec3){worldCoords.x, worldCoords.y, worldCoords.z});

Ray ray;
ray.origin = camera.position;
ray.direction = rayDirection;

return ray;
}

// Массив с матрицами модели для каждого экземпляра
mat4 modelMatrices[1000];

// Заполнение массива матриц (позиции, повороты, масштабы)
for (int i = 0; i < 1000; i++) {
mat4 model = mat4_identity();
// Случайное смещение
float x = ((rand() % 100) / 100.0f – 0.5f) * 100.0f;
float y = ((rand() % 100) / 100.0f – 0.5f) * 100.0f;
float z = ((rand() % 100) / 100.0f – 0.5f) * 100.0f;
model = mat4_translate(model, (vec3){x, y, z});

// Случайное вращение
float angle = ((rand() % 100) / 100.0f) * 360.0f;
model = mat4_rotate(model, angle * (M_PI / 180.0f), (vec3){0.4f, 0.6f, 0.8f});

// Случайное масштабирование
float scale = ((rand() % 100) / 100.0f) * 0.5f + 0.5f;
model = mat4_scale(model, (vec3){scale, scale, scale});

modelMatrices[i] = model;
}

// Создание VBO для матриц моделей
unsigned int instanceVBO;
glGenBuffers(1, &instanceVBO);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(mat4) * 1000, &modelMatrices[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);

// Настройка атрибутов инстансинга
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);

// mat4 требует 4 атрибута vec4
for (unsigned int i = 0; i < 4; i++) {
glEnableVertexAttribArray(3 + i); // location = 3, 4, 5, 6
glVertexAttribPointer(3 + i, 4, GL_FLOAT, GL_FALSE, sizeof(mat4), 
(void*)(sizeof(float) * i * 4));
glVertexAttribDivisor(3 + i, 1); // Изменять атрибут только для нового инстанса
}

// Отрисовка всех экземпляров за один вызов
glDrawElementsInstanced(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0, 1000);

// Функция для проверки ошибок OpenGL
void checkOpenGLError(const char* stmt, const char* fname, int line) {
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
printf("OpenGL error %08x, at %s:%i – for %s\n", err, fname, line, stmt);
abort();
}
}

// Использование (обычно через макрос)
#ifdef DEBUG
#define GL_CHECK(stmt) do { \
stmt; \
checkOpenGLError(#stmt, __FILE__, __LINE__); \
} while (0)
#else
#define GL_CHECK(stmt) stmt
#endif

// Пример использования
GL_CHECK(glBindBuffer(GL_ARRAY_BUFFER, VBO));

// Функция обратного вызова для сообщений отладки
void APIENTRY glDebugOutput(GLenum source, GLenum type, unsigned int id,
GLenum severity, GLsizei length, 
const char* message, const void* userParam) {
// Игнорирование не-критических уведомлений
if (id == 131169 || id == 131185 || id == 131218 || id == 131204) return;

printf("---------------\n");
printf("Debug message (%u): %s\n", id, message);

switch (source) {
case GL_DEBUG_SOURCE_API: printf("Source: API\n"); break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM: printf("Source: Window System\n"); break;
case GL_DEBUG_SOURCE_SHADER_COMPILER: printf("Source: Shader Compiler\n"); break;
case GL_DEBUG_SOURCE_THIRD_PARTY: printf("Source: Third Party\n"); break;
case GL_DEBUG_SOURCE_APPLICATION: printf("Source: Application\n"); break;
case GL_DEBUG_SOURCE_OTHER: printf("Source: Other\n"); break;
}

switch (type) {
case GL_DEBUG_TYPE_ERROR: printf("Type: Error\n"); break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: printf("Type: Deprecated Behavior\n"); break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: printf("Type: Undefined Behavior\n"); break;
case GL_DEBUG_TYPE_PORTABILITY: printf("Type: Portability\n"); break;
case GL_DEBUG_TYPE_PERFORMANCE: printf("Type: Performance\n"); break;
case GL_DEBUG_TYPE_MARKER: printf("Type: Marker\n"); break;
case GL_DEBUG_TYPE_PUSH_GROUP: printf("Type: Push Group\n"); break;
case GL_DEBUG_TYPE_POP_GROUP: printf("Type: Pop Group\n"); break;
case GL_DEBUG_TYPE_OTHER: printf("Type: Other\n"); break;
}

switch (severity) {
case GL_DEBUG_SEVERITY_HIGH: printf("Severity: high\n"); break;
case GL_DEBUG_SEVERITY_MEDIUM: printf("Severity: medium\n"); break;
case GL_DEBUG_SEVERITY_LOW: printf("Severity: low\n"); break;
case GL_DEBUG_SEVERITY_NOTIFICATION: printf("Severity: notification\n"); break;
}
printf("\n");
}

// Включение отладки OpenGL
glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); 
glDebugMessageCallback(glDebugOutput, NULL);
glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL, GL_TRUE);