@woosh/meep-engine 3.23.0 → 3.25.0

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

@@ -1,7 +1,4 @@
 import { assert } from "../../../../core/assert.js";
-import {
-    compute_tight_near_far_clipping_planes
-} from "../../../../core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import {
     aabb3_from_v3_array_transformed
@@ -23,8 +20,10 @@ import { inverseLerp } from "../../../../core/math/inverseLerp.js";
 import {
     quaternion_invert_orientation
 } from "../../../../engine/graphics/ecs/camera/quaternion_invert_orientation.js";
+import { CSM_CASTER_RANGE_UNKNOWN } from "./csm/CSM_CASTER_RANGE_STRUCT.js";
 import { SHADOWMAP_CSM_CASCADE_BLEND_FRACTION } from "./csm/SHADOWMAP_CSM_CASCADE_BLEND_FRACTION.js";
 import { SHADOWMAP_CSM_CASCADE_COUNT } from "./csm/SHADOWMAP_CSM_CASCADE_COUNT.js";
+import { SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION } from "./csm/SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION.js";
 import { Shadowmap } from "./Shadowmap.js";
 import { SHADOWMAP_FILTER_SIZE } from "./SHADOWMAP_FILTER_SIZE.js";
 import { update_frustum_far_plane } from "./update_frustum_far_plane.js";
