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 EngineCore
{
    struct CpuPrimitiveData
    {
        // culling data
        glm::vec3 boundingSphereWorldPosition;
        float boundingSphereRadius;
 
        // Meshlet Info
        uint32_t meshletOffset; // where the meshlet data for this primitive starts
        uint32_t meshletCount;
 
        uint32_t primitiveIndex;
    };

    struct CpuMeshData
    {
        glm::mat4 modelMatrix;
        std::vector<CpuPrimitiveData> primitives;
    };
 
 

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

    struct Dispatch
    {
        uint32_t groupSizeX = 0u;
        uint32_t groupSizeY = 0u;
        uint32_t groupSizeZ = 0u;
    };

    struct UnifiedMeshlet
    {
        uint32_t vertexCount;    // Number of vertices in this meshlet
        uint32_t triangleCount;  // Number of triangles in this meshlet (primitive count)
        uint32_t vertexDataOffset;
        uint32_t triangleDataOffset;
        uint32_t primitiveIndex;
        uint32_t pipelineIndex;
    };

    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;
    };
 
    struct PerObjectPrimitiveData
    {
        std::vector<UnifiedMeshlet> meshletData;
        uint32_t                    textureIndex = 0u;
        std::vector<uint32_t>       vertices;
        std::vector<uint8_t>        tris;
    };

    struct alignas( 16 ) [[deprecated("Use mat4 directly via RenderingDataManager::getPerObjectDataBuffer()")]] PerObjectData
    {
        glm::mat4 worldMatrix;
        glm::vec4 colorMultiplier;
        uint32_t  meshletCount;
        uint32_t  indexCount;
        uint32_t  meshOffset;
        float     boundingSphereRadius;
    };

    struct ObjectCullingData
    {
        glm::vec4 worldPositionAndRadius;
        uint32_t objectIndex;
        uint32_t _padding[3];  // Pad to 32 bytes for std430 struct alignment
    };

    struct LocalBoundsData
    {
        glm::vec4 localCenterAndRadius;  
    };

    struct PrimitiveMeshletData
    {
        uint32_t meshletStartIndex;
        uint32_t meshletCount;
        uint32_t pipelineID;
    };

    struct MeshUnpackingData
    {
        uint32_t meshStartIndex;  // start index of the meshlets of this mesh
        uint32_t meshletCount;    // amount of meshlets of which this meshlet is made of
        uint32_t objectIndex;     // index which links back to the main SSBO
    };

    struct FrustumPlanes
    {
        std::array<glm::vec4, 6> planes[2];  // [eyeIndex][planeIndex] left, right, top, bottom, near, far
    };

    struct HiZViewProjectionData
    {
        glm::mat4 viewProjection[2];  // [eyeIndex] - 2 x 64 bytes = 128 bytes
        glm::vec2 screenSize;         // 8 bytes
        uint32_t hiZMipLevels;        // 4 bytes
        uint32_t _padding;            // 4 bytes for alignment
    };  // Total: 144 bytes

    struct VisibleMeshletInfo
    {
        uint32_t objectID;
        uint32_t meshletIndex;
        float ditherFactor;      
        uint32_t _padding;
    };
 
    struct VisibleMeshletRange
    {
        uint32_t objectIndex;     // Index into the allObjects array
        uint32_t startMeshletId;  // First thread ID assigned to this object's meshlets
        uint32_t meshletCount;    // How many meshlets this object has
        uint32_t _padding;        // Optional: for 16-byte alignment (GPU preference)
    };
 
    struct ObjectCullingCounters
    {
        uint32_t objectCount;
        uint32_t totalMeshletCount;
    };
 
    // ============================================================================
    // Instancing Data Structures (for geometry deduplication)
    // ============================================================================

    struct MeshGeometryData
    {
        uint32_t meshletStartIndex;    
        uint32_t meshletCount;         
        uint32_t pipelineIndex;        
        uint32_t singleMeshletGeoIndex;
        // LOD extension (Phase 1)
        uint32_t clusterStartIndex;    
        uint32_t clusterCount;         
        uint32_t groupStartIndex;      
        uint32_t groupCount;           
    };
    static_assert(sizeof(MeshGeometryData) == 32, "MeshGeometryData size mismatch");

    struct InstanceData
    {
        glm::mat4 worldMatrix;         
        uint32_t meshGeometryId;       
        uint32_t materialId;           
        uint32_t colorTextureId;       
        uint32_t _padding;             
    };  // Total: 80 bytes

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

    struct MeshGeometryMapping
    {
        uint32_t meshGeometryId;       
        uint32_t meshletStartIndex;    
        uint32_t meshletCount;         
        uint32_t vertexBaseOffset;     
        uint32_t triangleBaseOffset;   
        // Vertex shader path data (for single-meshlet geometry)
        uint32_t vsIndexOffset;        
        uint32_t vsIndexCount;         
        bool isSingleMeshlet;          
        // Cached material lookup (avoids redundant asset manager queries)
        uint32_t pipelineIndex;        
        glm::vec3 localBoundsCenter;   
        float localBoundsRadius;       
    };

    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) GpuDiffuseFlatColorMaterial
    {
        glm::vec3 color;
        float _padding;  // Align to 16 bytes for std430
    };
    static_assert(sizeof(GpuDiffuseFlatColorMaterial) == 16, "GpuDiffuseFlatColorMaterial size mismatch");

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

    struct alignas(16) GpuPbrMaterial
    {
        // Texture indices (0xFFFFFFFF = not present)
        uint32_t baseColorTextureIndex;
        uint32_t normalTextureIndex;
        uint32_t roughnessMetallicTextureIndex;
        uint32_t emissiveTextureIndex;
 
        // Material factors - vec4 must be 16-byte aligned
        glm::vec4 baseColorFactor;
 
        // vec3 in std430 has 16-byte alignment; offset 32 is 16-byte aligned
        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;  // Lightmap texture index (0xFFFFFFFF = not present)
        uint32_t hasLightmap;           // 1 if lightmap is present, 0 otherwise
    };
    static_assert(sizeof(GpuPbrMaterial) == 80, "GpuPbrMaterial size mismatch with GLSL std430 layout");
    static_assert(offsetof(GpuPbrMaterial, baseColorFactor) == 16, "baseColorFactor must be at offset 16");
    static_assert(offsetof(GpuPbrMaterial, emissiveFactor) == 32, "emissiveFactor must be at offset 32 (16-byte aligned for std430 vec3)");

    struct alignas(16) GpuNormalsMaterial
    {
        uint32_t debug;
        uint32_t _padding[3];
    };
    static_assert(sizeof(GpuNormalsMaterial) == 16, "GpuNormalsMaterial size mismatch");

    struct alignas(16) SHProbeData
    {
        glm::vec4 coefficients[9];  // L0-L2 RGB coefficients (9 bands)
        float scale;
        float ambientTerm;
        uint32_t _padding[2];
    };
    static_assert(sizeof(SHProbeData) == 160, "SHProbeData size mismatch");
 
    // ============================================================================
    // LOD (Level of Detail) Data Structures
    // ============================================================================

    struct ClusterLodData
    {
        glm::vec4 boundsPositionAndRadius;  
        float error;                         
        int32_t refinedGroupId;              
        uint32_t meshletIndex;               
        uint32_t _padding;
    };
    static_assert(sizeof(ClusterLodData) == 32, "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");
 
}  // namespace EngineCore