std140: статическая валидация структур

std140 – самый платформонезависимый лейаут uniform-блоков. Если вы передаете параметры в шейдер структурами, а не по одному, то лучше использовать именно его. Конечно, у переносимости есть своя цена: стандарт предусматривает несколько ограничений, самое известное из которых – выравнивание по 16 байтам. То есть, все поля структуры должны быть по размеру кратны 16 байтам. Например, если это вектор – то vec4, если матрица – то mat4. Некратные 16 байтам типы (float, int и др.) также можно использовать, но их необходимо выравнивать вручную – то есть, одиночный float пойдет все равно как vec4. Использование невыровненных данных приводит к тому, что в шейдере считываются неправильные значения, и это вызывает недоумение у начинающих.

Благодаря CTFE и статической интроспекции в D можно проверять структуры на соответствие этому правилу на этапе компиляции – все необходимое есть в std.traits:

import std.traits;

bool fieldsAligned(T, alias numBytes)()
{
    static if (is(T == struct))
    {
        alias FieldTypes = Fields!T;
        
        static foreach(FT; FieldTypes)
        {
            static if (FT.sizeof % numBytes != 0)
                return false;
        }
        
        return true;
    }
    else return false;
}

alias Std140Compliant(T) = fieldsAligned!(T, 16);

Теперь можно делать так:

import dlib.math.vector;
import dlib.math.matrix;

struct Uniforms
{
    Matrix4x4f modelViewMatrix;
    Matrix4x4f normalMatrix;
    Vector4f worldPosition;
    float someParameter; // Will not compile, use Vector4f instead
}

static assert(Std140Compliant!Uniforms,
    Uniforms.stringof ~ " does not conform to std140 layout");

Возникает вопрос, почему бы просто не делать align(16)? Можно!

struct AlignedUniforms
{
  align(16):
    float a;
    Vector3f b;
    Matrix4x4f c;
}

Преимуществом такого подхода является право использовать любые типы для полей, но это неэффктивно: например, вместо того, чтобы впустую расходовать три байта после a, можно было бы упаковать a вместе с b в один 16-байтный вектор. Поэтому я лично не фанат автоматического компиляторного выравнивания – лучше это делать вручную, защитившись от ошибок необходимыми статическими проверками.

Обновления

bindbc-newton 0.3.2

Небольшой исправляющий релиз, который фиксит список путей к Newton под Linux.

https://github.com/gecko0307/bindbc-newton/releases/tag/v0.3.2

dlib2 компилируется под WASM

Поддержка Web Assembly в LDC существует достаточно давно, и я когда-то уже делал экспериментальный мини-проект – приложение с треугольником, рисующимся через OpenGL ES, которое можно скомпилировать как под десктоп, так и в WASM-модуль. Для этой работы пришлось написать минимальную замену стандартной библиотеке, поскольку поддержка WASM в Phobos чуть более, чем никакая. Надеюсь изменить эту ситуацию в dlib2 – dcore уже сейчас можно собрать под WASM!

Например, вот такой “Hello, World” на десктопе печатает в стандартный вывод, а в браузере – в консоль, причем с поддержкой UTF-8:

module main;

import dcore.stdio;

extern(C):

void main()
{
    // Minimal cross-platform betterC application.
    // Will print to stdout on desktop and to the console in browser.
    
    printf("Hello from D! Привет из D!\n");
}

В ближайшее время напишу пост по статусу dlib2 и всем деталям планируемых фич.

Багфиксы и улучшения в MiniGL

Актуализировал и чуть доработал MiniGL, мой программный растеризатор. Исправил альфа-смешивание, а также теперь можно отключить запись и чтение z-буфера для отрисовки экранных спрайтов. Обновил также демонстрационное приложение – теперь это почти готовый движок для коридорных ретро-шутеров: есть проверка столкновений со стенами, стрельба магией и спрайт оружия.

Упрощенный рендеринг

По мере усложнения стандартного рендер-движка Dagon, повышаются и системные требования – в данный момент он требует довольно мощную видеокарту геймерского класса, желательно NVIDIA. Но, поскольку далеко не все игры обязаны иметь топовую графику, неплохо предусмотреть в движке некий облегченный режим, оптимальный для казуальных жанров и стилизации под ретро, где не нужен сложный пайплайн с реалистичным освещением и PBR. В Dagon рендер уже давно структурно вынесен в отдельную систему, которую можно модифицировать и даже полностью заменять, не трогая остальной код движка – модель данных сцены и менеджер ресурсов в Dagon полностью независимы от рендера. Это позволило без особых сложностей добавить упрощенный рендер-движок SimpleRenderer, который вы можете создать в вашем классе игры (на базе Game или Application) и заменить им стандартный DeferredRenderer.

