Foundation 施工笔记 【1】- Mesh Shader 和自适应 LOD

...
size_t maxMeshlets = meshopt_buildMeshletsBound(indices.size(), kMeshletMaxVertices, kMeshletMaxTriangles);
// Worst bounds
outMeshletVertices.resize(maxMeshlets * kMeshletMaxVertices), outMeshletTriangles.resize(maxMeshlets * kMeshletMaxTriangles);
Vector<meshopt_Meshlet> meshoptMeshlets(maxMeshlets, outMeshlet.get_allocator());
size_t meshlets =
    meshopt_buildMeshlets(meshoptMeshlets.data(), outMeshletVertices.data(), outMeshletTriangles.data(),
                          indices.data(), indices.size(), reinterpret_cast<const float*>(&vertices[0]),
                          vertices.size(), sizeof(Vertex), kMeshletMaxVertices, kMeshletMaxTriangles,
                          0.25f // As recommended by the docs
    );
meshoptMeshlets.resize(meshlets);
{
    const auto& [vertexOffset, triangleOffset, vertexCount, triangleCount] = meshoptMeshlets.back();
    outMeshletVertices.resize(vertexOffset + vertexCount);
    outMeshletTriangles.resize(triangleOffset + triangleCount * 3);
}
...

...
renderer->CreatePass(
    "Mesh Shader", RHIDeviceQueueType::Graphics, 0u,
    [=](PassHandle self, Renderer* r)
    {
        r->BindBackbufferRTV(self);
        r->BindTextureDSV(self, zbufferHandle,
                              {.format = RHIResourceFormat::D32SignedFloat,
                              .range = RHITextureSubresourceRange::Create(RHITextureAspectFlagBits::Depth)});
        r->BindShader(self, RHIShaderStageBits::Mesh, "meshMain", "data/shaders/MeshShaderBasicMesh.spv");
        r->BindShader(self, RHIShaderStageBits::Fragment, "fragMain", "data/shaders/MeshShaderBasicFrag.spv");
        // NOTE: globalParams is introduced by slang compiler and is currently not customizable
        //       for uniform storage members
        r->BindBufferUniform(self, uboHandle, RHIPipelineStageBits::MeshShader, "globalParams");
        r->BindBufferStorageRead(self, meshHandle,
                                 RHIPipelineStageBits::MeshShader | RHIPipelineStageBits::FragmentShader, "mesh");
    },
    [&](PassHandle self, Renderer* r, RHICommandList* cmd)
    {
        auto const& img_wh = r->GetSwapchainExtent();
        auto* uboData = r->DerefResource(uboHandle).Get<RHIBuffer*>();
        cmd->UpdateBuffer(uboData, 0, AsBytes(ubo));
        r->CmdBeginGraphics(self, cmd, img_wh);
        r->CmdSetPipeline(self, cmd);
        // Simplest dispatch - spawn meshlets one by one to each Mesh Shader WG
        // We don't need a task shader - if unbound, DrawMeshTasks dispatches
        // Mesh Shader workgroups effectively directly.
        cmd->SetViewport(0, 0, img_wh.x, img_wh.y)
            .SetScissor(0, 0, img_wh.x, img_wh.y)
            .DrawMeshTasks(ubo.mesh.lod[0].meshletCount, 1, 1)
            .EndGraphics();
    });

static const size_t kWGSize = 64;
[outputtopology("triangle")]
[numthreads(kWGSize, 1, 1)]
void meshMain(
    // See graphics reference available at:
    // * https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/sv-groupindex
    in uint gid: SV_GroupID,
    in uint tid: SV_GroupIndex,
    OutputVertices<V2F, 96> verts,
    OutputIndices<uint3, 96> triangles,
) {    
    GSMeshLOD lod = globalParams.mesh.lod[0];
    // Each WG of mesh shader processes *exactly* one meshlet per dispatch
    FMeshlet meshlet = mesh.Load<FMeshlet>(lod.meshletOffset + gid * sizeof(FMeshlet));
    uint32_t vtxBase = lod.meshletVtxOffset + meshlet.vtxOffset * sizeof(uint32_t);
    uint32_t vtxCount = meshlet.vtxCount;
    uint32_t triBase = lod.meshletTriOffset + meshlet.triOffset * sizeof(uint8_t);
    uint32_t triCount = meshlet.triCount;
    SetMeshOutputCounts(vtxCount, triCount);
    // Each thread in the WG processes multiple vertices/triangles
    for (uint i = tid; i < vtxCount; i += kWGSize) {
        uint ind = mesh.Load<uint32_t>(vtxBase + i * sizeof(uint32_t));
        FVertex vtx = mesh.Load<FVertex>(globalParams.mesh.vtxOffset + ind * sizeof(FVertex));
        V2F v2f;
        v2f.pos = mul(globalParams.mvp, float4(vtx.position, 1.0));
        v2f.meshlet = gid;
        verts[i] = v2f;
    }
    for (uint i = tid; i < triCount; i += kWGSize) {
        MIndex tri = mesh.Load<MIndex>(triBase + i * sizeof(MIndex));
        triangles[i] = uint3(tri.v0, tri.v1, tri.v2);
    }
}

