@woosh/meep-engine 2.39.39 → 2.39.42

package/engine/EngineHarness.js

@@ -27,6 +27,8 @@ 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";
+import SoundListenerSystem from "./sound/ecs/SoundListenerSystem.js";
+import SoundListener from "./sound/ecs/SoundListener.js";
 
 /**
  *
@@ -174,6 +176,10 @@ export class EngineHarness {
             em.addSystem(new CameraSystem(engine.graphics.scene, engine.graphics))
         }
 
+        if (em.getSystem(SoundListenerSystem) === null) {
+            em.addSystem(new SoundListenerSystem(engine.sound.context));
+        }
+
         if (!ecd.isComponentTypeRegistered(Tag)) {
             ecd.registerComponentType(Tag);
         }
@@ -199,6 +205,7 @@ export class EngineHarness {
             .add(transform)
             .add(cameraController)
             .add(camera)
+            .add(new SoundListener())
             .add(Tag.fromJSON(["Camera"]))
             .build(ecd);
 

package/engine/asset/loaders/geometry/geometry/computeBufferAttributeHash.js

@@ -1,3 +1,5 @@
+import { computeStridedIntegerArrayHash } from "../../../../computeStridedIntegerArrayHash.js";
+
 /**
  *
  * @param {THREE.BufferAttribute} attribute
@@ -15,14 +17,11 @@ export function computeBufferAttributeHash(attribute) {
         // compute stride so that we don't have to iterate over the entire buffer, instead picking at most X(509) values to consider
         const stride = Math.max(1, Math.ceil(index_data_size / 509));
 
-        for (let i = 0; i < index_data_size; i += stride) {
-            const value = index_data[i];
-
-            result = ((result * 31) + value) | 0;
-
-        }
+        result ^= computeStridedIntegerArrayHash(index_data, 0, index_data_size, stride);
 
     }
 
     return result;
 }
+
+

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

@@ -7,4 +7,13 @@ export class Codec {
     async decode(data) {
         throw  new Error('Unsupported Operation');
     }
+
+    /**
+     * Whether codec is able to decode this data, typically checks headers in the data
+     * @param {Uint8Array} data
+     * @return {Promise<boolean>} true if able, false otherwise
+     */
+    async test(data) {
+        return true;
+    }
 }

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

@@ -1,28 +1,69 @@
 import { Codec } from "./Codec.js";