SimpleRenderer полностью переопределяет рендеринг объектов. Здесь по умолчанию нет физически обоснованных источников света, карт окружения и т.д. – за освещение отвечает простейшая модель Блинна-Фонга, которая в данный момент работает с одним глобальным направленным источником света (environment.sun текущей сцены). Нет normal mapping’а и прочих эффектов материала – учитывается только baseColorFactor/baseColorTexture. Но зато вы можете назначить вашим материалам любой шейдер с любыми эффектами – в DeferredRenderer такой возможности нет (все объекты с пользовательскими шейдерами трактуются как forward и рендерятся отдельно, после всех deferred-проходов). Также в этой системе поддерживаются слои, что позволяет явным образом задавать порядок рендеринга группам объектов – например, можно занести все прозрачные объекты в отдельный слой, который рисуется поверх дефолтного.

SimpleRenderer отлично подойдет для создания игр для low-end железа, он будет работать даже на самых слабых системах.

Бокс-проекция

Добавил в Dagon поддержку бокс-проекции для световых зондов окружения (EnvironmentProbe). Техника старая, но никем не отмененная – а главное, хорошо сочетается с deferred-рендером!

Стандартный environment mapping предполагает, что стенки виртуальной среды, с которой считывается освещение, бесконечно удалены от объектов сцены. Это допущение работает для открытого пространства, но не годится для интерьера. Бокс-проекция корректирует сэмплинг из карты окружения так, что результат выровнен по сторонам бокса заданного размера, благодаря чему минимумом ресурсов достигается сносного качества непрямое освещение в интерьере (если, конечно, карта окружения 1 в 1 совпадает с моделью комнаты). Это эффективный способ аппроксимировать локальный GI в ограниченном пространстве: окружение интерьера, с которого рендерилась карта, статичное, но любые другие объекты могут быть динамическими. При трансформации камеры или объекта внутри комнаты, отражения соответствующим образом меняются, причем как зеркальные, так и диффузные.

Получается даже имитировать объемные источники света! На скриншотах ниже нет ничего, кроме параллельного источника света для солнца и двух статичных карт окружения – для улицы и для интерьера. Отражения окон и светящегося блока на полу получаются автоматически:

Главным минусом техники является то, что создать под нее правильную карту не очень просто – нужно учитывать различия в координатных системах.

Тригонометрия в бенчмарках

“Неважно, что ты любишь больше:
косинус ли, синус ли…”

Тригонометрия – основа многих приложений, от компьютерной графики до научных симуляций. Все мы привыкли вызывать sin и cos, не задумываясь, как они реализованы. А реализации могут быть разные! Работая над математической библиотекой для dlib2, я провел интересное исследование – какая тригонометрия лучше? Конечно, есть функции из std.math, и в большинстве случаев подойдут именно они. Но не все так просто – все зависит от того, что именно вы разрабатываете.

Если вы собираете обычное приложение, то кажется, что беспокоиться не о чем. Но если вам, по тем или иным причинам, нельзя обращаться к Phobos? Тогда есть два основных пути – sin и cos из стандартной библиотеки C, либо кастомная реализация, если код собирается под голое железо (например, при создании ядра ОС или программировании встраиваемой электроники). Но если вы используете LDC, то ничто не мешает использовать интринсики LLVM – они, оказывается, работают быстрее, чем std.math!

Я провел ряд тестов для всех вариантов тригонометрии:

  • Тест на точность – вычисление синуса и косинуса для 200 аргументов от -π до +π. Замерялась максимальная погрешность – расхождение результата с std.math.sin и std.math.cos;
  • Тест на производительность – время вычисления синуса и косинуса 1000000 раз.

Во всех кейсах я использовал LDC 1.39.0 под Windows 10. Получилось следующее:

  • std.math.sin, std.math.cos:
    • Время выполнения: 4 мс
  • LLVM интринсики llvm_sin, llvm_cos:
    • Время выполнения: 2 мс
    • Точность: абсолютная (макс. погрешность для sin: 0, для cos: 0)
  • Функции sin, cos из стандартной библиотеки C:
    • Время выполнения: 21 мс
    • Точность: абсолютная (макс. погрешность для sin: 0, для cos: 0)
  • Моя кастомная реализация на таблицах:
    • Время выполнения: 33 мс
    • Точность: порядка 10-7 (макс. погрешность для sin: 2.97038e-07, для cos: 1.78188e-07)

Также я пробовал версию с ассемблерными вставками, но она получилась почему-то медленнее кастомной – видимо, при использовании инлайнового ассемблера компилятор не задействует какие-то оптимизации (а еще есть мнение, что x87 fsin, fcos на современных процессорах медленные сами по себе). Смысла в таком варианте реализации особо нет, так что я его не стал рассматривать для включения в библиотеку.

В итоге в dlib2 войдут четыре реализации с таким приоритетом:

  • Если используется LDC, то синус и косинус – это интринсики (то есть, кодогенератор сам выбирает оптимальную реализацию под нужную архитектуру);
  • Если используются другие компиляторы (DMD, GDC):
    • Если код компилируется с поддержкой Phobos, то используются функции из std.math;
    • Если код собирается в режиме version(NoPhobos), но не version(FreeStanding) (то есть, под Windows или Unix-подобную ОС), то используются функции рантайма C;
    • Если же идет компиляция в bare metal, то используется кастомная реализация на таблицах.