@woosh/meep-engine 3.37.0 → 3.38.0

package/src/shade/playground/water_refraction/world.js

@@ -0,0 +1,137 @@
+import { Color } from "../../../core/color/Color.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import Terrain from "../../../engine/ecs/terrain/ecs/Terrain.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { t64_announce_change } from "../../../engine/ecs/transform/t64_announce_change.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import Water from "../../../engine/graphics/ecs/water/Water.js";
+import { ParticleEffect } from "../../../engine/graphics/ecs/particles/ParticleEffect.js";
+import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
+import { meshlet_geometry_build_from_geometry } from "../../renderer/geometry/meshlet_geometry_build_from_geometry.js";
+import { MeshletGeometry } from "../../renderer/geometry/MeshletGeometry.js";
+import { make_box_geometry } from "../../renderer/geometry/primitives/make_box_geometry.js";
+import { make_plane_geometry } from "../../renderer/geometry/primitives/make_plane_geometry.js";
+import { StandardAttributes } from "../../renderer/geometry/StandardAttributes.js";
+import { ShadeDrawSide } from "../../renderer/material/ShadeDrawSide.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { TransparencyMode } from "../../renderer/material/TransparencyMode.js";
+import { DynamicMesh } from "../../renderer/scene/DynamicMesh.js";
+import { DynamicMeshBatch } from "../../renderer/scene/DynamicMeshBatch.js";
+import { ColorSpace } from "../../renderer/texture/ColorSpace.js";
+import { ShadeTexture } from "../../renderer/texture/ShadeTexture.js";
+import { ShadeImage } from "../../renderer/texture/source/ShadeImage.js";
+import { bonfire_effects } from "../particle_ecs/bonfire_effects.js";
+import { bonfire_sprites } from "../particle_ecs/bonfire_sprites.js";
+
+export const height_at = (x,z,offset=0) => -2 + Math.max(0,z-18)*0.5 + offset;
+
+function pose(x,y,z,rotation=Quaternion.identity) {
+    const transform = new Transform64();
+    transform.setTranslation(x,y,z);
+    if (rotation !== undefined) { transform.setRotation(rotation.x,rotation.y,rotation.z,rotation.w); }
+    transform.updateMatrix(); return transform;
+}
+function material(rgb,alpha=1) {
+    const m=new StandardShadeMaterial(); m.diffuse_color.copy(new Color(...rgb,alpha));
+    m.metallic_factor=0; m.roughness_factor=0.55; m.draw_side=ShadeDrawSide.Double;
+    m.transparency_mode=alpha<1?TransparencyMode.Transparent:TransparencyMode.Opaque;
+    return m;
+}
+function meshlets(geometry) {
+    const result=new MeshletGeometry(); meshlet_geometry_build_from_geometry(geometry,result); return result;
+}
+function shaded(geometry,material) { const s=new ShadedGeometry(); s.geometry=geometry; s.material=material; return s; }
+function checker() {
+    // A four-texel-wide square blurred under ordinary bilinear filtering even with
+    // water disabled. Keep the same world-space pattern with a sharp source image.
+    const size=1024, data=Sampler2D.uint8(4,size,size);
+    for(let y=0;y<size;y++) for(let x=0;x<size;x++) {
+        const bright=((x>>6)+(y>>6))%2===0;
+        const n=bright?215:42; data.data.set([n,bright?220:66,bright?200:84,255],(y*size+x)*4);
+    }
+    const image=ShadeImage.fromSampler2D(data); image.color_space=ColorSpace.SRGB;
+    return ShadeTexture.from(image);
+}
+
+/** All visible static content uses ordinary ECS meshlets; water owns no demo-specific pass. */
+export async function build_world(dataset) {
+    await MeshoptClusterizer.ready;
+    const entities=[];
+    const build=builder=>{builder.build(dataset);entities.push(builder.id);return builder.id;};
+    const terrain=new Terrain(); terrain.size.set(32,32); terrain.gridScale=1;
+    function sampler(offset=0) {
+        const s=Sampler2D.float32(1,65,65);
+        for(let y=0;y<65;y++) for(let x=0;x<65;x++) s.data[y*65+x]=height_at(x/64*32,y/64*32,offset);
+        return s;
+    }
+    terrain.samplerHeight=sampler(); build(new Entity().add(terrain).add(pose(0,0,0)));
+    const floor_geo=make_plane_geometry(32,32,32,32);
+    const positions=floor_geo.getAttribute(StandardAttributes.Position).data;
+    const normals=floor_geo.getAttribute(StandardAttributes.Normal).data;
+    for(let i=0;i<positions.length;i+=3) {
+        const x=positions[i]+16,z=16-positions[i+1];
+        positions[i]=x; positions[i+1]=height_at(x,z); positions[i+2]=z;
+        const slope=z>18?0.5:0,n=Math.hypot(1,slope);
+        normals[i]=0; normals[i+1]=1/n; normals[i+2]=-slope/n;
+    }
+    const floor_material=material([1,1,1]); floor_material.texture_albedo=checker();
+    const floor_transform=pose(0,0,0);
+    const floor_entity=build(new Entity().add(floor_transform).add(shaded(meshlets(floor_geo),floor_material)));
+    const water=new Water(); water.level.set(0); water.scattering.set(0.6);
+    const water_entity=build(new Entity().add(water));
+    const add_mesh=(geo,m,x,y,z,rotation)=>{
+        const t=pose(x,y,z,rotation);const component=shaded(meshlets(geo),m);
+        const entity=build(new Entity().add(t).add(component)); return {transform:t,component,entity};
+    };
+    add_mesh(make_box_geometry(4,1.5,2),material([0.48,0.23,0.08]),16,0.15,14);
+    for(let i=0;i<5;i++) add_mesh(make_box_geometry(0.12,3.5,0.12),material([0.9,0.5,0.13]),9+i*0.45,-0.25,14);
+    const card=add_mesh(make_plane_geometry(2,2),material([0.2,0.65,0.9],0.5),12,0,12);
+    const submerged=add_mesh(make_box_geometry(1.2,0.8,1.2),material([0.8,0.14,0.1]),15,-1.4,11);
+    const effects=bonfire_effects(bonfire_sprites());
+    const live_effects=[effects.smoke,effects.embers];
+    const particle_transforms=[];
+    for(const [i,effect] of [effects.smoke,effects.embers].entries()) {
+        effect.spawn_rate=80; const t=pose(11+i*2,-0.5,10);
+        const entity=build(new Entity().add(t).add(effect)); particle_transforms.push({transform:t,entity});
+    }
+    const ribbon=DynamicMesh.from(make_plane_geometry(6,0.14,16,1),[0.75,0.12,0.9,0.55]);
+    const ribbon_base=ribbon.geometry.getAttribute(StandardAttributes.Position).data.slice();
+    const batch=new DynamicMeshBatch(); batch.add(ribbon);
+    let secondary=null;
+    let last_update=null;
+    return {terrain,water,water_entity,card,submerged,batch,ribbon,effects:live_effects,entities,
+        reset_particles() {
+            particle_transforms.forEach(({entity},i)=>{
+                const replacement=live_effects[i].clone();
+                dataset.removeComponentFromEntity(entity,ParticleEffect);
+                dataset.addComponentToEntity(entity,replacement);live_effects[i]=replacement;
+            });
+        },
+        update(time,{layer_height=0,animate=false}={}) {
+            if(last_update!==null&&last_update[0]===time&&last_update[1]===layer_height&&last_update[2]===animate)return;
+            last_update=[time,layer_height,animate];
+            card.transform.setTranslation(12,layer_height,12); t64_announce_change(dataset,card.entity);
+            particle_transforms.forEach(({transform:t,entity},i)=>{t.setTranslation(11+i*2,layer_height-0.7,10);t64_announce_change(dataset,entity);});
+            submerged.transform.setTranslation(15+(animate?Math.sin(time)*2:0),-1.4,11);
+            t64_announce_change(dataset,submerged.entity);
+            const p=ribbon.geometry.getAttribute(StandardAttributes.Position).data;
+            for(let i=0;i<p.length;i+=3) {
+                p[i]=13+ribbon_base[i]; p[i+1]=layer_height+ribbon_base[i+1]+Math.sin(ribbon_base[i]+time)*0.6;
+                p[i+2]=9+Math.cos(ribbon_base[i]*0.5)*0.7;
+            }
+            ribbon.geometry.needsUpdate=true;
+        },
+        replace_terrain(offset=-0.25) {
+            terrain.samplerHeight=sampler(offset); floor_transform.setTranslation(0,offset,0);t64_announce_change(dataset,floor_entity);
+        },
+        overlap(enabled) {
+            if(enabled&&secondary===null) {const other=new Water();other.level.set(water.level.getValue()-0.4);
+                other.color.setRGB(0.65,0.1,0.25);secondary=build(new Entity().add(other));}
+            if(!enabled&&secondary!==null) {dataset.removeEntity(secondary);secondary=null;}
+        },
+        dispose() {entities.forEach(id=>{if(dataset.entityExists(id)) dataset.removeEntity(id);});batch.clear();},
+    };
+}

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

