@woosh/meep-engine 3.57.0 → 3.59.0

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js

@@ -0,0 +1,475 @@
+import { assert } from "../../../../core/assert.js";
+import { isPowerOfTwo } from "../../../../core/math/isPowerOfTwo.js";
+import { MESH_CARD_CAPTURE_BUDGET_MAX } from "../../geometry/sdf/cards/GPUMeshCardSets.js";
+import { MESH_SDF_BAKE_BUDGET_MAX } from "../../geometry/sdf/GPUGeometrySDFManager.js";
+import { ProbeClipmapDebugView } from "./debug/ProbeClipmapDebugView.js";
+
+/**
+ * Cascades either clipmap may have at most.
+ * @type {number}
+ */
+export const PROBE_CLIPMAP_CASCADE_COUNT_MAX = 8;
+
+/**
+ * Cells per axis a cascade of either clipmap may have.
+ * @type {ReadonlyArray<number>}
+ */
+export const PROBE_CLIPMAP_CASCADE_RESOLUTIONS = Object.freeze([16, 32, 64]);
+
+/**
+ * Bounds of the octahedral radiance and depth resolutions, texels per side.
+ * @type {number}
+ */
+export const PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN = 4;
+
+/**
+ * @type {number}
+ */
+export const PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX = 32;
+
+/**
+ * The smallest {@link ProbeClipmapSettings#brick_build_budget}: one workgroup's worth of cells.
+ * @type {number}
+ */
+export const PROBE_CLIPMAP_BRICK_BUILD_BUDGET_MIN = 64;
+
+/**
+ * The most {@link ProbeClipmapSettings#mesh_sdf_max_bricks}: 64 bricks are 448 voxels a side, three and a
+ * half times Unreal's cap, in seven levels. It bounds the levels a thread walks, and the bake's ring,
+ * which holds twice the largest geometry's bricks, to 2^20 entries.
+ * @type {number}
+ */
+export const PROBE_CLIPMAP_MESH_SDF_MAX_BRICKS_LIMIT = 64;
+
+/**
+ * Settings of {@link ShadeIndirectLightingMode.ProbeClipmap}, held on `Renderer.probe_clipmap` and
+ * read every frame the mode runs (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §10).
+ *
+ * Three kinds of field, by what a change costs:
+ * - **structure**: the cascade counts and resolutions, the brick voxel, the probe spacing, and the
+ *   radiance and depth resolutions. A change destroys the GI and builds it again at the next frame,
+ *   so its bricks and probes warm up from nothing.
+ * - **the mesh caches**: {@link mesh_sdf_voxel_size} and {@link mesh_sdf_max_bricks}. A change bakes
+ *   every cached geometry again.
+ * - **budgets and times**: they size a frame's work and set uniforms, and take effect the next frame
+ *   without a rebuild.
+ *
+ * Each setter checks its own field. {@link rays_per_probe} and {@link ray_budget} also depend on other
+ * fields, so those relations are checked when the GI takes the settings for a frame, whichever was set
+ * first.
+ */
+export class ProbeClipmapSettings {
+
+    #brick_cascade_count = 6;
+
+    /**
+     * Cascades of the brick clipmap, the world as rays see it. Each doubles the voxel of the one
+     * inside it, so 6 cascades of 32 cells at 0.125 m reach 896 m across. Structure.
+     * @returns {number}
+     */
+    get brick_cascade_count() {
+        return this.#brick_cascade_count;
+    }
+
+    /**
+     * @param {number} v integer, 1 to {@link PROBE_CLIPMAP_CASCADE_COUNT_MAX}
+     */
+    set brick_cascade_count(v) {
+        assert.isPositiveInteger(v, 'brick_cascade_count');
+        assert.lessThanOrEqual(v, PROBE_CLIPMAP_CASCADE_COUNT_MAX, 'brick_cascade_count');
+
+        this.#brick_cascade_count = v;
+    }
+
+    #brick_cascade_resolution = 32;
+
+    /**
+     * Cells per axis of a brick cascade; a cell is one brick of 7 voxels a side. Structure.
+     * @returns {number}
+     */
+    get brick_cascade_resolution() {
+        return this.#brick_cascade_resolution;
+    }
+
+    /**
+     * @param {number} v one of {@link PROBE_CLIPMAP_CASCADE_RESOLUTIONS}
+     */
+    set brick_cascade_resolution(v) {
+        assert.isOneOf(v, PROBE_CLIPMAP_CASCADE_RESOLUTIONS, 'brick_cascade_resolution');
+
+        this.#brick_cascade_resolution = v;
+    }
+
+    #brick_voxel_size = 0.125;
+
+    /**
+     * The finest cascade's voxel, metres; every cascade doubles it. The default puts eight voxels across
+     * one cell of the finest probe cascade at the default {@link probe_spacing}, and is of the order of
+     * Unreal's global distance field (19.8 cm at its finest clipmap). Structure.
+     * @returns {number}
+     */
+    get brick_voxel_size() {
+        return this.#brick_voxel_size;
+    }
+
+    /**
+     * @param {number} v metres, positive and finite
+     */
+    set brick_voxel_size(v) {
+        assert.isFinite(v, 'brick_voxel_size');
+        assert.greaterThan(v, 0, 'brick_voxel_size');
+
+        this.#brick_voxel_size = v;
+    }
+
+    #brick_build_budget = 4096;
+
+    /**
+     * Brick cells written a frame at most: those that scrolled in and those a change touched wait their
+     * turn past it. A time knob, as `Renderer.shadow_update_budget` is.
+     * @returns {number}
+     */
+    get brick_build_budget() {
+        return this.#brick_build_budget;
+    }
+
+    /**
+     * @param {number} v integer, at least {@link PROBE_CLIPMAP_BRICK_BUILD_BUDGET_MIN}
+     */
+    set brick_build_budget(v) {
+        assert.isPositiveInteger(v, 'brick_build_budget');
+        assert.greaterThanOrEqual(v, PROBE_CLIPMAP_BRICK_BUILD_BUDGET_MIN, 'brick_build_budget');
+
+        this.#brick_build_budget = v;
+    }
+
+    #mesh_sdf_voxel_size = 0.125;
+
+    /**
+     * A geometry's cached distance field voxel, in the geometry's own units. The default matches
+     * {@link brick_voxel_size}, so a mesh drawn at unit scale is as fine as the finest brick cascade.
+     * A change bakes every cached geometry again.
+     * @returns {number}
+     */
+    get mesh_sdf_voxel_size() {
+        return this.#mesh_sdf_voxel_size;
+    }
+
+    /**
+     * @param {number} v positive and finite
+     */
+    set mesh_sdf_voxel_size(v) {
+        assert.isFinite(v, 'mesh_sdf_voxel_size');
+        assert.greaterThan(v, 0, 'mesh_sdf_voxel_size');
+
+        this.#mesh_sdf_voxel_size = v;
+    }
+
+    #mesh_sdf_max_bricks = 18;
+
+    /**
+     * Bricks per axis a geometry's distance field may have before its voxel grows to fit: a safety net,
+     * not a budget. 18 bricks are 126 voxels, Unreal's per-mesh cap at unit scale; at the default voxel
+     * the grid reaches 15.75 m, so a mesh spans 14.75 m, a band short of it at each end, before it is
+     * baked coarser than asked. A change bakes every cached geometry again.
+     * @returns {number}
+     */
+    get mesh_sdf_max_bricks() {
+        return this.#mesh_sdf_max_bricks;
+    }
+
+    /**
+     * @param {number} v an even integer from 2, since a geometry's grid grows in steps of two bricks, to
+     *        {@link PROBE_CLIPMAP_MESH_SDF_MAX_BRICKS_LIMIT}
+     */
+    set mesh_sdf_max_bricks(v) {
+        assert.isPositiveInteger(v, 'mesh_sdf_max_bricks');
+        assert.greaterThanOrEqual(v, 2, 'mesh_sdf_max_bricks');
+        assert.lessThanOrEqual(v, PROBE_CLIPMAP_MESH_SDF_MAX_BRICKS_LIMIT, 'mesh_sdf_max_bricks');
+        assert.equal(v % 2, 0, 'mesh_sdf_max_bricks must be even');
+
+        this.#mesh_sdf_max_bricks = v;
+    }
+
+    #mesh_sdf_bake_budget = 23;
+
+    /**
+     * Bricks evaluated a frame at most while geometry caches fill: a time knob, as
+     * `shadow_update_budget` is. A brick is 512 texels, a thread each, and a texel is an exact
+     * nearest-point query and a 64-ray vote against its geometry's BLAS, so what a brick costs
+     * follows its geometry's tree. A frame with nothing to bake spends nothing.
+     *
+     * The default is derived against 1 ms a frame on the RTX 4090 (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md
+     * §6.4). Over Sponza's fill, its 103 geometries all coarsened by the cap, with the budgets
+     * interleaved in one process, evaluate costs 798 µs plus 8.6 µs a brick at the median, which
+     * reaches 1 ms at 23. At 23 the fill's evaluate costs 840 µs a frame at the median and 5.3 ms at
+     * worst, and every geometry is resident after 5,712 frames of baking.
+     *
+     * On the AMD iGPU (RDNA2) the same 23 bricks cost 26 ms a frame at the median and 79 ms at worst,
+     * and no budget fits 1 ms: one brick costs 2.3 ms there.
+     * @returns {number}
+     */
+    get mesh_sdf_bake_budget() {
+        return this.#mesh_sdf_bake_budget;
+    }
+
+    /**
+     * @param {number} v a positive integer, at most {@link MESH_SDF_BAKE_BUDGET_MAX}: a frame's store
+     *        runs eight workgroups a brick in one dispatch row
+     */
+    set mesh_sdf_bake_budget(v) {
+        assert.isPositiveInteger(v, 'mesh_sdf_bake_budget');
+        assert.lessThanOrEqual(v, MESH_SDF_BAKE_BUDGET_MAX, 'mesh_sdf_bake_budget');
+
+        this.#mesh_sdf_bake_budget = v;
+    }
+
+    #card_capture_budget = 16384;
+
+    /**
+     * Card pages captured a frame at most: new (geometry, material) pairs first, then recaptures of
+     * materials that changed (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5). A time knob. A page is 64
+     * texels, a thread each, and a texel is a ray through its card's slab, up to four alpha draws, and
+     * a material sample. A frame with nothing to capture spends nothing.
+     *
+     * The default is derived against 1 ms a frame on the RTX 4090, as {@link mesh_sdf_bake_budget}
+     * is. Over Sponza's 103 card sets (154,138 pages), recaptured with the budgets interleaved frame by
+     * frame in one process, 16,384 pages cost 0.33, 0.43 and 0.87 ms at the median in three runs and
+     * 32,768 went past 1 ms in all three; the cost turns steeply between the two. The runs shared the
+     * GPU with another load of 40–73%, which is in the medians: the least loaded frames cost 0.11 ms at
+     * 16,384. At the default Sponza's cards are captured in 10 frames.
+     *
+     * On the AMD iGPU (RDNA2) a page costs 0.78 µs: 16,384 pages cost 33.5 ms at the median, and
+     * about 1,290 fit 1 ms (1,024 cost 0.80 ms).
+     * @returns {number}
+     */
+    get card_capture_budget() {
+        return this.#card_capture_budget;
+    }
+
+    /**
+     * @param {number} v a positive integer, at most {@link MESH_CARD_CAPTURE_BUDGET_MAX}: a workgroup a
+     *        page in one dispatch row
+     */
+    set card_capture_budget(v) {
+        assert.isPositiveInteger(v, 'card_capture_budget');
+        assert.lessThanOrEqual(v, MESH_CARD_CAPTURE_BUDGET_MAX, 'card_capture_budget');
+
+        this.#card_capture_budget = v;
+    }
+
+    #probe_cascade_count = 5;
+
+    /**
+     * Cascades of the probe clipmap, what shading samples. Each doubles the spacing of the one inside
+     * it, so 5 cascades of 32 points at 1 m reach 512 m across. Structure.
+     * @returns {number}
+     */
+    get probe_cascade_count() {
+        return this.#probe_cascade_count;
+    }
+
+    /**
+     * @param {number} v integer, 1 to {@link PROBE_CLIPMAP_CASCADE_COUNT_MAX}
+     */
+    set probe_cascade_count(v) {
+        assert.isPositiveInteger(v, 'probe_cascade_count');
+        assert.lessThanOrEqual(v, PROBE_CLIPMAP_CASCADE_COUNT_MAX, 'probe_cascade_count');
+
+        this.#probe_cascade_count = v;
+    }
+
+    #probe_cascade_resolution = 32;
+
+    /**
+     * Lattice points per axis of a probe cascade. Structure.
+     * @returns {number}
+     */
+    get probe_cascade_resolution() {
+        return this.#probe_cascade_resolution;
+    }
+
+    /**
+     * @param {number} v one of {@link PROBE_CLIPMAP_CASCADE_RESOLUTIONS}
+     */
+    set probe_cascade_resolution(v) {
+        assert.isOneOf(v, PROBE_CLIPMAP_CASCADE_RESOLUTIONS, 'probe_cascade_resolution');
+
+        this.#probe_cascade_resolution = v;
+    }
+
+    #probe_spacing = 1;
+
+    /**
+     * Metres between probes in the finest cascade; every cascade doubles it. Lumen's world-space
+     * radiance cache spaces its finest probes 1.04 m apart, and DDGI recommends 1 to 2 m for human-scale
+     * scenes. Structure.
+     * @returns {number}
+     */
+    get probe_spacing() {
+        return this.#probe_spacing;
+    }
+
+    /**
+     * @param {number} v metres, positive and finite
+     */
+    set probe_spacing(v) {
+        assert.isFinite(v, 'probe_spacing');
+        assert.greaterThan(v, 0, 'probe_spacing');
+
+        this.#probe_spacing = v;
+    }
+
+    #radiance_resolution = 16;
+
+    /**
+     * Octahedral radiance texels per side of a probe, between Enshrouded's low (8) and mid (16) tiers.
+     * Structure.
+     * @returns {number}
+     */
+    get radiance_resolution() {
+        return this.#radiance_resolution;
+    }
+
+    /**
+     * @param {number} v a power of two, {@link PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN} to
+     * {@link PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX}
+     */
+    set radiance_resolution(v) {
+        assert.isPositiveInteger(v, 'radiance_resolution');
+        assert.ok(isPowerOfTwo(v), 'radiance_resolution must be a power of two');
+        assert.greaterThanOrEqual(v, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN, 'radiance_resolution');
+        assert.lessThanOrEqual(v, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX, 'radiance_resolution');
+
+        this.#radiance_resolution = v;
+    }
+
+    #depth_resolution = 8;
+
+    /**
+     * Octahedral depth-moment texels per side of a probe, independent of {@link radiance_resolution}.
+     * Structure.
+     * @returns {number}
+     */
+    get depth_resolution() {
+        return this.#depth_resolution;
+    }
+
+    /**
+     * @param {number} v a power of two, {@link PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN} to
+     * {@link PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX}
+     */
+    set depth_resolution(v) {
+        assert.isPositiveInteger(v, 'depth_resolution');
+        assert.ok(isPowerOfTwo(v), 'depth_resolution must be a power of two');
+        assert.greaterThanOrEqual(v, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN, 'depth_resolution');
+        assert.lessThanOrEqual(v, PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX, 'depth_resolution');
+
+        this.#depth_resolution = v;
+    }
+
+    #rays_per_probe = 256;
+
+    /**
+     * Rays a probe traces each time it updates. Below `radiance_resolution²` an update covers a spread
+     * subset of the probe's texels; above it, each texel averages several rays.
+     * @returns {number}
+     */
+    get rays_per_probe() {
+        return this.#rays_per_probe;
+    }
+
+    /**
+     * @param {number} v a power of two in `[radiance_resolution² / 4, 4·radiance_resolution²]`, checked
+     * against {@link radiance_resolution} when the GI takes the settings
+     */
+    set rays_per_probe(v) {
+        assert.isPositiveInteger(v, 'rays_per_probe');
+        assert.ok(isPowerOfTwo(v), 'rays_per_probe must be a power of two');
+
+        this.#rays_per_probe = v;
+    }
+
+    #ray_budget = 131072;
+
+    /**
+     * Rays traced a frame at most, so `floor(ray_budget / rays_per_probe)` probes update a frame and
+     * every wanted probe is traced again after as many frames as that takes. Between Enshrouded's low and
+     * mid tiers (100k and 250k rays a frame). A time knob.
+     * @returns {number}
+     */
+    get ray_budget() {
+        return this.#ray_budget;
+    }
+
+    /**
+     * @param {number} v integer, at least {@link rays_per_probe}, checked when the GI takes the settings
+     */
+    set ray_budget(v) {
+        assert.isPositiveInteger(v, 'ray_budget');
+
+        this.#ray_budget = v;
+    }
+
+    #response_time = 0.5;
+
+    /**
+     * Seconds of the exponential blend a probe's radiance follows a change by: an update blends by
+     * `1 − e^(−Δt / response_time)`. DDGI's hysteresis of 0.97 a frame at 60 fps is 0.55 s.
+     * @returns {number}
+     */
+    get response_time() {
+        return this.#response_time;
+    }
+
+    /**
+     * @param {number} v seconds, positive and finite
+     */
+    set response_time(v) {
+        assert.isFinite(v, 'response_time');
+        assert.greaterThan(v, 0, 'response_time');
+
+        this.#response_time = v;
+    }
+
+    #retention_time = 1;
+
+    /**
+     * Seconds a probe no pixel wants keeps its slot before it is freed, so a probe that leaves the screen
+     * and comes back within it keeps its history.
+     * @returns {number}
+     */
+    get retention_time() {
+        return this.#retention_time;
+    }
+
+    /**
+     * @param {number} v seconds, positive and finite
+     */
+    set retention_time(v) {
+        assert.isFinite(v, 'retention_time');
+        assert.greaterThan(v, 0, 'retention_time');
+
+        this.#retention_time = v;
+    }
+
+    #debug_view = ProbeClipmapDebugView.None;
+
+    /**
+     * What the frame shows in place of its colour, before TAA: the frame itself, or one of the mode's
+     * debug views. Takes effect the next frame.
+     * @returns {ProbeClipmapDebugView}
+     */
+    get debug_view() {
+        return this.#debug_view;
+    }
+
+    /**
+     * @param {ProbeClipmapDebugView} v
+     */
+    set debug_view(v) {
+        assert.enum(v, ProbeClipmapDebugView, 'debug_view');
+
+        this.#debug_view = v;
+    }
+}

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

