@woosh/meep-engine 3.36.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/chunk_pose_accumulator.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_atomic_add_f32_storage } from "../shader/chunk/atomic/chunk_atomic_add_f32_storage.js";
 import {
     POSE_ACCUMULATOR_OFFSET_DIRTY,
     POSE_ACCUMULATOR_OFFSET_ROTATION,
@@ -20,9 +21,8 @@ import {
  * 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.
  *
@@ -55,29 +55,19 @@ fn pose_accumulator_slot_base(row: u32) -> u32 {
     return row * POSE_ACCUMULATOR_STRIDE;
 }
 
-fn pose_accumulator_atomic_add_f32(word_index: u32, value: f32) {
-    loop {
-        let old_u = atomicLoad(&pose_accumulator[word_index]);
-        let new_f = bitcast<f32>(old_u) + value;
-        let new_u = bitcast<u32>(new_f);
-        let result = atomicCompareExchangeWeak(&pose_accumulator[word_index], old_u, new_u);
-        if result.exchanged { break; }
-    }
-}
-
 fn pose_accumulator_add_translation(row: u32, value: vec3<f32>, mask: u32) {
     let base = pose_accumulator_slot_base(row) + POSE_OFFSET_TRANSLATION;
     var dirty_bits: u32 = 0u;
     if (mask & 0x1u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 0u, value.x);
+        atomic_add_f32_storage(&pose_accumulator[base + 0u], value.x);
         dirty_bits |= POSE_DIRTY_TX;
     }
     if (mask & 0x2u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 1u, value.y);
+        atomic_add_f32_storage(&pose_accumulator[base + 1u], value.y);
         dirty_bits |= POSE_DIRTY_TY;
     }
     if (mask & 0x4u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 2u, value.z);
+        atomic_add_f32_storage(&pose_accumulator[base + 2u], value.z);
         dirty_bits |= POSE_DIRTY_TZ;
     }
     if dirty_bits != 0u {
@@ -106,10 +96,10 @@ fn pose_accumulator_add_rotation(row: u32, value: vec4<f32>, mask: u32, weight:
     let w = select(weight, value.w, (mask & 0x8u) != 0u);
 
     let base = pose_accumulator_slot_base(row) + POSE_OFFSET_ROTATION;
-    pose_accumulator_atomic_add_f32(base + 0u, value.x);
-    pose_accumulator_atomic_add_f32(base + 1u, value.y);
-    pose_accumulator_atomic_add_f32(base + 2u, value.z);
-    pose_accumulator_atomic_add_f32(base + 3u, w);
+    atomic_add_f32_storage(&pose_accumulator[base + 0u], value.x);
+    atomic_add_f32_storage(&pose_accumulator[base + 1u], value.y);
+    atomic_add_f32_storage(&pose_accumulator[base + 2u], value.z);
+    atomic_add_f32_storage(&pose_accumulator[base + 3u], w);
     atomicOr(&pose_accumulator[pose_accumulator_slot_base(row) + POSE_OFFSET_DIRTY], POSE_DIRTY_R);
 }
 
@@ -117,19 +107,19 @@ fn pose_accumulator_add_scale(row: u32, value: vec3<f32>, mask: u32) {
     let base = pose_accumulator_slot_base(row) + POSE_OFFSET_SCALE;
     var dirty_bits: u32 = 0u;
     if (mask & 0x1u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 0u, value.x);
+        atomic_add_f32_storage(&pose_accumulator[base + 0u], value.x);
         dirty_bits |= POSE_DIRTY_SX;
     }
     if (mask & 0x2u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 1u, value.y);
+        atomic_add_f32_storage(&pose_accumulator[base + 1u], value.y);
         dirty_bits |= POSE_DIRTY_SY;
     }
     if (mask & 0x4u) != 0u {
-        pose_accumulator_atomic_add_f32(base + 2u, value.z);
+        atomic_add_f32_storage(&pose_accumulator[base + 2u], value.z);
         dirty_bits |= POSE_DIRTY_SZ;
     }
     if dirty_bits != 0u {
         atomicOr(&pose_accumulator[pose_accumulator_slot_base(row) + POSE_OFFSET_DIRTY], dirty_bits);
     }
 }
