@woosh/meep-engine 3.61.2 → 3.61.3

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_split.js

@@ -1,146 +0,0 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { chunk_mesh_sdf_bake, MESH_SDF_ARENA_RESOURCE } from "../bake/chunk_mesh_sdf_bake.js";
-import { MESH_SDF_HEADERS_RESOURCE } from "../MESH_SDF_RESOURCES.js";
-import { chunk_mesh_cards } from "./chunk_mesh_cards.js";
-import { MESH_CARD_DIRECTIONS } from "./MESH_CARDS.js";
-
-/**
- * @type {WebGPUStruct}
- */
-export const MESH_CARDS_SPLIT_SETTINGS = WebGPUStruct.from({
-    /** the geometry whose cards are placed */
-    geometry: u32,
-}, "MeshCardsSplitSettings");
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", MESH_CARDS_SPLIT_SETTINGS);
-
-resources.createGroup()
-    .add(MESH_SDF_HEADERS_RESOURCE)
-    .add(MESH_SDF_ARENA_RESOURCE);
-
-/**
- * Card placement, step 2 (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5): a thread a direction runs its
- * greedy search. The direction starts with one card over the whole grid, its outer projection, and
- * each split takes the layer that newly covers the most run starts.
- *
- * Within a direction the cards partition the layers. A run start (m, z) lies in the card whose
- * layers hold z, and is covered when that card's near face is at or before m. A split of card
- * [k₀, k₁) at layer s gives the far part [s, k₁), which newly covers the uncovered run starts with
- * k₀ < m ≤ s ≤ z < k₁. The near part keeps its own, so coverage never shrinks. That count is a
- * rectangle of the (m, z) histogram, read from its 2-D prefix sums in four loads.
- *
- * A direction's gains never grow from one split to the next, and splits along one direction leave
- * the others' gains alone. Merging the six directions' sequences by gain is therefore the greedy
- * search over all six, which the merge does. The splits are written in the order taken, (gain,
- * layer) each, MESH_CARD_SPLITS_MAX at most; the first gain of 0 ends the sequence.
- *
- * Runs on the device as the bake does, a pass with nothing to wait on, though the six threads do
- * work a frame's passes must not: the prefix sums over every (m, z) of the direction, and up to 26
- * scans of its layers. It runs once for each geometry that turns resident.
- *
- * @type {ComputeShader}
- */
-export const shader_mesh_cards_split = ComputeShader.from({
-    label: "Mesh Cards Split",
-    resources,
-    body: CodeChunk.from(
-        //language=WGSL
-        `
-/** whether layer k starts a card, two words for up to 64 layers */
-fn mesh_cards_starts(bounds: vec2<u32>, layer: u32) -> bool {
-    return ((bounds[layer >> 5u] >> (layer & 31u)) & 1u) != 0u;
-}
-
-fn mesh_cards_histogram_at(histogram: u32, stride: u32, m: i32, z: i32) -> u32 {
-    if (m < 0 || z < 0) {
-        return 0u;
-    }
-
-    return atomicLoad(&mesh_sdf_indirection[histogram + u32(m) * stride + u32(z)]);
-}
-
-/** run starts with m in [m0, m1] and z in [z0, z1], from the prefix sums */
-fn mesh_cards_rectangle(histogram: u32, stride: u32, m0: i32, m1: i32, z0: i32, z1: i32) -> u32 {
-    if (m0 > m1 || z0 > z1) {
-        return 0u;
-    }
-
-    return mesh_cards_histogram_at(histogram, stride, m1, z1)
-        + mesh_cards_histogram_at(histogram, stride, m0 - 1, z0 - 1)
-        - mesh_cards_histogram_at(histogram, stride, m0 - 1, z1)
-        - mesh_cards_histogram_at(histogram, stride, m1, z0 - 1);
-}
-
-@compute @workgroup_size(${MESH_CARD_DIRECTIONS})
-fn main(@builtin(local_invocation_index) direction: u32) {
-    let header = mesh_sdf_headers[settings.geometry];
-    let parts = mesh_card_placement_of(header.bricks);
-    let layers = mesh_card_extent(header.bricks, direction).x;
-    let stride = parts.layers;
-
-    let histogram = header.cards + parts.histograms + direction * stride * stride;
-
-    // the 2-D inclusive prefix sums, in place
-    for (var m = 0; m < i32(layers); m++) {
-        for (var z = 0; z < i32(layers); z++) {
-            let sum = atomicLoad(&mesh_sdf_indirection[histogram + u32(m) * stride + u32(z)])
-                + mesh_cards_histogram_at(histogram, stride, m - 1, z)
-                + mesh_cards_histogram_at(histogram, stride, m, z - 1)
-                - mesh_cards_histogram_at(histogram, stride, m - 1, z - 1);
-
-            atomicStore(&mesh_sdf_indirection[histogram + u32(m) * stride + u32(z)], sum);
-        }
-    }
-
-    let splits = header.cards + parts.splits + direction * MESH_CARD_SPLITS_MAX * 2u;
-
-    // layer 0 starts the whole-grid card
-    var bounds = vec2<u32>(1u, 0u);
-
-    for (var step = 0u; step < MESH_CARD_SPLITS_MAX; step++) {
-        var best_gain = 0u;
-        var best_layer = 0u;
-
-        // card by card, each [near, far), every layer inside it a candidate
-        var near = 0u;
-
-        while (near < layers) {
-            var far = near + 1u;
-
-            while (far < layers && !mesh_cards_starts(bounds, far)) {
-                far++;
-            }
-
-            for (var s = near + 1u; s < far; s++) {
-                let gain = mesh_cards_rectangle(histogram, stride, i32(near) + 1, i32(s), i32(s), i32(far) - 1);
-
-                if (gain > best_gain) {
-                    best_gain = gain;
-                    best_layer = s;
-                }
-            }
-
-            near = far;
-        }
-
-        if (best_gain == 0u) {
-            break;
-        }
-
-        atomicStore(&mesh_sdf_indirection[splits + 2u * step], best_gain);
-        atomicStore(&mesh_sdf_indirection[splits + 2u * step + 1u], best_layer);
-
-        bounds[best_layer >> 5u] |= 1u << (best_layer & 31u);
-    }
-}
-`, [
-            chunk_mesh_sdf_bake,
-            chunk_mesh_cards,
-        ]),
-});

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_mesh_cards.d.ts

