Освещение и тени в 3D графике на C: руководство разработчика

typedef struct {
float x, y, z;
} Vector3;

typedef struct {
Vector3 position; // Позиция источника света
Vector3 color; // RGB цвет света
float intensity; // Интенсивность
float attenuation; // Коэффициент затухания
} Light;

typedef struct {
Vector3 position; // Позиция вершины
Vector3 normal; // Нормаль к поверхности
Vector3 color; // Цвет материала
float shininess; // Блеск (для бликов)
} Vertex;

// Скалярное произведение векторов
float dot_product(Vector3 a, Vector3 b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}

// Нормализация вектора
Vector3 normalize(Vector3 v) {
float length = sqrt(dot_product(v, v));
Vector3 result = {v.x / length, v.y / length, v.z / length};
return result;
}

// Оптимизированная версия с использованием SSE
Vector3 normalize_fast(Vector3 v) {
// Реализация с использованием SIMD для параллельных вычислений
float inv_length = 1.0f / sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
v.x *= inv_length;
v.y *= inv_length;
v.z *= inv_length;
return v;
}

Vector3 calculate_lighting(Vertex vertex, Light light, Vector3 camera_pos) {
// Расчет направления от вершины к источнику света
Vector3 light_dir = {
light.position.x – vertex.position.x,
light.position.y – vertex.position.y,
light.position.z – vertex.position.z
};
float distance = sqrt(dot_product(light_dir, light_dir));
light_dir = normalize(light_dir);

// Расчет диффузного компонента (закон Ламберта)
float diff = fmax(dot_product(vertex.normal, light_dir), 0.0);

// Расчет зеркального компонента (модель Фонга)
Vector3 view_dir = {
camera_pos.x – vertex.position.x,
camera_pos.y – vertex.position.y,
camera_pos.z – vertex.position.z
};
view_dir = normalize(view_dir);

Vector3 reflect_dir = {
-light_dir.x + 2.0 * diff * vertex.normal.x,
-light_dir.y + 2.0 * diff * vertex.normal.y,
-light_dir.z + 2.0 * diff * vertex.normal.z
};
float spec = pow(fmax(dot_product(view_dir, reflect_dir), 0.0), vertex.shininess);

// Расчет затухания света с расстоянием
float attenuation = 1.0 / (1.0 + light.attenuation * distance);

// Суммирование компонентов
Vector3 result = {
(0.1 * vertex.color.x) + // ambient component
(diff * vertex.color.x * light.color.x * light.intensity * attenuation) + // diffuse
(spec * light.color.x * light.intensity * attenuation) // specular
// То же самое для y и z компонент
};

return result;
}

Vector3 calculate_lambert_lighting(Vector3 normal, Vector3 light_dir, 
Vector3 diffuse_color, Vector3 light_color) {
// Нормализуем входные векторы
normal = normalize(normal);
light_dir = normalize(light_dir);

// Вычисляем косинус угла между нормалью и направлением света
float diffuse_factor = fmax(dot_product(normal, light_dir), 0.0f);

// Результирующий цвет как произведение диффузного фактора, 
// цвета материала и цвета света
Vector3 result = {
diffuse_factor * diffuse_color.x * light_color.x,
diffuse_factor * diffuse_color.y * light_color.y,
diffuse_factor * diffuse_color.z * light_color.z
};

return result;
}

typedef struct {
float ambient; // Коэффициент фонового освещения
float diffuse; // Коэффициент рассеянного освещения
float specular; // Коэффициент бликового освещения
float shininess; // Показатель блеска
} Material;

