@woosh/meep-engine 3.26.0 → 3.28.0

package/src/shade/renderer/geometry/virtual/runtime/vgeo_frontier_words.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Words of frontier one view keeps: one bit per page row of the tier it cuts against.
+ *
+ * The frontier is the set of pages a view's cut is standing on, and it is a **bitmask over page
+ * rows** rather than a list of groups because that is the granularity everything else in the cut
+ * already speaks: a page is what `vg_claim_page` claims, what a page visit evaluates whole, and what
+ * both directions of the traversal cross. A reseed hands the descent those pages instead of node 0
+ * of the root, and CUT_PLAN_2026_09_14 §7.5's coarsen path carries it the rest of the way.
+ *
+ * It is small. A 4,096-row tier is 128 words — half a kilobyte a view — against the 120–160 KB §5
+ * sizes a group-level frontier at, and it needs no allocator, no compaction and no entry format.
+ * What it gives up is per-instance keying (§1.1): two instances of one geometry at different
+ * distances share one page set, which is a superset of each one's own and therefore correct, but
+ * costs the closer instance a few page visits it did not need.
+ *
+ * @param {number} page_row_capacity
+ * @returns {number} words
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_frontier_words(page_row_capacity: number): number;
+//# sourceMappingURL=vgeo_frontier_words.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/vgeo_frontier_words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_frontier_words.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_frontier_words.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uDANW,MAAM,GACJ,MAAM,CASlB"}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_frontier_words.js