-`);
+`, [chunk_atomic_add_f32_storage]);

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/animation/skinning/bounds_refresh/shader_meshlet_bounds_reduce.js

@@ -6,7 +6,8 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { SKINNING_BINDING_STRUCT } from "../SKINNING_BINDING_STRUCT.js";
-import { chunk_aabb_atomic_f32 } from "./chunk_aabb_atomic_f32.js";
+import { chunk_atomic_min_f32_storage } from "../../../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
+import { chunk_atomic_max_f32_storage } from "../../../shader/chunk/atomic/chunk_atomic_max_f32_storage.js";
 
 /**
  * Workgroup size — also the per-meshlet vertex stride. One thread per
@@ -113,7 +114,7 @@ fn main(
     // Note that the storage sentinels in \`meshlet.bounds_box\` and
     // \`geometry.bounding_box\` ARE true ±inf — the scatter pass
     // writes the u32 bit pattern directly via \`atomicStore\`, no
-    // const-fold involved, and \`aabb_atomic_min_f32\` bitcasts
+    // const-fold involved, and \`atomic_min_f32_storage\` bitcasts
     // back to f32 at runtime where ±inf is a valid value.
     var thread_min = vec3<f32>( 3.4028234e38);
     var thread_max = vec3<f32>(-3.4028234e38);
@@ -164,23 +165,23 @@ fn main(
         let final_max = wg_max[0];
 
         let m_bounds_base = m_base_words + MESHLET_BOUNDS_OFFSET;
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 0u], final_min.x);
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 1u], final_min.y);
-        aabb_atomic_min_f32(&meshlet_metadata_atomic[m_bounds_base + 2u], final_min.z);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 3u], final_max.x);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 4u], final_max.y);
-        aabb_atomic_max_f32(&meshlet_metadata_atomic[m_bounds_base + 5u], final_max.z);
+        atomic_min_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 0u], final_min.x);
+        atomic_min_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 1u], final_min.y);
+        atomic_min_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 2u], final_min.z);
+        atomic_max_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 3u], final_max.x);
+        atomic_max_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 4u], final_max.y);
+        atomic_max_f32_storage(&meshlet_metadata_atomic[m_bounds_base + 5u], final_max.z);
 
         let g_base = binding.clone_geometry_index * GEOMETRY_STRIDE + GEOMETRY_BBOX_OFFSET;
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 0u], final_min.x);
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 1u], final_min.y);
-        aabb_atomic_min_f32(&geometry_metadata_atomic[g_base + 2u], final_min.z);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 3u], final_max.x);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 4u], final_max.y);
-        aabb_atomic_max_f32(&geometry_metadata_atomic[g_base + 5u], final_max.z);
+        atomic_min_f32_storage(&geometry_metadata_atomic[g_base + 0u], final_min.x);
+        atomic_min_f32_storage(&geometry_metadata_atomic[g_base + 1u], final_min.y);
+        atomic_min_f32_storage(&geometry_metadata_atomic[g_base + 2u], final_min.z);
+        atomic_max_f32_storage(&geometry_metadata_atomic[g_base + 3u], final_max.x);
+        atomic_max_f32_storage(&geometry_metadata_atomic[g_base + 4u], final_max.y);
+        atomic_max_f32_storage(&geometry_metadata_atomic[g_base + 5u], final_max.z);
     }
 }
-`, [chunk_aabb_atomic_f32]);
+`, [chunk_atomic_min_f32_storage, chunk_atomic_max_f32_storage]);
 
 /**
  * Compute shader that reduces a clone meshlet's deformed vertex

package/src/shade/renderer/deferred/indirect/chunk_lpv_sample_light.js

@@ -1,7 +1,7 @@
 import {
     chunk_lpv_mesh_interpolate_radiance_via_atlas
 } from "../../global_illumination/probe/octahedral/sample/chunk_lpv_mesh_interpolate_radiance_via_atlas.js";
-import { chunk_roughness_to_mip_ratio } from "../../light/environment/chunk_sphere_probe_roughness_to_lod.js";
+import { chunk_roughness_to_mip_ratio } from "../../light/environment/chunk_roughness_to_mip_ratio.js";
 
 import {
     chunk_lpv_mesh_interpolate_probe_irradiance_pre