@woosh/meep-engine 2.165.3 → 2.165.5

package/src/engine/graphics/ecs/light/binding/three/ThreeLightBinding.js

@@ -1,4 +1,4 @@
-import { DoubleSide, Mesh, MeshDepthMaterial, RGBADepthPacking, Scene } from "three";
+import { DoubleSide, Mesh, MeshDepthMaterial, MeshDistanceMaterial, RGBADepthPacking, Scene, Vector3 } from "three";
 import { ThreeBypassRenderer } from "../../../../render/utils/ThreeBypassRenderer.js";
 import { CameraView } from "../../../../render/view/CameraView.js";
 import { three_setSceneAutoUpdate } from "../../../../three/three_setSceneAutoUpdate.js";
@@ -59,6 +59,68 @@ function __getDepthMaterial(object) {
     return result;
 }
 
+const __distance_material = new MeshDistanceMaterial({
+    side: DoubleSide
+});
+
+/**
+ * Reference values for point light shadow casting, set per render in
+ * {@link ThreeLightBinding.__shadowmap_render} before the shadow scene is
+ * built. Shadow renders are sequential, so shared state is safe here.
+ */
+const __distance_params = {
+    reference_position: new Vector3(),
+    near_distance: 0,
+    far_distance: 0
+};
+
+/**
+ * Point light shadows compare world-space distance to the light rather than
+ * projected depth (three.js getPointShadow), which requires
+ * MeshDistanceMaterial instead of MeshDepthMaterial
+ * @param {Mesh} object
+ * @returns {Material}
+ * @private
+ */
+function __getDistanceMaterial(object) {
+    let result;
+
+    const customDistanceMaterial = object.customDistanceMaterial;
+
+    if (customDistanceMaterial !== undefined) {
+        result = customDistanceMaterial;
+    } else {
+
+        const source_material = object.material;
+        if (
+            typeof source_material.alphaTest === "number"
+            && source_material.alphaTest > 0
+            && source_material.alphaTest < 1
+            && source_material.map !== null
+            && source_material.map !== undefined
+        ) {
+            // alpha-tested
+            result = new MeshDistanceMaterial({
+                side: DoubleSide,
+                map: source_material.map,
+                alphaTest: source_material.alphaTest
+            });
+
+        } else {
+            // generic
+            result = __distance_material;
+        }
+    }
+
+    if (result.isMeshDistanceMaterial === true) {
+        result.referencePosition.copy(__distance_params.reference_position);
+        result.nearDistance = __distance_params.near_distance;
+        result.farDistance = __distance_params.far_distance;
+    }
+
+    return result;
+}
+
 /**
  *
  * @param {THREE.Object3D} object3D
@@ -109,6 +171,11 @@ export function three_set_shadow_resolution(shadow, resolution) {
             shadow.map = null;
         }
 
+        if (shadow.mapPass !== null) {
+            shadow.mapPass.dispose();
+            shadow.mapPass = null;
+        }
+
     }
 }
 
@@ -157,13 +224,14 @@ export class ThreeLightBinding extends LightBinding {
          */
         const cache = this.__system.__three_light_cache;
 
+        // tear down shadow state while the light is still bound
+        this.__shadowmap_unlink();
+
         cache.release(this.__three_getLight());
 
         // clear bound light
         this.__c_light.__threeObject = null;
 
-        this.__shadowmap_unlink();
-
         super.unlink(ctx);
     }
 