@@ -0,0 +1,28 @@
+import { assert } from "../../../../../core/assert.js";
+
+/**
+ * Words of frontier one view keeps: one bit per page row of the tier it cuts against.
+ *
+ * The frontier is the set of pages a view's cut is standing on, and it is a **bitmask over page
+ * rows** rather than a list of groups because that is the granularity everything else in the cut
+ * already speaks: a page is what `vg_claim_page` claims, what a page visit evaluates whole, and what
+ * both directions of the traversal cross. A reseed hands the descent those pages instead of node 0
+ * of the root, and CUT_PLAN_2026_09_14 §7.5's coarsen path carries it the rest of the way.
+ *
+ * It is small. A 4,096-row tier is 128 words — half a kilobyte a view — against the 120–160 KB §5
+ * sizes a group-level frontier at, and it needs no allocator, no compaction and no entry format.
+ * What it gives up is per-instance keying (§1.1): two instances of one geometry at different
+ * distances share one page set, which is a superset of each one's own and therefore correct, but
+ * costs the closer instance a few page visits it did not need.
+ *
+ * @param {number} page_row_capacity
+ * @returns {number} words
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function vgeo_frontier_words(page_row_capacity) {
+    assert.isNonNegativeInteger(page_row_capacity, 'page_row_capacity');
+
+    return Math.ceil(page_row_capacity / 32);
+}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_page.worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vgeo_page.worker.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/vgeo_page.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vgeo_page.worker.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_page.worker.js"],"names":[],"mappings":""}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_page.worker.js

@@ -0,0 +1,13 @@
+import { vgeo_page_worker_serve } from "../format/read/vgeo_page_worker_serve.js";
+
+/**
+ * The page-fetch worker: reads, verifies and decodes pages off the main thread.
+ *
+ * Nothing here but the serve call; the protocol lives with the core in `format/read/` so a spec can
+ * run it over a loopback, and this file exists so that {@link make_vgeo_page_worker} has a module
+ * to point a `Worker` at.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+vgeo_page_worker_serve(self);

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_block_words.d.ts

@@ -1,18 +1,23 @@
 /**
  * How many arena words one page's block runs to.
  *
- * A page is **one allocation** — `[node rows][group rows][cluster rows]`, back to back — so this is
- * the whole of what installing it costs the arena and the whole of what evicting it returns. Every
- * base inside the block is a count away from the block's own start, which is why a page row carries
- * three counts and one offset and nothing can move inside a resident page.
+ * A page is **one allocation** — `[node rows][group rows][cluster rows][parent rows]`, back to
+ * back — so this is the whole of what installing it costs the arena and the whole of what evicting
+ * it returns. Every base inside the block is a count away from the block's own start, which is why
+ * a page row carries the counts and nothing can move inside a resident page.
+ *
+ * The parent rows are last because they are the section a page may not have: a container written
+ * before `format_version` 4 carries no upward edge, `parent_entry_count` is zero, and the block is
+ * exactly what it was.
  *
  * @param {number} node_count
  * @param {number} group_count
  * @param {number} cluster_count
+ * @param {number} [parent_entry_count]
  * @returns {number} words
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_runtime_page_block_words(node_count: number, group_count: number, cluster_count: number): number;
+export function vgeo_runtime_page_block_words(node_count: number, group_count: number, cluster_count: number, parent_entry_count?: number): number;
 //# sourceMappingURL=vgeo_runtime_page_block_words.d.ts.map

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_block_words.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_runtime_page_block_words.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_block_words.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,0DARW,MAAM,eACN,MAAM,iBACN,MAAM,GACJ,MAAM,CASlB"}
+{"version":3,"file":"vgeo_runtime_page_block_words.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_block_words.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,0DATW,MAAM,eACN,MAAM,iBACN,MAAM,uBACN,MAAM,GACJ,MAAM,CAYlB"}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_page_block_words.js

@@ -1,25 +1,34 @@
 import { VGEO_CLUSTER_ROW_WORDS } from "./layout/VGEO_CLUSTER_ROW_WORDS.js";
 import { VGEO_GROUP_ROW_WORDS } from "./layout/VGEO_GROUP_ROW_WORDS.js";
 import { VGEO_NODE_ROW_WORDS } from "./layout/VGEO_NODE_ROW_WORDS.js";
+import { VGEO_PARENT_ROW_WORDS } from "./layout/VGEO_PARENT_ROW_WORDS.js";
 
 /**
  * How many arena words one page's block runs to.
  *
- * A page is **one allocation** — `[node rows][group rows][cluster rows]`, back to back — so this is
- * the whole of what installing it costs the arena and the whole of what evicting it returns. Every
- * base inside the block is a count away from the block's own start, which is why a page row carries
- * three counts and one offset and nothing can move inside a resident page.
+ * A page is **one allocation** — `[node rows][group rows][cluster rows][parent rows]`, back to
+ * back — so this is the whole of what installing it costs the arena and the whole of what evicting
+ * it returns. Every base inside the block is a count away from the block's own start, which is why
+ * a page row carries the counts and nothing can move inside a resident page.
+ *
+ * The parent rows are last because they are the section a page may not have: a container written
+ * before `format_version` 4 carries no upward edge, `parent_entry_count` is zero, and the block is
+ * exactly what it was.
  *
  * @param {number} node_count
  * @param {number} group_count
  * @param {number} cluster_count
+ * @param {number} [parent_entry_count]
  * @returns {number} words
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function vgeo_runtime_page_block_words(node_count, group_count, cluster_count) {
+export function vgeo_runtime_page_block_words(
+    node_count, group_count, cluster_count, parent_entry_count = 0
+) {
     return node_count * VGEO_NODE_ROW_WORDS
         + group_count * VGEO_GROUP_ROW_WORDS
-        + cluster_count * VGEO_CLUSTER_ROW_WORDS;
+        + cluster_count * VGEO_CLUSTER_ROW_WORDS
+        + parent_entry_count * VGEO_PARENT_ROW_WORDS;
 }

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.d.ts

@@ -1,5 +1,5 @@
 /**
- * Lay one decoded page's node, group and cluster rows into the arena.
+ * Lay one decoded page's node, group, cluster and parent rows into the arena.
  *
  * This is the whole of what a page install writes besides its payload, and it is deliberately a
  * free function over two views rather than a method: the pool calls it against a mapped GPU upload
@@ -14,6 +14,11 @@
  * resolves to a page that is trivially resident — itself — and falls straight through to the
  * selectability question, which is the only one it was ever really asking.
  *
+ * The parent rows (format §6.3) get the same treatment for the same reason, off the page's own
+ * parent-page table rather than its child table. A page from a container written before
+ * `format_version` 4 has no such table, so the section is empty and the page row's
+ * `PARENT_ENTRY_COUNT` says zero — which is what a kernel checks, rather than asking a version.
+ *
  * Group selectability is **not** written here. It changes after install, as the reader's activation
  * cascades run, and it is the one field of a resident page that moves.
  *

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_runtime_write_page_block.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qDAXW,WAAW,UACX,YAAY,QAEZ,MAAM,mBAEJ,MAAM,CAoGlB"}
+{"version":3,"file":"vgeo_runtime_write_page_block.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qDAXW,WAAW,UACX,YAAY,QAEZ,MAAM,mBAEJ,MAAM,CAkIlB"}

package/src/shade/renderer/geometry/virtual/runtime/vgeo_runtime_write_page_block.js

@@ -10,9 +10,11 @@ import { VGEO_NODE_ROW_LEAF_BIT } from "./layout/VGEO_NODE_ROW_LEAF_BIT.js";
 import { VGEO_NODE_ROW_OFFSET } from "./layout/VGEO_NODE_ROW_OFFSET.js";
 import { VGEO_NODE_ROW_WORDS } from "./layout/VGEO_NODE_ROW_WORDS.js";
 import { VGEO_NO_CHILD_PAGE } from "./layout/VGEO_NO_CHILD_PAGE.js";
+import { VGEO_PARENT_ROW_OFFSET } from "./layout/VGEO_PARENT_ROW_OFFSET.js";
+import { VGEO_PARENT_ROW_WORDS } from "./layout/VGEO_PARENT_ROW_WORDS.js";
 
 /**
- * Lay one decoded page's node, group and cluster rows into the arena.
+ * Lay one decoded page's node, group, cluster and parent rows into the arena.
  *
  * This is the whole of what a page install writes besides its payload, and it is deliberately a
  * free function over two views rather than a method: the pool calls it against a mapped GPU upload
@@ -27,6 +29,11 @@ import { VGEO_NO_CHILD_PAGE } from "./layout/VGEO_NO_CHILD_PAGE.js";
  * resolves to a page that is trivially resident — itself — and falls straight through to the
  * selectability question, which is the only one it was ever really asking.
  *
+ * The parent rows (format §6.3) get the same treatment for the same reason, off the page's own
+ * parent-page table rather than its child table. A page from a container written before
+ * `format_version` 4 has no such table, so the section is empty and the page row's
+ * `PARENT_ENTRY_COUNT` says zero — which is what a kernel checks, rather than asking a version.
+ *
  * Group selectability is **not** written here. It changes after install, as the reader's activation
  * cascades run, and it is the one field of a resident page that moves.
  *
@@ -51,6 +58,7 @@ export function vgeo_runtime_write_page_block(words, floats, base, page) {
 
     const group_base = base + node_count * VGEO_NODE_ROW_WORDS;
     const cluster_base = group_base + group_count * VGEO_GROUP_ROW_WORDS;
+    const parent_base = cluster_base + cluster_count * VGEO_CLUSTER_ROW_WORDS;
 
     let broken_child_refs = 0;
 
@@ -84,6 +92,7 @@ export function vgeo_runtime_write_page_block(words, floats, base, page) {
          tier's answer costs.
          */
         words[row + VGEO_GROUP_ROW_OFFSET.PARENT_COUNT] = page.group_parent_count[group];
