@woosh/meep-engine 2.33.25 → 2.33.26

package/core/geom/3d/shape/AbstractShape3D.js

@@ -1,5 +1,31 @@
 export class AbstractShape3D {
-    constructor() {
+    /**
+     * Signed distance to boundary of the shape from the given point
+     * @param {number[]} point
+     * @returns {number}
+     */
+    signed_distance_at_point(point) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * Samples both distances as well as the gradient
+     * @param {number[]} result resulting gradient is written here
+     * @param {number[]} point sampling point
+     * @returns {number}
+     */
+    signed_distance_gradient_at_point(result, point) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {number[]} result where the resulting point is stored
+     * @param {number[]} reference reference point from which to go
+     * @returns {void}
+     */
+    nearest_point_on_surface(result, reference) {
+        throw new Error('Not Implemented');
     }
 
     /**
@@ -7,6 +33,7 @@ export class AbstractShape3D {
      * @param {number[]} result
      * @param {number} result_offset
      * @param {function} random
+     * @returns {void}
      */
     sample_random_point_in_volume(result, result_offset, random) {
         throw new Error('Not Implemented');

package/core/geom/3d/shape/TransformedShape3D.js

@@ -1,11 +1,12 @@
 import { mat4, vec3 } from "gl-matrix";
 import { AbstractShape3D } from "./AbstractShape3D.js";
+import { sign } from "../../../math/sign.js";
 
 /**
  *
  * @type {number[]|Float32Array|vec3}
  */
-const scratch_v3 = [];
+const scratch_v3_0 = [];
 
 export class TransformedShape3D extends AbstractShape3D {
     constructor() {
@@ -98,29 +99,83 @@ export class TransformedShape3D extends AbstractShape3D {
     }
 
     get volume() {
-        mat4.getScaling(scratch_v3, this.__matrix);
+        mat4.getScaling(scratch_v3_0, this.__matrix);
 
-        const scale_modifier = scratch_v3[0] * scratch_v3[1] * scratch_v3[2];
+        const scale_modifier = scratch_v3_0[0] * scratch_v3_0[1] * scratch_v3_0[2];
 
         return this.__subject.volume * scale_modifier;
     }
 
+    signed_distance_gradient_at_point(result, point) {
+        // transform point to subject's local space
+        vec3.transformMat4(scratch_v3_0, point, this.__inverse_matrix);
+
+        const subject = this.__subject;
+
+        // sample gradient at the point
+        const distance = subject.signed_distance_gradient_at_point(scratch_v3_0, scratch_v3_0);
+
+        const m = this.__matrix;
+
+        const m11 = m[0];
+        const m12 = m[1];
+        const m13 = m[2];
+
+        const m21 = m[4];
+        const m22 = m[5];
+        const m23 = m[6];
+
+        const m31 = m[8];
+        const m32 = m[9];
+        const m33 = m[10];
+
+        const scale_x = Math.hypot(m11, m12, m13);
+        const scale_y = Math.hypot(m21, m22, m23);
+        const scale_z = Math.hypot(m31, m32, m33);
+
+        const scaled_gx = scratch_v3_0[0] * scale_x;
+        const scaled_gy = scratch_v3_0[1] * scale_y;
+        const scaled_gz = scratch_v3_0[2] * scale_z;
+
+        // normalize gradient
+        const gd = distance / Math.hypot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2]);
+
+        const scaled_dx = scaled_gx * gd ;
+        const scaled_dy = scaled_gy * gd ;
+        const scaled_dz = scaled_gz * gd ;
+
+        // determine sign
+        const result_sign = sign(distance);
+
+        const scaled_distance = result_sign * Math.sqrt(scaled_dx * scaled_dx + scaled_dy * scaled_dy + scaled_dz * scaled_dz);
+
+        result[0] = scaled_gx;
+        result[1] = scaled_gy;
+        result[2] = scaled_gz;
+
+        return scaled_distance;
+    }
+
+    signed_distance_at_point(point) {
+        return this.signed_distance_gradient_at_point(scratch_v3_0, point);
+    }
+
     contains_point(point) {
         // transform point to subject's local space
-        vec3.transformMat4(scratch_v3, point, this.__inverse_matrix);
+        vec3.transformMat4(scratch_v3_0, point, this.__inverse_matrix);
 
-        return this.__subject.contains_point(scratch_v3);
+        return this.__subject.contains_point(scratch_v3_0);
     }
 
     sample_random_point_in_volume(result, result_offset, random) {
-        this.__subject.sample_random_point_in_volume(scratch_v3, 0, random);
+        this.__subject.sample_random_point_in_volume(scratch_v3_0, 0, random);
 
         // apply transform
-        vec3.transformMat4(scratch_v3, scratch_v3, this.__matrix);
+        vec3.transformMat4(scratch_v3_0, scratch_v3_0, this.__matrix);
 
         // write out
-        result[0] = scratch_v3[0];
-        result[1] = scratch_v3[1];
-        result[2] = scratch_v3[2];
+        result[0] = scratch_v3_0[0];
+        result[1] = scratch_v3_0[1];
+        result[2] = scratch_v3_0[2];
     }
 }

package/core/geom/3d/shape/TransformedShape3D.spec.js

@@ -0,0 +1,33 @@
+import { UnitCubeShape3D } from "./UnitCubeShape3D.js";
+import { TransformedShape3D } from "./TransformedShape3D.js";
+
+test('signed distance identity transform', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [1, 1, 1]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-0.5);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0.5);
+});
+
+test('signed distance translation', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [1, 0, 0], [1, 1, 1]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(0.5);
+
+    expect(s.signed_distance_at_point([-1, 0, 0])).toBeCloseTo(1.5);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(-0.5);
+});
+
+test('signed distance scale', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 2, 2]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-1);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([2, 0, 0])).toBeCloseTo(1);
+});

