GLM vec3: векторная алгебра для трехмерной разработки на OpenGL

Для кого эта статья:

• Программисты и разработчики, занимающиеся 3D-графикой и компьютерными играми
• Студенты и обучающиеся, желающие изучить C++ и работу с графическими библиотеками

• Специалисты в области компьютерной графики, ищущие оптимизированные математические решения для своих проектов

  GLM (OpenGL Mathematics) — это ядерный инструмент, без которого профессиональная 3D-разработка превращается в пытку самописными математическими функциями. Эта статья расскажет о glm::vec3 — трёхмерном векторе, который станет вашим верным спутником в 3D-пространстве. Если вы хоть раз пытались вручную вычислять перемещение, поворот или проекцию объектов в 3D, вы уже знаете, почему правильная работа с векторами критична для успеха проекта. Погрузимся в мир векторной алгебры с практической стороны, без лишней академичности. 🚀

Хотите превратить абстрактные знания в реальные навыки 3D-программирования? Курс программирования на C++ от Skypro включает практические модули по работе с графическими библиотеками, включая GLM и OpenGL. Вы не просто изучите синтаксис, а создадите собственные 3D-приложения, понимая каждую строчку кода. Учитесь у практикующих разработчиков и забудьте о пробелах в понимании математики компьютерной графики.

GLM библиотека: математический фундамент для OpenGL

GLM (OpenGL Mathematics) — это заголовочная библиотека C++, вдохновлённая синтаксисом GLSL (OpenGL Shading Language). Она была создана для устранения разрыва между кодом шейдеров и приложения, предоставляя единообразный математический интерфейс. Вместо того чтобы заниматься ручной имплементацией векторов, матриц и других математических структур, GLM предлагает готовые решения, оптимизированные для 3D-графики.

Философия GLM проста: максимальная совместимость с GLSL при минимальных зависимостях. Для начала работы достаточно подключить необходимые заголовочные файлы:

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

В GLM реализованы все основные типы данных GLSL:

• Скалярные типы: аналоги float, int, bool
• Векторы: vec2, vec3, vec4 (и их целочисленные варианты)
• Матрицы: mat2, mat3, mat4, mat2x3 и другие
• Кватернионы: quat

Ключевыми преимуществами использования GLM являются:

Александр Волков, технический директор игровой студии

Однажды мы столкнулись с критической проблемой производительности в нашем движке. Профилирование показало, что мы тратили почти 30% процессорного времени на собственную реализацию векторной математики. Тогда мы решили перейти на GLM. Меня поразило, насколько легко было интегрировать библиотеку — просто заменили заголовочные файлы и адаптировали несколько методов. Производительность взлетела, а количество кода уменьшилось вдвое. Но самое ценное — мы получили совместимость с GLSL, что позволило использовать идентичные математические выражения как в основном коде, так и в шейдерах. Больше не приходилось мысленно "переводить" алгоритмы при переносе их на GPU.

Основы glm::vec3: создание и инициализация векторов

Трёхмерный вектор glm::vec3 — фундаментальный тип данных для работы с 3D-графикой. Он представляет точку или направление в трёхмерном пространстве через координаты X, Y и Z. Для начала работы с glm::vec3 необходимо подключить основной заголовочный файл библиотеки:

#include <glm/glm.hpp>

Существует несколько способов создания и инициализации трёхмерных векторов:

• Конструктор по умолчанию (все компоненты инициализируются нулями)
• Конструктор с одним значением (все компоненты получают одинаковое значение)
• Конструктор с тремя компонентами (задание X, Y, Z отдельно)
• Инициализация через другие типы векторов

Рассмотрим эти методы на практике:

// Конструктор по умолчанию
glm::vec3 defaultVector; // (0.0, 0.0, 0.0)

// Конструктор с одним значением
glm::vec3 uniformVector(1.0f); // (1.0, 1.0, 1.0)

// Конструктор с тремя компонентами
glm::vec3 position(2.5f, 0.0f, -1.5f); // (2.5, 0.0, -1.5)