+        words[row + VGEO_GROUP_ROW_OFFSET.PARENT_FIRST] = page.group_parent_first[group] ?? 0;
 
         // not selectable until activation says so; a page installs drawing nothing. Any other
         // default draws a group before the ancestors it hangs off have arrived.
@@ -134,5 +143,33 @@ export function vgeo_runtime_write_page_block(words, floats, base, page) {
         words[row + VGEO_CLUSTER_ROW_OFFSET.CHILD_REF] = child_ref;
     }
 
+    for (let entry = 0; entry < page.parent_ref.length; entry++) {
+        const row = parent_base + entry * VGEO_PARENT_ROW_WORDS;
+
+        const parent_ref = page.parent_ref[entry];
+
+        /*
+         A parent_ref outside the page's parent-page table is the upward twin of a broken child_ref
+         and is counted with it: format §11.16 forbids it, validation is off by default, and the
+         cluster it would have named does not exist. Pointing it at this page would be worse than
+         admitting there is nothing there — VGEO_NO_CHILD_PAGE never resolves, so a walk up stops
+         and the fallback re-descends, which is correct rather than merely safe.
+        */
+        let parent_page_index;
+
+        if (parent_ref === VGEO_SAME_PAGE) {
+            parent_page_index = page.index;
+        } else if (parent_ref < page.parent_page_index.length) {
+            parent_page_index = page.parent_page_index[parent_ref];
+        } else {
+            parent_page_index = VGEO_NO_CHILD_PAGE;
+
+            broken_child_refs++;
+        }
+
+        words[row + VGEO_PARENT_ROW_OFFSET.PAGE_INDEX] = parent_page_index;
+        words[row + VGEO_PARENT_ROW_OFFSET.CLUSTER] = page.parent_cluster[entry];
+    }
+
     return broken_child_refs;
 }

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sharc_evict.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js"],"names":[],"mappings":"AAkGA,+CAIG;8BAlG2B,kCAAkC"}
+{"version":3,"file":"shader_sharc_evict.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js"],"names":[],"mappings":"AAmGA,+CAIG;8BAnG2B,kCAAkC"}

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js

