@woosh/meep-engine 2.138.4 → 2.138.5

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.138.4",
+  "version": "2.138.5",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Walk a BVH and, for each node-AABB overlapping the frustum, update the
+ * running (min, max) distance from those AABBs to a plane. Used to compute the
+ * tight near/far range a camera needs to contain all visible content along its
+ * view direction.
+ *
+ * Distances are measured along the plane normal: positive when the AABB sits
+ * on the side the normal points to. Range starts wide and shrinks per AABB —
+ * caller may pre-seed `result` (e.g. to chain BVHs) and read back the
+ * accumulated range.
+ *
+ * Resolves at AABB granularity. Nodes fully inside the frustum take a fast
+ * path (no further recursion) and contribute their full AABB extent, which
+ * may overstate the range slightly when the AABB extends past the frustum
+ * walls; for clipping plane fitting that's the right (conservative) tradeoff.
+ *
+ * @param {{near:number, far:number}} result accumulator — mutated in place.
+ *   Initialize {near: +Infinity, far: -Infinity} on first call.
+ * @param {BVH} bvh
+ * @param {ArrayLike<number>} frustum 6 inward-facing planes, layout matching
+ *   {@link frustum_from_projection_matrix_array}
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ */
+export function bvh_query_depth_range_in_frustum(result: {
+    near: number;
+    far: number;
+}, bvh: BVH, frustum: ArrayLike<number>, plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number): void;
+//# sourceMappingURL=bvh_query_depth_range_in_frustum.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_depth_range_in_frustum.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yDAVW;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,MAAM,CAAA;CAAC,qBAGzB,UAAU,MAAM,CAAC,kBAEjB,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,QAkEhB"}

package/src/core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js

@@ -0,0 +1,101 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_array_intersects_frustum_degree } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_degree.js";
+import { aabb3_compute_distance_above_plane_max } from "../../../geom/3d/aabb/aabb3_compute_distance_above_plane_max.js";
+import { aabb3_compute_distance_above_plane_min } from "../../../geom/3d/aabb/aabb3_compute_distance_above_plane_min.js";
+import { NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+const scratch_aabb = new Float32Array(6);
+
+/**
+ * Walk a BVH and, for each node-AABB overlapping the frustum, update the
+ * running (min, max) distance from those AABBs to a plane. Used to compute the
+ * tight near/far range a camera needs to contain all visible content along its
+ * view direction.
+ *
+ * Distances are measured along the plane normal: positive when the AABB sits
+ * on the side the normal points to. Range starts wide and shrinks per AABB —
+ * caller may pre-seed `result` (e.g. to chain BVHs) and read back the
+ * accumulated range.
+ *
+ * Resolves at AABB granularity. Nodes fully inside the frustum take a fast
+ * path (no further recursion) and contribute their full AABB extent, which
+ * may overstate the range slightly when the AABB extends past the frustum
+ * walls; for clipping plane fitting that's the right (conservative) tradeoff.
+ *
+ * @param {{near:number, far:number}} result accumulator — mutated in place.
+ *   Initialize {near: +Infinity, far: -Infinity} on first call.
+ * @param {BVH} bvh
+ * @param {ArrayLike<number>} frustum 6 inward-facing planes, layout matching
+ *   {@link frustum_from_projection_matrix_array}
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ */
+export function bvh_query_depth_range_in_frustum(
+    result,
+    bvh,
+    frustum,
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant
+) {
+    const root = bvh.root;
+
+    if (root === NULL_NODE) {
+        return;
+    }
+
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    while (stack.pointer > stack_top) {
+        stack.pointer--;
+
+        const node = stack[stack.pointer];
+
+        bvh.node_get_aabb(node, scratch_aabb);
+
+        const x0 = scratch_aabb[0];
+        const y0 = scratch_aabb[1];
+        const z0 = scratch_aabb[2];
+        const x1 = scratch_aabb[3];
+        const y1 = scratch_aabb[4];
+        const z1 = scratch_aabb[5];
+
+        const intersection = aabb3_array_intersects_frustum_degree(scratch_aabb, 0, frustum);
+
+        if (intersection === 0) {
+            continue;
+        }
+
+        const node_is_leaf = bvh.node_is_leaf(node);
+
+        if (node_is_leaf || intersection === 2) {
+            // leaf or fully-inside subtree — contribute this AABB and stop descending
+            const d_min = aabb3_compute_distance_above_plane_min(
+                plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                x0, y0, z0, x1, y1, z1
+            );
+            const d_max = aabb3_compute_distance_above_plane_max(
+                plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                x0, y0, z0, x1, y1, z1
+            );
+
+            if (d_min < result.near) {
+                result.near = d_min;
+            }
+            if (d_max > result.far) {
+                result.far = d_max;
+            }
+        } else {
+            // partially inside — descend
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
+
+            stack[stack.pointer++] = child1;
+            stack[stack.pointer++] = child2;
+        }
+    }
+}

package/src/engine/EngineHarness.js

@@ -192,7 +192,7 @@ export class EngineHarness {
             distance = 10,
             pitch = 1.4,
             yaw = 0,
-            autoClip = false,
+            autoClip = true,
             distanceMin = 0.01,
             distanceMax = 1000,
             fieldOfView = 45
@@ -286,7 +286,7 @@ export class EngineHarness {
                                  cameraFieldOfView,
                                  cameraFarDistance,
                                  cameraController = true,
-                                 cameraAutoClip = false,
+                                 cameraAutoClip = true,
                                  shadowmapResolution,
                                  showFps = true
                              }) {

package/src/engine/ecs/renderable/RenderSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/renderable/RenderSystem.js"],"names":[],"mappings":";AAcA;;GAEG;AACH;IAqBI;;;;OAIG;IACH,4CAOC;IAhCD,uDAAuC;IAEvC,kEAEE;IAEF,kBAAgB;IAEhB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAUZ;;OAEG;IACH,yBAA8B;IAGlC,2CA8CC;IAED,4CAEC;IAED;;;;;OAKG;IACH,iBAJW,UAAU,aACV,SAAS,qBAwCnB;IAED;;;;;OAKG;IACH,mBAJW,UAAU,aACV,SAAS,qBAiBnB;IAED;;;;;;;;;;;;OAYG;IACH,gEAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,kBACG,MAAM,QAAE,UAAU,mCAA0B,OAAO,wBAE1D,MAAM,CAelB;CACJ;uBA9LsB,cAAc;0BACX,2BAA2B;uBAC9B,iBAAiB;4CAPI,oDAAoD;oBAH5E,gCAAgC"}
+{"version":3,"file":"RenderSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/renderable/RenderSystem.js"],"names":[],"mappings":";AAeA;;GAEG;AACH;IAqBI;;;;OAIG;IACH,4CAOC;IAhCD,uDAAuC;IAEvC,kEAEE;IAEF,kBAAgB;IAEhB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAUZ;;OAEG;IACH,yBAA8B;IAGlC,2CAmDC;IAED,4CAEC;IAED;;;;;OAKG;IACH,iBAJW,UAAU,aACV,SAAS,qBAwCnB;IAED;;;;;OAKG;IACH,mBAJW,UAAU,aACV,SAAS,qBAiBnB;IAED;;;;;;;;;;;;OAYG;IACH,gEAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,kBACG,MAAM,QAAE,UAAU,mCAA0B,OAAO,wBAE1D,MAAM,CAelB;CACJ;uBAnMsB,cAAc;0BACX,2BAA2B;uBAC9B,iBAAiB;4CAPI,oDAAoD;oBAJ5E,gCAAgC"}

package/src/engine/ecs/renderable/RenderSystem.js

@@ -1,4 +1,5 @@
 import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { SignalBinding } from "../../../core/events/signal/SignalBinding.js";
 import { ResourceAccessKind } from "../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
@@ -69,6 +70,11 @@ class RenderSystem extends System {
             }
         )
 