package/core/geom/3d/shape/{CompositeShape.js → UnionShape3D.js}

@@ -2,6 +2,8 @@ import { AbstractShape3D } from "./AbstractShape3D.js";
 import { seededRandom } from "../../../math/random/seededRandom.js";
 import { binarySearchHighIndex } from "../../../collection/array/binarySearchHighIndex.js";
 import { compareNumbers } from "../../../primitives/numbers/compareNumbers.js";
+import { min2 } from "../../../math/min2.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 
 /**
  * To avoid severe performance overhead, we limit number of possible rejections
@@ -18,16 +20,7 @@ const VOLUME_OVERLAP_ESTIMATION_SUB_TAPS = 4;
 
 const scratch_array = [];
 
-/**
- *
- * @param {AbstractShape3D} shape
- * @return {number}
- */
-function getVolume(shape) {
-    return shape.volume;
-}
-
-export class CompositeShape3D extends AbstractShape3D {
+export class UnionShape3D extends AbstractShape3D {
     constructor() {
         super();
 
@@ -50,6 +43,10 @@ export class CompositeShape3D extends AbstractShape3D {
         this.__child_volumes = [];
     }
 
+    /**
+     *
+     * @private
+     */
     __compute_volume_variables() {
         this.__volume_sum = 0;
 
@@ -123,7 +120,7 @@ export class CompositeShape3D extends AbstractShape3D {
     }
 
     static from(children) {
-        const r = new CompositeShape3D();
+        const r = new UnionShape3D();
 
         r.children = children;
 
@@ -169,6 +166,25 @@ export class CompositeShape3D extends AbstractShape3D {
         return r;
     }
 
+    signed_distance_gradient_at_point(result, point) {
+        return compute_signed_distance_gradient_by_sampling(result, this, point);
+    }
+
+    signed_distance_at_point(point) {
+        let r = Infinity;
+
+        const children = this.children;
+        const child_count = children.length;
+
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            r = min2(child.signed_distance_at_point(point), r);
+        }
+
+        return r;
+    }
+
     contains_point(point) {
         const children = this.children;
         const n = children.length;
@@ -183,7 +199,6 @@ export class CompositeShape3D extends AbstractShape3D {
         return false;
     }
 
-
     sample_random_point_in_volume(result, result_offset, random) {
         const children = this.children;
         const child_count = children.length;

package/core/geom/3d/shape/UnitCubeShape3D.js

@@ -1,5 +1,11 @@
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { randomPointInBox } from "../../random/randomPointInBox.js";
+import { v3_length } from "../../v3_length.js";
+import { max2 } from "../../../math/max2.js";
+import { max3 } from "../../../math/max3.js";
+import { min2 } from "../../../math/min2.js";
+import { clamp } from "../../../math/clamp.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 
 export class UnitCubeShape3D extends AbstractShape3D {
 
@@ -7,6 +13,77 @@ export class UnitCubeShape3D extends AbstractShape3D {
         return 1;
     }
 
+    nearest_point_on_surface(result, reference) {
+        const r_x = reference[0];
+        const r_y = reference[1];
+        const r_z = reference[2];
+
+        // figure out closest face to the reference point
+        const ar_x = Math.abs(r_x);
+        const ar_y = Math.abs(r_y);
+        const ar_z = Math.abs(r_z);
+
+        if (ar_x > ar_y && ar_x > ar_z) {
+            // X is smallest, project onto X axis
+            if (r_x <= 0) {
+                result[0] = -0.5;
+            } else {
+                result[0] = 0.5;
+            }
+
+            result[1] = clamp(r_y, -0.5, 0.5);
+            result[2] = clamp(r_z, -0.5, 0.5);
+        } else if (ar_y > ar_x && ar_y > ar_z) {
+            // Y is smallest, project onto X axis
+            if (r_y <= 0) {
+                result[1] = -0.5;
+            } else {
+                result[1] = 0.5;
+            }
+
+            result[0] = clamp(r_x, -0.5, 0.5);
+            result[2] = clamp(r_z, -0.5, 0.5);
+        } else {
+            // project onto Z axis
+
+            if (r_z <= 0) {
+                result[2] = -0.5;
+            } else {
+                result[2] = 0.5;
+            }
+
+            result[0] = clamp(r_x, -0.5, 0.5);
+            result[1] = clamp(r_y, -0.5, 0.5);
+        }
+    }
+
+    signed_distance_gradient_at_point(result, point) {
+        return compute_signed_distance_gradient_by_sampling(result,this, point);
+    }
+
+    signed_distance_at_point(point) {
+        /*
+        based on https://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
+        original shader code:
+            ------------
+            float sdBox( vec3 p, vec3 b )
+            {
+              vec3 q = abs(p) - b;
+              return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);
+            }
+            ------------
+         */
+        const q_x = Math.abs(point[0]) - 0.5;
+        const q_y = Math.abs(point[1]) - 0.5;
+        const q_z = Math.abs(point[2]) - 0.5;
+
+        return v3_length(
+            max2(q_x, 0),
+            max2(q_y, 0),
+            max2(q_z, 0)
+        ) + min2(max3(q_x, q_y, q_z), 0);
+    }
+
     contains_point(point) {
         const x = point[0];
         const y = point[1];

package/core/geom/3d/shape/UnitCubeShape3D.spec.js

@@ -0,0 +1,42 @@
+import { UnitCubeShape3D } from "./UnitCubeShape3D.js";
+
+test('signed distance', () => {
+    const s = new UnitCubeShape3D();
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-0.5);
+
+    expect(s.signed_distance_at_point([0.5, 0, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0, 0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([-0.5, 0, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, -0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([0.5, 0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, 0, 0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([-0.5, 0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, -0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, -0.5, 0])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([0, -0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, -0.5, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([-0.5, 0, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, 0, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, 0, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([0.5, 0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, 0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, -0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, 0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, -0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, -0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, 0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, -0.5, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0.5);
+});

package/core/geom/3d/shape/UnitSphereShape3D.js

@@ -1,6 +1,11 @@
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { randomPointInSphere } from "../../random/randomPointInSphere.js";
+import { v3_length } from "../../v3_length.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
 
+/**
+ * Sphere with diameter of 1 (radius = 0.5)
+ */
 export class UnitSphereShape3D extends AbstractShape3D {
     get volume() {
         return 0.523598776;
@@ -10,12 +15,38 @@ export class UnitSphereShape3D extends AbstractShape3D {
         return 3.14159265;
     }
 
+    nearest_point_on_surface(result, reference) {
+
+        const r_x = reference[0];
+        const r_y = reference[1];
+        const r_z = reference[2];
+
+        // normalize vector to 0.5 radius
+        const d = 0.5 / Math.hypot(r_x, r_y, r_z);
+
+        result[0] = r_x * d;
+        result[1] = r_y * d;
+        result[2] = r_z * d;
+    }
+
+    signed_distance_gradient_at_point(result, point) {
+        return compute_signed_distance_gradient_by_sampling(result,this, point);
+    }
+
+    signed_distance_at_point(point) {
+        return v3_length(
+            point[0],
+            point[1],
+            point[2]
+        ) - 0.5;
+    }
+
     contains_point(point) {
         const x = point[0];
         const y = point[1];
         const z = point[2];
 
-        return (x * x + y * y + z * z) < 1;
+        return (x * x + y * y + z * z) < 0.25;
     }
 
     sample_random_point_in_volume(result, result_offset, random) {

package/core/geom/3d/shape/util/compute_signed_distance_gradient_by_sampling.js

@@ -0,0 +1,48 @@
+const scratch_v = [];
+
+/**
+ *
+ * @param {number[]} result
+ * @param {AbstractShape3D} shape
+ * @param {number[]} point
+ * @returns {number}
+ */
+export function compute_signed_distance_gradient_by_sampling(result, shape, point) {
+    const v0 = shape.signed_distance_at_point(point);
+
+    scratch_v[0] = point[0] + 1e-5;
+    scratch_v[1] = point[1];
+    scratch_v[2] = point[2];
+
+    const vx = shape.signed_distance_at_point(scratch_v);
+
+    scratch_v[0] = point[0];
+    scratch_v[1] = point[1] + 1e-5;
+    scratch_v[2] = point[2];
+
+    const vy = shape.signed_distance_at_point(point);
+
+    scratch_v[0] = point[0];
+    scratch_v[1] = point[1];
+    scratch_v[2] = point[2] + 1e-5;
+
+    const vz = shape.signed_distance_at_point(point);
+
+    // convert absolute sample values to relative
+    const rx = vx - v0;
+    const ry = vy - v0;
+    const rz = vz - v0;
+
+    // normalize by sampling distance
+    const d = 1e-5 / 1.73205080757;
+
+    const nx = rx * d;
+    const ny = ry * d;
+    const nz = rz * d;
+
+    result[0] = nx;
+    result[1] = ny;
+    result[2] = nz;
+
+    return v0;
+}

package/core/geom/3d/shape/util/shape_to_visual_entity.js

@@ -1,4 +1,4 @@
-import { CompositeShape3D } from "../CompositeShape.js";
+import { UnionShape3D } from "../UnionShape3D.js";
 import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
 import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
 import { TransformedShape3D } from "../TransformedShape3D.js";
@@ -30,7 +30,7 @@ export const SHAPE_VISUAL_ENTITY_TAG = 'util/vis/Shape3D';
 
 /**
  *
- * @param {CompositeShape3D} shape
+ * @param {UnionShape3D} shape
  * @param {EntityComponentDataset} ecd
  * @returns {EntityBuilder}
  */
@@ -145,7 +145,7 @@ function transformed_shape_to_entity(shape, ecd) {
  * @returns {EntityBuilder}
  */
 export function shape_to_visual_entity(shape, ecd) {
-    if (shape instanceof CompositeShape3D) {
+    if (shape instanceof UnionShape3D) {
         return composite_shape_to_entity(shape, ecd);
     } else if (shape instanceof UnitCubeShape3D) {
         return cube_shape_to_entity(shape, ecd);

package/engine/graphics/ecs/highlight/plugin/OutlineRenderPlugin.js

@@ -147,7 +147,7 @@ export class OutlineRenderPlugin extends EnginePlugin {
         this.__compositing_layer.name = "Silhouette Outline";
         this.__compositing_layer.stage = CompositingStages.POST_TRANSPARENT;
 
-        this.__compositing_layer.on.preRender.add(this.__render, this);
+        graphics.on.preRender.add(this.__render, this);
 
 
         // set rendering resolution
@@ -160,7 +160,7 @@ export class OutlineRenderPlugin extends EnginePlugin {
 
         const graphics = this.engine.graphics;
 
-        this.__compositing_layer.on.preRender.remove(this.__render, this);
+        graphics.on.preRender.remove(this.__render, this);
 
         graphics.viewport.size.onChanged.remove(this.__set_viewport_size, this);
 

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -63,7 +63,7 @@ import {
 import { seededRandom } from "../../../../../../../core/math/random/seededRandom.js";
 import { TransformedShape3D } from "../../../../../../../core/geom/3d/shape/TransformedShape3D.js";
 import { mat4 } from "gl-matrix";
-import { CompositeShape3D } from "../../../../../../../core/geom/3d/shape/CompositeShape.js";
+import { UnionShape3D } from "../../../../../../../core/geom/3d/shape/UnionShape3D.js";
 import { ShadedGeometry } from "../../../../../ecs/mesh-v2/ShadedGeometry.js";
 import { DrawMode } from "../../../../../ecs/mesh-v2/DrawMode.js";
 import { makeHelperBoxGeometry } from "../../../../../../../editor/process/symbolic/makeHelperBoxGeometry.js";
@@ -313,7 +313,7 @@ async function sample_scene_0(engine) {
     await make_demo_volume({
         ecd: ecd,
         lut: heatmap_lut_0,
-        shape: CompositeShape3D.from([
+        shape: UnionShape3D.from([
             TransformedShape3D.from_m4(new UnitCubeShape3D(), mat_from_aabb3(new AABB3(67.73, 0, 89, 115.84, 3, 118.34))),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), mat_from_aabb3(new AABB3(98, 0, 76.5, 109.5, 3, 89)))
         ]),
@@ -325,7 +325,7 @@ async function sample_scene_0(engine) {
     await make_demo_volume({
         ecd: ecd,
         lut: heatmap_lut_0,
-        shape: CompositeShape3D.from([
+        shape: UnionShape3D.from([
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [14.980091485108495, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 7.469446746375293, 0, 54.83080514238756, 1.568241402881399, 92.51937192481576, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [6.644515553810907, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 5.507507223409315, 0, 46.95032009188344, 1.568241402881399, 95.54148649329517, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [23.762890107594952, 0, 0, 0, 0, 2.812495250139616, 0, 0, 0, 0, 34.57956316503163, 0, 55.436098243647756, 1.568241402881399, 113.46988143189215, 1])
@@ -349,7 +349,7 @@ async function sample_scene_0(engine) {
     await make_demo_volume({
         ecd: ecd,
         lut: heatmap_lut_pink_to_blue,
-        shape: CompositeShape3D.from([
+        shape: UnionShape3D.from([
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [15.218520811592711, 0, 0, 0, 0, 3.058639690434693, 0, 0, 0, 0, 5.828701399328644, 0, 89.53848861962253, 2.0721850959505907, 73.05504876489894, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [18.10977091153633, 0, 0, 0, 0, 3.058639690434693, 0, 0, 0, 0, 2.5862076050328002, 0, 88.03260126722904, 2.0721850959505907, 69.0797462656922, 1])
         ]),
@@ -363,7 +363,7 @@ async function sample_scene_0(engine) {
     await make_demo_volume({
         ecd: ecd,
         lut: heatmap_lut_3,
-        shape: CompositeShape3D.from([
+        shape: UnionShape3D.from([
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [20.977896627021547, 0, 0, 0, 0, 2.956899734575006, 0, 0, 0, 0, 36.201589869571954, 0, 99.2120028317975, 1.5919924971428276, 49.21655402009093, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [24.455615450514458, 0, 0, 0, 0, 2.956899734575006, 0, 0, 0, 0, 28.081536987027807, 0, 80.11618755300161, 1.5919924971428276, 45.13808745329574, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [5.562874425497998, 0, 0, 0, 0, 2.956899734575006, 0, 0, 0, 0, 2.654155224548708, 0, 70.80986716000054, 1.5919924971428276, 59.679876796143446, 1])
@@ -378,7 +378,7 @@ async function sample_scene_0(engine) {
     await make_demo_volume({
         ecd: ecd,
         lut: heatmap_lut_orange_to_red,
-        shape: CompositeShape3D.from([
+        shape: UnionShape3D.from([
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [-3.8971594611231577, -1.9562533614625899, -0.5725042419276598, 0, -8.346390838999248, 16.986127440019352, -1.226109479938015, 0, 0.12112312197093604, 0, -0.8245111322851176, 0, 55.83305788880312, 9.579537179233043, 83.59013920067233, 1]),
             TransformedShape3D.from_m4(new UnitSphereShape3D(), [10.237283879346698, 0, 0, 0, 0, 10.237283879346698, 0, 0, 0, 0, 10.237283879346698, 0, 51.783732965076716, 18.028888481196716, 82.91084586075068, 1])
         ]),
@@ -555,7 +555,7 @@ async function sample_scene_nam(engine) {
     await make_demo_volume({
         ecd: ecd,
         lut: heatmap_lut_pink_to_blue,
-        shape: CompositeShape3D.from([
+        shape: UnionShape3D.from([
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [5.985827128973811, 0, 0, 0, 0, 2.435269776236539, 0, 0, 0, 0, 4.669621139110231, 0, 11.08356834576874, 1.2643565739307023, 2.4360416869081885, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [8.413758403821523, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 7.775469675813772, 0, 4.313201108449287, 1.4169994923726943, 4.011630095541064, 1]),
             TransformedShape3D.from_m4(new UnitCubeShape3D(), [8.413758403821523, 0, 0, 0, 0, 2.3166487265965343, 0, 0, 0, 0, 2.925065210015915, 0, 12.417224289491141, 1.4169994923726943, 6.432483110925785, 1])

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -173,13 +173,19 @@ export class ShadowMapRenderer {
 
         if (shadow.map === null) {
 
-            const pars = { format: RGBAFormat };
+            const pars = {
+                format: RGBAFormat,
+                scissorTest: false,
+                stencilBuffer: false
+            };
 
             if (!shadow.isPointLightShadow && renderer.shadowMap.type === VSMShadowMap) {
                 pars.minFilter = LinearFilter;
                 pars.magFilter = LinearFilter;
 
-                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
+                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, Object.assign({
+                    depthBuffer: false
+                }, pars));
 
             } else {
                 pars.minFilter = NearestFilter;

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.25",
+  "version": "2.33.26",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",