@woosh/meep-engine 2.37.1 → 2.37.4

package/core/geom/Quaternion.js

@@ -763,6 +763,7 @@ class Quaternion {
     }
 
     /**
+     * XYZ order
      * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
      * @param {number} x angle in X axis in radians
      * @param {number} y angle in Y axis in radians
@@ -788,6 +789,36 @@ class Quaternion {
         this.set(_x, _y, _z, _w);
     }
 
+    /**
+     * XYZ order
+     * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
+     * @see http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
+     * @see https://github.com/mrdoob/three.js/blob/510705cde208b165fd87946b0f8504a1cd6dbe83/src/math/Quaternion.js#L206
+     * @param {number} x angle in X axis in radians
+     * @param {number} y angle in Y axis in radians
+     * @param {number} z angle in Z axis in radians
+     */
+    fromEulerAnglesXYZ(x, y, z) {
+        const scaled_x = x * 0.5;
+        const scaled_y = y * 0.5;
+        const scaled_z = z * 0.5;
+
+        const s1 = Math.sin(scaled_x);
+        const s2 = Math.sin(scaled_y);
+        const s3 = Math.sin(scaled_z);
+
+        const c1 = Math.cos(scaled_x);
+        const c2 = Math.cos(scaled_y);
+        const c3 = Math.cos(scaled_z);
+
+        const _x = s1 * c2 * c3 + c1 * s2 * s3;
+        const _y = c1 * s2 * c3 - s1 * c2 * s3;
+        const _z = c1 * c2 * s3 + s1 * s2 * c3;
+        const _w = c1 * c2 * c3 - s1 * s2 * s3;
+
+        this.set(_x, _y, _z, _w);
+    }
+
     /**
      * Writes Pitch(Y), Yaw(Z), Roll(X) to a given vector
      * @source http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/

package/core/model/ModuleRegistry.d.ts

@@ -0,0 +1,3 @@
+export class ModuleRegistry {
+
+}

package/core/process/undo/ActionProcessor.js

@@ -9,7 +9,6 @@ import List from "../../collection/list/List.js";
 import Signal from "../../events/signal/Signal.js";
 import { min2 } from "../../math/min2.js";
 import { Mark } from "./Mark.js";
-import { IllegalStateException } from "../../fsm/exceptions/IllegalStateException.js";
 
 /**
  * @template C, M
@@ -75,13 +74,6 @@ export class ActionProcessor {
          */
         this.onMarkRemoved = new Signal();
 
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__action_in_progress = false;
-
         /**
          *
          * @type {Promise<never>}
@@ -172,10 +164,8 @@ export class ActionProcessor {
      * Insert a mark into the timeline, all actions between marks are grouped logically for UNDO and REDO mechanism
      * @param {D} description
      */