+        const bvh = this.bvh;
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         const visibleSet = this.renderLayer.visibleSet;
 
         visibleSet.onAdded.add(m => {

package/src/engine/ecs/terrain/ecs/TerrainSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/TerrainSystem.js"],"names":[],"mappings":";AA+BA;IAwMI;;;;;OAKG;IACH,kEAHW,OAAO,uBAwCjB;IA1ND;;;;;OAKG;IACH,kEAeC;IA7CD,iCAAyB;IAEzB,mBAAe;IACf,mBAAe;IAEf;;;;OAIG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAoBZ,yBAAwB;IAExB,2BAAgC;IAGpC,kDAMC;IAED,2CAwDC;IAED,4CAEC;IAED;;;;OAIG;IACH,gBAHW,OAAO,qBAqBjB;IAED;;;;OAIG;IACH,kBAHW,OAAO,qBAKjB;IAED,6BAaC;IAED;;;;;OAKG;IACH,gCAwBC;CA+CJ;uBAvQsB,iBAAiB;oBAEpB,cAAc;oBAbd,mCAAmC"}
+{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/TerrainSystem.js"],"names":[],"mappings":";AAgCA;IA0NI;;;;;OAKG;IACH,kEAHW,OAAO,uBAwCjB;IA5OD;;;;;OAKG;IACH,kEAeC;IA7CD,iCAAyB;IAEzB,mBAAe;IACf,mBAAe;IAEf;;;;OAIG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAoBZ,yBAAwB;IAExB,2BAAgC;IAGpC,kDAMC;IAED,2CA0EC;IAED,4CAEC;IAED;;;;OAIG;IACH,gBAHW,OAAO,qBAqBjB;IAED;;;;OAIG;IACH,kBAHW,OAAO,qBAKjB;IAED,6BAaC;IAED;;;;;OAKG;IACH,gCAwBC;CA+CJ;uBAzRsB,iBAAiB;oBAEpB,cAAc;oBAdd,mCAAmC"}

package/src/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import {
     bvh_query_user_data_overlaps_frustum
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
@@ -136,6 +137,24 @@ class TerrainSystem extends System {
             return match_count;
         };
 
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            const em = this.entityManager;
+
+            if (em === null) {
+                return;
+            }
+
+            const ecd = em.dataset;
+
+            if (ecd === null) {
+                return;
+            }
+
+            ecd.traverseComponents(Terrain, (component) => {
+                bvh_query_depth_range_in_frustum(result, component.tiles.bvh, frustum, nx, ny, nz, c);
+            });
+        };
+
         const am = this.assetManager;
 
         await am.tryRegisterLoader('image', new ImageRGBADataLoader());

package/src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.d.ts

@@ -1,6 +1,9 @@
 /**
+ * Tighten the camera's near/far planes to the world-space depth range of all
+ * BVH-backed render layers' content visible inside the camera's frustum. Falls
+ * back to (clip_near, clip_far) when no layer contributes content.
  *
- * @param {Camera} c
+ * @param {Camera} c camera ECS component (its `object` is the THREE.Camera)
  * @param {RenderLayerManager} layers
  */
 export function auto_set_camera_clipping_planes(c: Camera, layers: RenderLayerManager): void;

package/src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto_set_camera_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,6FAMC"}
+{"version":3,"file":"auto_set_camera_clipping_planes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,6FAsFC"}

package/src/engine/graphics/ecs/camera/auto_set_camera_clipping_planes.js

@@ -1,12 +1,121 @@
-/**
- *
- * @param {Camera} c
- * @param {RenderLayerManager} layers
- */
-export function auto_set_camera_clipping_planes(c, layers) {
-    // TODO implement
-
-    c.object.far = c.clip_far;
-    c.object.near = c.clip_near;
-
-}
+import { Frustum as ThreeFrustum } from "three";
+import { read_three_planes_to_array } from "../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
+import { frustum_from_camera } from "./frustum_from_camera.js";
+
+const CLIPPING_EPSILON = 0.001;
+const CLIPPING_NEAR_MIN = 0.5;
+const CLIPPING_FAR_DEFAULT = 100;
+
+const scratch_three_frustum = new ThreeFrustum();
+const scratch_frustum_planes = new Float32Array(24);
+const scratch_range = { near: 0, far: 0 };
+
+/**
+ * Hysteresis prevents the clipping planes from thrashing as content moves
+ * slightly. A shrink is only honored when it's at least this fraction of the
+ * current near-to-far span; smaller shrinks are ignored, so an object briefly
+ * crossing the frustum boundary doesn't trigger a re-projection.
+ *
+ * Loosenings (when content moves further away or closer) always apply
+ * immediately — never delay including content.
+ *
+ * @type {number}
+ */
+const HYSTERESIS = 0.33;
+
+/**
+ * Tighten the camera's near/far planes to the world-space depth range of all
+ * BVH-backed render layers' content visible inside the camera's frustum. Falls
+ * back to (clip_near, clip_far) when no layer contributes content.
+ *
+ * @param {Camera} c camera ECS component (its `object` is the THREE.Camera)
+ * @param {RenderLayerManager} layers
+ */
+export function auto_set_camera_clipping_planes(c, layers) {
+    const camera = c.object;
+
+    if (camera === null) {
+        return;
+    }
+
+    // Run visibility against the user-specified outer bounds, not the previous
+    // frame's tightened range — otherwise objects could be culled before we
+    // ever see them and the autoClip would shrink toward nothing.
+    camera.near = c.clip_near;
+    camera.far = c.clip_far;
+
+    frustum_from_camera(camera, scratch_three_frustum, true);
+    read_three_planes_to_array(scratch_three_frustum.planes, scratch_frustum_planes);
+
+    // Depth plane: passes through camera position, normal pointing along the
+    // view direction (-Z in camera local). A world-space point's distance to
+    // this plane equals its signed depth in front of the camera.
+    const m = camera.matrixWorld.elements;
+    const nx = -m[8];
+    const ny = -m[9];
+    const nz = -m[10];
+    const cam_x = m[12];
+    const cam_y = m[13];
+    const cam_z = m[14];
+    const plane_constant = -(nx * cam_x + ny * cam_y + nz * cam_z);
+
+    scratch_range.near = Number.POSITIVE_INFINITY;
+    scratch_range.far = Number.NEGATIVE_INFINITY;
+
+    layers.traverse((layer) => {
+        if (!layer.state.visible) {
+            return;
+        }
+
+        const compute = layer.compute_depth_range;
+
+        if (compute === null) {
+            return;
+        }
+
+        compute(scratch_range, scratch_frustum_planes, nx, ny, nz, plane_constant);
+    });
+
+    let new_near = scratch_range.near - CLIPPING_EPSILON;
+    let new_far = scratch_range.far + CLIPPING_EPSILON;
+
+    if (!isFinite(new_near) || new_near < CLIPPING_NEAR_MIN) {
+        new_near = CLIPPING_NEAR_MIN;
+    }
+    if (!isFinite(new_far) || new_far <= new_near) {
+        new_far = Math.max(new_near + CLIPPING_EPSILON, CLIPPING_FAR_DEFAULT);
+    }
+
+    // Clamp inside the user-specified outer bounds so the tightened range
+    // never expands past what the camera is configured to render.
+    if (new_near < c.clip_near) {
+        new_near = c.clip_near;
+    }
+    if (new_far > c.clip_far) {
+        new_far = c.clip_far;
+    }
+
+    // Hysteresis: only shrink each plane if the shrink is meaningful relative
+    // to the current span. Loosening always applies immediately.
+    const old_near = camera.near;
+    const old_far = camera.far;
+    const old_span = old_far - old_near;
+    const shrink_threshold = HYSTERESIS * old_span;
+
+    if (new_near > old_near && new_near - old_near < shrink_threshold) {
+        new_near = old_near;
+    }
+    if (new_far < old_far && old_far - new_far < shrink_threshold) {
+        new_far = old_far;
+    }
+
+    camera.near = new_near;
+    camera.far = new_far;
+
+    // Rebuild the projection matrix from the tightened range — CameraView
+    // reads camera.projectionMatrix directly when capturing the frame's
+    // frustum, and the wide-range matrix from the depth-query step above is
+    // now stale.
+    camera.updateProjectionMatrix();
+}
+

package/src/engine/graphics/ecs/light/LightSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/light/LightSystem.js"],"names":[],"mappings":"AAuQA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,2DANW,YAAY,SACZ,WAAW,oBACX,MAAM,QAmEhB;;uBAvVsB,qBAAqB;sBAEtB,YAAY;AAQlC;IACI;;;;;OAKG;IACH,2CAsFC;IA1EG,kDAAsC;IAGtC,6DAEC;IAGD,eAAoB;IACpB,WAA2B;IAC3B,aAAwB;IAExB;;;;OAIG;IACH,mBAA0B;IAE1B;;;;OAIG;IACH,wBAA2B;IAE3B,gBAAkB;IAElB;;;;OAIG;IACH,kBAAoC;IAGpC;;;;OAIG;IACH,2BAA8B;IAC9B;;;;OAIG;IACH,iBAAoB;IAGpB;;;;OAIG;IACH,4BAAgD;IAqBpD,mCAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,QAkB/B;IAED;;;;OAIG;IACH,4BAHW,KAAK,UACL,MAAM,QAMhB;IAED,2CAOC;IAED,4CASC;IAGD,4CAOC;IAED;;;;;OAKG;IACH,wCAmCC;IAED;;;;;;OAMG;IACH,sCAwBC;CACJ;sCA3PqC,8CAA8C;0BAC1D,qCAAqC;4CAFnB,uDAAuD"}
+{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/light/LightSystem.js"],"names":[],"mappings":"AAwQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,2DARW,YAAY,SACZ,WAAW,oBACX,MAAM,qCA0EhB;;uBArWsB,qBAAqB;sBAEtB,YAAY;AASlC;IACI;;;;;OAKG;IACH,2CAsFC;IA1EG,kDAAsC;IAGtC,6DAEC;IAGD,eAAoB;IACpB,WAA2B;IAC3B,aAAwB;IAExB;;;;OAIG;IACH,mBAA0B;IAE1B;;;;OAIG;IACH,wBAA2B;IAE3B,gBAAkB;IAElB;;;;OAIG;IACH,kBAAoC;IAGpC;;;;OAIG;IACH,2BAA8B;IAC9B;;;;OAIG;IACH,iBAAoB;IAGpB;;;;OAIG;IACH,4BAAgD;IAqBpD,mCAEC;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,GAAC,MAAM,GAAC,OAAO,QAkB/B;IAED;;;;OAIG;IACH,4BAHW,KAAK,UACL,MAAM,QAMhB;IAED,2CAOC;IAED,4CASC;IAGD,4CAOC;IAED;;;;;OAKG;IACH,wCAmCC;IAED;;;;;;OAMG;IACH,sCAwBC;CACJ;sCA5PqC,8CAA8C;0BAC1D,qCAAqC;4CAFnB,uDAAuD"}

package/src/engine/graphics/ecs/light/LightSystem.js

@@ -12,6 +12,7 @@ import { Light } from './Light.js';
 import { LightContext } from "./LightContext.js";
 import { LightType } from "./LightType.js";
 import { compute_view_frustum_aabb_in_space } from "./shadow/compute_view_frustum_aabb_in_space.js";
+import { extend_shadow_camera_near_for_casters } from "./shadow/extend_shadow_camera_near_for_casters.js";
 import { setShadowCameraDimensionsDiscrete } from "./shadow/setShadowCameraDimensionsDiscrete.js";
 import { ShadowManager } from "./shadow/ShadowManager.js";
 import { ThreeLightCache } from "./three/ThreeLightCache.js";
@@ -212,7 +213,7 @@ class LightSystem extends AbstractContextSystem {
 
                 l.castShadow = true;
 
-                three_update_shadow_camera_extents(this.__camera_object, l, this.settings.shadowDistance);
+                three_update_shadow_camera_extents(this.__camera_object, l, this.settings.shadowDistance, this.__graphics.layers);
 
             } else {
 
@@ -275,6 +276,12 @@ const DEFAULT_SHADOW_DISTANCE = 100;
  * across hundreds of world units). `shadow_distance` caps the depth of the view
  * frustum we fit against, trading visible-shadow distance for sharpness.
  *
+ * The receiver-only fit misses any occluder above the view frustum: a brick
+ * hanging in the air just above the camera's view casts no visible shadow on
+ * the ground below because it's clipped out of the shadow map. When `layers`
+ * is provided we walk every render layer's BVH for AABBs in the column above
+ * the receivers and pull `near` back to the closest caster found.
+ *
  * three.js leaves shadow.camera positioned wherever it last was — the renderer
  * doesn't call updateMatrices() until render time. updateMatrices is forced
  * here so matrixWorldInverse reflects the light's current pose; ShadowMapRenderer
@@ -285,8 +292,10 @@ const DEFAULT_SHADOW_DISTANCE = 100;
  * @param {number} [shadow_distance] max world-space view depth to cover with
  *   shadow; defaults to {@link DEFAULT_SHADOW_DISTANCE}. Use Infinity to fit
  *   the entire view frustum (sharp shadows close up become unaffordable).
+ * @param {RenderLayerManager} [layers] render layers, used to find shadow
+ *   casters outside the view frustum. Omit to use receiver-only fit.
  */
-export function three_update_shadow_camera_extents(camera, light, shadow_distance = DEFAULT_SHADOW_DISTANCE) {
+export function three_update_shadow_camera_extents(camera, light, shadow_distance = DEFAULT_SHADOW_DISTANCE, layers = null) {
 
     const shadow = light.shadow;
     if (shadow === undefined) {
@@ -345,6 +354,11 @@ export function three_update_shadow_camera_extents(camera, light, shadow_distanc
     shadow_camera.near = -scratch_aabb3.z1;
     shadow_camera.far = -scratch_aabb3.z0;
 
+    // Pull near back to include occluders above the view frustum so they cast
+    // visible shadows. Far stays at the receiver fit — occluders behind
+    // receivers can't shadow into the view.
+    extend_shadow_camera_near_for_casters(shadow_camera, layers);
+
     shadow_camera.updateProjectionMatrix();
 
     // small bias to prevent shadow acne

package/src/engine/graphics/ecs/light/shadow/extend_shadow_camera_near_for_casters.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Push the shadow camera's near plane back toward the light to include any
+ * occluder whose shadow would fall within the camera's x/y bounds, even when
+ * the occluder itself sits outside the main view frustum.
+ *
+ * Without this step the textbook "fit shadow camera to view frustum" leaves
+ * the near plane at the closest receiver — a brick floating just above the
+ * view frustum gets clipped out of the shadow map and casts no shadow on the
+ * ground below.
+ *
+ * Algorithm:
+ *   1. Take the shadow camera's existing left/right/top/bottom (already fit
+ *      to receivers) as the x/y extents of a light-local query box. Extend z
+ *      to a wide range so any caster along the light direction is captured.
+ *   2. Transform the 6 box planes to world space via the shadow camera's
+ *      matrixWorld.
+ *   3. Walk every render layer's BVH through `compute_depth_range` against
+ *      this world-space volume, measured along the shadow camera's view
+ *      direction.
+ *   4. If the closest depth found is smaller than the camera's current near,
+ *      replace near with it.
+ *
+ * Far is intentionally left alone: casters behind the farthest receiver (in
+ * light direction) can't shadow anything in the view.
+ *
+ * @param {THREE.OrthographicCamera} shadow_camera
+ * @param {RenderLayerManager} layers
+ */
+export function extend_shadow_camera_near_for_casters(shadow_camera: THREE.OrthographicCamera, layers: RenderLayerManager): void;
+//# sourceMappingURL=extend_shadow_camera_near_for_casters.d.ts.map

package/src/engine/graphics/ecs/light/shadow/extend_shadow_camera_near_for_casters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend_shadow_camera_near_for_casters.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/light/shadow/extend_shadow_camera_near_for_casters.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qEAHW,MAAM,kBAAkB,oCAuDlC"}

package/src/engine/graphics/ecs/light/shadow/extend_shadow_camera_near_for_casters.js

@@ -0,0 +1,97 @@
+import {
+    clipping_volume_matrix4_project
+} from "../../../../../core/geom/3d/frustum/clipping_volume_matrix4_project.js";
+import { hexahedron_from_aabb } from "../../../../../core/geom/3d/frustum/hexahedron_from_aabb.js";
+
+const scratch_local_planes = new Float32Array(24);
+const scratch_world_planes = new Float32Array(24);
+const scratch_range = { near: 0, far: 0 };
+
+// Half-extent of the z range used for the caster query. We want any object in
+// the column above the receivers regardless of how far it sits along the light
+// direction, so the query volume is effectively unbounded in z; the BVH walk's
+// AABB-vs-frustum test is happy with a wide-but-finite range and avoids
+// infinities propagating through plane math.
+const CASTER_QUERY_HALF_RANGE = 1e7;
+
+/**
+ * Push the shadow camera's near plane back toward the light to include any
+ * occluder whose shadow would fall within the camera's x/y bounds, even when
+ * the occluder itself sits outside the main view frustum.
+ *
+ * Without this step the textbook "fit shadow camera to view frustum" leaves
+ * the near plane at the closest receiver — a brick floating just above the
+ * view frustum gets clipped out of the shadow map and casts no shadow on the
+ * ground below.
+ *
+ * Algorithm:
+ *   1. Take the shadow camera's existing left/right/top/bottom (already fit
+ *      to receivers) as the x/y extents of a light-local query box. Extend z
+ *      to a wide range so any caster along the light direction is captured.
+ *   2. Transform the 6 box planes to world space via the shadow camera's
+ *      matrixWorld.
+ *   3. Walk every render layer's BVH through `compute_depth_range` against
+ *      this world-space volume, measured along the shadow camera's view
+ *      direction.
+ *   4. If the closest depth found is smaller than the camera's current near,
+ *      replace near with it.
+ *
+ * Far is intentionally left alone: casters behind the farthest receiver (in
+ * light direction) can't shadow anything in the view.
+ *
+ * @param {THREE.OrthographicCamera} shadow_camera
+ * @param {RenderLayerManager} layers
+ */
+export function extend_shadow_camera_near_for_casters(shadow_camera, layers) {
+    if (layers === null) {
+        return;
+    }
+
+    const x0 = shadow_camera.left;
+    const x1 = shadow_camera.right;
+    const y0 = shadow_camera.bottom;
+    const y1 = shadow_camera.top;
+
+    hexahedron_from_aabb(
+        scratch_local_planes, 0,
+        x0, y0, -CASTER_QUERY_HALF_RANGE,
+        x1, y1, CASTER_QUERY_HALF_RANGE
+    );
+
+    clipping_volume_matrix4_project(
+        scratch_world_planes, 0,
+        scratch_local_planes, 0,
+        6,
+        shadow_camera.matrixWorld.elements
+    );
+
+    // Depth plane: world-space, normal along the shadow camera's view direction
+    // (-Z column of matrixWorld), passing through the camera position. A point's
+    // distance to this plane equals its depth in front of the camera.
+    const m = shadow_camera.matrixWorld.elements;
+    const nx = -m[8];
+    const ny = -m[9];
+    const nz = -m[10];
+    const plane_constant = -(nx * m[12] + ny * m[13] + nz * m[14]);
+
+    scratch_range.near = Number.POSITIVE_INFINITY;
+    scratch_range.far = Number.NEGATIVE_INFINITY;
+
+    layers.traverse((layer) => {
+        if (!layer.state.visible) {
+            return;
+        }
+
+        const compute = layer.compute_depth_range;
+
+        if (compute === null) {
+            return;
+        }
+
+        compute(scratch_range, scratch_world_planes, nx, ny, nz, plane_constant);
+    });
+
+    if (isFinite(scratch_range.near) && scratch_range.near < shadow_camera.near) {
+        shadow_camera.near = scratch_range.near;
+    }
+}

package/src/engine/graphics/ecs/mesh/MeshSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/MeshSystem.js"],"names":[],"mappings":"AA6BA;IAiZI;;;;;;;OAOG;IACH,kCANW,IAAI,uCAEJ,OAAO,GACL,OAAO,CAQnB;IA7ZD;;;;;OAKG;IACH,4BAwDC;IAjDG;;;;OAIG;IACH,iBAAsB;IAEtB,iDAAqC;IAErC,4DAEC;IAGD;;;OAGG;IACH,2BAAgC;IAEhC,sBAAwB;IAExB;;;OAGG;IACH,YAFU,MAAO,MAAO,aAAa,CAAC,CAAC,CAEnB;IAEpB,cAAwB;IAExB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,qBAA6B;IAGjC;;;;;;OAMG;IACH,8BALW,MAAM,4DAGN,IAAI,QA+Bd;IAED,2CAuDC;IAED;;;;OAIG;IACH,gCAHoB,IAAI,QAAE,MAAM,+BA8C/B;IAED,4CAEC;IAED;;;;;OAKG;IACH,YAHW,IAAI,aADJ,SAAS,UAET,MAAM,QAkChB;IAED;;;;;OAKG;IACH,cAHW,IAAI,aADJ,SAAS,YAET,MAAM,QAmChB;IAED;;;;OAIG;IACH,gCAFW,IAAI,QA+Ed;IAED,6BAoBC;CAgBJ;uBAnbsB,wBAAwB;0BACrB,qCAAqC;iBAO/B,WAAW;4CAVC,uDAAuD;8BAJrE,iDAAiD;oBAE3D,kCAAkC"}
+{"version":3,"file":"MeshSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh/MeshSystem.js"],"names":[],"mappings":"AA8BA;IAsZI;;;;;;;OAOG;IACH,kCANW,IAAI,uCAEJ,OAAO,GACL,OAAO,CAQnB;IAlaD;;;;;OAKG;IACH,4BAwDC;IAjDG;;;;OAIG;IACH,iBAAsB;IAEtB,iDAAqC;IAErC,4DAEC;IAGD;;;OAGG;IACH,2BAAgC;IAEhC,sBAAwB;IAExB;;;OAGG;IACH,YAFU,MAAO,MAAO,aAAa,CAAC,CAAC,CAEnB;IAEpB,cAAwB;IAExB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,+BAAmC;IAEnC;;;;OAIG;IACH,qBAA6B;IAGjC;;;;;;OAMG;IACH,8BALW,MAAM,4DAGN,IAAI,QA+Bd;IAED,2CA4DC;IAED;;;;OAIG;IACH,gCAHoB,IAAI,QAAE,MAAM,+BA8C/B;IAED,4CAEC;IAED;;;;;OAKG;IACH,YAHW,IAAI,aADJ,SAAS,UAET,MAAM,QAkChB;IAED;;;;;OAKG;IACH,cAHW,IAAI,aADJ,SAAS,YAET,MAAM,QAmChB;IAED;;;;OAIG;IACH,gCAFW,IAAI,QA+Ed;IAED,6BAoBC;CAgBJ;uBAxbsB,wBAAwB;0BACrB,qCAAqC;iBAO/B,WAAW;4CAVC,uDAAuD;8BAJrE,iDAAiD;oBAE3D,kCAAkC"}

package/src/engine/graphics/ecs/mesh/MeshSystem.js

@@ -1,6 +1,7 @@
 import { BoxBufferGeometry, MeshLambertMaterial } from "three";
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { SignalBinding } from "../../../../core/events/signal/SignalBinding.js";
 
 import Vector3 from "../../../../core/geom/Vector3.js";
@@ -157,6 +158,11 @@ export class MeshSystem extends System {
             }
         )
 
+        const bvh = this.__bvh_binary;
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         const visibleSet = this.renderLayer.visibleSet;
 
         visibleSet.onAdded.add(m => {

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js"],"names":[],"mappings":"AA6DA;IACI;;;OAGG;IACH,4BAmEC;IAjEG,2DAA+C;IAE/C;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,uBAA0B;IAE1B;;;;OAIG;IACH,wBAAgC;IAEhC;;;;OAIG;IACH,4BAAoC;IAEpC;;;;OAIG;IACH,kCAA0C;IAE1C;;;;OAIG;IACH,qBAA6B;IAI7B,0BAYE;IAEF,yBAIC;IAIL;;;OAGG;IACH,eAEC;IAED;;;OAGG;IACH,4BAFa,IAAI,MAAM,EAAC,MAAM,CAAC,CAI9B;IAED;;;;OAIG;IACH,+BAHW,MAAM,+CAsBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACL,OAAO,CAmBlB;IAED;;;;OAIG;IACH,4BASC;IAED;;;;OAIG;IACH,8BAMC;IAED,2CAgCC;IAED,4CAcC;IAED;;;;;OAKG;IACH,SAJW,cAAc,KACd,SAAS,UACT,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,WAJW,cAAc,KACd,SAAS,UACT,MAAM,QAsBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GACxB,MAAM,CAQlB;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAC;QAAC,OAAO,EAAE,aAAa,CAAA;KAAC,EAAE,CA8D1E;IAGD;;;;;;;;;;;;OAYG;IACH,wBAXW,aAAa,YACb,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAA;KAAC,GAAC,SAAS,CAmF1D;CACJ;uBAxfsB,wBAAwB;0BACrB,qCAAqC;+BAGhC,qBAAqB;iBARnC,uCAAuC;oBAXpC,mCAAmC;2BAO5B,yCAAyC;8BAEtC,2CAA2C"}
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js"],"names":[],"mappings":"AA8DA;IACI;;;OAGG;IACH,4BAmEC;IAjEG,2DAA+C;IAE/C;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,uBAA0B;IAE1B;;;;OAIG;IACH,wBAAgC;IAEhC;;;;OAIG;IACH,4BAAoC;IAEpC;;;;OAIG;IACH,kCAA0C;IAE1C;;;;OAIG;IACH,qBAA6B;IAI7B,0BAYE;IAEF,yBAIC;IAIL;;;OAGG;IACH,eAEC;IAED;;;OAGG;IACH,4BAFa,IAAI,MAAM,EAAC,MAAM,CAAC,CAI9B;IAED;;;;OAIG;IACH,+BAHW,MAAM,+CAsBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACL,OAAO,CAmBlB;IAED;;;;OAIG;IACH,4BASC;IAED;;;;OAIG;IACH,8BAMC;IAED,2CAqCC;IAED,4CAcC;IAED;;;;;OAKG;IACH,SAJW,cAAc,KACd,SAAS,UACT,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,WAJW,cAAc,KACd,SAAS,UACT,MAAM,QAsBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GACxB,MAAM,CAQlB;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAC;QAAC,OAAO,EAAE,aAAa,CAAA;KAAC,EAAE,CA8D1E;IAGD;;;;;;;;;;;;OAYG;IACH,wBAXW,aAAa,YACb,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,uEAGJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAA;KAAC,GAAC,SAAS,CAmF1D;CACJ;uBA7fsB,wBAAwB;0BACrB,qCAAqC;+BAGhC,qBAAqB;iBARnC,uCAAuC;oBAZpC,mCAAmC;2BAQ5B,yCAAyC;8BAEtC,2CAA2C"}

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -1,6 +1,7 @@
 import { mat4 } from "gl-matrix";
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
 import {
     bvh_query_user_data_overlaps_frustum
@@ -256,6 +257,11 @@ export class ShadedGeometrySystem extends System {
             return ctx.collect(destination, destination_offset, graphics.renderer, view, this.__bvh_binary, ecd);
         });
 
+        const bvh = this.__bvh_binary;
+        this.__render_layer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         this.__optimization_task.state.set(TaskState.INITIAL);
         engine.executor.run(this.__optimization_task);
 

package/src/engine/graphics/ecs/trail2d/Trail2DSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Trail2DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail2d/Trail2DSystem.js"],"names":[],"mappings":";AAyBA;IAkCI;;;OAGG;IACH,4BA4BC;IAjED,oDAAoC;IAEpC,+DAEE;IAEF;;;OAGG;IACH,WAFU,4BAA4B,CAES;IAE/C;;;;OAIG;IACH,wBAAiC;IAGjC;;;;OAIG;IACH,oBAAgB;IAEhB;;;OAGG;IACH,YAAgB;IAcZ;;;;OAIG;IACH,iBAAsB;IAEtB;;;OAGG;IACH,UAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,2CAcC;IAED,4CAIC;IAED;;;;;OAKG;IACH,sBAoDC;IAED;;;;;OAKG;IACH,YAHW,OAAO,aADP,SAAS,YAET,MAAM,QAahB;IAED;;;;;OAKG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAShB;IAED;;;;OAIG;IACH,yBAHW,OAAO,aACP,SAAS,QAoCnB;IAED,6BAWC;CACJ;uBA/PsB,wBAAwB;0BACrB,qCAAqC;oBAY3C,cAAc;4CAdU,uDAAuD;6CAYtD,yDAAyD;+BARvE,yBAAyB"}
+{"version":3,"file":"Trail2DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail2d/Trail2DSystem.js"],"names":[],"mappings":";AA0BA;IAkCI;;;OAGG;IACH,4BA4BC;IAjED,oDAAoC;IAEpC,+DAEE;IAEF;;;OAGG;IACH,WAFU,4BAA4B,CAES;IAE/C;;;;OAIG;IACH,wBAAiC;IAGjC;;;;OAIG;IACH,oBAAgB;IAEhB;;;OAGG;IACH,YAAgB;IAcZ;;;;OAIG;IACH,iBAAsB;IAEtB;;;OAGG;IACH,UAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,2CAmBC;IAED,4CAIC;IAED;;;;;OAKG;IACH,sBAoDC;IAED;;;;;OAKG;IACH,YAHW,OAAO,aADP,SAAS,YAET,MAAM,QAahB;IAED;;;;;OAKG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAShB;IAED;;;;OAIG;IACH,yBAHW,OAAO,aACP,SAAS,QAoCnB;IAED,6BAWC;CACJ;uBApQsB,wBAAwB;0BACrB,qCAAqC;oBAY3C,cAAc;4CAdU,uDAAuD;6CAYtD,yDAAyD;+BARvE,yBAAyB"}

package/src/engine/graphics/ecs/trail2d/Trail2DSystem.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { clamp } from "../../../../core/math/clamp.js";
 import { max2 } from "../../../../core/math/max2.js";
@@ -104,6 +105,11 @@ class Trail2DSystem extends System {
             }
         );
 
+        const bvh = this.bvh;
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         this.__ribbon_plugin = await this.__engine.plugins.acquire(RibbonXPlugin);
     }
 

package/src/engine/graphics/ecs/water/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAYA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CA4DC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBA/QsB,wBAAwB;kBAM7B,YAAY;oBAPV,mCAAmC"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAaA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CAiEC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBApRsB,wBAAwB;kBAM7B,YAAY;oBARV,mCAAmC"}

package/src/engine/graphics/ecs/water/WaterSystem.js

@@ -1,6 +1,7 @@
 import { BackSide, PlaneBufferGeometry } from 'three';
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { System } from '../../../ecs/System.js';
 import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
 import { make_bvh_visibility_builder } from "../../render/make_bvh_visibility_builder.js";
@@ -90,6 +91,11 @@ class WaterSystem extends System {
             }
         )
 
+        const bvh = this.bvh;
+        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
 
         const self = this;
 

package/src/engine/graphics/impostors/octahedral/prototypeBaker.js

@@ -41,6 +41,7 @@ async function main(engine) {
         showFps: false,
         enableLights: true,
         enableShadows: true,
+        cameraAutoClip: true,
     });
 
 

package/src/engine/graphics/particles/ecs/ParticleEmitterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/particles/ecs/ParticleEmitterSystem.js"],"names":[],"mappings":"AAYA;IAeI;;;;;OAKG;IACH,4BAwBC;IA5CD,yCAA4C;IAE5C,uEAEE;IAEF;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB,kBAAgB;IAcZ;;;OAGG;IACH,+BAAqC;IAErC;;;OAGG;IACH,2BAAuC;IAEvC;;;OAGG;IACH,gBAFU,gBAAgB,CAE2E;IAIzG,2CAyHC;IAED,4CAEC;IAED;;;;;OAKG;IACH,cAJW,eAAe,aACf,SAAS,qBAoCnB;IAED;;;;;OAKG;IACH,gBAJW,eAAe,aACf,SAAS,qBAenB;IAED,6BAEC;CACJ;uBAtPsB,wBAAwB;gCAIf,iDAAiD;4CANrC,uDAAuD;iCAQlE,0CAA0C;0BALjD,qCAAqC"}
+{"version":3,"file":"ParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/particles/ecs/ParticleEmitterSystem.js"],"names":[],"mappings":"AAaA;IAeI;;;;;OAKG;IACH,4BAwBC;IA5CD,yCAA4C;IAE5C,uEAEE;IAEF;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB,kBAAgB;IAcZ;;;OAGG;IACH,+BAAqC;IAErC;;;OAGG;IACH,2BAAuC;IAEvC;;;OAGG;IACH,gBAFU,gBAAgB,CAE2E;IAIzG,2CA8HC;IAED,4CAEC;IAED;;;;;OAKG;IACH,cAJW,eAAe,aACf,SAAS,qBAoCnB;IAED;;;;;OAKG;IACH,gBAJW,eAAe,aACf,SAAS,qBAenB;IAED,6BAEC;CACJ;uBA3PsB,wBAAwB;gCAIf,iDAAiD;4CANrC,uDAAuD;iCAQlE,0CAA0C;0BALjD,qCAAqC"}

