RenderData.h

#pragma once
#include <array>
#include <cstddef>  // for offsetof
#include <glm/mat4x4.hpp>
#include <vector>

 
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;
    }  // namespace GpuBuffers

    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;      
        uint32_t  vertexCount          = 0;      
        uint32_t  singleMeshletGeoIndex = 0xFFFFFFFFu;  
        uint32_t  clusterStartIndex     = 0xFFFFFFFFu;  
        uint32_t  clusterCount          = 0;            
        uint32_t  groupStartIndex       = 0xFFFFFFFFu;  
        uint32_t  groupCount            = 0;            
 
        // Phase C (bindless geometry): device addresses of the per-slot GPU ranges. Populated during
        // upload once the shared backing buffers exist (they still point into the shared append
        // buffers for now; sub-step 2 swaps them for per-slot VkBuffers). A zero address means the
        // range is not present for this geometry.
        uint64_t meshletDataAddress           = 0;  
        uint64_t singleMeshletGeoDataAddress  = 0;  
        uint64_t clusterLodDataAddress        = 0;  
        uint64_t clusterGroupDataAddress      = 0;  
        uint64_t boneVertexDataAddress        = 0;  
        uint64_t vertexDataAddress            = 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;  
            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
        {
            static constexpr uint32_t FLAG_SKINNED = 1u << 0;   
            static constexpr uint32_t FLAG_RESIDENT = 1u << 1;  
 
            uint64_t meshletDataAddress;            
            uint32_t meshletCount;                  
            uint32_t pipelineIndex;                 
            uint64_t singleMeshletGeoDataAddress;   
            uint32_t singleMeshletGeoIndex;         
            uint64_t clusterLodDataAddress;         
            uint32_t clusterCount;                  
            uint64_t clusterGroupDataAddress;       
            uint32_t groupCount;                    
            uint32_t flags;                         
            uint32_t boneCount;                     
            uint64_t boneVertexDataAddress;         
            uint64_t indexDataAddress;              
            uint64_t vertexDataAddress;             
            uint32_t geometryVertexStart;           
            uint32_t _padding;                      
        };
 
        static_assert( sizeof( MeshGeometryData ) == 104, "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 = 1.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, 1.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;            
            uint64_t clusterLodDataAddress;  
            uint32_t clusterIndex;           
            float    ditherFactor;           
            uint32_t _padding;               
        };
 
        static_assert( sizeof( ClusterSurvivor ) == 32, "ClusterSurvivor size mismatch" );

        struct VisibleLodPrimitive
        {
            uint32_t primitiveID;            
            uint64_t clusterLodDataAddress;  
            uint64_t clusterGroupDataAddress;
            uint32_t clusterCount;           
            uint32_t meshGeometryId;         
        };
 
        static_assert( sizeof( VisibleLodPrimitive ) == 32, "VisibleLodPrimitive size mismatch" );
 
    }  // namespace GpuBuffers

    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;

    using GpuDiffuseFlatColorMaterial = GpuBuffers::DiffuseFlatColorMaterial;
    using GpuDiffuseShaderMaterial = GpuBuffers::DiffuseShaderMaterial;
    using GpuPbrMaterial = GpuBuffers::PbrMaterial;
    using GpuNormalsMaterial = GpuBuffers::NormalsMaterial;

    using SHProbeData = GpuBuffers::SHProbeData;
    using DynamicPointLight = GpuBuffers::DynamicPointLight;
    using DynamicPointLightBuffer = GpuBuffers::DynamicPointLightBuffer;
    using SunLightBuffer = GpuBuffers::SunLightBuffer;
    using SunShadowCascadeBuffer = GpuBuffers::SunShadowCascadeBuffer;

    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