// Инициализация из vec2
glm::vec2 planePos(3.0f, 4.0f);
glm::vec3 spacePos(planePos, 2.0f); // (3.0, 4.0, 2.0)

Доступ к компонентам вектора можно получить несколькими способами, что делает GLM чрезвычайно гибким инструментом:

glm::vec3 position(1.0f, 2.0f, 3.0f);

// Доступ по индексам (нумерация с 0)
float x = position[0]; // 1.0
float y = position[1]; // 2.0
float z = position[2]; // 3.0

// Доступ через имена компонентов
x = position.x; // 1.0
y = position.y; // 2.0
z = position.z; // 3.0

// Доступ через swizzling (как в GLSL)
glm::vec2 xy = position.xy; // (1.0, 2.0)
glm::vec3 zyx = position.zyx; // (3.0, 2.0, 1.0)

Стоит отметить некоторые предопределённые константы, которые часто используются при работе с 3D-пространством:

Базовые операции с векторами в GLM

Библиотека GLM реализует все стандартные операции с векторами, позволяя писать интуитивно понятный код для трехмерной математики. Рассмотрим наиболее часто используемые операции с трёхмерными векторами. 📐

1. Арифметические операции

Арифметические операции с векторами включают векторное сложение, вычитание, умножение и деление. GLM позволяет выполнять эти операции как между векторами, так и между вектором и скаляром:

glm::vec3 v1(1.0f, 2.0f, 3.0f);
glm::vec3 v2(2.0f, 3.0f, 4.0f);
float scalar = 2.0f;

// Сложение векторов
glm::vec3 sum = v1 + v2; // (3.0, 5.0, 7.0)

// Вычитание векторов
glm::vec3 diff = v1 – v2; // (-1.0, -1.0, -1.0)

// Умножение на скаляр
glm::vec3 scaled = v1 * scalar; // (2.0, 4.0, 6.0)

// Деление на скаляр
glm::vec3 divided = v1 / scalar; // (0.5, 1.0, 1.5)

// Покомпонентное умножение векторов
glm::vec3 componentMult = v1 * v2; // (2.0, 6.0, 12.0)

2. Скалярное произведение (Dot Product)

Скалярное произведение — одна из ключевых операций в 3D-математике, которая используется для определения угла между векторами, проекции одного вектора на другой и множества других геометрических вычислений:

glm::vec3 v1(1.0f, 0.0f, 0.0f); // Вектор по оси X
glm::vec3 v2(0.0f, 1.0f, 0.0f); // Вектор по оси Y

// Скалярное произведение
float dotProduct = glm::dot(v1, v2); // 0.0, так как векторы перпендикулярны

// Вычисление угла между векторами
glm::vec3 v3(1.0f, 1.0f, 0.0f);
float angle = glm::acos(glm::dot(v1, v3) / (glm::length(v1) * glm::length(v3)));
angle = glm::degrees(angle); // Конвертация радиан в градусы

3. Векторное произведение (Cross Product)

Векторное произведение двух векторов даёт новый вектор, перпендикулярный обоим исходным. Эта операция необходима при вычислении нормалей к поверхностям, создании ортогональных координатных систем и т.д.:

glm::vec3 v1(1.0f, 0.0f, 0.0f); // Вектор по оси X
glm::vec3 v2(0.0f, 1.0f, 0.0f); // Вектор по оси Y

// Векторное произведение
glm::vec3 crossProduct = glm::cross(v1, v2); // (0.0, 0.0, 1.0) – вектор по оси Z

4. Нормализация вектора

Нормализация преобразует вектор в единичный, сохраняя его направление. Это фундаментальная операция для работы с направлениями в 3D-пространстве:

glm::vec3 direction(3.0f, 4.0f, 0.0f);

// Нормализация вектора
glm::vec3 normalizedDir = glm::normalize(direction); // (0.6, 0.8, 0.0)

// Вычисление длины (модуля) вектора
float length = glm::length(direction); // 5.0
float lengthSq = glm::length2(direction); // 25.0 (квадрат длины, более эффективен)

5. Рефлексия и рефракция

