@woosh/meep-engine 2.39.38 → 2.39.41

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

@@ -10,6 +10,48 @@ import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bv
  */
 const stack = [];
 
+/**
+ *
+ * @param {DataView} data_view
+ * @param {number} address
+ * @param {ArrayLike<number>|number[]} planes
+ * @return {boolean}
+ */
+function frustum_check(data_view, address, planes) {
+    const n_x0 = data_view.getFloat32(address);
+    const n_y0 = data_view.getFloat32(address + 4);
+    const n_z0 = data_view.getFloat32(address + 8);
+    const n_x1 = data_view.getFloat32(address + 12);
+    const n_y1 = data_view.getFloat32(address + 16);
+    const n_z1 = data_view.getFloat32(address + 20);
+
+    for (let plane_address = 0; plane_address < 24; plane_address += 4) {
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        const distanceAbovePlane = aabb3_computeDistanceAbovePlane_max(
+            plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+            n_x0, n_y0, n_z0,
+            n_x1, n_y1, n_z1
+        );
+
+        if (distanceAbovePlane <= 0) {
+            // node is below the plane
+
+            // query_bvh_frustum_from_objects.rejection_count++;
+
+            return false;
+        }
+
+        // TODO under current scheme we can reserve 6 bit in what we push onto the stack for plane mask (allows us to skip some planar tests)
+    }
+
+    return true;
+}
+
 /**
  * Most of the data is in flat continuous array for cache coherence
  * @param {number[]} destination
@@ -57,35 +99,8 @@ export function query_bvh_frustum_from_texture(
             // is intermediate node
             const node_address = node_index * BVH_BINARY_NODE_SIZE;
 
-            const n_x0 = data_view.getFloat32(node_address);
-            const n_y0 = data_view.getFloat32(node_address + 4);
-            const n_z0 = data_view.getFloat32(node_address + 8);
-            const n_x1 = data_view.getFloat32(node_address + 12);
-            const n_y1 = data_view.getFloat32(node_address + 16);
-            const n_z1 = data_view.getFloat32(node_address + 20);
-
-            for (plane_address = 0; plane_address < 24; plane_address += 4) {
-
-                const plane_normal_x = planes[plane_address];
-                const plane_normal_y = planes[plane_address + 1];
-                const plane_normal_z = planes[plane_address + 2];
-                const plane_constant = planes[plane_address + 3];
-
-                const distanceAbovePlane = aabb3_computeDistanceAbovePlane_max(
-                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
-                    n_x0, n_y0, n_z0,
-                    n_x1, n_y1, n_z1
-                );
-
-                if (distanceAbovePlane < 0) {
-                    // node is below the plane
-
-                    // query_bvh_frustum_from_objects.rejection_count++;
-
-                    continue stack_loop;
-                }
-
-                // TODO under current scheme we can reserve 6 bit in what we push onto the stack for plane mask (allows us to skip some planar tests)
+            if (!frustum_check(data_view, node_address, planes)) {
+                continue;
             }
 
             const left_index = (node_index << 1) + 1;
@@ -130,6 +145,11 @@ export function query_bvh_frustum_from_texture(
 
             } else if (light_type === 3) {
                 // decal
+
+                if (!frustum_check(data_view, node_address, planes)) {
+                    continue;
+                }
+
             } else {
                 throw new Error(`Unsupported light type ${light_type}`);
             }

package/engine/graphics/texture/atlas/AbstractTextureAtlas.js

@@ -16,4 +16,15 @@ export class AbstractTextureAtlas {
     remove(patch) {
         throw new Error('Not Implemented')
     }
+
+    get sampler() {
+        throw new Error('Not Implemented')
+    }
+
+    /**
+     * @throws {Error} if update fails
+     */
+    update() {
+        throw new Error('Not Implemented')
+    }
 }

package/engine/graphics/texture/atlas/CachingTextureAtlas.js

@@ -1,5 +1,6 @@
 import { Cache } from "../../../../core/cache/Cache.js";
 import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