Vector3 calculate_phong_lighting(Vector3 position, Vector3 normal, Vector3 view_pos,
Vector3 light_pos, Vector3 light_color,
Vector3 material_color, Material material) {
// Нормализованные векторы для расчетов
normal = normalize(normal);

// Вектор направления к свету
Vector3 light_dir = {
light_pos.x – position.x,
light_pos.y – position.y,
light_pos.z – position.z
};
light_dir = normalize(light_dir);

// Вектор отражения света (для бликового компонента)
float nl_dot = dot_product(normal, light_dir);
Vector3 reflection = {
normal.x * 2.0f * nl_dot – light_dir.x,
normal.y * 2.0f * nl_dot – light_dir.y,
normal.z * 2.0f * nl_dot – light_dir.z
};
reflection = normalize(reflection);

// Вектор направления к камере
Vector3 view_dir = {
view_pos.x – position.x,
view_pos.y – position.y,
view_pos.z – position.z
};
view_dir = normalize(view_dir);

// Компонент фонового освещения
Vector3 ambient = {
material.ambient * material_color.x * light_color.x,
material.ambient * material_color.y * light_color.y,
material.ambient * material_color.z * light_color.z
};

// Компонент диффузного освещения
float diff = fmax(dot_product(normal, light_dir), 0.0f);
Vector3 diffuse = {
material.diffuse * diff * material_color.x * light_color.x,
material.diffuse * diff * material_color.y * light_color.y,
material.diffuse * diff * material_color.z * light_color.z
};

// Компонент бликового освещения
float spec = pow(fmax(dot_product(view_dir, reflection), 0.0f), material.shininess);
Vector3 specular = {
material.specular * spec * light_color.x,
material.specular * spec * light_color.y,
material.specular * spec * light_color.z
};

// Суммируем все компоненты
Vector3 result = {
ambient.x + diffuse.x + specular.x,
ambient.y + diffuse.y + specular.y,
ambient.z + diffuse.z + specular.z
};

return result;
}

// Вариант бликовой составляющей по модели Блинна-Фонга
Vector3 half_vector = {
light_dir.x + view_dir.x,
light_dir.y + view_dir.y,
light_dir.z + view_dir.z
};
half_vector = normalize(half_vector);
float spec = pow(fmax(dot_product(normal, half_vector), 0.0f), material.shininess);

// Функция для создания матрицы проекции тени на плоскость
void create_shadow_matrix(Matrix4x4 result, Vector4 plane, Vector3 light_pos) {
// Плоскость задаётся уравнением ax + by + cz + d = 0
float a = plane.x;
float b = plane.y;
float c = plane.z;
float d = plane.w;

// Координаты источника света
float lx = light_pos.x;
float ly = light_pos.y;
float lz = light_pos.z;

// Вычисляем dot product между нормалью плоскости и позицией света
float dot = a*lx + b*ly + c*lz + d;

// Заполняем матрицу проекции
result[0][0] = dot – a*lx; result[0][1] = -a*ly; result[0][2] = -a*lz; result[0][3] = -a*d;
result[1][0] = -b*lx; result[1][1] = dot – b*ly; result[1][2] = -b*lz; result[1][3] = -b*d;
result[2][0] = -c*lx; result[2][1] = -c*ly; result[2][2] = dot – c*lz; result[2][3] = -c*d;
result[3][0] = -lx; result[3][1] = -ly; result[3][2] = -lz; result[3][3] = dot;

// Нормализуем матрицу
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
result[i][j] /= dot;
}
}
}

// Первый проход: создание карты теней
void create_shadow_map(Light* light, Scene* scene, DepthBuffer* shadow_map) {
// Установка матрицы вида с позиции источника света
Matrix4x4 light_view_matrix;
set_view_matrix(light_view_matrix, light->position, light->target, light->up);

// Матрица проекции (обычно ортографическая для направленного света)
Matrix4x4 light_proj_matrix;
if (light->type == DIRECTIONAL_LIGHT) {
set_orthographic_projection(light_proj_matrix, /* параметры */);
} else {
set_perspective_projection(light_proj_matrix, /* параметры */);
}

// Очистка буфера глубины
clear_depth_buffer(shadow_map);

// Рендеринг сцены с точки зрения света, записывая только глубину
for (int i = 0; i < scene->object_count; i++) {
Object* obj = &scene->objects[i];

// Преобразование вершин объекта в пространство света
transform_vertices(obj, light_view_matrix, light_proj_matrix);

// Запись глубины в shadow_map
rasterize_depth_only(obj, shadow_map);
}
}