-import { logger } from "../../../../logging/GlobalLogger.js";
 
 export class CodecWithFallback extends Codec {
     /**
      *
-     * @param {Codec} main
-     * @param {Codec} fallback
+     * @param {Codec} codecs
      */
-    constructor(main, fallback) {
+    constructor(...codecs) {
         super();
 
-        this.main = main;
-        this.fallback = fallback;
+        this.children = codecs.slice();
+
+        if (this.children.length < 1) {
+            throw new Error('At least one codec must be provided');
+        }
+    }
+
+    async test(data) {
+        const codecs = this.children;
+        const codec_count = codecs.length;
+
+        for (let i = 0; i < codec_count; i++) {
+            const codec = codecs[i];
+
+            if (codec.test(data)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     async decode(data) {
 
-        try {
-            return await this.main.decode(data);
-        } catch (e) {
-            logger.warn(`Main codec failed, will attempt fallback. Error: ${e}`);
+        const codecs = this.children;
+        const codec_count = codecs.length;
 
-            return this.fallback.decode(data);
+        const errors = [];
+
+        let result;
+
+        for (let i = 0; i < codec_count; i++) {
+            const codec = codecs[i];
+
+            if (!codec.test(data)) {
+                errors.push({
+                    index: i, error: "Codec doesn't support this data"
+                });
+                continue;
+            }
+
+            try {
+                result = await codec.decode(data);
+            } catch (e) {
+
+                errors.push({
+                    index: i, error: e
+                });
+
+                continue;
+            }
+
+            return result;
         }
 
+        throw new Error(`All codecs failed, errors: ${errors.map(a => JSON.stringify(a)).join('\n')}`);
+
     }
 }

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

@@ -1,6 +1,7 @@
 import { Codec } from "./Codec.js";
 import WorkerBuilder from "../../../../../core/process/worker/WorkerBuilder.js";
 import { OnDemandWorkerManager } from "../../../../../core/process/worker/OnDemandWorkerManager.js";
+import { PNG_HEADER_BYTES } from "../png/PNG_HEADER_BYTES.js";
 
 export class ThreadedImageDecoder extends Codec {
     constructor() {
@@ -23,6 +24,17 @@ export class ThreadedImageDecoder extends Codec {
         this.worker.setTimeout(200);
     }
 
+    async test(data) {
+
+        for (let i = 0; i < PNG_HEADER_BYTES.length; i++) {
+            if (data[i] !== PNG_HEADER_BYTES[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     async decode(data) {
         const result = await this.worker.request('decode', [data.buffer]);
         return result;

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

@@ -6,6 +6,7 @@ import zlib from 'pako';
 import { PNG } from './PNG.js';
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
+import { PNG_HEADER_BYTES } from "./PNG_HEADER_BYTES.js";
 
 function readUInt32(buffer, offset) {
     return (buffer[offset] << 24) +
@@ -62,7 +63,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])) {
+    if (!isArrayEqualStrict(header, PNG_HEADER_BYTES)) {
         throw new Error('invalid PNGReader file (bad signature)');
     }
 

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

@@ -0,0 +1 @@
+export const PNG_HEADER_BYTES = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];

package/engine/computeStridedIntegerArrayHash.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {number[]|Uint32Array|Uint16Array|Uint8Array} array
+ * @param {number} offset
+ * @param {number} length
+ * @param {number} stride
+ * @return {number}
+ */
+export function computeStridedIntegerArrayHash(array, offset, length, stride) {
+    let result = length;
+
+    for (let i = offset; i < length; i += stride) {
+        const value = array[i];
+
+        result = ((result * 31) + value) | 0;
+    }
+
+    return result;
+}

package/engine/ecs/EntityBuilder.d.ts

@@ -28,4 +28,6 @@ export default class EntityBuilder {
     addEventListener(eventName: string, listener: (data?: any) => void, context?: any): EntityBuilder
 
     removeEventListener(eventName: string, listener: (data?: any) => void, context?: any): EntityBuilder
+
+    static readFromDataset(entity: number, dataset: EntityComponentDataset): EntityBuilder
 }

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

@@ -1,3 +1,5 @@
-export default class GUIElement {
+import View from "../../../view/View";
 
+export default class GUIElement {
+    static fromView(view: View): GUIElement
 }

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

@@ -390,16 +390,18 @@ export class TerrainLayers {
 
         const resolution = this.resolution;
 
-        const singleLayerByteSize = resolution.x * resolution.y * 3;
+        const single_layer_byte_size = resolution.x * resolution.y * 3;
 
-        if (arrayData.length < singleLayerByteSize * index) {
+        if (arrayData.length < single_layer_byte_size * index) {
             throw new Error('Texture data is too small, make sure you rebuild texture data before attempting to write');
         }
 
-        const address = singleLayerByteSize * index;
+        const address = single_layer_byte_size * index;
 
         const sampler = this.__obtain_layer_data_at_resolution(layer, resolution);
 
+        assert.equal(sampler.data.length, single_layer_byte_size, 'Incorrect layer data size');
+
         arrayData.set(sampler.data, address);
 
         //mark texture for update

package/engine/graphics/ecs/light/binding/fp/FPLightBinding.js

@@ -8,12 +8,21 @@ export class FPLightBinding extends LightBinding {
         this.__light = null;
     }
 
+    /**
+     *
+     * @return {ForwardPlusRenderingPlugin}
+     * @private
+     */
+    get __plugin(){
+        return ctx.system.__plugin.getValue();
+    }
+
     link(ctx) {
         /**
          *
          * @type {ForwardPlusRenderingPlugin}
          */
-        const fp = ctx.system.__plugin.getValue();
+        const fp = this.__plugin;
 
         const lightManager = fp.getLightManager();
 
@@ -43,7 +52,7 @@ export class FPLightBinding extends LightBinding {
          *
          * @type {ForwardPlusRenderingPlugin}
          */
-        const fp = ctx.system.__plugin.getValue();
+        const fp = this.__plugin;
 
         const lightManager = fp.getLightManager();
 

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

@@ -28,12 +28,6 @@ import {
  */
 const scratch_point = new SurfacePoint3();
 
-/**
- *
- * @type {Float32Array|mat4}
- */
-const scratch_m4 = new Float32Array(16);
-
 /**
  * @readonly
  * @type {Float32Array}
@@ -256,12 +250,12 @@ export class ShadedGeometrySystem extends System {
     link(sg, t, entity) {
         sg.__c_transform = t;
 
+        sg.update_bounds();
+
         t.position.onChanged.add(sg.updateTransform, sg);
         t.rotation.onChanged.add(sg.updateTransform, sg);
         t.scale.onChanged.add(sg.updateTransform, sg);
 
-        sg.update_bounds();
-
         // remember entity for lookups
         sg.__entity = entity;
 

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts

@@ -15,4 +15,11 @@ export class GeometrySpatialQueryAccelerator {
         origin_x: number, origin_y: number, origin_z: number,
         direction_x: number, direction_y: number, direction_z: number
     ): boolean
+
+    /**
+     * In bytes
+     */
+    cache_size: number
+
+    static INSTANCE: GeometrySpatialQueryAccelerator;
 }

package/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js

@@ -33,6 +33,22 @@ export class GeometrySpatialQueryAccelerator {
         this.__visitor_raycast = new RaycastNearestHitComputingVisitor();
     }
 
+    /**
+     *
+     * @param {number} value in bytes
+     */
+    set cache_size(value) {
+        this.cache.setMaxWeight(value);
+    }
+
+    /**
+     *
+     * @return {number} in bytes
+     */
+    get cache_size() {
+        return this.cache.maxWeight;
+    }
+
     /**
      *
      * @param {THREE.BufferGeometry} geometry
@@ -184,7 +200,7 @@ export class GeometrySpatialQueryAccelerator {
         const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
         const vertices = de_interleaved_position_attribute.array;
 
-        if(index_attribute === undefined || index_attribute === null){
+        if (index_attribute === undefined || index_attribute === null) {
             return buildUnsortedUnindexed(vertices);
         }
 

package/engine/graphics/geometry/optimization/merge/merge_geometry_hierarchy.js

@@ -0,0 +1,336 @@
+import { StaticMaterialCache } from "../../../../asset/loaders/material/StaticMaterialCache.js";
+import { HashMap } from "../../../../../core/collection/HashMap.js";
+import { computeGeometryEquality } from "../../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
+import { computeGeometryHash } from "../../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
+import { array_copy } from "../../../../../core/collection/array/copyArray.js";
+import { mat4 } from "gl-matrix";
+import { Group, Matrix4, Mesh } from "three";
+import { mergeBufferGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { groupArrayBy } from "../../../../../core/collection/ArrayUtils.js";
+import { collectIteratorValueToArray } from "../../../../../core/collection/IteratorUtils.js";
+
+class GeometryContext {
+    constructor() {
+        this.matrix = new Float32Array(16);
+        this.material = null;
+        this.geometry = null;
+    }
+}
+
+const DEFAULT_INSTANCING_MERGE_POLYCOUNT = 1024;
+
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @param {THREE.Object3D} ancestor_root
+ * @param {Float32Array} result
+ */
+function compute_transform_matrix(object, ancestor_root, result) {
+    /**
+     *
+     * @type {THREE.Object3D[]}
+     */
+    const path = [];
+
+    let node = object;
+
+    while (node !== ancestor_root) {
+
+        if (path.indexOf(node) !== -1) {
+            throw new Error('Circular dependency');
+        }
+
+        path.push(node);
+
+        node = node.parent;
+
+        if (node === null) {
+            throw new Error('Ancestor not found');
+        }
+
+    }
+
+    //
+    path.reverse();
+
+    mat4.identity(result);
+
+    for (let i = 0; i < path.length; i++) {
+        const el = path[i];
+
+        mat4.multiply(result, result, el.matrix.elements);
+    }
+
+}
+
+
+/**
+ *
+ * @param {THREE.BufferGeometry} a
+ * @param {THREE.BufferGeometry} b
+ * @returns {boolean}
+ */
+function equal_attribute_structure(a, b) {
+    if (a === b) {
+        return true;
+    }
+
+    const a_attribute_names = Object.keys(a.attributes);
+    const b_attribute_names = Object.keys(b.attributes);
+
+
+    const n = a_attribute_names.length;
+    if (n !== b_attribute_names.length) {
+        return false;
+    }
+
+    for (let i = 0; i < n; i++) {
+        const a_key = a_attribute_names[i];
+
+        const b_attribute_index = b_attribute_names.indexOf(a_key);
+
+        if (b_attribute_index === -1) {
+            return -1;
+        }
+
+        const a_attribute = a.attributes[a_key];
+        const b_attribute = b.attributes[a_key];
+
+        if (a_attribute.itemSize !== b_attribute.itemSize) {
+            return false;
+        }
+
+        if (a_attribute.normalized !== b_attribute.normalized) {
+            return false;
+        }
+
+        if (a_attribute.array.constructor !== b_attribute.array.constructor) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ *
+ * @param {GeometryContext[]} contexts
+ * @returns {GeometryContext}
+ */
+function merge_contexts(contexts) {
+
+    const geometries = contexts.map(ctx => {
+        const g = ctx.geometry.clone();
+
+        const matrix4 = new Matrix4();
+        matrix4.elements = ctx.matrix;
+
+        g.applyMatrix4(matrix4);
+
+        return g;
+    });
+
+    const merged = mergeBufferGeometries(geometries);
+
+    const merged_context = new GeometryContext();
+
+    mat4.identity(merged_context.matrix);
+    merged_context.geometry = merged;
+    merged_context.material = contexts[0].material;
+
+    return merged_context;
+}
+
+/**
+ *
+ * @param {GeometryContext[]} input
+ * @param {GeometryContext[]} output
+ * @param {number} output_offset
+ * @returns {number}
+ */
+function merge_by_material(input, output, output_offset) {
+    let result_offset = output_offset;
+
+    const undecided = input.slice();
+
+    while (undecided.length > 0) {
+        for (let i = 0; i < undecided.length; i++) {
+            const ref_0 = undecided[i];
+
+            const set_indices = [i];
+            const set_contexts = [ref_0];
+
+            for (let j = i + 1; j < undecided.length; j++) {
+                const ref_1 = undecided[j];
+
+                const geo_0 = ref_0.geometry;
+                const geo_1 = ref_1.geometry;
+
+                if (geo_0 === geo_1) {
+                    const tri_count = (geo_0.getIndex().count) / 3;
+                    if (tri_count > DEFAULT_INSTANCING_MERGE_POLYCOUNT) {
+                        // instancing, and instances are large enough for instancing to be efficient
+                        continue;
+                    }
+                }
+
+                if (!equal_attribute_structure(geo_0, geo_1)) {
+                    continue;
+                }
+
+                if (ref_0.material !== ref_1.material) {
+                    continue;
+                }
+
+                set_indices.push(j);
+                set_contexts.push(ref_1);
+            }
+
+            let out = ref_0;
+
+            for (let j = set_indices.length - 1; j >= 0; j--) {
+                undecided.splice(set_indices[j], 1);
+            }
+
+            if (set_indices.length > 1) {
+
+
+                out = merge_contexts(set_contexts);
+
+                i--;
+            }
+
+            output[result_offset++] = out;
+        }
+    }
+
+    return result_offset - output_offset;
+
+}
+
+/**
+ *
+ * @param {GeometryContext} ctx
+ * @returns {Mesh}
+ */
+function context_to_mesh(ctx) {
+    const mesh = new Mesh(ctx.geometry, ctx.material);
+
+    matrix_array_to_three_object(ctx.matrix, mesh);
+
+    return mesh;
+}
+
+/**
+ *
+ * @param {number[]} matrix
+ * @param {THREE.Object3D} destination
+ */
+function matrix_array_to_three_object(matrix, destination) {
+
+    array_copy(matrix, 0, destination.matrix.elements, 0, 16);
+
+    destination.matrix.decompose(destination.position, destination.quaternion, destination.scale);
+
+    destination.rotation.setFromQuaternion(destination.quaternion);
+}
+
+/**
+ *
+ * @param {THREE.Object3D} source
+ * @param {THREE.Object3D} destination
+ */
+function apply_transform_to_another_three_object(source, destination) {
+    const m4 = new Matrix4();
+
+    m4.multiplyMatrices(source.matrix, destination.matrix);
+
+    matrix_array_to_three_object(m4.elements, destination);
+}
+
+/**
+ *
+ * @param {THREE.Object3D} input
+ * @param context
+ * @returns {THREE.Object3D}
+ */
+export function merge_geometry_hierarchy(input, context = new Context()) {
+    // material cache
+    const material_cache = new StaticMaterialCache();
+
+
+    const geometry_cache = new HashMap({
+        keyEqualityFunction: computeGeometryEquality,
+        keyHashFunction: computeGeometryHash
+    });
+
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geo
+     * @return {THREE.BufferGeometry}
+     */
+    function dedupe_geometry(geo) {
+        const existing = geometry_cache.get(geo);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        geometry_cache.set(geo, geo);
+
+        return geo;
+    }
+
+    let contexts = [];
+
+    // collect geometries
+    input.traverse(o => {
+        if (o.isMesh && !!(o.geometry)) {
+
+            const ctx = new GeometryContext();
+
+            ctx.material = material_cache.acquire(o.material);
+            ctx.geometry = dedupe_geometry(o.geometry);
+
+            compute_transform_matrix(o, input, ctx.matrix);
+
+            contexts.push(ctx);
+        }
+    });
+
+    const materials = collectIteratorValueToArray([], material_cache.materialCache.data.keys());
+
+    const color_groups = groupArrayBy(materials, (m => m.color.getHex()));
+
+    console.warn(color_groups);
+
+
+    const contexts_merge_stage_0 = [];
+
+    merge_by_material(contexts, contexts_merge_stage_0, 0);
+
+    // convert contexts to Meshes
+
+    const meshes = contexts_merge_stage_0.map(context_to_mesh);
+
+    let result_object;
+
+    if (meshes.length === 1) {
+        // only one mesh is present, return that
+        result_object = meshes[0];
+    } else {
+
+        result_object = new Group();
+
+        for (let i = 0; i < meshes.length; i++) {
+            const m = meshes[i];
+            result_object.add(m);
+        }
+    }
+
+    // copy transform from original
+    apply_transform_to_another_three_object(input, result_object);
+
+    return result_object;
+}