@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The brick clipmap's counters and indirect dispatches, every word an atomic (`BRICK_CLIPMAP.js`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_STATE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * What take wrote for the frame, as every pass after it reads it: the dispatches it made, and the
+ * taken keys' first and count (`BRICK_CLIPMAP.js`). Those passes dispatch through it too, so they
+ * bind it read-only.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_TAKE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The pending ring: cell keys in the order they were queued, a power of two of them, every key at
+ * most once.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_RING_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A bit per key, set while the key is on the ring or being built: what keeps a key from being queued
+ * twice.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_PENDING_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The free slots of the atlas and the object cells, as a slot stack whose count is
+ * `brick_state[BRICK_STATE_FREE]`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_FREE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The taken cells' staging, a build slot each of `BRICK_STAGING_WORDS` words: 512 distance bytes, four
+ * a word, then 64 objects. Providers merge into it, and free and store read it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_STAGING_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The brick clipmap's layout as WGSL constants, and what a key and an entry are.
+ *
+ * ```wgsl
+ * fn brick_clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn brick_clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn brick_clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn brick_clipmap_map_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32> // its texel in the brick map
+ * fn brick_clipmap_entry_holds_slot(entry: u32) -> bool
+ * fn brick_clipmap_byte_voxels(byte: u32) -> f32 // a staged byte's distance, in voxels of its cascade
+ * ```
+ *
+ * A distance is encoded as the mesh caches' are (§7.2): `e = saturate(d / 2R + 0.5)` in a byte, with R
+ * {@link MESH_SDF_BAND_VOXELS} voxels of the cell's cascade.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap: CodeChunk;
+/**
+ * Queue a key unless it is already pending: set its bit, and append it to the ring when the bit was
+ * clear. A key is on the ring at most once, so a ring of a power of two at least as long as there are
+ * keys never overflows.
+ *
+ * ```wgsl
+ * fn brick_clipmap_enqueue(key: u32, ring_capacity: u32)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_enqueue: CodeChunk;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick_clipmap.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap.js"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,mCAFU,wBAAwB,CAE4F;AAE9H;;;;;GAKG;AACH,kCAFU,wBAAwB,CAEuE;AAEzG;;;;GAIG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;GAIG;AACH,qCAFU,wBAAwB,CAEgG;AAElI;;;;GAIG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;;GAIG;AACH,qCAFU,wBAAwB,CAEmF;AAErH;;;;;;;;;;;;;;;;GAgBG;AACH,kCAFU,SAAS,CAmDhB;AAEH;;;;;;;;;;GAUG;AACH,0CAFU,SAAS,CAmBhB;yCAnKsC,sDAAsD;0BADrE,uCAAuC"}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap.js

@@ -0,0 +1,169 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { atomic_u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { MESH_SDF_BAND_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import {
+    BRICK_CELL_WORKGROUP_SIZE,
+    BRICK_CLIPMAP_EMPTY,
+    BRICK_CLIPMAP_EMPTY_INSIDE,
+    BRICK_CLIPMAP_STORE_PENDING,
+    BRICK_CLIPMAP_UNKNOWN,
+    BRICK_OBJECT_CELLS,
+    BRICK_OBJECT_CELLS_PER_AXIS,
+    BRICK_STAGING_DISTANCE_WORDS,
+    BRICK_STAGING_WORDS,
+    BRICK_STATE_FREE,
+    BRICK_STATE_HEAD,
+    BRICK_STATE_STARVED,
+    BRICK_STATE_TAIL,
+    BRICK_TAKE_CELL_DISPATCH,
+    BRICK_TAKE_COUNT,
+    BRICK_TAKE_FIRST,
+    BRICK_TAKE_WORD_DISPATCH,
+    BRICK_THREAD_WORKGROUP_SIZE
+} from "./BRICK_CLIPMAP.js";
+
+/**
+ * The brick clipmap's counters and indirect dispatches, every word an atomic (`BRICK_CLIPMAP.js`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_STATE_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_state", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * What take wrote for the frame, as every pass after it reads it: the dispatches it made, and the
+ * taken keys' first and count (`BRICK_CLIPMAP.js`). Those passes dispatch through it too, so they
+ * bind it read-only.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_TAKE_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_take", WebGPUArray.u32);
+
+/**
+ * The pending ring: cell keys in the order they were queued, a power of two of them, every key at
+ * most once.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_RING_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_ring", WebGPUArray.u32, true);
+
+/**
+ * A bit per key, set while the key is on the ring or being built: what keeps a key from being queued
+ * twice.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_PENDING_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_pending", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * The free slots of the atlas and the object cells, as a slot stack whose count is
+ * `brick_state[BRICK_STATE_FREE]`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_FREE_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_free", WebGPUArray.u32, true);
+
+/**
+ * The taken cells' staging, a build slot each of `BRICK_STAGING_WORDS` words: 512 distance bytes, four
+ * a word, then 64 objects. Providers merge into it, and free and store read it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_STAGING_RESOURCE = ShaderResourceDescriptor.storageBuffer("brick_staging", WebGPUArray.u32, true);
+
+/**
+ * The brick clipmap's layout as WGSL constants, and what a key and an entry are.
+ *
+ * ```wgsl
+ * fn brick_clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn brick_clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn brick_clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn brick_clipmap_map_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32> // its texel in the brick map
+ * fn brick_clipmap_entry_holds_slot(entry: u32) -> bool
+ * fn brick_clipmap_byte_voxels(byte: u32) -> f32 // a staged byte's distance, in voxels of its cascade
+ * ```
+ *
+ * A distance is encoded as the mesh caches' are (§7.2): `e = saturate(d / 2R + 0.5)` in a byte, with R
+ * {@link MESH_SDF_BAND_VOXELS} voxels of the cell's cascade.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap = CodeChunk.from(
+    //language=WGSL
+    `
+const BRICK_CLIPMAP_UNKNOWN = ${BRICK_CLIPMAP_UNKNOWN}u;
+const BRICK_CLIPMAP_EMPTY = ${BRICK_CLIPMAP_EMPTY}u;
+const BRICK_CLIPMAP_EMPTY_INSIDE = ${BRICK_CLIPMAP_EMPTY_INSIDE}u;
+const BRICK_CLIPMAP_STORE_PENDING = ${BRICK_CLIPMAP_STORE_PENDING}u;
+const BRICK_CLIPMAP_BAND_VOXELS = ${MESH_SDF_BAND_VOXELS}.0;
+
+const BRICK_OBJECT_CELLS = ${BRICK_OBJECT_CELLS}u;
+const BRICK_OBJECT_CELLS_PER_AXIS = ${BRICK_OBJECT_CELLS_PER_AXIS}u;
+const BRICK_STAGING_DISTANCE_WORDS = ${BRICK_STAGING_DISTANCE_WORDS}u;
+const BRICK_STAGING_WORDS = ${BRICK_STAGING_WORDS}u;
+const BRICK_CELL_WORKGROUP_SIZE = ${BRICK_CELL_WORKGROUP_SIZE}u;
+const BRICK_THREAD_WORKGROUP_SIZE = ${BRICK_THREAD_WORKGROUP_SIZE}u;
+
+const BRICK_STATE_HEAD = ${BRICK_STATE_HEAD}u;
+const BRICK_STATE_TAIL = ${BRICK_STATE_TAIL}u;
+const BRICK_STATE_FREE = ${BRICK_STATE_FREE}u;
+const BRICK_STATE_STARVED = ${BRICK_STATE_STARVED}u;
+
+const BRICK_TAKE_CELL_DISPATCH = ${BRICK_TAKE_CELL_DISPATCH}u;
+const BRICK_TAKE_WORD_DISPATCH = ${BRICK_TAKE_WORD_DISPATCH}u;
+const BRICK_TAKE_FIRST = ${BRICK_TAKE_FIRST}u;
+const BRICK_TAKE_COUNT = ${BRICK_TAKE_COUNT}u;
+
+fn brick_clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32 {
+    return (cascade * resolution + storage.z) * resolution * resolution + storage.y * resolution + storage.x;
+}
+
+fn brick_clipmap_key_cascade(key: u32, resolution: u32) -> u32 {
+    return key / (resolution * resolution * resolution);
+}
+
+fn brick_clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32> {
+    return vec3<u32>(key % resolution, (key / resolution) % resolution, (key / (resolution * resolution)) % resolution);
+}
+
+fn brick_clipmap_map_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32> {
+    return vec3<u32>(storage.x, storage.y, storage.z + cascade * resolution);
+}
+
+fn brick_clipmap_entry_holds_slot(entry: u32) -> bool {
+    return entry < BRICK_CLIPMAP_EMPTY;
+}
+
+fn brick_clipmap_byte_voxels(byte: u32) -> f32 {
+    return 2.0 * BRICK_CLIPMAP_BAND_VOXELS * (f32(byte) / 255.0 - 0.5);
+}
+`);
+
+/**
+ * Queue a key unless it is already pending: set its bit, and append it to the ring when the bit was
+ * clear. A key is on the ring at most once, so a ring of a power of two at least as long as there are
+ * keys never overflows.
+ *
+ * ```wgsl
+ * fn brick_clipmap_enqueue(key: u32, ring_capacity: u32)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_enqueue = CodeChunk.from(
+    //language=WGSL
+    `
+fn brick_clipmap_enqueue(key: u32, ring_capacity: u32) {
+    let bit = 1u << (key & 31u);
+
+    if ((atomicOr(&brick_pending[key >> 5u], bit) & bit) != 0u) {
+        // already queued, or being built: it builds whatever its storage cell holds then
+        return;
+    }
+
+    let at = atomicAdd(&brick_state[BRICK_STATE_TAIL], 1u);
+
+    brick_ring[at & (ring_capacity - 1u)] = key;
+}
+`, [
+    chunk_brick_clipmap,
+]);
+
+chunk_brick_clipmap_enqueue.requireResource(BRICK_STATE_RESOURCE);
+chunk_brick_clipmap_enqueue.requireResource(BRICK_RING_RESOURCE);
+chunk_brick_clipmap_enqueue.requireResource(BRICK_PENDING_RESOURCE);

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Steps a ray takes at most (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.9, chosen). A step past empty
+ * space is a block or a cell, and one near a surface is at least half a voxel.
+ * @type {number}
+ */
+export const BRICK_TRACE_STEPS: number;
+/**
+ * How far past a block's or a cell's exit a step lands, in voxels of its cascade: enough that the
+ * next cell is the one past the face, and far less than the half voxel a hit allows.
+ * @type {number}
+ */
+export const BRICK_TRACE_NUDGE: number;
+/**
+ * The brick map as the tracer reads it: an entry a cell, the cascades stacked along z.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_MAP_TEXTURE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The occupancy as the tracer reads it: a count a block of 4³ storage cells, the cascades stacked.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_OCCUPANCY_TEXTURE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The world's bricks: an `r8unorm` 3-D atlas of 8³ tiles, on the lattice the mesh bricks use (§7.2).
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_ATLAS_TEXTURE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The mesh bricks' sampler: linear, clamped. A tap inside a brick never reaches past it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_SAMPLER_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Every cascade's window, finest first.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_LEVELS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The object cells: {@link BRICK_OBJECT_CELLS} `meshes` rows a slot, 0 for none.
+ * @type {ShaderResourceDescriptor}
+ */
+export const BRICK_OBJECTS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A brick's distance at a point of its cell, and the field's gradient there.
+ *
+ * ```wgsl
+ * fn brick_clipmap_sample(slot: u32, local: vec3<f32>, voxel: f32) -> f32 // local in voxels from the cell's corner
+ * fn brick_clipmap_normal(slot: u32, local: vec3<f32>) -> vec3<f32>       // out of the solid, unit length
+ * ```
+ *
+ * One hardware trilinear tap of the atlas at texel `slot_origin + 0.5 + local`, `local` clamped to the
+ * brick's [0, 7]: it never reads a neighbouring slot (§7.2). The gradient is a tetrahedral one, four
+ * taps half a voxel off, each clamped the same way.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_sample: CodeChunk;
+/**
+ * Where a point is in the cascades: whether a cascade's window holds it, inset by a margin, and the
+ * finest cascade that does.
+ *
+ * ```wgsl
+ * fn brick_clipmap_window_holds(level: ClipmapLevel, position: vec3<f32>, inset: f32) -> bool
+ * fn brick_clipmap_start(position: vec3<f32>, cascade_count: u32) -> u32 // cascade_count when none does
+ * ```
+ *
+ * The tracer starts in the finest window holding the point by half a voxel of its cascade (§7.9).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_window: CodeChunk;
+/**
+ * A step of a march through the brick clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.9): what the
+ * tracer and the soft shadow both walk.
+ *
+ * ```wgsl
+ * fn brick_clipmap_march(origin: vec3<f32>, direction: vec3<f32>, cascade_count: u32, march: ptr<function, BrickClipmapMarch>) -> u32
+ * ```
+ *
+ * `direction` is unit length, so `t` is a distance. A march starts at its `t` in the finest cascade
+ * whose window holds that point by half a voxel (`brick_clipmap_start`). A step reads one occupancy
+ * and one entry, and where it stands:
+ * - a point past the window, inset by half a voxel, carries the march to the next cascade, and past
+ *   the last it has left;
+ * - a block of no cells to read is passed whole, clamped to the window;
+ * - UNKNOWN goes on in the next cascade from the same `t`: space not built yet is read from the
+ *   parent, not passed through;
+ * - EMPTY is passed to the cell's exit;
+ * - a brick, or EMPTY inside, is a cell to read, which the march leaves to its caller: its entry, its
+ *   corner, its voxel and the point.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_march: CodeChunk;
+/**
+ * The first surface along a ray through the brick clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.9).
+ *
+ * ```wgsl
+ * fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_max: f32, cascade_count: u32) -> BrickClipmapHit
+ * ```
+ *
+ * The march (`brick_clipmap_march`) from `t_min`, at most {@link BRICK_TRACE_STEPS} steps, each
+ * reading in a brick one atlas tap:
+ * - EMPTY inside is a hit where the march stands: the ray is inside a solid, and its hit is a back
+ *   face (§7.2, §8.4), its normal along the ray;
+ * - in a brick, a distance under half a voxel is a hit, and any other is a step of at least half a
+ *   voxel.
+ *
+ * A march that spends its steps is unresolved, and its caller discards it (§8.8). One past `t_max`,
+ * or out of every window, is a miss.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_trace: CodeChunk;
+/**
+ * How much of a light's disk a point sees along a ray through the brick clipmap (§7.9), from 0 to 1.
+ *
+ * ```wgsl
+ * fn brick_clipmap_soft_shadow(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_max: f32, sin_angle: f32, cascade_count: u32) -> f32
+ * ```
+ *
+ * `direction` is toward the light, unit length, and `sin_angle` the sine of the light's angular
+ * radius (its `disk_radius`). The march is the tracer's (`brick_clipmap_march`), from `t_min`, at
+ * most {@link BRICK_TRACE_STEPS} steps.
+ *
+ * The estimate is Quílez's two-sided penumbra. The light's edge is a cone about the ray, of radius
+ * `t·sin θ`; in each brick the march reads the clearance, the field less the tracer's half-voxel
+ * expand, so that a wall thinner than a voxel shadows as it is hit. The least of the clearance over the
+ * cone's radius goes below zero inside the occluder:
+ * - the march goes on into the occluder, half a voxel a step, until the least reaches -1, which is
+ *   the light hidden whole;
+ * - clamped to [-1, 1], it maps through `¼(1 + x)²(2 - x)` to the visible part, which is half at the
+ *   shadow's geometric edge, as the analytic disk is. The classic, one-sided estimate reads 0 there.
+ *
+ * EMPTY inside hides the light whole. An EMPTY cell, or a block passed whole, is clear by at least a
+ * voxel, wider than a sun's cone within its cascade's range, and the march reads nothing in it. A march
+ * out of every window, or past `t_max`, sees what it has not found hidden; so does one that spends
+ * its steps.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_soft_shadow: CodeChunk;
+/**
+ * The finest cascade's signed distance at a point (§7.9), for probe relocation.
+ *
+ * ```wgsl
+ * fn brick_clipmap_distance(position: vec3<f32>, cascade_count: u32) -> f32
+ * ```
+ *
+ * The finest window holding the point answers, unless its cell is UNKNOWN, which defers to the
+ * parent. EMPTY reads R of its cascade, EMPTY inside -R: the surface is at least that far. A point no
+ * window holds, or that only UNKNOWN cells cover, reads R of the coarsest cascade.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_distance: CodeChunk;
+/**
+ * The direction the brick clipmap's field rises fastest at a point, unit length, or zero where it has
+ * no slope: for probe relocation (§8.4).
+ *
+ * ```wgsl
+ * fn brick_clipmap_gradient(position: vec3<f32>, cascade_count: u32) -> vec3<f32>
+ * ```
+ *
+ * Four taps of {@link chunk_brick_clipmap_distance} at the corners of a tetrahedron a voxel of the finest
+ * window holding the point across, as `brick_clipmap_normal` takes them inside a brick; here across
+ * bricks and cascades. On a field of slope one the taps sum to four voxels; under a tenth of that it
+ * reads as flat, inside a solid past the band or in the space beyond it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_gradient: CodeChunk;
+/**
+ * The `meshes` row whose surface a hit is on (§7.9), 0 for none.
+ *
+ * ```wgsl
+ * fn brick_clipmap_object(hit: BrickClipmapHit) -> u32
+ * ```
+ *
+ * The object cell of the texel nearest the hit moved half a voxel along the normal, onto the ray's
+ * side: of a wall thinner than a voxel, whose two faces are in neighbouring object cells, it picks
+ * the face the ray hit, as UE's object lookup does. A front face's normal is against the ray, and a
+ * back face is counted, never shaded (§8.4), so the move is along the normal. A hit inside a solid
+ * has no face: none.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_brick_clipmap_object: CodeChunk;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_brick_clipmap_trace.d.ts.map

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_brick_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,yCAFU,wBAAwB,CAEoE;AAEtG;;;GAGG;AACH,+CAFU,wBAAwB,CAEgF;AAElH;;;GAGG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,qCAFU,wBAAwB,CAEqF;AAEvH;;;GAGG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,qCAFU,wBAAwB,CAE6E;AAE/G;;;;;;;;;;;;;GAaG;AACH,yCAFU,SAAS,CAoCZ;AAKP;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAyBZ;AAIP;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,SAAS,CAgFZ;AAKP;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCAFU,SAAS,CAoGZ;AAEP;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,8CAFU,SAAS,CA8CZ;AAEP;;;;;;;;;;;;GAYG;AACH,2CAFU,SAAS,CAsCZ;AAIP;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA0BZ;AAEP;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CAqBZ;yCArkBkC,sDAAsD;0BADrE,uCAAuC"}