package/src/engine/graphics/particles/ecs/ParticleEmitterSystem.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../../core/assert.js";
+import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
@@ -85,6 +86,11 @@ export class ParticleEmitterSystem extends System {
             }
         );
 
+        const bvh = this.particleEngine.bvh;
+        renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
+            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        };
+
         renderLayer.visibleSet.onAdded.add((points) => {
             /**
              *

package/src/engine/graphics/render/layers/RenderLayer.d.ts

@@ -17,4 +17,6 @@ export class RenderLayer {
      * @deprecated
      */
     visibleSet: IncrementalDeltaSet<Object3D>
+
+    compute_depth_range: ((result: { near: number; far: number }, frustum: ArrayLike<number>, plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number) => void) | null
 }

package/src/engine/graphics/render/layers/RenderLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderLayer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/layers/RenderLayer.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,OAFU,gBAAgB,CAEK;IAE/B;;;OAGG;IACH,MAFU,SAAO,IAAI,CAET;IAEZ;;;;OAIG;IACH,SAFU,OAAO,CAED;IAEhB;;;OAGG;IACH,2CAAgC;IAEhC;;;;;OAKG;IACH,YAFU,oBAAoB,MAAM,QAAQ,CAAC,CAEe;IAU5D;;;OAGG;IACH,0BAEC;IAdD;;;OAGG;IACH,uBAEC;IAUD;;;;;;;;;OASG;IACH,qDALW,MAAM,OACN,MAAM,sCAMhB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,QAAQ,EAAE,sBAChB,MAAM,qBAEJ,MAAM,CAIlB;CACJ;iCA7EgC,uBAAuB;oCADpB,sCAAsC"}
+{"version":3,"file":"RenderLayer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/render/layers/RenderLayer.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,OAFU,gBAAgB,CAEK;IAE/B;;;OAGG;IACH,MAFU,SAAO,IAAI,CAET;IAEZ;;;;OAIG;IACH,SAFU,OAAO,CAED;IAEhB;;;OAGG;IACH,2CAAgC;IAEhC;;;;;OAKG;IACH,YAFU,oBAAoB,MAAM,QAAQ,CAAC,CAEe;IAU5D;;;OAGG;IACH,0BAEC;IAdD;;;OAGG;IACH,uBAEC;IAUD;;;;;;;;;OASG;IACH,qDALW,MAAM,OACN,MAAM,sCAMhB;IAED;;;;;;OAMG;IACH,6BALW,MAAM,QAAQ,EAAE,sBAChB,MAAM,qBAEJ,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,8BAFmB;QAAC,IAAI,EAAC,MAAM,CAAC;QAAA,GAAG,EAAC,MAAM,CAAA;KAAC,WAAU,UAAU,MAAM,CAAC,kBAAiB,MAAM,kBAAiB,MAAM,kBAAiB,MAAM,kBAAiB,MAAM,KAAK,IAAI,CAEhJ;CAC9B;iCA3FgC,uBAAuB;oCADpB,sCAAsC"}

package/src/engine/graphics/render/layers/RenderLayer.js

@@ -78,4 +78,18 @@ export class RenderLayer {
     buildVisibleSet(destination, destination_offset, view) {
         throw new Error('deprecated');
     }
+
+    /**
+     * Expand a (near, far) depth range to cover this layer's content that
+     * intersects a frustum. Driven by the camera's autoClip path; defaults to
+     * a no-op for layers that don't own a BVH or don't participate in depth
+     * fitting (e.g. screen-space overlays).
+     *
+     * Systems with a BVH wire this from their `startup` alongside
+     * `buildVisibleSet` — typically using
+     * {@link bvh_query_depth_range_in_frustum} against their own BVH.
+     *
+     * @type {((result:{near:number,far:number}, frustum:ArrayLike<number>, plane_normal_x:number, plane_normal_y:number, plane_normal_z:number, plane_constant:number) => void) | null}
+     */
+    compute_depth_range = null;
 }

package/src/engine/intelligence/mcts/MonteCarlo.js

@@ -152,7 +152,7 @@ export class MonteCarloTreeSearch {
                     assert.notNaN(s, 'computed Node score');
                     assert.isFinite(s, `computed Node score`);
 
-                    score = s + randomRoll;
+                    score = s + randomRoll * 1e-5;
                 } else {
 
                     //use a constant value for unexplored nodes