@woosh/meep-engine 3.53.0 → 3.54.0

package/src/shade/renderer/light/environment/shader_project_far_field_irradiance_sh.js

@@ -0,0 +1,72 @@
+import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
+import {
+    chunk_directional_lights_iteration_mask
+} from "../../shader/chunk/light/io/chunk_directional_lights_iteration_mask.js";
+import {
+    chunk_get_directional_light_info_by_index
+} from "../../shader/chunk/light/io/chunk_get_directional_light_info_by_index.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_volumetrics_irradiance_sh } from "../../volumetrics/chunk_volumetrics_irradiance_sh.js";
+import { ENVIRONMENT_SH_TYPE } from "./shader_project_environment_sh.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("environment_sh", ENVIRONMENT_SH_TYPE)
+    .addStorageBuffer("light_data", WebGPUArray.u32, false)
+    .addStorageBuffer("far_field_sh", METRO_L1_IRRADIANCE_STRUCT, true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(1)
+fn main() {
+    const INDIRECT_INTENSITY : f32 = ${INDIRECT_LIGHT_INTENSITY};
+
+    let scaled_radiance = array<vec3<f32>, 4>(
+        environment_sh[0].xyz * INDIRECT_INTENSITY,
+        environment_sh[1].xyz * INDIRECT_INTENSITY,
+        environment_sh[2].xyz * INDIRECT_INTENSITY,
+        environment_sh[3].xyz * INDIRECT_INTENSITY,
+    );
+
+    var sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+    sh = volumetrics_irradiance_sh_add_radiance(sh, scaled_radiance);
+
+    var directional_bits = directional_lights_iteration_mask(&light_data);
+    while (directional_bits != 0u) {
+        let directional_index = countTrailingZeros(directional_bits);
+        directional_bits &= ~(1u << directional_index);
+
+        let sun = get_directional_light_info_by_index(&light_data, directional_index);
+        sh = volumetrics_irradiance_sh_add(sh, sun.color, sun.direction);
+    }
+
+    far_field_sh = volumetrics_irradiance_sh_storable(sh);
+}
+`, [
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+        chunk_volumetrics_irradiance_sh,
+        chunk_directional_lights_iteration_mask,
+        chunk_get_directional_light_info_by_index,
+    ]
+);
+
+/**
+ * Projects the scene's far-field irradiance (the environment SH scaled by `INDIRECT_LIGHT_INTENSITY`
+ * plus unshadowed directional lights) into a single cached {@link METRO_L1_IRRADIANCE_STRUCT} buffer on
+ * `GPULightCollection`. Updated only when the environment or directional lights change.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_project_far_field_irradiance_sh = ComputeShader.from({
+    label: "Environment / project far-field irradiance SH",
+    resources,
+    body,
+});

package/src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Number of cluster cells along each axis of a single world-space clipmap cascade (`8 × 8 × 8 = 512`).
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_GRID_SIZE: number;
+/**
+ * Total cluster cells in one cascade (`8³ = 512`).
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE: number;
+/**
+ * Maximum number of cascades supported by the world-space light cluster clipmap.
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_MAX_CASCADES: number;
+/**
+ * Maximum number of lights (point + spot) assigned to a single world-space cluster cell.
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL: number;
+/**
+ * Maximum number of point/spot lights culled into the world-space clipmap candidate list.
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_LIGHT_CAPACITY: number;
+/**
+ * Settings passed to the world-space light culling pass: the world-space AABB of the coarsest
+ * cascade (including its skirt).
+ * @type {WebGPUStruct}
+ */
+export const WORLD_LIGHT_CLUSTER_CULL_SETTINGS: WebGPUStruct;
+/**
+ * Exact sphere-vs-AABB and conservative spot-cone-vs-AABB intersection tests in world space.
+ * @type {CodeChunk}
+ */
+export const chunk_world_cluster_aabb: CodeChunk;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=WORLD_LIGHT_CLUSTER.d.ts.map

package/src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WORLD_LIGHT_CLUSTER.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,oDAFU,MAAM,CAEwE;AAExF;;;GAGG;AACH,+CAFU,MAAM,CAEiE;AAEjF;;;GAGG;AACH,sDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,iDAFU,MAAM,CAEuC;AAEvD;;;;GAIG;AACH,gDAFU,YAAY,CAOc;AAEpC;;;GAGG;AACH,uCAFU,SAAS,CAsCjB;6BAtF2B,mCAAmC;0BAFtC,oCAAoC"}

package/src/shade/renderer/light/world_cluster/WORLD_LIGHT_CLUSTER.js

@@ -0,0 +1,90 @@
+import { chunk_cone_intersects_sphere } from "../../shader/chunk/geometry/cone/chunk_cone_intersects_sphere.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { u32, vec3f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { IRRADIANCE_CLIPMAP_CASCADE_LIMIT } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
+import { CLUSTER_LIGHT_PROXY } from "../cluster/CLUSTER_LIGHT_PROXY.js";
+
+/**
+ * Number of cluster cells along each axis of a single world-space clipmap cascade (`8 × 8 × 8 = 512`).
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_GRID_SIZE = 8;
+
+/**
+ * Total cluster cells in one cascade (`8³ = 512`).
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE = WORLD_LIGHT_CLUSTER_GRID_SIZE ** 3;
+
+/**
+ * Maximum number of cascades supported by the world-space light cluster clipmap.
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_MAX_CASCADES = IRRADIANCE_CLIPMAP_CASCADE_LIMIT;
+
+/**
+ * Maximum number of lights (point + spot) assigned to a single world-space cluster cell.
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL = 128;
+
+/**
+ * Maximum number of point/spot lights culled into the world-space clipmap candidate list.
+ * @type {number}
+ */
+export const WORLD_LIGHT_CLUSTER_LIGHT_CAPACITY = 4096;
+
+/**
+ * Settings passed to the world-space light culling pass: the world-space AABB of the coarsest
+ * cascade (including its skirt).
+ * @type {WebGPUStruct}
+ */
+export const WORLD_LIGHT_CLUSTER_CULL_SETTINGS = WebGPUStruct.from({
+    coarsest_min: vec3f,
+    cascade_count: u32,
+    coarsest_max: vec3f,
+    pad0: u32,
+}, "WorldLightClusterCullSettings");
+
+/**
+ * Exact sphere-vs-AABB and conservative spot-cone-vs-AABB intersection tests in world space.
+ * @type {CodeChunk}
+ */
+export const chunk_world_cluster_aabb = CodeChunk.from(
+    //language=WGSL
+    `
+fn world_cluster_sphere_intersects_aabb(
+    center: vec3<f32>,
+    radius: f32,
+    box_min: vec3<f32>,
+    box_max: vec3<f32>,
+) -> bool {
+    let closest = clamp(center, box_min, box_max);
+    let d = center - closest;
+    return dot(d, d) <= radius * radius;
+}
+
+fn world_cluster_cone_intersects_aabb(
+    proxy: ${CLUSTER_LIGHT_PROXY.wgsl_ref},
+    box_min: vec3<f32>,
+    box_max: vec3<f32>,
+) -> bool {
+    if (!world_cluster_sphere_intersects_aabb(proxy.bound.xyz, proxy.bound.w, box_min, box_max)) {
+        return false;
+    }
+    let box_center = 0.5 * (box_min + box_max);
+    let box_radius = length(0.5 * (box_max - box_min));
+    return cone_intersects_sphere(
+        proxy.apex_height.xyz,
+        proxy.direction_cos.xyz,
+        proxy.apex_height.w,
+        proxy.direction_cos.w,
+        vec4<f32>(box_center, box_radius)
+    ) || world_cluster_sphere_intersects_aabb(proxy.apex_height.xyz, proxy.source_radius, box_min, box_max);
+}
+`, [
+        CLUSTER_LIGHT_PROXY.declaration_chunk,
+        chunk_cone_intersects_sphere,
+    ]
+);

package/src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.d.ts

@@ -0,0 +1,12 @@
+export const WORLD_CLUSTER_LOOKUP_RESOURCE: ShaderResourceDescriptor;
+export const WORLD_CLUSTER_DATA_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Lookup helper for reading the world-space light cluster cell corresponding to a texel of cascade
+ * `cascade` in the irradiance clipmap tile (`tile_size = resolution + 2 * border`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_world_light_cluster_lookup: CodeChunk;
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_world_light_cluster_lookup.d.ts.map

package/src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_world_light_cluster_lookup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.js"],"names":[],"mappings":"AAQA,qEAIE;AAEF,mEAIE;AAEF;;;;;GAKG;AACH,+CAFU,SAAS,CA6BjB;yCAnDuC,mDAAmD;0BADlE,oCAAoC"}

package/src/shade/renderer/light/world_cluster/chunk_world_light_cluster_lookup.js

@@ -0,0 +1,56 @@
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../shader/resource/ShaderResourceDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { LIGHT_CLUSTER_METADATA } from "../cluster/LIGHT_CLUSTER_METADATA.js";
+import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../cluster/shader_cluster_assign_lights.js";
+import { WORLD_LIGHT_CLUSTER_GRID_SIZE } from "./WORLD_LIGHT_CLUSTER.js";
+
+export const WORLD_CLUSTER_LOOKUP_RESOURCE = ShaderResourceDescriptor.storageBuffer(
+    "world_cluster_lookup",
+    LIGHT_CLUSTER_LOOKUP_STRUCT,
+    false
+);
+
+export const WORLD_CLUSTER_DATA_RESOURCE = ShaderResourceDescriptor.storageBuffer(
+    "world_cluster_data",
+    WebGPUArray.u32,
+    false
+);
+
+/**
+ * Lookup helper for reading the world-space light cluster cell corresponding to a texel of cascade
+ * `cascade` in the irradiance clipmap tile (`tile_size = resolution + 2 * border`).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_world_light_cluster_lookup = CodeChunk.from(
+    //language=WGSL
+    `
+const WORLD_LIGHT_CLUSTER_GRID_SIZE: u32 = ${WORLD_LIGHT_CLUSTER_GRID_SIZE}u;
+
+fn world_light_cluster_cell_from_local_texel(local_texel: vec3<u32>, tile_size: vec3<u32>) -> vec3<u32> {
+    let num = (local_texel * 2u + vec3<u32>(1u)) * WORLD_LIGHT_CLUSTER_GRID_SIZE;
+    let den = tile_size * 2u;
+    return min(num / den, vec3<u32>(WORLD_LIGHT_CLUSTER_GRID_SIZE - 1u));
+}
+
+fn world_light_cluster_metadata_by_texel(
+    cascade: u32,
+    local_texel: vec3<u32>,
+    tile_size: vec3<u32>,
+) -> ${LIGHT_CLUSTER_METADATA.wgsl_ref} {
+    let cell = world_light_cluster_cell_from_local_texel(local_texel, tile_size);
+    let index = grid3d_to_index(
+        vec3<u32>(cell.xy, cascade * WORLD_LIGHT_CLUSTER_GRID_SIZE + cell.z),
+        vec2<u32>(WORLD_LIGHT_CLUSTER_GRID_SIZE)
+    );
+    return world_cluster_lookup[index];
+}
+`, [
+        LIGHT_CLUSTER_METADATA.declaration_chunk,
+        chunk_grid3d_to_index,
+    ]
+);
+
+chunk_world_light_cluster_lookup.requireResource(WORLD_CLUSTER_LOOKUP_RESOURCE);

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Offer the pipelines {@link graph_build_world_light_clusters} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_build_world_light_clusters_pipelines(enquiry: PipelineEnquiry): void;
+/**
+ * Builds the world-space light cluster clipmap over the cascades of the irradiance clipmap.
+ *
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
+ * @param {number} options.irradiance_clipmap_uniform graph handle of the `IRRADIANCE_CLIPMAP_STRUCT` uniform
+ * @param {number} options.cascade_count active cascade count
+ * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including skirt)
+ * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including skirt)
+ * @returns {{lookup: number, data: number}}
+ */
+export function graph_build_world_light_clusters({ graph, lights, irradiance_clipmap_uniform, cascade_count, coarsest_min, coarsest_max, }: {
+    graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    lights: import("../GPULightCollection.js").GPULightCollection;
+    irradiance_clipmap_uniform: number;
+    cascade_count: number;
+    coarsest_min: ArrayLike<number>;
+    coarsest_max: ArrayLike<number>;
+}): {
+    lookup: number;
+    data: number;
+};
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
+//# sourceMappingURL=graph_build_world_light_clusters.d.ts.map

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_build_world_light_clusters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,sEAFW,eAAe,QAMzB;AAED;;;;;;;;;;;GAWG;AACH;IARsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAClB,MAAM,EAArE,OAAO,0BAA0B,EAAE,kBAAkB;IACrC,0BAA0B,EAA1C,MAAM;IACU,aAAa,EAA7B,MAAM;IACqB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACU,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CA0H1C;8BA3KY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js

@@ -0,0 +1,196 @@
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { CLUSTER_LIGHT_PROXY } from "../cluster/CLUSTER_LIGHT_PROXY.js";
+import { LIGHT_CLUSTER_METADATA } from "../cluster/LIGHT_CLUSTER_METADATA.js";
+import {
+    shader_world_cluster_assign_lights,
+    WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE,
+} from "./shader_world_cluster_assign_lights.js";
+import {
+    shader_world_cluster_cull_point_lights,
+    shader_world_cluster_cull_spot_lights,
+} from "./shader_world_cluster_cull_lights.js";
+import {
+    WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE,
+    WORLD_LIGHT_CLUSTER_CULL_SETTINGS,
+    WORLD_LIGHT_CLUSTER_GRID_SIZE,
+    WORLD_LIGHT_CLUSTER_LIGHT_CAPACITY,
+    WORLD_LIGHT_CLUSTER_MAX_CASCADES,
+    WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL,
+} from "./WORLD_LIGHT_CLUSTER.js";
+
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+const CULLED_LIST_DESCRIPTOR = BufferResourceDescriptor.from(
+    COLLECTION_U32_STRUCT_WRITE.size + WORLD_LIGHT_CLUSTER_LIGHT_CAPACITY * u32.size,
+    GPUBufferUsage.STORAGE,
+    0,
+    16,
+);
+
+const PROXIES_DESCRIPTOR = BufferResourceDescriptor.from(
+    WORLD_LIGHT_CLUSTER_LIGHT_CAPACITY * CLUSTER_LIGHT_PROXY.aligned_size,
+    GPUBufferUsage.STORAGE,
+);
+
+const LOOKUP_DESCRIPTOR = BufferResourceDescriptor.from(
+    WORLD_LIGHT_CLUSTER_MAX_CASCADES * WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE * LIGHT_CLUSTER_METADATA.aligned_size,
+    GPUBufferUsage.STORAGE,
+);
+
+const DATA_DESCRIPTOR = BufferResourceDescriptor.from(
+    COLLECTION_U32_STRUCT_WRITE.size
+    + WORLD_LIGHT_CLUSTER_MAX_CASCADES * WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE * WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL * u32.size,
+    GPUBufferUsage.STORAGE,
+    0,
+    16,
+);
+
+/**
+ * Offer the pipelines {@link graph_build_world_light_clusters} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_build_world_light_clusters_pipelines(enquiry) {
+    enquiry.compute.push(shader_world_cluster_cull_point_lights.pipeline);
+    enquiry.compute.push(shader_world_cluster_cull_spot_lights.pipeline);
+    enquiry.compute.push(shader_world_cluster_assign_lights.pipeline);
+}
+
+/**
+ * Builds the world-space light cluster clipmap over the cascades of the irradiance clipmap.
+ *
+ * @param {object} options
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
+ * @param {number} options.irradiance_clipmap_uniform graph handle of the `IRRADIANCE_CLIPMAP_STRUCT` uniform
+ * @param {number} options.cascade_count active cascade count
+ * @param {ArrayLike<number>} options.coarsest_min `[x, y, z]` world min of coarsest cascade (including skirt)
+ * @param {ArrayLike<number>} options.coarsest_max `[x, y, z]` world max of coarsest cascade (including skirt)
+ * @returns {{lookup: number, data: number}}
+ */
+export function graph_build_world_light_clusters({
+    graph,
+    lights,
+    irradiance_clipmap_uniform,
+    cascade_count,
+    coarsest_min,
+    coarsest_max,
+}) {
+    const gr_light_data = lights?.buffer_data instanceof GPUBuffer
+        ? graph_import_buffer(graph, lights.buffer_data, "world_cluster/lights_database")
+        : -1;
+
+    const cull_data = {
+        lights,
+        cascade_count,
+        cull_settings: {
+            coarsest_min: [coarsest_min[0], coarsest_min[1], coarsest_min[2]],
+            cascade_count,
+            coarsest_max: [coarsest_max[0], coarsest_max[1], coarsest_max[2]],
+            pad0: 0,
+        },
+        light_data: -1,
+        culled_lights: -1,
+        proxies: -1,
+    };
+
+    const cull_pass = graph.add("World cluster / cull lights", cull_data, (data, resources, context) => {
+        if (data.cascade_count <= 0) {
+            return;
+        }
+
+        const point_table = data.lights.database.get("light_point");
+        const spot_table = data.lights.database.get("light_spot");
+        const point_threads = point_table.dispatch_page_count * point_table.descriptor.elements_per_page;
+        const spot_threads = spot_table.dispatch_page_count * spot_table.descriptor.elements_per_page;
+
+        if (point_threads === 0 && spot_threads === 0) {
+            return;
+        }
+
+        const settings_buffer = context.encoder.allocateTransientValueBuffer(
+            WORLD_LIGHT_CLUSTER_CULL_SETTINGS,
+            data.cull_settings,
+            GPUBufferUsage.UNIFORM
+        );
+
+        const bindings = {
+            settings: settings_buffer,
+            light_data: data.light_data !== -1 ? resources.get(data.light_data) : data.lights.buffer_data,
+            output_list: resources.get(data.culled_lights),
+            proxies: resources.get(data.proxies),
+        };
+
+        if (point_threads > 0) {
+            shader_world_cluster_cull_point_lights.dispatchThreads({
+                encoder: context.encoder,
+                bindings,
+                thread_count_x: point_threads,
+            });
+        }
+
+        if (spot_threads > 0) {
+            shader_world_cluster_cull_spot_lights.dispatchThreads({
+                encoder: context.encoder,
+                bindings,
+                thread_count_x: spot_threads,
+            });
+        }
+    });
+
+    if (gr_light_data !== -1) {
+        cull_data.light_data = cull_pass.read(gr_light_data);
+    }
+    cull_data.culled_lights = cull_pass.create("World cluster / culled list", CULLED_LIST_DESCRIPTOR);
+    cull_data.proxies = cull_pass.create("World cluster / proxies", PROXIES_DESCRIPTOR);
+
+    const assign_data = {
+        cascade_count,
+        irradiance_clipmap: -1,
+        culled_lights: -1,
+        proxies: -1,
+        lookup: -1,
+        data: -1,
+    };
+
+    const assign_pass = graph.add("World cluster / assign lights", assign_data, (data, resources, context) => {
+        if (data.cascade_count <= 0) {
+            return;
+        }
+
+        const groups_xy = Math.ceil(WORLD_LIGHT_CLUSTER_GRID_SIZE / WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE[0]);
+        const groups_z = Math.ceil(
+            (WORLD_LIGHT_CLUSTER_GRID_SIZE * data.cascade_count) / WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE[2]
+        );
+
+        shader_world_cluster_assign_lights.dispatch({
+            encoder: context.encoder,
+            group_count_x: groups_xy,
+            group_count_y: groups_xy,
+            group_count_z: groups_z,
+            bindings: {
+                irradiance_clipmap: resources.get(data.irradiance_clipmap),
+                culled_lights: resources.get(data.culled_lights),
+                proxies: resources.get(data.proxies),
+                world_cluster_lookup: resources.get(data.lookup),
+                world_cluster_data: resources.get(data.data),
+            },
+        });
+    });
+
+    assign_data.irradiance_clipmap = assign_pass.read(irradiance_clipmap_uniform);
+    assign_data.culled_lights = assign_pass.read(cull_data.culled_lights);
+    assign_data.proxies = assign_pass.read(cull_data.proxies);
+    assign_data.lookup = assign_pass.create("World cluster / lookup", LOOKUP_DESCRIPTOR);
+    assign_data.data = assign_pass.create("World cluster / data", DATA_DESCRIPTOR);
+
+    return {
+        lookup: assign_data.lookup,
+        data: assign_data.data,
+    };
+}

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.d.ts

@@ -0,0 +1,10 @@
+export const WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE: readonly number[];
+/**
+ * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each
+ * cascade of the world-space irradiance clipmap.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_world_cluster_assign_lights: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_world_cluster_assign_lights.d.ts.map

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_world_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js"],"names":[],"mappings":"AAoBA,oEAA4E;AAoI5E;;;;;GAKG;AACH,iDAFU,aAAa,CAMpB;8BA9J2B,+BAA+B"}