@woosh/meep-engine 3.60.5 → 3.60.7

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/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/Renderer.d.ts

@@ -303,6 +303,17 @@ export class Renderer {
      * @returns {GPUTextureContext}
      */
     get texture_depth_previous(): GPUTextureContext;
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_current(): GPUTextureContext;
+    /**
+     * At the size last frame was drawn at, as {@link texture_depth_previous} is.
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_previous(): GPUTextureContext;
     /**
      *
      * @param {number} ratio

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -39,6 +39,7 @@ import { PresentTarget } from "./extension/PresentTarget.js";
 import { RenderExtensionRegistry } from "./extension/RenderExtensionRegistry.js";
 import { SceneColor } from "./extension/SceneColor.js";
 import { ViewTextures } from "./extension/ViewTextures.js";
+import { G_BUFFER_COLOR_TARGETS } from "./gbuffer/G_BUFFER_COLOR_TARGETS.js";
 import { G_BUFFER_MIP_LEVELS } from "./gbuffer/G_BUFFER_MIP_LEVELS.js";
 import { shader_brick4_diffuse } from "./global_illumination/brick4/gpu/draw/shader_brick4_diffuse.js";
 import {
@@ -856,6 +857,34 @@ export class Renderer {
      */
     #textures_taa_history = new Array(2);
 
+    /**
+     * The G-buffer normal, ping-ponged as depth is: reprojection asks which surface a history texel was
+     * written on, and only last frame's normal says.
+     * @type {GPUTextureContext[]}
+     */
+    #textures_normal = new Array(2);
+
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_current() {
+        const tx = this.#textures_normal;
+
+        return tx[this.#frame_count % tx.length];
+    }
+
+    /**
+     * At the size last frame was drawn at, as {@link texture_depth_previous} is.
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture_normal_previous() {
+        const tx = this.#textures_normal;
+
+        return tx[(this.#frame_count - 1 + tx.length) % tx.length];
+    }
+
     /**
      *
      * @returns {GPUTextureContext}
@@ -1820,6 +1849,14 @@ export class Renderer {
                 mipLevelCount: G_BUFFER_MIP_LEVELS,
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC,
             }));
+
+            this.#textures_normal[i] = graphics.textures.contextFromDescriptor(TextureDescriptor.from({
+                label: `Normal ${i}`,
+                size: resolution_internal,
+                format: G_BUFFER_COLOR_TARGETS[1].format,
+                mipLevelCount: 1,
+                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+            }));
         }
 
 
@@ -2063,6 +2100,7 @@ export class Renderer {
     #destroy_render_targets() {
         const targets = [
             ...this.#textures_depth,
+            ...this.#textures_normal,
             ...this.#textures_taa_history,
             ...(this.#vis_render_target?.color_attachments ?? []),
         ];
@@ -2072,6 +2110,7 @@ export class Renderer {
         }
 
         this.#textures_depth.fill(undefined);
+        this.#textures_normal.fill(undefined);
         this.#textures_taa_history.fill(undefined);
 
         this.#vis_render_target = undefined;
@@ -2311,9 +2350,10 @@ export class Renderer {
         }
 
         // cycle depth attachment, then size the target this frame draws into. Previous depth is not
-        // attached, so it keeps the size it was drawn at.
+        // attached, so it keeps the size it was drawn at. The normal cycles with it, the same way.
         this.#vis_render_target.depth_attachment = this.texture_depth_current;
         this.#vis_render_target.resize(this.#internal_resolution.x, this.#internal_resolution.y);
+        this.texture_normal_current.resize(this.#internal_resolution.x, this.#internal_resolution.y);
         this.#postprocess.update(this.#frame_count);
 
         // Advance whichever upscaler we're going to ask for jitter on this
@@ -2749,6 +2789,7 @@ export class Renderer {
             view: view_ctx,
             texture_viz_mesh: gr_viz_buffer_mesh,
             texture_viz_triangle: gr_viz_buffer_triangle,
+            texture_normal: graph_import_texture(graph, this.texture_normal_current, "normal"),
         });
 
         // update texture references
@@ -3035,6 +3076,7 @@ export class Renderer {
                 input_depth: gr_texture_depth_current,
                 input_velocity: gr_velocity,
                 input_normal: gr_texture_normal,
+                input_normal_previous: graph_import_texture(graph, this.texture_normal_previous, "normal previous"),
                 input_occlusion: gr_occlusion_clip,
                 input_hzb: gr_texture_hzb,
                 // NOTE: AO is blended into the G-buffer

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"}