@@ -2678,6 +2678,10 @@ export class Renderer {
                 color_texture: current_color_out,
                 depth_texture: gr_texture_depth_current,
 
+                normal_texture: gr_texture_normal,
+                hzb_texture: gr_texture_hzb,
+                environment_texture: gr_texture_environment,
+
                 limits: this.graphics.collection_limits,
 
                 light_cluster_data: light_clusters.data,

package/src/shade/renderer/animation/chunk_pose_accumulator.d.ts

@@ -4,9 +4,8 @@
  * The importing shader binds:
  *   `var<storage, read_write> pose_accumulator: array<atomic<u32>>;`
  *
- * f32 atomic-add isn't native to WGSL. We implement it as a
- * `atomicCompareExchangeWeak` spin: load the current u32, reinterpret as
- * f32, add the contribution, reinterpret back, CAS. Contention is
+ * f32 atomic-add isn't native to WGSL. The shared `atomic_add_f32_storage`
+ * helper uses a compare-exchange retry loop over plain f32 bits. Contention is
  * typically low (each `(row, channel)` has 1–2 contributors in a
  * normalised blend), so the spin rarely loops more than once.
  *

package/src/shade/renderer/animation/chunk_pose_accumulator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_pose_accumulator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/chunk_pose_accumulator.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;GAiBG;AACH,qCAFU,SAAS,CAsGhB;0BAtIuB,iCAAiC"}
+{"version":3,"file":"chunk_pose_accumulator.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/chunk_pose_accumulator.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;GAgBG;AACH,qCAFU,SAAS,CA4FgB;0BA5HT,iCAAiC"}

package/src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAUA;;;;;;;GAOG;AACH,gCAAiC;AAsKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAIG;8BAjN2B,kCAAkC"}
+{"version":3,"file":"shader_meshlet_bounds_reduce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,gCAAiC;AAsKjC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAIG;8BAlN2B,kCAAkC"}

package/src/shade/renderer/light/environment/chunk_roughness_to_mip_ratio.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Input roughness is linear (blender calls it "UI roughness")
+ * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_lightprobe_sphere_mapping_lib.glsl#L102
+ * @type {CodeChunk}
+ */
+export const chunk_roughness_to_mip_ratio: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_roughness_to_mip_ratio.d.ts.map

package/src/shade/renderer/light/environment/chunk_roughness_to_mip_ratio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_roughness_to_mip_ratio.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/chunk_roughness_to_mip_ratio.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,2CAFU,SAAS,CAiBjB;0BAvBwB,oCAAoC"}

package/src/shade/renderer/light/environment/chunk_sphere_probe_roughness_to_lod.d.ts

@@ -1,9 +1,3 @@
-/**
- * Input roughness is linear (blender calls it "UI roughness")
- * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_lightprobe_sphere_mapping_lib.glsl#L102
- * @type {CodeChunk}
- */
-export const chunk_roughness_to_mip_ratio: CodeChunk;
 /**
  * Input roughness is linear (blender calls it "UI roughness")
  * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_lightprobe_sphere_mapping_lib.glsl#L102

package/src/shade/renderer/light/environment/chunk_sphere_probe_roughness_to_lod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sphere_probe_roughness_to_lod.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/chunk_sphere_probe_roughness_to_lod.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,2CAFU,SAAS,CAkBjB;AAEF;;;;GAIG;AACH,kDAFU,SAAS,CAajB;0BA1CwB,oCAAoC"}
+{"version":3,"file":"chunk_sphere_probe_roughness_to_lod.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/chunk_sphere_probe_roughness_to_lod.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,kDAFU,SAAS,CAajB;0BApBwB,oCAAoC"}

package/src/shade/renderer/particles/bounds/chunk_particle_bounds.d.ts

@@ -13,7 +13,7 @@
  *
  * ## Why f32 in the buffer, and not an order-preserving encoding
  *
- * `aabb_atomic_min_f32` / `aabb_atomic_max_f32` are the engine's, shared with the skinned-mesh
+ * `atomic_min_f32_storage` / `atomic_max_f32_storage` are the engine's, shared with the skinned-mesh
  * bounds refresh, and they CAS-spin over the plain float so the words are readable as floats at
  * every moment of the frame. The sign-flip encoding that would let `atomicMin` do it in one
  * instruction leaves the buffer in a form only a decoder understands, and the publish pass reads

package/src/shade/renderer/particles/bounds/chunk_particle_bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/bounds/chunk_particle_bounds.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,0CAFU,SAAS,CAwEyC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,8CAFU,SAAS,CA4CsC;0BApL/B,oCAAoC"}
+{"version":3,"file":"chunk_particle_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/bounds/chunk_particle_bounds.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,0CAFU,SAAS,CAwE8E;AAEjG;;;;;;;;;;;;;;;;GAgBG;AACH,8CAFU,SAAS,CA4CsC;0BArL/B,oCAAoC"}

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

@@ -34,6 +34,23 @@
  * channel without the method is always asked.
  */
 export type AVBOITSideChannel = {
+    /**
+     * Optional optics preparation before occupancy; at most one producer per view. Inputs are
+     * immutable opaque resources. The returned background is read by the one shared resolve.
+     * Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
+     */
+    avboit_prepare?: (args: {
+        graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext;
+        camera: number;
+        color_texture: number;
+        depth_texture: number;
+        normal_texture: number;
+        hzb_texture: number;
+        environment_texture: number;
+    }) => {
+        background_color?: number;
+    };
     /**
      * add the channel's slices to the occupancy bits; returns the bits'
      * handle after the write. `cluster_parameters` is the frame's depth curve (`avboit_build_depth_curve`).

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

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoCc,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAM9D,MAAM,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAC,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAI1E,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAM9D,MAAM,OAAO"}

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

@@ -34,6 +34,13 @@
  * channel without the method is always asked.
  *
  * @typedef {object} AVBOITSideChannel
+ * @property {(args: {graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
+ *     view_ctx: import("../../../view/GPUViewContext.js").GPUViewContext, camera: number,
+ *     color_texture: number, depth_texture: number, normal_texture: number,
+ *     hzb_texture: number, environment_texture: number}) => {background_color?: number}} [avboit_prepare]
+ *     Optional optics preparation before occupancy; at most one producer per view. Inputs are
+ *     immutable opaque resources. The returned background is read by the one shared resolve.
+ *     Keep prepared state per graph/camera, not on an entity or in a global current-view slot.
  * @property {(args: {
  *     graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph,
  *     camera: number,

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

@@ -0,0 +1,4 @@
+/** Stable lost throughput at tiny extinction; a fixed norm cutoff drops bright faint surfaces. */
+export const chunk_avboit_renormalization: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_renormalization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_renormalization.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_renormalization.js"],"names":[],"mappings":"AAEA,kGAAkG;AAClG,qDAOG;0BAVuB,uCAAuC"}

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

@@ -0,0 +1,11 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/** Stable lost throughput at tiny extinction; a fixed norm cutoff drops bright faint surfaces. */
+export const chunk_avboit_renormalization = CodeChunk.from(/* language=WGSL */ `
+fn avboit_renormalization(extinction: vec3f, norm: vec3f) -> vec3f {
+    let x = max(extinction, vec3f(0.0));
+    let small_loss = x * (1.0 - 0.5 * x + x * x / 6.0);
+    let loss = select(vec3f(1.0) - exp(-x), small_loss, x < vec3f(0.001));
+    return select(vec3f(0.0), min(loss / max(norm, vec3f(1e-20)), vec3f(65504.0)), norm > vec3f(0.0));
+}
+`);

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

@@ -0,0 +1,4 @@
+/** A covering RGB-throughput surface; the existing particle/scalar entry point stays unchanged. */
+export const chunk_avboit_rgb_contribution: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_rgb_contribution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_rgb_contribution.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_rgb_contribution.js"],"names":[],"mappings":"AAGA,mGAAmG;AACnG,sDAc8C;0BAlBpB,uCAAuC"}

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

@@ -0,0 +1,19 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_avboit_premultiplied_contribution } from "./chunk_avboit_premultiplied_contribution.js";
+
+/** A covering RGB-throughput surface; the existing particle/scalar entry point stays unchanged. */
+export const chunk_avboit_rgb_contribution = CodeChunk.from(/* language=WGSL */ `
+fn avboit_rgb_contribution(
+    radiance: vec3<f32>, self_transmittance: vec3<f32>,
+    front_transmittance: vec3<f32>, fog: vec4<f32>,
+) -> AVBOITContribution {
+    let t = clamp(self_transmittance, vec3<f32>(1e-6), vec3<f32>(1.0));
+    let loss = vec3<f32>(1.0) - t;
+    var out: AVBOITContribution;
+    out.color = vec4<f32>((radiance * fog.w + loss * fog.xyz) * front_transmittance, 0.0);
+    out.norm = vec4<f32>(loss * front_transmittance, 0.0);
+    out.extinction = vec4<f32>(-log(t), 0.0);
+    out.emission = vec4<f32>(0.0);
+    return out;
+}
+`, [chunk_avboit_premultiplied_contribution]);

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_avboit_splat_slice.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAuCjB;0BAzDwB,uCAAuC"}
+{"version":3,"file":"chunk_avboit_splat_slice.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_splat_slice.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,uCAFU,SAAS,CAyCjB;0BA3DwB,uCAAuC"}

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

@@ -21,12 +21,10 @@ import { chunk_avboit_pack_counts } from "./chunk_avboit_pack_counts.js";
 export const chunk_avboit_splat_slice = CodeChunk.from(
     //language=WGSL
     `
-fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
+fn avboit_splat_counts(column: u32, slice: i32, counts: vec3<u32>, texel: vec2<u32>) {
     let physical = i32(warp.physical_count);
     let s = clamp(slice, 0, physical - 1);
 
-    let counts = avboit_extinction_to_counts(extinction);
-
     if (all(counts == vec3<u32>(0u))) {
         return;
     }
@@ -50,6 +48,10 @@ fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec
         }
     }
 }
+
+fn avboit_splat_slice(column: u32, slice: i32, extinction: vec3<f32>, texel: vec2<u32>) {
+    avboit_splat_counts(column, slice, avboit_extinction_to_counts(extinction), texel);
+}
     `, [
         chunk_avboit_extinction_to_counts,
         chunk_avboit_overflows,

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

@@ -0,0 +1,4 @@
+/** Partition already quantized counts. Rounding two fractional extinctions can erase both. */
+export const chunk_avboit_split_counts: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_avboit_split_counts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_avboit_split_counts.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/chunk_avboit_split_counts.js"],"names":[],"mappings":"AAEA,8FAA8F;AAC9F,kDAIG;0BAPuB,uCAAuC"}

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

@@ -0,0 +1,8 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/** Partition already quantized counts. Rounding two fractional extinctions can erase both. */
+export const chunk_avboit_split_counts = CodeChunk.from(/* language=WGSL */ `
+fn avboit_split_counts(counts: vec3<u32>, fraction: f32) -> vec3<u32> {
+    return min(counts, vec3<u32>(vec3<f32>(counts) * clamp(fraction, 0.0, 1.0) + 0.5));
+}
+`);

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

@@ -164,7 +164,7 @@ export function avboit_create_accumulators(pass: FramePassBuilder, resolution: A
  *   sources of transparent fragments; the MBOIT orchestrator ignores them
  * @returns {number} resource ID of the composited color texture
  */
-export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, indirect_lighting_mode, avboit, side_channels, }: {
+export function graph_rasterize_meshes_transparent_avboit({ graph, buckets, view_ctx, viewport, depth_texture, color_texture, normal_texture, hzb_texture, environment_texture, limits, light_cluster_parameters, light_cluster_lookup, light_cluster_data, shadowmap_atlas, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, indirect_lighting_mode, avboit, side_channels, }: {
     graph: FrameGraph;
     buckets: number;
     view_ctx: GPUViewContext;

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

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IAtB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGU,sBAAsB,EAAzD,yBAAyB;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CA8RlB;+BAr8B8B,qBAAqB;0CA9BV,uCAAuC"}
+{"version":3,"file":"graph_rasterize_meshes_transparent_avboit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/graph_rasterize_meshes_transparent_avboit.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,oDAHW,UAAU,MAAM,CAAC,GACf,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;GAYG;AACH;IAT+B,KAAK;IACA,KAAK;IACd,MAAM,EAAtB,MAAM;IACqB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACD,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;IACW,SAAS,GAA1B,MAAM;IACJ,MAAM,CA4DlB;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,SAAS,EAAzB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACmB,kBAAkB,EAA7C,UAAU,MAAM,CAAC;IACQ,MAAM,GAA/B,cAAc;IACZ,MAAM,CAsDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,6KAFa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAiJjE;AAED;;;;;;;;;;GAUG;AACH;IAP+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,UAAU,EAA1B,MAAM;IACU,QAAQ,EAAxB,MAAM;IACY,gBAAgB,EAAlC,MAAM,EAAE;IACN,MAAM,CAoClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qUAFa;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAwN7D;AAED;;;;;;;;GAQG;AACH,+EAHW,UAAU,MAAM,CAAC,GACf;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAe/E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IAtB+B,KAAK;IACT,OAAO,EAAvB,MAAM;IACkB,QAAQ;IACd,QAAQ,EAA1B,MAAM,EAAE;IACQ,aAAa,EAA7B,MAAM;IACU,aAAa,EAA7B,MAAM;IACuB,MAAM;IACnB,wBAAwB,EAAxC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,eAAe,EAA/B,MAAM;IACU,oBAAoB,EAApC,MAAM;IAC6B,sBAAsB,EAAzD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAGU,sBAAsB,EAAzD,yBAAyB;IACA,MAAM,GAA/B,cAAc;IACiD,aAAa,GAA5E,OAAO,wBAAwB,EAAE,iBAAiB,EAAE;IAElD,MAAM,CAiTlB;+BAx9B8B,qBAAqB;0CA9BV,uCAAuC"}

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

@@ -724,6 +724,9 @@ export function graph_rasterize_meshes_transparent_avboit({
                                                               viewport,
                                                               depth_texture,
                                                               color_texture,
+                                                              normal_texture,
+                                                              hzb_texture,
+                                                              environment_texture,
                                                               limits,
                                                               light_cluster_parameters,
                                                               light_cluster_lookup,
@@ -809,7 +812,7 @@ export function graph_rasterize_meshes_transparent_avboit({
     const primitive_front = construct_primitive_state(ShadeDrawMode.Triangles, ShadeDrawSide.Front);
     const primitive_double = construct_primitive_state(ShadeDrawMode.Triangles, ShadeDrawSide.Double);
 
-    const gr_hzb = graph_import_texture(graph, view_ctx.hierarchical_z_buffer.texture);
+    const gr_hzb = hzb_texture ?? graph_import_texture(graph, view_ctx.hierarchical_z_buffer.texture);
     const gr_camera = graph_import_buffer(graph, view_ctx.camera.buffer.buffer);
 
     const voxel_resolution = avboit_voxel_resolution(view_ctx.resolution);
@@ -819,6 +822,22 @@ export function graph_rasterize_meshes_transparent_avboit({
     const camera = view_ctx.camera.camera;
     const cluster_parameters = avboit_build_depth_curve(camera.near, camera.far);
 
+    // A background producer transports only immutable opaque radiance. Reject ambiguity before
+    // recording any preparation rather than letting channel registration order choose a winner.
+    const preparers = side_channels.filter(channel => typeof channel.avboit_prepare === "function");
+    if (preparers.length > 1) {
+        throw new Error("AVBOIT supports one refractive background producer per view");
+    }
+    let background_color = color_texture;
+    for (const channel of preparers) {
+        const prepared = channel.avboit_prepare({ graph, view_ctx, camera: gr_camera, color_texture,
+            depth_texture, normal_texture, hzb_texture: gr_hzb, environment_texture });
+        if (prepared?.background_color !== undefined) {
+            assert.isNonNegativeInteger(prepared.background_color, 'prepared.background_color');
+            background_color = prepared.background_color;
+        }
+    }
+
     // Draw artifacts (shared with MBOIT)
     // ======
 
@@ -992,7 +1011,7 @@ export function graph_rasterize_meshes_transparent_avboit({
         shader: shader_avboit_resolve,
         output_resolution: view_ctx.resolution,
         inputs: {
-            tScene: color_texture,
+            tScene: background_color,
             tColor: accumulators.color,
             tNorm: accumulators.norm,
             tExtinction: accumulators.extinction,

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

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AA4EA,gDAUE;4BApF0B,gCAAgC"}
+{"version":3,"file":"shader_avboit_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_resolve.js"],"names":[],"mappings":"AAwEA,gDAUE;4BAhF0B,gCAAgC"}

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

@@ -3,6 +3,7 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { chunk_avboit_renormalization } from "./chunk_avboit_renormalization.js";
 
 const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
@@ -19,7 +20,7 @@ resources.createGroup()
  *
  * ```
  * T_total = exp(-Σ extinction)
- * norm    = Σ norm > ε ? (1 - T_total) / Σ norm : 0
+ * norm    = Σ norm > 0 ? stable_lost_throughput(Σ extinction) / Σ norm : 0
  * out     = scene × T_total + Σ color × norm + Σ emission
  * ```
  *
@@ -58,19 +59,14 @@ fn main(
     let total_transmittance = exp(-accum_extinction);
 
     // sum of (1 - T_self) * T at each fragment; zero where nothing transparent was drawn
-    let safe = accum_norm > vec3<f32>(1e-4);
-    let renormalization = select(
-        vec3<f32>(0.0),
-        (vec3<f32>(1.0) - total_transmittance) / max(accum_norm, vec3<f32>(1e-4)),
-        safe
-    );
+    let renormalization = avboit_renormalization(accum_extinction, accum_norm);
 
     let transparent = accum_color * renormalization;
 
     return vec4<f32>(scene.rgb * total_transmittance + transparent + accum_emission, scene.a);
 }
     `, [
-        chunk_is_nan
+        chunk_is_nan, chunk_avboit_renormalization
     ]
 )
 

package/src/shade/renderer/scene/shader_bvh_extract_instance_leaves.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAUA,4CAA6C;AAkH7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA7I2B,4BAA4B"}
+{"version":3,"file":"shader_bvh_extract_instance_leaves.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/shader_bvh_extract_instance_leaves.js"],"names":[],"mappings":"AAWA,4CAA6C;AAmH7C;;;;;;;;;;;;;;;;;GAiBG;AACH,iDAFU,aAAa,CAMpB;8BA9I2B,4BAA4B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 addition over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Each compare-exchange attempt adds to the current float value and writes the sum
+ * as plain f32 bits. Failed or spurious exchanges retry from a fresh atomic load,
+ * so concurrent additions are not lost.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_add_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_add_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_add_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAehB;0BAxBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 maximum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_max_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_max_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_max_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAkBhB;0BA3BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 minimum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_min_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_min_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_min_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAkBhB;0BA3BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/geometry/plane/{plane_ray_raycast.d.ts → chunk_plane_ray_raycast.d.ts}

@@ -2,6 +2,6 @@
  * Ported from meep
  * @type {CodeChunk}
  */
-export const plane_ray_raycast: CodeChunk;
+export const chunk_plane_ray_raycast: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=plane_ray_raycast.d.ts.map
+//# sourceMappingURL=chunk_plane_ray_raycast.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/plane/chunk_plane_ray_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_plane_ray_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/plane/chunk_plane_ray_raycast.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,sCAFU,SAAS,CA2Cf;0BA/CsB,gCAAgC"}

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.d.ts

@@ -0,0 +1,4 @@
+/** Mayer et al. 2026 tangent-plane refinement. All arithmetic is in matrix view space. */
+export const chunk_screen_space_newton_ray: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_screen_space_newton_ray.d.ts.map

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_screen_space_newton_ray.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.js"],"names":[],"mappings":"AAWA,0FAA0F;AAC1F,sDAwFkF;0BApGxD,6BAA6B"}