@woosh/meep-engine 2.44.7 → 2.45.1

package/engine/graphics/render/forward_plus/prototype/prototypeLightManager.js

@@ -62,7 +62,7 @@ import { TooltipManager } from "../../../../../view/tooltip/TooltipManager.js";
 import { GMLEngine } from "../../../../../view/tooltip/gml/GMLEngine.js";
 import { PointerDevice } from "../../../../input/devices/PointerDevice.js";
 import { StaticKnowledgeDatabase } from "../../../../knowledge/database/StaticKnowledgeDatabase.js";
-import { Localization } from "../../../../../core/Localization.js";
+import { Localization } from "../../../../../core/localization/Localization.js";
 import '../../../../../../../../css/game.scss'
 import { randomFromArray } from "../../../../../core/math/random/randomFromArray.js";
 import { debugAtlas } from "../../../particles/particular/engine/shader/debugAtlas.js";
@@ -1558,8 +1558,8 @@ function draw_camera_view_planes() {
     });
 }
 
-prepare_scene_2();
-// prepare_scene_decal_0();
+// prepare_scene_2();
+prepare_scene_decal_0();
 // prepare_scene_decal_1();
 // prepare_scene_decal_2();
 // prepare_scene_9();

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

@@ -125,9 +125,9 @@ export function query_bvh_frustum_from_texture(
             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_texel_index * 4;
+            // mask out type bits
+            const light_address = light_descriptor & 0xFFFFFFF8;
 
             if (light_type === 0) {
                 // Point light

package/engine/graphics/render/forward_plus/sort_decal_data.js

@@ -0,0 +1,102 @@
+const _scratch_array = [];
+
+/**
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number[]} lookup
+ * @param {number[]} data
+ * @returns {number}
+ */
+function compare_decals(a, b, lookup, data) {
+    if (a === b) {
+        return 0;
+    }
+
+    const a_encoded = lookup[a];
+    const b_encoded = lookup[b];
+
+    // mask out bottom 2 type bits
+    const a_address = a_encoded & 0xFFFFFFF8;
+    const b_address = b_encoded & 0xFFFFFFF8;
+
+    const a_priority = data[a_address + 20];
+    const b_priority = data[b_address + 20];
+
+    let diff = b_priority - a_priority;
+
+    if (diff !== 0) {
+        return diff;
+    }
+
+
+    const a_id = data[a_address + 21];
+    const b_id = data[b_address + 21];
+
+    // data order is explicit and stable, we use that as a secondary comparison criteria
+    return b_id - a_id;
+}
+
+/**
+ * Decals need to be drawn in a specific order to achieve correct blending, for this they need to be sorted
+ * @param {number[]|Uint8ClampedArray|Uint8Array|Uint32Array} lookup
+ * @param {number[]|Float32Array} data
+ * @param {number} offset
+ * @param {number} count
+ */
+export function sort_decal_data(lookup, data, offset, count) {
+    const stack = _scratch_array;
+
+    stack[0] = offset;
+    stack[1] = offset + count - 1;
+
+    let stackPointer = 2;
+    let i, j;
+
+    while (stackPointer > 0) {
+        stackPointer -= 2;
+
+        const right = stack[stackPointer + 1];
+        const left = stack[stackPointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        /* partition */
+        while (i <= j) {
+
+            while (compare_decals(i, pivotIndex, lookup, data) > 0) {
+                i++;
+            }
+
+            while (compare_decals(j, pivotIndex, lookup, data) < 0) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    const swap = lookup[i];
+                    lookup[i] = lookup[j]
+                    lookup[j] = swap;
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack[stackPointer++] = left;
+            stack[stackPointer++] = j;
+        }
+        if (i < right) {
+            stack[stackPointer++] = i;
+            stack[stackPointer++] = right;
+        }
+    }
+}

package/engine/graphics/sh3/path_tracer/prototypePathTracer.js

@@ -27,7 +27,7 @@ import Task from "../../../../core/process/task/Task.js";
 import { TaskSignal } from "../../../../core/process/task/TaskSignal.js";
 import Quaternion from "../../../../core/geom/Quaternion.js";
 import TaskProgressView from "../../../../view/task/TaskProgressView.js";
-import { Localization } from "../../../../core/Localization.js";
+import { Localization } from "../../../../core/localization/Localization.js";
 
 import '../../../../../../../css/game.scss';
 import { MouseEvents } from "../../../input/devices/events/MouseEvents.js";

package/engine/input/devices/InputDeviceButton.d.ts

@@ -0,0 +1,7 @@
+import Signal from "../../../core/events/signal/Signal";
+
+export class InputDeviceButton{
+    readonly up: Signal
+    readonly down: Signal
+    readonly is_down: boolean
+}

package/engine/input/devices/InputDeviceButton.js

@@ -0,0 +1,22 @@
+import Signal from "../../../core/events/signal/Signal.js";
+
+/**
+ * Representation of an input device key
+ */
+export class InputDeviceButton {
+    /**
+     * Button press
+     * @type {Signal}
+     */
+    down = new Signal()
+    /**
+     * Button release
+     * @type {Signal}
+     */
+    up = new Signal()
+    /**
+     * is button currently being pressed?
+     * @type {boolean}
+     */
+    is_down = false
+}

package/engine/input/devices/KeyboardDevice.d.ts

@@ -1,3 +1,14 @@
+import {InputDeviceButton} from "./InputDeviceButton";
+import Signal from "../../../core/events/signal/Signal";
+
 export default class KeyboardDevice {
+    constructor(domElement:EventTarget|Element)
+
+    readonly on: {up:Signal,down:Signal}
+
+    readonly keys:{[key:string]:InputDeviceButton}
+
+    start():void
 
+    stop():void
 }

package/engine/input/devices/KeyboardDevice.js

@@ -5,6 +5,7 @@
 import Signal from "../../../core/events/signal/Signal.js";
 import { KeyCodes } from './KeyCodes.js';
 import { KeyboardEvents } from "./events/KeyboardEvents.js";
+import { InputDeviceButton } from "./InputDeviceButton.js";
 
 /**
  *
@@ -66,21 +67,23 @@ class KeyboardDevice {
             up: new Signal()
         };
 
-        //initialize separate events for each key
+
+        /**
+         *
+         * @type {Object<InputDeviceButton>}
+         */
         const keys = this.keys = {};
 
         const codeToKeyNameMap = [];
 
+        //initialize separate events for each key
         for (let keyName in KeyCodes) {
 
             const keyCode = KeyCodes[keyName];
 
             codeToKeyNameMap[keyCode] = keyName;
 
-            keys[keyName] = {
-                down: new Signal(),
-                up: new Signal()
-            };
+            keys[keyName] = new InputDeviceButton();
         }
 
         this.__handlerKeyDown = (event) => {
@@ -91,7 +94,11 @@ class KeyboardDevice {
             const keyName = codeToKeyNameMap[keyCode];
 
             if (keyName !== undefined) {
-                keys[keyName].down.send1(event);
+                const button = keys[keyName];
+
+                button.is_down = true;
+                button.down.send1(event);
+
             }
         }
 
@@ -104,7 +111,10 @@ class KeyboardDevice {
             const keyName = codeToKeyNameMap[keyCode];
 
             if (keyName !== undefined) {
-                keys[keyName].up.send1(event);
+                const button = keys[keyName];
+
+                button.is_down = false;
+                button.up.send1(event);
             }
         }
     }

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

package/core/Localization.js

@@ -1,199 +0,0 @@
-import levenshtein from "fast-levenshtein";
-import { GameAssetType } from "../engine/asset/GameAssetType.js";
-import { parseTooltipString } from "../view/tooltip/gml/parser/parseTooltipString.js";
-import { assert } from "./assert.js";
-import ObservedString from "./model/ObservedString.js";
-import { seedVariablesIntoTemplateString } from "./parser/seedVariablesIntoTemplateString.js";
-import { STRING_TEMPLATE_VARIABLE_REGEX } from "./parser/STRING_TEMPLATE_VARIABLE_REGEX.js";
-
-/**
- * Validation utility method
- * @param {string} template
- * @return {string}
- */
-function validationMockSeed(template) {
-
-    const result = template.replace(STRING_TEMPLATE_VARIABLE_REGEX, function (match, varName) {
-        return "0";
-    });
-
-    return result;
-}
-
-const FAILURE_MESSAGE_CACHE = {};
-
-export class Localization {
-    constructor() {
-        /**
-         *
-         * @type {AssetManager|null}
-         */
-        this.assetManager = null;
-
-        this.json = {};
-
-        /**
-         * Measured in characters per second
-         * @type {number}
-         */
-        this.reading_speed = 10;
-
-        /**
-         *
-         * @type {ObservedString}
-         */
-        this.locale = new ObservedString('');
-    }
-
-    /**
-     *
-     * @param {string} text
-     * @returns {number}
-     */
-    computeReadingTime(text) {
-        assert.typeOf(text, 'string', 'text');
-
-        return text.length / this.reading_speed;
-    }
-
-    /**
-     *
-     * @param {AssetManager} am
-     */
-    setAssetManager(am) {
-        this.assetManager = am;
-    }
-
-    /**
-     * @returns {boolean}
-     * @param {function(key:string, error:*, original: string)} errorConsumer
-     */
-    validate(errorConsumer) {
-        let result = true;
-
-        for (let key in this.json) {
-            const value = this.json[key];
-
-            const seededValue = validationMockSeed(value);
-
-            try {
-                parseTooltipString(seededValue);
-            } catch (e) {
-                result = false;
-                errorConsumer(key, e, value);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {string} locale
-     * @returns {Promise}
-     */
-    loadLocale(locale) {
-        const am = this.assetManager;
-
-        const pLoadData = am.promise(`data/database/text/${locale}.json`, GameAssetType.JSON)
-            .then(asset => {
-                const json = asset.create();
-
-                this.json = json;
-
-                this.locale.set(locale);
-            });
-
-        const pLoadMetadata = am.promise(`data/database/text/languages.json`, GameAssetType.JSON)
-            .then(asset => {
-                const languages_metadata = asset.create();
-
-                const { reading_speed = 10 } = languages_metadata[locale];
-
-                assert.isNumber(reading_speed, 'reading_speed');
-                assert.greaterThan(reading_speed, 0, 'reading_speed');
-
-                this.reading_speed = reading_speed;
-            });
-
-        return Promise.all([pLoadData, pLoadMetadata]);
-    }
-
-    /**
-     *
-     * @param {String} id
-     * @return {boolean}
-     */
-    hasString(id) {
-        return this.json[id] !== undefined;
-    }
-
-    /**
-     *
-     * @param {number} value
-     */
-    formatIntegerByThousands(value) {
-        const formatter = new Intl.NumberFormat(this.locale.getValue(), { useGrouping: true });
-
-        return formatter.format(value);
-    }
-
-    /**
-     *
-     * @param {string} id
-     * @param {object} [seed]
-     *
-     * @returns {string}
-     */
-    getString(id, seed = {}) {
-        assert.typeOf(id, 'string', 'id');
-
-        const value = this.json[id];
-
-        if (value === undefined) {
-
-            if (!ENV_PRODUCTION) {
-                const locale = this.locale.getValue();
-
-                if (FAILURE_MESSAGE_CACHE[locale] === undefined) {
-                    FAILURE_MESSAGE_CACHE[locale] = {};
-                }
-
-                if (FAILURE_MESSAGE_CACHE[locale][id] === undefined) {
-
-                    //try to find similar keys
-                    const similarities = Object.keys(this.json).map(function (key) {
-                        const distance = levenshtein.get(key, id);
-                        return {
-                            key,
-                            distance
-                        };
-                    });
-
-                    similarities.sort(function (a, b) {
-                        return a.distance - b.distance;
-                    });
-
-                    const suggestions = similarities.slice(0, 3).map(p => p.key);
-
-                    const message = `No localization value for id='${id}', seed=${JSON.stringify(seed)}, approximate matches: ${suggestions.join(', ')}`;
-
-                    FAILURE_MESSAGE_CACHE[locale][id] = message;
-
-                }
-
-                console.warn(FAILURE_MESSAGE_CACHE[locale][id]);
-
-            }
-
-            //no value
-            return `@${id}`;
-
-        }
-
-        //value needs to be seeded
-        const seededValue = seedVariablesIntoTemplateString(value, seed);
-
-        return seededValue;
-    }
-}