@@ -26,10 +26,11 @@ const PUSH_CONSTANTS = WebGPUStruct.from({
     capacity: u32,
 });
 
-// per-dispatch, eight bytes, read-only: immediate data rather than a uniform buffer
-resources.setImmediate("settings", PUSH_CONSTANTS);
-
+// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
+//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
+//      value into a transient uniform, so no call site changes.
 resources.createGroup()
+    .addUniform("settings", PUSH_CONSTANTS)
     .addStorageBuffer('hashMapData', HASH_MAP_DATA_STRUCT, true)
     .addStorageBuffer("voxelData", WebGPUArray.from(vec4u))
     .addStorageBuffer('evictionRequests', EVICTION_STRUCT);

package/src/shade/renderer/loader/gltf/load_gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAgDlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CA+0B/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BAtlC2B,mBAAmB;yBAUtB,gBAAgB"}
+{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAmIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAgDlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CA8zB/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BApkC2B,mBAAmB;yBAStB,gBAAgB"}

package/src/shade/renderer/loader/gltf/load_gltf.js

@@ -9,7 +9,6 @@ import { clamp01 } from "../../../../core/math/clamp01.js";
 import { computeObjectHash } from "../../../../core/math/hash/computeObjectHash.js";
 import { inverseLerp } from "../../../../core/math/inverseLerp.js";
 import { objectDeepEquals } from "../../../../core/model/object/objectDeepEquals.js";
-import { number_format_by_thousands } from "../../../../core/primitives/numbers/number_format_by_thousands.js";
 import { AnimationInterpolationKind } from "../../../../engine/animation/clip/AnimationInterpolationKind.js";
 import { curve_from_track_data } from "../../../../engine/animation/clip/curve_from_track_data.js";
 import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
@@ -35,7 +34,6 @@ import { ShadeImage } from "../../texture/source/ShadeImage.js";
 import { SceneBundle } from "../SceneBundle.js";
 import { SceneNode } from "../SceneNode.js";
 import { coalesce_array_duplicates } from "../../../../format/scene/gltf/coalesce_array_duplicates.js";
-import { fix_up_material_sides } from "./fix_up_material_sides.js";
 import { GLTF_COMPONENT_TYPE } from "../../../../format/scene/gltf/gltf_component_type.js";
 import { gltf_create_material } from "./gltf_create_material.js";
 import { gltf_create_texture } from "./gltf_create_texture.js";
@@ -1092,25 +1090,8 @@ export function load_gltf(url, { assetManager, scope, fileMap, texture_support }
         return bundle;
     }
 
-    /**
-     * @param {SceneBundle} bundle
-     */
-    function fix_scene_material_sidedness(bundle) {
-        const meshes = bundle.nodes.filter(node => node.geometry !== null);
-
-        const { geometries_modified: fixed_count, primitives_delta } = fix_up_material_sides(meshes);
-
-        if (fixed_count > 0) {
-            console.warn(`Fixed ${fixed_count} geometries in accordance with material sidedness. Primitives added: ${number_format_by_thousands(primitives_delta)}`);
-        }
-
-        return bundle;
-    }
-
-
     return load_gltf_document(url, { assetManager, scope, fileMap, texture_support })
         .then(process)
-        // .then(fix_scene_material_sidedness)
         // .then(prepare_lightmap)
         ;
 }

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#240@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#247@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/material/chunk_material_draw_side.d.ts

