@woosh/meep-engine 3.57.0 → 3.58.0

package/src/shade/renderer/shader/chunk/sdf/chunk_scene_sdf_raymarch.js

@@ -1,5 +1,6 @@
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
-import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { chunk_mesh_sdf_raymarch } from "../../../geometry/sdf/chunk_mesh_sdf_raymarch.js";
+import { chunk_mesh_sdf_header } from "../../../geometry/sdf/chunk_mesh_sdf_sample.js";
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { BVH_NULL_NODE_DEFINITION } from "../bvh/BVH_NULL_NODE_DEFINITION.js";
 import { BVH_TRAVERSAL_STACK_SIZE } from "../bvh/BVH_TRAVERSAL_STACK_SIZE.js";
@@ -7,25 +8,40 @@ import { BVH_TRAVERSAL_STACK_SIZE } from "../bvh/BVH_TRAVERSAL_STACK_SIZE.js";
 import { chunk_aabb3_distance_to_ray } from "../geometry/aabb3/chunk_aabb3_distance_to_ray.js";
 import { chunk_aabb3_unsigned_distance_to_point } from "../geometry/aabb3/chunk_aabb3_unsigned_distance_to_point.js";
 import { chunk_array_to_aabb3 } from "../geometry/aabb3/chunk_array_to_aabb3.js";
-import { chunk_mat4_extract_scale } from "../geometry/mat4/chunk_mat4_extract_scale.js";
 import { chunk_mat4_inverse } from "../geometry/mat4/chunk_mat4_inverse.js";
 import { chunk_ray_transform_m4 } from "../geometry/ray/chunk_ray_transform_m4.js";
 import { RAY_STRUCT } from "../geometry/ray/RAY_STRUCT.js";
-import { chunk_max_v3 } from "../geometry/vec3/chunk_max_v3.js";
 import { F32_MAX_DEFINITION } from "../math/F32_MAX_DEFINITION.js";
-import { chunk_sdf_raymarch } from "./chunk_sdf_texture_raycast.js";
-import { chunk_sdf_texture_region_sample_linear_uv } from "./chunk_sdf_texture_region_sample_linear_uv.js";
 
-export const chunk_scene_sdf_raymarch = CodeChunk.from(
+/**
+ * The nearest hit of a ray through the meshes' fields, and the `meshes` row it is on:
+ *
+ * ```wgsl
+ * fn scene_sdf_raymarch_hit(ray: Ray) -> SceneSDFHit // t = F32_MAX for none
+ * ```
+ *
+ * The TLAS is walked nearest box first; in every instance it meets, the ray marches that geometry's
+ * sparse field at level 0 in its local space, whose t is the world one.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_scene_sdf_raymarch_hit = CodeChunk.from(
     //language=WGSL
     `
-fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
+struct SceneSDFHit {
+    t: f32,
+    mesh: u32,
+}
+
+fn scene_sdf_raymarch_hit(ray:${RAY_STRUCT.wgsl_ref}) -> SceneSDFHit{
     var node_index = tlas.root;
 
     var stack:array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
     var pointer  = 1u;
         
-    var best_distance = F32_MAX;
+    var best: SceneSDFHit;
+
+    best.t = F32_MAX;
         
     for(;pointer > 0 && pointer <= ${BVH_TRAVERSAL_STACK_SIZE};){
             
@@ -33,7 +49,7 @@ fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
         
         let distance_to_node = aabb_distance_to_ray(node.bounds, ray);
         
-        if(distance_to_node > best_distance){
+        if(distance_to_node > best.t){
             
             pointer --;
             node_index = stack[pointer];
@@ -64,31 +80,25 @@ fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
             let mesh = scene_read_mesh(&scene_database, mesh_id);
             let node = scene_read_node(&scene_database, mesh.node);
 
-            let geometry_ray = ray_transform_m4(ray, mat4_inverse(node.global));
+            /*
+             The ray enters the instance with its direction made unit there, so a hit's parameter
+             there is in the instance's units: a stretch of the world's, the length of the world
+             direction under the inverse. Over the stretch it is a world distance again.
+            */
+            let to_local = mat4_inverse(node.global);
+            let geometry_ray = ray_transform_m4(ray, to_local);
+            let stretch = length((to_local * vec4<f32>(ray.direction, 0.0)).xyz);
 
-            let geometry = geometries[mesh.geometry];
+            let local_t = mesh_sdf_raymarch(mesh_sdf_header(mesh.geometry), 0u, geometry_ray);
+            let distance = select(local_t / stretch, -1.0, local_t < 0.0);
 
-            let geometry_bounds = array_to_aabb3(geometry.bounding_box);
-            let geometry_bounds_span = geometry_bounds.max - geometry_bounds.min;
-
-            // normalize position
-
-            let offset = tile_atlas_slot_origin(mesh.geometry, settings.sdf_atlas_resolution.xy, vec3(settings.sdf_tile_resolution));
-            let geometry_distance = sdf_raymarch(geometry_ray, texture_sdf,  offset,  vec3(settings.sdf_tile_resolution));
-
-            // move point to world-space
-
-            let geometry_scale = max_v3( mat4_extract_scale(node.global) );
-            
-            // re-scale distance
-            let distance = geometry_scale * geometry_distance;
-            
-            if(distance >= best_distance){
+            if(distance < 0.0 || distance >= best.t){
                 continue;
             }
             
             // found a good hit
-            best_distance = distance;
+            best.t = distance;
+            best.mesh = mesh_id;
             
             
         }
@@ -96,21 +106,39 @@ fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
     }
         
        
