@woosh/meep-engine 3.14.6 → 3.15.0

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

@@ -29,6 +29,20 @@ export class Renderer {
      * @type {ShadeIndirectLightingMode}
      */
     indirect_lighting_mode: ShadeIndirectLightingMode;
+    /**
+     * Which order-independent transparency technique draws the transparent buckets. Both modes
+     * are wired at the single transparency call site and take the same inputs, so this is safe to
+     * flip at runtime for an A/B. See {@link ShadeTransparencyMode} for what each one costs and
+     * needs from the device. AVBOIT is the default since 2026-09-03: depth-complexity invariant
+     * where MBOIT leaks stacked surfaces, and no 32-bit float blending.
+     * @type {ShadeTransparencyMode}
+     */
+    transparency_mode: ShadeTransparencyMode;
+    /**
+     * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
+     * @type {AVBOITSettings}
+     */
+    avboit: AVBOITSettings;
     feature_ssr_enabled: boolean;
     feature_ssao_enabled: boolean;
     /**
@@ -388,6 +402,8 @@ export class Renderer {
 }
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
+import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
+import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
 import { MotionBlur } from "./postprocess/motion_blur/MotionBlur.js";
 import { DepthOfField } from "./postprocess/dof/raymarch/DepthOfField.js";
 import { DepthOfFieldU } from "./postprocess/dof/gather/DepthOfFieldU.js";

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":"AA4FA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EAkOC;IAED;;OAEG;IACH,gBAGC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CAu2BnB;;CACJ;6BAr5E4B,yBAAyB;0CACZ,gCAAgC;2BApB/C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAiC7C,uBAAuB;gCAtCnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BApDvC,2BAA2B;iCAkDrB,0CAA0C;4CApC/B,+DAA+D;yBA6BlF,yBAAyB;kCAMhB,wBAAwB;oBAvBtC,0BAA0B;uCAPP,sDAAsD"}
+{"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

@@ -54,6 +54,9 @@ import { shader_debug_velocity } from "./postprocess/velocity/shader_debug_veloc
 import {
     graph_rasterize_meshes_transparent_oit
 } from "./rasterize/native/oit/graph_rasterize_meshes_transparent_oit.js";
+import {
+    graph_rasterize_meshes_transparent_avboit
+} from "./rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js";
 import {
     viz_rasterization_alpha_tested_pass_descriptor
 } from "./rasterize/native/viz/viz_rasterization_alpha_tested_pass_descriptor.js";
@@ -65,6 +68,8 @@ import { graph_rasterize_scene } from "./rasterize/standard/graph_rasterize_scen
 import { ReSTIRDI } from "./restir/di/ReSTIRDI.js";
 import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
+import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
+import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";
 import { graph_image_pass } from "./shader/graph/graph_image_pass.js";
 import { graph_import_buffer } from "./shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "./shader/graph/graph_import_texture.js";
@@ -167,6 +172,22 @@ export class Renderer {
      */
     indirect_lighting_mode = ShadeIndirectLightingMode.IBL;
 
+    /**
+     * Which order-independent transparency technique draws the transparent buckets. Both modes
+     * are wired at the single transparency call site and take the same inputs, so this is safe to
+     * flip at runtime for an A/B. See {@link ShadeTransparencyMode} for what each one costs and
+     * needs from the device. AVBOIT is the default since 2026-09-03: depth-complexity invariant
+     * where MBOIT leaks stacked surfaces, and no 32-bit float blending.
+     * @type {ShadeTransparencyMode}
+     */
+    transparency_mode = ShadeTransparencyMode.AVBOIT;
+
+    /**
+     * Switches of the AVBOIT mode, read every frame while {@link transparency_mode} selects it.
+     * @type {AVBOITSettings}
+     */
+    avboit = new AVBOITSettings();
+
     feature_ssr_enabled = false;
     feature_ssao_enabled = true;
     /**
@@ -2178,35 +2199,8 @@ export class Renderer {
 
             }
 
-            // current_color_out = indirect_diffuse
-            // current_color_out = indirect_specular
-
         }
 
-        // current_color_out = graph_decode_rgbe9995_to_rgb16float({
-        //     graph,
-        //     input:indirect_diffuse_near_field,
-        //     resolution: view_ctx.resolution,
-        // });
-        //
-        // const [norm] = graph_image_pass({
-        //     shader: shader_decode_octahedral_normal,
-        //     inputs:{
-        //         tInput: bent_normals,
-        //     },
-        //     graph,
-        //     output_resolution: view_ctx.resolution,
-        // });
-        //
-        // [current_color_out] = graph_image_pass({
-        //     graph,
-        //     shader: shader_draw_normals,
-        //     inputs:{
-        //         tInput: norm,
-        //     },
-        //     output_resolution: view_ctx.resolution,
-        // });
-
         // Composite volumetric fog over the finalized opaque + background + indirect colour.
         // A dedicated pass (not inline in the shading shaders) because indirect lighting is added
         // in a separate additively-blended pass, so the full surface radiance only exists here.
@@ -2250,7 +2244,13 @@ export class Renderer {
             // do transparent alpha pass
             graph.push_scope("transparencies");
 
-            current_color_out = graph_rasterize_meshes_transparent_oit({
+            // Mutually exclusive by construction: one orchestrator runs at this one call site, and both
+            // take the same argument object, so the mode is a pure selector.
+            const graph_rasterize_meshes_transparent = this.transparency_mode === ShadeTransparencyMode.AVBOIT
+                ? graph_rasterize_meshes_transparent_avboit
+                : graph_rasterize_meshes_transparent_oit;
+
+            current_color_out = graph_rasterize_meshes_transparent({
                 graph,
                 buckets: gr_render_buckets,
                 view_ctx,
@@ -2270,6 +2270,7 @@ export class Renderer {
                 volumetrics_metadata: volumetrics.metadata,
 
                 indirect_lighting_mode: this.indirect_lighting_mode,
+                avboit: this.avboit,
             });
 
             graph.pop_scope();

package/src/shade/renderer/ShadeTransparencyMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Selects which order-independent transparency technique draws the transparent buckets.
+ *
+ * Both modes share everything up to the draw commands (material filtering, meshlet expansion, HZB
+ * culling) and both composite onto the scene colour at `FramePhase.AfterLighting`; they differ in
+ * how the per-pixel transmittance in front of a fragment is represented.
+ */
+export type ShadeTransparencyMode = number;
+export namespace ShadeTransparencyMode {
+    let MBOIT: number;
+    let AVBOIT: number;
+}
+//# sourceMappingURL=ShadeTransparencyMode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShadeTransparencyMode.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/ShadeTransparencyMode.js"],"names":[],"mappings":";;;;;;;oCAOU,MAAM"}

package/src/shade/renderer/ShadeTransparencyMode.js

@@ -0,0 +1,30 @@
+/**
+ * Selects which order-independent transparency technique draws the transparent buckets.
+ *
+ * Both modes share everything up to the draw commands (material filtering, meshlet expansion, HZB
+ * culling) and both composite onto the scene colour at `FramePhase.AfterLighting`; they differ in
+ * how the per-pixel transmittance in front of a fragment is represented.
+ *
+ * @enum {number}
+ */
+export const ShadeTransparencyMode = {
+    /**
+     * Moment-based OIT (Peters et al. 2017): four power moments of the transmittance function per
+     * pixel, additively blended at full resolution into `r32float` + `rgba32float` targets, which
+     * is what puts `float32-blendable` on the device floor. Smooth, cheap, and not depth-complexity
+     * invariant — stacked opaque-ish layers leak. The default until 2026-09-03.
+     *
+     * See `rasterize/native/oit/`.
+     */
+    MBOIT: 0,
+    /**
+     * Adaptive voxel-based OIT (Drobot, SIGGRAPH 2025): extinction splatted into a 1/8-resolution
+     * voxel volume whose depth axis is adaptively packed onto 128 physical slices, integrated into a
+     * 3D transmittance lookup. Depth-complexity and shift invariant, filters the background per
+     * channel for transmissive materials (opt-in, `Renderer.avboit`), and needs no 32-bit float
+     * blending. The default.
+     *
+     * See `rasterize/native/avboit/`.
+     */
+    AVBOIT: 1,
+};

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.d.ts

@@ -37,6 +37,15 @@ export class AccumulatingPathTracer {
      * @type {boolean}
      */
     clear_history: boolean;
+    /**
+     * Samples accumulated by the tile that has had the fewest — the floor on how converged the
+     * image is anywhere. Zero right after a reset or before the first frame. A page presenting the
+     * traced image as a reference reads this to say how settled it is, rather than guessing from
+     * frames elapsed (a frame advances one tile, not the whole image).
+     *
+     * @returns {number}
+     */
+    get min_sample_count(): number;
     /**
      * Render one tile worth of new samples and blend it into the accumulation buffer.
      *

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH;IA8EI;;;OAGG;IACH,uCAgBC;IAhGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA+NtB;;;;;;OAMG;IACH,yCAFa,MAAM,CAyJlB;;CACJ"}
+{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH;IA8EI;;;OAGG;IACH,uCAgBC;IAhGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA+NtB;;;;;;;OAOG;IACH,+BAgBC;IAED;;;;;;OAMG;IACH,yCAFa,MAAM,CAyJlB;;CACJ"}

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js

@@ -269,6 +269,32 @@ export class AccumulatingPathTracer {
         }
     }
 
+    /**
+     * Samples accumulated by the tile that has had the fewest — the floor on how converged the
+     * image is anywhere. Zero right after a reset or before the first frame. A page presenting the
+     * traced image as a reference reads this to say how settled it is, rather than guessing from
+     * frames elapsed (a frame advances one tile, not the whole image).
+     *
+     * @returns {number}
+     */
+    get min_sample_count() {
+        const counts = this.#tile_sample_counts;
+
+        if (counts.length === 0) {
+            return 0;
+        }
+
+        let min = counts[0];
+
+        for (let i = 1; i < counts.length; i++) {
+            if (counts[i] < min) {
+                min = counts[i];
+            }
+        }
+
+        return min;
+    }
+
     /**
      * Render one tile worth of new samples and blend it into the accumulation buffer.
      *

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

@@ -10,9 +10,14 @@
  * @param {number[]} resolution
  * @param {string} [label] used for debug
  * @param {GPUSceneContext} scene
+ * @returns {{meshlets: number, draw_commands: number, meshlet_collection: number, meshlet_iterator_command: number}}
+ *   resource IDs: the material-sorted meshlet array the draws consume, one indirect draw command per
+ *   material, the HZB-filtered collection with its count header, and the dispatch command over it
  */
 export function graph_prepare_meshlet_draw_commands_by_material({ graph, materials, bucket_id, limits, buckets, hzb, camera, scene, resolution, label, }: FrameGraph): {
-    meshlets: any;
-    draw_commands: any;
+    meshlets: number;
+    draw_commands: number;
+    meshlet_collection: number;
+    meshlet_iterator_command: number;
 };
 //# sourceMappingURL=prepare_meshlet_draw_commands_by_material.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;GAYG;AACH;;;EA2SC"}
+{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;GAeG;AACH;cAJwB,MAAM;mBAAiB,MAAM;wBAAsB,MAAM;8BAA4B,MAAM;EAuTlH"}

package/src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js

@@ -37,6 +37,9 @@ import { shader_sort_meshlets_by_material } from "./shader_sort_meshlets_by_mate
  * @param {number[]} resolution
  * @param {string} [label] used for debug
  * @param {GPUSceneContext} scene
+ * @returns {{meshlets: number, draw_commands: number, meshlet_collection: number, meshlet_iterator_command: number}}
+ *   resource IDs: the material-sorted meshlet array the draws consume, one indirect draw command per
+ *   material, the HZB-filtered collection with its count header, and the dispatch command over it
  */
 export function graph_prepare_meshlet_draw_commands_by_material({
                                                                     graph,
@@ -335,6 +338,14 @@ export function graph_prepare_meshlet_draw_commands_by_material({
 
     return {
         meshlets: sort_meshlets_by_material_data.output,
-        draw_commands: draw_commands_data.commands
+        draw_commands: draw_commands_data.commands,
+        /*
+         The HZB-filtered collection *before* material sorting — the one with a `count` header — and
+         the indirect dispatch command that iterates it. The sorted buffer above is a bare array whose
+         extent only the draw commands know, so a pass that wants one thread per surviving meshlet
+         (the AVBOIT occupancy prepass) takes these two instead.
+        */
+        meshlet_collection: meshlets,
+        meshlet_iterator_command,
     }
 }

package/src/shade/renderer/rasterize/expand/shader_filter_triangle_by_material_side.js

@@ -15,7 +15,7 @@ import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
 import { MESH_TRIANGLE_REFERENCE_STRUCT } from "../../geometry/meshlet/MESH_TRIANGLE_REFERENCE_STRUCT.js";
-import { chunk_material_side_should_draw } from "../native/oit/chunk_material_side_should_draw.js";
+import { chunk_material_side_should_draw } from "../forward/chunk_material_side_should_draw.js";
 
 const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()

package/src/shade/renderer/rasterize/forward/FORWARD_VERTEX_SHADER_STRUCT.d.ts

@@ -0,0 +1,3 @@
+export const FORWARD_VERTEX_SHADER_STRUCT: WebGPUStruct;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=FORWARD_VERTEX_SHADER_STRUCT.d.ts.map

package/src/shade/renderer/rasterize/forward/FORWARD_VERTEX_SHADER_STRUCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FORWARD_VERTEX_SHADER_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/FORWARD_VERTEX_SHADER_STRUCT.js"],"names":[],"mappings":"AAKA,wDAOE;6BAX2B,mCAAmC"}

package/src/shade/renderer/rasterize/{native/oit → forward}/FORWARD_VERTEX_SHADER_STRUCT.js

@@ -1,7 +1,7 @@
-import { vec2f, vec3f, vec4f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { WGSLAttribute } from "../../../shader/type/WGSLAttribute.js";
-import { WGSLStructField } from "../../../shader/type/WGSLStructField.js";
+import { vec2f, vec3f, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { WGSLAttribute } from "../../shader/type/WGSLAttribute.js";
+import { WGSLStructField } from "../../shader/type/WGSLStructField.js";
 
 export const FORWARD_VERTEX_SHADER_STRUCT = WebGPUStruct.fromFields(
     WGSLStructField.from('position', vec4f, WGSLAttribute.from('builtin', 'position')),

package/src/shade/renderer/rasterize/forward/SHADING_SCENE_RESOURCE_GROUP.d.ts

@@ -0,0 +1,3 @@
+export const SHADING_SCENE_RESOURCE_GROUP: ShaderResourceGroupDescriptor;
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.js";
+//# sourceMappingURL=SHADING_SCENE_RESOURCE_GROUP.d.ts.map

package/src/shade/renderer/rasterize/forward/SHADING_SCENE_RESOURCE_GROUP.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SHADING_SCENE_RESOURCE_GROUP.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/SHADING_SCENE_RESOURCE_GROUP.js"],"names":[],"mappings":"AAQA,yEAAgF;8CANlC,wDAAwD"}

package/src/shade/renderer/rasterize/forward/SHADING_SCENE_RESOURCE_GROUP.js

@@ -0,0 +1,17 @@
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { ShaderResourceGroupDescriptor } from "../../shader/resource/ShaderResourceGroupDescriptor.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_DEFINITION_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
+import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+
+export const SHADING_SCENE_RESOURCE_GROUP = new ShaderResourceGroupDescriptor();
+
+SHADING_SCENE_RESOURCE_GROUP
+    .addStorageBuffer("meshlets", WebGPUArray.from(MESHLET_DEFINITION_STRUCT))
+    .addStorageBuffer("meshlet_metadata", WebGPUArray.from(MESHLET_METADATA_STRUCT))
+    .addStorageBuffer("meshlet_data", GEOMETRY_ATTRIBUTE_DATA_TYPE)
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+

package/src/shade/renderer/rasterize/{native/oit → forward}/chunk_forward_shade_standard_fragment_brick4.d.ts

@@ -1,3 +1,3 @@
 export const chunk_forward_shade_standard_fragment_brick4: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_forward_shade_standard_fragment_brick4.d.ts.map

package/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment_brick4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_forward_shade_standard_fragment_brick4.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment_brick4.js"],"names":[],"mappings":"AA4BA,qEAwJC;0BA3JyB,oCAAoC"}

package/src/shade/renderer/rasterize/{native/oit → forward}/chunk_forward_shade_standard_fragment_brick4.js

@@ -1,29 +1,29 @@
-import { chunk_shade_standard_material_direct } from "../../../deferred/chunk_shade_standard_material_direct.js";
-import { chunk_decode_tangent_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
-import { INDIRECT_LIGHT_INTENSITY } from "../../../deferred/INDIRECT_LIGHT_INTENSITY.js";
+import { chunk_shade_standard_material_direct } from "../../deferred/chunk_shade_standard_material_direct.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
+import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
 import {
     chunk_brick4_sample_forward_indirect
-} from "../../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
-import { BSDF_ROUGHNESS_MINIMUM } from "../../../light/environment/DEFINES.js";
-import { chunk_compute_specular_occlusion } from "../../../shader/chunk/brdf/chunk_compute_specular_occlusion.js";
-import { chunk_F_Hauber } from "../../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
-import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
-import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+} from "../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
+import { BSDF_ROUGHNESS_MINIMUM } from "../../light/environment/DEFINES.js";
+import { chunk_compute_specular_occlusion } from "../../shader/chunk/brdf/chunk_compute_specular_occlusion.js";
+import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import {
     chunk_anti_alias_roughness_kaplanyan
-} from "../../../shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js";
+} from "../../shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js";
 import {
     chunk_build_orthonormal_matrix_nt
-} from "../../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_nt.js";
+} from "../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_nt.js";
 import {
     chunk_compute_indirect_specular
-} from "../../../shader/chunk/material/chunk_compute_indirect_specular.js";
+} from "../../shader/chunk/material/chunk_compute_indirect_specular.js";
 import {
     chunk_dielectric_specular_color
-} from "../../../shader/chunk/material/chunk_dielectric_specular_color.js";
-import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
-import { MATERIAL_SHADING_INFO_STRUCT } from "../../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+} from "../../shader/chunk/material/chunk_dielectric_specular_color.js";
+import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
+import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { FORWARD_VERTEX_SHADER_STRUCT } from "./FORWARD_VERTEX_SHADER_STRUCT.js";
 
 export const chunk_forward_shade_standard_fragment_brick4 = CodeChunk.from(

package/src/shade/renderer/rasterize/{native/oit → forward}/chunk_forward_shade_standard_fragment_ibl.d.ts

@@ -3,5 +3,5 @@
  * Uses environment map sampling for indirect lighting instead of Brick4 probes.
  */
 export const chunk_forward_shade_standard_fragment_ibl: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_forward_shade_standard_fragment_ibl.d.ts.map

package/src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment_ibl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_forward_shade_standard_fragment_ibl.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_shade_standard_fragment_ibl.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,kEA6IC;0BApJyB,oCAAoC"}

package/src/shade/renderer/rasterize/{native/oit → forward}/chunk_forward_shade_standard_fragment_ibl.js

@@ -1,28 +1,28 @@
-import { chunk_shade_standard_material_direct } from "../../../deferred/chunk_shade_standard_material_direct.js";
-import { chunk_decode_tangent_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
-import { chunk_get_ibl_irradiance } from "../../../deferred/indirect/chunk_get_ibl_irradiance.js";
-import { chunk_get_ibl_radiance } from "../../../deferred/indirect/chunk_get_ibl_radiance.js";
-import { INDIRECT_LIGHT_INTENSITY } from "../../../deferred/INDIRECT_LIGHT_INTENSITY.js";
-import { BSDF_ROUGHNESS_MINIMUM } from "../../../light/environment/DEFINES.js";
-import { chunk_compute_specular_occlusion } from "../../../shader/chunk/brdf/chunk_compute_specular_occlusion.js";
-import { chunk_F_Hauber } from "../../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
-import { chunk_get_view_space_depth } from "../../../shader/chunk/depth/chunk_get_view_space_depth.js";
-import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_shade_standard_material_direct } from "../../deferred/chunk_shade_standard_material_direct.js";
+import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
+import { chunk_get_ibl_irradiance } from "../../deferred/indirect/chunk_get_ibl_irradiance.js";
+import { chunk_get_ibl_radiance } from "../../deferred/indirect/chunk_get_ibl_radiance.js";
+import { INDIRECT_LIGHT_INTENSITY } from "../../deferred/INDIRECT_LIGHT_INTENSITY.js";
+import { BSDF_ROUGHNESS_MINIMUM } from "../../light/environment/DEFINES.js";
+import { chunk_compute_specular_occlusion } from "../../shader/chunk/brdf/chunk_compute_specular_occlusion.js";
+import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
+import { chunk_get_view_space_depth } from "../../shader/chunk/depth/chunk_get_view_space_depth.js";
+import { chunk_mat4_extract_position } from "../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import {
     chunk_anti_alias_roughness_kaplanyan
-} from "../../../shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js";
+} from "../../shader/chunk/geometry/normal/chunk_anti_alias_roughness_kaplanyan.js";
 import {
     chunk_build_orthonormal_matrix_nt
-} from "../../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_nt.js";
+} from "../../shader/chunk/geometry/normal/chunk_build_orthonormal_matrix_nt.js";
 import {
     chunk_compute_indirect_specular
-} from "../../../shader/chunk/material/chunk_compute_indirect_specular.js";
+} from "../../shader/chunk/material/chunk_compute_indirect_specular.js";
 import {
     chunk_dielectric_specular_color
-} from "../../../shader/chunk/material/chunk_dielectric_specular_color.js";
-import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
-import { MATERIAL_SHADING_INFO_STRUCT } from "../../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+} from "../../shader/chunk/material/chunk_dielectric_specular_color.js";
+import { GEOMETRIC_SHADING_INFO_STRUCT } from "../../shader/chunk/material/GEOMETRIC_SHADING_INFO_STRUCT.js";
+import { MATERIAL_SHADING_INFO_STRUCT } from "../../shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { FORWARD_VERTEX_SHADER_STRUCT } from "./FORWARD_VERTEX_SHADER_STRUCT.js";
 
 /**

package/src/shade/renderer/rasterize/{native/oit → forward}/chunk_material_side_should_draw.d.ts

@@ -4,5 +4,5 @@
  * @type {CodeChunk}
  */
 export const chunk_material_side_should_draw: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_material_side_should_draw.d.ts.map

package/src/shade/renderer/rasterize/forward/chunk_material_side_should_draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_material_side_should_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_material_side_should_draw.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,8CAFU,SAAS,CAmBlB;0BAxByB,oCAAoC"}

package/src/shade/renderer/rasterize/{native/oit → forward}/chunk_material_side_should_draw.js

@@ -1,5 +1,5 @@
-import { ShadeDrawSide } from "../../../material/ShadeDrawSide.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 
 /**
  * NOTE: draw_side is a {@link ShadeDrawSide} enum value, not a bitmask.

package/src/shade/renderer/rasterize/forward/vertex_shader_chunk.d.ts

@@ -0,0 +1,3 @@
+export const vertex_shader_chunk: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=vertex_shader_chunk.d.ts.map

package/src/shade/renderer/rasterize/forward/vertex_shader_chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex_shader_chunk.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/vertex_shader_chunk.js"],"names":[],"mappings":"AAUA,4CAoDE;0BAvDwB,oCAAoC"}

package/src/shade/renderer/rasterize/{native/oit → forward}/vertex_shader_chunk.js

@@ -1,11 +1,11 @@
-import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
 import {
     chunk_compute_normal_matrix_from_m4
-} from "../../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+} from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
 import {
     chunk_read_meshlet_vertex_by_draw_index
-} from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+} from "../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { FORWARD_VERTEX_SHADER_STRUCT } from "./FORWARD_VERTEX_SHADER_STRUCT.js";
 
 export const vertex_shader_chunk = CodeChunk.from(

package/src/shade/renderer/rasterize/native/avboit/AVBOITSettings.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Per-renderer settings of the AVBOIT transparency mode, held on `Renderer.avboit` the way the
+ * other sub-systems hold theirs (`dof`, `nss`, `path_tracer`). Read every frame by the orchestrator
+ * and carried into the warp header, so the splat and the draw see the same value for one frame.
+ *
+ * The compile-time tunables (slice counts, downscale, curve, bias) stay in `AVBOIT_CONSTANTS.js`;
+ * what lives here is the one thing that changes what a material *means*, which has to be a
+ * runtime decision the page can flip.
+ */
+export class AVBOITSettings {
+    /**
+     * Filter the light a transmissive surface lets through by its base colour, per channel, with
+     * `transmission_factor` as the weight — glTF's transmission semantics, where a red base colour
+     * on `transmission = 1` is red glass.
+     *
+     * Off by default because it is not what the rest of the engine does: the material model has no
+     * transmission colour today, the forward shader and the path tracer treat transmitted light as
+     * untinted, and the contract promises that flipping `transparency_mode` does not change what an
+     * asset looks like. On, the RGB extinction path does what the deck built it for; off, a
+     * transmissive surface lands where MBOIT and the tracer put it, and the per-channel plumbing
+     * costs nothing while it waits for a real transmission colour on the material.
+     *
+     * @type {boolean}
+     */
+    transmission_tint_from_base_color: boolean;
+}
+//# sourceMappingURL=AVBOITSettings.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/AVBOITSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AVBOITSettings.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSettings.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;IAEI;;;;;;;;;;;;;OAaG;IACH,mCAFU,OAAO,CAEyB;CAC7C"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSettings.js

@@ -0,0 +1,27 @@
+/**
+ * Per-renderer settings of the AVBOIT transparency mode, held on `Renderer.avboit` the way the
+ * other sub-systems hold theirs (`dof`, `nss`, `path_tracer`). Read every frame by the orchestrator
+ * and carried into the warp header, so the splat and the draw see the same value for one frame.
+ *
+ * The compile-time tunables (slice counts, downscale, curve, bias) stay in `AVBOIT_CONSTANTS.js`;
+ * what lives here is the one thing that changes what a material *means*, which has to be a
+ * runtime decision the page can flip.
+ */
+export class AVBOITSettings {
+
+    /**
+     * Filter the light a transmissive surface lets through by its base colour, per channel, with
+     * `transmission_factor` as the weight — glTF's transmission semantics, where a red base colour
+     * on `transmission = 1` is red glass.
+     *
+     * Off by default because it is not what the rest of the engine does: the material model has no
+     * transmission colour today, the forward shader and the path tracer treat transmitted light as
+     * untinted, and the contract promises that flipping `transparency_mode` does not change what an
+     * asset looks like. On, the RGB extinction path does what the deck built it for; off, a
+     * transmissive surface lands where MBOIT and the tracer put it, and the per-channel plumbing
+     * costs nothing while it waits for a real transmission colour on the material.
+     *
+     * @type {boolean}
+     */
+    transmission_tint_from_base_color = false;
+}