《可见性剔除系统：视锥、BVH、Hi-Z 与 GPU Driven 剔除》

场景图（Scene Graph）
   ↓  ① 视锥剔除（Frustum Culling）
候选集 A
   ↓  ② 遮挡剔除（Occlusion Culling / Hi-Z）
候选集 B
   ↓  ③ LOD 选择
候选集 C
   ↓  ④ 实例化 / 批处理
Draw Commands
   ↓  ⑤ 间接绘制（Indirect Draw）
GPU 光栅化

// C++：从视图投影矩阵提取 6 个视锥平面（Gribb-Hartmann 方法）
struct FFrustum {
    glm::vec4 planes[6];   // (nx, ny, nz, d)

    void ExtractFromMatrix(const glm::mat4& m) {
        // 左、右、下、上、近、远
        planes[0] = m[3] + m[0];   // left
        planes[1] = m[3] - m[0];   // right
        planes[2] = m[3] + m[1];   // bottom
        planes[3] = m[3] - m[1];   // top
        planes[4] = m[3] + m[2];   // near
        planes[5] = m[3] - m[2];   // far
        for (auto& p : planes) p /= glm::length(glm::vec3(p));
    }
};

// C++：包围球 vs 视锥
bool SphereInFrustum(const FFrustum& f, const glm::vec3& c, float r) {
    for (int i = 0; i < 6; ++i) {
        float dist = glm::dot(glm::vec3(f.planes[i]), c) + f.planes[i].w;
        if (dist < -r) return false;   // 完全在外侧 → 剔除
    }
    return true;   // 相交或在内 → 保留（保守）
}

// C++：AABB vs 视锥（p-vertex）
bool AABBInFrustum(const FFrustum& f, const glm::vec3& mn, const glm::vec3& mx) {
    for (int i = 0; i < 6; ++i) {
        glm::vec3 n = glm::vec3(f.planes[i]);
        glm::vec3 pv = glm::mix(mn, mx, glm::greaterThan(n, glm::vec3(0.0f)));
        if (glm::dot(n, pv) + f.planes[i].w < 0.0f) return false;
    }
    return true;
}

// C++：BVH 节点与 SAH 分割
struct FBVHNode {
    glm::vec3 boundsMin, boundsMax;
    int leftChild;    // 内部节点：左子索引
    int firstPrim;    // 叶节点：首个图元
    int primCount;    // 叶节点：图元数
};

// SAH 代价：节点表面积 × 图元数，面积 = 2(dx·dy + dy·dz + dz·dx)
float SAH(const glm::vec3& mn, const glm::vec3& mx, int n);

// C++：BVH 视锥剔除遍历
void CullBVH(const FBVHNode* nodes, int nodeIdx, const FFrustum& f,
             std::vector<int>& outVisible) {
    const FBVHNode& n = nodes[nodeIdx];
    if (!AABBInFrustum(f, n.boundsMin, n.boundsMax)) return;   // 整棵子树剔除
    if (n.primCount > 0) {                                     // 叶节点
        for (int i = 0; i < n.primCount; ++i)
            outVisible.push_back(n.firstPrim + i);
    } else {
        CullBVH(nodes, n.leftChild, f, outVisible);
        CullBVH(nodes, n.leftChild + 1, f, outVisible);
    }
}

Level 0: 1024×1024  原始深度
Level 1:  512×512   每 2×2 取 max
Level 2:  256×256
...
Level N:    1×1

// HLSL：Hi-Z 遮挡测试（在 compute 中）
bool IsOccluded(float2 aabbMinUV, float2 aabbMaxUV, float nearestDepth, Texture2D<float> hiZ) {
    float2 size = aabbMaxUV - aabbMinUV;
    // 选 mip 级别：让测试区域落在 1~2 个 texel 内
    float mip = ceil(log2(max(size.x, size.y) * hiZResolution));
    // 采样该区域的最远深度（Hi-Z 用 max 保证保守）
    float farthestDepth = hiZ.SampleLevel(samplerLinearClamp, (aabbMinUV + aabbMaxUV) * 0.5, mip);
    // 物体最近点仍比场景最远点还远 → 被遮挡
    return nearestDepth > farthestDepth;
}