struct V2F
{
    float4 pos : SV_POSITION;
    uint32_t meshlet : ID;
};
uint hash(uint a)
{
    a = (a + 0x7ed55d16) + (a << 12);
    a = (a ^ 0xc761c23c) ^ (a >> 19);
    a = (a + 0x165667b1) + (a << 5);
    a = (a + 0xd3a2646c) ^ (a << 9);
    a = (a + 0xfd7046c5) + (a << 3);
    a = (a ^ 0xb55a4f09) ^ (a >> 16);
    return a;
}
float3 hash3(uint a){
    a = hash(a);
    return float3(float(a & 255), float((a >> 8) & 255), float((a >> 16) & 255)) / 255.0;
}
struct Fragment
{
    float4 color : SV_Target;
};
[shader("fragment")]
Fragment fragMain(V2F input)
{
    Fragment output;
    output.color = float4(hash3(input.meshlet), 1.0);
    return output;
}

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)
};

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
    float error;
};
static_assert(sizeof(FLODGroup) == 24);

struct DAG
{
    struct Cluster
    {
        uint32_t group{~0u}; // ID of the FLODGroup this cluster belongs to
        uint32_t refined{~0u}; // ID of the FLODGroup (with more triangles) that produced this cluster during simplification (parent). ~0u if original geometry
        Vector<uint32_t> indices;
        Cluster(Allocator* alloc) : indices(alloc) {}
    };
    Vector<Cluster> clusters; // Note: scratch buffer
    // -- final DAG data
    Vector<FLODGroup> groups; // group error bounds
    Vector<FMeshlet> meshlets; // meshlets built from all clusters
    Vector<uint32_t> meshletVtx;
    Vector<uint8_t> meshletTri;
    DAG(Allocator* alloc) : clusters(alloc), groups(alloc), meshlets(alloc), meshletVtx(alloc), meshletTri(alloc) {}
} dag;

clodBuild(config, mesh,
          [&](clodGroup group, const clodCluster* clusters, size_t cluster_count) -> int
          {
              size_t group_id = dag.groups.size();
              dag.groups.push_back(FLODGroup{
                  .depth = group.depth,
                  .center = {group.simplified.center[0], group.simplified.center[1], group.simplified.center[2]},
                  .radius = group.simplified.radius,
                  .error = group.simplified.error});
              for (size_t i = 0; i < cluster_count; i++)
              {
                  auto& cluster = clusters[i];
                  auto& lvl = dag.clusters.emplace_back(vertices.get_allocator().mResource);
                  lvl.group = group_id, lvl.refined = cluster.refined;
                  auto& ind = lvl.indices;
                  ind.insert(ind.end(), cluster.indices, cluster.indices + cluster.index_count);
              }
              return group_id; // recorded as refined IDs
          });

// Done - build meshlets for each cluster
size_t numIndices = 0;
for (auto& cluster : dag.clusters)
    numIndices += cluster.indices.size();
// Worst bounds
dag.meshletVtx.resize(numIndices), dag.meshletTri.resize(numIndices);
uint32_t* vtx = dag.meshletVtx.data();
uint8_t* tri = dag.meshletTri.data();
dag.meshlets.reserve(dag.clusters.size());
for (auto& cluster : dag.clusters)
{
    FMeshlet meshlet{
        .group = cluster.group,
        .refined = cluster.refined,
        .vtxOffset = static_cast<uint32_t>(vtx - dag.meshletVtx.data()),
        .triOffset = static_cast<uint32_t>(tri - dag.meshletTri.data()),
    };
    // Index to Micro Index (uint8)
    size_t unique = clodLocalIndices(vtx, tri, cluster.indices.data(), cluster.indices.size());
    vtx += unique, tri += cluster.indices.size();
    meshlet.vtxCount = unique, meshlet.triCount = cluster.indices.size() / 3;
    // Compute bounds
    meshopt_Bounds bounds = meshopt_computeMeshletBounds(
        &dag.meshletVtx[meshlet.vtxOffset], &dag.meshletTri[meshlet.triOffset], meshlet.triCount,
        reinterpret_cast<const float*>(&vertices[0]), vertices.size(), sizeof(FVertex));
    meshlet.centerRadius = float4(bounds.center[0], bounds.center[1], bounds.center[2], bounds.radius);
    meshlet.coneAxisAngle =
        float4(bounds.cone_axis[0], bounds.cone_axis[1], bounds.cone_axis[2], bounds.cone_cutoff);
    meshlet.coneApex = float3(bounds.cone_apex[0], bounds.cone_apex[1], bounds.cone_apex[2]);
    dag.meshlets.push_back(meshlet);
}

...
uint32_t groupBase = globalParams.mesh.groupOffset + meshlet.group * sizeof(FLODGroup);
FLODGroup lodGroup = mesh.Load<FLODGroup>(groupBase);
if (lodGroup.depth != globalParams.cutDepth) { // <- Cull depth    
    SetMeshOutputCounts(0, 0);
    return;
}
...

float projErrorSimple(FLODGroup lodGroup) {
    float3 center = mul(globalParams.view, float4(lodGroup.center, 1.0)).xyz;
    float r = lodGroup.radius;
    float d = max(length(center) - r, globalParams.zNear);
    return lodGroup.error / d * abs(globalParams.proj[1][1]);
}

...
FLODGroup selfGroup = mesh.Load<FLODGroup>(globalParams.mesh.groupOffset + meshlet.group * sizeof(FLODGroup));
float selfError = projErrorSimple(selfGroup);
// Remember - we take the upper_bound of the acceptable clusters
// where it's the *first* LOD that exceeds the error threshold
bool culled = selfError <= globalParams.threshold;
if (meshlet.refined != ~0u){
    FLODGroup refGroup = mesh.Load<FLODGroup>(globalParams.mesh.groupOffset + meshlet.refined * sizeof(FLODGroup));
    float refError = projErrorSimple(refGroup);
    // The refined ones exceeds it too - impossible unless it's closer to
    // the actual upper bound. So cull ourselves.
    culled |= refError > globalParams.threshold;
}
// If culled do not render
...