@woosh/meep-engine 3.60.6 → 3.60.8

package/src/format/image/avif/av1/entropy/SymbolWriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SymbolWriter.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/entropy/SymbolWriter.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IACI,gFAAgF;IAChF,UADW,WAAW,CACuB;IAE7C,8DAA8D;IAC9D,iBADW,MAAM,CACG;IAEpB,uFAAuF;IACvF,KADW,MAAM,CACT;IAER,2FAA2F;IAC3F,OADW,MAAM,CACH;IAEd,0EAA0E;IAC1E,OADW,MAAM,CACN;IAEX;;OAEG;IACH,oBAFU,MAAM,CAEO;IAEvB,mEAAmE;IACnE,SADW,MAAM,CACL;IAEZ,mGAAmG;IACnG,MADW,MAAM,CACR;IAET;;;;OAIG;IACH,2BAHW,MAAM,GACJ,YAAY,CAYxB;IAED;;;;;OAKG;IACH,iBAFa,YAAY,CAQxB;IAiED;;;;;;;;OAQG;IACH,qBALW,MAAM,OACN,WAAW,UACX,MAAM,KACN,MAAM,QAuDhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAoBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,KACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,UAFa,UAAU,CA8CtB;;CACJ"}
+{"version":3,"file":"SymbolWriter.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/entropy/SymbolWriter.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IACI,gFAAgF;IAChF,UADW,WAAW,CACuB;IAE7C,8DAA8D;IAC9D,iBADW,MAAM,CACG;IAEpB,uFAAuF;IACvF,KADW,MAAM,CACT;IAER,2FAA2F;IAC3F,OADW,MAAM,CACH;IAEd,0EAA0E;IAC1E,OADW,MAAM,CACN;IAEX;;OAEG;IACH,oBAFU,MAAM,CAEO;IAEvB,mEAAmE;IACnE,SADW,MAAM,CACL;IAEZ,mGAAmG;IACnG,MADW,MAAM,CACR;IAET;;;;OAIG;IACH,2BAHW,MAAM,GACJ,YAAY,CAYxB;IAED;;;;;OAKG;IACH,iBAFa,YAAY,CAQxB;IAiED;;;;;;;;OAQG;IACH,qBALW,MAAM,OACN,WAAW,UACX,MAAM,KACN,MAAM,QAuDhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAoBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,KACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,KACN,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,UAFa,UAAU,CA8CtB;;CACJ"}

package/src/format/image/avif/av1/entropy/SymbolWriter.js

@@ -1,6 +1,7 @@
 import { floor_log2 } from "../util/floor_log2.js";
 import { BOOL_COST, COST_ONE_BIT, symbol_cost } from "./symbol_cost.js";
 import { EC_MIN_PROB, EC_PROB_SHIFT } from "../tables/av1_symbols.js";