// HLSL：GPU 视锥剔除 + 间接绘制参数写入
struct FInstanceData {
    float4x4 transform;
    float3   boundsCenter;
    float    boundsRadius;
    uint     meshIndex;
    uint     lodLevel;
};

StructuredBuffer<FInstanceData> instances;
RWStructuredBuffer<uint>        visibleIndices;
RWStructuredBuffer<FDrawArgs>   drawArgs;      // 每个 mesh 一份
RWStructuredBuffer<uint>        drawCounters;

[numthreads(64, 1, 1)]
void CullInstances(uint3 id : SV_DispatchThreadID) {
    uint i = id.x;
    if (i >= instanceCount) return;

    FInstanceData inst = instances[i];
    float3 center = mul(inst.transform, float4(inst.boundsCenter, 1)).xyz;
    float  radius = inst.boundsRadius * maxScale(inst.transform);

    // 视锥测试（6 平面）
    if (!SphereInFrustum(center, radius)) return;
    // Hi-Z 遮挡测试
    if (IsOccludedByHiZ(center, radius)) return;

    // 通过：追加到可见列表
    uint slot;
    visibleIndices.InterlockedAdd(drawCounters[inst.meshIndex], 1, slot);
    visibleIndices[drawCounters[inst.meshIndex] * MAX_PER_MESH + slot] = i;
}

// C++：间接绘制参数布局
struct FDrawIndexedArgs {
    uint32 IndexCountPerInstance;
    uint32 InstanceCount;         // GPU 写入
    uint32 StartIndexLocation;
    int32  BaseVertexLocation;
    uint32 StartInstanceLocation;
};
// CPU: cmd->DrawIndexedInstancedIndirect(argsBuffer, meshIndex * sizeof(FDrawIndexedArgs));

// HLSL：实例化顶点着色器
StructuredBuffer<float4x4> instanceTransforms : register(t0);

VSOutput VS(VSInput input, uint instanceID : SV_InstanceID) {
    float4x4 mvp = mul(viewProj, instanceTransforms[instanceID]);
    VSOutput o;
    o.position = mul(mvp, float4(input.position, 1.0));
    return o;
}

① GPU Cull Pass：遍历实例 → 视锥 + Hi-Z → 写可见索引
② GPU Compact：压缩可见实例（前缀和）
③ GPU Write Args：写 DrawIndexedInstancedIndirect 参数
④ CPU：一次 ExecuteIndirect 提交所有网格
⑤ GPU：光栅化可见实例

// C++：剔除 + LOD 联合决策
struct FVisibleInstance {
    uint32 instanceIndex;
    uint32 lodLevel;
    float  screenSize;
};

void CullAndSelectLOD(const FInstanceData& inst, const FCamera& cam,
                      FVisibleInstance& out) {
    float dist = glm::distance(cam.position, inst.boundsCenter);
    // 屏幕空间误差决定 LOD
    float screenSize = (inst.boundsRadius * 2.0f) / dist * cam.projectionScale;
    uint32 lod = SelectLOD(screenSize, inst.lodThresholds);
    if (lod >= inst.lodCount) return;   // 太小，直接剔除
    out = { inst.index, lod, screenSize };
}

// C++：LOD 滞后，避免边界抖动
uint32 SelectLODWithHysteresis(float screenSize, uint32 currentLOD,
                               const float* enterThresholds,
                               const float* exitThresholds) {
    if (currentLOD > 0 && screenSize < enterThresholds[currentLOD - 1])
        return currentLOD - 1;   // 变精细
    if (currentLOD < maxLOD && screenSize > exitThresholds[currentLOD])
        return currentLOD + 1;   // 变粗糙
    return currentLOD;
}