@woosh/meep-engine 2.36.0 → 2.36.4

package/engine/animation/curve/draw/plot_array.js

@@ -0,0 +1,76 @@
+import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+/**
+ *
+ * @param {number[]} data
+ * @return {number[]}
+ */
+export function array_compute_min_max(data) {
+    const point_count = data.length;
+
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < point_count; i++) {
+        min = min2(data[i], min);
+        max = max2(data[i], max);
+    }
+
+    return [min, max];
+}
+
+/**
+ *
+ * @param {CanvasRenderingContext2D} ctx
+ * @param {number} width
+ * @param {number} height
+ * @param {number} x_offset
+ * @param {number} y_offset
+ * @param {number[]} data
+ * @param {number[]} data_range_y
+ */
+export function plot_array(
+    ctx,
+    width,
+    height,
+    x_offset,
+    y_offset,
+    data,
+    data_range_y
+) {
+    const point_count = data.length;
+
+    if (data_range_y === undefined) {
+        data_range_y = array_compute_min_max(data)
+    }
+
+    const [min, max] = data_range_y;
+
+    const value_span = max - min;
+    const normalization_multiplier = value_span !== 0 ? 1 / value_span : 0;
+
+    ctx.beginPath();
+    if (point_count === 1) {
+        ctx.moveTo(x_offset, height + y_offset);
+        ctx.lineTo(x_offset + width, height + y_offset);
+    } else {
+
+        for (let i = 0; i < point_count; i++) {
+            const value = data[i];
+            const value_normalized = (value - min) * normalization_multiplier;
+
+            const v = 1 - value_normalized;
+            const u = i / (point_count - 1);
+
+            const x = u * width + x_offset;
+            const y = v * height + y_offset;
+
+            if (i === 0) {
+                ctx.moveTo(x, y);
+            } else {
+                ctx.lineTo(x, y);
+            }
+        }
+    }
+    ctx.stroke();
+}

package/engine/animation/curve/draw/plot_data.js

@@ -0,0 +1,49 @@
+import { draw_grid } from "./draw_grid.js";
+import { plot_array } from "./plot_array.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+
+/**
+ *
+ * @param {CanvasRenderingContext2D} ctx
+ * @param {number[]|Float32Array} data
+ * @param {Vector2} [margin]
+ * @param {number} width
+ * @param {number} height
+ * @param {number[]} [range_y]
+ */
+export function plot_data({
+                              ctx,
+                              data,
+                              margin = Vector2.zero,
+                              width,
+                              height,
+                              range_y
+                          }) {
+
+    ctx.fillStyle = '#222222';
+    ctx.fillRect(0, 0, width, height);
+
+    draw_grid({
+        ctx,
+        width,
+        height,
+        color: '#262626',
+        spacing: 32
+    });
+
+    draw_grid({
+        ctx,
+        width,
+        height,
+        color: '#303030',
+        spacing: 32,
+        offset_x: 16,
+        offset_y: 16
+    });
+
+    ctx.fillStyle = 'none';
+    ctx.strokeStyle = '#00ff00';
+    ctx.lineWidth = 1;
+    plot_array(ctx, width - margin.x * 2, height - margin.y * 2, margin.x, margin.y, data, range_y);
+
+}

package/engine/ecs/parent/EntityNode.d.ts

