@woosh/meep-engine 2.33.36 → 2.33.40

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/render/visibility/VisibilityComputer.js

@@ -9,6 +9,12 @@ const frustum = new Frustum();
  */
 const objectFilters = [];
 
+/**
+ *
+ * @type {function[]}
+ */
+const objectFilterExecutors = [];
+
 export const SOURCE_RENDER_LAYER_PROPERTY = '@meep-render-layer';
 
 export class VisibilityComputer {
@@ -135,12 +141,6 @@ export class VisibilityComputer {
         // clear visible set
         // this.__output.initializeUpdate();
 
-        /**
-         *
-         * @type {function[]}
-         */
-        const objectFilterExecutors = [];
-
         const filters = this.filters;
         const filterCount = filters.length;
 
@@ -151,7 +151,7 @@ export class VisibilityComputer {
 
             if (f.enabled && f.layerPredicate(layer)) {
                 objectFilters[objectFilterCount] = f;
-                objectFilterExecutors.push(f.objectPredicateExecute);
+                objectFilterExecutors[objectFilterCount] = f.objectPredicateExecute;
 
                 objectFilterCount++;
             }
@@ -165,6 +165,7 @@ export class VisibilityComputer {
             f.objectPredicateInitialize(this.__view.camera);
         }
 
+        objectFilterExecutors.length = objectFilterCount;
 
         layer.buildVisibleSet(this.__frustums, objectFilterExecutors, this.__includeObject, this);
 

package/engine/graphics/shaders/TerrainShader.js

@@ -366,27 +366,27 @@ function fragment() {
         gl_FragColor  = vec4( outgoingLight, diffuseColor.a );
       
         #if defined( TONE_MAPPING )
-            gl_FragColor.rgb = toneMapping( pc_fragColor.rgb );
+            gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );
         #endif
         
         //encode fragment
-        pc_fragColor = linearToOutputTexel( pc_fragColor );
+        gl_FragColor = linearToOutputTexel( gl_FragColor );
         #ifdef USE_FOG
             #ifdef FOG_EXP2
                 float fogFactor = 1.0 - exp( - fogDensity * fogDensity * fogDepth * fogDepth );
             #else
                 float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
             #endif
-            gl_FragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
+            gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );
         #endif
         
         #ifdef PREMULTIPLIED_ALPHA
             // Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
-            gl_FragColor.rgb *= pc_fragColor.a;
+            gl_FragColor.rgb *= gl_FragColor.a;
         #endif
         
         #ifdef DITHERING
-            pc_fragColor.rgb = dithering( pc_fragColor.rgb );
+            gl_FragColor.rgb = dithering( gl_FragColor.rgb );
         #endif
     }
     `;

package/engine/graphics/shadows/testShadowMapRendering.js

@@ -0,0 +1,192 @@
+import { EngineHarness } from "../../EngineHarness.js";
+import { loadSerializedScene } from "../../scene/SerializedScene.js";
+import { EngineConfiguration } from "../../EngineConfiguration.js";
+import { MeshSystem } from "../ecs/mesh/MeshSystem.js";
+import GUIElementSystem from "../../ecs/gui/GUIElementSystem.js";
+import HeadsUpDisplaySystem from "../../ecs/gui/hud/HeadsUpDisplaySystem.js";
+import TagSystem from "../../ecs/systems/TagSystem.js";
+import { AttachmentSocketsSystem } from "../../ecs/sockets/AttachmentSocketsSystem.js";
+import { AttachmentSystem } from "../../ecs/attachment/AttachmentSystem.js";
+import { SoundEmitterSystem } from "../../sound/ecs/emitter/SoundEmitterSystem.js";
+import SoundControllerSystem from "../../sound/ecs/SoundControllerSystem.js";
+import SoundListenerSystem from "../../sound/ecs/SoundListenerSystem.js";
+import AnimationSystem from "../../ecs/systems/AnimationSystem.js";
+import TopDownCameraControllerSystem from "../ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { CameraSystem } from "../ecs/camera/CameraSystem.js";
+import ClingToTerrainSystem from "../../ecs/terrain/ecs/ClingToTerrainSystem.js";
+import TerrainSystem from "../../ecs/terrain/ecs/TerrainSystem.js";
+import Trail2DSystem from "../ecs/trail2d/Trail2DSystem.js";
+import { Foliage2System } from "../../ecs/foliage/ecs/Foliage2System.js";
+import ViewportPositionSystem from "../../ecs/gui/position/ViewportPositionSystem.js";
+import SynchronizePositionSystem from "../../ecs/systems/SynchronizePositionSystem.js";
+import InputControllerSystem from "../../input/ecs/systems/InputControllerSystem.js";
+import { InputSystem } from "../../input/ecs/systems/InputSystem.js";
+import MeshHighlightSystem from "../ecs/highlight/system/MeshHighlightSystem.js";
+import LightSystem from "../ecs/light/LightSystem.js";
+import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { SerializationMetadataSystem } from "../../ecs/systems/SerializationMetadataSystem.js";
+import { PathDisplaySystem } from "../ecs/path/PathDisplaySystem.js";
+import { ParticleEmitterSystem } from "../particles/ecs/ParticleEmitterSystem.js";
+import { ShadedGeometrySystem } from "../ecs/mesh-v2/ShadedGeometrySystem.js";
+import { ArrayBufferLoader } from "../../asset/loaders/ArrayBufferLoader.js";
+import { initializeGameBinarySerializationRegistry } from "../../../../model/game/GameBinarySerializationRegistry.js";
+import WaterSystem from "../ecs/water/WaterSystem.js";
+import Army from "../../../../model/game/ecs/component/army/Army.js";
+import Mesh from "../ecs/mesh/Mesh.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import { buildCanvasViewFromTexture } from "../render/visibility/hiz/buildCanvasViewFromTexture.js";
+import ViewportPosition from "../../ecs/gui/position/ViewportPosition.js";
+import Vector2 from "../../../core/geom/Vector2.js";
+import GUIElement from "../../ecs/gui/GUIElement.js";
+import { enableEditor } from "../../../editor/enableEditor.js";
+import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {EngineConfiguration}
+ */
+function makeConfig(engine) {
+
+    const config = new EngineConfiguration();
+
+    /**
+     *
+     * @type {SoundEngine}
+     */
+    const sound = engine.sound;
+    const graphics = engine.graphics;
+    const assetManager = engine.assetManager;
+    const devices = engine.devices;
+
+    // graphics.renderer.shadowMap.type = BasicShadowMap;
+
+    const guiSystem = new GUIElementSystem(engine.gui.view, engine);
+    const headsUpDisplaySystem = new HeadsUpDisplaySystem(graphics);
+
+    config.addLoader('arraybuffer', new ArrayBufferLoader());
+
+    initializeGameBinarySerializationRegistry(engine.binarySerializationRegistry);
+
+    config.addManySystems(
+        new TagSystem(),
+        new AttachmentSocketsSystem(),
+        new AttachmentSystem(),
+        new SoundEmitterSystem(assetManager, sound.destination, sound.context),
+        new SoundControllerSystem(),
+        new SoundListenerSystem(sound.context),
+        guiSystem,
+        new AnimationSystem(graphics.viewport.size),
+        new TopDownCameraControllerSystem(graphics),
+        new CameraSystem(graphics.scene, graphics),
+        new MeshSystem(engine),
+        new ClingToTerrainSystem(),
+        new TerrainSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
+        new Foliage2System(assetManager, graphics),
+        new ViewportPositionSystem(graphics.viewport.size),
+        new SynchronizePositionSystem(),
+        new InputControllerSystem(devices),
+        new InputSystem(devices),
+        new MeshHighlightSystem(engine),
+        new LightSystem(engine, {
+            shadowResolution: 2048
+        }),
+        headsUpDisplaySystem,
+        new BehaviorSystem(engine),
+        new SerializationMetadataSystem(),
+        new PathDisplaySystem(engine),
+        new ParticleEmitterSystem(engine),
+        new ShadedGeometrySystem(engine),
+        new WaterSystem(graphics)
+    );
+
+
+    // Knowledge
+
+    return config;
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function get_three_light(engine) {
+
+    return engine.graphics.scene.children.find(l => l.isDirectionalLight);
+}
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function init_shadowmap_preview(engine) {
+    const ecd = engine.entityManager.dataset;
+
+    const graphics = engine.graphics;
+    const preview = buildCanvasViewFromTexture({
+        width: 512,
+        height: 512,
+        renderer: graphics.renderer,
+        texture: null
+    });
+
+    graphics.on.postOpaquePass.add(() => {
+
+        const light = get_three_light(engine);
+
+        if (light !== undefined) {
+            preview.texture = light.shadow.map.texture;
+
+            preview.render();
+        }
+    });
+
+
+    new EntityBuilder()
+        .add(ViewportPosition.fromJSON({
+            offset: new Vector2(10, 10)
+        }))
+        .add(GUIElement.fromView(preview.view))
+        .add(SerializationMetadata.Transient)
+        .build(ecd);
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @returns {Promise<void>}
+ */
+async function main(engine) {
+
+    const ecd = engine.entityManager.dataset;
+    await loadSerializedScene('data/levels/character_creation/level.bin', ecd, engine);
+
+
+    const character = ecd.getAnyComponent(Army);
+
+    const entity = EntityBuilder.readFromDataset(character.entity, ecd);
+
+    entity.getComponent(Mesh).url = "data/models/Conqueror Mech/Conqueror Mech.gltf";
+
+    init_shadowmap_preview(engine);
+
+    window.light = get_three_light(engine);
+}
+
+async function init(engineHarness) {
+
+    const engine = await engineHarness.initialize();
+
+    const config = makeConfig(engine);
+
+    await config.apply(engine);
+
+    enableEditor(engine);
+
+    main(engine);
+}
+
+init(eh);

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,8 +5,9 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.36",
+  "version": "2.33.40",
   "dependencies": {
+    "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",
     "simplex-noise": "2.4.0",