@woosh/meep-engine 2.33.22 → 2.33.26

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/ecs/path/testPathDisplaySystem.js

@@ -106,11 +106,11 @@ function makeConfig(engine) {
         new TopDownCameraControllerSystem(graphics),
         new TopDownCameraLanderSystem(),
         new CameraSystem(graphics.scene, graphics),
-        new MeshSystem(graphics, assetManager),
+        new MeshSystem(engine),
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),
@@ -179,11 +179,11 @@ function catmullRom(points) {
     cv.link();
 
     cv.css({
-               position: "absolute",
-               left: 0,
-               right: 0,
-               zIndex: 99999
-           });
+        position: "absolute",
+        left: 0,
+        right: 0,
+        zIndex: 99999
+    });
 
     const sample = [];
 
@@ -216,92 +216,92 @@ function sample_style_entity() {
     const style = new EntityPathStyle();
     style.spacing = 0.6;
     style.marker_start = EntityPathMarkerDefinition.from({
-                                                             blueprint: EntityBlueprint.from([
-                                                                                                 Transform.fromJSON({}),
-                                                                                                 Mesh.fromJSON({
-                                                                                                                   url: "data/models/arrow-symbols/arrow4/model-green.gltf",
-                                                                                                                   castShadow: true,
-                                                                                                                   receiveShadow: true
-                                                                                                               })
-                                                                                             ]),
-                                                             transform: Transform.fromJSON({
-                                                                                               scale: {
-                                                                                                   x: 0.3,
-                                                                                                   y: 0.3,
-                                                                                                   z: 0.3
-                                                                                               },
-                                                                                               rotation: {
-                                                                                                   x: 0.5,
-                                                                                                   y: -0.5,
-                                                                                                   z: 0.5,
-                                                                                                   w: 0.5
-                                                                                               },
-                                                                                               position: {
-                                                                                                   x: 0,
-                                                                                                   y: 1,
-                                                                                                   z: 0
-                                                                                               }
-                                                                                           })
-                                                         });
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/arrow-symbols/arrow4/model-green.gltf",
+                castShadow: true,
+                receiveShadow: true
+            })
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.3,
+                y: 0.3,
+                z: 0.3
+            },
+            rotation: {
+                x: 0.5,
+                y: -0.5,
+                z: 0.5,
+                w: 0.5
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
     style.marker_end = EntityPathMarkerDefinition.from({
-                                                           blueprint: EntityBlueprint.from([
-                                                                                               Transform.fromJSON({}),
-                                                                                               Mesh.fromJSON({
-                                                                                                                 url: "data/models/arrow-symbols/arrow4/model-red.gltf",
-                                                                                                                 castShadow: true,
-                                                                                                                 receiveShadow: true
-                                                                                                             })
-                                                                                           ]),
-                                                           transform: Transform.fromJSON({
-                                                                                             scale: {
-                                                                                                 x: 0.3,
-                                                                                                 y: 0.3,
-                                                                                                 z: 0.3
-                                                                                             },
-                                                                                             rotation: {
-                                                                                                 x: 0.5,
-                                                                                                 y: -0.5,
-                                                                                                 z: 0.5,
-                                                                                                 w: 0.5
-                                                                                             },
-                                                                                             position: {
-                                                                                                 x: 0,
-                                                                                                 y: 1,
-                                                                                                 z: 0
-                                                                                             }
-                                                                                         })
-                                                       });
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/arrow-symbols/arrow4/model-red.gltf",
+                castShadow: true,
+                receiveShadow: true
+            })
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.3,
+                y: 0.3,
+                z: 0.3
+            },
+            rotation: {
+                x: 0.5,
+                y: -0.5,
+                z: 0.5,
+                w: 0.5
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
     style.marker_main = EntityPathMarkerDefinition.from({
-                                                            blueprint: EntityBlueprint.from([
-                                                                                                Transform.fromJSON({}),
-                                                                                                Mesh.fromJSON({
-                                                                                                                  url: "data/models/Barel-Roll Droid/handpainted.gltf",
-                                                                                                                  castShadow: true,
-                                                                                                                  receiveShadow: true
-                                                                                                              }),
-                                                                                                Animation.fromJSON({
-                                                                                                                       clips: [
-                                                                                                                           {
-                                                                                                                               name: "fly",
-                                                                                                                               repeatCount: Infinity
-                                                                                                                           }
-                                                                                                                       ]
-                                                                                                                   }),
-                                                                                                Highlight.fromOne(1, 0, 0, 1)
-                                                                                            ]),
-                                                            transform: Transform.fromJSON({
-                                                                                              scale: {
-                                                                                                  x: 0.2,
-                                                                                                  y: 0.2,
-                                                                                                  z: 0.2
-                                                                                              },
-                                                                                              position: {
-                                                                                                  x: 0,
-                                                                                                  y: 1,
-                                                                                                  z: 0
-                                                                                              }
-                                                                                          })
-                                                        });
+        blueprint: EntityBlueprint.from([
+            Transform.fromJSON({}),
+            Mesh.fromJSON({
+                url: "data/models/Barel-Roll Droid/handpainted.gltf",
+                castShadow: true,
+                receiveShadow: true
+            }),
+            Animation.fromJSON({
+                clips: [
+                    {
+                        name: "fly",
+                        repeatCount: Infinity
+                    }
+                ]
+            }),
+            Highlight.fromOne(1, 0, 0, 1)
+        ]),
+        transform: Transform.fromJSON({
+            scale: {
+                x: 0.2,
+                y: 0.2,
+                z: 0.2
+            },
+            position: {
+                x: 0,
+                y: 1,
+                z: 0
+            }
+        })
+    });
 
     return style;
 }