@@ -239,6 +307,25 @@ export class ThreeLightBinding extends LightBinding {
         shadows.remove(this.__shadow_map);
 
         this.__shadow_map = null;
+
+        // release GPU resources of the shadow render targets, they are
+        // re-created on demand if shadow casting is enabled again
+        const light = this.__three_getLight();
+
+        const shadow = light === null ? undefined : light.shadow;
+
+        if (shadow !== undefined) {
+
+            if (shadow.map !== null) {
+                shadow.map.dispose();
+                shadow.map = null;
+            }
+
+            if (shadow.mapPass !== null) {
+                shadow.mapPass.dispose();
+                shadow.mapPass = null;
+            }
+        }
     }
 
     __shadowmap_prepare_view() {
@@ -250,6 +337,11 @@ export class ThreeLightBinding extends LightBinding {
          */
         const light = this.__three_getLight();
 
+        if (light.isPointLight === true) {
+            this.__shadowmap_prepare_view_point(cameraView, light);
+            return;
+        }
+
         /**
          *
          * @type {LightShadow}
@@ -269,6 +361,65 @@ export class ThreeLightBinding extends LightBinding {
 
     }
 
+    /**
+     * A point light shadow renders six cube faces, a single camera frustum
+     * would only cull correctly for one of them. Instead, cull by the
+     * axis-aligned box bounding the light's sphere of influence: every caster
+     * that can shadow any face lies within `distance` of the light. The box is
+     * written directly as six inward-facing "frustum" planes and the resulting
+     * visible set is shared by all six face renders.
+     * @param {CameraView} cameraView
+     * @param {THREE.PointLight} light
+     * @private
+     */
+    __shadowmap_prepare_view_point(cameraView, light) {
+        const p = this.__c_transform.position;
+
+        // mirrors PointLightShadow.updateMatrices: distance of 0 means unbounded
+        const r = light.distance || light.shadow.camera.far;
+
+        const f = cameraView.frustum;
+
+        // plane format: nx, ny, nz, constant; a point is inside a plane when
+        // dot(normal, point) + constant >= 0
+
+        // x >= p.x - r
+        f[0] = 1;
+        f[1] = 0;
+        f[2] = 0;
+        f[3] = r - p.x;
+
+        // x <= p.x + r
+        f[4] = -1;
+        f[5] = 0;
+        f[6] = 0;
+        f[7] = r + p.x;
+
+        // y >= p.y - r
+        f[8] = 0;
+        f[9] = 1;
+        f[10] = 0;
+        f[11] = r - p.y;
+
+        // y <= p.y + r
+        f[12] = 0;
+        f[13] = -1;
+        f[14] = 0;
+        f[15] = r + p.y;
+
+        // z >= p.z - r
+        f[16] = 0;
+        f[17] = 0;
+        f[18] = 1;
+        f[19] = r - p.z;
+
+        // z <= p.z + r
+        f[20] = 0;
+        f[21] = 0;
+        f[22] = -1;
+        f[23] = r + p.z;
+    }
+
 
     __shadowmap_render() {
 
@@ -297,6 +448,14 @@ export class ThreeLightBinding extends LightBinding {
 
         const shadow = threeLight.shadow;
 
+        const is_point_light = threeLight.isPointLight === true;
+
+        if (is_point_light) {
+            __distance_params.reference_position.setFromMatrixPosition(threeLight.matrixWorld);
+            __distance_params.near_distance = shadow.camera.near;
+            // mirrors PointLightShadow.updateMatrices
+            __distance_params.far_distance = threeLight.distance || shadow.camera.far;
+        }
 
         // prepare shadow scene
         const visible_objects = cameraView.visible_objects;
@@ -306,7 +465,7 @@ export class ThreeLightBinding extends LightBinding {
             scene: shadow_scene,
             input: visible_objects.elements,
             input_size: visible_object_count,
-            material_extractor: __getDepthMaterial,
+            material_extractor: is_point_light ? __getDistanceMaterial : __getDepthMaterial,
             object_filter: scene_object_filter
         })
 
@@ -367,9 +526,28 @@ export class ThreeLightBinding extends LightBinding {
 
             // disable automatic shadowmap rendering in three.js
             shadow.autoUpdate = false;
-            shadow.camera.matrixAutoUpdate = false;
 
-            const resolution = parseInt(settings.shadowResolution);
+            let resolution = parseInt(settings.shadowResolution);
+
+            if (shadow.isPointLightShadow === true) {
+                // PointLightShadow.updateMatrices re-orients the camera for
+                // every cube face and relies on updateMatrixWorld() to
+                // re-compose the matrix, so matrixAutoUpdate must stay enabled
+                shadow.camera.matrixAutoUpdate = true;
+
+                // small offset in normalized [near..far] distance units to
+                // suppress acne, casters render double-sided so front faces
+                // would otherwise compare against their own stored distance
+                shadow.bias = -0.002;
+
+                // resolution is per cube face and the shadow map allocates a
+                // 4x2 face atlas, cap the default to keep memory use sane
+                resolution = settings.shadowResolutionPoint !== undefined
+                    ? parseInt(settings.shadowResolutionPoint)
+                    : Math.min(resolution, 1024);
+            } else {
+                shadow.camera.matrixAutoUpdate = false;
+            }
 
             shadow.radius = 1;
             shadow.blurSamples = 8;