@woosh/meep-engine 3.37.0 → 3.39.0

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

@@ -0,0 +1,202 @@
+import ConcurrentExecutor from "../../../core/process/executor/ConcurrentExecutor.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import Quaternion from "../../../core/geom/Quaternion.js";
+import { AssetManager } from "../../../engine/asset/AssetManager.js";
+import { GameAssetType } from "../../../engine/asset/GameAssetType.js";
+import { ImageRGBADataLoader } from "../../../engine/asset/loaders/image/ImageRGBADataLoader.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { EntityManager } from "../../../engine/ecs/EntityManager.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { Light } from "../../../engine/graphics/ecs/light/Light.js";
+import { GPUParticleEmitterSystem } from "../../../engine/graphics3/GPUParticleEmitterSystem.js";
+import { GraphicsEngine } from "../../../engine/graphics3/GraphicsEngine.js";
+import { LightSystem } from "../../../engine/graphics3/LightSystem.js";
+import { ShadedGeometrySystem } from "../../../engine/graphics3/ShadedGeometrySystem.js";
+import { WaterSystem } from "../../../engine/graphics3/WaterSystem.js";
+import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { DynamicMeshAVBOITChannel } from "../../renderer/dynamic/DynamicMeshAVBOITChannel.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
+import { ShadeUpscalerType } from "../../renderer/ShadeUpscalerType.js";
+import { ParticipatingMediaVolume } from "../../renderer/volumetrics/ParticipatingMediaVolume.js";
+import { water_medium_preset } from "../../renderer/medium/water/water_presets.js";
+import { water_finalize_shader_brick4, water_finalize_shader_ibl, water_shader } from "../../renderer/water/shader_water.js";
+import * as water_shaders from "../../renderer/water/shader_water_avboit.js";
+import { install_profile_hotkey } from "../profile_hotkey.js";
+import { build_world } from "./world.js";
+
+const element = id => document.getElementById(id);
+const presets = {
+    shore: [[22,9,28],[16,0,15]], normal: [[12,17,12.01],[12,0,12]],
+    grazing: [[21,0.6,17],[12,0,12]], posts: [[8,3,20],[10,-0.5,14]],
+    edge: [[22,5,18],[23,0,11]], underwater: [[19,-0.8,18],[12,-1,12]],
+    discontinuities: [[18.946,7.002,6.28],[15.4,2.439,10.562]],
+};
+const input_ids = ["preset","enabled","level","ior","wind","wind_direction","roughness","medium","segments",
+    "reflection","layer_height","opacity","particles","ribbon","animate",
+    "overlap","warp_steps","mode","iterations","fallback","temporal","resolution","ssr","fog","transparency","debug"];
+const initial_inputs = Object.fromEntries(input_ids.map(id => [id,element(id).type === "checkbox" ? element(id).checked : element(id).value]));
+const number = id => Number(element(id).value);
+const checked = id => element(id).checked;
+
+async function main() {
+    const viewport = element("viewport"), graphics = new GraphicsEngine(), scene = new Scene();
+    viewport.appendChild(graphics.viewport.el);
+    const assets = new AssetManager({context:{},executor:new ConcurrentExecutor()});
+    await assets.registerLoader(GameAssetType.Image,new ImageRGBADataLoader()); assets.startup();
+    const dataset = new EntityComponentDataset(), entities = new EntityManager();
+    const water_system = new WaterSystem(graphics);
+    entities.addSystem(new ShadedGeometrySystem(graphics,scene)); entities.addSystem(new LightSystem(graphics,scene));
+    entities.addSystem(new GPUParticleEmitterSystem(graphics,scene,assets)); entities.addSystem(water_system);
+    entities.attachDataset(dataset);
+    await new Promise((resolve,reject) => entities.startup(resolve,reject));
+    const world = await build_world(dataset), channel = new DynamicMeshAVBOITChannel(world.batch);
+    graphics.add_transparency_channel(channel);
+    const sun = new Light(); sun.intensity.set(2.2);
+    const sun_pose = new Transform64(), rotation = new Quaternion();
+    rotation.fromUnitVectors(Vector3.forward,new Vector3(-0.3,-1,0.2).normalize());
+    sun_pose.setRotation(rotation.x,rotation.y,rotation.z,rotation.w);sun_pose.updateMatrix();
+    const sun_entity = new Entity().add(sun).add(sun_pose);sun_entity.build(dataset);
+    const camera = graphics.camera.camera, controller = new OrbitalCameraController(camera,viewport);
+    camera.near=0.1;camera.far=300;camera.fov=Math.PI/3;
+    const look = key => controller.look(new Vector3(...presets[key][0]),new Vector3(...presets[key][1]));
+    look("shore");
+    let ready=false,paused=false,step=false,time=0,profile=null,stop_loop=null,swapped=false,terrain_offset=0,revision=0;
+    const fog = new ParticipatingMediaVolume();fog.target_extinction=0.015;
+    fog.transform.setScale(80,40,80);fog.transform.setTranslation(16,0,16);fog.transform.updateMatrix();
+    let fog_added=false;
+    const report = message => {element("status").textContent=message;};
+    graphics.on.contextFailed.add(error => report(error.message));
+    graphics.on.contextLost.add(error => {ready=false;report(`GPU device lost · ${error.message} · use Restart device`);});
+    function configure() {
+        revision++;
+        const w=world.water,s=water_system.settings,r=graphics.renderer;
+        w.level.set(number("level"));w.ior.set(number("ior"));w.roughness.set(number("roughness"));
+        world.waves.windSpeed.set(number("wind"));world.waves.windDirection.set(number("wind_direction")*Math.PI/180);
+        w.medium=water_medium_preset({preset:element("medium").value});
+        Object.assign(s,{enabled:checked("enabled"),mode:number("mode"),max_updates:number("iterations"),
+            inscatter_segments:number("segments"),
+            fallback_steps:number("fallback"),reflections:checked("reflection")?1:0,debug_view:number("debug")});
+        world.card.component.material.diffuse_color.a=number("opacity");
+        world.effects.forEach(effect=>effect.emitting=checked("particles"));world.ribbon.visible=checked("ribbon");
+        world.overlap(checked("overlap"));
+        if(checked("fog")&&!fog_added){scene.volumetrics.add(fog);fog_added=true;}
+        if(!checked("fog")&&fog_added){scene.volumetrics.remove(fog);fog_added=false;}
+        if(r!==null&&r!==undefined){
+            r.transparency_mode=element("transparency").value==="avboit"?ShadeTransparencyMode.AVBOIT:ShadeTransparencyMode.MBOIT;
+            r.avboit.warp_steps_per_octave=checked("warp_steps")?4:1;
+            r.feature_taa_enabled=element("temporal").value!=="off";
+            r.upscale_type=element("temporal").value==="nss"?ShadeUpscalerType.NSS:ShadeUpscalerType.TAA;
+            r.feature_ssr_enabled=checked("ssr");r.pixel_ratio=number("resolution");
+            r.feature_automatic_exposure_enabled=false;r.exposure_compensation=0;
+            r.feature_bloom_enabled=false;r.feature_ssao_enabled=false;
+        }
+        element("probe").textContent="Settings changed — Shift-click to inspect a fresh pixel.";
+        if(element("transparency").value!=="avboit")report("MBOIT · water, particles and ribbons are unavailable");
+        else if(!s.enabled)report("Water disabled · shared transparency remains active");
+        else if(element("preset").value==="underwater")report("Below interface · bounded tint control; underwater transport is unsupported");
+        else report("Ready · one water interface · shared AVBOIT");
+    }
+    async function start_device() {
+        ready=false;profile?.dispose();await graphics.start();configure();
+        const renderer=graphics.renderer;
+        profile=install_profile_hotkey({renderer,name:"water_refraction",status:element("status"),target:viewport,
+            settings:()=>[element("mode").selectedOptions[0].textContent,`${number("iterations")} updates`,`${number("fallback")} fallback`,element("temporal").value]});
+        let validation_failed=false;
+        renderer.graphics.device.addEventListener("uncapturederror",event=>{
+            if(validation_failed)return;
+            validation_failed=true;ready=false;report(event.error.message);console.error(event.error.message);
+        });
+        ready=true;report("Ready · one water interface · shared AVBOIT");
+    }
+    function state() {
+        const t=camera.transform;
+        return {version:1,inputs:Object.fromEntries(input_ids.map(id=>[id,element(id).type==="checkbox"?checked(id):element(id).value])),
+            camera:{position:[t.translation_x,t.translation_y,t.translation_z],target:[controller.target.x,controller.target.y,controller.target.z]},
+            time,paused,terrain_offset,swapped};
+    }
+    function apply_state(value) {
+        if(value.version!==1)throw new Error("Unsupported state version");
+        for(const id of input_ids){const el=element(id),v=value.inputs?.[id];if(v===undefined)continue;
+            if(el.type==="checkbox")el.checked=!!v;
+            else if(el.type==="range"||el.type==="number"){
+                const n=Number(v);if(!Number.isFinite(n))throw new Error(`Invalid ${id}`);
+                el.value=Math.max(Number(el.min),Math.min(Number(el.max),n));
+            }else if(el.tagName==="SELECT"){
+                if(![...el.options].some(o=>o.value===String(v)))throw new Error(`Invalid ${id}`);el.value=v;
+            }else if(/^#[0-9a-f]{6}$/i.test(v))el.value=v;
+        }
+        const vector=v=>{if(!Array.isArray(v)||v.length!==3||!v.every(Number.isFinite))throw new Error("Invalid camera");return new Vector3(...v);};
+        controller.look(vector(value.camera.position),vector(value.camera.target));
+        if(!Number.isFinite(value.time)||value.time<0)throw new Error("Invalid time");
+        time=value.time;water_system.time=time;paused=!!value.paused;
+        terrain_offset=Number(value.terrain_offset)||0;world.replace_terrain(terrain_offset);
+        if(!!value.swapped!==swapped)swap_order();
+        configure();element("pause").textContent=paused?"Resume":"Pause";
+    }
+    function swap_order() {
+        graphics.remove_transparency_channel(channel);graphics.remove_transparency_channel(water_system.transparency_channel);
+        swapped=!swapped;
+        (swapped?[channel,water_system.transparency_channel]:[water_system.transparency_channel,channel]).forEach(c=>graphics.add_transparency_channel(c));
+    }
+    input_ids.forEach(id=>element(id).addEventListener("input",configure));
+    element("preset").addEventListener("change",()=>{look(element("preset").value);configure();});
+    element("pause").onclick=()=>{paused=!paused;element("pause").textContent=paused?"Resume":"Pause";};
+    element("step").onclick=()=>{paused=true;step=true;element("pause").textContent="Resume";};
+    element("reset").onclick=()=>{world.reset_particles();apply_state({version:1,inputs:initial_inputs,
+        camera:{position:presets.shore[0],target:presets.shore[1]},time:0,paused:false,terrain_offset:0,swapped:false});};
+    element("order").onclick=swap_order;
+    element("terrain").onclick=()=>{terrain_offset=terrain_offset===0?-0.25:0;world.replace_terrain(terrain_offset);};
+    element("restart").onclick=async()=>{try{ready=false;graphics.stop();await start_device();}catch(error){report(error.message);}};
+    element("profile").onclick=()=>profile?.toggle().catch(error=>report(error.message));
+    element("copy").onclick=async()=>{const json=JSON.stringify(state(),null,2);element("state").value=json;
+        try{await navigator.clipboard.writeText(json);}catch{/* Text remains available for manual copying. */}};
+    element("apply").onclick=()=>{try{apply_state(JSON.parse(element("state").value));}catch(error){report(error.message);}};
+    element("compile").onclick=async()=>{
+        if(!ready)return;
+        const device=graphics.renderer.graphics.device,errors=[];
+        for(const shader of [water_shader,water_finalize_shader_ibl,water_finalize_shader_brick4,...Object.values(water_shaders).map(s=>s.descriptor)]){
+            if(typeof shader?.source!=="string")continue;
+            const module=device.createShaderModule({code:shader.source});const info=await module.getCompilationInfo();
+            errors.push(...info.messages.filter(m=>m.type==="error").map(m=>`${m.lineNum}: ${m.message}`));
+        }
+        report(errors.length?errors.join("\n"):"Water shader modules compiled successfully.");
+    };
+    let probe_pending=false;
+    viewport.addEventListener("click",async event=>{
+        if(!event.shiftKey||!ready||probe_pending)return;
+        if(!checked("enabled")||element("transparency").value!=="avboit"){element("probe").textContent="Enable AVBOIT water before inspecting.";return;}
+        const rect=viewport.getBoundingClientRect();probe_pending=true;
+        const probe_revision=revision,probe_camera=JSON.stringify(state().camera);
+        try{const result=await water_system.request_probe([(event.clientX-rect.left)/rect.width,(event.clientY-rect.top)/rect.height]);
+            const packed=result.receiver[3],code=Math.floor(packed);
+            const classification=result.transmission[3]<=0?"no water coverage":code===31?"below-interface control":
+                ["Newton hit","HZB hit","undisplaced fallback","bounded sky"][Math.floor(code/8)]??"invalid";
+            const reason=["none / not attempted","bounds / clip","sky","parallel / invalid","ray interval","budget / residual"][code%8];
+            element("probe").textContent=JSON.stringify({...result,
+                stale:revision!==probe_revision||JSON.stringify(state().camera)!==probe_camera,
+                classification,newton_reason:code===31?"unsupported view":reason,
+                newton_updates:Math.round((packed-code)*32)},null,2);
+        }catch(error){element("probe").textContent=error.message;}finally{probe_pending=false;}
+    });
+    Object.assign(globalThis,{graphics,scene,dataset,entities,world,water_system,camera,controller,
+        water_playground:{state,apply_state,get ready(){return ready;}}});
+    await start_device();
+    function frame(raw_dt) {
+        if(!ready)return;
+        const dt=step?1/60:paused?0:Math.min(raw_dt,0.05);step=false;time+=dt;
+        graphics.viewport.size.set(Math.max(1,viewport.clientWidth),Math.max(1,viewport.clientHeight));
+        controller.update();world.update(time,{layer_height:number("layer_height"),animate:checked("animate")});
+        entities.update(dt);graphics.render(dt);
+    }
+    stop_loop=create_frame_loop(frame,60);
+    globalThis.water_playground.frame=frame;
+    window.addEventListener("pagehide",()=>{
+        ready=false;stop_loop?.();profile?.dispose();world.dispose();dataset.removeEntity(sun_entity.id);
+        channel.release(world.ribbon.geometry);graphics.remove_transparency_channel(channel);
+        entities.shutdown(()=>{},console.error);controller.pointer.stop();controller.keyboard.stop();graphics.stop();
+    },{once:true});
+}
+main().catch(error=>{console.error(error);element("status").textContent=error.message;});

package/src/shade/playground/water_refraction/world.d.ts

@@ -0,0 +1,39 @@
+/** All visible static content uses ordinary ECS meshlets; water owns no demo-specific pass. */
+export function build_world(dataset: any): Promise<{
+    terrain: Terrain;
+    water: Water;
+    waves: WaterWaves;
+    water_entity: any;
+    card: {
+        transform: Transform64;
+        component: ShadedGeometry;
+        entity: any;
+    };
+    submerged: {
+        transform: Transform64;
+        component: ShadedGeometry;
+        entity: any;
+    };
+    batch: DynamicMeshBatch;
+    ribbon: DynamicMesh;
+    effects: ParticleEffect[];
+    entities: any[];
+    reset_particles(): void;
+    update(time: any, { layer_height, animate }?: {
+        layer_height?: number;
+        animate?: boolean;
+    }): void;
+    replace_terrain(offset?: number): void;
+    overlap(enabled: any): void;
+    dispose(): void;
+}>;
+export function height_at(x: any, z: any, offset?: number): number;
+import Terrain from "../../../engine/ecs/terrain/ecs/Terrain.js";
+import Water from "../../../engine/graphics/ecs/water/Water.js";
+import WaterWaves from "../../../engine/graphics/ecs/water/WaterWaves.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import { ShadedGeometry } from "../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { DynamicMeshBatch } from "../../renderer/scene/DynamicMeshBatch.js";
+import { DynamicMesh } from "../../renderer/scene/DynamicMesh.js";
+import { ParticleEffect } from "../../../engine/graphics/ecs/particles/ParticleEffect.js";
+//# sourceMappingURL=world.d.ts.map

package/src/shade/playground/water_refraction/world.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/water_refraction/world.js"],"names":[],"mappings":"AA4DA,+FAA+F;AAC/F;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EC;AA9GM,mEAAsE;oBAzBzD,4CAA4C;kBAI9C,6CAA6C;uBACxC,kDAAkD;4BAJ7C,8CAA8C;+BAE3C,wDAAwD;iCAetD,0CAA0C;4BAD/C,qCAAqC;+BAXlC,0DAA0D"}

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

@@ -0,0 +1,141 @@
+import { Color } from "../../../core/color/Color.js";
+import { water_medium_preset } from "../../renderer/medium/water/water_presets.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 WaterWaves from "../../../engine/graphics/ecs/water/WaterWaves.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);
+    // the primitive wave simulation's forcing; the overlapping second body below has none and stays calm
+    const waves=new WaterWaves();
+    const water_entity=build(new Entity().add(water).add(waves));
+    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,waves,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.medium=water_medium_preset({preset:'turbid_river'});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

