@woosh/meep-engine 2.36.1 → 2.36.5

package/core/collection/queue/Deque.js

@@ -194,7 +194,7 @@ export class Deque {
 
     /**
      *
-     * @param {E} e
+     * @param {T} e
      * @returns {number}
      * @private
      */

package/core/color/Color.d.ts

@@ -7,7 +7,37 @@ export class Color {
     g: number
     b: number
 
-    onChanged: Signal
+    readonly onChanged: Signal<number, number, number, number, number, number>
 
-    setRGB(r: number, g: number, b: number)
+    parse(text: string): void
+
+    setRGB(r: number, g: number, b: number): void
+
+    setHSL(h: number, s: number, l: number): void
+
+    setHCL(h: number, c: number, l: number): void
+
+    setHSI(h: number, s: number, i: number): void
+
+    setHSV(h: number, s: number, v: number): void
+
+    getHSV(): { h: number, s: number, v: number }
+
+    toUint(): number
+
+    fromUint(v: number): void
+
+    equals(other: Color): boolean
+
+    hash(): number
+
+    copy(other: Color): void
+
+    clone(): Color
+
+    fromJSON(json: any): void
+
+    toJSON(): any
+
+    writeToArray(destination: ArrayLike<number>, destination_offset: number): void
 }

package/core/color/Color.js

@@ -10,7 +10,7 @@ import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 
-class Color {
+export class Color {
     /**
      *
      * @param {number} r value from 0 to 1
@@ -37,6 +37,10 @@ class Color {
          */
         this.b = b;
 
+        /**
+         * @readonly
+         * @type {Signal<number,number,number,number,number,number>}
+         */
         this.onChanged = new Signal();
     }
 
@@ -384,30 +388,39 @@ class Color {
         this.setRGB(r, g, b);
     }
 
+    /**
+     *
+     * @param {string} str CSS-style string
+     * @returns {void}
+     */
     parse(str) {
         const c = parseColor(str);
 
         this.setRGB(c[0] / 255, c[1] / 255, c[2] / 255);
     }
-}
 
-/**
- *
- * @param {number} r
- * @param {number} g
- * @param {number} b
- * @returns {Color}
- */
-Color.fromRGB = function (r, g, b) {
-    return new Color(r, g, b);
-};
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @returns {Color}
+     */
+    static fromRGB(r, g, b) {
+        return new Color(r, g, b);
+    }
 
-Color.parse = function (str) {
-    const r = new Color();
 
-    r.parse(str);
+    /**
+     *
+     * @param {string} str
+     * @return {Color}
+     */
+    static parse(str) {
+        const r = new Color();
 
-    return r;
-};
+        r.parse(str);
 
-export { Color };
+        return r;
+    };
+}

package/engine/EngineConfiguration.d.ts

@@ -6,13 +6,15 @@ import {AssetLoader} from "./asset/loaders/AssetLoader";
 export class EngineConfiguration {
     addPlugin(plugin: EnginePlugin): boolean
 
-    addSystem(system: System): boolean
+    addSystem<T>(system: System<T>): boolean
 
-    addManySystems(...systems: System[]): void
+    addManySystems(...systems: System<any>[]): void
 
     addDataTable(table: StaticKnowledgeDataTableDescriptor): boolean
 
-    addLoader<T>(type: string, loader: AssetLoader<T>): boolean;
+    addLoader<T>(type: string, loader: AssetLoader<T>): boolean
+
+    hasLoader(type: string): boolean
 
     apply(engine): Promise<any>
 }

package/engine/EngineConfiguration.js

@@ -28,6 +28,15 @@ export class EngineConfiguration {
         this.loaders = new Map();
     }
 