// Второй проход: использование карты теней для рендеринга
void render_with_shadows(Scene* scene, Camera* camera, DepthBuffer* shadow_map, 
Light* light, FrameBuffer* framebuffer) {
// Матрицы для преобразования из мирового пространства в пространство света
Matrix4x4 light_view_proj_matrix;
// ... (объединение матриц вида и проекции света)

// Матрица преобразования из пространства NDC в текстурные координаты
Matrix4x4 bias_matrix = {
{0.5f, 0.0f, 0.0f, 0.5f},
{0.0f, 0.5f, 0.0f, 0.5f},
{0.0f, 0.0f, 0.5f, 0.5f},
{0.0f, 0.0f, 0.0f, 1.0f}
};

Matrix4x4 shadow_matrix;
matrix_multiply(shadow_matrix, bias_matrix, light_view_proj_matrix);

// Рендеринг сцены с точки зрения камеры
for (int i = 0; i < scene->object_count; i++) {
Object* obj = &scene->objects[i];

// ... (обычная трансформация и подготовка к рендерингу)

// Для каждого фрагмента при рендеринге:
for (int y = 0; y < framebuffer->height; y++) {
for (int x = 0; x < framebuffer->width; x++) {
// ... (нормальная растеризация)

// Проверка теней
Vector4 world_pos = { /* позиция фрагмента в мировых координатах */ };
Vector4 shadow_coord;
transform_point(shadow_coord, shadow_matrix, world_pos);

float shadow_factor = 1.0f; // 1.0 = полное освещение, 0.0 = полная тень
if (shadow_coord.z <= get_depth_from_shadowmap(shadow_map, shadow_coord.x, shadow_coord.y) + bias) {
shadow_factor = 0.0f; // Точка в тени
}

// Применяем shadow_factor к освещению
// ...
}
}
}
}

#define CASCADE_COUNT 3

typedef struct {
DepthBuffer maps[CASCADE_COUNT];
float split_distances[CASCADE_COUNT + 1];
Matrix4x4 view_proj_matrices[CASCADE_COUNT];
} CascadedShadowMap;

void render_cascaded_shadow_maps(Light* light, Scene* scene, CascadedShadowMap* csm) {
// Разделяем пространство вида на каскады
csm->split_distances[0] = camera.near_plane;
csm->split_distances[CASCADE_COUNT] = camera.far_plane;

// Логарифмическое распределение каскадов
for (int i = 1; i < CASCADE_COUNT; i++) {
float p = (float)i / CASCADE_COUNT;
float log_split = csm->split_distances[0] * 
pow(csm->split_distances[CASCADE_COUNT] / csm->split_distances[0], p);
float uniform_split = csm->split_distances[0] + 
(csm->split_distances[CASCADE_COUNT] – csm->split_distances[0]) * p;
float weight = 0.7f; // Баланс между логарифмическим и равномерным распределением
csm->split_distances[i] = mix(uniform_split, log_split, weight);
}

// Рендерим каждый каскад
for (int i = 0; i < CASCADE_COUNT; i++) {
// Находим границы фрустума для этого каскада и настраиваем проекцию света
// ...

// Рендерим сцену с точки зрения света для этого каскада
create_shadow_map(light, scene, &csm->maps[i]);
}
}

float calculate_pcf_shadow(DepthBuffer* shadow_map, Vector3 shadow_coord, float bias) {
float shadow = 0.0f;
float texel_size = 1.0f / shadow_map->width;

// Берем несколько сэмплов вокруг точки и усредняем результаты
for (int x = -1; x <= 1; x++) {
for (int y = -1; y <= 1; y++) {
float pcf_depth = get_depth_from_shadowmap(
shadow_map, 
shadow_coord.x + x * texel_size, 
shadow_coord.y + y * texel_size
);
shadow += shadow_coord.z – bias > pcf_depth ? 1.0 : 0.0;
}
}

shadow /= 9.0f;
return 1.0f – shadow;
}

// Неоптимизированная функция скалярного произведения
float dot_product_scalar(Vector3 a, Vector3 b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}

// Оптимизированная с использованием SSE
#include <xmmintrin.h>

float dot_product_sse(Vector3 a, Vector3 b) {
__m128 va = _mm_set_ps(0, a.z, a.y, a.x);
__m128 vb = _mm_set_ps(0, b.z, b.y, b.x);
__m128 prod = _mm_mul_ps(va, vb);

// Горизонтальное суммирование
__m128 shuf = _mm_shuffle_ps(prod, prod, _MM_SHUFFLE(2, 3, 0, 1));
__m128 sums = _mm_add_ps(prod, shuf);
shuf = _mm_movehl_ps(shuf, sums);
sums = _mm_add_ss(sums, shuf);

float result;
_mm_store_ss(&result, sums);

return result;
}

// Функция для проверки, находится ли объект в пирамиде видимости
bool is_object_in_frustum(Object* obj, Frustum* frustum) {
// Простая проверка на основе AABB (Axis-Aligned Bounding Box)
Vector3 min_point = obj->bounding_box.min;
Vector3 max_point = obj->bounding_box.max;

for (int i = 0; i < 6; i++) {
Plane* plane = &frustum->planes[i];

// Найдем самую дальнюю точку по нормали плоскости
Vector3 p;
p.x = (plane->normal.x > 0) ? max_point.x : min_point.x;
p.y = (plane->normal.y > 0) ? max_point.y : min_point.y;
p.z = (plane->normal.z > 0) ? max_point.z : min_point.z;

// Если эта точка находится за плоскостью, весь объект невидим
if (dot_product(plane->normal, p) + plane->distance < 0) {
return false;
}
}

return true;
}

