@woosh/meep-engine 2.40.1 → 2.41.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/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/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);
 

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;

package/engine/graphics/ecs/mesh-v2/three_object_to_entity_composition.js

@@ -2,6 +2,22 @@ import { EntityNode } from "../../../ecs/parent/EntityNode.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "./ShadedGeometry.js";
 
+/**
+ *
+ * @param {Transform} transform
+ * @param {THREE.Object3D} three_object
+ */
+function copy_three_transform(transform, three_object) {
+
+    // copy object transform
+    transform.position.copy(three_object.position);
+    transform.scale.copy(three_object.scale);
+    transform.rotation.copy(three_object.quaternion);
+
+    //
+    transform.matrix.set(three_object.matrix.elements);
+}
+
 /**
  *
  * @param {THREE.Object3D} root
@@ -13,16 +29,15 @@ export function three_object_to_entity_composition(root) {
     const node_transform = node.transform;
 
     // copy object transform
-    node_transform.position.copy(root.position);
-    node_transform.scale.copy(root.scale);
-    node_transform.rotation.copy(root.quaternion);
-
-    //
-    node_transform.matrix.set(root.matrix.elements);
+    copy_three_transform(node_transform, root);
 
     const entity = node.entity;
 
-    entity.add(new Transform());
+    const transform = new Transform();
+    // initialize world transform
+    transform.fromMatrix4(root.matrixWorld.elements);
+
+    entity.add(transform);
 
     if (root.isMesh) {
         if (root.isSkinnedMesh) {

package/engine/graphics/filter/ImageFilter.js

@@ -3,7 +3,7 @@
  */
 
 
-import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
+import { DoubleSide, LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
 import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
@@ -41,6 +41,7 @@ function processTexture(
     material.fog = false;
     material.uniformsNeedUpdate = true;
     material.needsUpdate = true;
+    material.side = DoubleSide;
 
     const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 

package/engine/graphics/geometry/MikkT/MikkTSpace.spec.js

@@ -14,7 +14,13 @@ test('single triangle', () => {
 
     ctx.geometry_buffer_index = [0, 1, 2];
     ctx.geometry_buffer_vertex_position = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    ctx.geometry_buffer_vertex_normal = [0, 1, 0, 0, 1, 0, 0, 1, 0];
+
+    ctx.geometry_buffer_vertex_normal = [
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0
+    ];
+
     ctx.geometry_buffer_vertex_uv = [0, 0, 0, 0, 0, 0];
 
     genTangSpace(ctx);

package/engine/{asset/loaders/geometry/geometry → graphics/geometry/buffered}/computeBufferAttributeHash.js

@@ -1,4 +1,4 @@
-import { computeStridedIntegerArrayHash } from "../../../../computeStridedIntegerArrayHash.js";
+import { computeStridedIntegerArrayHash } from "../../../computeStridedIntegerArrayHash.js";
 
 /**
  *

package/engine/{asset/loaders/geometry/geometry → graphics/geometry/buffered}/computeGeometryEquality.js

@@ -1,5 +1,5 @@
-import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
-import { is_typed_array_equals } from "../../../../../core/collection/array/typed/is_typed_array_equals.js";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.d.ts";
+import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 
 /**

package/engine/{asset/loaders/geometry/geometry → graphics/geometry/buffered}/computeGeometryHash.js

@@ -1,5 +1,5 @@
 import { computeBufferAttributeHash } from "./computeBufferAttributeHash.js";
-import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.d.ts";
 
 /**
  *

package/engine/graphics/geometry/optimization/merge/merge_geometry_hierarchy.js

@@ -1,7 +1,7 @@
 import { StaticMaterialCache } from "../../../../asset/loaders/material/StaticMaterialCache.js";
 import { HashMap } from "../../../../../core/collection/HashMap.js";
-import { computeGeometryEquality } from "../../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
-import { computeGeometryHash } from "../../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../buffered/computeGeometryEquality.js";
+import { computeGeometryHash } from "../../buffered/computeGeometryHash.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 import { mat4 } from "gl-matrix";
 import { Group, Matrix4, Mesh } from "three";