@@ -73,6 +73,8 @@ export class Renderer {
     feature_tetrahedron_point_shadows: boolean;
     set shadow_update_budget(v: number);
     get shadow_update_budget(): number;
+    set shadow_cascade_count(v: number);
+    get shadow_cascade_count(): number;
     feature_bloom_enabled: boolean;
     feature_automatic_exposure_enabled: boolean;
     set exposure_compensation(v: number);

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

@@ -77,6 +77,7 @@ import { graph_import_buffer } from "./shader/graph/graph_import_buffer.js";
 import { graph_import_texture } from "./shader/graph/graph_import_texture.js";
 import { ShadeUpscalerType } from "./ShadeUpscalerType.js";
 import { DEFAULT_SHADOWMAP_UPDATE_BUDGET } from "./shadow/map/DEFAULT_SHADOWMAP_UPDATE_BUDGET.js";
+import { SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT } from "./shadow/map/csm/SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT.js";
 import { CascadedSceneSDF } from "./shadow/sdf/cascade/CascadedSceneSDF.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "./STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { GPUTextureContext } from "./texture/GPUTextureContext.js";
@@ -250,6 +251,26 @@ export class Renderer {
         return this.#shadow_update_budget;
     }
 
+    /**
+     * How many cascades a directional light's shadow map is split into, pushed to the scene's
+     * shadow context each frame; see {@link GPUSceneShadowmapContext.cascade_count}. More cascades
+     * put more shadow texels near the camera at the cost of a rasterization pass each. A change
+     * rebuilds every directional map, and its near planes come back loose for the two frames its
+     * caster range takes to be measured again.
+     * @type {number}
+     */
+    #shadow_cascade_count = SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT;
+
+    set shadow_cascade_count(v) {
+        assert.isPositiveInteger(v, 'shadow_cascade_count');
+
+        this.#shadow_cascade_count = v;
+    }
+
+    get shadow_cascade_count() {
+        return this.#shadow_cascade_count;
+    }
+
     feature_bloom_enabled = true;
     feature_automatic_exposure_enabled = true;
 
@@ -2093,6 +2114,8 @@ export class Renderer {
         sm.use_tetrahedron_point_shadows = this.feature_tetrahedron_point_shadows;
         // How many views the refresh scheduler may spend on this scene this frame.
         sm.update_budget = this.#shadow_update_budget;
+        // How many cascades a directional map has; a change rebuilds the maps inside process_lights.
+        sm.cascade_count = this.#shadow_cascade_count;
 
         const taa = this.#taa;
 
@@ -2678,6 +2701,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/dynamic/shader_dynamic_mesh_avboit_draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAyF1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCA5IjB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}
+{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AA+F1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCApJjB,8DAA8D;4CAY3D,mDAAmD;iCAC9D,+BAA+B"}

package/src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js

@@ -7,6 +7,8 @@ import { AVBOIT_DRAW_TARGETS } from "../rasterize/native/avboit/avboit_draw_frag
 import {
     chunk_avboit_premultiplied_contribution
 } from "../rasterize/native/avboit/chunk_avboit_premultiplied_contribution.js";
+import { chunk_avboit_view_depth_to_virtual } from "../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
+import { chunk_avboit_footprint_bias } from "../rasterize/native/avboit/chunk_avboit_footprint_bias.js";
 import { chunk_avboit_sample_transmittance } from "../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -78,6 +80,10 @@ fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) draw_index
 
 @fragment
 fn fs_main(in : DynamicMeshAVBOITVertexOut) -> DynamicMeshAVBOITDrawOutput {
+    // a ribbon seen at an angle runs through depth across a voxel; see avboit_footprint_bias. Taken
+    // first, in uniform control flow
+    let footprint = avboit_footprint_bias(&warp, fwidth(avboit_view_depth_to_virtual(&warp, in.view_depth)));
+
     if (in.color.a <= 0.0) {
         // faded out: covers nothing, and straight alpha carries no light without coverage
         discard;
@@ -85,7 +91,7 @@ fn fs_main(in : DynamicMeshAVBOITVertexOut) -> DynamicMeshAVBOITDrawOutput {
 
     let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
 
-    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, in.view_depth);
+    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, in.view_depth, footprint);
 
     if (all(transmittance <= vec3<f32>(${AVBOIT_EXTINCT_TRANSMITTANCE}))) {
         // nothing this fragment contributes survives what is in front of it; skip the shading
@@ -109,6 +115,8 @@ fn fs_main(in : DynamicMeshAVBOITVertexOut) -> DynamicMeshAVBOITDrawOutput {
 }
 `, [
     chunk_dynamic_mesh_avboit_vertex,
+    chunk_avboit_view_depth_to_virtual,
+    chunk_avboit_footprint_bias,
     chunk_avboit_sample_transmittance,
     chunk_sample_volumetrics,
     chunk_avboit_premultiplied_contribution,

package/src/shade/renderer/geometry/sdf/chunk_scene_point_query_volume_sign.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_scene_point_query_volume_sign.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_scene_point_query_volume_sign.js"],"names":[],"mappings":"AAoBA,4DAoEE;0BA5EwB,oCAAoC"}
+{"version":3,"file":"chunk_scene_point_query_volume_sign.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_scene_point_query_volume_sign.js"],"names":[],"mappings":"AAoBA,4DAsEE;0BA9EwB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_scene_point_query_volume_sign.js

@@ -9,7 +9,7 @@ import { chunk_ray_query_nearest } from "../../shader/chunk/geometry/ray/chunk_r
 import { RAY_STRUCT } from "../../shader/chunk/geometry/ray/RAY_STRUCT.js";
 import { chunk_sphere_fibonacci_point } from "../../shader/chunk/geometry/sphere/chunk_sphere_fibonacci_point.js";
 import { chunk_f32_array_as_vec3 } from "../../shader/chunk/geometry/vec3/chunk_f32_array_as_vec3.js";
-import { chunk_v3_matrix4_rotate } from "../../shader/chunk/geometry/vec3/chunk_v3_matrix4_rotate.js";
+import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 
 /**
@@ -57,10 +57,12 @@ fn scene_point_query_volume_sign(position_ws: vec3<f32>, max_distance: f32) -> f
         
         let normal = compute_triangle_face_normal(a,b,c);
         
-        // localize ray direction
+        // into the world by the normal matrix, not the instance matrix: under a non-uniform scale
+        // the two tilt a slanted face's normal opposite ways. Only its side is wanted, so it stays
+        // unnormalized
         let mesh = scene_read_mesh(&scene_database, hit.instance);
         let node = scene_read_node(&scene_database, mesh.node);
-        let normal_ws = v3_matrix4_rotate(normal, node.global);
+        let normal_ws = compute_normal_matrix_from_m4(node.global) * normal;
         
         if(dot(normal_ws, ray.direction) > 0.0){
             // back-facing
@@ -83,7 +85,7 @@ fn scene_point_query_volume_sign(position_ws: vec3<f32>, max_distance: f32) -> f
         chunk_geometry_read_triangle_vertices,
         chunk_f32_array_as_vec3,
         chunk_compute_triangle_face_normal,
-        chunk_v3_matrix4_rotate,
+        chunk_compute_normal_matrix_from_m4,
         chunk_scene_database_access,
     ]
 );

package/src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brick4_bake_basic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js"],"names":[],"mappings":"AAoCA;;;;;;;GAOG;AACH;IAL2C,MAAM;IACb,QAAQ;IACT,GAAG;IACF,KAAK;yBAkMxC"}
+{"version":3,"file":"brick4_bake_basic.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js"],"names":[],"mappings":"AAoCA;;;;;;;GAOG;AACH;IAL2C,MAAM;IACb,QAAQ;IACT,GAAG;IACF,KAAK;yBAmMxC"}

package/src/shade/renderer/global_illumination/brick4/gpu/bake/brick4_bake_basic.js

@@ -156,6 +156,7 @@ export async function brick4_bake_basic({
                 },
 
                 materials: r_materials.buffer_materials,
+                media: r_materials.buffer_media,
                 textures: r_materials.textureView,
 
                 //

package/src/shade/renderer/global_illumination/brick4/gpu/bake/sampling/chunk_direction_by_index_rand1.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Fibonacci point `index` of `limit`, turned by a frame around a uniformly random axis.
+ *
+ * The axis must be uniform on the sphere: the resolve buckets samples by contiguous index, which is a
+ * latitude band in the frame, and only an isotropic axis makes every band isotropic in the world.
+ * @type {CodeChunk}
+ */
 export const chunk_direction_by_index_rand1: CodeChunk;
 import { CodeChunk } from "../../../../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_direction_by_index_rand1.d.ts.map

package/src/shade/renderer/global_illumination/brick4/gpu/bake/sampling/chunk_direction_by_index_rand1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_direction_by_index_rand1.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/sampling/chunk_direction_by_index_rand1.js"],"names":[],"mappings":"AAaA,uDAuBC;0BAzByB,6CAA6C"}
+{"version":3,"file":"chunk_direction_by_index_rand1.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/global_illumination/brick4/gpu/bake/sampling/chunk_direction_by_index_rand1.js"],"names":[],"mappings":"AAUA;;;;;;GAMG;AACH,6CAFU,SAAS,CAqBlB;0BA5ByB,6CAA6C"}