Mesh.hpp

Go to the documentation of this file.

#pragma once
#include <Core/Container.hpp>
#include <Math/Math.hpp>
#include "Metadata.hpp"
#include "Precompute.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)
 
// Per-vertex binding stored separately from the render vertex format.
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 FEmissiveMeshlet
{
    uint32_t meshletIndex;
    uint32_t aliasOffset;
    uint32_t triCount;
    float area;
    float3 center;
    float radius;
};
static_assert(sizeof(FEmissiveMeshlet) == 32);
 
struct FSerializedMeshLOD
{
    FBlobRef indices;
    uint32_t indexCount{0};
};
 
struct FSerializedMesh
{
    FUUID id{};
    FSerializedBounds bounds;
    FBlobRef vertices;
    uint32_t vertexCount{0};
    Vector<FSerializedMeshLOD> lods;
    FBlobRef dagGroups;
    FBlobRef dagMeshlets;
    FBlobRef dagMeshletTri;
    FBlobRef dagMeshletVtx;
    FBlobRef emissiveMeshlets;
    FBlobRef emissiveAliases;
    FBlobRef emissivePrimitiveMap;
    FBlobRef skinBinding; // FSkinBinding per vertex; empty when rigid.
    FUUID skeleton{};     // skin skeleton id; kNilUUID when rigid.
 
    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; // Per-vertex skin binding; empty when rigid. Parallel to @ref vertices.
    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
        Vector<FEmissiveMeshlet> emissiveMeshlets;
        Vector<GSAlias> emissiveAliases;
        Vector<uint32_t> emissivePrimitiveMap;
        DAG(Allocator* alloc) :
            groups(alloc), meshlets(alloc), meshletTri(alloc), meshletVtx(alloc),
            emissiveMeshlets(alloc), emissiveAliases(alloc), emissivePrimitiveMap(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 CoordinateSystem(float3 n, float3& b1, float3& b2);
float2 PackUnitOctahedralSnorm(float3 v);
float3 UnpackUnitOctahedralSnorm(float2 v);
float PackUnitCircleSnorm(float2 v);
float2 UnpackUnitCircleSnorm(float v);
 
void RecomputeNormals(Span<FVertex> verts, Span<const uint32_t> indices);