// 为每个 meshlet 定义顶点和图元的上限
const sizet max_vertices = 64;
const sizet max_triangles = 124;

// 遍历 glTF 场景中的所有 mesh 和 primitive
for (u32 p = 0; p < mesh.primitives_count; ++p) {
    glTF::MeshPrimitive& mesh_primitive = mesh.primitives[p];

    // ... 省略了从 glTF 加载顶点、法线、UV 等属性数据的代码 ...
    // f32* vertices = ...
    // u16* indices = ...
    // u32 index_count = ...
    // u32 vertex_count = ...
}

// 计算构建 meshlet 所需的最大空间
const sizet max_meshlets = meshopt_buildMeshletsBound(index_count, max_vertices, max_triangles);

// 分配临时内存来存储 meshoptimizer 的输出
Array<meshopt_Meshlet> local_meshlets;
local_meshlets.init(temp_allocator, max_meshlets, max_meshlets);
// ... 为 meshlet_vertex_indices 和 meshlet_triangles 分配内存 ...

// 核心调用：构建 Meshlet！
sizet meshlet_count = meshopt_buildMeshlets(
    local_meshlets.data,          // 输出的 meshlet 数组
    meshlet_vertex_indices.data,  // 输出的顶点索引数组
    meshlet_triangles.data,       // 输出的图元索引数组
    indices,                      // 输入的原始索引数据
    index_count,                  // 输入的索引数量
    (f32*)vertices,               // 输入的顶点位置数据
    vertex_count,                 // 输入的顶点数量
    sizeof(vec3s),                // 每个顶点的大小
    max_vertices,                 // 单个 meshlet 的最大顶点数
    max_triangles,                // 单个 meshlet 的最大图元数
    cone_weight);                 // 用于锥形剔除优化的权重

// 遍历所有顶点，转换并打包数据
for (u32 v = 0; v < vertex_count; ++v) {
    GpuMeshletVertexData meshlet_vertex_data{};

    // 将法线从 [-1, 1] 范围的 float 压缩到 [0, 255] 范围的 u8
    if (normals != nullptr) {
        meshlet_vertex_data.normal[0] = (normals[v * 3 + 0] + 1.0f) * 127.0f;
        // ... y 和 z 分量 ...
    }

    // 将 UV 坐标转换为 16 位半精度浮点数
    meshlet_vertex_data.uv_coords[0] = meshopt_quantizeHalf(tex_coords[v * 2 + 0]);
    meshlet_vertex_data.uv_coords[1] = meshopt_quantizeHalf(tex_coords[v * 2 + 1]);

    meshlets_vertex_data.push(meshlet_vertex_data);
}

// 遍历 meshoptimizer 生成的每个 meshlet
for (u32 m = 0; m < meshlet_count; ++m) {
    meshopt_Meshlet& local_meshlet = local_meshlets[m];

    // 1. 计算用于剔除的边界球和锥体
    meshopt_Bounds bounds = meshopt_computeMeshletBounds(/* ... */);

    // 2. 填充我们自定义的 GpuMeshlet 结构体
    GpuMeshlet meshlet{};
    meshlet.vertex_count   = local_meshlet.vertex_count;
    meshlet.triangle_count = local_meshlet.triangle_count;
    // ... 填充 center, radius, cone_axis, cone_cutoff 等剔除信息 ...
    meshlet.mesh_index     = ...; // 记录它所属的原始网格索引

    // 3. 将该 meshlet 的顶点索引和图元索引打包到一个连续的缓冲中
    // 顶点索引
    for (u32 i = 0; i < meshlet.vertex_count; ++i) {
        meshlets_data.push(/* ... vertex index ... */);
    }

    // 4. 将图元索引打包到我们最终的GPU缓冲中
    // 将 u8 指针重新解释为 u32 指针，以便进行块读取
    const uint32_t* index_groups =
        reinterpret_cast<const uint32_t*>(meshlet_triangles.data() + local_meshlet.triangle_offset);

    // 计算需要多少个u32的块才能容纳所有三角形索引
    const uint32_t index_group_count = (local_meshlet.triangle_count * 3 + 3) / 4;

    // 将打包好的 u32 数据块追加到最终的缓冲中
    for (uint32_t i = 0; i < index_group_count; ++i) {
        meshlets_data.push_back(index_groups[i]);
    }

    meshlets.push(meshlet);
}