@@ -1,34 +0,0 @@
-/**
- * @param {Object} options
- * @param {FrameGraph} options.graph
- * @param {GPUViewContext} options.view
- * @param {number[]} options.resolution
- * @param {GPUMeshCardSets} options.cards
- * @param {GPUBuffer} options.rows the row → card set table
- * @returns {number} graph handle of the `rgba8unorm` image
- */
-export function graph_probe_clipmap_debug_mesh_cards({ graph, view, resolution, cards, rows }: {
-    graph: FrameGraph;
-    view: GPUViewContext;
-    resolution: number[];
-    cards: GPUMeshCardSets;
-    rows: GPUBuffer;
-}): number;
-/**
- * The view's scene through its geometry caches and cards: each pixel's camera ray is marched through
- * the meshes' sparse fields as in {@link ProbeClipmapDebugView.MeshSDF}, and at the nearest hit the
- * row's card set is asked what the surface is (`mesh_card_surface`), with the field's normal there
- * and at the tolerance of a hit as exact as the mesh's own voxel. It shows the diffuse albedo plus
- * emissive the cards hold.
- *
- * Purple is a row with no card set readers may use yet; dark red a point no card sees, which a GI
- * hit would give the material's mean.
- *
- * @type {ImageShader}
- */
-export const shader_probe_clipmap_debug_mesh_cards: ImageShader;
-export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-export type GPUViewContext = import("../../../view/GPUViewContext.js").GPUViewContext;
-export type GPUMeshCardSets = import("../../../geometry/sdf/cards/GPUMeshCardSets.js").GPUMeshCardSets;
-import { ImageShader } from "../../../shader/ImageShader.js";
-//# sourceMappingURL=graph_probe_clipmap_debug_mesh_cards.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_mesh_cards.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"graph_probe_clipmap_debug_mesh_cards.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_mesh_cards.js"],"names":[],"mappings":"AA0IA;;;;;;;;GAQG;AACH;IAP+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACI,UAAU,EAA5B,MAAM,EAAE;IACiB,KAAK,EAA9B,eAAe;IACI,IAAI;IACrB,MAAM,CA2ClB;AAzED;;;;;;;;;;;GAWG;AACH,oDAFU,WAAW,CAWlB;yBAvGU,OAAO,iEAAiE,EAAE,UAAU;6BACpF,OAAO,iCAAiC,EAAE,cAAc;8BACxD,OAAO,gDAAgD,EAAE,eAAe;4BATzD,gCAAgC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.d.ts

@@ -1,31 +0,0 @@
-/**
- * The tolerance a card's depth is held to at a GI hit, in voxels of the hit's brick cascade: a hit is
- * only as exact as its cascade, and UE's bias for a global-SDF hit is three half-voxels of its clipmap
- * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6).
- * @type {number}
- */
-export const PROBE_HIT_SURFACE_TOLERANCE_VOXELS: number;
-/**
- * What a GI hit's surface is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6), its diffuse albedo and its
- * emissive, from the `meshes` row the hit is on:
- *
- * ```wgsl
- * fn probe_clipmap_hit_surface(row: u32, position: vec3<f32>, normal: vec3<f32>, voxel: f32) -> ProbeClipmapHitSurface
- * ```
- *
- * - **The cards**: the row's card set, when it has one readers may use, asked at the hit moved into
- *   the geometry's local space through its node, the normal by the transpose of the node's linear
- *   part, and the tolerance {@link PROBE_HIT_SURFACE_TOLERANCE_VOXELS} voxels of the hit's cascade,
- *   `voxel`, in local units by the transform's mean scale, the cube root of its determinant.
- * - **Black**, where no card set is resident or no card sees the hit, as UE's Lumen leaves a hit no
- *   card covers: a surface whose albedo is not known brings back no light rather than light it may not
- *   have. The cost is energy, never invented energy: a material's colour factor is all of a flat one's
- *   albedo but only the bound of a textured one's, and in Sponza it made the bounce-lit gallery 60%
- *   brighter on screen (§6.6).
- * - **Row 0** names no object, the scene root never being a mesh: the hit is black.
- *
- * @type {CodeChunk}
- */
-export const chunk_probe_clipmap_hit_surface: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_probe_clipmap_hit_surface.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_probe_clipmap_hit_surface.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,iDAFU,MAAM,CAEsC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,8CAFU,SAAS,CA0CZ;0BAvEmB,uCAAuC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_hit_surface.js