@@ -337,13 +337,13 @@ function main(engine) {
     // ], 50));
 
     _p.setPositionsFromVectorArray([
-                                       new Vector3(3, 1, 1),
-                                       new Vector3(3, 1, 3),
-                                       new Vector3(7, 1, 3),
-                                       new Vector3(7, 1, 7),
-                                       new Vector3(3, 1, 7),
-                                       new Vector3(3, 1, 8),
-                                   ]);
+        new Vector3(3, 1, 1),
+        new Vector3(3, 1, 3),
+        new Vector3(7, 1, 3),
+        new Vector3(7, 1, 7),
+        new Vector3(3, 1, 7),
+        new Vector3(3, 1, 8),
+    ]);
 
 
     const trailPathStyle = new RibbonPathStyle();

package/engine/graphics/ecs/trail2d/Trail2D.js

@@ -5,6 +5,7 @@
 
 import Vector3 from "../../../../core/geom/Vector3.js";
 import Vector4 from "../../../../core/geom/Vector4.js";
+import { RibbonXMaterialSpec } from "../../trail/x/RibbonXMaterialSpec.js";
 
 /**
  * @readonly
@@ -24,8 +25,6 @@ class Trail2D {
          */
         this.maxAge = 5;
 
-        this.textureURL = null;
-
         /**
          * Trail width
          * @type {number}
@@ -65,9 +64,9 @@ class Trail2D {
 
         /**
          * transient
-         * @type {Material|null}
+         * @type {RibbonXMaterialSpec}
          */
-        this.material = null;
+        this.material = new RibbonXMaterialSpec();
 
         /**
          * transient
@@ -82,6 +81,20 @@ class Trail2D {
         this.flags = Trail2DFlags.Spawning | Trail2DFlags.Aging;
     }
 
+    dispose() {
+        if (this.ribbon !== null) {
+            this.ribbon.dispose();
+        }
+    }
+
+    get textureURL() {
+        return this.material.diffuse;
+    }
+
+    set textureURL(v) {
+        this.material.diffuse = v;
+    }
+
     /**
      *
      * @param {number|Trail2DFlags} flag

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

@@ -1,7 +1,6 @@
 import {System} from "../../../ecs/System";
-import {GraphicsEngine} from "../../GraphicsEngine";
-import {AssetManager} from "../../../asset/AssetManager";
+import Engine from "../../../Engine";
 
 export default class Trail2DSystem extends System {
-    constructor(graphics: GraphicsEngine, assetManager: AssetManager)
+    constructor(engine: Engine)
 }