@woosh/meep-engine 2.40.0 → 2.41.0

package/core/binary/BinaryBuffer.js

@@ -959,14 +959,19 @@ export class BinaryBuffer {
     /**
      *
      * @param {number} length
+     * @param {boolean} [null_terminated]
      * @returns {string}
      */
-    readASCIICharacters(length) {
+    readASCIICharacters(length, null_terminated = false) {
         let result = "";
 
         for (let i = 0; i < length; i++) {
             const code = this.readUint8();
 
+            if (null_terminated && code === 0) {
+                break;
+            }
+
             result += String.fromCharCode(code);
         }
 

package/core/collection/HashMap.d.ts

@@ -19,6 +19,8 @@ export class HashMap<K, V> implements Iterable<[V, K]> {
 
     get(key: K): V | undefined
 
+    getOrCompute(key: K, compute: (k: K) => V, thisArg?: any): V
+
     has(key: K): boolean
 
     delete(key: K): boolean

package/core/collection/HashMap.js

@@ -273,6 +273,28 @@ export class HashMap {
         return undefined;
     }
 
+    /**
+     *
+     * @param {Key} key
+     * @param {function(Key):V} compute
+     * @param {*} [compute_context]
+     * @return {V}
+     */
+    getOrCompute(key, compute, compute_context) {
+        const existing = this.get(key);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        const value = compute.call(compute_context, key);
+
+        this.set(key, value);
+
+        return value;
+    }
+
+
     /**
      *
      * @param {K} key

package/core/geom/3d/normal/hemioct/encode_unit3_hemioct.js

@@ -2,6 +2,8 @@
  * Assume normalized input on +Z hemisphere.
  * Output is on [-1, 1].
  *
+ * Uses hemi-octahedron for sphere approximation
+ *
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014)
  * @param {number[]} output
  * @param {number} output_offset
@@ -27,6 +29,9 @@ export function encode_unit_to_hemioct(output, output_offset, x, y, z) {
 
 /**
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014)
+ *
+ * Uses hemi-octahedron for sphere approximation
+ *
  * @param {number[]} output
  * @param {number} output_offset
  * @param {number} x range [-1,1]

package/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js

@@ -0,0 +1,31 @@
+import { sign_not_zero } from "../../../../math/sign_not_zero.js";
+
+/**
+ * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
+ * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x range [0,1]
+ * @param {number} y range [0,1]
+ */
+export function decode_octahedron_to_unit(output, output_offset, x, y) {
+    let v_x = x;
+    let v_y = y;
+
+    const abs_x = Math.abs(v_x);
+    const abs_y = Math.abs(v_y);
+
+    let v_z = 1 - abs_x - abs_y;
+
+    if (v_z < 0) {
+        v_x = (1 - abs_y) * sign_not_zero(v_x);
+        v_y = (1 - abs_x) * sign_not_zero(v_y);
+    }
+
+    // normalize
+    const m = 1 / Math.hypot(v_x, v_y, v_z);
+
+    output[output_offset] = v_x * m;
+    output[output_offset + 1] = v_y * m;
+    output[output_offset + 2] = v_z * m;
+}

package/core/geom/3d/normal/octahedron/encode_unit_to_octahedron.js

@@ -0,0 +1,33 @@
+import { sign_not_zero } from "../../../../math/sign_not_zero.js";
+
+/**
+ * Input vector is assumed to be normalized
+ *
+ * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
+ * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} x range [-1,1]
+ * @param {number} y range [-1,1]
+ * @param {number} z range [-1,1]
+ */
+export function encode_unit_to_octahedron(output, output_offset, x, y, z) {
+    // Project the sphere onto the octahedron, and then onto the xy plane
+    const l2 = 1 / (Math.abs(x) + Math.abs(y) + Math.abs(z));
+
+    let p_x = x * l2;
+    let p_y = y * l2;
+
+    // Reflect the folds of the lower hemisphere over the diagonals
+    if (z <= 0) {
+        const abs_x = Math.abs(p_x);
+        const abs_y = Math.abs(p_y);
+
+        p_x = sign_not_zero(p_x) * (1 - abs_y);
+        p_y = sign_not_zero(p_y) * (1 - abs_x);
+    }
+
+    output[output_offset] = p_x;
+    output[output_offset + 1] = p_y;
+}

package/core/geom/3d/normal/octahedron/encoding.spec.js

@@ -0,0 +1,29 @@
+import { encode_unit_to_octahedron } from "./encode_unit_to_octahedron.js";
+import { decode_octahedron_to_unit } from "./decode_octahedron_to_unit.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ */
+function try_one(x, y) {
+    const output_v2 = [];
+    const output_v3 = [];
+
+    decode_octahedron_to_unit(output_v3, 0, x, y);
+    encode_unit_to_octahedron(output_v2, 0, output_v3[0], output_v3[1], output_v3[2]);
+
+    expect(output_v2[0]).toBeCloseTo(x);
+    expect(output_v2[1]).toBeCloseTo(y);
+}
+
+test("encoding/decoding consistency", () => {
+    // corners
+    try_one(0, 0);
+    try_one(0, 1);
+    try_one(1, 0);
+    try_one(1, 1);
+
+    // center
+    try_one(0.5, 0.5);
+});

package/core/geom/3d/topology/struct/BinaryTopology.js

@@ -0,0 +1,112 @@
+import { max2 } from "../../../../math/max2.js";
+
+const INITIAL_CAPACITY = 128;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const CAPACITY_GROW_MULTIPLIER = 1.2;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const CAPACITY_GROW_MIN_STEP = 32;
+
+class BinaryPool {
+
+    constructor(item_size, initial_capacity = INITIAL_CAPACITY) {
+        /**
+         * Size of a single pool item in bytes
+         * @type {number}
+         * @private
+         */
+        this.__item_size = item_size;
+        /**
+         * Unused slots
+         * @type {number[]}
+         * @private
+         */
+        this.__free = [];
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__free_pointer = 0;
+
+        this.__data_buffer = new ArrayBuffer(initial_capacity * item_size);
+        this.__data_uint8 = new Uint8Array(this.__data_buffer);
+
+        this.__capacity = initial_capacity;
+
+        this.__used_end = 0;
+    }
+
+    __grow_capacity() {
+        const new_capacity = Math.ceil(max2(
+            this.__capacity * CAPACITY_GROW_MULTIPLIER,
+            this.__capacity + CAPACITY_GROW_MIN_STEP
+        ));
+
+        const old_data_uint8 = this.__data_uint8;
+
+        const new_data_buffer = new ArrayBuffer(new_capacity * this.__item_size);
+
+        this.__data_buffer = new_data_buffer;
+        this.__data_uint8 = new Uint8Array(new_data_buffer);
+
+        // copy old data
+        this.__data_uint8.set(old_data_uint8);
+
+        this.__capacity = new_capacity;
+    }
+
+
+    /**
+     *
+     * @return {number}
+     */
+    allocate() {
+        if (this.__free_pointer > 0) {
+            // get unused slot
+            this.__free_pointer--;
+            return this.__free[this.__free_pointer];
+        }
+
+        // allocate new
+
+        let result = this.__used_end;
+
+        if (result >= this.__capacity) {
+            this.__grow_capacity();
+        }
+
+        this.__used_end++;
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} id
+     */
+    release(id) {
+        this.__free[this.__free_pointer++] = id;
+    }
+}
+
+/**
+ * Heavily influenced by blender's internal mesh structure
+ * @see https://github.com/blender/blender/blob/master/source/blender/bmesh/bmesh_class.h
+ */
+export class BinaryTopology {
+    __vertex_pool = new BinaryPool();
+    __edge_pool = new BinaryPool();
+    __loop_pool = new BinaryPool();
+    __face_pool = new BinaryPool();
+
+
+}

package/core/geom/Quaternion.js

@@ -1470,7 +1470,7 @@ class Quaternion {
 
     /**
      * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
-     * @param value
+     * @param {number} value
      */
     decodeFromUint32(value) {
         //read components
@@ -1481,9 +1481,9 @@ class Quaternion {
         const iv2 = (value >> 22) & 0x3FF;
 
         //scale components back to quaternion range
-        const v0 = (iv0 / 511.5 - 1) * K_CONST;
-        const v1 = (iv1 / 511.5 - 1) * K_CONST;
-        const v2 = (iv2 / 511.5 - 1) * K_CONST;
+        const v0 = (iv0 / 511 - 1) * K_CONST;
+        const v1 = (iv1 / 511 - 1) * K_CONST;
+        const v2 = (iv2 / 511 - 1) * K_CONST;
 
         //restore dropped component using quaternion identity: x^2 + y^2 + z^2 + w^2 = 1
         const dropped_2 = 1 - v0 * v0 - v1 * v1 - v2 * v2;
@@ -1501,7 +1501,7 @@ class Quaternion {
     }
 
     /**
-     *
+     * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
      * @returns {number}
      */
     encodeToUint32() {
@@ -1590,9 +1590,9 @@ class Quaternion {
         const m = 1 / (l * K_CONST);
 
         //re-normalize the remaining components to 10 bit UINT value
-        const oV0 = ((v0 * m + 1) * 511.5) | 0;
-        const oV1 = ((v1 * m + 1) * 511.5) | 0;
-        const oV2 = ((v2 * m + 1) * 511.5) | 0;
+        const oV0 = Math.round((v0 * m + 1) * 511);
+        const oV1 = Math.round((v1 * m + 1) * 511);
+        const oV2 = Math.round((v2 * m + 1) * 511);
 
         assert.ok(oV0 <= 1023 && oV0 >= 0, `expected 0 <= ov0 <= 1023, instead was '${oV0}'`);
         assert.ok(oV1 <= 1023 && oV1 >= 0, `expected 0 <= ov1 <= 1023, instead was '${oV1}'`);

package/core/geom/Quaternion.spec.js

@@ -154,6 +154,19 @@ test('encoding to Uint32 consistency', () => {
     check(1, 0, 0, 0);
 });
 
+test('encoding to Uint32 and decoding identity correctly', () => {
+    const a = new Quaternion();
+    a.copy(Quaternion.identity);
+
+    const b = new Quaternion();
+
+    const encoded = a.encodeToUint32();
+
+    b.decodeFromUint32(encoded);
+
+    expect(b.toJSON()).toEqual(a.toJSON());
+});
+
 
 test('to/from euler YXZ consistency', () => {
     function check(x, y, z) {

package/core/geom/Vector1.d.ts

@@ -10,4 +10,6 @@ export default class Vector1 {
     _sub(v: number): void
 
     isZero(): boolean
+
+    process(callback: (x) => any): void
 }

package/core/math/sign_not_zero.js

@@ -0,0 +1,8 @@
+/**
+ * Same as C "sign" function, but in case of input value being 0, returns +1
+ * @param {number} v
+ * @return {number}
+ */
+export function sign_not_zero(v) {
+    return v >= 0 ? 1 : -1;
+}

package/core/parser/simple/SimpleParser.js

@@ -2,6 +2,8 @@ import DataType from "./DataType.js";
 import ParserError from "./ParserError.js";
 import Token from "./Token.js";
 import TokenType from "./TokenType.js";
+import { readUnsignedInteger } from "./readUnsignedInteger.js";
+import { skipWhitespace } from "./skipWhitespace.js";
 
 
 const RX_IDENTIFIER_CHAR = /^[a-zA-Z0-9_]/;
@@ -272,90 +274,6 @@ function readHex(text, cursor, length) {
     return new Token(value, cursor, i, null, DataType.Number);
 }
 
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readUnsignedInteger(text, cursor, length) {
-    let i = cursor;
-
-    let value = 0;
-
-    main_loop: for (; i < length;) {
-        const char = text.charAt(i);
-        let digit;
-        switch (char) {
-            case '0':
-                digit = 0;
-                break;
-            case '1':
-                digit = 1;
-                break;
-            case '2':
-                digit = 2;
-                break;
-            case '3':
-                digit = 3;
-                break;
-            case '4':
-                digit = 4;
-                break;
-            case '5':
-                digit = 5;
-                break;
-            case '6':
-                digit = 6;
-                break;
-            case '7':
-                digit = 7;
-                break;
-            case '8':
-                digit = 8;
-                break;
-            case '9':
-                digit = 9;
-                break;
-            default:
-                if (i === cursor) {
-                    //first character is not a digit
-                    throw new ParserError(i, `Expected a digit [0,1,2,3,4,5,6,7,8,9] but got '${char}' instead`, text);
-                }
-                //not a digit
-                break main_loop;
-        }
-        i++;
-        value = value * 10 + digit;
-    }
-
-
-    return new Token(value, cursor, i, null, DataType.Number);
-}
-
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {number}
- */
-export function skipWhitespace(text, cursor, length) {
-    let i = cursor;
-    let char;
-    while (i < length) {
-        char = text.charAt(i);
-
-        if (char === ' ' || char === '\n' || char === '\t') {
-            i++;
-        } else {
-            break;
-        }
-    }
-    return i;
-}
 
 /**
  *
@@ -542,6 +460,5 @@ export {
     readLiteral,
     readNumber,
     readStringToken,
-    readBoolean,
-    readUnsignedInteger
+    readBoolean
 };

package/core/parser/simple/readUnsignedInteger.js

@@ -0,0 +1,66 @@
+import ParserError from "./ParserError.js";
+import Token from "./Token.js";
+import DataType from "./DataType.js";
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+export function readUnsignedInteger(text, cursor, length) {
+    let i = cursor;
+
+    let value = 0;
+
+    main_loop: for (; i < length;) {
+        const char = text.charAt(i);
+        let digit;
+        switch (char) {
+            case '0':
+                digit = 0;
+                break;
+            case '1':
+                digit = 1;
+                break;
+            case '2':
+                digit = 2;
+                break;
+            case '3':
+                digit = 3;
+                break;
+            case '4':
+                digit = 4;
+                break;
+            case '5':
+                digit = 5;
+                break;
+            case '6':
+                digit = 6;
+                break;
+            case '7':
+                digit = 7;
+                break;
+            case '8':
+                digit = 8;
+                break;
+            case '9':
+                digit = 9;
+                break;
+            default:
+                if (i === cursor) {
+                    //first character is not a digit
+                    throw new ParserError(i, `Expected a digit [0,1,2,3,4,5,6,7,8,9] but got '${char}' instead`, text);
+                }
+                //not a digit
+                break main_loop;
+        }
+        i++;
+        value = value * 10 + digit;
+    }
+
+
+    return new Token(value, cursor, i, null, DataType.Number);
+}
+

package/core/parser/simple/skipWhitespace.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {number}
+ */
+export function skipWhitespace(text, cursor, length) {
+    let i = cursor;
+    let char;
+    while (i < length) {
+        char = text.charAt(i);
+
+        if (char === ' ' || char === '\n' || char === '\t') {
+            i++;
+        } else {
+            break;
+        }
+    }
+    return i;
+}

package/editor/view/ecs/components/common/NumberController.js

@@ -24,7 +24,7 @@ export class NumberController extends View {
         const el = document.createElement('input');
         this.el = el;
 
-        classList.forEach(c => this.addClass(c));
+        this.addClasses(classList);
 
         el.setAttribute('type', 'text');
         el.setAttribute('spellcheck', false);
@@ -34,6 +34,7 @@ export class NumberController extends View {
 
         let lockForward = false;
 
+
         /**
          *
          * @param {number} num_value
@@ -44,7 +45,26 @@ export class NumberController extends View {
             let str = String(num_value);
 
             if (Math.abs(num_value) > 0 && Math.abs(num_value % 1).toString().length > (figures + 2)) {
-                str = num_value.toFixed(figures);
+                const long_form = num_value.toFixed(figures);
+
+                const separator_index = long_form.indexOf('.');
+
+                if (separator_index !== -1) {
+                    // has a decimal fraction, remove trailing zeroes
+                    let i = long_form.length - 1;
+
+                    while (i > 0 && long_form.charAt(i) === "0") {
+                        i--;
+                    }
+
+                    if (long_form.charAt(i) === '.') {
+                        i--;
+                    }
+
+                    str = long_form.slice(0, i + 1);
+                } else {
+                    str = long_form;
+                }
             }
 
             return str;
@@ -80,10 +100,8 @@ export class NumberController extends View {
          * Input field stops being edited
          */
         function handle_blur() {
-            if (Number.isNaN(parseFloat(el.value))) {
-                // input in the field is invalid, replace with the value held in the data container
-                el.value = format_value_string(_value.getValue());
-            }
+            // reformat contents of the input field
+            el.value = format_value_string(_value.getValue());
         }
 
         _value.process(data2view);

package/engine/EngineHarness.js

@@ -81,7 +81,7 @@ export class EngineHarness {
 
         window.engine = this.engine;
 
-        logger.addBackend(new ConsoleLoggerBackend());
+        logger.addBackend(ConsoleLoggerBackend.INSTANCE);
 
         this.p = null;
     }
@@ -122,6 +122,10 @@ export class EngineHarness {
             document.body.appendChild(engine.viewStack.el);
             engine.viewStack.link();
 
+            // set css
+            document.body.style.margin = "0";
+            document.body.style.overflow = "hidden";
+
             function handleInput() {
                 window.removeEventListener(MouseEvents.Down, handleInput);
 
@@ -437,6 +441,7 @@ export class EngineHarness {
 
         const eb = new EntityBuilder();
 
+        eb.add(new Transform())
         eb.add(terrain);
 
         if (enableWater) {

package/engine/asset/AssetDescription.spec.js

@@ -0,0 +1,27 @@
+import { AssetDescription } from "./AssetDescription.js";
+
+test('equality', () => {
+    const a = new AssetDescription('a', 'b');
+    const b = new AssetDescription('a', 'b');
+    const c = new AssetDescription('b', 'a');
+    const d = new AssetDescription('b', 'b');
+    const e = new AssetDescription('a', 'a');
+    const f = new AssetDescription('x', 'y');
+
+    expect(b.equals(a)).toBe(true);
+    expect(b.equals(c)).toBe(false);
+    expect(b.equals(d)).toBe(false);
+    expect(b.equals(e)).toBe(false);
+    expect(b.equals(f)).toBe(false);
+});
+
+
+test('hash stability', () => {
+    const a = new AssetDescription('a', 'b');
+
+    expect(a.hash()).toEqual(a.hash());
+
+    const b = new AssetDescription('a', 'b');
+
+    expect(a.hash()).toEqual(b.hash());
+});