@woosh/meep-engine 2.33.23 → 2.33.27

package/engine/graphics/composit/CompositingStages.js

@@ -0,0 +1,8 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const CompositingStages = {
+    POST_OPAQUE: 1,
+    POST_TRANSPARENT: 0
+}

package/engine/graphics/composit/LayerCompositer.js

@@ -52,8 +52,6 @@ class LayerCompositer {
 
         layer.renderTarget.dispose();
 
-        this.scene.remove(layer.object);
-
         return true;
     }
 
@@ -113,8 +111,6 @@ class LayerCompositer {
 
         this.layerTargets.push(layer);
 
-        this.scene.add(layer.object);
-
         return true;
     }
 
@@ -138,13 +134,46 @@ class LayerCompositer {
 
     /**
      *
-     * @param {WebGLRenderer} renderer
+     * @param {number} stage
+     * @private
      */
-    composite(renderer) {
+    __prepare_scene_for_stage(stage) {
+        const layers = this.layerTargets;
+        const layer_count = layers.length;
+
+        const scene = this.scene;
+
+        let child_count = 0;
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = layers[i];
+
+            if (layer.stage !== stage) {
+                continue;
+            }
+
+            scene.children[child_count++] = layer.object;
+
+            layer.on.preRender.send0();
+        }
+
+        scene.children.length = child_count;
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {number} stage
+     */
+    composite(renderer, stage) {
+        assert.isNonNegativeInteger(stage, 'stage');
+
         if (!this.hasActiveLayers()) {
             return;
         }
 
+        this.__prepare_scene_for_stage(stage);
+
         const camera = this.camera;
         const scene = this.scene;
 

package/engine/graphics/ecs/animation/animator/AnimationClip.js

@@ -1,8 +1,9 @@
-import { computeHashFloat, computeHashIntegerArray} from "../../../../../core/math/MathUtils.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { AnimationClipFlag } from "./AnimationClipFlag.js";
 import { LoopOnce, LoopRepeat } from "three";
 import { AnimationEventTypes } from "./AnimationEventTypes.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationClip {
     constructor() {

package/engine/graphics/ecs/animation/animator/AnimationClipDefinition.js

@@ -1,7 +1,8 @@
 import { isArrayEqual } from "../../../../../core/collection/ArrayUtils.js";
-import { computeHashArray, computeHashIntegerArray } from "../../../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
 import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
+import { computeHashArray } from "../../../../../core/collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
 
 /**
  *

package/engine/graphics/ecs/animation/animator/AnimationNotification.js

@@ -1,4 +1,5 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationNotification {
     constructor() {

package/engine/graphics/ecs/animation/animator/AnimationNotificationDefinition.js

@@ -1,6 +1,7 @@
-import { computeHashIntegerArray, computeObjectHash } from "../../../../../core/math/MathUtils.js";
 import { objectDeepEquals } from "../../../../../core/model/object/objectDeepEquals.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeObjectHash } from "../../../../../core/math/hash/computeObjectHash.js";
 
 export class AnimationNotificationDefinition {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/AnimationGraph.js

@@ -3,11 +3,12 @@ import { AnimationTransition } from "./AnimationTransition.js";
 import { AnimationStateType } from "./AnimationStateType.js";
 import { AnimationMixer } from "three";
 import { AnimationGraphFlag } from "./AnimationGraphFlag.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../../core/math/MathUtils.js";
 import { writeAnimationGraphDefinitionToJSON } from "./definition/serialization/writeAnimationGraphDefinitionToJSON.js";
 import { readAnimationGraphDefinitionFromJSON } from "./definition/serialization/readAnimationGraphDefinitionFromJSON.js";
 import { assert } from "../../../../../../core/assert.js";
 import { threeUpdateTransform } from "../../../../util/threeUpdateTransform.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationGraph {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/definition/AnimationGraphDefinition.js

@@ -4,8 +4,9 @@ import { AnimationStateDefinition } from "./AnimationStateDefinition.js";
 import { AnimationClipDefinition } from "../../AnimationClipDefinition.js";
 import { AnimationClip } from "../../AnimationClip.js";
 import { isArrayEqual } from "../../../../../../../core/collection/ArrayUtils.js";
-import { computeHashArray, computeHashIntegerArray } from "../../../../../../../core/math/MathUtils.js";
 import { invokeObjectHash } from "../../../../../../../core/model/object/invokeObjectHash.js";
+import { computeHashArray } from "../../../../../../../core/collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class AnimationGraphDefinition {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/definition/AnimationStateDefinition.js

@@ -1,5 +1,5 @@
 import { AnimationStateType } from "../AnimationStateType.js";
-import { computeHashIntegerArray } from "../../../../../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../../../../../core/collection/array/computeHashIntegerArray.js";
 
 export class AnimationStateDefinition {
     constructor() {

package/engine/graphics/ecs/animation/animator/graph/definition/AnimationTransitionDefinition.js

@@ -1,5 +1,6 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../../core/math/hash/computeHashFloat.js";
 
 export class AnimationTransitionDefinition {
     constructor() {

package/engine/graphics/ecs/camera/CameraClippingPlaneComputer.js

@@ -1,7 +1,7 @@
-import { isValueBetweenInclusive } from "../../../../core/math/MathUtils.js";
 import { frustumFromCamera } from "./CameraSystem.js";
 import { Frustum as ThreeFrustum } from "three";
 import { v3_dot } from "../../../../core/geom/v3_dot.js";
+import { isValueBetweenInclusive } from "../../../../core/math/isValueBetweenInclusive.js";
 
 const CLIPPING_EPSILON = 0.001;
 

package/engine/graphics/ecs/highlight/HighlightDefinition.js

@@ -1,7 +1,8 @@
 import { Color } from "../../../../core/color/Color.js";
 import { assert } from "../../../../core/assert.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { COMPONENT_SERIALIZATION_TRANSIENT_FIELD } from "../../../ecs/storage/COMPONENT_SERIALIZATION_TRANSIENT_FIELD.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 export class HighlightDefinition {
     constructor() {

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

@@ -7,6 +7,7 @@ import { HighlightRenderGroup } from "../renderer/HighlightRenderGroup.js";
 import { ObjectPoolFactory } from "../../../../../core/model/object/ObjectPoolFactory.js";
 import { HighlightRenderElement } from "../renderer/HighlightRenderElement.js";
 import { noop } from "../../../../../core/function/Functions.js";
+import { CompositingStages } from "../../../composit/CompositingStages.js";
 
 export class OutlineRenderPlugin extends EnginePlugin {
     constructor() {
@@ -99,12 +100,14 @@ export class OutlineRenderPlugin extends EnginePlugin {
 
     /**
      *
-     * @param {WebGLRenderer} renderer
-     * @param {Camera} camera
-     * @param {ThreeScene} scene
      * @private
      */
-    __render(renderer, camera, scene) {
+    __render() {
+        const engine = this.engine;
+        const graphics = engine.graphics;
+
+        const camera = graphics.camera;
+
         // collect elements
         const source_count = this.__sources.length;
 
@@ -139,11 +142,12 @@ export class OutlineRenderPlugin extends EnginePlugin {
 
         viewport_size.process(this.__set_viewport_size, this);
 
-        graphics.on.preComposite.add(this.__render, this);
-
         // create compositing layer
         this.__compositing_layer = graphics.layerComposer.createLayer(this.__renderer.__renderTargetFinal, BlendingType.MultiplyAdd);
         this.__compositing_layer.name = "Silhouette Outline";
+        this.__compositing_layer.stage = CompositingStages.POST_TRANSPARENT;
+
+        graphics.on.preRender.add(this.__render, this);
 
 
         // set rendering resolution
@@ -156,7 +160,7 @@ export class OutlineRenderPlugin extends EnginePlugin {
 
         const graphics = this.engine.graphics;
 
-        graphics.on.preComposite.remove(this.__render, this);
+        graphics.on.preRender.remove(this.__render, this);
 
         graphics.viewport.size.onChanged.remove(this.__set_viewport_size, this);
 

package/engine/graphics/ecs/light/Light.d.ts

@@ -1,6 +1,6 @@
 import ObservedEnum from "../../../../core/model/ObservedEnum";
 import {Color} from "../../../../core/color/Color";
-import {Vector1} from "../../../../core/geom/Vector1";
+import Vector1 from "../../../../core/geom/Vector1";
 import ObservedBoolean from "../../../../core/model/ObservedBoolean";
 import {LightType} from "./LightType";
 

package/engine/graphics/ecs/light/Light.js

@@ -103,9 +103,14 @@ export class Light {
 
         if (json.intensity !== undefined) {
             this.intensity.fromJSON(json.intensity);
+        } else {
+            this.intensity.set(1);
         }
+
         if (json.castShadow !== undefined) {
             this.castShadow.fromJSON(json.castShadow);
+        } else {
+            this.castShadow.set(false);
         }
 
         const actual_type = this.type.getValue();

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

@@ -99,7 +99,8 @@ export class ThreeLightBinding extends LightBinding {
          */
         const cache = this.__system.__three_light_cache;
 
-        threeEnsureLightObject(this.__c_light, cache);
+        const c_light = this.__c_light;
+        threeEnsureLightObject(c_light, cache);
 
         super.link(ctx);
     }
@@ -112,6 +113,9 @@ export class ThreeLightBinding extends LightBinding {
 
         cache.release(this.__three_getLight());
 
+        // clear bound light
+        this.__c_light.__threeObject = null;
+
         this.__shadowmap_unlink();
 
         super.unlink(ctx);

package/engine/graphics/ecs/mesh/Mesh.js

@@ -3,13 +3,14 @@
  */
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { getSkeletonBoneByType } from "./SkeletonUtils.js";
 import { assert } from "../../../../core/assert.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { updateNodeByTransformAndBBB } from "./updateNodeByTransformAndBBB.js";
 import { applyTransformToThreeObject } from "./applyTransformToThreeObject.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/graphics/ecs/mesh-v2/DrawMode.js

@@ -0,0 +1,5 @@
+export const DrawMode = {
+    Triangles: 0,
+    Lines: 2,
+    LineSegments: 3
+};

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.d.ts

@@ -0,0 +1,13 @@
+import {BufferGeometry, Material} from "three";
+import {AABB3} from "../../../../core/bvh2/aabb3/AABB3";
+
+export class ShadedGeometry {
+    readonly geometry: BufferGeometry
+    readonly material: Material
+
+    readonly bvh: Readonly<AABB3>
+
+    from(geometry: BufferGeometry, material: Material): void
+
+    static from(geometry: BufferGeometry, material: Material): ShadedGeometry
+}

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -1,9 +1,10 @@
-import { Mesh, Quaternion } from "three";
+import { Line, LineSegments, Mesh } from "three";
 import { updateNodeByMatrix4AndBBB } from "../mesh/updateNodeByTransformAndBBB.js";
 import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
 import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
+import { DrawMode } from "./DrawMode.js";
+import { applyTransformToThreeObject } from "../mesh/applyTransformToThreeObject.js";
 
-const _q = new Quaternion();
 const _aabb3 = new AABB3();
 
 export class ShadedGeometry {
@@ -19,6 +20,12 @@ export class ShadedGeometry {
          */
         this.material = null;
 
+        /**
+         *
+         * @type {DrawMode|number}
+         */
+        this.mode = DrawMode.Triangles;
+
         /**
          *
          * @type {THREE.Object3D|null}
@@ -34,6 +41,19 @@ export class ShadedGeometry {
         this.__bvh_leaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
     }
 
+    __build_object() {
+        const mode = this.mode;
+        if (mode === DrawMode.Triangles) {
+            this.__cached_object = new Mesh(this.geometry, this.material);
+        } else if (mode === DrawMode.Lines) {
+            this.__cached_object = new Line(this.geometry, this.material);
+        } else if (mode === DrawMode.LineSegments) {
+            this.__cached_object = new LineSegments(this.geometry, this.material);
+        } else {
+            throw new Error(`Unsupported draw mode '${mode}'`);
+        }
+    }
+
     get bvh() {
         return this.__bvh_leaf;
     }
@@ -42,10 +62,12 @@ export class ShadedGeometry {
      *
      * @param {THREE.BufferGeometry} geometry
      * @param {THREE.Material} material
+     * @param draw_mode
      */
-    from(geometry, material) {
+    from(geometry, material, draw_mode = DrawMode.Triangles) {
         this.geometry = geometry;
         this.material = material;
+        this.mode = draw_mode;
 
         // ensure that geometry has a bounding box
         if (geometry.boundingBox === null) {
@@ -53,7 +75,7 @@ export class ShadedGeometry {
         }
 
         if (this.__cached_object === null) {
-            this.__cached_object = new Mesh(geometry, material);
+            this.__build_object();
         } else {
             this.__cached_object.material = material;
             this.__cached_object.geometry = geometry;
@@ -64,12 +86,13 @@ export class ShadedGeometry {
      *
      * @param geometry
      * @param material
+     * @param mode
      * @return {ShadedGeometry}
      */
-    static from(geometry, material) {
+    static from(geometry, material, mode) {
         const r = new ShadedGeometry();
 
-        r.from(geometry, material);
+        r.from(geometry, material, mode);
 
         return r;
     }
@@ -77,6 +100,7 @@ export class ShadedGeometry {
     updateTransform() {
         // update matrix
         this.__cached_object.updateMatrix();
+        this.__cached_object.updateMatrixWorld();
 
         // update bounds
 
@@ -116,9 +140,7 @@ export class ShadedGeometry {
      */
     setRotationByComponents(x, y, z, w) {
 
-        _q.set(x, y, z, w);
-
-        this.__cached_object.rotation.setFromQuaternion(_q);
+        this.__cached_object.quaternion.set(x, y, z, w);
 
         this.updateTransform();
     }
@@ -140,15 +162,7 @@ export class ShadedGeometry {
      * @param {Transform} t
      */
     applyTransform(t) {
-        // TODO this can be optimized quite a lot
-        const position = t.position;
-        this.setPositionByComponents(position.x, position.y, position.z);
-
-        const rotation = t.rotation;
-        this.setRotationByComponents(rotation.x, rotation.y, rotation.z, rotation.w);
-
-        const scale = t.scale;
-        this.setScaleByComponents(scale.x, scale.y, scale.z);
+        applyTransformToThreeObject(this.__cached_object, t);
 
         this.updateTransform();
     }

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

@@ -0,0 +1,6 @@
+import {System} from "../../../ecs/System";
+import Engine from "../../../Engine";
+
+export class ShadedGeometrySystem extends System {
+    constructor(engine: Engine)
+}

package/engine/graphics/geometry/AttributeSpec.js

@@ -0,0 +1,105 @@
+import { DataType } from "../../../core/collection/table/DataType.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { DataTypeByteSizes } from "../../../core/collection/table/DataTypeByteSizes.js";
+import { assert } from "../../../core/assert.js";
+
+export class AttributeSpec {
+    constructor() {
+        /**
+         *
+         * @type {string}
+         */
+        this.name = "";
+
+        /**
+         *
+         * @type {DataType}
+         */
+        this.type = DataType.Float32;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.itemSize = 1;
+
+        /**
+         * Normalized values will be automatically converted to float32 in the shader
+         * This gives good optimization opportunities for things like normal vectors
+         * Applies to integer types only
+         * @type {boolean}
+         */
+        this.normalized = false;
+    }
+
+    static fromJSON(j) {
+        const r = new AttributeSpec();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+
+    fromJSON({
+                 name,
+                 type,
+                 itemSize,
+                 normalized = false
+             }) {
+
+        assert.isString(name, 'name');
+        assert.enum(type, DataType, 'type');
+
+        assert.isNumber(itemSize, 'itemSize');
+        assert.isNonNegativeInteger(itemSize, 'itemSize');
+        assert.greaterThanOrEqual(itemSize, 1, 'itemSize must be >= 1');
+
+        assert.isBoolean(normalized, 'normalized');
+
+        this.name = name;
+        this.type = type;
+        this.itemSize = itemSize;
+        this.normalized = normalized;
+    }
+
+    hash() {
+        return computeStringHash(this.name);
+    }
+
+    /**
+     *
+     * @param {AttributeSpec} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.type === other.type
+            && this.itemSize === other.itemSize
+            && this.normalized === other.normalized
+            && this.name === other.name
+            ;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    getByteSize() {
+        return this.itemSize * DataTypeByteSizes[this.type];
+    }
+
+    /**
+     *
+     * @param {AttributeSpec} a
+     * @param {AttributeSpec} b
+     * @return {number}
+     */
+    static byName(a, b) {
+        return a.name.localeCompare(b.name);
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AttributeSpec.prototype.isAttributeSpec = true;

package/engine/graphics/{micron/format/MicronVertexDataSpec.js → geometry/VertexDataSpec.js}

@@ -1,14 +1,14 @@
-import { isArrayEqual } from "../../../../core/collection/ArrayUtils.js";
-import { computeHashArray } from "../../../../core/math/MathUtils.js";
-import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
+import { isArrayEqual } from "../../../core/collection/ArrayUtils.js";
+import { invokeObjectHash } from "../../../core/model/object/invokeObjectHash.js";
+import { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
 
 const DEFAULT_HASH = 123456;
 
-export class MicronVertexDataSpec {
+export class VertexDataSpec {
     constructor() {
         /**
          *
-         * @type {MicronGeometryBufferAttributeSpec[]}
+         * @type {AttributeSpec[]}
          */
         this.attributes = [];
 
@@ -22,7 +22,49 @@ export class MicronVertexDataSpec {
 
     /**
      *
-     * @param {MicronGeometryBufferAttributeSpec[]} attributes
+     * @param {string} name
+     * @return {AttributeSpec|undefined}
+     */
+    getAttributeByName(name) {
+
+        const attributes = this.attributes;
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+            const attribute = attributes[i];
+
+            if (attribute.name === name) {
+                return attribute;
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     *
+     * @param {AttributeSpec} attribute
+     * @return {VertexDataSpec}
+     */
+    add(attribute) {
+
+        //check uniqueness of name
+        if (this.getAttributeByName(attribute.name) !== undefined) {
+            throw new Error(`Attribute named '${attribute.name}' already exists`);
+        }
+
+        this.attributes.push(attribute);
+
+        // reset hash
+        this.__hash = DEFAULT_HASH;
+
+        //for chaining, return self
+        return this;
+    }
+
+    /**
+     *
+     * @param {AttributeSpec[]} attributes
      */
     setAttributes(attributes) {
         this.attributes = attributes;
@@ -33,7 +75,7 @@ export class MicronVertexDataSpec {
 
     /**
      *
-     * @param {MicronVertexDataSpec} other
+     * @param {VertexDataSpec} other
      * @returns {boolean}
      */
     equals(other) {
@@ -56,24 +98,6 @@ export class MicronVertexDataSpec {
         return this.__hash;
     }
 
-    /**
-     *
-     * @param {string} name
-     * @return {MicronGeometryBufferAttributeSpec|undefined}
-     */
-    getAttributeByName(name) {
-        const attributes = this.attributes;
-        const n = attributes.length;
-        for (let i = 0; i < n; i++) {
-            const spec = attributes[i];
-
-            if (spec.name === name) {
-                return spec;
-            }
-        }
-
-    }
-
     /**
      *
      * @returns {number}
@@ -93,3 +117,10 @@ export class MicronVertexDataSpec {
         return result;
     }
 }
+
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+VertexDataSpec.prototype.isVertexDataSpec = true;