// Определение уровня детализации для расчетов освещения
int determine_lighting_lod(Object* obj, Camera* camera) {
// Вычисляем расстояние до объекта
Vector3 to_object = {
obj->position.x – camera->position.x,
obj->position.y – camera->position.y,
obj->position.z – camera->position.z
};
float distance = sqrt(dot_product(to_object, to_object));

// Определяем уровень детализации на основе расстояния и размера объекта
float size_factor = obj->bounding_radius / distance;

if (size_factor > 0.1f) return 0; // Высокий уровень детализации
else if (size_factor > 0.01f) return 1; // Средний уровень детализации
else return 2; // Низкий уровень детализации
}

// Первый проход – заполнение G-буфера
void geometry_pass(Scene* scene, Camera* camera, GBuffer* g_buffer) {
// Очистка буферов
clear_framebuffer(&g_buffer->position);
clear_framebuffer(&g_buffer->normal);
clear_framebuffer(&g_buffer->albedo);
clear_framebuffer(&g_buffer->material);
clear_depth_buffer(&g_buffer->depth);

// Рендеринг геометрии, запись атрибутов в G-буфер
for (int i = 0; i < scene->object_count; i++) {
Object* obj = &scene->objects[i];
if (!is_object_in_frustum(obj, &camera->frustum)) continue;

// Рендеринг объекта в G-буфер
render_to_gbuffer(obj, camera, g_buffer);
}
}

// Второй проход – расчет освещения
void lighting_pass(Scene* scene, GBuffer* g_buffer, FrameBuffer* final_image) {
// Для каждого пикселя экрана
for (int y = 0; y < final_image->height; y++) {
for (int x = 0; x < final_image->width; x++) {
// Извлекаем данные из G-буфера
Vector3 position = read_position(g_buffer, x, y);
Vector3 normal = read_normal(g_buffer, x, y);
Vector3 albedo = read_albedo(g_buffer, x, y);
MaterialParams material = read_material(g_buffer, x, y);

// Инициализируем накопитель для освещения
Vector3 accumulated_light = {0.0f, 0.0f, 0.0f};

// Для каждого источника света
for (int i = 0; i < scene->light_count; i++) {
Light* light = &scene->lights[i];

// Проверяем, влияет ли этот свет на данную точку
if (!is_light_affecting_point(light, position)) continue;

// Рассчитываем освещение от этого источника
Vector3 light_contribution = calculate_lighting(position, normal, 
scene->camera.position, 
light, albedo, material);

// Добавляем к накопленному освещению
accumulated_light.x += light_contribution.x;
accumulated_light.y += light_contribution.y;
accumulated_light.z += light_contribution.z;
}

// Записываем результат в финальное изображение
write_pixel(final_image, x, y, accumulated_light);
}
}
}

typedef struct {
int cell_size; // Размер ячейки в мировых единицах
int table_size; // Размер хеш-таблицы
Light** cells; // Массив указателей на списки источников света
int* cell_counts; // Количество источников в каждой ячейке
} SpatialHashGrid;

// Функция хеширования для получения индекса ячейки
int spatial_hash(Vector3 position, int cell_size, int table_size) {
// Преобразуем мировые координаты в индексы ячеек
int ix = (int)floor(position.x / cell_size);
int iy = (int)floor(position.y / cell_size);
int iz = (int)floor(position.z / cell_size);

// Хеш-функция, комбинирующая три индекса в один
unsigned int hash = (unsigned int)((ix * 73856093) ^ 
(iy * 19349663) ^ 
(iz * 83492791));

return hash % table_size;
}

// Добавление источника света в сетку
void add_light_to_grid(SpatialHashGrid* grid, Light* light) {
// Получаем индекс ячейки для позиции света
int index = spatial_hash(light->position, grid->cell_size, grid->table_size);

// Добавляем свет в соответствующую ячейку
int count = grid->cell_counts[index];
grid->cells[index][count] = light;
grid->cell_counts[index]++;
}

