@woosh/meep-engine 2.33.76 → 2.34.3

package/engine/asset/loaders/image/ImageDecoderWorker.js

@@ -19,10 +19,11 @@ async function decode_png(png_bytes) {
         // console.profileEnd('decode');
 
         resolve({
-            data: uint_channels.data,
+            data: uint_channels.data.buffer,
             width,
             height,
-            itemSize: uint_channels.itemSize
+            itemSize: uint_channels.itemSize,
+            bitDepth: uint_channels.bitDepth
         });
     });
 }

package/engine/asset/loaders/image/ImageRGBADataAsset.js

@@ -1,4 +1,5 @@
 import { Asset } from "../../Asset.js";
+import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 
 export class ImageRGBADataAsset extends Asset {
     /**
@@ -39,11 +40,6 @@ export class ImageRGBADataAsset extends Asset {
     }
 
     create() {
-        return {
-            data: this.data,
-            width: this.width,
-            height: this.height,
-            itemSize: this.itemSize
-        };
+        return new Sampler2D(this.data, this.itemSize, this.width, this.height);
     }
 }

package/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -23,7 +23,7 @@ export class ImageRGBADataLoader extends AssetLoader {
     /**
      *
      * @param {string} path
-     * @returns {Promise<{data:ArrayBuffer, width: number, height:number, itemSize: number}>}
+     * @returns {Promise<{data:ArrayBuffer, width: number, height:number, itemSize: number, bitDepth:number}>}
      * @private
      */
     async __decode_via_worker(path) {
@@ -45,7 +45,23 @@ export class ImageRGBADataLoader extends AssetLoader {
 
         const bitmap = await this.__decode_via_worker(path);
 
-        return new ImageRGBADataAsset(new Uint8Array(bitmap.data), bitmap.width, bitmap.height, bitmap.itemSize);
+
+        let data;
+
+        switch (bitmap.bitDepth) {
+            case 8:
+
+                data = new Uint8Array(bitmap.data);
+                break
+            case 16:
+                data = new Uint16Array(bitmap.data);
+                break;
+            default:
+                throw new Error(`Unsupported bit depth '${bitmap.bitDepth}'`);
+        }
+
+
+        return new ImageRGBADataAsset(data, bitmap.width, bitmap.height, bitmap.itemSize);
     }
 
     load(path, success, failure, progress) {

package/engine/asset/loaders/image/codec/NativeImageDecoder.js

@@ -46,7 +46,8 @@ export class NativeImageDecoder extends Codec {
             data: rgba_data,
             width: width,
             height: height,
-            itemSize: 4
+            itemSize: 4,
+            bitDepth: 8
         };
     }
 }

package/engine/asset/loaders/image/png/PNG.js

@@ -364,7 +364,7 @@ PNG.prototype.getUint8Data_case3 = function () {
 }
 
 /**
- * @returns {{itemSize:number, data:Uint8Array}}
+ * @returns {{itemSize:number, data:Uint8Array, bitDepth: number}}
  */
 PNG.prototype.getUint8Data = function () {
     let data;
@@ -397,6 +397,7 @@ PNG.prototype.getUint8Data = function () {
 
     return {
         data,
-        itemSize
+        itemSize,
+        bitDepth: this.bitDepth
     };
 };

package/engine/asset/loaders/image/png/PNGReader.js

@@ -61,6 +61,7 @@ PNGReader.prototype.decodeHeader = function () {
 
     buffer.readBytes(header, 0, 8)
 
+    // see https://www.w3.org/TR/PNG-Structure.html
     if (!isArrayEqualStrict(header, [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])) {
         throw new Error('invalid PNGReader file (bad signature)');
     }

package/engine/ecs/EntityComponentDataset.js

@@ -5,8 +5,8 @@ import Signal, {
     findSignalHandlerIndexByHandleAndContext
 } from "../../core/events/signal/Signal.js";
 import { EventType } from "./EntityManager.js";
-import { arraySetDiff } from "../../core/collection/Set.js";
 import { SignalHandler } from "../../core/events/signal/SignalHandler.js";
+import { arraySetDiff } from "../../core/collection/array/arraySetDiff.js";
 
 /**
  *

package/engine/ecs/storage/BinaryBufferSerializer.js

@@ -48,7 +48,7 @@ function isEntityTransient(entity, dataset, smComponentIndex, componentInstance)
     return isTransient;
 }
 
-class BinaryBufferSerialization {
+class BinaryBufferSerializer {
     constructor() {
         /**
          *
@@ -171,4 +171,4 @@ class BinaryBufferSerialization {
     }
 }
 
-export default BinaryBufferSerialization;
+export default BinaryBufferSerializer;

package/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -267,6 +267,15 @@ export class TerrainLayers {
         return index;
     }
 
+    /**
+     *
+     * @param {TerrainLayer} layer
+     * @return {boolean}
+     */
+    removeLayer(layer) {
+        return this.layers.removeOneOf(layer);
+    }
+
     /**
      *
      * @param {TerrainLayer} layer

package/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -46,32 +46,7 @@ export function loadLegacyTerrainSplats(description, mapping, am) {
 
                 mapping.resize(width, height, 4);
 
-
-                const weightData = mapping.weightData;
-
-                const dataOffset = index * width * height;
-
-                const sourceWidth = source.width;
-                const sourceHeight = source.height;
-
-                const source_max_y = sourceHeight - 1;
-                const source_max_x = sourceWidth - 1;
-
-                for (let y = 0; y < height; y++) {
-                    const v = y / height;
-
-                    for (let x = 0; x < width; x++) {
-
-                        const u = x / width;
-
-                        const targetIndex = y * width + x;
-                        const targetAddress = dataOffset + targetIndex;
-
-                        const value = source.sampleChannelBilinear(u * source_max_x, v * source_max_y, 0);
-
-                        weightData[targetAddress] = value;
-                    }
-                }
+                mapping.writeLayerFromSampler(source, index, 0);
 
             });
     }
@@ -146,6 +121,77 @@ export class SplatMapping {
         this.materialTexture = new DataTexture(new Uint8Array(width * height * 4), width, height);
     }
 
+    /**
+     *
+     * @param {Sampler2D} source
+     * @param {number} index
+     * @param {number} channel
+     */
+    writeLayerFromSampler(source, index, channel = 0) {
+        const weightData = this.weightData;
+
+        const width = this.size.x;
+        const height = this.size.y;
+
+        const dataOffset = index * width * height;
+
+        const sourceWidth = source.width;
+        const sourceHeight = source.height;
+
+        const source_max_y = sourceHeight - 1;
+        const source_max_x = sourceWidth - 1;
+
+        for (let y = 0; y < height; y++) {
+            const v = y / height;
+
+            for (let x = 0; x < width; x++) {
+
+                const u = x / width;
+
+                const targetIndex = y * width + x;
+                const targetAddress = dataOffset + targetIndex;
+
+                const value = source.sampleChannelBilinear(u * source_max_x, v * source_max_y, channel);
+
+                weightData[targetAddress] = value;
+            }
+        }
+
+    }
+
+    /**
+     *
+     * @param {Sampler2D} destination
+     * @param {number} index
+     * @param {number} channel
+     */
+    readLayerToSampler(destination, index, channel = 0) {
+        const weightData = this.weightData;
+
+        const width = this.size.x;
+        const height = this.size.y;
+
+        assert.equal(destination.width, width, 'destination dimensions mismatch');
+        assert.equal(destination.height, height, 'destination dimensions mismatch');
+
+        const dataOffset = index * width * height;
+
+        for (let y = 0; y < height; y++) {
+
+            for (let x = 0; x < width; x++) {
+
+                const targetIndex = y * width + x;
+                const targetAddress = dataOffset + targetIndex;
+
+                const value = weightData[targetAddress];
+
+                destination.writeChannel(x, y, channel, value);
+
+            }
+        }
+
+    }
+
     /**
      *
      * @param {Uint8Array} source

package/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -6,12 +6,11 @@
 import Vector3 from '../../../../../core/geom/Vector3.js';
 import { assert } from "../../../../../core/assert.js";
 import { lerp } from "../../../../../core/math/lerp.js";
-import { Euler, Matrix4 } from "three";
+import { Matrix4 } from "three";
 import { normalize_angle_rad } from "../../../../../core/geom/normalize_angle_rad.js";
 import { eulerAnglesFromMatrix } from "../../../../../core/geom/3d/eulerAnglesFromMatrix.js";
 
 const m4 = new Matrix4();
-const euler = new Euler();
 const angles = [];
 
 const panOffset = new Vector3();

package/engine/graphics/ecs/highlight/system/MeshHighlightSystem.d.ts

@@ -1,7 +1,8 @@
 import {System} from "../../../../ecs/System";
-import {GraphicsEngine} from "../../../GraphicsEngine";
 import Engine from "../../../../Engine";
+import Highlight from "../Highlight";
+import Mesh from "../../mesh/Mesh";
 
-export default class MeshHighlightSystem extends System {
+export default class MeshHighlightSystem extends System<Highlight, Mesh> {
     constructor(engine: Engine)
 }

package/engine/graphics/ecs/highlight/system/RenderableHighlightSystem.d.ts

@@ -1,6 +1,8 @@
 import {System} from "../../../../ecs/System";
 import Engine from "../../../../Engine";
+import Highlight from "../Highlight";
+import Renderable from "../../../../ecs/components/Renderable";
 
-export class RenderableHighlightSystem extends System {
+export class RenderableHighlightSystem extends System<Highlight, Renderable> {
     constructor(engine: Engine)
 }

package/engine/graphics/ecs/highlight/system/ShadedGeometryHighlightSystem.d.ts

@@ -0,0 +1,8 @@
+import {System} from "../../../../ecs/System";
+import {ShadedGeometry} from "../../mesh-v2/ShadedGeometry";
+import Highlight from "../Highlight";
+import Engine from "../../../../Engine";
+
+export class ShadedGeometryHighlightSystem extends System<Highlight, ShadedGeometry> {
+    constructor(engine: Engine)
+}

package/engine/graphics/ecs/highlight/system/ShadedGeometryHighlightSystem.js

@@ -0,0 +1,180 @@
+import { System } from "../../../../ecs/System.js";
+import { HighlightRenderElementSource } from "../plugin/HighlightRenderElementSource.js";
+import Highlight from "../Highlight.js";
+import { OutlineRenderPlugin } from "../plugin/OutlineRenderPlugin.js";
+import { ShadedGeometry } from "../../mesh-v2/ShadedGeometry.js";
+
+class Supplier extends HighlightRenderElementSource {
+    /**
+     *
+     * @param {ShadedGeometryHighlightSystem} system
+     */
+    constructor(system) {
+        super();
+
+        /**
+         *
+         * @type {ShadedGeometryHighlightSystem}
+         * @private
+         */
+        this.__system = system;
+
+        /**
+         *
+         * @type {ObjectPoolFactory<HighlightRenderElement>}
+         * @private
+         */
+        this.__pool = null;
+        /**
+         *
+         * @type {HighlightRenderGroup}
+         * @private
+         */
+        this.__group = null;
+    }
+
+    collect(pool, group) {
+
+        this.__pool = pool;
+        this.__group = group;
+
+        const system = this.__system;
+
+        /**
+         *
+         * @type {EntityManager}
+         */
+        const em = system.entityManager;
+
+        const dataset = em.dataset;
+
+        if (dataset === null) {
+            return;
+        }
+
+        dataset.traverseEntities([Highlight, ShadedGeometry], this.__visit, this);
+    }
+
+    /**
+     *
+     * @param {Highlight} highlight
+     * @param {ShadedGeometry} sg
+     * @param {number} entity
+     * @private
+     */
+    __visit(highlight, sg, entity) {
+
+        // TODO cull by visibility
+
+        // if (!sg.getFlag(ShadedGeometryFlags.InView)) {
+        //     return;
+        // }
+
+        const elements = highlight.elements;
+
+        if (elements.isEmpty()) {
+            // no elements
+            return;
+        }
+
+        const object = sg.__cached_object;
+
+        if (object === null) {
+            // no renderable primitive
+            return;
+        }
+
+        const renderElement = this.__pool.create();
+
+        renderElement.definitions = elements.asArray();
+        renderElement.object = object;
+
+        this.__group.elements.add(renderElement);
+    }
+}
+
+export class ShadedGeometryHighlightSystem extends System {
+    /**
+     *
+     * @param {Engine} engine
+     * @constructor
+     */
+    constructor(engine) {
+        super();
+
+        /**
+         *
+         * @type {Engine}
+         * @private
+         */
+        this.__engine = engine;
+
+        this.dependencies = [Highlight, ShadedGeometry];
+
+        this.__element_source = new Supplier(this);
+
+        /**
+         *
+         * @type {Reference<OutlineRenderPlugin>}
+         * @private
+         */
+        this.__plugin_renderer_ref = null;
+
+    }
+
+    /**
+     *
+     * @param {EntityManager} entityManager
+     * @param {function} readyCallback
+     * @param {function} errorCallback
+     */
+    shutdown(entityManager, readyCallback, errorCallback) {
+        try {
+
+            if (this.__plugin_renderer_ref !== null) {
+
+                this.__plugin_renderer_ref.getValue().removeSource(this.__element_source);
+
+                this.__plugin_renderer_ref.release();
+
+                this.__plugin_renderer_ref = null;
+            }
+
+            readyCallback();
+        } catch (e) {
+            errorCallback();
+        }
+    }
+
+    /**
+     *
+     * @param {EntityManager} entityManager
+     * @param {function} readyCallback
+     * @param {function} errorCallback
+     */
+    startup(entityManager, readyCallback, errorCallback) {
+        /**
+         *
+         * @type {EntityManager}
+         */
+        this.entityManager = entityManager;
+
+        const engine = this.__engine;
+
+        engine.plugins.acquire(OutlineRenderPlugin)
+            .then(ref => {
+
+                this.__plugin_renderer_ref = ref;
+
+                /**
+                 *
+                 * @type {OutlineRenderPlugin}
+                 */
+                const plugin = ref.getValue();
+
+                plugin.addSource(this.__element_source);
+
+            }, errorCallback)
+            .then(readyCallback);
+    }
+}

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

@@ -53,6 +53,60 @@ export class ShadedGeometry {
          * @private
          */
         this.__transform = null;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.flags = 0;
+    }
+
+    /**
+     *
+     * @param {number|ShadedGeometryFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|ShadedGeometryFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|ShadedGeometryFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|ShadedGeometryFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
+    }
+
+    /**
+     * Current cached entity that this component is attached to
+     * @return {number}
+     */
+    get entity() {
+        return this.__entity;
     }
 
     /**
@@ -91,7 +145,7 @@ export class ShadedGeometry {
      *
      * @param {THREE.BufferGeometry} geometry
      * @param {THREE.Material} material
-     * @param draw_mode
+     * @param {DrawMode} [draw_mode]
      */
     from(geometry, material, draw_mode = DrawMode.Triangles) {
         this.geometry = geometry;
@@ -113,38 +167,42 @@ export class ShadedGeometry {
 
     /**
      *
-     * @param geometry
-     * @param material
-     * @param mode
+     * @param {THREE.BufferGeometry} geometry
+     * @param {THREE.Material} material
+     * @param {DrawMode} [draw_mode]
      * @return {ShadedGeometry}
      */
-    static from(geometry, material, mode) {
+    static from(geometry, material, draw_mode) {
         const r = new ShadedGeometry();
 
-        r.from(geometry, material, mode);
+        r.from(geometry, material, draw_mode);
 
         return r;
     }
 
     updateTransform() {
+        const object_3d = this.__cached_object;
+
         // update matrix
-        this.__cached_object.updateMatrix();
-        this.__cached_object.updateMatrixWorld();
+        object_3d.updateMatrix();
+        object_3d.updateMatrixWorld();
 
         // update bounds
-
         const gbb = this.geometry.boundingBox;
 
+        const min = gbb.min;
+        const max = gbb.max;
+
         _aabb3.setBounds(
-            gbb.min.x,
-            gbb.min.y,
-            gbb.min.z,
-            gbb.max.x,
-            gbb.max.y,
-            gbb.max.z
+            min.x,
+            min.y,
+            min.z,
+            max.x,
+            max.y,
+            max.z
         );
 
-        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, this.__cached_object.matrix.elements);
+        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, object_3d.matrix.elements);
     }
 
     /**

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

@@ -0,0 +1,7 @@
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const ShadedGeometryFlags = {
+    InView: 1
+};

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

@@ -8,7 +8,16 @@ import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
 import { mat4 } from "gl-matrix";
 import { returnTrue } from "../../../../core/function/Functions.js";
 
+/**
+ *
+ * @type {BinaryNode|LeafNode[]}
+ */
 const traversal_stack = [];
+
+/**
+ *
+ * @type {number}
+ */
 let traversal_cursor = 0;
 
 /**

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

@@ -13,12 +13,14 @@ const eh = new EngineHarness();
  */
 async function main(engine) {
 
-    await engine.entityManager.addSystem(new ShadedGeometrySystem(engine));
+    const em = engine.entityManager;
+
+    await em.addSystem(new ShadedGeometrySystem(engine));
 
     EngineHarness.buildBasics({ engine })
 
 
-    const ecd = engine.entityManager.dataset;
+    const ecd = em.dataset;
 
     new EntityBuilder()
         .add(new Transform())

package/engine/graphics/geometry/VertexDataSpec.js

@@ -41,6 +41,26 @@ export class VertexDataSpec {
         return undefined;
     }
 
+    /**
+     * @returns {number} -1 if not found
+     * @param {string} name
+     */
+    getAttributeIndexByName(name) {
+
+        const attributes = this.attributes;
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+            const attribute = attributes[i];
+
+            if (attribute.name === name) {
+                return i;
+            }
+        }
+
+        return undefined;
+    }
+
     /**
      *
      * @param {AttributeSpec} attribute