GLM предоставляет встроенные функции для расчёта отражения и преломления векторов — операций, критически важных для физически корректного рендеринга:

glm::vec3 incident(-1.0f, -1.0f, 0.0f);
glm::vec3 normal(0.0f, 1.0f, 0.0f);

// Отражение вектора от поверхности с заданной нормалью
glm::vec3 reflected = glm::reflect(incident, normal); // (-1.0, 1.0, 0.0)

// Преломление вектора (рефракция)
float ratio = 1.0f / 1.33f; // Отношение показателей преломления (воздух/вода)
glm::vec3 refracted = glm::refract(incident, normal, ratio);

Елена Ковалёва, ведущий разработчик физических движков

Когда я только начинала работать над физической симуляцией воды в нашей игре, столкнулась с неожиданной проблемой: поверхность воды выглядела неестественно при определённых углах падения света. Профилирование показало, что наша самописная функция рефракции генерировала неточные результаты при некоторых граничных значениях. Замена всего одной функции на glm::refract моментально решила проблему. Что показательно — GLM обрабатывал вырожденные случаи (полное внутреннее отражение) правильно и с гораздо лучшей производительностью. Этот случай стал для меня хорошим уроком: не изобретайте велосипед там, где математическая точность критична. Библиотеки вроде GLM существуют именно для того, чтобы предоставить надёжные и оптимизированные реализации сложных математических операций.

Геометрические трансформации с использованием glm::vec3

В 3D-графике геометрические трансформации являются фундаментальным механизмом для манипуляции объектами в виртуальном пространстве. Векторы glm::vec3 часто используются как для представления позиции объектов, так и для задания параметров трансформаций. Рассмотрим основные типы преобразований и как применять их с использованием GLM. 🔄

1. Перемещение (Translation)

Перемещение — самая интуитивно понятная трансформация, изменяющая положение объекта в пространстве. В GLM мы можем использовать glm::translate для создания матрицы перемещения:

// Создаём начальную матрицу (единичную)
glm::mat4 model = glm::mat4(1.0f);

// Определяем вектор перемещения
glm::vec3 translationVector(2.0f, 1.0f, -3.0f);

// Создаём матрицу перемещения и применяем её
model = glm::translate(model, translationVector);

// Теперь можно применить эту матрицу к вершинам объекта
glm::vec4 vertex(1.0f, 0.0f, 0.0f, 1.0f);
glm::vec4 transformedVertex = model * vertex; // (3.0, 1.0, -3.0, 1.0)

2. Масштабирование (Scaling)

Масштабирование изменяет размеры объекта. GLM позволяет выполнять как равномерное, так и неравномерное масштабирование по различным осям:

// Создаём начальную матрицу
glm::mat4 model = glm::mat4(1.0f);

// Определяем вектор масштабирования
glm::vec3 scaleVector(2.0f, 0.5f, 1.0f); // x*2, y*0.5, z без изменений

// Создаём матрицу масштабирования и применяем её
model = glm::scale(model, scaleVector);

// Пример комбинации трансформаций (сначала масштабирование, затем перемещение)
glm::vec3 translationVector(1.0f, 0.0f, 0.0f);
model = glm::translate(model, translationVector);

3. Вращение (Rotation)

Вращение — наиболее комплексная трансформация. GLM предоставляет несколько способов задания вращения, включая угол-ось и эйлеровы углы:

// Создаём начальную матрицу
glm::mat4 model = glm::mat4(1.0f);

// Вращение вокруг произвольной оси на заданный угол
glm::vec3 rotationAxis(0.0f, 1.0f, 0.0f); // Вращение вокруг оси Y
float rotationAngle = glm::radians(45.0f); // 45 градусов в радианах
model = glm::rotate(model, rotationAngle, rotationAxis);

// Вращение через эйлеровы углы (yaw, pitch, roll)
glm::vec3 eulerAngles(glm::radians(30.0f), glm::radians(45.0f), glm::radians(60.0f));
glm::mat4 rotationMatrix = glm::yawPitchRoll(eulerAngles.x, eulerAngles.y, eulerAngles.z);