+import { msb_32 } from "../../../../../core/binary/msb_32.js";
 
 /**
  * Initial capacity of the pre-carry buffer, in 16-bit words. Grows as needed.
@@ -146,7 +147,7 @@ export class SymbolWriter {
     #normalize(low, range) {
         let count = this.count;
 
-        const d = 16 - (32 - Math.clz32(range));
+        const d = 15 - msb_32(range);
 
         let s = count + d;
 

package/src/generation/foliage/material/foliage_tile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foliage_tile.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_tile.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,sDAHW,OAAO,oCAAoC,EAAE,qBAAqB,GAChE,MAAM,CAIlB;AAmBD;;;;;;;;;;;;;GAaG;AACH,6CAHW,OAAO,gCAAgC,EAAE,iBAAiB,GACxD,iBAAiB,CAqC7B;AAuBD;;;;;;;;;GASG;AACH,6CANW,OAAO,gCAAgC,EAAE,iBAAiB,UAC1D,iBAAiB,WACjB,MAAM,kBACN,OAAO,GACL,iBAAiB,CAwH7B;;;;;mBAlPa,MAAM;;;;gBACN,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;cACN,MAAM;cACN,MAAM;;;;qBACN,MAAM;;;;aACN,MAAM;;;;kBACN,MAAM;;;;aACN,MAAM;;;;WACN,MAAM;;;;;;mBACN,MAAM;;;;;;cAoFN,MAAM;;;;WACN,YAAY;;;;UACZ,YAAY;;;;eACZ,YAAY;;;;SACZ,YAAY;;;;YACZ,YAAY;;;;UACZ,YAAY"}
+{"version":3,"file":"foliage_tile.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/material/foliage_tile.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,sDAHW,OAAO,oCAAoC,EAAE,qBAAqB,GAChE,MAAM,CAIlB;AAmBD;;;;;;;;;;;;;GAaG;AACH,6CAHW,OAAO,gCAAgC,EAAE,iBAAiB,GACxD,iBAAiB,CAqC7B;AAuBD;;;;;;;;;GASG;AACH,6CANW,OAAO,gCAAgC,EAAE,iBAAiB,UAC1D,iBAAiB,WACjB,MAAM,kBACN,OAAO,GACL,iBAAiB,CAwH7B;;;;;mBAlPa,MAAM;;;;gBACN,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;cACN,MAAM;cACN,MAAM;;;;qBACN,MAAM;;;;aACN,MAAM;;;;kBACN,MAAM;;;;aACN,MAAM;;;;WACN,MAAM;;;;;;mBACN,MAAM;;;;;;cAoFN,MAAM;;;;WACN,YAAY;;;;UACZ,YAAY;;;;eACZ,YAAY;;;;SACZ,YAAY;;;;YACZ,YAAY;;;;UACZ,YAAY"}

package/src/generation/foliage/material/foliage_tile.js

@@ -8,6 +8,7 @@ import { FoliageTileContent } from "../config/FoliageTileContent.js";
 import { foliage_card_plane_count } from "../skeleton/foliage_card_density.js";
 import { foliage_variant_maturity } from "../skeleton/foliage_senescence.js";
 import { leaf_geometry, needle_shoot_geometry } from "./leaf_geometry.js";
+import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /**
  * Most tiles an atlas packs (`compute_foliage_variant_atlas_layout`).
@@ -124,7 +125,7 @@ export function foliage_tile_layout(species) {
     let stem = Infinity;
     for (let s = 0; s < g.stems.length; s += 5) stem = Math.min(stem, 2 * g.stems[s + 4]);
     const wanted = Math.max(FEATURE_TEXELS * card_size / Math.max(1e-6, g.finest), STEM_TEXELS * card_size / Math.max(1e-6, stem));
-    const resolution = clamp(Math.pow(2, Math.ceil(Math.log2(wanted))), MIN_RESOLUTION, MAX_RESOLUTION);
+    const resolution = ceilPowerOfTwo(Math.ceil(clamp(wanted, MIN_RESOLUTION, MAX_RESOLUTION)));
 
     return {
         variant_count: foliage_atlas_variant_count(material),

package/src/generation/markers/GridActionRuleSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridActionRuleSet.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridActionRuleSet.js"],"names":[],"mappings":"AA2BA;IA0BI;;;;;;;;OAQG;IACH;QAN4C,KAAK,EAAtC,uBAAuB;QACW,MAAM,GAAxC,uBAAuB;QACJ,OAAO,GAA1B,MAAM,EAAE;QACU,kBAAkB,GAApC,OAAO;QACL,iBAAiB,CAkB7B;IAjDD;;;OAGG;IACH,UAFU,uBAAuB,CAEnB;IAEd;;;OAGG;IACH,QAFU,uBAAuB,GAAC,MAAM,CAEI;IAE5C;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;;OAGG;IACH,aAFU,OAAO,CAEE;IA6BnB;;;OAGG;IACH,uCAEC;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,eACN,MAAM,QAiIhB;CACJ;wCArNuC,8BAA8B"}
+{"version":3,"file":"GridActionRuleSet.d.ts","sourceRoot":"","sources":["../../../../src/generation/markers/GridActionRuleSet.js"],"names":[],"mappings":"AA4BA;IA0BI;;;;;;;;OAQG;IACH;QAN4C,KAAK,EAAtC,uBAAuB;QACW,MAAM,GAAxC,uBAAuB;QACJ,OAAO,GAA1B,MAAM,EAAE;QACU,kBAAkB,GAApC,OAAO;QACL,iBAAiB,CAkB7B;IAjDD;;;OAGG;IACH,UAFU,uBAAuB,CAEnB;IAEd;;;OAGG;IACH,QAFU,uBAAuB,GAAC,MAAM,CAEI;IAE5C;;;OAGG;IACH,SAFU,MAAM,EAAE,CAED;IAEjB;;;OAGG;IACH,aAFU,OAAO,CAEE;IA6BnB;;;OAGG;IACH,uCAEC;IAED;;;;;;OAMG;IACH,8BAJW,MAAM,eACN,MAAM,QAyIhB;CACJ;wCA7NuC,8BAA8B"}

package/src/generation/markers/GridActionRuleSet.js

@@ -3,6 +3,7 @@ import { ArrayIteratorRandom } from "../../core/collection/array/iterator/ArrayI
 import { ArrayIteratorSequential } from "../../core/collection/array/iterator/ArrayIteratorSequential.js";
 import { v2_rotate } from "../../core/geom/vec2/v2_rotate.js";
 import { PI_HALF } from "../../core/math/PI_HALF.js";
+import { randomIntegerBetween } from "../../core/math/random/randomIntegerBetween.js";
 import { seededRandom } from "../../core/math/random/seededRandom.js";
 import TaskGroup from "../../core/process/task/TaskGroup.js";
 import { countTask } from "../../core/process/task/util/countTask.js";
@@ -146,7 +147,6 @@ export class GridActionRuleSet {
 
         const tMain = randomCountTask(seed, 0, sampleCount, index => {
 
-
             const sample_y = (index / sampleCountX) | 0;
             const sample_x = index % sampleCountX;
 
@@ -166,11 +166,19 @@ export class GridActionRuleSet {
 
                 const matcher = element.pattern;
 
+                let ROTATION_COUNT = 1;
+                let INITIAL_ROTATION = 0;
+
+                if (element.allowRotation) {
+                    ROTATION_COUNT = 4;
+                    // to avoid biasing rotation 0, we pick a random initial rotation; the sequence is always the same though
+                    INITIAL_ROTATION = randomIntegerBetween(random, 0, 3);
+                }
+
                 sampling_loop: for (let sampleIndex = 0; sampleIndex < patternSize;) {
                     const sampleOffsetX = pattern[sampleIndex++];
                     const sampleOffsetY = pattern[sampleIndex++];
 
-                    const ROTATION_COUNT = element.allowRotation ? 4 : 1;
 
                     // a single roll per placement attempt: whether the rule fires is decided once,
                     // the rotation scan only decides the orientation. Rolling per rotation would
@@ -178,8 +186,9 @@ export class GridActionRuleSet {
                     const roll = random();
 
                     for (let j = 0; j < ROTATION_COUNT; j++) {
+                        const rotation_index = (j + INITIAL_ROTATION) % 4;
 
-                        const rotation = j * PI_HALF;
+                        const rotation = rotation_index * PI_HALF;
 
                         v2_rotate(scratch_offset, 0, sampleOffsetX, sampleOffsetY, rotation);
 

package/src/shade/device/mock/SoftwareGPUDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AA+QA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;OAQG;IACH;QAP+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAuBrC;IAvDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAiCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAmJD;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;;;;;OAOG;IACH,kEAUC;IAkCD;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAED;;;;;;OAMG;IACH,oEAFa,0BAA0B,CAItC;IAED;;;;;OAKG;IACH,sEAFa,2BAA2B,CAIvC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAluBa,mBAAiB,IAAI;;sCA9QG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}
+{"version":3,"file":"SoftwareGPUDevice.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/mock/SoftwareGPUDevice.js"],"names":[],"mappings":"AAoQA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAFgB,SAAS;IAkCrB;;;;;;;;OAQG;IACH;QAP+B,KAAK,GAAzB,MAAM;QACwB,gBAAgB,GAA9C,gBAAgB;QAGyB,cAAc,GAAvD,2BAA2B;OAuBrC;IAvDD;;;;;OAKG;IACH,qCAEC;IAOD;;;;;;OAMG;IACH,iCAEC;IAiCD;;OAEG;IACH,kCAEC;IAID;;OAEG;IACH,sBAEC;IAaD;;;;;;;;OAQG;IACH,iEAUC;IAwBD;;;;;OAKG;IACH,uCAEC;IAID;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,gBAcC;IAID;;;;;;;;;OASG;IACH,uBALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,uBAAuB,GAC7B,IAAI,CAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,YACN,kCAAkC,YAClC,OAAO,GAAC,oBAAoB,GAC1B,IAAI,CAIhB;IAED;;;OAGG;IACH,qBAHW,KAAK,GACH,OAAO,CAInB;IASD;;;;;;;OAOG;IACH,wCAFa,IAAI,CAUhB;IAED;;;;;;;;;OASG;IACH,iBAHa,QAAQ,mBAAiB,IAAI,CAAC,CAc1C;IAED;;;;;;;;;;;;;;OAcG;IACH,yCAFa,IAAI,CA4BhB;IAED;;;;;;;;;OASG;IACH,yDAcC;IAuJD;;;;;;OAMG;IACH,4DAcC;IAED;;;;;;OAMG;IACH,6DAEC;IAED;;;OAGG;IACH,oFAEC;IAED;;;;;;;OAOG;IACH,kEAUC;IAkCD;;;OAGG;IACH,iFAcC;IAED;;;;;;;OAOG;IACH,2EAEC;IAED;;;;;;OAMG;IACH,iFAEC;IAED;;;;;OAKG;IACH,oFAEC;IAED;;;;;;OAMG;IACH,oEAFa,0BAA0B,CAItC;IAED;;;;;OAKG;IACH,sEAFa,2BAA2B,CAIvC;IAUD;;;;;OAKG;IACH,kBAFa,MAAM,CAMlB;IAED;;;OAGG;IACH,+DAQC;IA4BD;;;OAGG;IACH,kFAEC;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;;CAN9C;;;;;;;;;;;;WAtuBa,mBAAiB,IAAI;;sCAnQG,4BAA4B;kCAHhC,wBAAwB;mCASvB,yBAAyB"}

package/src/shade/device/mock/SoftwareGPUDevice.js

@@ -16,6 +16,7 @@ import { texture_view_resource_refusal } from "./texture_view_resource.js";
 import { gpu_texture_format_feature } from "../../descriptor/texture/format/gpu_texture_format_feature.js";
 import { gpu_texture_format_info } from "../../descriptor/texture/format/gpu_texture_format_info.js";
 import { gpu_texture_formats_view_compatible } from "../../descriptor/texture/format/gpu_texture_formats_view_compatible.js";
+import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
 
 /**
  * The limits a device reports when nothing was asked for — the spec's default values, which is what
@@ -257,18 +258,6 @@ function buffer_usage_refusal(usage) {
     return null;
 }
 
-/**
- * Mip levels a texture of these dimensions can have - one per halving until every axis is 1.
- *
- * @param {number} width
- * @param {number} height
- * @param {number} depth counted only for a 3d texture; array layers do not halve
- * @returns {number}
- */
-function max_mip_level_count(width, height, depth) {
-    return Math.floor(Math.log2(Math.max(width, height, depth))) + 1;
-}
-
 /**
  * One entry of the device's error scope stack.
  *
@@ -685,6 +674,10 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase {
 
         const dimension = descriptor.dimension ?? "2d";
 
+        if (width === 0 || height === 0 || depth === 0) {
+            return `${width}x${height}x${depth} has a zero-sized axis; every axis must be at least 1`;
+        }
+
         if (descriptor.usage === 0 || descriptor.usage === undefined) {
             return 'usage is 0, a texture must declare at least one usage';
         }
@@ -764,7 +757,7 @@ export class SoftwareGPUDevice extends SoftwareGPUObjectBase {
         const mip_level_count = descriptor.mipLevelCount ?? 1;
 
         // array layers do not halve with the mip chain; only a 3d texture's depth does
-        const max_mips = max_mip_level_count(width, height, dimension === "3d" ? depth : 1);
+        const max_mips = texture_mip_level_count(width, height, depth, dimension);
 
         if (mip_level_count < 1 || mip_level_count > max_mips) {
             return `mipLevelCount ${mip_level_count} is outside [1, ${max_mips}] for ${width}x${height}x${depth}`;

package/src/shade/playground/caldera/main.js

@@ -39,6 +39,7 @@ import {
     caldera_vgeo_record,
     caldera_read_placements,
 } from "./caldera_format.js";
+import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /**
  * Caldera, drawn by meep: 45 districts, millions of placements, and every triangle of it standing
@@ -1040,12 +1041,12 @@ function virtual_capacities(manifest, page_capacity, requested_queue) {
         ? requested_queue
         : Math.min(
             1 << 22,
-            1 << Math.ceil(Math.log2(Math.max(1 << 18, Math.max(1, instances) * 16)))
+            ceilPowerOfTwo(Math.max(1 << 18, Math.max(1, instances) * 16))
         );
 
     return {
         geometry_capacity: containers + 64,
-        lookup_words: 1 << Math.ceil(Math.log2(Math.max(1 << 16, pages * 1.5))),
+        lookup_words: ceilPowerOfTwo(Math.ceil(Math.max(1 << 16, pages * 1.5))),
         claim_word_capacity: Math.ceil(
             Math.max(1, manifest.max_vgeo_instances ?? 1) * page_capacity / 32
         ) * 2,

package/src/shade/playground/probe_clipmap/README.md

@@ -23,7 +23,8 @@ has the two lines that put it there. Another scene loads with `?scene=/some/othe
 | Indirect light | the probe clipmap, or IBL to compare against |
 | Debug view | the brick clipmap as the probes' rays see it; the geometry caches' mesh SDF; the hits' albedo from the cards |
 | Path tracer (P) | the accumulating path tracer's image in place of the rasterized one, as ground truth; TAA is off while it is on and comes back after |
-| Re-sampling (R) | each probe update pools its rays with what four of its neighbours have already seen, where their depth confirms it (`ProbeClipmapSettings.resampling`); off by default, and measured slower to converge and a few per cent brighter on Sponza (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8) |
+| History re-sampling (R) | each probe update pools its rays with what four of its neighbours have already seen, where their depth confirms it (`ProbeClipmapSettings.history_resampling`); off by default, and measured quieter but no faster to converge on Sponza (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8) |
+| Ray re-sampling (T) | each probe update also takes every ray one neighbour traced the same frame, the neighbour drawn by its radiance and the probe's sight of it, each ray where the probe's depth confirms its hit or sky (`ProbeClipmapSettings.ray_resampling`); off by default (PROBE_RAY_REPROJECTION_SCOPE_2026_11_01.md) |
 | Sun height, Sun turn | where the sun stands |
 | Point lights | eight shadowed point lights along the scene's long axis, which the probes' hits take as local lights |
 | TAA | the resolve the probe pick's noise is meant for |

package/src/shade/playground/probe_clipmap/index.html

@@ -109,8 +109,13 @@
     </label>
 
     <label>
-        <input type="checkbox" id="resampling">
-        <span>Re-sampling <span class="hint">— probes take their neighbours' radiance; R flips it</span></span>
+        <input type="checkbox" id="history_resampling">
+        <span>History re-sampling <span class="hint">— probes take their neighbours' radiance; R flips it</span></span>
+    </label>
+
+    <label>
+        <input type="checkbox" id="ray_resampling">
+        <span>Ray re-sampling <span class="hint">— probes take a neighbour's rays of the frame; T flips it</span></span>
     </label>
 
     <hr>

package/src/shade/playground/probe_clipmap/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA4RzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAsSzB"}

package/src/shade/playground/probe_clipmap/main.js

@@ -282,15 +282,22 @@ export async function start() {
 
     path_tracing_toggle.addEventListener('change', event => set_path_tracing(event.target.checked));
 
-    const resampling_toggle = element('resampling');
+    const history_resampling_toggle = element('history_resampling');
 
-    resampling_toggle.checked = renderer.probe_clipmap.resampling;
-    resampling_toggle.addEventListener('change', event => {
-        renderer.probe_clipmap.resampling = event.target.checked;
+    history_resampling_toggle.checked = renderer.probe_clipmap.history_resampling;
+    history_resampling_toggle.addEventListener('change', event => {
+        renderer.probe_clipmap.history_resampling = event.target.checked;
+    });
+
+    const ray_resampling_toggle = element('ray_resampling');
+
+    ray_resampling_toggle.checked = renderer.probe_clipmap.ray_resampling;
+    ray_resampling_toggle.addEventListener('change', event => {
+        renderer.probe_clipmap.ray_resampling = event.target.checked;
     });
 
     document.addEventListener('keydown', event => {
-        // not while typing a number, nor in a select, where P and R pick an option
+        // not while typing a number, nor in a select, where P, R and T pick an option
         const typing = event.target === bake_budget || event.target instanceof HTMLSelectElement;
 
         if (event.repeat || typing) {
@@ -300,8 +307,11 @@ export async function start() {
         if (event.code === 'KeyP') {
             set_path_tracing(!renderer.feature_path_tracing_enabled);
         } else if (event.code === 'KeyR') {
-            resampling_toggle.checked = !resampling_toggle.checked;
-            renderer.probe_clipmap.resampling = resampling_toggle.checked;
+            history_resampling_toggle.checked = !history_resampling_toggle.checked;
+            renderer.probe_clipmap.history_resampling = history_resampling_toggle.checked;
+        } else if (event.code === 'KeyT') {
+            ray_resampling_toggle.checked = !ray_resampling_toggle.checked;
+            renderer.probe_clipmap.ray_resampling = ray_resampling_toggle.checked;
         }
     });
 

package/src/shade/playground/sh_exponential/sh_exp_playground_shaders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sh_exp_playground_shaders.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/sh_exponential/sh_exp_playground_shaders.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,8BAFU,MAAM,EAAE,CAOhB;AAEF;;;;;;GAMG;AACH,oCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;GAaG;AACH,qCAFU,YAAY,CAgBI;AAsC1B;;;;;;GAMG;AACH,qDAFU,aAAa,CAuDpB;AAeH;;;;;GAKG;AACH,qCAFU,aAAa,CA4FpB;6BArQ0B,4CAA4C;8BAJ3C,wCAAwC"}
+{"version":3,"file":"sh_exp_playground_shaders.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/sh_exponential/sh_exp_playground_shaders.js"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,8BAFU,MAAM,EAAE,CAOhB;AAEF;;;;;;GAMG;AACH,oCAFU,MAAM,CAE0B;AAE1C;;;;;;;;;;;;;GAaG;AACH,qCAFU,YAAY,CAgBI;AAsC1B;;;;;;GAMG;AACH,qDAFU,aAAa,CAuDpB;AAeH;;;;;GAKG;AACH,qCAFU,aAAa,CAoFpB;6BA7P0B,4CAA4C;8BAJ3C,wCAAwC"}

package/src/shade/playground/sh_exponential/sh_exp_playground_shaders.js

@@ -1,4 +1,6 @@
 import { chunk_get_ibl_radiance } from "../../renderer/deferred/indirect/chunk_get_ibl_radiance.js";
+import { chunk_rgb_to_luminance } from "../../renderer/shader/chunk/color/chunk_rgb_to_luminance.js";
+import { chunk_sRGBTransferOETF } from "../../renderer/shader/chunk/color/sRGB/chunk_sRGBTransferOETF.js";
 import { chunk_sh_exp_p4q2_base_reflectance } from "../../renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_p4q2_base_reflectance.js";
 import { SH_EXP_P4Q2_PROBE_STRUCT } from "../../renderer/shader/chunk/spherical_harmonics/exponential/SH_EXP_P4Q2_PROBE_STRUCT.js";
 import { chunk_D_GGX } from "../../renderer/shader/chunk/brdf/chunk_D_GGX.js";
@@ -191,16 +193,6 @@ fn tonemap(x: vec3<f32>) -> vec3<f32> {
     return vec3<f32>(1.0) - exp(-max(x, vec3<f32>(0.0)) * view.exposure);
 }
 
-fn srgb_encode(x: vec3<f32>) -> vec3<f32> {
-    let low = x * 12.92;
-    let high = 1.055 * pow(x, vec3<f32>(1.0 / 2.4)) - 0.055;
-    return select(high, low, x <= vec3<f32>(0.0031308));
-}
-
-fn luminance(x: vec3<f32>) -> f32 {
-    return dot(x, vec3<f32>(0.2126, 0.7152, 0.0722));
-}
-
 @compute @workgroup_size(8, 8)
 fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let width = view.columns * view.cell_size;
@@ -222,7 +214,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
             values[row * slots + pixel] = vec4<f32>(0.0);
         }
 
-        textureStore(output, id.xy, vec4<f32>(srgb_encode(BACKGROUND), 1.0));
+        textureStore(output, id.xy, vec4<f32>(sRGBTransferOETF(BACKGROUND), 1.0));
         return;
     }
 
@@ -258,15 +250,17 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         color = tonemap(value);
     } else {
         // red: SH exponential brighter than the reference, blue: darker; on the tonemapped scale
-        let difference = (luminance(tonemap(sh_exp)) - luminance(tonemap(reference))) * view.error_gain;
+        let difference = (rgb_to_luminance(tonemap(sh_exp)) - rgb_to_luminance(tonemap(reference))) * view.error_gain;
         color = vec3<f32>(max(difference, 0.0), 0.0, max(-difference, 0.0));
     }
 
-    textureStore(output, id.xy, vec4<f32>(srgb_encode(saturate(color)), 1.0));
+    textureStore(output, id.xy, vec4<f32>(sRGBTransferOETF(saturate(color)), 1.0));
 }
 `, [
             chunk_playground_sphere,
             chunk_sh_exp_p4q2_base_reflectance,
             chunk_get_ibl_radiance,
+            chunk_rgb_to_luminance,
+            chunk_sRGBTransferOETF,
         ]),
 });

package/src/shade/playground/vgeo_scene/main.js

@@ -38,6 +38,7 @@ import { place_primitive } from "../../renderer/scene/rows/place_primitive.js";
 import { Scene } from "../../renderer/scene/Scene.js";
 import { load_default_environment } from "../load_default_environment.js";
 import { install_profile_hotkey } from "../profile_hotkey.js";
+import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /**
  * A **whole converted scene** of virtual geometry: thousands of containers, tens of thousands of
@@ -1437,7 +1438,7 @@ function scene_capacities(manifest, page_capacity) {
 
     return {
         geometry_capacity: manifest.geometry_count + 64,
-        lookup_words: 1 << Math.ceil(Math.log2(Math.max(1 << 16, manifest.total_pages * 1.5))),
+        lookup_words: ceilPowerOfTwo(Math.ceil(Math.max(1 << 16, manifest.total_pages * 1.5))),
         claim_word_capacity: Math.ceil(max_instances * page_capacity / 32) * 2,
         max_instances,
     };

package/src/shade/playground/vsm/VSMDebugOverlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VSMDebugOverlay.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vsm/VSMDebugOverlay.js"],"names":[],"mappings":";;;2BAyBU,MAAM;;;;;;;AA2LhB;;;;;;;;;GASG;AACH;IAuCI;;OAEG;IACH,sBAFW,OAAO,mCAAmC,EAAE,eAAe,EAMrE;IAzCD;;OAEG;IACH,MAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,OAFU,OAAO,CAEH;IAEd;;;OAGG;IACH,KAFU,OAAO,+CAA+C,EAAE,gBAAgB,GAAC,IAAI,CAE5E;IAEX;;;OAGG;IACH,SAFU,OAAO,uDAAuD,EAAE,wBAAwB,GAAC,IAAI,CAExF;IAiGf,gBAIC;;CACJ;gCA3V+B,6CAA6C"}
+{"version":3,"file":"VSMDebugOverlay.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/vsm/VSMDebugOverlay.js"],"names":[],"mappings":";;;2BA0BU,MAAM;;;;;;;AA4LhB;;;;;;;;;GASG;AACH;IAuCI;;OAEG;IACH,sBAFW,OAAO,mCAAmC,EAAE,eAAe,EAMrE;IAzCD;;OAEG;IACH,MAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,OAFU,OAAO,CAEH;IAEd;;;OAGG;IACH,KAFU,OAAO,+CAA+C,EAAE,gBAAgB,GAAC,IAAI,CAE5E;IAEX;;;OAGG;IACH,SAFU,OAAO,uDAAuD,EAAE,wBAAwB,GAAC,IAAI,CAExF;IAiGf,gBAIC;;CACJ;gCA7V+B,6CAA6C"}

package/src/shade/playground/vsm/VSMDebugOverlay.js

@@ -6,6 +6,7 @@ import { SceneColor } from "../../renderer/extension/SceneColor.js";
 import { ViewTextures } from "../../renderer/extension/ViewTextures.js";
 import { LIGHT_DATABASE_SPEC } from "../../renderer/light/LIGHT_DATABASE_SPEC.js";
 import { chunk_project_position_from_depth } from "../../renderer/shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_rgb_to_luminance } from "../../renderer/shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_u32_to_hash_color } from "../../renderer/shader/chunk/color/chunk_u32_to_hash_color.js";
 import { chunk_lut_turbo } from "../../renderer/shader/chunk/color/lut/chunk_lut_turbo.js";
 import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
@@ -186,7 +187,7 @@ fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
     }
 
     // modulated by the picture, so the shadows stay readable under the tint
-    let luminance = dot(scene.rgb, vec3f(0.2126, 0.7152, 0.0722));
+    let luminance = rgb_to_luminance(scene.rgb);
 
     return vec4f(tint * (0.15 + luminance), scene.a);
 }
@@ -199,6 +200,7 @@ fn main(@builtin(position) coord: vec4f) -> @location(0) vec4f {
                 chunk_vsm_find_page,
                 chunk_lut_turbo,
                 chunk_u32_to_hash_color,
+                chunk_rgb_to_luminance,
             ]
         ),
     }),

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#279@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#281@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#279@#execute_fill"(record: object, _resources: any, context: {
+    static "__#281@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#279@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#281@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#281@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#283@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -90,19 +90,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#282@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#284@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#282@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#284@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#282@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#282@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#282@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#282@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#284@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#284@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#284@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#284@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -41,7 +41,7 @@ export class GPUFluidPressureSolve {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#278@#execute"(data: {
+    static "__#280@#execute"(data: {
         solve: GPUFluidPressureSolve;
         arm: number;
         count: number;

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_mg_coarsest.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;GAaG;AACH,qDAuFG;8BA5H2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_mg_coarsest.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;GAaG;AACH,qDAuFG;8BA7H2B,+BAA+B"}

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_coarsest.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { chunk_grid_tile_window } from "../../shader/chunk/grid/chunk_grid_tile_window.js";
 import { chunk_index_to_grid3d } from "../../shader/chunk/grid/chunk_index_to_grid3d.js";
 import { chunk_is_finite } from "../../shader/chunk/math/chunk_is_finite.js";
@@ -67,7 +68,7 @@ fn tile_read_p(local: vec3<i32>) -> f32 {
 
     let c = vec3<u32>(local);
 
-    return level_values[c.x + params.size.x * (c.y + params.size.y * c.z)];
+    return level_values[grid3d_to_index(c, params.size.xy)];
 }
 
 @compute @workgroup_size(${FLUID_MG_COARSEST_CELL_LIMIT})
@@ -82,10 +83,9 @@ fn main(@builtin(local_invocation_index) lane: u32) {
 
     if (inside) {
         let storage = grid_tile_window_storage(vec3<i32>(cell), params.input_corner_storage, params.input_period);
-        let held = values[storage.x + params.input_period.x * (storage.y + params.input_period.y * storage.z)];
+        storage_index = grid3d_to_index(storage, params.input_period.xy);
+        let held = values[storage_index];
         let rhs_value = rhs[lane];
-
-        storage_index = storage.x + params.input_period.x * (storage.y + params.input_period.y * storage.z);
         word = words[lane];
         f = select(0.0, rhs_value, is_finite(rhs_value));
         level_values[lane] = select(0.0, held, is_finite(held));
@@ -116,6 +116,7 @@ fn main(@builtin(local_invocation_index) lane: u32) {
     }
 }
 `, [
+            chunk_grid3d_to_index,
             chunk_grid_tile_window,
             chunk_index_to_grid3d,
             chunk_fluid_mg_relax,

package/src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_mg_residual_restrict.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;GAgBG;AACH,8DAuHG;8BApK2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_mg_residual_restrict.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/pressure/shader_fluid_mg_residual_restrict.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;GAgBG;AACH,8DAwHG;8BAtK2B,+BAA+B"}