RenderData.h

Go to the documentation of this file.

#pragma once
#include <array>
#include <cstddef>  // for offsetof
#include <glm/mat4x4.hpp>
#include <vector>
 
#include "GpuDataLayouts.hpp"
 
namespace Engine::Rendering
{
    // ============================================================================
    // CPU-Side Data Structures
    // ============================================================================

    struct CpuPrimitiveData
    {
        glm::vec3 boundingSphereWorldPosition;
        float boundingSphereRadius;
 
        uint32_t meshletOffset; 
        uint32_t meshletCount;
        uint32_t primitiveIndex;
    };

    struct CpuMeshData
    {
        glm::mat4 modelMatrix;
        std::vector<CpuPrimitiveData> primitives;
    };
 
    // Forward declaration for GPU buffer structs
    namespace GpuBuffers {
        struct UnifiedMeshlet;
    }

    struct PerObjectPrimitiveData
    {
        std::vector<GpuBuffers::UnifiedMeshlet> meshletData;
        uint32_t                    textureIndex = 0u;
        std::vector<uint32_t>       vertices;
        std::vector<uint8_t>        tris;
    };

    struct MeshGeometryMapping
    {
        uint32_t meshGeometryId;
        uint32_t meshletStartIndex;
        uint32_t meshletCount;
        uint32_t vertexBaseOffset;
        uint32_t triangleBaseOffset;
        uint32_t vsIndexOffset;            
        uint32_t vsIndexCount;
        bool isSingleMeshlet;
        uint32_t pipelineIndex;
        glm::vec3 localBoundsCenter;
        float localBoundsRadius;
        bool hasLodData = false;
        uint32_t boneVertexBaseOffset = 0;
        uint32_t boneCount = 0;
    };

    struct FrustumPlanes
    {
        std::array<glm::vec4, 6> planes[2];  
    };
 
    // ============================================================================
    // GPU Buffer Data Structures (must match GLSL layouts)
    // ============================================================================
 
    namespace GpuBuffers
    {
        struct Dispatch
        {
            uint32_t groupSizeX = 0u;
            uint32_t groupSizeY = 0u;
            uint32_t groupSizeZ = 0u;
        };

        struct GpuMeshDescription
        {
            uint32_t meshletCount = 0u;
            uint32_t offset       = 0u;
        };

        struct alignas(16) UnifiedMeshlet
        {
            uint32_t vertexCount;
            uint32_t triangleCount;
            uint32_t vertexDataOffset;
            uint32_t triangleDataOffset;
            uint32_t primitiveIndex;
            uint32_t pipelineIndex;
            uint64_t vertexDataAddress;
            uint64_t triangleDataAddress;
            uint32_t _padding[2]{};
        };
        static_assert(sizeof(UnifiedMeshlet) == 48, "UnifiedMeshlet size mismatch");

        struct MeshletBounds
        {
            glm::vec4 worldPositionAndRadius;  // xyz = world position, w = radius
            uint32_t  meshletIndex  = 0;
            uint32_t  pipelineIndex = 0;
        };

        struct MeshPrimitiveRenderData
        {
            uint32_t colorTextureId;
            uint32_t materialId;
            uint32_t shProbeIndex = 0;   
            uint32_t _padding = 0;
        };

        struct ObjectCullingData
        {
            glm::vec4 worldPositionAndRadius;  
            uint32_t objectIndex;
            uint32_t _padding[3];
        };

        struct LocalBoundsData
        {
            glm::vec4 localCenterAndRadius;  
        };

        struct PrimitiveMeshletData
        {
            uint64_t meshletDataAddress;
            uint32_t meshletStartIndex;
            uint32_t meshletCount;
            uint32_t pipelineID;
            uint32_t _padding;
        };
        static_assert(sizeof(PrimitiveMeshletData) == 24, "PrimitiveMeshletData size mismatch");

        struct MeshUnpackingData
        {
            uint32_t meshStartIndex;  
            uint32_t meshletCount;
            uint32_t objectIndex;     
        };

        struct VisibleMeshletInfo
        {
            uint64_t meshletDataAddress;
            uint32_t objectID;
            uint32_t meshletIndex;
            float ditherFactor;      
            uint32_t _padding;
        };
        static_assert(sizeof(VisibleMeshletInfo) == 24, "VisibleMeshletInfo size mismatch");

        struct VisibleMeshletRange
        {
            uint32_t objectIndex;
            uint32_t startMeshletId;
            uint32_t meshletCount;
            uint32_t _padding;
        };

        struct ObjectCullingCounters
        {
            uint32_t objectCount;
            uint32_t totalMeshletCount;
        };

        struct MeshGeometryData
        {
            uint32_t meshletStartIndex;
            uint32_t meshletCount;
            uint32_t pipelineIndex;
            uint32_t singleMeshletGeoIndex;    
            uint32_t clusterStartIndex;        
            uint32_t clusterCount;
            uint32_t groupStartIndex;
            uint32_t groupCount;
            uint32_t flags;                    
            uint32_t boneCount;                
            uint32_t boneVertexDataStart;
            uint32_t geometryVertexStart;
        };
        static_assert(sizeof(MeshGeometryData) == 48, "MeshGeometryData size mismatch");