+import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
 
 /**
  * 4Mb
@@ -26,6 +27,7 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
          */
         this.__cached_patches = new Cache({
             maxWeight: cache_size,
+            keyHashFunction: invokeObjectHash,
             keyWeigher(sampler) {
                 return sampler.computeByteSize();
             }
@@ -41,6 +43,25 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
         this.__cached_patches.onEvicted.add(this.__handle_cache_eviction, this);
     }
 
+    update() {
+        try {
+            this.__atals.update();
+        } catch (e) {
+            if (this.__cached_patches.size() > 0) {
+
+                // has some caches patches, lets drop them
+                this.__cached_patches.clear();
+
+                // try to update again
+                this.__atals.update();
+
+            } else {
+                // just re-throw
+                throw e;
+            }
+        }
+    }
+
     /**
      *
      * @returns {AbstractTextureAtlas}
@@ -49,6 +70,14 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
         return this.__atals;
     }
 
+    /**
+     *
+     * @return {Sampler2D}
+     */
+    get sampler() {
+        return this.__atals.sampler;
+    }
+
     /**
      *
      * @param {Sampler2D} sampler
@@ -74,6 +103,11 @@ export class CachingTextureAtlas extends AbstractTextureAtlas {
 
         if (existing_patch !== null) {
             // cache hit
+
+            // remove from cache
+            this.__cached_patches.remove(sampler);
+
+            // return patch
             return existing_patch;
         }
 

package/engine/graphics/texture/atlas/ReferencedTextureAtlas.js

@@ -26,6 +26,10 @@ export class ReferencedTextureAtlas extends AbstractTextureAtlas {
 
     }
 
+    update() {
+        this.__atlas.update();
+    }
+
     /**
      *
      * @param {Reference} ref
@@ -39,8 +43,10 @@ export class ReferencedTextureAtlas extends AbstractTextureAtlas {
         ref_counts.set(patch, ref_count - 1);
 
         if (ref_count === 1) {
-            // clear patch
+            // last reference removed, clear patch
             this.__atlas.remove(patch);
+            ref_counts.delete(patch);
+            this.__patches.delete(patch.sampler);
         }
     }
 
@@ -61,6 +67,8 @@ export class ReferencedTextureAtlas extends AbstractTextureAtlas {
         if (patch === undefined) {
             patch = atlas.add(sampler);
             ref_counts.set(patch, 1)
+
+            this.__patches.set(sampler, patch);
         } else {
             ref_counts.set(patch, ref_counts.get(patch) + 1);
         }

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -9,7 +9,9 @@ import { AtlasPatchFlag } from "./AtlasPatchFlag.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
-import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import {
+    DataType2TypedArrayConstructorMapping
+} from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
 import { invokeObjectClone } from "../../../../core/model/object/invokeObjectClone.js";
 
@@ -47,10 +49,11 @@ export class TextureAtlas extends AbstractTextureAtlas {
         const channel_count = 4;
 
         /**
+         * @private
          * @readonly
          * @type {Sampler2D}
          */
-        this.sampler = new Sampler2D(new TypeArrayConstructor(size * size * channel_count), channel_count, size, size);
+        this.__sampler = new Sampler2D(new TypeArrayConstructor(size * size * channel_count), channel_count, size, size);
 
 
         /**
@@ -71,6 +74,14 @@ export class TextureAtlas extends AbstractTextureAtlas {
         this.__needsUpdate = false;
     }
 
+    /**
+     *
+     * @return {Sampler2D}
+     */
+    get sampler() {
+        return this.__sampler;
+    }
+
     /**
      *
      * @param {Sampler2D} sampler
@@ -127,7 +138,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
 
 
         //erase data
-        this.sampler.data.fill(0);
+        this.__sampler.data.fill(0);
 
         this.__needsUpdate = true;
     }
@@ -175,7 +186,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
 
         this.size.set(x, y);
         this.packer.resize(x, y);
-        this.sampler.resize(x, y);
+        this.__sampler.resize(x, y);
 
         return true;
     }
@@ -188,17 +199,17 @@ export class TextureAtlas extends AbstractTextureAtlas {
     paintPatch(patch) {
         // console.time('TextureAtlas.paintPatch');
 
-        const target = this.sampler;
+        const target = this.__sampler;
 
         const source = patch.sampler;
 
-        const patchPosition = patch.position;
-        const patchSize = patch.size;
+        const patch_position = patch.position;
+        const patch_size = patch.size;
 
         target.copy_sameItemSize(
             source,
             0, 0,
-            patchPosition.x, patchPosition.y, patchSize.x, patchSize.y
+            patch_position.x, patch_position.y, patch_size.x, patch_size.y
         );
 
         patch.setFlag(AtlasPatchFlag.Painted);
@@ -222,7 +233,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
 
         this.eraseArea(x0, y0, x1, y1);
 
-
+        // mark as non-painted
         patch.clearFlag(AtlasPatchFlag.Painted);
     }
 
@@ -234,9 +245,9 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @param {number} y1
      */
     eraseArea(x0, y0, x1, y1) {
-        const sampler = this.sampler;
+        const sampler = this.__sampler;
 
-        sampler.zeroFill(x0, y0, x1, y1);
+        sampler.zeroFill(x0, y0, x1 - x0, y1 - y0);
     }
 
     /**
@@ -246,6 +257,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @return {AtlasPatch}
      */
     add(sampler, padding = 4) {
+        // console.log('#add');
 
         const patch = new AtlasPatch();
 
@@ -272,6 +284,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * @return {boolean}
      */
     remove(patch) {
+        // console.log('#remove');
         const patchIndex = this.patches.indexOf(patch);
 
         if (patchIndex === -1) {
@@ -282,15 +295,15 @@ export class TextureAtlas extends AbstractTextureAtlas {
         this.patches.splice(patchIndex, 1);
         this.idPool.release(patch.id);
 
-        if (patch.getFlag(AtlasPatchFlag.Packed)) {
-            this.packer.remove(patch.packing);
-        }
-
         if (patch.getFlag(AtlasPatchFlag.Painted)) {
             //erase the patch
             this.erasePatch(patch);
         }
 
+        if (patch.getFlag(AtlasPatchFlag.Packed)) {
+            this.packer.remove(patch.packing);
+        }
+
         return true;
     }
 
@@ -513,7 +526,7 @@ export class TextureAtlas extends AbstractTextureAtlas {
      * Drops all the data
      */
     reset() {
-        this.sampler.data.fill(0);
+        this.__sampler.data.fill(0);
 
         this.patches = [];
 

package/engine/graphics/texture/atlas/TextureAtlasDebugger.js

@@ -1,5 +1,6 @@
-import EmptyView from "../../../../view/elements/EmptyView.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
+import { CanvasView } from "../../../../view/elements/CanvasView.js";
+import { FrameRunner } from "../../FrameRunner.js";
 
 /**
  * Visualizer for TextureAtlas, to help understand current state of the atlas
@@ -9,13 +10,19 @@ export class TextureAtlasDebugger {
      *
      * @param {TextureAtlas} atlas
      * @param {Vector2} [scale]
+     * @param {boolean} [draw_padding]
+     * @param {boolean} [draw_borders]
      */
-    constructor(atlas, { scale = new Vector2(1, 1) } = {}) {
+    constructor(atlas, {
+        scale = new Vector2(1, 1),
+        draw_padding = true,
+        draw_borders = true
+    } = {}) {
         window.atlas = atlas;
 
-        this.vAtlasContent = new EmptyView({ tag: 'canvas' });
+        const vCanvas = new CanvasView();
 
-        this.vAtlasContent.css({
+        vCanvas.css({
             position: "absolute",
             top: "0",
             left: "0",
@@ -25,49 +32,98 @@ export class TextureAtlasDebugger {
             background: 'rgba(0,0,0,0.8)'
         });
 
-        const ctx = this.vAtlasContent.el.getContext('2d');
+        const ctx = vCanvas.context2d;
+
+        let last_drawn_version = -1;
 
         function draw() {
 
             const size = atlas.size;
+
+
             if (size.x !== 0 && size.y !== 0) {
                 ctx.clearRect(0, 0, size.x, size.y);
 
                 const imageData = ctx.createImageData(size.x, size.y);
+
                 imageData.data.set(atlas.sampler.data);
 
                 ctx.putImageData(imageData, 0, 0);
 
-                ctx.strokeStyle = 'red';
 
                 //draw patch boundaries
-                atlas.patches.forEach(patch => {
-                    const aabb2 = patch.packing;
+                for (let i = 0; i < atlas.patches.length; i++) {
+                    const patch = atlas.patches[i];
 
-                    ctx.strokeRect(aabb2.x0, aabb2.y0, aabb2.getWidth(), aabb2.getHeight());
+                    if (draw_padding) {
+                        // draw padding area
+                        ctx.strokeStyle = 'rgba(0,166,255,0.5)';
+                        ctx.lineWidth = patch.padding;
 
-                });
+                        ctx.strokeRect(
+                            patch.position.x - patch.padding * 0.5,
+                            patch.position.y - patch.padding * 0.5,
+                            patch.size.x + patch.padding,
+                            patch.size.y + patch.padding,
+                        );
+                    }
+
+                    if (draw_borders) {
+                        const aabb2 = patch.packing;
+
+                        // draw patch borders
+                        ctx.strokeStyle = 'red';
+                        ctx.lineWidth = 1;
+
+                        ctx.strokeRect(aabb2.x0, aabb2.y0, aabb2.getWidth(), aabb2.getHeight());
+                    }
+                }
 
             } else {
                 ctx.clearRect(0, 0, 1, 1);
             }
+
+            // remember last drawn version
+            last_drawn_version = atlas.sampler.version;
+        }
+
+        vCanvas.size.set(0, 0);
+
+        function try_draw() {
+            if (last_drawn_version !== atlas.sampler.version) {
+                draw();
+            }
         }
 
-        this.vAtlasContent.size.set(0, 0);
+        const write_dimensions = () => {
+            const x = atlas.size.x;
+            const y = atlas.size.y;
 
-        atlas.size.onChanged.add((x, y) => {
-            const v = this.vAtlasContent;
+            vCanvas.size.set(x, y);
+            vCanvas.scale.copy(scale);
+            vCanvas.transformOrigin.set(0, 0);
+        };
 
-            const w = x * scale.x;
-            const h = y * scale.y;
+        function full_update() {
+            write_dimensions();
+            draw();
+        }
+
+        const fr = new FrameRunner(try_draw);
 
-            v.size.set(w, h);
-            v.el.setAttribute('width', x);
-            v.el.setAttribute('height', y);
+        atlas.size.onChanged.add(full_update);
 
+        vCanvas.on.linked.add(() => {
+            full_update();
+            fr.startup();
         });
 
-        this.vAtlasContent.on.linked.add(draw);
+        vCanvas.on.unlinked.add(() => {
+            fr.shutdown();
+        })
+
         atlas.on.painted.add(draw);
+
+        this.vAtlasContent = vCanvas;
     }
 }

package/engine/graphics/texture/sampler/Sampler2D.d.ts

@@ -1,4 +1,6 @@
 export class Sampler2D {
+    constructor(data: ArrayLike<number>, itemSize?: number, width?: number, height?: number)
+
     readonly height: number
     readonly width: number
 

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

@@ -14,6 +14,9 @@ import { typedArrayToDataType } from "../../../../core/collection/array/typedArr
 import {
     compute_typed_array_constructor_from_data_type
 } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { Base64 } from "../../../../core/binary/Base64.js";
+import { computeStridedIntegerArrayHash } from "../../../computeStridedIntegerArrayHash.js";
+import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 /**
  * @class
@@ -22,20 +25,20 @@ export class Sampler2D {
     /**
      *
      * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
-     * @param {int} itemSize
-     * @param {int} width
-     * @param {int} height
+     * @param {number} itemSize
+     * @param {number} width
+     * @param {number} height
      * @constructor
      */
     constructor(data = [], itemSize = 1, width = 0, height = 0) {
-        if (!Number.isInteger(itemSize)) {
-            throw new Error(`itemSize must be integer, instead was ${itemSize}`);
+        if (!Number.isInteger(itemSize) || itemSize < 0) {
+            throw new Error(`itemSize must be a non-negative integer, instead was ${itemSize}`);
         }
-        if (!Number.isInteger(width)) {
-            throw new Error(`width must be integer, instead was ${width}`);
+        if (!Number.isInteger(width) || itemSize < 0) {
+            throw new Error(`width must be a non-negative integer, instead was ${width}`);
         }
-        if (!Number.isInteger(height)) {
-            throw new Error(`height must be integer, instead was ${height}`);
+        if (!Number.isInteger(height) || itemSize < 0) {
+            throw new Error(`height must be a non-negative integer, instead was ${height}`);
         }
 
         if (data === undefined) {
@@ -522,6 +525,7 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelBilinear(x, y, channel) {
+        assert.isNonNegativeInteger(channel, 'channel');
 
         const itemSize = this.itemSize;
 
@@ -1098,12 +1102,16 @@ export class Sampler2D {
      * @param {Number} height
      */
     zeroFill(x, y, width, height) {
+        assert.isNonNegativeInteger(width, 'width');
+        assert.isNonNegativeInteger(height, 'height');
 
         const x0 = clamp(x, 0, this.width);
         const y0 = clamp(y, 0, this.height);
         const x1 = clamp(x + width, 0, this.width);
         const y1 = clamp(y + height, 0, this.height);
 
+        // console.log(`#zerofill x:${x}, y:${y}, width:${width}, height:${height} \t -> \t x0:${x0}, y0:${y0}, x1:${x1}, y1:${y1}`); // DEBUG
+
         const data = this.data;
         const itemSize = this.itemSize;
 
@@ -1431,6 +1439,40 @@ export class Sampler2D {
         }
     }
 
+    /**
+     *
+     * @param {Sampler2D} other
+     * @return {boolean}
+     */
+    equals(other) {
+        if (
+            this.width !== other.width
+            || this.height !== other.height
+            || this.itemSize !== other.itemSize
+        ) {
+            return false;
+        }
+
+        return is_typed_array_equals(this.data, other.data);
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        let hash = (((this.width & 0xFFFF) << 16) | (this.height & 0xFFFF)) ^ this.itemSize;
+
+        const length = this.data.length;
+
+        const stride = Math.max(1, Math.ceil(length / 509));
+
+        hash ^= computeStridedIntegerArrayHash(this.data, 0, length, stride);
+
+        return hash;
+    }
+
+
     /**
      * @returns {Sampler2D}
      */
@@ -1450,19 +1492,38 @@ export class Sampler2D {
     }
 
     toJSON() {
+        const encoded = Base64.encode(this.data.buffer);
+
         return {
             height: this.height,
             width: this.width,
             itemSize: this.itemSize,
             type: typedArrayToDataType(this.data),
-            data: Array.from(this.data)
+            data: encoded
         }
     }
 
     fromJSON({ height, width, itemSize, type, data }) {
         const CTOR = compute_typed_array_constructor_from_data_type(type);
 
-        this.data = new CTOR(data);
+        if (typeof data === "string") {
+
+            const decoded = Base64.decode(data);
+
+            this.data = new CTOR(decoded);
+
+        } else if (Array.isArray(data)) {
+            // deprecated
+            console.warn('Array JSON format is deprecated, please upgrade your data as soon as possible');
+
+            this.data = new CTOR(data);
+
+        } else {
+
+            throw new Error('Unsupported data format');
+
+        }
+
         this.height = height;
         this.width = width;
         this.itemSize = itemSize;

package/engine/sound/ecs/SoundListenerSystem.js

@@ -9,6 +9,7 @@ import { Transform } from '../../ecs/transform/Transform.js';
 import { browserInfo } from "../../Platform.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { noop } from "../../../core/function/Functions.js";
+import { assert } from "../../../core/assert.js";
 
 const v3 = new Vector3();
 const v3_up = new Vector3();
@@ -86,6 +87,10 @@ class SoundListenerSystem extends System {
      */
     constructor(context) {
         super();
+
+        assert.defined(context, 'context');
+        assert.isInstanceOf(context, AudioContext, 'context', 'AudioContext');
+
         this.dependencies = [SoundListener, Transform];
         //
         this.webAudioContext = context;