forward_lit_scene_mesh_subrender_internal.h

#pragma once
 
#include "pixelbullet/assets/material.h"
#include "pixelbullet/core/assert.h"
#include "pixelbullet/private/graphics/rendering/buffers/buffer.h"
#include "pixelbullet/private/graphics/rendering/buffers/morph_mesh_resource.h"
#include "pixelbullet/private/graphics/rendering/buffers/skinned_mesh_resource.h"
#include "pixelbullet/private/graphics/rendering/buffers/skinned_morph_mesh_resource.h"
#include "pixelbullet/private/graphics/rendering/buffers/static_mesh_resource.h"
#include "pixelbullet/private/graphics/rendering/buffers/storage_buffer.h"
#include "pixelbullet/private/graphics/rendering/buffers/uniform_handler.h"
#include "pixelbullet/private/graphics/rendering/descriptors/descriptors_handler.h"
#include "pixelbullet/private/graphics/runtime_support/images/image_2d.h"
#include "pixelbullet/private/graphics/rendering/images/image_cube.h"
#include "pixelbullet/private/graphics/rendering/images/image_depth.h"
#include "pixelbullet/private/graphics/rendering/pipelines/pipeline_graphics.h"
#include "pixelbullet/private/scene/rendering/forward_lit_scene_mesh_subrender.h"
#include "pixelbullet/private/scene/rendering/render_resource_resolver.h"
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace pixelbullet
{
namespace forward_lit_scene_mesh_internal
{
constexpr uint32_t k_max_point_light_count = 8;
constexpr uint32_t k_max_spot_light_count = 8;
 
enum class MeshDrawKind
{
    None,
    Static,
    Morph,
    Skinned,
    SkinnedMorph,
};
 
struct SceneUniformState
{
    glm::mat4 view_projection{ 1.0f };
    glm::vec4 camera_position_ambient_intensity{ 0.0f, 0.0f, 0.0f, 0.32f };
    glm::vec4 ambient_color{ 0.18f, 0.19f, 0.24f, 0.0f };
    glm::vec4 environment_params{ 0.0f };
};
 
struct DirectionalLightGpu
{
    glm::vec4 direction_intensity{ 0.0f, 0.0f, -1.0f, 0.0f };
    glm::vec4 color{ 1.0f, 1.0f, 1.0f, 0.0f };
};
 
struct PointLightGpu
{
    glm::vec4 position_range{ 0.0f };
    glm::vec4 color_intensity{ 0.0f };
};
 
struct SpotLightGpu
{
    glm::vec4 position_range{ 0.0f };
    glm::vec4 direction_outer_cos{ 0.0f, 0.0f, -1.0f, 0.0f };
    glm::vec4 color_intensity{ 0.0f };
    glm::vec4 angle_params{ 1.0f, 0.0f, 0.0f, 0.0f };
};
 
struct LightingUniformState
{
    DirectionalLightGpu directional_light{};
    std::array<PointLightGpu, k_max_point_light_count> point_lights{};
    std::array<SpotLightGpu, k_max_spot_light_count> spot_lights{};
    glm::vec4 light_counts{ 0.0f };
    glm::mat4 shadow_view_projection{ 1.0f };
    glm::vec4 shadow_params0{ 0.0f };
    glm::vec4 shadow_params1{ 0.0f };
};
 
struct MeshUniformState
{
    glm::mat4 model{ 1.0f };
    glm::vec4 base_color_factor{ 1.0f };
    glm::vec4 material_factors{ 0.0f, 1.0f, 0.0f, 0.0f };
    glm::vec4 emissive_factor{ 0.0f };
    glm::vec4 material_strengths{ 1.0f, 1.0f, 1.0f, 0.0f };
    glm::vec4 ior_factor{ 1.5f, 0.0f, 0.0f, 0.0f };
    glm::vec4 transmission_factors{ 0.0f };
    glm::vec4 transmission_semantics{ 0.0f };
    glm::vec4 transmission_texture_uv_sets{ 0.0f };
    glm::vec4 transmission_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 transmission_uv_rotations{ 0.0f };
    glm::vec4 volume_factors{ 0.0f };
    glm::vec4 volume_attenuation_color{ 1.0f, 1.0f, 1.0f, 0.0f };
    glm::vec4 volume_semantics{ 0.0f };
    glm::vec4 volume_texture_uv_sets{ 0.0f };
    glm::vec4 volume_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 volume_uv_rotations{ 0.0f };
    glm::vec4 material_semantics{ 0.0f, 0.5f, 0.0f, 0.0f };
    glm::vec4 texture_uv_sets{ 0.0f };
    glm::vec4 base_color_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 normal_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 orm_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 emissive_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 texture_uv_rotations{ 0.0f };
    glm::vec4 specular_factors{ 1.0f, 1.0f, 1.0f, 1.0f };
    glm::vec4 specular_semantics{ 0.0f };
    glm::vec4 specular_texture_uv_sets{ 0.0f };
    glm::vec4 specular_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 specular_color_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 specular_uv_rotations{ 0.0f };
    glm::vec4 clearcoat_factors{ 0.0f, 0.0f, 1.0f, 0.0f };
    glm::vec4 clearcoat_semantics{ 0.0f };
    glm::vec4 clearcoat_texture_uv_sets{ 0.0f };
    glm::vec4 clearcoat_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 clearcoat_roughness_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 clearcoat_normal_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 clearcoat_uv_rotations{ 0.0f };
    glm::vec4 sheen_factors{ 0.0f };
    glm::vec4 sheen_semantics{ 0.0f };
    glm::vec4 sheen_texture_uv_sets{ 0.0f };
    glm::vec4 sheen_color_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 sheen_roughness_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 sheen_uv_rotations{ 0.0f };
    glm::vec4 iridescence_factors{ 0.0f, 1.3f, 100.0f, 400.0f };
    glm::vec4 iridescence_semantics{ 0.0f };
    glm::vec4 iridescence_texture_uv_sets{ 0.0f };
    glm::vec4 iridescence_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 iridescence_thickness_uv_transform{ 0.0f, 0.0f, 1.0f, 1.0f };
    glm::vec4 iridescence_uv_rotations{ 0.0f };
};
 
struct SlotDependencies
{
    std::string mesh_path;
    std::string material_path;
    std::vector<std::string> material_texture_paths;
};
 
struct ResolvedResources
{
    std::shared_ptr<StaticMeshResource> static_mesh;
    std::shared_ptr<MorphMeshResource> morph_mesh;
    std::shared_ptr<SkinnedMeshResource> skinned_mesh;
    std::shared_ptr<SkinnedMorphMeshResource> skinned_morph_mesh;
    std::shared_ptr<Image2D> base_color_texture;
    std::shared_ptr<Image2D> normal_texture;
    std::shared_ptr<Image2D> orm_texture;
    std::shared_ptr<Image2D> emissive_texture;
    std::shared_ptr<Image2D> transmission_texture;
    std::shared_ptr<Image2D> volume_thickness_texture;
    std::shared_ptr<Image2D> specular_texture;
    std::shared_ptr<Image2D> specular_color_texture;
    std::shared_ptr<Image2D> clearcoat_texture;
    std::shared_ptr<Image2D> clearcoat_roughness_texture;
    std::shared_ptr<Image2D> clearcoat_normal_texture;
    std::shared_ptr<Image2D> sheen_color_texture;
    std::shared_ptr<Image2D> sheen_roughness_texture;
    std::shared_ptr<Image2D> iridescence_texture;
    std::shared_ptr<Image2D> iridescence_thickness_texture;
    std::vector<std::unique_ptr<StorageBuffer>> joint_palette_buffers;
    std::vector<std::unique_ptr<StorageBuffer>> morph_weights_buffers;
 
    void ResetResolvedBindings() noexcept
    {
        static_mesh.reset();
        morph_mesh.reset();
        skinned_mesh.reset();
        skinned_morph_mesh.reset();
        base_color_texture.reset();
        normal_texture.reset();
        orm_texture.reset();
        emissive_texture.reset();
        transmission_texture.reset();
        volume_thickness_texture.reset();
        specular_texture.reset();
        specular_color_texture.reset();
        clearcoat_texture.reset();
        clearcoat_roughness_texture.reset();
        clearcoat_normal_texture.reset();
        sheen_color_texture.reset();
        sheen_roughness_texture.reset();
        iridescence_texture.reset();
        iridescence_thickness_texture.reset();
    }
 
    [[nodiscard]] StorageBuffer* GetJointPaletteBuffer(const uint32_t image_index) const noexcept
    {
        return image_index < joint_palette_buffers.size() ? joint_palette_buffers[image_index].get() : nullptr;
    }
 
    [[nodiscard]] StorageBuffer* GetMorphWeightsBuffer(const uint32_t image_index) const noexcept
    {
        return image_index < morph_weights_buffers.size() ? morph_weights_buffers[image_index].get() : nullptr;
    }
 
    [[nodiscard]] const Buffer* GetVertexBuffer() const noexcept
    {
        if (static_mesh)
        {
            return static_mesh->GetVertexBuffer();
        }
        if (morph_mesh)
        {
            return morph_mesh->GetVertexBuffer();
        }
        if (skinned_mesh)
        {
            return skinned_mesh->GetVertexBuffer();
        }
        if (skinned_morph_mesh)
        {
            return skinned_morph_mesh->GetVertexBuffer();
        }
        return nullptr;
    }
 
    [[nodiscard]] const Buffer* GetIndexBuffer() const noexcept
    {
        if (static_mesh)
        {
            return static_mesh->GetIndexBuffer();
        }
        if (morph_mesh)
        {
            return morph_mesh->GetIndexBuffer();
        }
        if (skinned_mesh)
        {
            return skinned_mesh->GetIndexBuffer();
        }
        if (skinned_morph_mesh)
        {
            return skinned_morph_mesh->GetIndexBuffer();
        }
        return nullptr;
    }
 
    [[nodiscard]] uint32_t GetIndexCount() const noexcept
    {
        if (static_mesh)
        {
            return static_mesh->GetIndexCount();
        }
        if (morph_mesh)
        {
            return morph_mesh->GetIndexCount();
        }
        if (skinned_mesh)
        {
            return skinned_mesh->GetIndexCount();
        }
        if (skinned_morph_mesh)
        {
            return skinned_morph_mesh->GetIndexCount();
        }
        return 0u;
    }
 
    [[nodiscard]] bool HasRenderableMesh() const noexcept
    {
        return GetVertexBuffer() != nullptr && GetIndexBuffer() != nullptr && GetIndexCount() > 0u;
    }
};
 
static_assert(sizeof(SceneUniformState) == sizeof(float) * 28);
static_assert(sizeof(LightingUniformState) == sizeof(float) * 228);
static_assert(sizeof(MeshUniformState) == sizeof(float) * 208);
 
VertexLayout CreateStaticMeshVertexInput();
VertexLayout CreateSkinnedMeshVertexInput();
std::vector<ShaderDefine> CreateLitSceneDefines();
const VirtualPath& LitSceneVertexShader();
const VirtualPath& LitSceneMorphVertexShader();
const VirtualPath& LitSceneSkinnedVertexShader();
const VirtualPath& LitSceneSkinnedMorphVertexShader();
const VirtualPath& LitSceneFragmentShader();
const std::string& ShadowMapAttachmentName();
const VirtualPath& FlatWhiteTexture();
const VirtualPath& FallbackEnvironmentCubemap();
std::vector<std::string> CollectMaterialTexturePaths(const Material& material);
std::vector<std::size_t> CollectMatchingSlotIndices(const std::vector<std::optional<SlotDependencies>>& slot_dependencies,
                                                    const ForwardLitSceneMeshAssetChangeSet& change_set);
bool MatchesActiveEnvironmentCubemapRoot(const std::optional<std::string>& active_cubemap_root,
                                         const std::vector<std::string>& changed_cubemaps) noexcept;
bool MatchesActiveEnvironmentAsset(const std::optional<std::string>& active_environment_asset,
                                   const std::vector<std::string>& changed_environment_assets) noexcept;
 
void ValidatePipelineLayouts(ForwardLitSceneMeshSubrenderImpl& impl);
void Render(ForwardLitSceneMeshSubrenderImpl& impl, const RenderFrameContext& frame_context);
std::size_t RefreshAllAssetCaches(ForwardLitSceneMeshSubrenderImpl& impl);
std::size_t RefreshAssetCaches(ForwardLitSceneMeshSubrenderImpl& impl, const ForwardLitSceneMeshAssetChangeSet& change_set);
} // namespace forward_lit_scene_mesh_internal
 
struct ForwardLitSceneMeshSubrenderImpl
{
    ForwardLitSceneMeshSubrenderImpl(const Subrender::Stage& stage, RenderDevice& render_device, Filesystem& filesystem,
                                     ResourceCache& resource_cache, const SceneRenderData& render_data,
                                     const ForwardLitMaterialOverrideProvider* material_override_provider);
 
    void EnsureMeshCapacity(std::size_t mesh_count)
    {
        ASSERT(mesh_layout.has_value(), "Forward lit scene mesh layout must be initialized");
        while (mesh_uniforms.size() < mesh_count)
        {
            UniformHandler mesh_uniform(render_device);
            mesh_uniform.Update(mesh_layout);
            mesh_uniforms.emplace_back(std::move(mesh_uniform));
            mesh_descriptors.emplace_back(culled_pipeline);
            resolved_resources.emplace_back();
            slot_draw_kinds.emplace_back(forward_lit_scene_mesh_internal::MeshDrawKind::None);
            slot_dependencies.emplace_back(std::nullopt);
        }
    }
 
    void InvalidateSlotState(std::size_t slot_index)
    {
        if (slot_index >= resolved_resources.size())
        {
            return;
        }
 
        resolved_resources[slot_index].ResetResolvedBindings();
        slot_draw_kinds[slot_index] = forward_lit_scene_mesh_internal::MeshDrawKind::None;
        slot_dependencies[slot_index].reset();
    }
 
    void InvalidateAllSlotState()
    {
        for (std::size_t slot_index = 0; slot_index < resolved_resources.size(); ++slot_index)
        {
            InvalidateSlotState(slot_index);
        }
    }
 
    void ClearUnusedSlotState(std::size_t mesh_count)
    {
        for (std::size_t mesh_index = mesh_count; mesh_index < resolved_resources.size(); ++mesh_index)
        {
            InvalidateSlotState(mesh_index);
        }
    }
 
    [[nodiscard]] std::size_t CountActiveSlots() const noexcept
    {
        return static_cast<std::size_t>(
            std::count_if(slot_dependencies.begin(), slot_dependencies.end(), [](const auto& slot) { return slot.has_value(); }));
    }
 
    [[nodiscard]] std::vector<std::size_t> CollectMatchingSlotIndices(const ForwardLitSceneMeshAssetChangeSet& change_set) const;
 
    const SceneRenderData* render_data = nullptr;
    RenderDevice& render_device;
    RenderResourceResolver resource_resolver;
    const ForwardLitMaterialOverrideProvider* material_override_provider = nullptr;
    PipelineGraphics culled_pipeline;
    PipelineGraphics double_sided_pipeline;
    PipelineGraphics transparent_culled_pipeline;
    PipelineGraphics transparent_double_sided_pipeline;
    PipelineGraphics morph_culled_pipeline;
    PipelineGraphics morph_double_sided_pipeline;
    PipelineGraphics morph_transparent_culled_pipeline;
    PipelineGraphics morph_transparent_double_sided_pipeline;
    PipelineGraphics skinned_culled_pipeline;
    PipelineGraphics skinned_double_sided_pipeline;
    PipelineGraphics skinned_transparent_culled_pipeline;
    PipelineGraphics skinned_transparent_double_sided_pipeline;
    PipelineGraphics skinned_morph_culled_pipeline;
    PipelineGraphics skinned_morph_double_sided_pipeline;
    PipelineGraphics skinned_morph_transparent_culled_pipeline;
    PipelineGraphics skinned_morph_transparent_double_sided_pipeline;
    std::optional<BufferLayout> mesh_layout;
    UniformHandler scene_uniforms;
    UniformHandler lighting_uniforms;
    std::vector<UniformHandler> mesh_uniforms;
    std::vector<DescriptorsHandler> mesh_descriptors;
    std::vector<forward_lit_scene_mesh_internal::ResolvedResources> resolved_resources;
    std::vector<forward_lit_scene_mesh_internal::MeshDrawKind> slot_draw_kinds;
    std::vector<std::optional<forward_lit_scene_mesh_internal::SlotDependencies>> slot_dependencies;
    std::optional<std::string> environment_asset_path;
    std::optional<std::string> environment_skybox_cubemap_root;
    std::optional<std::string> environment_diffuse_irradiance_cubemap_root;
    std::optional<std::string> environment_specular_prefilter_cubemap_root;
    std::shared_ptr<ImageCube> environment_skybox_cubemap;
    std::shared_ptr<ImageCube> environment_diffuse_irradiance_cubemap;
    std::shared_ptr<ImageCube> environment_specular_prefilter_cubemap;
};
} // namespace pixelbullet