// COMPUTE_GPU_MESH_CULLING
// 每个工作组派发64个线程，每个线程处理一个物体实例
layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;

void main() {
    uint mesh_instance_index = gl_GlobalInvocationID.x;
    // ... 边界检查 ...

    // 获取物体实例数据和包围球信息
    MeshDraw mesh_draw = mesh_draws[mesh_draw_index];
    vec4 bounding_sphere = mesh_bounds[mesh_draw_index];
    mat4 model = mesh_instance_draws[mesh_instance_index].model;

    // 将包围球从模型空间转换到世界空间和观察空间
    vec4 world_bounding_center = model * vec4(bounding_sphere.xyz, 1);
    vec4 view_bounding_center = world_to_camera * world_bounding_center;

    // 计算世界空间下的包围球半径
    float scale = length(model[0]);
    float radius = bounding_sphere.w * scale;

    // 1. 视锥剔除
    bool frustum_visible = true;
    for (uint i = 0; i < 6; ++i) {
        // 平面方程: dot(N, P) + D = 0。我们预先计算好平面法线指向视锥内部
        // dot(plane, point) > -radius 表示球体在平面的内侧或与平面相交
        frustum_visible = frustum_visible && (dot(frustum_planes[i], view_bounding_center) > -radius);
    }

    // 2. 遮挡剔除
    bool occlusion_visible = true;
    if (frustum_visible) {
        occlusion_visible = occlusion_cull(...); // 详细实现在下文
    }
    
    // 3. 生成绘制指令
    if (frustum_visible && occlusion_visible) {
        // ... 使用 atomicAdd 将该物体的绘制指令写入可见列表 ...
    } else {
        // ... 使用 atomicAdd 将该物体的ID写入被剔除列表，用于Pass 3重检 ...
    }
}

// 2D Polyhedral Bounds of a Clipped, Perspective-Projected 3D Sphere. Michael Mara, Morgan McGuire. 2013
bool project_sphere(vec3 C, float r, float znear, float P00, float P11, out vec4 aabb) {
  // C.z 是观察空间深度，必须在近平面外
  if (C.z - r < znear) return false;

  // ... 复杂的数学变换，计算球体轮廓线投影后的边界 ...
  // P00 和 P11 是投影矩阵的 [0][0] 和 [1][1] 项

  aabb = vec4(minx.x / minx.y * P00, miny.x / miny.y * P11, maxx.x / maxx.y * P00, maxy.x / maxy.y * P11);
  // 将裁剪空间坐标 [-1, 1] 转换为 UV 空间 [0, 1]
  aabb = aabb.xwzy * vec4(0.5f, -0.5f, 0.5f, -0.5f) + vec4(0.5f);

  return true;
}

// ... in occlusion_cull()
ivec2 depth_pyramid_size = textureSize(depth_pyramid_texture, 0);
float width = (aabb.z - aabb.x) * depth_pyramid_size.x;
float height = (aabb.w - aabb.y) * depth_pyramid_size.y;

// 选择能覆盖AABB的最粗糙（但足够精细）的Mip层级
float level = floor(log2(max(width, height)));

// ... in occlusion_cull()
// 采样器设置为 MAX reduction，所以一次采样即可得到区域最大深度
vec2 uv = (aabb.xy + aabb.zw) * 0.5;
float depth = textureLod(depth_pyramid_texture, uv, level).r;
// ... (采样角点并取最大值)

// ... in occlusion_cull()
// 计算球体表面最靠近相机的点的深度
vec3 dir = normalize(camera_world_position - world_bounding_center.xyz);
vec4 sceen_space_center_last = culling_view_projection * vec4(world_bounding_center + dir * radius, 1.0);
float depth_sphere = sceen_space_center_last.z / sceen_space_center_last.w;

