Scene not Graph

class GameObject {
public:
    virtual void preRender();
    virtual void render();
    virtual void postRender();
    hvector children;
};
void GameObject::renderTree() {
    preRender();   // настроить состояние
    render();      // нарисовать объект
    for (auto* child : children)
        child->renderTree();
    postRender();  // восстановить состояние
}

// дерево сцены:
// Root
//   Wall (material: stone)
//   Player (material: character)
//   Floor (material: stone)  <-- тот же материал что у Wall, но рисуется третьим
// обход дает нам такую последовательность вызовов:
// bind stone shader
// draw wall
// bind character shader  <-- переключение
// draw player
// bind stone shader      <-- ещё одно переключение
// draw floor
// 3 переключения конвейера отрисовки

// дерево сцены:
Root
  Wall (material: stone)
  Player (material: character)
  Floor (material: stone)  <-- тот же материал что у Wall
sort objects by material
// обход дает нам такую последовательность вызовов:
bind stone shader
draw wall
draw floor
bind character shader  <-- переключение
draw player
2 переключения конвейера отрисовки

// правильный порядок отрисовки прозрачных объектов:
// сначала дальние, потом ближние к камере
struct TransparentObject {
    Mesh* mesh;
    float distanceToCamera;
};
// нужна сортировка по дистанции, но дерево её не предоставляет
std::sort(transparents.begin(), transparents.end(),
    [](const auto& a, const auto& b) {
        return a.distanceToCamera > b.distanceToCamera;
    });

struct TransparentDrawCall {
    Mesh* mesh;
    Material* material;
    glm::mat4 transform;
    float distanceToCamera;
};
void Renderer::renderTransparents(const Camera& camera) {
    std::vector transparents;
    for (auto* obj : scene.transparentObjects) {
        glm::vec3 center = obj->getWorldBounds().center();
        float dist = glm::length(center - camera.position);
        transparents.push_back({obj->mesh, obj->material,
                                obj->transform, dist});
    }
    // сортируем сзади наперёд
    std::sort(transparents.begin(), transparents.end(),
        [](const auto& a, const auto& b) {
            return a.distanceToCamera > b.distanceToCamera;
        });
    // рисуем с выключенной записью в depth buffer
    // но с чтением из него — чтобы непрозрачная геометрия
    // корректно перекрывала прозрачную
    setDepthWrite(false);
    setDepthTest(true);
    for (auto& call : transparents)
        draw(call);
    setDepthWrite(true);
}

void Renderer::renderFrame() {
    renderOpaquePass();           // непрозрачная геометрия
    renderAlphaTestPass();        // листва, решётки — без сортировки
    renderTransparentPass();      // WBOIT или сортировка по глубине
    renderParticlePass();         // аддитивное смешение — без сортировки
    renderPostProcess();          // постпроцессинг
    renderUIPass();               // UI поверх всего
}

class GameObject {
    bool castsShadow = true;
    bool receivesTransparency = false;
    bool renderInMirror = true;
    int renderLayer = 0;
    // ... ещё десяток флагов
};

glBindTexture(GL_TEXTURE_2D, texture1);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindTexture(GL_TEXTURE_2D, texture2);
glDrawArrays(GL_TRIANGLES, 0, 24);

vkCmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
vkCmdBindVertexBuffers(cmdBuffer, 0, 1, &vertexBuffer, offsets);
vkCmdDraw(cmdBuffer, vertexCount, 1, 0, 0);
// тут еще можно пройтись по буферу и чтото изменить
...
// отправка произойдёт позже, когда мы вызовем vkQueueSubmit

struct DrawCommand {
    uint64_t sortKey; // закодированные приоритеты
    Mesh* mesh;
    Material* material;
    vec4 transform;
};
// сортируем перед отправкой
std::sort(opaqueCommands.begin(), opaqueCommands.end(),
    [](const auto& a, const auto& b) {
        return a.sortKey < b.sortKey;
    });
// sortKey можно строить упаковывая разные поля в биты:
// [shader_id: 16 bits][material_id: 16 bits][depth: 24 bits][...]

class StaticMesh {
    hvector cachedCommands;
    bool dirty = true;
public:
    void buildCommands() {
        if (!dirty) return;
        cachedCommands.clear();
        // заполняем один раз
        dirty = false;
    }
    void submitTo(RenderQueue& queue) {
        buildCommands();
        queue.append(cachedCommands); // просто копируем
    }
};

class RHI {
public:
    virtual RHIBuffer* createBuffer(size_t size, BufferUsage usage) = 0;
    virtual RHITexture* createTexture(TextureDesc desc) = 0;
    virtual void draw(RHICommandList* cmd, uint32_t vertexCount) = 0;
};
class VulkanRHI : public RHI {
    void draw(RHICommandList* cmd, uint32_t vertexCount) override {
        auto* vkCmd = static_cast(cmd);
        vkCmdDraw(vkCmd->handle, vertexCount, 1, 0, 0);
    }
};
class D3D12RHI : public RHI {
    void draw(RHICommandList* cmd, uint32_t vertexCount) override {
        auto* d3dCmd = static_cast(cmd);
        d3dCmd->list->DrawInstanced(vertexCount, 1, 0, 0);
    }
};

// объект не знает как его нарисуют, он только сообщает о себе
class MeshComponent {
public:
    void collectRenderData(RenderScene& scene) {
        scene.submitMesh(
            NMesh{ mesh },
            NMaterial{ material },
            NTransform{ getWorldTransform() },
            NCastsShadow{ true },
            NRenderLayer{ RenderLayer::Opaque }
        });
    }
};