Mesh.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Container.hpp>
#include <Math/Math.hpp>
#include "Serialization.hpp"
using namespace Foundation;
using namespace Core;
using namespace Math;
 
constexpr uint32_t kMeshletMaxVertices = 64; // max vertices per meshlet
constexpr uint32_t kMeshletMaxTriangles = 96; // max triangles per meshlet (indices=3*triangles)
 
#pragma pack(push,4)
struct FVertex
{
    float3 position;
    float3 normal;
    float3 tangent;
    float bitangentSign;
    float2 uv;
};
static_assert(sizeof(FVertex) == 48);
 
struct FQVertex
{
    uint16_t position[4]; // quantized FP16 [xyz] padding [w]
    uint32_t tbn32; // packed tangent frame
    uint16_t uv[2]; // quantized FP16 [uv]
 
    static uint32_t PackTBN(const float3& normal, const float3& tangent, float bitangentSign);
    static void UnpackTBN(uint32_t packed, float3& outNormal, float3& outTangent, float& outBitangentSign);
 
    static FQVertex Pack(FVertex const& vertex);
    static FVertex Unpack(FQVertex const& vertex);
};
static_assert(sizeof(FQVertex) == 16);
#pragma pack(pop)
 
struct FSkinBinding
{
    uint16_t joints[4]{0, 0, 0, 0};
    float weights[4]{1, 0, 0, 0};
};
static_assert(sizeof(FSkinBinding) == 24);
 
struct FLODGroup // @ref clodGroup
{
    // DAG level the group was generated at
    int depth;
 
    // sphere bounds, in mesh coordinate space
    float3 center;
    float radius;
 
    // combined simplification error, in mesh coordinate space
    // FLT_MAX for terminal groups
    float error;
};
static_assert(sizeof(FLODGroup) == 24);
 
struct FMeshlet // @ref meshopt_Meshlet
{
    /* meshlet group */
    /* ID of the @ref FLODGroup this meshlet belongs to in a hierarchy */
    uint32_t group;
    /* ID of the @ref FLODGroup (with more triangles) that produced this meshlet during simplification (parent). ~0u if
     * original geometry */
    uint32_t refined;
 
    /* meshlet */
    /* offsets within meshletVtx and meshletTri arrays with meshlet data */
    uint32_t vtxOffset; // in vertices
    uint32_t triOffset; // in indices (3*triangles)
    /* number of vertices and triangles used in the meshlet; data is stored in consecutive range defined by offset and
     * count */
    uint32_t vtxCount;
    uint32_t triCount;
 
    /* bounds */
    float4 centerRadius; // (x,y,z,r)
    float4 coneAxisAngle; // (x,y,z,cos(half solid angle))
    float3 coneApex; // (x,y,z)
};
static_assert(sizeof(FMeshlet) == 68);
 
struct FSerializedMeshLOD
{
    FBlobRef indices;
    uint32_t indexCount{0};
};
 
struct FSerializedMesh
{
    FBlobRef vertices;
    uint32_t vertexCount{0};
    Vector<FSerializedMeshLOD> lods;
    FBlobRef dagGroups;
    FBlobRef dagMeshlets;
    FBlobRef dagMeshletTri;
    FBlobRef dagMeshletVtx;
    // Optional CPU skinning data: per-vertex @ref FSkinBinding (count == vertexCount when present)
    // plus the index of the bound skeleton in the scene's skeleton table (-1 = not skinned).
    // Skinned meshes carry no DAG/meshlets (they take the dynamic vertex/index path).
    FBlobRef skinBinding;
    int32_t skeleton{-1};
    // Optional morph-target POSITION deltas (target-major: target t, vertex v at t*vertexCount + v),
    // the target count, and the index of the driving morph-weight track (-1 = not morph-animated).
    // Morph-animated meshes also take the dynamic vertex/index path.
    FBlobRef morphPositions;
    uint32_t morphTargetCount{0};
    int32_t morphTrack{-1};
 
    explicit FSerializedMesh(Allocator* alloc = GLOBAL_ALLOC)
        : lods(alloc)
    {
    }
};
 
struct FImportedMesh
{
    Vector<FVertex> vertices; // Full precision, raw vertices. Used by importers.
    Vector<FQVertex> verticesQuantized; // Quantized vertex data for GPU upload.
    Vector<FSkinBinding> skin; // Optional CPU skin binding, parallel to @ref vertices (empty if not skinned).
    Vector<float3> morphPositions; // Optional morph POSITION deltas, target-major (t*vertexCount + v).
    uint32_t morphTargetCount{0};
    struct LOD
    {
        Vector<uint32_t> indices; // Full precision triangle indices
        LOD(Allocator* alloc) : indices(alloc) {}
    };
    Vector<LOD> lods;
    struct DAG
    {
        Vector<FLODGroup> groups; // LOD groups with error bounds
        Vector<FMeshlet> meshlets; // Meshlets built from all clusters
        Vector<uint8_t> meshletTri; // Meshlet local triangle indices
        Vector<uint32_t> meshletVtx; // Meshlet vertex indices into vertices/verticesQuantized
        DAG(Allocator* alloc) : groups(alloc), meshlets(alloc), meshletTri(alloc), meshletVtx(alloc) {}
    } dag;
 
    FImportedMesh(Allocator* alloc);
    void Optimize();
    void SimplifyLOD(int levels, float scale);
    void ClusterizeDAG();
    void Quantize();
    void Dequantize();
    bool EnsureQuantized();
    [[nodiscard]] bool IsQuantized() const { return !verticesQuantized.empty(); }
    bool EnsureRaw();
    [[nodiscard]] bool IsRaw() const { return !vertices.empty(); }
    [[nodiscard]] size_t CalculateQuantizedBound(bool lod, bool dag) const;
};
 
/* -- Math Exports -- */
void buildOrthonormalBasis(float3 n, float3& b1, float3& b2);
float2 packUnitOctahedralSnorm(float3 v);
float3 unpackUnitOctahedralSnorm(float2 v);
float packUnitCircleSnorm(float2 v);
float2 unpackUnitCircleSnorm(float v);