@@ -0,0 +1,14 @@
+/**
+ * What a {@link ShadeDrawSide} means once `Back` stopped being a pipeline state of its own.
+ *
+ * A back-sided material is a front-sided one drawn with its winding reversed: the vertex shader
+ * emits each triangle's corners in the opposite order and the fixed-function rasterizer, still
+ * culling back faces, keeps the surface's back. That is what lets both share a bucket — see
+ * `chunk_rasterization_material_bucket` — and it is the same mechanism a reflected instance uses,
+ * so the two compose by exclusive-or.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_draw_side: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_material_draw_side.d.ts.map

package/src/shade/renderer/material/chunk_material_draw_side.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_material_draw_side.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/chunk_material_draw_side.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,uCAFU,SAAS,CAqBb;0BAjCoB,iCAAiC"}

package/src/shade/renderer/material/chunk_material_draw_side.js

@@ -0,0 +1,34 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ShadeDrawSide } from "./ShadeDrawSide.js";
+
+/**
+ * What a {@link ShadeDrawSide} means once `Back` stopped being a pipeline state of its own.
+ *
+ * A back-sided material is a front-sided one drawn with its winding reversed: the vertex shader
+ * emits each triangle's corners in the opposite order and the fixed-function rasterizer, still
+ * culling back faces, keeps the surface's back. That is what lets both share a bucket — see
+ * `chunk_rasterization_material_bucket` — and it is the same mechanism a reflected instance uses,
+ * so the two compose by exclusive-or.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_draw_side = CodeChunk.from(
+    //language=WGSL
+    `
+/**
+ * Whether the material asks for the back face, and therefore for reversed winding.
+ */
+fn material_draws_back_side( draw_side: u32 ) -> bool{
+    return draw_side == ${ShadeDrawSide.Back}u;
+}
+
+/**
+ * Whether the fragment is looking at the front of the surface.
+ *
+ * Not \`front_facing\`: that is the rasterizer's answer about the winding the vertex shader
+ * emitted, and a back-sided material emitted it reversed on purpose.
+ */
+fn material_fragment_faces_front( front_facing: bool, draw_side: u32 ) -> bool{
+    return front_facing != material_draws_back_side(draw_side);
+}
+`, [])

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA6EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAkOrB;AAjRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AAyQH,8CAIE;0BA1SwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAwOrB;AAvRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AA+QH,8CAIE;0BAhTwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}

package/src/shade/renderer/material/standard/fragment_gbuffer.js

@@ -6,6 +6,7 @@ import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
 import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
 import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { chunk_node3d_flags } from "../../scene/chunk_node3d_flags.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
 import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
 import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
@@ -225,7 +226,12 @@ fn main(
     );
 
     // Get tangent handedness from the provoking vertex (0).
-    let geometry_tangent_handedness = vertex_0.tangent.w;
+    // a reflection changes the tangent frame's handedness — see NODE3D_GLOBAL_FLAG_MIRRORED
+    let geometry_tangent_handedness = select(
+        vertex_0.tangent.w,
+        -vertex_0.tangent.w,
+        node3d_global_is_mirrored(node)
+    );
 
     let geometry_color = interpolate_attribute_3f32(
         vertex_0.color,
@@ -316,6 +322,7 @@ fn main(
         chunk_rgbe9995_encode,
         chunk_dither_color_8bit_triangle_noise,
         chunk_scene_database_access,
+        chunk_node3d_flags,
 
         ...extra_chunks,
     ]

package/src/shade/renderer/particles/shaders/shader_particle_emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAoD3B,iDAIG;6BAxG0B,mCAAmC;8BAGlC,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAuD3B,iDAIG;6BA3G0B,mCAAmC;8BAGlC,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_emit.js

@@ -52,8 +52,9 @@ export const EMIT_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.setImmediate('settings', EMIT_SETTINGS);
-
+// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
+//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
+//      value into a transient uniform, so no call site changes.
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -62,7 +63,9 @@ resources.createGroup()
     .addStorageBuffer("pool", WebGPUArray.u32, true)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    // last in the group, so the storage bindings keep the indices the specs read by
+    .addUniform('settings', EMIT_SETTINGS);
 
 const body = CodeChunk.from(
     /* language=wgsl */

package/src/shade/renderer/particles/shaders/shader_particle_simulate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAsD/B,qDAIG;iDApH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAyD/B,qDAIG;iDAvH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_simulate.js

@@ -67,8 +67,9 @@ export const SIMULATE_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.setImmediate('settings', SIMULATE_SETTINGS);
-
+// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
+//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
+//      value into a transient uniform, so no call site changes.
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -77,7 +78,9 @@ resources.createGroup()
     .addStorageBuffer("sim_list", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    // last in the group, so the storage bindings keep the indices the specs read by
+    .addUniform('settings', SIMULATE_SETTINGS);
 
 
 const body = CodeChunk.from(/* language=wgsl */ `

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDAsHC;0BA/NyB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAiCA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDA+HC;0BAxOyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -1,4 +1,7 @@
 import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import {
+    chunk_mat4_linear_determinant
+} from "../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
 import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
 import {
@@ -201,7 +204,15 @@ fn sample_material_data(
         world_face_normal = -world_face_normal;
     }
 
-    let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, geometry_tangent.w));
+    // a reflection changes the tangent frame's handedness — see NODE3D_GLOBAL_FLAG_MIRRORED.
+    // No node here: the tracer is handed a matrix, so the sign comes off the matrix.
+    let tangent_handedness = select(
+        geometry_tangent.w,
+        -geometry_tangent.w,
+        mat4_linear_determinant(instance_transform) < 0.0
+    );
+
+    let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, tangent_handedness));
 
     var normal_sample = decode_tangent_normal(indirect_sample_texture(material.texture_normal, material.sampler_normal, uv));
     
