@woosh/meep-engine 2.40.1 → 2.42.0

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/apply_mat4_transform_to_v3_array.js

@@ -6,11 +6,9 @@
  * @param {number[]|Float32Array|Float64Array} destination
  * @param {number} destination_offset
  * @param {number} count
- * @param {THREE.Matrix4} matrix
+ * @param {mat4|number[]|Float32Array} mat4
  */
-export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, count, matrix) {
-
-    const mat4 = matrix.elements;
+export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, count, mat4) {
 
     const a0 = mat4[0];
     const a1 = mat4[1];

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/sphere/sphere_radius_sqr_from_v3_array_transformed.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_length
+ * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @returns {number}
+ */
+export function sphere_radius_sqr_from_v3_array_transformed(input, input_length, e) {
+    let result = 0;
+
+    for (let i = 0; i < input_length; i += 3) {
+        const x = input[i];
+        const y = input[i + 1];
+        const z = input[i + 2];
+
+        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
+        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
+        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+
+        const l2 = _x * _x + _y * _y + _z * _z;
+
+        if (l2 > result) {
+            result = l2;
+        }
+    }
+
+    return result;
+}

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

@@ -1705,6 +1705,20 @@ class Quaternion {
         return result;
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {Quaternion}
+     */
+    static fromEulerAngles(x, y, z) {
+        const r = new Quaternion();
+
+        r.fromEulerAnglesXYZ(x, y, z);
+
+        return r;
+    }
 
     /**
      * Behaves similarly to Unity's Quaternion `RotateToward` method

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/engine/EngineHarness.js

@@ -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);
 
@@ -149,6 +153,7 @@ export class EngineHarness {
      * @param {boolean} [autoClip]
      * @param {number} [distanceMin]
      * @param {number} [distanceMax]
+     * @param {number} [fieldOfView] in degrees
      * @returns {EntityBuilder}
      */
     static buildCamera(
@@ -159,9 +164,10 @@ export class EngineHarness {
             distance = 10,
             pitch = 1.4,
             yaw = 0,
-            autoClip = true,
+            autoClip = false,
             distanceMin = 0,
-            distanceMax = 1000
+            distanceMax = 1000,
+            fieldOfView = 45
         }
     ) {
         const em = engine.entityManager;
@@ -195,6 +201,7 @@ export class EngineHarness {
 
         camera.active.set(true);
         camera.autoClip = autoClip;
+        camera.fov.set(fieldOfView);
 
         const entityBuilder = new EntityBuilder();
 
@@ -225,6 +232,7 @@ export class EngineHarness {
      * @param {boolean} [enableWater]
      * @param {boolean} [enableTerrain]
      * @param {boolean} [enableLights=true]
+     * @param {number} [cameraFieldOfView]
      * @param {boolean} [cameraController=true]
      */
     static async buildBasics({
@@ -240,6 +248,7 @@ export class EngineHarness {
                                  enableWater = true,
                                  enableTerrain = true,
                                  enableLights = true,
+                                 cameraFieldOfView,
                                  cameraController = true
                              }) {
 
@@ -252,7 +261,8 @@ export class EngineHarness {
             target: focus,
             pitch,
             yaw,
-            distance
+            distance,
+            fieldOfView: cameraFieldOfView
         });
 
         const cameraEntity = camera.entity;

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());
+});

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -11,7 +11,9 @@ import { MeshDepthMaterial, RGBADepthPacking } from "three";
 import { TextureAttachmentsByMaterialType } from "./material/TextureAttachmensByMaterialType.js";
 import { AssetLoader } from "./AssetLoader.js";
 import { ensureGeometryBoundingSphere } from "../../graphics/geometry/buffered/ensureGeometryBoundingSphere.js";
-import { computeSkinnedMeshBoundingVolumes } from "../../graphics/geometry/skining/computeSkinnedMeshBoundingVolumes.js";
+import {
+    computeSkinnedMeshBoundingVolumes
+} from "../../graphics/geometry/skining/computeSkinnedMeshBoundingVolumes.js";
 import { ensureGeometryBoundingBox } from "../../graphics/util/ensureGeometryBoundingBox.js";
 import { cloneObject3D } from "../../graphics/three/cloneObject3D.js";
 import GLTFTextureDDSExtension from "./gltf/extensions/MSFT_texture_dds.js";
@@ -20,8 +22,8 @@ import { computeObjectBoundingSphere } from "./gltf/computeObjectBoundingSphere.
 import { isMesh } from "./gltf/isMesh.js";
 import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
 import { HashSet } from "../../../core/collection/HashSet.js";
-import { computeGeometryHash } from "./geometry/geometry/computeGeometryHash.js";
-import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEquality.js";
+import { computeGeometryHash } from "../../graphics/geometry/buffered/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../graphics/geometry/buffered/computeGeometryEquality.js";
 import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/traverseThreeObject.js";
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";

package/engine/ecs/foliage/ImpostorFoliage.js

@@ -19,6 +19,10 @@ import {
 import Vector2 from "../../../core/geom/Vector2.js";
 import Vector4 from "../../../core/geom/Vector4.js";
 
+/**
+ * @deprecated use other options, such as ShadedMesh with INSTANCED draw mode or dedicated instanced mesh system such as Foliage2System
+ * @constructor
+ */
 const Foliage = function (options) {
     const size = options.size || 1;
     const lightMap = options.lightMap;