+    /**
+     *
+     * @param {string} type
+     * @returns {boolean}
+     */
+    hasLoader(type) {
+        return this.loaders.has(type);
+    }
+
     /**
      * @template T
      * @param {string} type

package/engine/EngineHarness.js

@@ -26,6 +26,7 @@ import { EngineConfiguration } from "./EngineConfiguration.js";
 import { JsonAssetLoader } from "./asset/loaders/JsonAssetLoader.js";
 import { logger } from "./logging/GlobalLogger.js";
 import { ConsoleLoggerBackend } from "./logging/ConsoleLoggerBackend.js";
+import { noop } from "../core/function/Functions.js";
 
 /**
  *
@@ -85,10 +86,12 @@ export class EngineHarness {
     }
 
     /**
-     *
+     * @param {(config:EngineConfiguration,engine:Engine)=>*} configuration
      * @returns {Promise<Engine>}
      */
-    initialize() {
+    initialize({
+                   configuration = noop
+               } = {}) {
 
         if (this.p !== null) {
             return this.p;
@@ -98,7 +101,12 @@ export class EngineHarness {
 
         const promise = new Promise(async function (resolve, reject) {
             const config = new EngineConfiguration();
-            config.addLoader('json', new JsonAssetLoader());
+
+            configuration(config, engine);
+
+            if (!config.hasLoader('json')) {
+                config.addLoader('json', new JsonAssetLoader());
+            }
 
             await config.apply(engine);
 

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

@@ -16,7 +16,7 @@ export class EntityNode {
 
     removeChild(node: EntityNode): boolean
 
-    traverseChildren(visitor: (EntityNode) => void, thisArg?: any): void
+    traverse(visitor: (node: EntityNode) => any, thisArg?: any): void
 
     build(ecd: EntityComponentDataset): void
 

package/engine/ecs/parent/EntityNode.js

@@ -5,6 +5,7 @@ import { assert } from "../../../core/assert.js";
 import { array_push_if_unique } from "../../../core/collection/array/array_push_if_unique.js";
 import { Transform } from "../transform/Transform.js";
 import { TransformAttachment, TransformAttachmentFlags } from "../transform-attachment/TransformAttachment.js";
+import Signal from "../../../core/events/signal/Signal.js";
 
 export class EntityNode {
     /**
@@ -39,6 +40,29 @@ export class EntityNode {
          * @private
          */
         this.__transform = new Transform();
+
+        this.on = {
+            built: new Signal(),
+            destroyed: new Signal()
+        };
+    }
+
+    /**
+     *
+     * @param {(node:EntityNode)=>*} visitor
+     * @param {*} [thisArg]
+     */
+    traverse(visitor, thisArg) {
+        visitor.call(thisArg, this);
+
+        const children = this.__children;
+        const n = children.length;
+
+        for (let i = 0; i < n; i++) {
+            const child = children[i];
+
+            child.traverse(visitor, thisArg);
+        }
     }
 
     /**
@@ -276,6 +300,8 @@ export class EntityNode {
 
             child.build(ecd);
         }
+
+        this.on.built.send0();
     }
 
     destroy() {
@@ -295,5 +321,7 @@ export class EntityNode {
 
         // then main entity
         this.__entity.destroy();
+
+        this.on.destroyed.send0();
     }
 }

package/engine/ecs/transform-attachment/TransformAttachmentSystem.js

@@ -12,11 +12,62 @@ function update(parent_transform, attachment_transform, child_transform) {
     child_transform.multiplyTransforms(parent_transform, attachment_transform);
 }
 
+class UpdateContext {
+    constructor() {
+        /**
+         *
+         * @type {TransformAttachment|null}
+         */
+        this.attachment = null;
+
+        /**
+         *
+         * @type {Transform|null}
+         */
+        this.transform = null;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.entity = -1;
+
+        /**
+         *
+         * @type {Transform|null}
+         */
+        this.parent_transform = null;
+    }
+
+    update() {
+        update(this.parent_transform, this.attachment.transform, this.transform);
+    }
+
+    link() {
+        this.parent_transform.position.onChanged.add(this.update, this);
+        this.parent_transform.rotation.onChanged.add(this.update, this);
+        this.parent_transform.scale.onChanged.add(this.update, this);
+    }
+
+    unlink() {
+        this.parent_transform.position.onChanged.remove(this.update, this);
+        this.parent_transform.rotation.onChanged.remove(this.update, this);
+        this.parent_transform.scale.onChanged.remove(this.update, this);
+    }
+}
+
 export class TransformAttachmentSystem extends System {
     constructor() {
         super();
 
         this.dependencies = [TransformAttachment, Transform];
+
+        /**
+         *
+         * @type {UpdateContext[]}
+         * @private
+         */
+        this.__contexts = [];
     }
 
     /**
@@ -25,25 +76,23 @@ export class TransformAttachmentSystem extends System {
      * @param {Transform} transform
      * @param {number} entity
      */
-    __update_one(attachment, transform, entity) {
+    link(attachment, transform, entity) {
+        const ctx = new UpdateContext();
+        ctx.system = this;
 
-        const em = this.entityManager;
-        const ecd = em.dataset;
+        ctx.attachment = attachment;
+        ctx.transform = transform;
+        ctx.entity = entity;
 
-        const parent_transform = ecd.getComponent(attachment.parent, Transform);
 
-        update(parent_transform, attachment.transform, transform);
-    }
+        ctx.parent_transform = this.entityManager.dataset.getComponent(attachment.parent, Transform);
+
+        ctx.link();
+
+        this.__contexts[entity] = ctx;
 
-    /**
-     *
-     * @param {TransformAttachment} attachment
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(attachment, transform, entity) {
         if ((attachment.flags & TransformAttachmentFlags.Immediate) !== 0) {
-            this.__update_one(attachment, transform, entity);
+            ctx.update();
         }
     }
 
@@ -55,5 +104,11 @@ export class TransformAttachmentSystem extends System {
      */
     unlink(attachment, transform, entity) {
 
+
+        const ctx = this.__contexts[entity];
+
+        delete this.__contexts[entity];
+
+        ctx.unlink();
     }
 }

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.d.ts

@@ -0,0 +1,8 @@
+export class SGMesh {
+    url: string
+
+    castShadow: boolean
+    receiveShadow: boolean
+
+    static fromURL(url: string): SGMesh
+}

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

@@ -0,0 +1,137 @@
+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);
+    }
+
+    /**
+     *
+     * @param {string} url
+     * @returns {SGMesh}
+     */
+    static fromURL(url) {
+        const r = new SGMesh();
+
+        r.url = url;
+        r.castShadow = true;
+        r.receiveShadow = true;
+
+        return r;
+    }
+}
+
+SGMesh.typeName = "SGMesh";

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshEvents.d.ts

@@ -0,0 +1,12 @@
+export enum SGMeshEvents {
+
+    /**
+     * When asset is attached/loaded onto the Mesh component.
+     * This is the time when the 3d data becomes renderable
+     */
+    AssetLoaded= '@ecd-component-SGMesh/asset-attached',
+    /**
+     * Required asset failed to load for whatever reason
+     */
+    AssetLoadFailed= '@ecd-component-SGMesh/asset-failed',
+}

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

@@ -0,0 +1,12 @@
+export const SGMeshEvents = {
+
+    /**
+     * When asset is attached/loaded onto the Mesh component.
+     * This is the time when the 3d data becomes renderable
+     */
+    AssetLoaded: '@ecd-component-SGMesh/asset-attached',
+    /**
+     * Required asset failed to load for whatever reason
+     */
+    AssetLoadFailed: '@ecd-component-SGMesh/asset-failed',
+};

package/engine/graphics/ecs/mesh-v2/aggregate/SGMeshSystem.d.ts

@@ -0,0 +1,7 @@
+import {System} from "../../../../ecs/System";
+import {SGMesh} from "./SGMesh";
+import {Transform} from "../../../../ecs/transform/Transform";
+
+export class SGMeshSystem extends System<SGMesh, Transform> {
+
+}

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

@@ -0,0 +1,203 @@
+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";
+import { ShadedGeometry } from "../ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
+import { SGMeshEvents } from "./SGMeshEvents.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 ecd = this.entityManager.dataset;
+
+        const assetType = assetTypeByPath(mesh.url);
+
+        let asset;
+
+        try {
+            asset = await am.promise(mesh.url, assetType);
+        } catch (e) {
+            ecd.sendEvent(entity, SGMeshEvents.AssetLoadFailed);
+            return;
+        }
+
+        // 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.transform.copy(transform);
+
+        entity_node.build(ecd);
+
+        function update_position() {
+            entity_node.transform.position.copy(transform.position);
+        }
+
+        function update_rotation() {
+            entity_node.transform.rotation.copy(transform.rotation);
+        }
+
+        function update_scale() {
+            entity_node.transform.scale.copy(transform.scale);
+        }
+
+        transform.position.onChanged.add(update_position);
+        transform.rotation.onChanged.add(update_rotation);
+        transform.scale.onChanged.add(update_scale);
+
+        entity_node.on.destroyed.addOne(() => {
+
+            transform.position.onChanged.remove(update_position);
+            transform.rotation.onChanged.remove(update_rotation);
+            transform.scale.onChanged.remove(update_scale);
+
+        });
+
+        // apply flags to the hierarchy
+        entity_node.traverse(node => {
+            /**
+             *
+             * @type {ShadedGeometry|null}
+             */
+            const sg = node.entity.getComponent(ShadedGeometry);
+            if (sg === null) {
+                return;
+            }
+
+            sg.writeFlag(ShadedGeometryFlags.CastShadow, mesh.castShadow);
+            sg.writeFlag(ShadedGeometryFlags.ReceiveShadow, mesh.receiveShadow);
+        });
+
+
+        ecd.sendEvent(entity, SGMeshEvents.AssetLoaded);
+    }
+
+    /**
+     *
+     * @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/aggregate/prototypeSGMesh.js

@@ -0,0 +1,53 @@
+import { EngineHarness } from "../../../../EngineHarness.js";
+import { ShadedGeometrySystem } from "../ShadedGeometrySystem.js";
+import { SGMeshSystem } from "./SGMeshSystem.js";
+import EntityBuilder from "../../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { SGMesh } from "./SGMesh.js";
+import { GameAssetType } from "../../../../asset/GameAssetType.js";
+import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { BehaviorSystem } from "../../../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { BehaviorComponent } from "../../../../intelligence/behavior/ecs/BehaviorComponent.js";
+import { OrbitingBehavior } from "../../../../../../model/game/util/behavior/OrbitingBehavior.js";
+import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
+
+new EngineHarness().initialize({
+    configuration(config, engine) {
+        config.addManySystems(
+            new ShadedGeometrySystem(engine),
+            new SGMeshSystem(engine),
+            new BehaviorSystem(engine),
+            new TransformAttachmentSystem()
+        );
+
+        config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
+    }
+}).then(main);
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function main(engine) {
+    EngineHarness.buildBasics({
+        engine
+    });
+
+    const ecd = engine.entityManager.dataset;
+
+    const mesh = SGMesh.fromURL("data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf");
+
+    new EntityBuilder()
+        .add(Transform.fromJSON({
+            position: new Vector3(10, 0, 10)
+        }))
+        // .add(SGMesh.fromURL("data/models/snaps/cube_blue.gltf"))
+        .add(mesh)
+        .add(BehaviorComponent.fromOne(OrbitingBehavior.from({
+            center: new Vector3(10, 0, 10),
+            radius: 5,
+            rate: 2
+        })))
+        .build(ecd);
+}

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/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.36.1",
+  "version": "2.36.5",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",