@@ -5,15 +5,19 @@ import {Transform} from "../transform/Transform";
 export class EntityNode {
     constructor(entity?: EntityBuilder)
 
-    parent: EntityNode | null
-    entity: EntityBuilder
+    readonly parent: EntityNode | null
+    readonly entity: EntityBuilder
 
-    transform: Transform
+    readonly transform: Transform
+
+    readonly children: Readonly<EntityNode[]>
 
     addChild(node: EntityNode): boolean
 
     removeChild(node: EntityNode): boolean
 
+    traverseChildren(visitor: (EntityNode) => void, thisArg?: any): void
+
     build(ecd: EntityComponentDataset): void
 
     destroy(): void

package/engine/ecs/parent/EntityNode.js

@@ -41,6 +41,23 @@ export class EntityNode {
         this.__transform = new Transform();
     }
 
+    /**
+     *
+     * @param {(EntityNode) => *} visitor
+     * @param {*} [context]
+     */
+    traverseChildren(visitor, context) {
+        this.__children.forEach(visitor, context);
+    }
+
+    /**
+     *
+     * @return {Readonly<EntityNode[]>}
+     */
+    get children() {
+        return this.__children;
+    }
+
     /**
      *
      * @private
@@ -162,6 +179,10 @@ export class EntityNode {
         }
     }
 
+    /**
+     *
+     * @return {EntityBuilder}
+     */
     get entity() {
         return this.__entity;
     }

package/engine/ecs/parent/entity_node_compute_bounding_box.js

@@ -0,0 +1,41 @@
+import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { AABB3 } from "../../../core/bvh2/aabb3/AABB3.js";
+
+const scratch_aabb3 = new AABB3();
+
+/**
+ *
+ * @param {AABB3} out
+ * @param {EntityNode} root
+ */
+export function entity_node_expand_bounding_box_to_fit(out, root) {
+    const sg = root.entity.getComponent(ShadedGeometry);
+
+    if (sg !== null) {
+        sg.getBoundingBox(scratch_aabb3);
+
+        out.expandToFit(scratch_aabb3);
+    }
+
+    const children = root.children;
+    const child_count = children.length;
+
+    for (let i = 0; i < child_count; i++) {
+        const child = children[i];
+
+        entity_node_expand_bounding_box_to_fit(out, child);
+    }
+}
+
+/**
+ *
+ * @param {AABB3} out
+ * @param {EntityNode} root
+ */
+export function entity_node_compute_bounding_box(out, root) {
+    // init bounds
+    out.setNegativelyInfiniteBounds();
+
+    // expand bounds to fit the tree
+    entity_node_expand_bounding_box_to_fit(out, root);
+}

package/engine/graphics/ecs/highlight/HighlightDefinition.d.ts

@@ -1,6 +1,16 @@
 import {Color} from "../../../../core/color/Color";
 
 export class HighlightDefinition {
-    color: Color
+    readonly color: Color
     opacity: number
+
+    static rgba(r: number, g: number, b: number, a?: number): HighlightDefinition
+
+    equals(other: HighlightDefinition): boolean
+
+    hash(): number
+
+    fromJSON(json: any): void
+
+    toJSON(): any
 }

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

@@ -1,6 +1,5 @@
 import { Color } from "../../../../core/color/Color.js";
 import { assert } from "../../../../core/assert.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";
 
@@ -8,7 +7,7 @@ export class HighlightDefinition {
     constructor() {
 
         /**
-         *
+         * @readonly
          * @type {Color}
          */
         this.color = new Color();
@@ -18,12 +17,6 @@ export class HighlightDefinition {
          * @type {number}
          */
         this.opacity = 1;
-
-        /**
-         *
-         * @type {boolean}
-         */
-        this[COMPONENT_SERIALIZATION_TRANSIENT_FIELD] = false;
     }
 
     /**
@@ -73,4 +66,21 @@ export class HighlightDefinition {
 
         return r;
     }
+
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} [a]
+     * @return {HighlightDefinition}
+     */
+    static rgba(r, g, b, a = 1) {
+        const result = new HighlightDefinition();
+
+        result.color.setRGB(r, g, b);
+        result.opacity = a;
+
+        return result;
+    }
 }

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

@@ -10,7 +10,9 @@ import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererCo
 import { assert } from "../../../../core/assert.js";
 import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_compose.js";
 import { ray3_array_apply_matrix4 } from "../../../../core/geom/3d/ray/ray3_array_apply_matrix4.js";
-import { ExplicitBinaryBoundingVolumeHierarchy } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
+import {
+    ExplicitBinaryBoundingVolumeHierarchy
+} from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
 import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/bvh_query_leaves_generic.js";
 import { BVHQueryIntersectsRay } from "../../../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
 
@@ -157,6 +159,8 @@ export class ShadedGeometrySystem extends System {
 
     async startup(entityManager, readyCallback, errorCallback) {
 
+        this.entityManager = entityManager;
+
         const engine = this.__engine;
         const graphics = engine.graphics;
 

package/engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js

@@ -0,0 +1,122 @@
+export const SGMeshFlags = {
+    CastShadow: 1,
+    ReceiveShadow: 2
+};
+
+export class SGMesh {
+    constructor() {
+        /**
+         *
+         * @type {string|null}
+         */
+        this.__url = null;
+
+        /**
+         *
+         * @type {EntityNode|null}
+         * @private
+         */
+        this.__node = null;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.flags = 0;
+    }
+
+    /**
+     *
+     * @returns {string|null}
+     */
+    get url() {
+        return this.__url;
+    }
+
+    /**
+     *
+     * @param {string|null} v
+     */
+    set url(v) {
+        if (v === this.__url) {
+            // no change
+            return;
+        }
+
+        this.__url = v;
+    }
+
+    /**
+     *
+     * @param {number|SGMeshFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|SGMeshFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|SGMeshFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|SGMeshFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
+    }
+
+    /**
+     *
+     * @return {boolean}
+     */
+    get castShadow() {
+        return this.getFlag(SGMeshFlags.CastShadow);
+    }
+
+    /**
+     *
+     * @param {boolean} v
+     */
+    set castShadow(v) {
+        this.writeFlag(SGMeshFlags.CastShadow, v);
+    }
+
+    /**
+     *
+     * @return {boolean}
+     */
+    get receiveShadow() {
+        return this.getFlag(SGMeshFlags.ReceiveShadow);
+    }
+
+    /**
+     *
+     * @param {boolean} v
+     */
+    set receiveShadow(v) {
+        this.writeFlag(SGMeshFlags.ReceiveShadow, v);
+    }
+}
+
+SGMesh.typeName = "SGMesh";

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.js

@@ -0,0 +1,148 @@
+import { System } from "../../../../ecs/System.js";
+import { SGMesh } from "./SGMesh.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { assetTypeByPath } from "../../mesh/assetTypeByPath.js";
+import { three_object_to_entity_composition } from "../three_object_to_entity_composition.js";
+
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const CYCLE_COUNT = 128;
+
+export class SGMeshSystem extends System {
+    /**
+     *
+     * @param {Engine} engine
+     */
+    constructor(engine) {
+        super();
+
+        /**
+         *
+         * @type {Engine}
+         * @private
+         */
+        this.__engine = engine;
+
+        /**
+         *
+         * @type {AssetManager}
+         * @private
+         */
+        this.__assetManager = engine.assetManager;
+
+        this.dependencies = [SGMesh, Transform];
+
+        /**
+         *
+         * @type {number[]}
+         * @private
+         */
+        this.__wait_queue = [];
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__wait_queue_process_index = 0;
+    }
+
+    /**
+     *
+     * @param {number} entity
+     * @param {SGMesh} mesh
+     * @param {Transform} transform
+     */
+    async process(entity, mesh, transform) {
+        const am = this.__assetManager;
+
+        const assetType = assetTypeByPath(component.url);
+
+        const asset = await am.promise(mesh.url, assetType);
+
+        // TODO check that entity still exists, as we get to this point asynchronously
+
+        const entity_node = three_object_to_entity_composition(asset.create());
+
+        mesh.__node = entity_node;
+
+        entity_node.build(this.entityManager.dataset);
+    }
+
+    /**
+     *
+     * @param {SGMesh} mesh
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(mesh, transform, entity) {
+        if (mesh.url === null) {
+            this.__wait_queue.push(entity);
+            return;
+        }
+
+        this.process(entity, mesh, transform);
+    }
+
+    /**
+     *
+     * @param {SGMesh} mesh
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(mesh, transform, entity) {
+        if (mesh.__node !== null) {
+            mesh.__node.destroy();
+
+            mesh.__node = null;
+        }
+
+        // check the queue
+        const i = this.__wait_queue.indexOf(entity);
+
+        if (i !== -1) {
+            this.__wait_queue.splice(i, 1);
+        }
+    }
+
+    update(time_delta) {
+
+        const waiting = this.__wait_queue;
+
+        let l = waiting.length;
+
+        if (l > 0) {
+
+            let pointer = this.__wait_queue_process_index;
+
+            const dataset = this.entityManager.dataset;
+
+            for (let i = 0; i < CYCLE_COUNT; i++) {
+
+                const index = pointer % l;
+
+                const entity = waiting[index];
+
+                const mesh = dataset.getComponent(entity, SGMesh);
+
+                if (mesh.url === null) {
+                    continue;
+                }
+
+                const transform = dataset.getComponent(entity, Transform);
+
+                this.process(entity, mesh, transform);
+
+                waiting.splice(i, 1);
+
+                i--;
+                l--;
+            }
+
+            this.__wait_queue_process_index = pointer;
+
+        }
+    }
+}

package/engine/graphics/ecs/mesh-v2/render/adapters/InstancedRendererAdapter.js

@@ -3,6 +3,7 @@ import { HashMap } from "../../../../../../core/collection/HashMap.js";
 import { InstancedMeshGroup } from "../../../../geometry/instancing/InstancedMeshGroup.js";
 import { ShadedGeometryFlags } from "../../ShadedGeometryFlags.js";
 import { DrawMode } from "../../DrawMode.js";
+import { StreamDrawUsage } from "three";
 
 const INSTANCED_EQUALITY_FLAGS = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
@@ -89,6 +90,7 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
             }
 
             im = new InstancedMeshGroup();
+            im.instance_usage = StreamDrawUsage;
             im.shrinkFactor = 0; // prevent shrinking as we're essentially rebuilding this geometry frame
 
             im.setMaterial(sg.material);

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

@@ -0,0 +1,4 @@
+import {Object3D} from "three";
+import {EntityNode} from "../../../ecs/parent/EntityNode";
+
+export function three_object_to_entity_composition(object: Object3D): EntityNode

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -1,10 +1,10 @@
 import {
     BufferGeometry,
+    DynamicDrawUsage,
     InstancedBufferAttribute,
     InstancedBufferGeometry,
     MeshDepthMaterial,
-    RGBADepthPacking,
-    StreamDrawUsage
+    RGBADepthPacking
 } from 'three';
 import ThreeFactory from "../../three/ThreeFactory.js";
 import { StaticMaterialCache } from "../../../asset/loaders/material/StaticMaterialCache.js";
@@ -77,6 +77,13 @@ export class InstancedMeshGroup {
          */
         this.__attributeTransformArray = null;
 
+        /**
+         *
+         * @type {Usage}
+         * @private
+         */
+        this.__instanceUsage = DynamicDrawUsage;
+
         /**
          *
          * @type {Material}
@@ -90,6 +97,30 @@ export class InstancedMeshGroup {
         this.mesh = ThreeFactory.createMesh();
     }
 
+    /**
+     *
+     * @param {Usage} v
+     */
+    set instance_usage(v) {
+        if (this.__instanceUsage === v) {
+            return;
+        }
+
+        this.__instanceUsage = v;
+
+        if (this.__attributeTransform !== null) {
+            this.__attributeTransform.setUsage(v);
+        }
+    }
+
+    /**
+     *
+     * @return {Usage}
+     */
+    get instance_usage() {
+        return this.__instanceUsage;
+    }
+
     dispose() {
         if (this.__threeGeometry !== null) {
             this.__threeGeometry.dispose();
@@ -367,7 +398,7 @@ export class InstancedMeshGroup {
         //rewrite old attributes
         this.__attributeTransformArray = newTransformArray;
         this.__attributeTransform = new InstancedBufferAttribute(newTransformArray, 16);
-        this.__attributeTransform.setUsage(StreamDrawUsage);
+        this.__attributeTransform.setUsage(this.__instanceUsage);
 
         //add attributes to newly created geometry
         geometry.setAttribute("instanceMatrix", this.__attributeTransform);

package/engine/graphics/micron/format/serialization/collection/geometry_collection_serialization.spec.js

@@ -0,0 +1,24 @@
+import { deserialize_geometry_collection, serialize_geometry_collection } from "./geometry_collection_serialization.js";
+import { BinaryBuffer } from "../../../../../../core/binary/BinaryBuffer.js";
+
+test('serialize empty', () => {
+    const bb = new BinaryBuffer();
+
+    expect(() => {
+        serialize_geometry_collection([], bb);
+    }).not.toThrow();
+
+});
+
+test('serialize/deserialize empty', () => {
+    const bb = new BinaryBuffer();
+
+    serialize_geometry_collection([], bb);
+
+    bb.position = 0;
+
+    const destination = [];
+    deserialize_geometry_collection(destination, bb);
+
+    expect(destination.length).toBe(0);
+});