-    return best_distance;
+    return best;
 }
     `, [
         BVH_NULL_NODE_DEFINITION,
-        chunk_max_v3,
-        chunk_mat4_extract_scale,
         chunk_mat4_inverse,
         chunk_aabb3_distance_to_ray,
         chunk_aabb3_unsigned_distance_to_point,
-        chunk_tile_atlas_slot_origin,
-        chunk_sdf_texture_region_sample_linear_uv,
         chunk_array_to_aabb3,
         chunk_ray_transform_m4,
         F32_MAX_DEFINITION,
-        chunk_sdf_raymarch,
+        chunk_mesh_sdf_header,
+        chunk_mesh_sdf_raymarch,
         chunk_scene_database_access,
     ]
+);
+
+/**
+ * {@link chunk_scene_sdf_raymarch_hit}'s distance alone:
+ *
+ * ```wgsl
+ * fn scene_sdf_raymarch(ray: Ray) -> f32 // F32_MAX for no hit
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_scene_sdf_raymarch = CodeChunk.from(
+    //language=WGSL
+    `
+fn scene_sdf_raymarch(ray:${RAY_STRUCT.wgsl_ref}) -> f32{
+    return scene_sdf_raymarch_hit(ray).t;
+}
+    `, [
+        RAY_STRUCT.declaration_chunk,
+        chunk_scene_sdf_raymarch_hit,
+    ]
 );

package/src/shade/renderer/shader/compiler/CodeChunk.d.ts