4. Построение систем координат

Трёхмерные векторы активно используются при построении систем координат, что критически важно для камер, ориентации объектов и многого другого:

// Определяем основные вектора системы координат
glm::vec3 position(0.0f, 0.0f, 5.0f); // Положение камеры
glm::vec3 target(0.0f, 0.0f, 0.0f); // Точка, на которую смотрит камера
glm::vec3 worldUp(0.0f, 1.0f, 0.0f); // Вектор "вверх" в мировом пространстве

// Построение вида камеры (матрица вида)
glm::mat4 viewMatrix = glm::lookAt(position, target, worldUp);

// Вычисление базисных векторов для локальной системы координат
glm::vec3 forward = glm::normalize(target – position);
glm::vec3 right = glm::normalize(glm::cross(forward, worldUp));
glm::vec3 up = glm::cross(right, forward);

Знание того, в каком порядке применять трансформации, критически важно для корректной работы. Ниже приведены основные сценарии применения трансформаций в различных контекстах:

Практические приёмы использования glm::vec3 в 3D-проектах

Теоретические знания о glm::vec3 приобретают реальную ценность лишь при их применении в практических задачах разработки 3D-графики. В этом разделе я рассмотрю наиболее распространённые паттерны использования трёхмерных векторов в контексте реальных проектов. 💡

1. Расчёт нормалей для освещения

Корректное освещение в 3D-сцене требует точного вычисления нормалей к поверхностям. Для треугольной грани нормаль можно вычислить с помощью векторного произведения:

// Имеем три вершины треугольника
glm::vec3 v0(0.0f, 0.0f, 0.0f);
glm::vec3 v1(1.0f, 0.0f, 0.0f);
glm::vec3 v2(0.0f, 1.0f, 0.0f);

// Вычисляем два вектора, лежащие в плоскости треугольника
glm::vec3 edge1 = v1 – v0;
glm::vec3 edge2 = v2 – v0;

// Вычисляем нормаль как векторное произведение
glm::vec3 normal = glm::normalize(glm::cross(edge1, edge2));

// Использование нормали для расчёта освещения
glm::vec3 lightDir = glm::normalize(glm::vec3(1.0f, 1.0f, 1.0f));
float diffuse = glm::max(glm::dot(normal, lightDir), 0.0f);

2. Детектирование столкновений в 3D-пространстве

Определение пересечений объектов является фундаментальной задачей физического моделирования. Рассмотрим пример вычисления точки пересечения луча и треугольника:

bool rayTriangleIntersection(
const glm::vec3& rayOrigin, 
const glm::vec3& rayDirection,
const glm::vec3& v0, 
const glm::vec3& v1, 
const glm::vec3& v2,
glm::vec3& intersectionPoint
) {
// Алгоритм Мёллера-Трумбора
const float EPSILON = 0.0000001f;
glm::vec3 edge1 = v1 – v0;
glm::vec3 edge2 = v2 – v0;
glm::vec3 h = glm::cross(rayDirection, edge2);
float a = glm::dot(edge1, h);

// Проверка параллельности
if (a > -EPSILON && a < EPSILON) return false;

float f = 1.0f / a;
glm::vec3 s = rayOrigin – v0;
float u = f * glm::dot(s, h);

if (u < 0.0f || u > 1.0f) return false;

glm::vec3 q = glm::cross(s, edge1);
float v = f * glm::dot(rayDirection, q);

if (v < 0.0f || u + v > 1.0f) return false;

float t = f * glm::dot(edge2, q);
if (t > EPSILON) {
intersectionPoint = rayOrigin + rayDirection * t;
return true;
}

return false;
}

3. Интерполяция позиции и ориентации

Для плавной анимации объектов часто требуется интерполяция между различными состояниями. GLM предоставляет функции для линейной (lerp) и сферической (slerp) интерполяции:

// Линейная интерполяция позиций
glm::vec3 startPosition(0.0f, 0.0f, 0.0f);
glm::vec3 endPosition(10.0f, 5.0f, -3.0f);
float interpolationFactor = 0.3f; // 0.0 = start, 1.0 = end