@@ -111,6 +110,59 @@ export class DirectionalLightShadowmap extends Shadowmap {
 
     splits = new Float32Array(SHADOWMAP_CSM_CASCADE_COUNT);
 
+    /**
+     * The row of the light database's `shadow_csm_caster_range` table this map's caster range is
+     * published into, claimed by the shadow context with the map; -1 until then.
+     *
+     * @type {number}
+     */
+    caster_row = -1;
+
+    /**
+     * Per cascade, the nearest caster along the light's axis that the GPU measured — from the
+     * world origin, the previous frame's cascade frusta — as the readback delivered it. NaN until
+     * the first delivery, which is what {@link caster_range_valid} reads: the readback writes these
+     * bytes only when a request lands, and a request that was dropped leaves them as they were.
+     *
+     * @type {Float32Array}
+     */
+    caster_range = new Float32Array(SHADOWMAP_CSM_CASCADE_COUNT).fill(NaN);
+
+    /**
+     * {@link caster_range} as the bytes the readback writes into.
+     *
+     * @type {Uint8Array}
+     */
+    #caster_range_bytes = new Uint8Array(this.caster_range.buffer);
+
+    /**
+     * Whether {@link caster_range} has ever been delivered.
+     *
+     * @type {boolean}
+     */
+    caster_range_valid = false;
+
+    /**
+     * What the accumulate pass measures this frame's casters against: the light's axis and each
+     * cascade's four side planes, as {@link update} fitted them. `base` is the shadow context's.
+     *
+     * `planes` is what is marshalled — a vec4 per plane — and `planes_words` the one buffer those
+     * are views over, which {@link update} writes.
+     *
+     * @type {{z_axis: Float32Array, planes: Float32Array[], planes_words: Float32Array, base: number, cascade_count: number}}
+     */
+    caster_settings = (() => {
+        const planes_words = new Float32Array(SHADOWMAP_CSM_CASCADE_COUNT * 16);
+
+        return {
+            z_axis: new Float32Array(4),
+            planes: Array.from({ length: SHADOWMAP_CSM_CASCADE_COUNT * 4 }, (_, i) => planes_words.subarray(i * 4, i * 4 + 4)),
+            planes_words,
+            base: 0,
+            cascade_count: SHADOWMAP_CSM_CASCADE_COUNT,
+        };
+    })();
+
     update(main_camera, scene_ctx) {
 
         assert.defined(main_camera, 'main_camera');
@@ -122,8 +174,6 @@ export class DirectionalLightShadowmap extends Shadowmap {
         //      and then refine clipping for each cascade as well maybe. Refining individual cascades will bring less benefit, as the value is greatest for furthest cascades and the difference between cascade clip and whole view clip will be marginal.
 
         // TODO incorporate HZB data (min max depth in view)
-        // TODO incorporate BVH (TLAS) data to refine bounds
-        // TODO reference meep code for bounds calculation
 
 
         // TODO Consider making use of https://www.w3.org/TR/webgpu/#depth-clip-control to avoid having to compute proper "near" distance
@@ -131,6 +181,20 @@ export class DirectionalLightShadowmap extends Shadowmap {
         const light = this.light;
         const views = this.views;
 
+        /*
+         What the GPU measured of last frame's casters has landed by now, if it has: the readback
+         is applied at the head of the frame, before the maps are fitted, and a delivery is the one
+         thing that writes the range. A request still on the device leaves the previous delivery
+         standing; a dropped one — the row changed hands — does the same, and the next request is
+         answered on the row as it is. A frame asks every frame, so at steady state a request is
+         answered two frames on, whichever frame's it was.
+        */
+        const readback = scene_ctx.lights.readback;
+
+        if (!this.caster_range_valid && !Number.isNaN(this.caster_range[0])) {
+            this.caster_range_valid = true;
+        }
+
         // see https://github.com/TheRealMJP/Shadows/blob/338290a57e7c65d493783fd48f39a28321e84e81/Shadows/SetupShadows.hlsl#L92
 
         const split_params = [];
@@ -169,12 +233,12 @@ export class DirectionalLightShadowmap extends Shadowmap {
 
         const light_rotation = new Quaternion();
 
-        // light_rotation.lookRotation(light.transform_global.forward, main_camera.right);
+        // light_rotation.lookRotation(light.transform.forward, main_camera.right);
         light_rotation.set(
-            light.transform_global.rotation_x,
-            light.transform_global.rotation_y,
-            light.transform_global.rotation_z,
-            light.transform_global.rotation_w
+            light.transform.rotation_x,
+            light.transform.rotation_y,
+            light.transform.rotation_z,
+            light.transform.rotation_w
         );
 
         for (let i = 0; i < cascade_count; i++) {
@@ -262,20 +326,19 @@ export class DirectionalLightShadowmap extends Shadowmap {
             }
 
             {
-                // Push the near plane back to include shadow casters that sit between the
-                // light and the view slice. Caster bounds come from a TLAS query that
-                // tightens the (relaxed) near/far planes of the cascade's light frustum
-                // against scene geometry while the four side planes stay fixed. When the
-                // query reports no casters there is nothing to shadow and the slice's own
-                // range stands.
-
+                /*
+                 Push the near plane back to include shadow casters that sit between the light and
+                 the view slice. How near they reach is measured on the GPU — `shader_csm_caster_range`
+                 over every mesh row's world bounds, which the CPU does not hold for a subtree the GPU
+                 drives — against the frusta fitted here, and read back: what is applied is the range
+                 the previous frame's frusta measured, less a margin for the frame of motion between,
+                 since a caster that edged past it would flicker. This frame's side planes are what
+                 the pass runs with next. Until a first delivery, or for a cascade nothing was in
+                 front of, the slice's own range stands.
+                */
                 const shadow_proj = new Float32Array(16);
 
-                // The z range here is irrelevant: planes 4/5 are relaxed by the query, which
-                // keeps their normals and recomputes only their offsets. This projection looks
-                // down +z where the light's view space looks down -z, which swaps those two
-                // planes over — and the loop below reads both and takes the nearer, so the swap
-                // does not reach the result.
+                // The z range here is irrelevant: only the four side planes are handed to the pass.
                 m4_orthographic_off_center_z0(
                     shadow_proj,
                     extents.x0, extents.x1,
@@ -289,56 +352,30 @@ export class DirectionalLightShadowmap extends Shadowmap {
                 const cascade_light_frustum = new Float32Array(24);
                 frustum_from_projection_matrix_array(cascade_light_frustum, light_view_projection);
 
-                const valid_clip = compute_tight_near_far_clipping_planes(
-                    cascade_light_frustum, 0,
-                    0b110000,
-                    scene_ctx.tlas.bvh,
-                    cascade_light_frustum
-                );
-
-                if (valid_clip) {
-                    // Convert each tightened boundary plane to a light-view-space z by
-                    // projecting the cascade center onto it; the smaller of the two is the
-                    // caster boundary on the light's side. Plane normals from the matrix
-                    // extraction are not unit length — normalize through the math.
-                    let caster_z_min = Infinity;
-
-                    for (let plane_index = 4; plane_index <= 5; plane_index++) {
-                        const plane_address = plane_index * 4;
-
-                        const nx = cascade_light_frustum[plane_address];
-                        const ny = cascade_light_frustum[plane_address + 1];
-                        const nz = cascade_light_frustum[plane_address + 2];
-                        const w = cascade_light_frustum[plane_address + 3];
+                // planes 0..3 are the sides; 4 and 5 are what the pass measures
+                this.caster_settings.planes_words.set(cascade_light_frustum.subarray(0, 16), i * 16);
 
-                        const n_length = Math.sqrt(nx * nx + ny * ny + nz * nz);
-
-                        // signed distance from the cascade center to the plane
-                        const d = (
-                            nx * cascade_frustum_center.x
-                            + ny * cascade_frustum_center.y
-                            + nz * cascade_frustum_center.z
-                            + w
-                        ) / n_length;
+                if (i === 0) {
+                    // the light-view z row, the same for every cascade: the axis the range is
+                    // measured along, from the world origin
+                    this.caster_settings.z_axis.set([light_view[2], light_view[6], light_view[10], 0]);
+                }
 
-                        // closest point on the plane to the center
-                        const qx = cascade_frustum_center.x - (nx / n_length) * d;
-                        const qy = cascade_frustum_center.y - (ny / n_length) * d;
-                        const qz = cascade_frustum_center.z - (nz / n_length) * d;
+                if (this.caster_range_valid) {
+                    const nearest = this.caster_range[i];
 
-                        // light-view-space z of that point (column-major z row)
-                        const z_view = light_view[2] * qx + light_view[6] * qy + light_view[10] * qz + light_view[14];
+                    if (nearest < CSM_CASTER_RANGE_UNKNOWN) {
+                        // into this cascade's light view: the row's translation is the centre's
+                        const caster_z_min = nearest + light_view[14];
+                        const margin = (extents.z1 - extents.z0) * SHADOWMAP_CSM_CASTER_RANGE_MARGIN_FRACTION;
 
-                        caster_z_min = Math.min(caster_z_min, z_view);
+                        // only ever push back, never forward — receivers ahead of the casters
+                        // still need the slice's own range
+                        extents.z0 = Math.min(extents.z0, caster_z_min - margin);
                     }
-
-                    // only ever push back, never forward — receivers ahead of the casters
-                    // still need the slice's own range
-                    extents.z0 = Math.min(extents.z0, caster_z_min);
                 }
             }
 
-
             // write out shadow camera settings
             camera.left = extents.x0;
             camera.right = extents.x1;
@@ -366,6 +403,17 @@ export class DirectionalLightShadowmap extends Shadowmap {
         // shadow_directional row needs to be re-published.
         this.metadata_changed = true;
 
+        // and ask for what the pass measures this frame, for the next frame's fit
+        if (this.caster_row !== -1) {
+            readback.request(
+                scene_ctx.lights.shadow_context.caster_range_table,
+                this.caster_row,
+                0,
+                this.#caster_range_bytes.length,
+                this.#caster_range_bytes
+            );
+        }
+
         // csm_debug_draw_preview({
         //     canvas_ctx: DEBUG_CANVAS.context2d,
         //     size: DEBUG_CANVAS.size,

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

@@ -69,6 +69,13 @@ export class GPUSceneShadowmapContext {
      * @returns {number}
      */
     get debug_drop_size_scale(): number;
+    /**
+     * The readback service's handle for the light database's `shadow_csm_caster_range` table —
+     * what a directional map asks its range through.
+     *
+     * @returns {number}
+     */
+    get caster_range_table(): number;
     /**
      *
      * @param {Light} light

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":"AAkGA;;GAEG;AACH;IA8KI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EA6D5B;IAhPD,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;IAqCtC;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAgGD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAmFhC;IA6aD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAuOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAYC;;CACJ;qCArxCY,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;oCAtDX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AAyGA;;GAEG;AACH;IAoNI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EA+D5B;IAxRD,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;IA2EtC;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAkGD;;;;;OAKG;IACH,iCAMC;IAgHD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QAgE3B;IAyED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QAsFhC;IAsbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAwOnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,KAAK,CAWjB;IAED,gBAiBC;;CACJ;qCA38CY,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;oCA7DX,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;kBAtBrC,wCAAwC"}