@woosh/meep-engine 2.33.37 → 2.33.41

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

@@ -28,6 +28,7 @@ export function query_bvh_frustum_from_texture(
 
     let stackPointer = 1;
     let result = 0;
+    let plane_address;
 
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
@@ -55,9 +56,7 @@ export function query_bvh_frustum_from_texture(
             const n_y1 = data_view.getFloat32(node_address + 16);
             const n_z1 = data_view.getFloat32(node_address + 20);
 
-            for (let j = 0; j < 6; j++) {
-
-                const plane_address = j * 4;
+            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];
@@ -84,41 +83,51 @@ export function query_bvh_frustum_from_texture(
             const left_index = (node_index << 1) + 1;
             const right_index = left_index + 1;
 
-            if (left_index < last_valid_index) {
-                stack[stackPointer] = left_index;
-                stackPointer++;
-            }
-
+            // left node ends up on top of the stack, which aligns with the desired access sequence
             if (right_index < last_valid_index) {
-                stack[stackPointer] = right_index;
-                stackPointer++;
+                stack[stackPointer++] = right_index;
+                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
+                stack[stackPointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack[stackPointer++] = left_index;
             }
 
 
         } else {
             // leaf node
             const leaf_index = node_index - binary_node_count;
+
             const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
 
-            const light_index = data_view.getUint32(node_address + 24);
+            const light_descriptor = data_view.getUint32(node_address + 24);
+
+            const light_type = light_descriptor & 3;
+            const light_texel_index = light_descriptor >> 2;
 
-            const light_address = light_index * 8;
+            const light_address = light_texel_index * 4;
 
-            // TODO figure out light type from address
+            if (light_type === 0) {
+                // Point light
 
+                const light_x = source_data[light_address];
+                const light_y = source_data[light_address + 1];
+                const light_z = source_data[light_address + 2];
 
-            const light_x = source_data[light_address];
-            const light_y = source_data[light_address + 1];
-            const light_z = source_data[light_address + 2];
+                const radius = source_data[light_address + 3];
 
-            const radius = source_data[light_address + 3];
+                if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                    continue;
+                }
+            } else if (light_type === 3) {
+                // decal
+                debugger;
 
-            if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
-                continue;
+            } else {
+                throw new Error('Unsupported light type');
             }
 
             // write to output
-            destination[destination_offset + result] = light_index;
+            destination[destination_offset + result] = light_descriptor;
 
             result++;
         }

package/engine/graphics/render/visibility/IncrementalDeltaSet.d.ts

@@ -14,4 +14,6 @@ export class IncrementalDeltaSet<T> {
     initializeUpdate(): void
 
     finalizeUpdate(): void
+
+    sort(f: (T) => number, ctx?: any): void
 }

package/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -74,6 +74,7 @@ export class IncrementalDeltaSet {
      *
      * @param {function(T):number} score_function
      * @param {*} [score_context]
+     * @returns {void}
      */
     sort(score_function, score_context) {
         arrayQuickSort(this.elements, score_function, score_context, 0, this.size - 1);

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

@@ -0,0 +1,19 @@
+export class AbstractTextureAtlas {
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {AtlasPatch}
+     */
+    add(sampler) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {AtlasPatch} patch
+     * @returns {boolean}
+     */
+    remove(patch) {
+        throw new Error('Not Implemented')
+    }
+}

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

@@ -0,0 +1,99 @@
+import { Cache } from "../../../../core/cache/Cache.js";
+import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
+
+/**
+ * 4Mb
+ * @type {number}
+ */
+const DEFAULT_CACHE_SIZE = 4194304;
+
+export class CachingTextureAtlas extends AbstractTextureAtlas {
+    /**
+     *
+     * @param {AbstractTextureAtlas} atlas
+     * @param {number} cache_size
+     */
+    constructor({
+                    atlas,
+                    cache_size = DEFAULT_CACHE_SIZE
+                }) {
+        super();
+
+        /**
+         *
+         * @type {Cache<Sampler2D, AtlasPatch>}
+         * @private
+         */
+        this.__cached_patches = new Cache({
+            maxWeight: cache_size,
+            keyWeigher(sampler) {
+                return sampler.computeByteSize();
+            }
+        });
+
+        /**
+         *
+         * @type {TextureAtlas}
+         * @private
+         */
+        this.__atals = atlas;
+
+        this.__cached_patches.onEvicted.add(this.__handle_cache_eviction, this);
+    }
+
+    /**
+     *
+     * @returns {AbstractTextureAtlas}
+     */
+    get atlas() {
+        return this.__atals;
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @param {AtlasPatch} patch
+     * @private
+     */
+    __handle_cache_eviction(sampler, patch) {
+        this.__atals.remove(patch);
+    }
+
+    reset() {
+        this.__cached_patches.drop();
+        this.__atals.reset();
+    }
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {AtlasPatch}
+     */
+    add(sampler) {
+        const existing_patch = this.__cached_patches.get(sampler);
+
+        if (existing_patch !== null) {
+            // cache hit
+            return existing_patch;
+        }
+
+        return this.__atals.add(sampler);
+    }
+
+    /**
+     *
+     * @param {AtlasPatch} patch
+     */
+    remove(patch) {
+
+        // validate presence of patch in the atlas
+        if (!this.__atals.contains(patch)) {
+            return false;
+        }
+
+        // push to cache, let eviction logic handle the rest
+        this.__cached_patches.put(patch.sampler, patch);
+
+        return true;
+    }
+}

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

@@ -1,14 +1,12 @@
 import { TextureAtlas } from "./TextureAtlas.js";
 import { ReferenceManager } from "../../../reference/v1/ReferenceManager.js";
 import { Sampler2D } from "../sampler/Sampler2D.js";
-import { Cache } from "../../../../core/cache/Cache.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { HashMap } from "../../../../core/collection/HashMap.js";
 import { strictEquals } from "../../../../core/function/Functions.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { copy_Sampler2D_channel_data } from "../sampler/copy_Sampler2D_channel_data.js";
-
-const CACHE_SIZE = 4194304;
+import { CachingTextureAtlas } from "./CachingTextureAtlas.js";
 
 export class ManagedAtlas {
     /**
@@ -26,28 +24,20 @@ export class ManagedAtlas {
 
         /**
          *
-         * @type {TextureAtlas}
+         * @type {WeakMap<string, Sampler2D>}
+         * @private
          */
-        this.atlas = atlas;
+        this.__cached_samplers = new Map();
+        const cached_samplers = this.__cached_samplers;
 
+        const cached_atlas = new CachingTextureAtlas({ atlas });
+        this.__caching_atlas = cached_atlas;
 
         /**
          *
-         * @type {Cache<String, AtlasPatch>}
+         * @type {TextureAtlas}
          */
-        const patchesInactive = new Cache({
-            maxWeight: CACHE_SIZE,
-            keyHashFunction: computeStringHash,
-            keyEqualityFunction: strictEquals,
-            valueWeigher(patch) {
-                return patch.sampler.data.length;
-            }
-        });
-
-        // watch for patches being removed
-        patchesInactive.onRemoved.add((key, value) => {
-            atlas.remove(value);
-        });
+        this.atlas = atlas;
 
         /**
          *
@@ -64,19 +54,12 @@ export class ManagedAtlas {
          */
         this.patchesActive = activePatches;
 
-        /**
-         * @private
-         * @type {Cache<String, AtlasPatch>}
-         */
-        this.patchesInactive = patchesInactive;
-
         /**
          * Automatically update TextureAtlas
          * @type {boolean}
          */
         this.autoUpdate = true;
 
-
         this.rebuildDelay = 200; //in milliseconds
 
         let counterLoadingAssets = 0;
@@ -97,7 +80,7 @@ export class ManagedAtlas {
 
         /**
          *
-         * @param {String} url
+         * @param {string} url
          * @returns {Promise<AtlasPatch>}
          */
         function creator(url) {
@@ -110,14 +93,10 @@ export class ManagedAtlas {
                     return;
                 }
 
-                patch = patchesInactive.get(url);
-
-                if (patch !== null) {
-                    //move to active
-                    patchesInactive.silentRemove(url);
-
-                    activePatches.set(url, patch);
+                const cached_sampler = cached_samplers.get(url);
 
+                if (cached_sampler !== undefined) {
+                    patch = cached_atlas.add(cached_sampler);
                     resolve(patch);
                     return;
                 }
@@ -154,7 +133,10 @@ export class ManagedAtlas {
                         sampler = source;
                     }
 
-                    const patch = atlas.add(sampler);
+                    cached_samplers.set(url, sampler);
+
+
+                    const patch = cached_atlas.add(sampler);
 
                     //record active patch
                     activePatches.set(url, patch);
@@ -197,8 +179,7 @@ export class ManagedAtlas {
                     //remove from active
                     activePatches.delete(url);
 
-                    //put into inactive set
-                    patchesInactive.put(url, patch);
+                    self.__caching_atlas.remove(patch);
                 }
             });
         }
@@ -218,8 +199,7 @@ export class ManagedAtlas {
 
     reset() {
         this.references.reset();
-        this.atlas.reset();
-        this.patchesInactive.drop();
+        this.__caching_atlas.reset();
         this.patchesActive.clear();
     }
 

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

@@ -0,0 +1,75 @@
+import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
+import { Reference } from "../../../reference/v2/Reference.js";
+
+export class ReferencedTextureAtlas extends AbstractTextureAtlas {
+    /**
+     *
+     * @param {AbstractTextureAtlas} atlas
+     */
+    constructor(atlas) {
+        super();
+
+        this.__atlas = atlas;
+
+        /**
+         *
+         * @type {Map<Sampler2D, AtlasPatch>}
+         * @private
+         */
+        this.__patches = new Map();
+        /**
+         *
+         * @type {Map<AtlasPatch, number>}
+         * @private
+         */
+        this.__ref_counts = new Map();
+
+    }
+
+    /**
+     *
+     * @param {Reference} ref
+     * @param {AtlasPatch} patch
+     * @private
+     */
+    __handle_ref_release(ref, patch) {
+        const ref_counts = this.__ref_counts;
+
+        const ref_count = ref_counts.get(patch);
+        ref_counts.set(patch, ref_count - 1);
+
+        if (ref_count === 1) {
+            // clear patch
+            this.__atlas.remove(patch);
+        }
+    }
+
+
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {Reference<AtlasPatch>}
+     */
+    acquire(sampler) {
+
+        let patch = this.__patches.get(sampler);
+
+        const ref_counts = this.__ref_counts;
+
+        const atlas = this.__atlas;
+
+        if (patch === undefined) {
+            patch = atlas.add(sampler);
+            ref_counts.set(patch, 1)
+        } else {
+            ref_counts.set(patch, ref_counts.get(patch) + 1);
+        }
+
+        const ref = new Reference();
+        ref.bind(patch);
+
+        ref.onReleased.add(this.__handle_ref_release, this);
+
+        return ref;
+    }
+}

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

@@ -11,8 +11,9 @@ import { assert } from "../../../../core/assert.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
 import { DataType2TypedArrayConstructorMapping } from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 import { invokeObjectClone } from "../../../../core/model/ObjectUtils.js";
+import { AbstractTextureAtlas } from "./AbstractTextureAtlas.js";
 
-export class TextureAtlas {
+export class TextureAtlas extends AbstractTextureAtlas {
     /**
      *
      * @param {number} [size]
@@ -20,6 +21,8 @@ export class TextureAtlas {
      * @constructor
      */
     constructor(size = 16, data_type = DataType.Uint8) {
+        super();
+
         /**
          *
          * @type {IdPool}
@@ -68,6 +71,23 @@ export class TextureAtlas {
         this.__needsUpdate = false;
     }
 
+    /**
+     *
+     * @param {Sampler2D} sampler
+     * @returns {AtlasPatch|undefined}
+     */
+    getPatch(sampler) {
+        const patches = this.patches;
+        const patch_count = patches.length;
+        for (let i = 0; i < patch_count; i++) {
+            const patch = patches[i];
+
+            if (patch.sampler === sampler) {
+                return patch;
+            }
+        }
+    }
+
     /**
      * Whether or not current state of atlas requires calling {#update}
      * @returns {boolean}
@@ -222,7 +242,7 @@ export class TextureAtlas {
     /**
      *
      * @param {Sampler2D} sampler
-     * @param {number} padding
+     * @param {number} [padding]
      * @return {AtlasPatch}
      */
     add(sampler, padding = 4) {

package/engine/reference/v2/Reference.d.ts

@@ -1,4 +1,8 @@
+import Signal from "../../../core/events/signal/Signal";
+
 export class Reference<T> {
+    readonly onReleased: Signal<Reference<T>, T>
+
     getValue(): T | null
 
     release(): void

package/engine/reference/v2/Reference.js

@@ -73,12 +73,14 @@ export class Reference {
             return;
         }
 
+        const v = this.__value;
+
         // prevent further usage of the reference
         this.__value = null;
 
         this.__is_bound = false;
 
-        this.__onReleased.send1(this);
+        this.__onReleased.send2(this,v);
     }
 }
 

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