@@ -26,7 +26,7 @@ export class CodeChunk {
      * @param {Map<CodeChunk, CodeChunk>} memo what each chunk of this call's graph became
      * @returns {CodeChunk}
      */
-    static "__#77@#specialize"(chunk: CodeChunk, set: ShaderSwitchSet, memo: Map<CodeChunk, CodeChunk>): CodeChunk;
+    static "__#78@#specialize"(chunk: CodeChunk, set: ShaderSwitchSet, memo: Map<CodeChunk, CodeChunk>): CodeChunk;
     get isCodeChunk(): boolean;
     /**
      *

package/src/shade/renderer/shader/compiler/ShaderSwitch.d.ts

@@ -26,7 +26,7 @@ export class ShaderSwitch {
      * @param {number|boolean} default_value
      * @returns {ShaderSwitch}
      */
-    static "__#75@#make"(label: string, values: ReadonlyArray<number | boolean>, names: ReadonlyArray<string>, default_value: number | boolean): ShaderSwitch;
+    static "__#76@#make"(label: string, values: ReadonlyArray<number | boolean>, names: ReadonlyArray<string>, default_value: number | boolean): ShaderSwitch;
     /**
      * A switch over the members of an engine enum: a plain object of names to distinct integers, one of
      * which is `0` — the value every switch has until a set says otherwise.

package/src/shade/renderer/shader/compiler/ShaderSwitchSet.d.ts

@@ -17,7 +17,7 @@ export class ShaderSwitchSet {
      * @param {Array<number|boolean>} values none of them its switch's default
      * @returns {ShaderSwitchSet}
      */
-    static "__#76@#intern"(switches: ShaderSwitch[], values: Array<number | boolean>): ShaderSwitchSet;
+    static "__#77@#intern"(switches: ShaderSwitch[], values: Array<number | boolean>): ShaderSwitchSet;
     /**
      * The values as one string, the same for the same values. What interning is keyed by.
      * @returns {string}

package/src/shade/renderer/shader/resource/ShaderResourceDescriptor.d.ts

@@ -16,7 +16,7 @@ export class ShaderResourceDescriptor {
      * @param {WebGPUType|string} type
      * @returns {ShaderResourceDescriptor}
      */
-    static "__#74@#buffer"(name: string, type: WebGPUType | string): ShaderResourceDescriptor;
+    static "__#75@#buffer"(name: string, type: WebGPUType | string): ShaderResourceDescriptor;
     /**
      * A uniform buffer declaration.
      *

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.js

@@ -8,12 +8,12 @@ import {
     frustum_from_projection_matrix_array
 } from "../../../../core/geom/3d/frustum/frustum_from_projection_matrix_array.js";
 import { frustum_slice } from "../../../../core/geom/3d/frustum/frustum_slice.js";
-import { compose_matrix4_array } from "../../../../core/geom/3d/mat4/compose_matrix4_array.js";
+import { m4_compose } from "../../../../core/geom/3d/mat4/m4_compose.js";
 import { m4_invert } from "../../../../core/geom/3d/mat4/m4_invert.js";
 import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
 import { m4_orthographic_off_center_z0 } from "../../../../core/geom/3d/mat4/m4_orthographic_off_center_z0.js";
 import Quaternion from "../../../../core/geom/Quaternion.js";
-import { v3_array_centroid } from "../../../../core/geom/vec3/v3_array_centroid.js";
+import { v3_centroid_v3_buffer } from "../../../../core/geom/vec3/v3_centroid_v3_buffer.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { exp2 } from "../../../../core/math/exp2.js";
 import { inverseLerp } from "../../../../core/math/inverseLerp.js";
@@ -299,7 +299,7 @@ export class DirectionalLightShadowmap extends Shadowmap {
 
             // Calculate the centroid of the view frustum slice
             const cascade_frustum_center = new Vector3();
-            v3_array_centroid(cascade_frustum_center, 0, cascade_frustum_corners, 0, 8);
+            v3_centroid_v3_buffer(cascade_frustum_center, 0, cascade_frustum_corners, 0, 8);
 
             // Create a temporary view matrix for the light
 
@@ -315,7 +315,7 @@ export class DirectionalLightShadowmap extends Shadowmap {
 
             const _q = new Quaternion();
             quaternion_invert_orientation(_q, light_rotation);
-            compose_matrix4_array(light_view, cascade_frustum_center, _q, new Vector3(1, 1, -1.0));
+            m4_compose(light_view, cascade_frustum_center, _q, new Vector3(1, 1, -1.0));
 
             m4_invert(light_view, light_view);
 

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts

@@ -76,6 +76,36 @@ export class GPUSceneShadowmapContext {
      * @type {number}
      */
     virtual_lod_bias: number;
+    /**
+     * Pushed from {@link Renderer.shadow_virtual_max_load_factor} each frame.
+     *
+     * @param {number} v in `[0, 1]`; `0` disables dynamic throttling
+     */
+    set virtual_max_load_factor(v: number);
+    /**
+     * @returns {number}
+     */
+    get virtual_max_load_factor(): number;
+    /**
+     * Pushed from {@link Renderer.shadow_virtual_low_load_factor} each frame.
+     *
+     * @param {number} v in `[0, 1]`
+     */
+    set virtual_low_load_factor(v: number);
+    /**
+     * @returns {number}
+     */
+    get virtual_low_load_factor(): number;
+    /**
+     * Pushed from {@link Renderer.shadow_virtual_max_dynamic_lod_bias} each frame.
+     *
+     * @param {number} v non-negative; `0` disables dynamic throttling
+     */
+    set virtual_max_dynamic_lod_bias(v: number);
+    /**
+     * @returns {number}
+     */
+    get virtual_max_dynamic_lod_bias(): number;
     /**
      * Pushed from {@link Renderer.shadow_virtual_first_texel_size}. A change rebuilds every virtual
      * shadow map in {@link process_lights}: every page of the clipmap changes size.
@@ -138,20 +168,23 @@ export class GPUSceneShadowmapContext {
      */
     get cascade_table(): number;
     /**
-     * Record this frame's virtual shadow map feedback — the casters that moved, the pages they made
-     * stale, the pages the view's pixels ask for — into the frame's `Shading` graph once the main
-     * view's depth exists, and read it back for the maps' next frames. Does nothing in a scene
-     * without virtual shadow maps. See {@link graph_vsm_feedback}.
+     * Record this frame's virtual shadow map feedback — the pages the scene's movers made stale, the
+     * pages the view's pixels ask for — into the frame's `Shading` graph once the main view's depth
+     * exists, and read it back for the maps' next frames. Does nothing in a scene without virtual
+     * shadow maps, and then reads nothing of `movers`. See {@link graph_vsm_feedback}.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {import("../../view/GPUViewContext.js").GPUViewContext} options.view the main view
      * @param {number} options.depth graph handle of the main view's depth
+     * @param {number} options.movers graph handle of the scene's mover list this frame
+     *     ({@link GPUSceneContext#graph_movers})
      */
-    graph_virtual_feedback({ graph, view, depth }: {
+    graph_virtual_feedback({ graph, view, depth, movers }: {
         graph: FrameGraph;
         view: import("../../view/GPUViewContext.js").GPUViewContext;
         depth: number;
+        movers: number;
     }): void;
     /**
      *
@@ -181,9 +214,9 @@ export class GPUSceneShadowmapContext {
      *          frame's spend but not charged against the budget the local lights compete for.
      *        - **Local, off-screen** (`projected_area_px <= 0`) → skipped entirely.
      *        - **Local, in-view, invalid** → MUST draw. `is_invalid` means the committed layout
-     *          has never held valid depth (freshly created map); sampling it would display
-     *          garbage, so we bypass the budget. Resizes no longer invalidate under the dual-
-     *          layout model — this flag fires only on first-draw.
+     *          holds no valid depth — a map not yet drawn, or every map after the atlas grew
+     *          into a new texture; sampling it would display garbage, so we bypass the budget.
+     *          Resizes do not invalidate under the dual-layout model.
      *        - **Local, in-view, valid** → compete for the remaining budget by score. Ordering
      *          is descending score so the most important (largest-on-screen, stalest) maps win.
      *  5. **Fit the winners.** `map.update()` on each selected map, so its projection matrices
@@ -261,11 +294,17 @@ export class GPUSceneShadowmapContext {
      */
     process_lights(): boolean;
     /**
+     * Place a square patch of `resolution` texels in the atlas. When it does not fit: first the
+     * room pending resizes hold is given back, then the atlas grows, and only when it is as large
+     * as the device allows is the patch shrunk, halving and kept to whole multiples of `step`,
+     * down to {@link SHADOWMAP_PATCH_MIN_SIDE}.
      *
-     * @param {number} resolution
-     * @returns {AABB2}
+     * @param {number} resolution side the patch asks for
+     * @param {number} [step] texels the side must be a multiple of
+     * @returns {AABB2} the patch placed, `resolution` or smaller on a side
+     * @throws {Error} when not even the smallest patch fits
      */
-    bind(resolution: number): AABB2;
+    bind(resolution: number, step?: number): AABB2;
     destroy(): void;
     #private;
 }

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAkJA;;GAEG;AACH;IAoWI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IA1aD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAerB;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IAkGD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;OAUG;IACH;QAJ+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;aAuChB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAuG3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IA2bD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAqTnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAsBC;;CACJ;qCA/lEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCA7ErD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA0JA;;GAEG;AACH;IA8aI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IApfD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAiBrB;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,4CAKC;IAjBD;;OAEG;IACH,2CAEC;IA2BD;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA2FD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;;;OAYG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;aA+BhB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QA0G3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IAwbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAsTnB;IAED;;;;;;;;;;OAUG;IACH,iBALW,MAAM,SACN,MAAM,GACJ,KAAK,CAejB;IA2DD,gBAiBC;;CACJ;qCAruEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAhFrD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}