        struct InstanceData
        {
            glm::mat4 worldMatrix;
            uint32_t meshGeometryId;       
            uint32_t materialId;
            uint32_t colorTextureId;
            uint32_t _padding;
        };

        struct InstanceCullingData
        {
            glm::vec4 worldPositionAndRadius;  
            uint32_t instanceId;               
            uint32_t meshGeometryId;           
            uint32_t _padding[2]{};
        };

        struct SingleMeshletGeometryData
        {
            uint32_t indexCount;
            uint32_t firstIndex;
            int32_t  vertexOffset;
            uint32_t pipelineIndex;
        };
 
        // ============================================================================
        // GPU Material Data Structures (must match GLSL std430 layout)
        // ============================================================================

        struct alignas(16) DiffuseFlatColorMaterial
        {
            glm::vec3 color;
            float _padding;
        };
        static_assert(sizeof(DiffuseFlatColorMaterial) == 16, "DiffuseFlatColorMaterial size mismatch");

        struct alignas(16) DiffuseShaderMaterial
        {
            uint32_t baseColorTextureIndex;
            float _padding1[3];
            glm::vec4 baseColorFactor;
        };
        static_assert(sizeof(DiffuseShaderMaterial) == 32, "DiffuseShaderMaterial size mismatch");
        static_assert(offsetof(DiffuseShaderMaterial, baseColorFactor) == 16, "baseColorFactor must be at offset 16");

        struct alignas(16) PbrMaterial
        {
            uint32_t baseColorTextureIndex;          
            uint32_t normalTextureIndex;             
            uint32_t roughnessMetallicTextureIndex;  
            uint32_t emissiveTextureIndex;           
 
            glm::vec4 baseColorFactor;
 
            glm::vec3 emissiveFactor;
            float roughnessFactor;
 
            float metallicFactor;
            float normalScale;
            float sh_scale;
            float ambient_term;
 
            uint32_t debug_mode;
            uint32_t tone_mapping;
            uint32_t lightmapTextureIndex;  
            uint32_t hasLightmap;
 
            float alphaCutoff;              
            float exposure;
            uint32_t normalMapBC5;          
            uint32_t _padding[1];
        };
        static_assert(sizeof(PbrMaterial) == 96, "PbrMaterial size mismatch with GLSL std430 layout");
        static_assert(offsetof(PbrMaterial, baseColorFactor) == 16, "baseColorFactor must be at offset 16");
        static_assert(offsetof(PbrMaterial, emissiveFactor) == 32, "emissiveFactor must be at offset 32 (16-byte aligned for std430 vec3)");

        struct alignas(16) NormalsMaterial
        {
            uint32_t debug;
            uint32_t _padding[3];
        };
        static_assert(sizeof(NormalsMaterial) == 16, "NormalsMaterial size mismatch");
 
        // ============================================================================
        // GPU Lighting Data Structures
        // ============================================================================

        struct alignas(16) SHProbeData
        {
            glm::vec4 coefficients[9];  
            float scale;
            float ambientTerm;
            float _padding0 = 0.0f;
            uint32_t _padding1 = 0u;
        };
        static_assert(sizeof(SHProbeData) == 160, "SHProbeData size mismatch");
 
        constexpr uint32_t MAX_DYNAMIC_POINT_LIGHTS = 64;

        struct alignas(16) DynamicPointLight
        {
            glm::vec4 positionRadius{0.0f};
            glm::vec4 colorIntensity{0.0f};
        };
        static_assert(sizeof(DynamicPointLight) == 32, "DynamicPointLight size mismatch");

        struct alignas(16) DynamicPointLightBuffer
        {
            uint32_t pointLightCount = 0;
            uint32_t _padding[3]{};
            std::array<DynamicPointLight, MAX_DYNAMIC_POINT_LIGHTS> pointLights{};
        };
        static_assert(sizeof(DynamicPointLightBuffer) == 16 + MAX_DYNAMIC_POINT_LIGHTS * sizeof(DynamicPointLight),
                      "DynamicPointLightBuffer size mismatch");

        struct alignas(16) SunLightBuffer
        {
            glm::vec4 directionEnabled{0.0f, -1.0f, 0.0f, 0.0f};
            glm::vec4 colorIntensity{1.0f, 1.0f, 1.0f, 0.0f};
            glm::vec4 shadowParams{0.0f};  
            glm::vec4 lightmapShadowParams{1.0f, 0.0f, 0.0f, 0.0f};  
        };
        static_assert(sizeof(SunLightBuffer) == 64, "SunLightBuffer size mismatch");
 
        constexpr uint32_t MAX_SUN_SHADOW_CASCADES = 4u;

