@woosh/meep-engine 2.36.2 → 2.36.4

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/graphics/ecs/highlight/HighlightDefinition.d.ts

@@ -1,7 +1,7 @@
 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

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