// Получение списка источников света, потенциально влияющих на точку
void get_lights_affecting_point(SpatialHashGrid* grid, Vector3 position, 
Light** result_lights, int* result_count) {
// Получаем индекс ячейки для позиции точки
int index = spatial_hash(position, grid->cell_size, grid->table_size);

// Возвращаем все источники света в этой ячейке
*result_count = grid->cell_counts[index];
for (int i = 0; i < *result_count; i++) {
result_lights[i] = grid->cells[index][i];
}
}

// Инициализация шейдерной программы для фонговского освещения
GLuint setup_phong_shader() {
// Вершинный шейдер
const char* vertex_shader_source = 
"#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n"
"layout(location = 1) in vec3 aNormal;\n"
"uniform mat4 model;\n"
"uniform mat4 view;\n"
"uniform mat4 projection;\n"
"out vec3 FragPos;\n"
"out vec3 Normal;\n"
"void main() {\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"
"}\n";

// Фрагментный шейдер с реализацией модели Фонга
const char* fragment_shader_source = 
"#version 330 core\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"
"out vec4 FragColor;\n"
"void main() {\n"
" // ambient\n"
" float ambientStrength = 0.1;\n"
" vec3 ambient = ambientStrength * lightColor;\n"
" // diffuse\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"
" // specular\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"
" // result\n"
" vec3 result = (ambient + diffuse + specular) * objectColor;\n"
" FragColor = vec4(result, 1.0);\n"
"}\n";

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

GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fragment_shader_source, NULL);
glCompileShader(fragment_shader);

// Создание шейдерной программы
GLuint shader_program = glCreateProgram();
glAttachShader(shader_program, vertex_shader);
glAttachShader(shader_program, fragment_shader);
glLinkProgram(shader_program);

// Освобождение ресурсов после линковки
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);

return shader_program;
}

// Создание и настройка фреймбуфера для карты теней
void setup_shadow_map(GLuint* shadow_map_fbo, GLuint* shadow_map, int shadow_width, int shadow_height) {
// Создание текстуры для карты теней
glGenTextures(1, shadow_map);
glBindTexture(GL_TEXTURE_2D, *shadow_map);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 
shadow_width, shadow_height, 0, 
GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);

// Создание фреймбуфера и прикрепление текстуры глубины
glGenFramebuffers(1, shadow_map_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, *shadow_map_fbo);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, *shadow_map, 0);
glDrawBuffer(GL_NONE);
glReadBuffer(GL_NONE);

// Проверка комплектности фреймбуфера
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
printf("Error: Shadow framebuffer is not complete!\n");
}

glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

// Создание буфера для констант шейдера (Common Buffer Object)
void create_constant_buffer(ID3D11Device* device, ID3D11Buffer** constant_buffer, 
UINT buffer_size) {
D3D11_BUFFER_DESC buffer_desc = {0};
buffer_desc.Usage = D3D11_USAGE_DYNAMIC;
buffer_desc.ByteWidth = buffer_size;
buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

HRESULT hr = device->lpVtbl->CreateBuffer(device, &buffer_desc, NULL, constant_buffer);
if (FAILED(hr)) {
printf("Failed to create constant buffer\n");
}
}

// Обновление буфера констант с парамет

**Читайте также**
- [Однородные координаты в 3D-графике: матричные преобразования объектов](/gamedev/odnorodnye-koordinaty-v-3d-grafike/)
- [Эволюция 3D графики: от проволочных моделей к фотореализму](/digital-art/istoriya-i-razvitie-3d-grafiki/)
- [OpenGL: создание 3D-графики с нуля – первые шаги для новичков](/gamedev/vvedenie-v-opengl-dlya-3d-grafiki/)
- [Матрицы поворота в 3D графике: управление трёхмерным пространством](/gamedev/matrica-povorota-v-3d-grafike/)
- [Математика в 3D графике: превращаем формулы в инструменты творчества](/digital-art/osnovy-matematiki-dlya-3d-grafiki/)
- [Матрицы трансформации в 3D: ключи к управлению виртуальным миром](/gamedev/matrica-transformacii-v-3d-grafike/)
- [ANGLE: мост между OpenGL ES и нативными графическими API](/gamedev/osnovy-angle-dlya-3d-grafiki/)
- [Трехмерное вращение объектов: математика, техники, решения](/gamedev/povorot-vokrug-osej-v-3d-grafike/)
- [Разработка 3D движка на C: от математики до оптимизации рендеринга](/gamedev/realizaciya-prostogo-3d-dvizhka-na-c/)
- [Матрица масштабирования в 3D: создание и трансформация объектов](/gamedev/matrica-masshtabirovaniya-v-3d-grafike/)