@@ -0,0 +1,138 @@
+/**
+ * A brick map entry for a cell not classified since it entered its window: the engine's null. A ray
+ * reads such a cell from the next cascade out.
+ * @type {number}
+ */
+export const BRICK_CLIPMAP_UNKNOWN: number;
+/**
+ * A brick map entry for a cell with no surface within one voxel, outside the surface: the high bit,
+ * so that no slot reaches it. A ray steps across such a cell.
+ * @type {number}
+ */
+export const BRICK_CLIPMAP_EMPTY: number;
+/**
+ * A brick map entry for a cell with no surface within one voxel, inside a solid: a ray that starts in
+ * it hits at once, as a back face (§7.2).
+ * @type {number}
+ */
+export const BRICK_CLIPMAP_EMPTY_INSIDE: number;
+/**
+ * A taken cell's entry between free and store: it needs a brick and holds no slot yet, and store pops
+ * it one in the same frame, so no reader meets it.
+ * @type {number}
+ */
+export const BRICK_CLIPMAP_STORE_PENDING: number;
+/**
+ * Cells a side of one occupancy texel (§7.3).
+ * @type {number}
+ */
+export const BRICK_OCCUPANCY_BLOCK: number;
+/**
+ * Texels of a cell's object grid on a side: one object per 2³ texels of the brick's 8³ (§7.3).
+ * @type {number}
+ */
+export const BRICK_OBJECT_CELLS_PER_AXIS: number;
+/**
+ * Objects a slot holds: the `meshes` row nearest in each of its 2³-texel cells, 0 for none.
+ * @type {number}
+ */
+export const BRICK_OBJECT_CELLS: number;
+/**
+ * The `meshes` rows an object cell can name: one more than the largest row that fits in the 24 bits
+ * the object decision packs a row into beside its distance byte (`chunk_brick_object`). A row past it
+ * writes no object, as a provider that cannot name a row does (§7.6, contract 5).
+ * @type {number}
+ */
+export const BRICK_OBJECT_ROW_LIMIT: number;
+/**
+ * Words of a build slot's staged distances: 512 bytes, four texels a word, texel `t` in byte `t % 4`
+ * of word `t / 4`.
+ * @type {number}
+ */
+export const BRICK_STAGING_DISTANCE_WORDS: number;
+/**
+ * Words of a build slot in the staging: its distances, then its objects.
+ * @type {number}
+ */
+export const BRICK_STAGING_WORDS: number;
+/**
+ * Lanes of the passes that run a workgroup a taken cell: free, store and the mesh provider. Eight
+ * texels a lane.
+ * @type {number}
+ */
+export const BRICK_CELL_WORKGROUP_SIZE: number;
+/**
+ * Lanes of the passes that run a thread a word, a cell or a key: scroll, clear, coarse.
+ * @type {number}
+ */
+export const BRICK_THREAD_WORKGROUP_SIZE: number;
+/**
+ * Keys taken off the ring so far, ever: the ring's head.
+ * @type {number}
+ */
+export const BRICK_STATE_HEAD: number;
+/**
+ * Keys put on the ring so far, ever: the ring's tail.
+ * @type {number}
+ */
+export const BRICK_STATE_TAIL: number;
+/**
+ * Free slots on the free list: the slot stack's count.
+ * @type {number}
+ */
+export const BRICK_STATE_FREE: number;
+/**
+ * Takes the free slots held back, ever: a frame takes no more cells than there are free slots, since
+ * every cell it takes may need one, so no pop of store's fails. A count that moves is what the host
+ * grows the capacity on, as the mesh bake's starved take is (§6.4).
+ * @type {number}
+ */
+export const BRICK_STATE_STARVED: number;
+/**
+ * Words of the state buffer.
+ * @type {number}
+ */
+export const BRICK_STATE_WORDS: number;
+/**
+ * Three words: the indirect dispatch of a workgroup a taken cell, folded into y past the per-dimension
+ * limit.
+ * @type {number}
+ */
+export const BRICK_TAKE_CELL_DISPATCH: number;
+/**
+ * Three words: the indirect dispatch of a thread a staging word of the taken cells.
+ * @type {number}
+ */
+export const BRICK_TAKE_WORD_DISPATCH: number;
+/**
+ * The frame's first taken key, as a count of keys taken before it: its ring index is this mod the
+ * ring's capacity.
+ * @type {number}
+ */
+export const BRICK_TAKE_FIRST: number;
+/**
+ * Keys the frame took: its build slots are 0 to this.
+ * @type {number}
+ */
+export const BRICK_TAKE_COUNT: number;
+/**
+ * Words of the take buffer.
+ * @type {number}
+ */
+export const BRICK_TAKE_WORDS: number;
+/**
+ * Past `t_max`, or out of every window.
+ * @type {number}
+ */
+export const BRICK_TRACE_MISS: number;
+/**
+ * At a surface, or inside a solid.
+ * @type {number}
+ */
+export const BRICK_TRACE_HIT: number;
+/**
+ * Out of steps: its caller discards it.
+ * @type {number}
+ */
+export const BRICK_TRACE_UNRESOLVED: number;
+//# sourceMappingURL=BRICK_CLIPMAP.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BRICK_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/BRICK_CLIPMAP.js"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,oCAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,kCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,yCAFU,MAAM,CAEkD;AAElE;;;;GAIG;AACH,0CAFU,MAAM,CAEmD;AAEnE;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;GAGG;AACH,iCAFU,MAAM,CAEmD;AAEnE;;;;;GAKG;AACH,qCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,2CAFU,MAAM,CAE2D;AAE3E;;;GAGG;AACH,kCAFU,MAAM,CAEqE;AAErF;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,0CAFU,MAAM,CAE8B;AAM9C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAQnC;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;;GAIG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAOlC;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,qCAFU,MAAM,CAEwB"}