@woosh/meep-engine 2.36.4 → 2.36.7

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<A, B, C, D, E>(system: System<A, B, C, D, E>): 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/gui/GUIElement.d.ts

@@ -0,0 +1,3 @@
+export default class GUIElement {
+
+}

package/engine/ecs/gui/GUIElementSystem.d.ts

@@ -1,7 +1,8 @@
 import {System} from "../System";
 import Engine from "../../Engine";
 import View from "../../../view/View";
+import {GUIElement} from "./GUIElement";
 
-export default class GUIElementSystem extends System {
+export default class GUIElementSystem extends System<GUIElement> {
     constructor(container: View, engine: 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/systems/RenderSystem.d.ts

@@ -1,6 +1,7 @@
 import {System} from "../System";
 import {GraphicsEngine} from "../../graphics/GraphicsEngine";
+import Renderable from "../components/Renderable";
 
-export default class RenderSystem extends System {
+export default class RenderSystem extends System<Renderable> {
     constructor(graphics: GraphicsEngine)
 }

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/camera/CameraSystem.d.ts

@@ -4,7 +4,7 @@ import {GraphicsEngine} from "../../GraphicsEngine";
 import {EntityComponentDataset} from "../../../ecs/EntityComponentDataset";
 import {Camera} from "./Camera";
 
-export class CameraSystem extends System {
+export class CameraSystem extends System<Camera> {
     constructor(scene: Scene, graphics: GraphicsEngine)
 
     public static getFirstActiveCamera(ecd: EntityComponentDataset): { entity: number, component: Camera | undefined }

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

@@ -1,7 +1,8 @@
 import {System} from "../../../ecs/System";
 import Engine from "../../../Engine";
+import {Light} from "./Light";
 
-export default class LightSystem extends System {
+export default class LightSystem extends System<Light> {
     constructor(engine: Engine, {
         shadowResolution
     }: {

package/engine/graphics/ecs/mesh/MeshSystem.d.ts

@@ -1,6 +1,7 @@
 import {System} from "../../../ecs/System";
 import Engine from "../../../Engine";
+import Mesh from "./Mesh";
 
-export class MeshSystem extends System {
+export class MeshSystem extends System<Mesh> {
     constructor(engine: Engine)
 }

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

@@ -117,6 +117,21 @@ export class SGMesh {
     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,8 @@
+import {System} from "../../../../ecs/System";
+import {SGMesh} from "./SGMesh";
+import {Transform} from "../../../../ecs/transform/Transform";
+import Engine from "../../../../Engine";
+
+export class SGMeshSystem extends System<SGMesh, Transform> {
+    constructor(engine: Engine)
+}

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

@@ -3,6 +3,9 @@ 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";
 
 
 /**
@@ -57,10 +60,18 @@ export class SGMeshSystem extends System {
      */
     async process(entity, mesh, transform) {
         const am = this.__assetManager;
+        const ecd = this.entityManager.dataset;
 
-        const assetType = assetTypeByPath(component.url);
+        const assetType = assetTypeByPath(mesh.url);
 
-        const asset = await am.promise(mesh.url, assetType);
+        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
 
@@ -68,7 +79,51 @@ export class SGMeshSystem extends System {
 
         mesh.__node = entity_node;
 
-        entity_node.build(this.entityManager.dataset);
+        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);
     }
 
     /**

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/input/ecs/components/InputController.d.ts

@@ -0,0 +1,3 @@
+export default class InputController {
+
+}

package/engine/input/ecs/systems/InputControllerSystem.d.ts

@@ -1,5 +1,6 @@
 import {System} from "../../../ecs/System";
+import {InputController} from "../components/InputController";
 
-export default class InputControllerSystem extends System {
+export default class InputControllerSystem extends System<InputController> {
     constructor(devices: any)
-}
+}

package/engine/input/ecs/systems/InputSystem.d.ts

@@ -1,5 +1,6 @@
 import {System} from "../../../ecs/System";
+import {Input} from "../components/Input";
 
-export class InputSystem extends System {
+export class InputSystem extends System<Input> {
     constructor(devices: any)
 }

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.4",
+  "version": "2.36.7",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",