glm::vec3 currentPosition = glm::mix(startPosition, endPosition, interpolationFactor);
// Альтернативно: glm::vec3 currentPosition = glm::lerp(startPosition, endPosition, interpolationFactor);

// Для плавного ускорения и замедления можно использовать easing-функции
float smoothFactor = glm::smoothstep(0.0f, 1.0f, interpolationFactor);
glm::vec3 smoothPosition = glm::mix(startPosition, endPosition, smoothFactor);

4. Генерация процедурного контента

Трёхмерные векторы — ключевой элемент при создании процедурного контента, например, ландшафтов или текстур:

// Создание шума Перлина для генерации ландшафта
float generatePerlinNoise(const glm::vec3& position, int octaves) {
float total = 0.0f;
float frequency = 1.0f;
float amplitude = 1.0f;
float maxValue = 0.0f;

for (int i = 0; i < octaves; i++) {
// Здесь предполагается наличие функции noise(x, y, z)
total += glm::perlin(position * frequency) * amplitude;
maxValue += amplitude;
amplitude *= 0.5f;
frequency *= 2.0f;
}

return total / maxValue;
}

// Применение для создания вершин ландшафта
std::vector<glm::vec3> generateTerrain(int width, int depth, float scale) {
std::vector<glm::vec3> vertices;

for (int z = 0; z < depth; z++) {
for (int x = 0; x < width; x++) {
glm::vec3 position((float)x, 0.0f, (float)z);
float height = generatePerlinNoise(position * 0.1f, 6) * scale;
vertices.push_back(glm::vec3(x, height, z));
}
}

return vertices;
}

5. Оптимизация производительности при работе с векторами

При работе с большим количеством векторных операций важно учитывать аспекты производительности:

• Используйте функцию glm::length2() вместо glm::length() для сравнения расстояний (избегаете затратной операции извлечения квадратного корня)
• Предварительно вычисляйте и сохраняйте часто используемые нормализованные векторы
• Используйте функции GLM для векторных операций вместо написания собственных (они обычно оптимизированы, включая возможное использование SIMD)
• Рассмотрите возможность использования glm::fvec3 для операций с плавающей точкой одинарной точности или glm::dvec3 для двойной точности в зависимости от требуемой точности

Практические примеры нестандартного использования glm::vec3:

• Цветовые пространства: векторы glm::vec3 удобны для представления цветов в различных цветовых пространствах (RGB, HSV и т.д.)
• Представление физических величин: для хранения силы, ускорения, угловой скорости и других физических параметров
• Хранение данных текстурных координат для триплетов (u, v, w) в случае объёмных текстур
• Эвристические веса в системах искусственного интеллекта и принятия решений

Применение библиотеки GLM и типа glm::vec3 в проектах трёхмерной графики значительно упрощает разработку и повышает производительность. Вместо того чтобы тратить время на разработку и отладку собственных математических функций, сосредоточьтесь на бизнес-логике вашего приложения. Помните: высокоуровневая математическая библиотека не только экономит время, но и предотвращает множество потенциальных ошибок, особенно связанных с граничными случаями в векторных операциях. Начните использовать полный потенциал GLM сегодня и ощутите, как ваш код становится чище, надёжнее и выразительнее.

Читайте также

• Установка и настройка OpenGL: гайд для всех платформ без ошибок
• Перспективная проекция в OpenGL: трансформация координат и матрицы
• Геометрические основы OpenGL: от математики к визуализации 3D-миров
• MVP-матрицы OpenGL: принципы работы 3D-трансформаций в графике
• Математические основы OpenGL: векторы и матрицы для начинающих
• Создание и настройка камеры в OpenGL: матрицы, векторы, исходный код
• Настройка камеры в OpenGL: функция lookAt и видовая матрица
• Математика OpenGL: векторы и матрицы в основе 3D-графики
• Ортографическая проекция в OpenGL: основы, принципы, реализация
• Координатные системы в OpenGL: путь от вершин к пикселям