@woosh/meep-engine 2.33.76 → 2.34.0

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/terrain/ecs/splat/SplatMapping.js

@@ -146,6 +146,44 @@ 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 {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/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -13,6 +13,9 @@ import { build_geometry_info } from "./build_geometry_info.js";
 import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.js";
 import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compute_buffer_geometry_byte_size.js";
 import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
+import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
+import { min2 } from "../../../../core/math/min2.js";
+import { max2 } from "../../../../core/math/max2.js";
 
 /**
  * Returns current time in milliseconds
@@ -100,6 +103,38 @@ function attributes_from_buffer_geometry(buffer_geometry) {
 
 const PRINT_VERBOSE_STATS = false;
 
+/**
+ *
+ * @param {AABB3} result
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_length
+ */
+function aabb3_from_v3_array(result, input, input_length) {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let z0 = Infinity;
+
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    let z1 = -Infinity;
+
+    for (let i = 0; i < input_length; i += 3) {
+        const x = input[i];
+        const y = input[i + 1];
+        const z = input[i + 2];
+
+        x0 = min2(x, x0);
+        y0 = min2(y, y0);
+        z0 = min2(z, z0);
+
+        x1 = max2(x, x1);
+        y1 = max2(y, y1);
+        z1 = max2(z, z1);
+    }
+
+    result.setBounds(x0, y0, z0, x1, y1, z1);
+}
+
 /**
  *
  * @param {THREE.BufferGeometry} input
@@ -118,7 +153,12 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
     const vertex_position_array = position_attribute.array;
 
     topoMesh.build(vertex_position_array, face_index_array);
-    expandConnectivityByLocality(topoMesh);
+
+    // compute aabb
+    const geometry_aabb = new AABB3();
+    aabb3_from_v3_array(geometry_aabb, vertex_position_array, vertex_position_array.length);
+
+    expandConnectivityByLocality(topoMesh, geometry_aabb);
 
     /**
      * Used to generate neighbourhood assignment

package/engine/graphics/particles/particular/engine/parameter/ParticleParameter.js

@@ -173,8 +173,12 @@ export class ParticleParameter {
         //lock default track
         this.defaultTrackValue.disableWriteMode();
 
-        for (i = 0; i < this.trackCount; i++) {
-            track = this.tracks.get(i);
+        const track_count = this.trackCount;
+        const tracks = this.tracks;
+
+        for (i = 0; i < track_count; i++) {
+
+            track = tracks.get(i);
 
             if (track === undefined) {
                 //write the default track into the parameter
@@ -183,6 +187,7 @@ export class ParticleParameter {
                 //lock track
                 track.disableWriteMode();
             }
+
         }
 
         this.computeStatistics();

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -433,9 +433,10 @@ async function sample_scene_nam(engine) {
         "distanceMax": 1000
     });
 
-    // load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
-    load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
+    load_model('moicon/20_Dec_2021_Nammo/with_assets(for_alex)/model.gltf', ecd)
+    // load_model('moicon/20_Dec_2021_Nammo/with_assets_micron_conveted/model.gltf', ecd)
     // load_model('moicon/micron_container/model.gltf', ecd)
+    // load_model('moicon/test_philippe_jan_2022/test/model.gltf', ecd)
 
     const P_SIZE_SMALL = 0.15;
     const P_SIZE_MEDIUM = 0.6;

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -30,13 +30,19 @@ export function query_bvh_frustum_from_texture(
     let result = 0;
     let plane_address;
 
+    const binary_node_count = root.getBinaryNodeCount();
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
     stack[0] = 0;
 
-    const binary_node_count = root.getBinaryNodeCount();
     const last_valid_index = binary_node_count + root.getLeafNodeCount();
     const data_view = root.getDataView();
 
@@ -122,8 +128,6 @@ export function query_bvh_frustum_from_texture(
 
             } else if (light_type === 3) {
                 // decal
-                debugger;
-
             } else {
                 throw new Error(`Unsupported light type ${light_type}`);
             }

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -1374,6 +1374,8 @@ Sampler2D.prototype.traverseCircle = function (centerX, centerY, radius, visitor
  * @param {boolean} [preserveData=true]
  */
 Sampler2D.prototype.resize = function (x, y, preserveData = true) {
+    assert.isNonNegativeInteger(x, 'x');
+    assert.isNonNegativeInteger(y, 'y');
 
     const _w = this.width;
     const _h = this.height;

package/engine/graphics/texture/sampler/downsampleSampler2D.js

@@ -56,9 +56,11 @@ export function downsampleSampler2D(input, output) {
 
             // accumulate sample
             for (j = 0; j < sH; j++) {
+                const row_index = (sampleOffsetY + j) * iW;
+
                 for (i = 0; i < sW; i++) {
 
-                    const iAddress = ((sampleOffsetX + i) + (sampleOffsetY + j) * iW) * itemSize;
+                    const iAddress = ((sampleOffsetX + i) + row_index) * itemSize;
 
                     for (k = 0; k < itemSize; k++) {
                         sample[k] += iData[k + iAddress];