// ... in occlusion_cull()
// 如果物体最近点的深度大于（远于）采样区域的最远遮挡物深度，则被遮挡
occlusion_visible = (depth_sphere <= depth);

// ... in main()
if (frustum_visible && occlusion_visible) {
    // 为不透明物体列表申请一个索引
    uint draw_index = atomicAdd(opaque_mesh_visible_count, 1);
    
    // 填充间接绘制指令
    draw_commands[draw_index].drawId = mesh_instance_index; // 传递实例ID
    // ... (填充 taskCount, firstTask 等)
} else if (late_flag == 0) { // late_flag=0表示这是第一次剔除
    // 将被剔除的物体加入到“待重检”列表
    uint draw_index = atomicAdd(opaque_mesh_culled_count, 1);
    draw_late_commands[draw_index].drawId = mesh_instance_index;
}

layout(local_size_x = 32, local_size_y = 1, local_size_z = 1) in;

// ... Buffer Definitions ...

out taskNV block
{
    uint meshlet_indices[32]; // 输出给 Mesh Shader 的共享数据
};

void main()
{
    // 索引计算
    uint task_index = gl_LocalInvocationID.x;
    uint meshlet_group_index = gl_WorkGroupID.x;
    uint global_meshlet_index = meshlet_group_index * 32 + task_index;

    // ... 获取模型矩阵等实例数据 ...
    mat4 model = mesh_instance_draws[mesh_instance_index].model;

    // Meshlet 包围体变换
    vec4 world_center = model * vec4(meshlets[global_meshlet_index].center, 1);
    float scale = length(model[0]);
    float radius = meshlets[global_meshlet_index].radius * scale * 1.1; // 稍微放大包围球，避免精度问题

    // ... 背面剔除 (Cone Culling) ...
    
    bool accept = false;
    vec4 view_center = world_to_camera_debug * world_center;

    // 视锥剔除
    bool frustum_visible = true;
    for (uint i = 0; i < 6; ++i) {
        frustum_visible = frustum_visible && (dot(frustum_planes[i], view_center) > -radius);
    }

    // ... 遮挡剔除... 

    uvec4 ballot = subgroupBallot(accept);

    uint index = subgroupBallotExclusiveBitCount(ballot);

    if (accept)
        meshlet_indices[index] = global_meshlet_index;

    uint count = subgroupBallotBitCount(ballot);

    if (task_index == 0)
        gl_TaskCountNV = count;

// As described in meshoptimizer.h
bool coneCull(vec3 center, float radius, vec3 cone_axis, float cone_cutoff, vec3 camera_position) {
  return dot(center - camera_position, cone_axis) >=
         cone_cutoff * length(center - camera_position) + radius;
}

layout(local_size_x = 32, local_size_y = 1, local_size_z = 1) in;
layout(triangles, max_vertices = 64, max_primitives = 124) out;

// ... Buffer Definitions ...

in taskNV block
{
    uint meshlet_indices[32]; // 从 Task Shader 接收的共享数据
};

// ... Output Vertex Attributes ...

void main()
{
    // 1. 获取 Meshlet 索引
    uint task_index = gl_LocalInvocationID.x;
    // 注意：这里 gl_WorkGroupID.x 不再是 Meshlet 组索引，而是可见 Meshlet 的索引
    uint global_meshlet_index = meshlet_indices[gl_WorkGroupID.x];

    // 2. 解压 Meshlet 数据
    Meshlet meshlet = meshlets[global_meshlet_index];
    uint vertex_count = uint(meshlet.vertex_count);
    uint triangle_count = uint(meshlet.triangle_count);
    uint data_offset = meshlet.data_offset;
    uint vertexOffset = data_offset;
    uint indexOffset = data_offset + vertex_count;

    // ... 获取模型矩阵 ...
    mat4 model = mesh_instance_draws[mesh_instance_index].model;

    // 3. 顶点处理 (并行)
    // 每个线程处理一部分顶点
    for (uint i = task_index; i < vertex_count; i += 32)
    {
        uint vi = meshletData[vertexOffset + i]; // 获取局部顶点索引
        vec3 position = ...; // 从 Buffer 中读取顶点位置

        // ... 法线、切线等属性的解压和变换 ...

        // 核心：顶点变换
        gl_MeshVerticesNV[i].gl_Position = view_projection * (model * vec4(position, 1));

        // ... 设置其他输出给片元着色器的 varying 变量 ...
    }

    // 4. 索引处理 (并行)
    uint indexGroupCount = (indexCount + 3) / 4; // 索引被打包存储
    for (uint i = task_index; i < indexGroupCount; i += 32)
    {
        // 高效的索引解包函数
        writePackedPrimitiveIndices4x8NV(i * 4, meshletData[indexOffset + i]);
    }

    // 5. 设置图元数量
    if (task_index == 0)
        gl_PrimitiveCountNV = triangle_count;
}

writePackedPrimitiveIndices4x8NV(i * 4, meshletData[indexOffset + i]);

// 资源创建
void DepthPyramidPass::create_depth_pyramid_resource(Texture* depth_texture) {
    u32 width = depth_texture->width / 2;
    u32 height = depth_texture->height / 2;

    // 1. 计算金字塔层数
    depth_pyramid_levels = 0;
    while (width >= 2 && height >= 2) {
        depth_pyramid_levels++;
        width /= 2;
        height /= 2;
    }

    // 2. 创建一个带有多级 Mipmap 的纹理
    TextureCreation depth_hierarchy_creation{};
    depth_hierarchy_creation.set_format_type(VK_FORMAT_R32_SFLOAT, TextureType::Enum::Texture2D)
        .set_flags(TextureFlags::Compute_mask) // 标记为可用于Compute Shader读写
        .set_size(depth_texture->width / 2, depth_texture->height / 2, 1)
        .set_name("depth_hierarchy")
        .set_mips(depth_pyramid_levels); // 指定 Mipmap 层数
    depth_pyramid = gpu.create_texture(depth_hierarchy_creation);

    // ...

    // 3. 为每一层 Mipmap 创建独立的视图和描述符集
    for (u32 i = 0; i < depth_pyramid_levels; ++i) {
        // 创建指向特定 Mip 层的视图
        depth_pyramid_view_creation.sub_resource.mip_base_level = i;
        depth_pyramid_views[i] = gpu.create_texture_view(depth_pyramid_view_creation);

        // 绑定输入和输出纹理
        if (i == 0) { // 第一层：输入是原始深度图
            descriptor_set_creation.reset()
                .texture(depth_texture->handle, 0) // binding 0: src
                .texture(depth_pyramid_views[i], 1) // binding 1: dst
                .set_layout(depth_pyramid_layout);
        } else { // 后续层：输入是上一级 Mip
            descriptor_set_creation.reset()
                .texture(depth_pyramid_views[i - 1], 0) // binding 0: src
                .texture(depth_pyramid_views[i], 1)     // binding 1: dst
                .set_layout(depth_pyramid_layout);
        }
        depth_hierarchy_descriptor_set[i] = gpu.create_descriptor_set(descriptor_set_creation);
    }
}

layout(set = MATERIAL_SET, binding = 0) uniform sampler2D src;
layout(set = MATERIAL_SET, binding = 1) uniform writeonly image2D dst;

layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;

void main() {
    // 1. 计算当前线程ID对应的输出纹理坐标
    ivec2 out_coords = ivec2(gl_GlobalInvocationID.xy);
    
    // 2. 计算在源纹理（大一倍）中对应的 2x2 像素区域的左上角坐标
    ivec2 texel_position00 = out_coords * 2;

    // 3. 采样 2x2 区域的四个深度值
    float d00 = texelFetch( src, texel_position00, 0 ).r;
    float d01 = texelFetch( src, texel_position00 + ivec2(0, 1), 0 ).r;
    float d10 = texelFetch( src, texel_position00 + ivec2(1, 0), 0 ).r;
    float d11 = texelFetch( src, texel_position00 + ivec2(1, 1), 0 ).r;

    // 4. 找出四个深度值中的最大值
    float result = max(max(d00, d01), max(d10, d11));

    // 5. 将最大值写入目标纹理的对应位置
    imageStore( dst, out_coords, vec4(result, 0, 0, 0) );
}

// 确保原始深度图可以作为Shader资源被读取
util_add_image_barrier(gpu, gpu_commands->vk_command_buffer, depth_texture,
                       RESOURCE_STATE_SHADER_RESOURCE, 0, 1, true);

// 循环生成每一层 Mipmap
for (u32 mip_index = 0; mip_index < depth_pyramid_texture->mip_level_count; ++mip_index) {
    // 1. 内存屏障：转换当前 Mip 层的布局，准备写入
    util_add_image_barrier(gpu, ..., RESOURCE_STATE_UNDEFINED, RESOURCE_STATE_UNORDERED_ACCESS, mip_index, ...);

    // 2. 绑定当前层对应的描述符集 (包含了输入和输出)
    gpu_commands->bind_descriptor_set(&depth_hierarchy_descriptor_set[mip_index], 1, nullptr, 0);

    // 3. 派发 Compute Shader
    u32 group_x = (width + 7) / 8; // (width / 8)向上取整
    u32 group_y = (height + 7) / 8; // (height / 8)向上取整
    gpu_commands->dispatch(group_x, group_y, 1);

    // 4. 内存屏障：转换当前 Mip 层的布局，确保写入完成，并准备好在下一轮作为输入被读取
    util_add_image_barrier(gpu, ..., RESOURCE_STATE_UNORDERED_ACCESS, RESOURCE_STATE_SHADER_RESOURCE, mip_index, ...);

    width /= 2;
    height /= 2;
}

// It might be better to use logarithmic slices to have better resolution
// closer to the camera.
const f32 bin_size = 1.0f / k_light_z_bins;

Array<u32> bin_range_per_light;
bin_range_per_light.init(context.scratch_allocator, active_lights, active_lights);

for (u32 i = 0; i < active_lights; ++i) {
    const SortedLight& light = sorted_lights[i];

    // 跳过完全在摄像机背后的光源
    if (light.projected_z_min < 0.0f && light.projected_z_max < 0.0f) {
        bin_range_per_light[i] = u32_max;
        continue;
    }

    // 计算光源覆盖的最小和最大 Z-Bin 索引
    // projected_z_min/max 已经是归一化到 [0, 1] 的深度值
    const u32 min_bin = hydra::max(0, hydra::floori32(light.projected_z_min * k_light_z_bins));
    const u32 max_bin = hydra::max(0, hydra::ceili32(light.projected_z_max * k_light_z_bins));

    // 将 min_bin 和 max_bin 打包到一个 u32 中
    bin_range_per_light[i] = (min_bin & 0xffff) | ((max_bin & 0xffff) << 16);
}

for (u32 bin = 0; bin < k_light_z_bins; ++bin) {
    u32 min_light_id = k_num_lights + 1; // 初始为一个无效的最大值
    u32 max_light_id = 0;               // 初始为一个无效的最小值

    for (u32 i = 0; i < active_lights; ++i) {
        const u32 light_bins = bin_range_per_light[i];
        if (light_bins == u32_max) {
            continue;
        }

        // 从 u32 中解包出 min_bin 和 max_bin
        const u32 min_bin = light_bins & 0xffff;
        const u32 max_bin = light_bins >> 16;

        // 检查当前光源是否覆盖了当前正在处理的 bin
        if (bin >= min_bin && bin <= max_bin) {
            // 如果是，更新这个 bin 所见光源的最小和最大索引
            if (i < min_light_id) {
                min_light_id = i;
            }
            if (i > max_light_id) {
                max_light_id = i;
            }
        }
    }

    // 将这个 bin 的光源索引范围打包并存入最终的 LUT
    lights_lut[bin] = min_light_id | (max_light_id << 16);
}

// 迭代所有激活的光源
for (u32 i = 0; i < active_lights; ++i) {
    // ... 获取光源位置和半径 ...
    vec4s view_space_pos = glms_mat4_mulv(game_camera.camera.view, pos);

    // ... (一系列复杂的数学计算) ...
    // 最终目标是得到一个NDC坐标系下的AABB
    vec4s aabb{ min_ndc_x, min_ndc_y, max_ndc_x, max_ndc_y };

    // ...

    // 将NDC坐标 [-1, 1] 转换为屏幕像素坐标 [0, width] / [0, height]
    vec4s aabb_screen{(aabb.x * 0.5f + 0.5f) * (gpu.swapchain_width - 1),
                      (aabb.y * 0.5f + 0.5f) * (gpu.swapchain_height - 1),
                      (aabb.z * 0.5f + 0.5f) * (gpu.swapchain_width - 1),
                      (aabb.w * 0.5f + 0.5f) * (gpu.swapchain_height - 1)};
    
    // ...
}

    // 计算 Tile 的数量和尺寸
    static const u32 k_num_lights = 256;
    static const u32 k_light_z_bins = 16;
    static const u32 k_tile_size = 8;
    static const u32 k_num_words = (k_num_lights + 31) / 32;
    const u32 tile_x_count = scene_data.resolution_x / k_tile_size;
    const u32 tile_y_count = scene_data.resolution_y / k_tile_size;
    // Assign light
    Array<u32> light_tiles_bits;
    light_tiles_bits.init(tile_x_count * tile_y_count * k_num_words);

    // ... 计算得到屏幕坐标 aabb_screen ...
    // 裁剪和边界检查，确保 AABB 在屏幕范围内
    min_x = max(min_x, 0.0f);
    min_y = max(min_y, 0.0f);
    max_x = min(max_x, (float)gpu.swapchain_width);
    max_y = min(max_y, (float)gpu.swapchain_height);

    // 根据AABB计算它覆盖的 tile 范围
    u32 first_tile_x = (u32)(min_x * tile_size_inv);
    u32 last_tile_x = min(tile_x_count - 1, (u32)(max_x * tile_size_inv));
    u32 first_tile_y = (u32)(min_y * tile_size_inv);
    u32 last_tile_y = min(tile_y_count - 1, (u32)(max_y * tile_size_inv));

    // 遍历所有被该光源覆盖的 tile
    for (u32 y = first_tile_y; y <= last_tile_y; ++y) {
        for (u32 x = first_tile_x; x <= last_tile_x; ++x) {
            // 计算当前 tile 在一维数组中的索引
            u32 array_index = y * tile_stride + x * k_num_words;

            // 计算当前光源 i 应该在位掩码的哪个 u32 的哪一位
            u32 word_index = i / 32;
            u32 bit_index = i % 32;

            // 将对应的位置1
            light_tiles_bits[array_index + word_index] |= (1 << bit_index);
        }
    }

vec4 final_color = vec4(0);

// 1. 获取片元在相机空间的坐标
vec4 pos_camera_space = world_to_camera * vec4(world_position, 1.0);

// 2. 根据深度计算 Z-Bin 索引
float linear_d = (pos_camera_space.z - z_near) / (z_light_far - z_near);
int bin_index = int(linear_d / BIN_WIDTH);

// 3. 从 Z-Bin LUT 中获取光源索引范围
uint bin_value = bins[bin_index];
uint min_light_id = bin_value & 0xFFFF;
uint max_light_id = (bin_value >> 16) & 0xFFFF;

// 4. 根据屏幕坐标计算 Tile 地址
uvec2 tile = position / uint(TILE_SIZE);
uint stride = uint(NUM_WORDS) * (uint(resolution.x) / uint(TILE_SIZE));
uint address = tile.y * stride + tile.x;

#else // 未开启优化
  // 检查 min_light_id 是否有效
  if (min_light_id != NUM_LIGHTS + 1) {
    // 遍历 Z-Bin 给出的光源索引范围
    for (uint light_id = min_light_id; light_id <= max_light_id; ++light_id) {
      // 计算该光源在位掩码中的位置
      uint word_id = light_id / 32;
      uint bit_id = light_id % 32;

      // 检查 Tile 位掩码中对应的位是否为 1
      if ((tiles[address + word_id] & (1 << bit_id)) != 0) {
        // 如果两个条件都满足，该光源有效，进行光照计算
        uint global_light_index = light_indices[light_id];
        final_color.rgb +=
            calculate_point_light_contribution(...);
      }
    }
  }
#endif

#if ENABLE_OPTIMIZATION
  // 1. 在整个 subgroup 中找到一个统一的、更大的光源索引范围
  uint merged_min = subgroupBroadcastFirst(subgroupMin(min_light_id));
  uint merged_max = subgroupBroadcastFirst(subgroupMax(max_light_id));

  // 计算这个统一范围覆盖了哪些 u32 "words"
  uint word_min = max(merged_min / 32, 0);
  uint word_max = min(merged_max / 32, NUM_WORDS);

  // 2. 以统一的 word 范围进行循环，避免了循环本身的发散
  for (uint word_index = word_min; word_index <= word_max; ++word_index) {
    uint mask = tiles[address + word_index];

    // 3. 为每个线程重新构建其独立的 Z-Bin 掩码
    uint local_min = clamp(int(min_light_id) - int((word_index * 32)), 0, 31);
    uint mask_width = clamp(int(max_light_id) - int(min_light_id) + 1, 0, 32);
    uint zbin_mask = (mask_width == 32) ? uint(0xFFFFFFFF) : bit_field_mask(mask_width, local_min);
    
    // 应用 Z-Bin 掩码
    mask &= zbin_mask;

    // 4. 将 subgroup 中所有线程的有效光源掩码进行“或”操作，得到一个统一的掩码
    uint merged_mask = subgroupBroadcastFirst(subgroupOr(mask));

    // 5. 在统一的掩码上循环，所有线程执行完全相同的路径
    while (merged_mask != 0) {
      uint bit_index = get_lowest_bit(merged_mask); // 找到第一个为1的位
      uint light_index = 32 * word_index + bit_index;

      merged_mask ^= (1 << bit_index); // 清除该位

      uint global_light_index = light_indices[light_index];
      final_color.rgb +=
          calculate_point_light_contribution(...);
    }
  }
#endif

// NOTE(marco): ...these values are stored in scalar registers and we avoid storing them in vector registers
uint merged_min = subgroupBroadcastFirst(subgroupMin(min_light_id));
uint merged_max = subgroupBroadcastFirst(subgroupMax(max_light_id));

// NOTE(marco): ...The while loop below can then use scalar
// registers as we know the value will be uniform across all threads
uint merged_mask = subgroupBroadcastFirst(subgroupOr(mask));

while (merged_mask != 0) { // 在标量寄存器上操作，无分歧
  uint bit_index = get_lowest_bit(merged_mask); // 标量操作
  ...
  merged_mask ^= (1 << bit_index); // 标量操作
  ...
}

  // ... 其他光源，如定向光、带阴影的光源 ...
  final_color.rgb += calculate_directional_light_contribution(...);

  vec3 F = fresnel_schlick_roughness(max(dot(normal, V), 0.0), F0, roughness);
  // ...
  kD *= 1.0 - metallic;
  
  // 间接光照-漫反射
  vec3 indirect_diffuse = indirect_irradiance * gi_intensity * base_colour.rgb;
  final_color.rgb += (kD * indirect_diffuse) * ao;

  // 间接光照-镜面反射
  vec2 envBRDF = textureLod(brdf_lut_texture, vec2(NoV, roughness), 0).rg;
  vec3 indirect_specular = reflection_color * (F * envBRDF.x + envBRDF.y);
  final_color.rgb += (indirect_specular) * ao;

  // ... 添加自发光 ...
  final_color.rgb += emissive;

  // ... sRGB 编码并返回 ...
  return vec4(encode_srgb(final_color.rgb), final_color.a);

// 1. 在 XZ 平面上求解
vec2s cx{view_space_pos.x, view_space_pos.z};
// 计算相机到圆心的距离的平方 与 半径的平方 的差值
const f32 tx_squared = glms_vec2_dot(cx, cx) - (radius * radius);
const bool tx_camera_inside = tx_squared <= 0;
// 计算一个包含切线信息的辅助向量
vec2s vx{sqrtf(tx_squared), radius};
// 构造一个 2D 旋转缩放矩阵
mat2s xtransf_min{vx.x, vx.y, -vx.y, vx.x};
// 计算下边界切点
vec2s minx = glms_mat2_mulv(xtransf_min, cx);
// 构造另一个旋转缩放矩阵
mat2s xtransf_max{vx.x, -vx.y, vx.y, vx.x};
// 计算上边界切点
vec2s maxx = glms_mat2_mulv(xtransf_max, cx);

// 2. 在 YZ 平面上做同样的操作 (注意 Y 轴取反)
vec2s cy{-view_space_pos.y, view_space_pos.z};
// ... 类似的计算 ...
vec2s miny = ...;
vec2s maxy = ...;

// 3. 将 2D 切点坐标转换为 NDC 坐标
vec4s aabb{minx.x / minx.y * game_camera.camera.projection.m00,
           miny.x / miny.y * game_camera.camera.projection.m11,
           maxx.x / maxx.y * game_camera.camera.projection.m00,
           maxy.x / maxy.y * game_camera.camera.projection.m11};

if (context.use_mcguire_method) {
    vec3s left, right, top, bottom;
    // 1. 沿 X 轴 (1,0,0) 找到左右边界点
    get_bounds_for_axis(vec3s{1, 0, 0}, view_space_pos, radius, 
                        game_camera.camera.near_plane, left, right);
    // 2. 沿 Y 轴 (0,1,0) 找到上下边界点
    get_bounds_for_axis(vec3s{0, 1, 0}, view_space_pos, radius, 
                        game_camera.camera.near_plane, top, bottom);

    // 3. 将这些视图空间的边界点投影到 NDC
    left = project(game_camera.camera.projection, left);
    right = project(game_camera.camera.projection, right);
    top = project(game_camera.camera.projection, top);
    bottom = project(game_camera.camera.projection, bottom);

    // 4. 组合成最终的 AABB
    aabb.x = right.x;
    aabb.z = left.x;
    aabb.y = -top.y;     // Y 轴在屏幕和 NDC 空间可能反向
    aabb.w = -bottom.y;
}

void get_bounds_for_axis(const vec3s& a, /* Bounding axis (e.g. {1,0,0}) */ ...) {
    // 将球心 C 投影到由轴 a 和 z 轴定义的 2D 平面
    const vec2s c{glms_vec3_dot(a, C), C.z};
    // ... 与方法一类似的切点计算 ...

    // 检查球体是否与近裁剪面相交
    const bool clipSphere = (c.y + r >= nearZ);
    // ...

    for (int i = 0; i < 2; ++i) {
        // ... 计算切点 bounds[i] ...

        // 如果切点在近平面内侧，并且球体与近平面相交
        const bool clipBound = cameraInsideSphere || (bounds[i].y > nearZ);
        if (clipSphere && clipBound) {
            // 用球体与近平面相交的交点替换切点
            bounds[i] = vec2s{c.x + k, nearZ};
        }
        // ...
    }
    // ... 将 2D 边界点转换回 3D 摄像机空间 ...
}

if (context.use_view_aabb) {
    vec3s aabb_min{...}, aabb_max{...};

    // 1. 遍历光源包围球的3D AABB的8个顶点
    for (u32 c = 0; c < 8; ++c) {
        vec3s corner{...}; // 计算第c个角点世界坐标
        // ...
        
        // 2. 将角点转换到视图空间，并裁剪到近平面
        vec4s corner_vs = glms_mat4_mulv(game_camera.camera.view, ...);
        corner_vs.z = glm_max(game_camera.camera.near_plane, corner_vs.z);

        // 3. 将视图空间角点投影到NDC
        vec4s corner_ndc = glms_mat4_mulv(game_camera.camera.projection, corner_vs);
        corner_ndc = glms_vec4_divs(corner_ndc, corner_ndc.w);

        // 4. 在 NDC 空间中更新 AABB 的 min/max
        aabb_min.x = glm_min(aabb_min.x, corner_ndc.x);
        // ... aabb_min.y, aabb_max.x, aabb_max.y ...
    }
    // 5. 用 min/max 组合成最终 AABB
    aabb.x = aabb_min.x;
    aabb.z = aabb_max.x;
    // ...
}