directional_shadow_scene_mesh_subrender_internal.h

#pragma once
 
#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/pipelines/pipeline_graphics.h"
#include "pixelbullet/graphics/subrender.h"
#include "pixelbullet/private/scene/rendering/render_resource_resolver.h"
#include "pixelbullet/scene/render_data.h"
 
#include <cstddef>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace pixelbullet
{
enum class DirectionalShadowMeshDrawKind
{
    None,
    Static,
    Morph,
    Skinned,
    SkinnedMorph,
};
 
class Filesystem;
class RenderDevice;
class ResourceCache;
 
struct DirectionalShadowResolvedResources
{
    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::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();
    }
 
    [[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;
    }
};
 
struct DirectionalShadowSceneMeshSubrenderImpl
{
    DirectionalShadowSceneMeshSubrenderImpl(const Subrender::Stage& stage, RenderDevice& render_device, Filesystem& filesystem,
                                            ResourceCache& resource_cache, const SceneRenderData& render_data);
 
    void EnsureMeshCapacity(std::size_t mesh_count);
    void InvalidateSlotState(std::size_t slot_index);
    void ClearUnusedSlotState(std::size_t mesh_count);
 
    const SceneRenderData* render_data = nullptr;
    RenderDevice& render_device;
    RenderResourceResolver resource_resolver;
    PipelineGraphics culled_pipeline;
    PipelineGraphics double_sided_pipeline;
    PipelineGraphics morph_culled_pipeline;
    PipelineGraphics morph_double_sided_pipeline;
    PipelineGraphics skinned_culled_pipeline;
    PipelineGraphics skinned_double_sided_pipeline;
    PipelineGraphics skinned_morph_culled_pipeline;
    PipelineGraphics skinned_morph_double_sided_pipeline;
    std::optional<BufferLayout> mesh_layout;
    UniformHandler scene_uniforms;
    std::vector<UniformHandler> mesh_uniforms;
    std::vector<DescriptorsHandler> mesh_descriptors;
    std::vector<DirectionalShadowResolvedResources> resolved_resources;
    std::vector<DirectionalShadowMeshDrawKind> slot_draw_kinds;
    std::vector<std::optional<std::string>> slot_mesh_paths;
};
 
namespace directional_shadow_scene_mesh_internal
{
std::unique_ptr<DirectionalShadowSceneMeshSubrenderImpl> CreateImpl(const Subrender::Stage& stage, RenderDevice& render_device,
                                                                    Filesystem& filesystem, ResourceCache& resource_cache,
                                                                    const SceneRenderData& render_data);
std::vector<std::size_t> CollectMatchingMeshSlotIndices(const std::vector<std::optional<std::string>>& slot_mesh_paths,
                                                        const std::vector<std::string>& changed_meshes);
void Render(DirectionalShadowSceneMeshSubrenderImpl& impl, const RenderFrameContext& frame_context);
std::size_t RefreshAllAssetCaches(DirectionalShadowSceneMeshSubrenderImpl& impl);
std::size_t RefreshMeshCaches(DirectionalShadowSceneMeshSubrenderImpl& impl, const std::vector<std::string>& changed_meshes);
} // namespace directional_shadow_scene_mesh_internal
} // namespace pixelbullet