@@ -1,82 +0,0 @@
-import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
-import { chunk_mesh_card_surface } from "../../../geometry/sdf/cards/chunk_mesh_card_surface.js";
-import { MESH_CARD_ROWS_RESOURCE } from "../../../geometry/sdf/cards/MESH_CARD_RESOURCES.js";
-import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
-import { SCENE_DATABASE_RESOURCE } from "../../../scene/SCENE_DATABASE_RESOURCE.js";
-import { chunk_mat4_inverse } from "../../../shader/chunk/geometry/mat4/chunk_mat4_inverse.js";
-import { chunk_mat4_linear_determinant } from "../../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-
-/**
- * The tolerance a card's depth is held to at a GI hit, in voxels of the hit's brick cascade: a hit is
- * only as exact as its cascade, and UE's bias for a global-SDF hit is three half-voxels of its clipmap
- * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6).
- * @type {number}
- */
-export const PROBE_HIT_SURFACE_TOLERANCE_VOXELS = 1.5;
-
-/**
- * What a GI hit's surface is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.6), its diffuse albedo and its
- * emissive, from the `meshes` row the hit is on:
- *
- * ```wgsl
- * fn probe_clipmap_hit_surface(row: u32, position: vec3<f32>, normal: vec3<f32>, voxel: f32) -> ProbeClipmapHitSurface
- * ```
- *
- * - **The cards**: the row's card set, when it has one readers may use, asked at the hit moved into
- *   the geometry's local space through its node, the normal by the transpose of the node's linear
- *   part, and the tolerance {@link PROBE_HIT_SURFACE_TOLERANCE_VOXELS} voxels of the hit's cascade,
- *   `voxel`, in local units by the transform's mean scale, the cube root of its determinant.
- * - **Black**, where no card set is resident or no card sees the hit, as UE's Lumen leaves a hit no
- *   card covers: a surface whose albedo is not known brings back no light rather than light it may not
- *   have. The cost is energy, never invented energy: a material's colour factor is all of a flat one's
- *   albedo but only the bound of a textured one's, and in Sponza it made the bounce-lit gallery 60%
- *   brighter on screen (§6.6).
- * - **Row 0** names no object, the scene root never being a mesh: the hit is black.
- *
- * @type {CodeChunk}
- */
-export const chunk_probe_clipmap_hit_surface = CodeChunk.from(
-    //language=WGSL
-    `
-struct ProbeClipmapHitSurface {
-    albedo: vec3<f32>,
-    emissive: vec3<f32>,
-}
-
-fn probe_clipmap_hit_surface(row: u32, position: vec3<f32>, normal: vec3<f32>, voxel: f32) -> ProbeClipmapHitSurface {
-    var out: ProbeClipmapHitSurface;
-
-    if (row == 0u) {
-        return out;
-    }
-
-    let card_set = mesh_card_rows[row];
-
-    if (card_set != ${GPU_DATABASE_NULL}u) {
-        let global = scene_read_node(&scene_database, scene_read_mesh(&scene_database, row).node).global;
-        let linear = mat3x3<f32>(global[0].xyz, global[1].xyz, global[2].xyz);
-
-        let p = (mat4_inverse(global) * vec4<f32>(position, 1.0)).xyz;
-        let n = normalize(transpose(linear) * normal);
-        let scale = pow(abs(mat4_linear_determinant(global)), 1.0 / 3.0);
-
-        let seen = mesh_card_surface(card_set, p, n, ${PROBE_HIT_SURFACE_TOLERANCE_VOXELS.toFixed(1)} * voxel / scale);
-
-        if (seen.found) {
-            out.albedo = seen.albedo;
-            out.emissive = seen.emissive;
-        }
-    }
-
-    return out;
-}
-`, [
-        chunk_scene_database_access,
-        chunk_mat4_inverse,
-        chunk_mat4_linear_determinant,
-        chunk_mesh_card_surface,
-    ]);
-
-chunk_probe_clipmap_hit_surface.requireResource(SCENE_DATABASE_RESOURCE);
-chunk_probe_clipmap_hit_surface.requireResource(MESH_CARD_ROWS_RESOURCE);