-    mark(description) {
-        if (this.__action_in_progress) {
-            throw new IllegalStateException('Action is currently in progress');
-        }
+    async mark(description) {
+        await this.__barrier();
 
         const marks = this.marks;
         const numMarks = marks.length;
@@ -265,6 +255,24 @@ export class ActionProcessor {
      * @throws {Error} when mark is non-unique
      */
     async navigateTo(mark_descriptor) {
+        await this.__barrier();
+
+        const p = this.__unsafe_navigateTo(mark_descriptor);
+
+        this.__last_promise = p;
+
+        return await p;
+    }
+
+    /**
+     * Navigate to a specific mark back or forward
+     * @param {M} mark_descriptor specific mark description
+     * @returns {boolean} true on success, false otherwise (e.g. mark not found)
+     * @throws {Error} when mark is non-unique
+     * @private
+     */
+    async __unsafe_navigateTo(mark_descriptor) {
+
         // find all matching marks
         const matching_marks = this.__find_mark_indices_by_description(mark_descriptor);
 
@@ -293,7 +301,7 @@ export class ActionProcessor {
 
             while (target > this.cursor) {
                 // navigate forward
-                await this.redo();
+                await this.__unsafe_redo();
 
                 if (temp_cursor === this.cursor) {
                     // no cursor change
@@ -307,7 +315,7 @@ export class ActionProcessor {
 
             while (target < this.cursor) {
                 // navigate backwards
-                await this.undo();
+                await this.__unsafe_undo();
 
                 if (temp_cursor === this.cursor) {
                     // no cursor change
@@ -323,6 +331,21 @@ export class ActionProcessor {
     }
 
     async undo() {
+        await this.__barrier();
+
+        const p = this.__unsafe_undo();
+
+        this.__last_promise = p;
+
+        await p;
+    }
+
+    /**
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __unsafe_undo() {
         let markAddress = 0;
         /**
          *
@@ -351,7 +374,7 @@ export class ActionProcessor {
             this.cursor--;
             const action = this.history.get(this.cursor);
 
-            await this.__action_revert(action);
+            await action.revert(this.context);
         }
 
         if (mark !== null) {
@@ -363,8 +386,23 @@ export class ActionProcessor {
      * redo previous sequence of actions on the timeline, up to the next mark
      */
     async redo() {
+        await this.__barrier();
+
+        const p = this.__unsafe_redo();
 
+        this.__last_promise = p;
+
+        await p;
+    }
+
+    /**
+     *
+     * @returns {Promise<void>}
+     * @private
+     */
+    async __unsafe_redo() {
         let mark = this.history.length;
+
         //find mark
         const marks = this.marks;
 
@@ -382,7 +420,7 @@ export class ActionProcessor {
         while (this.cursor < mark) {
             const action = this.history.get(this.cursor);
 
-            await this.__action_apply(action);
+            await action.apply(this.context);
 
             this.historyMemoryUsage += action.computeByteSize();
 
@@ -395,15 +433,26 @@ export class ActionProcessor {
      * @param {Action[]} actions
      */
     async doMany(actions) {
-        const n = actions.length;
+        await this.__barrier();
 
-        for (let i = 0; i < n; i++) {
+        const p = new Promise(async (resolve, reject) => {
 
-            const action = actions[i];
+            const n = actions.length;
 
-            await this.do(action);
+            for (let i = 0; i < n; i++) {
 
-        }
+                const action = actions[i];
+
+                await this.__unsafe_do(action);
+
+            }
+
+            resolve();
+        });
+
+        this.__last_promise = p;
+
+        await p;
     }
 
     /**
@@ -411,21 +460,13 @@ export class ActionProcessor {
      * @param {Action} action
      */
     async do(action) {
-        await this.__action_apply(action);
+        await this.__barrier();
 
-        this.historyMemoryUsage += action.computeByteSize();
+        const p = this.__unsafe_do(action);
 
-        const history = this.history;
+        this.__last_promise = p;
 
-        //doing action invalidates "future" branch of history, we need to clear all actions beyond cursor
-        if (this.cursor < history.length) {
-            history.crop(0, this.cursor);
-            // TODO clear future marks
-        }
-
-        history.add(action);
-
-        this.cursor++;
+        await p;
     }
 
     /**
@@ -434,63 +475,34 @@ export class ActionProcessor {
      * @returns {Promise<void>}
      * @private
      */
-    async __action_apply(action) {
-        try {
-            await this.__last_promise;
-        } catch (e) {
-            // ignore
-        }
+    async __unsafe_do(action) {
+        await action.apply(this.context);
 
-        if (this.__action_in_progress) {
-            throw new IllegalStateException();
-        }
+        this.historyMemoryUsage += action.computeByteSize();
 
-        this.__action_in_progress = true;
+        const history = this.history;
 
-        let p;
-        try {
-            p = action.apply(this.context);
-        } finally {
-            this.__action_in_progress = false;
+        //doing action invalidates "future" branch of history, we need to clear all actions beyond cursor
+        if (this.cursor < history.length) {
+            history.crop(0, this.cursor);
+            // TODO clear future marks
         }
 
-        if (p !== undefined) {
-            this.__last_promise = p;
-            await p;
-        }
+        history.add(action);
 
+        this.cursor++;
     }
 
     /**
-     *
-     * @param {Action} action
+     * Await for synchronization barrier
      * @returns {Promise<void>}
      * @private
      */
-    async __action_revert(action) {
+    async __barrier() {
         try {
             await this.__last_promise;
         } catch (e) {
             // ignore
         }
-
-        if (this.__action_in_progress) {
-            throw new IllegalStateException();
-        }
-
-        this.__action_in_progress = true;
-
-        let p;
-        try {
-            p = action.revert(this.context);
-        } finally {
-            this.__action_in_progress = false;
-        }
-
-        if (p !== undefined) {
-            this.__last_promise = p;
-            await p;
-        }
-
     }
 }

package/editor/ecs/component/createObjectEditor.js

@@ -0,0 +1,155 @@
+import EmptyView from "../../../view/elements/EmptyView.js";
+import LabelView from "../../../view/common/LabelView.js";
+
+class FieldValueAdapter {
+    read(object, field_name) {
+
+    }
+
+    write(object, field_name, value) {
+
+    }
+}
+
+/**
+ * @template T
+ */
+class FieldDescriptor {
+    constructor() {
+        /**
+         *
+         * @type {string}
+         */
+        this.name = "";
+
+        /**
+         * typeof field
+         * @type {Class<T>}
+         */
+        this.type = null;
+
+        /**
+         *
+         * @type {FieldValueAdapter|null}
+         */
+        this.adapter = null;
+
+    }
+}
+
+/**
+ * @template T
+ * @param {T} value
+ */
+function objectToClass(value) {
+    const type = typeof value;
+
+    switch (type) {
+        case "object":
+            return value.__ptoto__.constructor;
+        case "boolean":
+            return Boolean;
+        case "function":
+            return Function;
+        case "string":
+            return String;
+        case "number":
+            return Number;
+        default:
+            throw new Error(`Unsupported type '${type}'`);
+    }
+}
+
+/**
+ *
+ * @param {Object} object
+ * @param {string} field_name
+ * @returns {boolean}
+ */
+function isPublicField(object, field_name) {
+    if (field_name.startsWith('_')) {
+        // private
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ *
+ * @param {Object} object
+ * @returns {FieldDescriptor[]}
+ */
+function extractObjectFields(object) {
+    const result = [];
+    const keys = Object.keys(object);
+
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+
+        if (!isPublicField(object, key)) {
+            continue;
+        }
+
+        const field_type = objectToClass(object[key]);
+
+        if (field_type === undefined) {
+            continue;
+        }
+
+        const descriptor = new FieldDescriptor();
+        descriptor.name = key;
+        descriptor.type = field_type;
+
+        result.push(descriptor);
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {Object} object
+ * @param {FieldDescriptor} field
+ * @param {Map<*, (parent:*, field:FieldDescriptor)=>View>} registry
+ */
+export function createFieldEditor(object, field, registry) {
+    const vResult = new EmptyView({});
+
+    vResult.addChild(new LabelView(field.name));
+
+    let vValue;
+
+    const factory = registry.get(field.type);
+
+    if (factory !== undefined) {
+        vValue = factory(object, field);
+    } else {
+        vValue = createObjectEditor(object, registry);
+    }
+
+    vResult.addChild(vValue);
+
+    return vResult;
+}
+
+/**
+ *
+ * @param {Object} object
+ * @param {Map<*, (parent:*, field:FieldDescriptor)=>View>} registry
+ */
+export function createObjectEditor(object, registry) {
+    const fields = extractObjectFields(object);
+
+    const vResult = new EmptyView({});
+
+    for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+
+        const vField = createFieldEditor(object, field, registry);
+
+        vResult.addChild(vField);
+    }
+
+    return vResult;
+}

package/editor/tools/SelectionTool.js

@@ -18,6 +18,7 @@ import EditorEntity from "../ecs/EditorEntity.js";
 import Terrain from "../../engine/ecs/terrain/ecs/Terrain.js";
 import { SurfacePoint3 } from "../../core/geom/3d/SurfacePoint3.js";
 import { makeScreenScissorFrustum } from "../../engine/graphics/camera/makeScreenScissorFrustum.js";
+import { ShadedGeometrySystem } from "../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
 
 class SelectionView extends View {
     constructor() {
@@ -220,7 +221,8 @@ function findEntityOfNode(node) {
  */
 export function pickingEntitySelection(point, engine, camera) {
 
-    const dataset = engine.entityManager.dataset;
+    const em = engine.entityManager;
+    const dataset = em.dataset;
 
     const graphicsEngine = engine.graphics;
 
@@ -262,6 +264,25 @@ export function pickingEntitySelection(point, engine, camera) {
         }
     }
 
+    /**
+     *
+     * @type {ShadedGeometrySystem|undefined}
+     */
+    const sgm = em.getSystem(ShadedGeometrySystem);
+
+    if (sgm !== undefined) {
+        const hits = sgm.raycast(
+            source.x, source.y, source.y,
+            rayDirection.x, rayDirection.y, rayDirection.z
+        );
+
+        for (let i = 0; i < hits.length; i++) {
+            const hit = hits[i];
+
+            tryAddEntity(hit.entity, hit.contact.position);
+        }
+    }
+
     //query render layers
     engine.graphics.layers.traverse(function (layer) {
         /**

package/engine/ecs/transform/Transform.js

@@ -7,13 +7,16 @@ import Quaternion from "../../../core/geom/Quaternion.js";
 import { decompose_matrix_4_array } from "../../../core/geom/3d/decompose_matrix_4_array.js";
 import { mat4 } from "gl-matrix";
 import { compose_matrix4_array } from "../../../core/geom/3d/compose_matrix4_array.js";
+import { TransformFlags } from "./TransformFlags.js";
+import { allocate_transform_m4 } from "../../graphics/ecs/mesh-v2/allocate_transform_m4.js";
 
 const delta = new Vector3();
 
-const scratch_buffer = new ArrayBuffer(32 * 4);
+const scratch_buffer = new ArrayBuffer(16 * 4);
 
 const m4_0 = new Float32Array(scratch_buffer, 0, 16);
-const m4_1 = new Float32Array(scratch_buffer, 64, 16)
+
+const FLAGS_DEFAULT = TransformFlags.AutomaticChangeDetection;
 
 export class Transform {
     /**
@@ -43,6 +46,79 @@ export class Transform {
          */
         this.scale = new Vector3(1, 1, 1);
 
+        /**
+         * @readonly
+         * @type {Float32Array}
+         */
+        this.matrix = allocate_transform_m4();
+
+        /**
+         * @protected
+         * @type {number}
+         */
+        this.flags = FLAGS_DEFAULT;
+
+        // watch changes
+        this.position.onChanged.add(this.__handle_component_change, this);
+        this.rotation.onChanged.add(this.__handle_component_change, this);
+        this.scale.onChanged.add(this.__handle_component_change, this);
+    }
+
+    /**
+     *
+     * @private
+     */
+    __handle_component_change() {
+        if (this.getFlag(TransformFlags.AutomaticChangeDetection)) {
+            this.setFlag(TransformFlags.MatrixNeedsUpdate);
+        }
+    }
+
+    /**
+     *
+     * @param {number|TransformFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|TransformFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|TransformFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|TransformFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
+    }
+
+
+    updateMatrix() {
+        compose_matrix4_array(this.matrix, this.position, this.rotation, this.scale);
+
+        this.clearFlag(TransformFlags.MatrixNeedsUpdate);
     }
 
     /**
@@ -82,6 +158,8 @@ export class Transform {
         } else {
             this.scale.copy(Vector3.one);
         }
+
+        this.setFlag(TransformFlags.MatrixNeedsUpdate);
     }
 
     toJSON() {
@@ -100,6 +178,10 @@ export class Transform {
         this.position.copy(other.position);
         this.rotation.copy(other.rotation);
         this.scale.copy(other.scale);
+
+        this.matrix.set(other.matrix);
+
+        this.flags = other.flags;
     }
 
     /**
@@ -154,10 +236,15 @@ export class Transform {
      * @param {Transform} b
      */
     multiplyTransforms(a, b) {
-        compose_matrix4_array(m4_0, a.position, a.rotation, a.scale);
-        compose_matrix4_array(m4_1, b.position, b.rotation, b.scale);
+        if (a.getFlag(TransformFlags.MatrixNeedsUpdate)) {
+            a.updateMatrix();
+        }
 
-        mat4.multiply(m4_0, m4_0, m4_1);
+        if (b.getFlag(TransformFlags.MatrixNeedsUpdate)) {
+            b.updateMatrix();
+        }
+
+        mat4.multiply(m4_0, a.matrix, b.matrix);
 
         this.fromMatrix4(m4_0);
     }
@@ -183,7 +270,17 @@ export class Transform {
      * @param {mat4|number[]|Float32Array} m
      */
     fromMatrix4(m) {
+        const ad = this.getFlag(TransformFlags.AutomaticChangeDetection);
+
+        this.clearFlag(TransformFlags.AutomaticChangeDetection);
+
+        this.matrix.set(m);
+
         decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
+
+        this.clearFlag(TransformFlags.MatrixNeedsUpdate);
+
+        this.writeFlag(TransformFlags.AutomaticChangeDetection, ad);
     }
 
     /**
@@ -195,6 +292,10 @@ export class Transform {
     }
 }
 
+/**
+ * @readonly
+ * @type {string}
+ */
 Transform.typeName = "Transform";
 
 /**

package/engine/ecs/transform/TransformFlags.js

@@ -0,0 +1,8 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const TransformFlags = {
+    MatrixNeedsUpdate: 1,
+    AutomaticChangeDetection: 2
+};

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

@@ -2,16 +2,6 @@ import { System } from "../System.js";
 import { TransformAttachment, TransformAttachmentFlags } from "./TransformAttachment.js";
 import { Transform } from "../transform/Transform.js";
 
-/**
- *
- * @param {Transform} parent_transform
- * @param {Transform} attachment_transform
- * @param {Transform} child_transform
- */
-function update(parent_transform, attachment_transform, child_transform) {
-    child_transform.multiplyTransforms(parent_transform, attachment_transform);
-}
-
 class UpdateContext {
     constructor() {
         /**
@@ -40,7 +30,7 @@ class UpdateContext {
     }
 
     update() {
-        update(this.parent_transform, this.attachment.transform, this.transform);
+        this.transform.multiplyTransforms(this.parent_transform, this.attachment.transform);
     }
 
     link() {

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

@@ -3,6 +3,8 @@ import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
 import { DrawMode } from "./DrawMode.js";
 import { ShadedGeometryFlags } from "./ShadedGeometryFlags.js";
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import { allocate_transform_m4 } from "./allocate_transform_m4.js";
+import { TransformFlags } from "../../../ecs/transform/TransformFlags.js";
 
 /**
  * @readonly
@@ -18,39 +20,6 @@ const FLAG_SET_EQUALITY = ShadedGeometryFlags.CastShadow
     | ShadedGeometryFlags.ReceiveShadow
 ;
 
-/**
- *
- * @type {number}
- */
-const TRANSFORM_ALLOCATOR_BUCKET_CAPACITY = 16;
-/**
- *
- * @type {ArrayBuffer|null}
- */
-let transform_bucket = null;
-/**
- *
- * @type {number}
- */
-let transform_bucket_cursor = TRANSFORM_ALLOCATOR_BUCKET_CAPACITY;
-
-/**
- * custom Float32Array allocator, allocated memory in continuous chunks
- * @returns {Float32Array}
- */
-function allocate_transform_m4() {
-    if (transform_bucket_cursor >= TRANSFORM_ALLOCATOR_BUCKET_CAPACITY) {
-        transform_bucket = new ArrayBuffer(TRANSFORM_ALLOCATOR_BUCKET_CAPACITY * 4 * 16);
-        transform_bucket_cursor = 0;
-    }
-
-    const result = new Float32Array(transform_bucket, transform_bucket_cursor * 16 * 4, 16);
-
-    transform_bucket_cursor++;
-
-    return result;
-}
-
 export class ShadedGeometry {
     constructor() {
         /**
@@ -216,7 +185,7 @@ export class ShadedGeometry {
      * @return {null|number[]}
      */
     get transform() {
-        return this.__transform;
+        return this.__c_transform.matrix;
     }
 
     /**
@@ -270,8 +239,14 @@ export class ShadedGeometry {
     }
 
     updateTransform() {
+        const t = this.__c_transform;
+
+        if (t.getFlag(TransformFlags.MatrixNeedsUpdate)) {
+            t.updateMatrix();
+        }
+
         //
-        this.__c_transform.toMatrix4(this.__transform);
+        this.__transform.set(t.matrix);
 
         this.update_bounds();
 

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

@@ -22,6 +22,7 @@ import TaskState from "../../../../core/process/task/TaskState.js";
 import {
     bvh_query_user_data_overlaps_frustum
 } from "../../../../core/bvh2/bvh3/bvh_query_user_data_overlaps_frustum.js";
+import { TransformFlags } from "../../../ecs/transform/TransformFlags.js";
 
 
 /**
@@ -250,7 +251,11 @@ export class ShadedGeometrySystem extends System {
         t.rotation.onChanged.add(sg.updateTransform, sg);
         t.scale.onChanged.add(sg.updateTransform, sg);
 
-        t.toMatrix4(sg.__transform);
+        if (t.getFlag(TransformFlags.MatrixNeedsUpdate)) {
+            t.updateMatrix();
+        }
+
+        sg.__transform.set(t.matrix);
         sg.update_bounds();
 
         // remember entity for lookups

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

@@ -7,6 +7,7 @@ import { ShadedGeometry } from "../ShadedGeometry.js";
 import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
 import { SGMeshEvents } from "./SGMeshEvents.js";
 import { ParentEntity } from "../../../../ecs/parent/ParentEntity.js";
+import { EntityNode } from "../../../../ecs/parent/EntityNode.js";
 
 
 /**
@@ -76,7 +77,21 @@ export class SGMeshSystem extends System {
 
         // TODO check that entity still exists, as we get to this point asynchronously
 
-        const entity_node = three_object_to_entity_composition(asset.create());
+        let entity_node = three_object_to_entity_composition(asset.create());
+
+        if (asset.has_root_transform) {
+            // apply root transform
+
+            const new_root = new EntityNode();
+
+            new_root.entity.add(new Transform());
+
+            entity_node.transform.copy(asset.root_transform);
+
+            new_root.addChild(entity_node);
+
+            entity_node = new_root;
+        }
 
         // attach parent entity to link hierarchy to this entity
         entity_node.entity.add(ParentEntity.from(entity));

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

@@ -0,0 +1,51 @@
+/**
+ * Larger bucket sizes provide better cache locality
+ * Larger bucket sizes also cause more hanging GC references, as if one matrix element is still held - ENTIRE bucket is still referenced
+ * @type {number}
+ */
+const TRANSFORM_ALLOCATOR_BUCKET_CAPACITY = 16;
+
+/**
+ *
+ * @type {ArrayBuffer|null}
+ */
+let transform_bucket = null;
+
+/**
+ *
+ * @type {number}
+ */
+let transform_bucket_cursor = TRANSFORM_ALLOCATOR_BUCKET_CAPACITY;
+
+const MATRIX_BYTE_SIZE = 4 * 16;
+
+/**
+ *
+ * @type {Float32Array}
+ */
+const MATRIX_IDENTITY = new Float32Array([
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+]);
+
+/**
+ * custom Float32Array allocator, allocated memory in continuous chunks
+ * @returns {Float32Array}
+ */
+export function allocate_transform_m4() {
+    if (transform_bucket_cursor >= TRANSFORM_ALLOCATOR_BUCKET_CAPACITY) {
+        transform_bucket = new ArrayBuffer(TRANSFORM_ALLOCATOR_BUCKET_CAPACITY * MATRIX_BYTE_SIZE);
+        transform_bucket_cursor = 0;
+    }
+
+    const result = new Float32Array(transform_bucket, transform_bucket_cursor * MATRIX_BYTE_SIZE, 16);
+
+    // initialize matrix
+    result.set(MATRIX_IDENTITY);
+
+    transform_bucket_cursor++;
+
+    return result;
+}

package/engine/graphics/ecs/mesh-v2/sample/load_gltf.js

@@ -4,10 +4,11 @@ import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { EngineConfiguration } from "../../../../EngineConfiguration.js";
 import { GLTFAssetLoader } from "../../../../asset/loaders/GLTFAssetLoader.js";
 import { three_object_to_entity_composition } from "../three_object_to_entity_composition.js";
-import { AttachmentSystem } from "../../../../ecs/attachment/AttachmentSystem.js";
 import { TransformAttachmentSystem } from "../../../../ecs/transform-attachment/TransformAttachmentSystem.js";
 import { Camera } from "../../camera/Camera.js";
 import { MicronRenderPlugin } from "../../../micron/plugin/MicronRenderPlugin.js";
+import { enableEditor } from "../../../../../editor/enableEditor.js";
+import { MeshSystem } from "../../mesh/MeshSystem.js";
 
 const eh = new EngineHarness();
 
@@ -22,14 +23,20 @@ async function init(harness) {
     const config = new EngineConfiguration();
 
     config.addSystem(new ShadedGeometrySystem(engine));
-    config.addSystem(new AttachmentSystem());
     config.addSystem(new TransformAttachmentSystem());
-    config.addLoader(GameAssetType.ModelGLTF_JSON, new GLTFAssetLoader());
+    config.addSystem(new MeshSystem(engine));
 
-    config.addPlugin( MicronRenderPlugin);
+    const gltfAssetLoader = new GLTFAssetLoader();
+
+    config.addLoader(GameAssetType.ModelGLTF_JSON, gltfAssetLoader);
+    config.addLoader(GameAssetType.ModelGLTF, gltfAssetLoader);
+
+    config.addPlugin(MicronRenderPlugin);
 
     await config.apply(engine);
 
+    enableEditor(engine);
+
     eh.initialize().then(main);
 }
 
@@ -51,12 +58,32 @@ async function load_gltf(path, engine) {
     const composition = three_object_to_entity_composition(three_object);
     console.timeEnd('composition conversion');
 
+    if (asset.has_root_transform) {
+        composition.transform.multiplyTransforms(composition.transform, asset.root_transform);
+    }
+
     console.time('composition build');
     // console.profile('composition build');
     composition.build(ecd);
     // console.profileEnd('composition build');
     console.timeEnd('composition build');
 
+
+    // console.log(composition);
+    // console.log(three_object);
+    //
+    // new EntityBuilder()
+    //     .add(Mesh.fromJSON({
+    //         url: path
+    //     }))
+    //     .add(Transform.fromJSON({
+    //         position: {
+    //             x: 5,
+    //             y: 0,
+    //             z: 0
+    //         }
+    //     }))
+    //     .build(ecd);
 }
 
 async function timeout(t = 1) {
@@ -88,6 +115,16 @@ async function main(engine) {
     // load_gltf('moicon/06_04_hapro/05-ground-floor/model.gltf', engine);
     // load_gltf('moicon/06_04_hapro/04-1st-floor/model.gltf', engine);
     // load_gltf('moicon/06_04_hapro/03-2nd-floor/model.gltf', engine);
+
+    // for (let i = 1; i <= 6; i++) {
+    //     load_gltf(`moicon/10_Feb_22_Demo/${i}/model.gltf`, engine);
+    // }
+    // load_gltf(`moicon/10_Feb_22_Demo/1/model.gltf`, engine);
+    // load_gltf(`moicon/10_Feb_22_Demo/2/model.gltf`, engine);
+    // load_gltf(`moicon/10_Feb_22_Demo/3/model.gltf`, engine);
+
+    // load_gltf(`data/models/samples/transform-hierarchy.glb`, engine);
+
 }
 
 init(eh);

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

@@ -15,8 +15,10 @@ export function three_object_to_entity_composition(root) {
     // copy object transform
     node_transform.position.copy(root.position);
     node_transform.scale.copy(root.scale);
-    const euler = root.rotation;
-    node_transform.rotation.fromEulerAngles(euler.x, euler.y, euler.z);
+    node_transform.rotation.copy(root.quaternion);
+
+    //
+    node_transform.matrix.set(root.matrix.elements);
 
     const entity = node.entity;
 

package/engine/graphics/ecs/path/entity/EntityPathStyle.d.ts

@@ -1,4 +1,4 @@
-import {ClassRegistry} from "../../../../../core/model/ClassRegistry";
+import {ModuleRegistry} from "../../../../../core/model/ModuleRegistry";
 import {EntityPathMarkerDefinition} from "./EntityPathMarkerDefinition";
 
 export class EntityPathStyle {
@@ -8,5 +8,5 @@ export class EntityPathStyle {
 
     public spacing: number
 
-    fromJSON(json: { marker_start: any, marker_end: any, marker_main: any, spacing?: number }, registry: ClassRegistry): void
+    fromJSON(json: { marker_start: any, marker_end: any, marker_main: any, spacing?: number }, registry: ModuleRegistry): void
 }

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

package/core/model/ClassRegistry.d.ts

@@ -1,3 +0,0 @@
-export class ClassRegistry {
-
-}