@@ -238,6 +249,7 @@ fn sample_material_data(
         chunk_interpolate_attribute_3f32,
         chunk_interpolate_attribute_4f32,
         chunk_compute_normal_matrix_from_m4,
+        chunk_mat4_linear_determinant,
         chunk_build_orthonormal_matrix_nt,
         chunk_decode_tangent_normal,
         chunk_compute_triangle_face_normal,

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#173@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#180@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts

@@ -9,9 +9,14 @@ export function construct_primitive_state(draw_mode: ShadeDrawMode, side: ShadeD
 /**
  * Named cull-mode lookup tables, keyed by {@link ShadeDrawSide }.
  *
- *  - `Standard` is the main-pass mapping: a `Front`-sided material renders its front face
- *    (cull back), `Back` renders its back face (cull front), `Double` renders both.
- *  - `Reversed` flips sided materials so the *back* face is what gets drawn. This is the
+ * `Front` and `Back` map to the same cull mode, because the winding they differ by is the
+ * vertex shader's to reverse — see `chunk_triangle_list_reverse_winding`. That is what lets
+ * them share a bucket, and it is why nothing here needs a fourth entry for the *instance's*
+ * handedness either.
+ *
+ *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
+ *    presents (cull back), `Double` renders both.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
  *    standard "back-face shadow casting" / "front-face culling for shadow casters"
  *    technique — shadow callers select this policy so the surface written into the shadow
  *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
@@ -21,12 +26,21 @@ export function construct_primitive_state(draw_mode: ShadeDrawMode, side: ShadeD
 export type CullPolicy = Readonly<Record<number, GPUCullMode>>;
 export namespace CullPolicy {
     let Standard: Readonly<{
-        [x: number]: "none" | "back" | "front";
+        [x: number]: "none" | "back";
     }>;
     let Reversed: Readonly<{
-        [x: number]: "none" | "back" | "front";
+        [x: number]: "none" | "front";
     }>;
 }
+/**
+ * One {@link ShadeDrawSide} per rasterization bucket — the sides that still differ once `Back`
+ * is drawn as a reversed `Front`. Callers that enumerate buckets iterate this rather than the
+ * enum, so a `Back`-sided material is picked up by the `Front` pass rather than by a pass of
+ * its own that would repeat the whole expansion chain for it.
+ *
+ * @type {ReadonlyArray<ShadeDrawSide>}
+ */
+export const RASTERIZATION_BUCKET_SIDES: ReadonlyArray<ShadeDrawSide>;
 import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 import { PrimitiveState } from "../../../descriptor/pipeline/render/PrimitiveState.js";

package/src/shade/renderer/rasterize/bucket/construct_primitive_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CAgB1B;;;;;;;;;;;;;yBApCS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;8BApBjB,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}
+{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AAsDA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CAgB1B;;;;;;;;;;;;;;;;;;yBAjDS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAnD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}