        struct alignas(16) SunShadowCascadeBuffer
        {
            std::array<glm::mat4, MAX_SUN_SHADOW_CASCADES> lightViewProj{};
            glm::vec4 cascadeSplits{0.0f};  
            glm::vec4 params{0.0f};         
            glm::vec4 biasParams{0.0f};     
            glm::vec4 cameraForward{0.0f};  
        };
        static_assert(sizeof(SunShadowCascadeBuffer) == 320, "SunShadowCascadeBuffer size mismatch");
 
        // ============================================================================
        // LOD (Level of Detail) Data Structures
        // ============================================================================

        struct ClusterLodData
        {
            glm::vec4 boundsPositionAndRadius;  
            float error;                         
            int32_t refinedGroupId;              
            uint32_t meshletIndex;               
            int32_t groupId;                     
            uint64_t meshletDataAddress;         
            uint32_t _padding[2]{};
        };
        static_assert(sizeof(ClusterLodData) == 48, "ClusterLodData size mismatch");

        struct ClusterGroupData
        {
            glm::vec4 simplifiedBoundsPositionAndRadius;  
            float simplifiedError;               
            int32_t depth;                       
            uint32_t _padding[2];
        };
        static_assert(sizeof(ClusterGroupData) == 32, "ClusterGroupData size mismatch");

        struct LodConfigUBO
        {
            float errorThresholdPixels;  
            float cameraProj11;          
            float cameraNear;            
            uint32_t ditherEnabled;      
            glm::vec4 cameraPosition;    
            glm::vec2 screenSize;        
            glm::vec2 _padding;
        };
        static_assert(sizeof(LodConfigUBO) == 48, "LodConfigUBO size mismatch");

        struct ClusterSurvivor
        {
            uint32_t primitiveID;        
            uint32_t clusterIndex;       
            float ditherFactor;          
            uint32_t _padding;
        };
        static_assert(sizeof(ClusterSurvivor) == 16, "ClusterSurvivor size mismatch");

        struct VisibleLodPrimitive
        {
            uint32_t primitiveID;        
            uint32_t clusterStartIndex;  
            uint32_t clusterCount;       
            uint32_t meshGeometryId;     
        };
        static_assert(sizeof(VisibleLodPrimitive) == 16, "VisibleLodPrimitive size mismatch");
 
    } // namespace GpuBuffers
 
    // ============================================================================
    // Backwards Compatibility Aliases (TODO: Remove after migration)
    // ============================================================================
 
    using GpuMeshDescription = GpuBuffers::GpuMeshDescription;
    using UnifiedMeshlet = GpuBuffers::UnifiedMeshlet;
    using MeshletBounds = GpuBuffers::MeshletBounds;
    using MeshPrimitiveRenderData = GpuBuffers::MeshPrimitiveRenderData;
    using ObjectCullingData = GpuBuffers::ObjectCullingData;
    using LocalBoundsData = GpuBuffers::LocalBoundsData;
    using PrimitiveMeshletData = GpuBuffers::PrimitiveMeshletData;
    using MeshUnpackingData = GpuBuffers::MeshUnpackingData;
    using VisibleMeshletInfo = GpuBuffers::VisibleMeshletInfo;
    using VisibleMeshletRange = GpuBuffers::VisibleMeshletRange;
    using ObjectCullingCounters = GpuBuffers::ObjectCullingCounters;
    using MeshGeometryData = GpuBuffers::MeshGeometryData;
    using InstanceData = GpuBuffers::InstanceData;
    using InstanceCullingData = GpuBuffers::InstanceCullingData;
    using SingleMeshletGeometryData = GpuBuffers::SingleMeshletGeometryData;
 
    // Material data aliases (old Gpu*Material names)
    using GpuDiffuseFlatColorMaterial = GpuBuffers::DiffuseFlatColorMaterial;
    using GpuDiffuseShaderMaterial = GpuBuffers::DiffuseShaderMaterial;
    using GpuPbrMaterial = GpuBuffers::PbrMaterial;
    using GpuNormalsMaterial = GpuBuffers::NormalsMaterial;
 
    // Lighting data aliases
    using SHProbeData = GpuBuffers::SHProbeData;
    using DynamicPointLight = GpuBuffers::DynamicPointLight;
    using DynamicPointLightBuffer = GpuBuffers::DynamicPointLightBuffer;
    using SunLightBuffer = GpuBuffers::SunLightBuffer;
    using SunShadowCascadeBuffer = GpuBuffers::SunShadowCascadeBuffer;
 
    // LOD data aliases
    using ClusterLodData = GpuBuffers::ClusterLodData;
    using ClusterGroupData = GpuBuffers::ClusterGroupData;
    using LodConfigUBO = GpuBuffers::LodConfigUBO;
    using ClusterSurvivor = GpuBuffers::ClusterSurvivor;
    using VisibleLodPrimitive = GpuBuffers::VisibleLodPrimitive;
    using Dispatch = GpuBuffers::Dispatch;
 
}  // namespace Engine::Rendering