@woosh/meep-engine 2.33.5 → 2.33.6

package/core/collection/RingBuffer.js

@@ -7,14 +7,32 @@ export class RingBuffer {
      * @constructor
      */
     constructor(size) {
-        assert.equal(typeof size, "number", `Type of 'size' must be 'number', was '${typeof size}' instead`);
+        assert.isNumber(size, 'size');
         assert.greaterThan(size, 0, `size`);
+        assert.isNonNegativeInteger(size, 'size');
 
+        /**
+         *
+         * @type {number}
+         */
         this.size = size;
 
+        /**
+         *
+         * @type {number}
+         */
         this.head = 0;
+
+        /**
+         *
+         * @type {number}
+         */
         this.tail = 0;
 
+        /**
+         *
+         * @type {number}
+         */
         this.count = 0;
 
         /**
@@ -62,13 +80,15 @@ export class RingBuffer {
 
         this.data[head] = element;
 
-        const newHead = (head + 1) % this.size;
+        const size = this.size;
+
+        const newHead = (head + 1) % size;
 
         this.head = newHead;
 
-        if (this.count === this.size) {
+        if (this.count === size) {
             //update tail
-            this.tail = (this.tail + 1) % this.size;
+            this.tail = (this.tail + 1) % size;
         } else {
             this.count++;
         }
@@ -130,11 +150,15 @@ export class RingBuffer {
      * @returns {V|undefined}
      */
     removeIf(condition, thisArg) {
+        const count = this.count;
+        const size = this.size;
 
-        for (let i = 0; i < this.count; i++) {
-            const index = (this.tail + i) % this.size;
+        const tail = this.tail;
+        const data = this.data;
 
-            const el = this.data[index];
+        for (let i = 0; i < count; i++) {
+            const index = (tail + i) % size;
+            const el = data[index];
 
             if (condition.call(thisArg, el)) {
 
@@ -151,10 +175,16 @@ export class RingBuffer {
      * @param {*} [thisArg]
      */
     forEach(visitor, thisArg) {
-        for (let i = 0; i < this.count; i++) {
-            const index = (this.tail + i) % this.size;
+        const count = this.count;
+        const size = this.size;
+
+        const tail = this.tail;
+        const data = this.data;
+
+        for (let i = 0; i < count; i++) {
 
-            const el = this.data[index];
+            const index = (tail + i) % size;
+            const el = data[index];
 
             visitor.call(thisArg, el);
         }

package/core/collection/array/typed/typed_array_copy.js

@@ -3,8 +3,8 @@ import { array_copy } from "../copyArray.js";
 
 /**
  *
- * @param {TypedArray} source
- * @param {TypedArray} destination
+ * @param {TypedArray|Float32Array} source
+ * @param {TypedArray|Float32Array} destination
  */
 export function typed_array_copy(source, destination) {
     const destination_size = destination.length;

package/core/geom/3d/aabb/aabb3_compute_projected_area.js

@@ -56,7 +56,7 @@ export function aabb3_project_to_2d(aabb_corners, projection_matrix) {
         const t_w = a3 * _x + b3 * _y + c3 * _z + d3;
 
         // perspective divide and normalization (-1,1 space projected to -0.5,0.5)
-        const d = 0.5 / Math.abs(t_w);
+        const d = 0.5 / t_w;
 
         // finally compute screen-space coordinates of the corner
         const x = t_x * d;
@@ -65,13 +65,14 @@ export function aabb3_project_to_2d(aabb_corners, projection_matrix) {
         if (x0 > x) {
             x0 = x;
         }
-        if (y0 > y) {
-            y0 = y;
-        }
 
         if (x1 < x) {
             x1 = x;
         }
+
+        if (y0 > y) {
+            y0 = y;
+        }
         if (y1 < y) {
             y1 = y;
         }

package/core/process/undo/ActionProcessor.d.ts

@@ -17,6 +17,8 @@ export class ActionProcessor<CTX, MD> {
 
     redo(): void
 
+    navigateTo(mark: MD): boolean
+
     doMany(actions: Action<CTX>[]): void
 
     do(action: Action<CTX>): this

package/core/process/undo/ActionProcessor.js

@@ -202,6 +202,64 @@ export class ActionProcessor {
 
     }
 
+    /**
+     * Navigate to a specific mark back or forward
+     * @param {M} mark_descriptor specific mark description
+     * @returns {boolean} true on success, false otherwise (e.g. mark not found)
+     * @throws {Error} when mark is non-unique
+     */
+    navigateTo(mark_descriptor) {
+        // find all matching marks
+        const matching_marks = this.marks.filter(m => m.description === mark_descriptor);
+
+        if (matching_marks.length === 0) {
+            // not found
+            return false;
+        }
+
+        if (matching_marks.length > 1) {
+            throw new Error(`Attempting to navigate to a non-unique mark descriptor '${mark_descriptor}'. Mark descriptor must be unique, instead ${matching_marks.length} matches were found`);
+        }
+
+        const match = matching_marks[0];
+
+        const target = match.index;
+
+        let temp_cursor = this.cursor;
+
+        if (target > this.cursor) {
+
+            while (target > this.cursor) {
+                // navigate forward
+                this.redo();
+
+                if (temp_cursor === this.cursor) {
+                    // no cursor change
+                    return false;
+                }
+
+                temp_cursor = this.cursor;
+            }
+
+        } else if (target < this.cursor) {
+
+            while (target < this.cursor) {
+                // navigate backwards
+                this.undo();
+
+                if (temp_cursor === this.cursor) {
+                    // no cursor change
+                    return false;
+                }
+
+                temp_cursor = this.cursor;
+            }
+
+        }
+
+        return true;
+    }
+
     undo() {
         let markAddress = 0;
         /**
@@ -226,7 +284,7 @@ export class ActionProcessor {
             markAddress = 0;
         }
 
-        //keep rewinding until we hit mark
+        //keep rewinding until we hit a mark
         while (this.cursor > markAddress && this.cursor > 0) {
             this.cursor--;
             const action = this.history.get(this.cursor);

package/core/process/undo/ActionProcessor.spec.js

@@ -0,0 +1,59 @@
+import { ActionProcessor } from "./ActionProcessor.js";
+import { Action } from "./Action.js";
+
+class DummyContext {
+    constructor() {
+        this.value = 0;
+    }
+}
+
+class DummyAction extends Action {
+    apply(context) {
+        // do nothing
+        context.value++;
+    }
+
+    revert(context) {
+        context.value--;
+    }
+}
+
+test('navigateTo backwards', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    ap.mark('a');
+    ap.do(new DummyAction());
+    ap.mark('b');
+    ap.do(new DummyAction());
+
+    expect(ap.navigateTo('a')).toBe(true);
+
+    expect(ctx.value).toBe(0);
+});
+
+test('navigateTo forward', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    ap.mark('a');
+    ap.do(new DummyAction());
+    ap.mark('b');
+    ap.do(new DummyAction());
+    ap.mark('c');
+
+    ap.undo();
+    ap.undo();
+    ap.undo();
+
+    expect(ap.navigateTo('c')).toBe(true);
+
+    expect(ctx.value).toBe(2);
+});
+
+test('navigateTo non-existent on empty', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    expect(ap.navigateTo('a')).toBe(false);
+});

package/core/process/undo/Mark.js

@@ -8,13 +8,14 @@ export class Mark {
      * @constructor
      */
     constructor(index, description) {
-        assert.typeOf(index, 'number', 'index');
+        assert.isNumber(index, 'index');
 
         /**
          *
          * @type {number}
          */
         this.index = index;
+
         /**
          *
          * @type {D}

package/engine/asset/loaders/material/bitmap2sampler_gl.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {WebGL2RenderingContext} gl
+ * @param {Sampler2D} sampler
+ * @param {ImageBitmap} bitmap
+ */
+export function bitmap2sampler_gl(gl, sampler, bitmap) {
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
+    gl.drawBuffers([gl.COLOR_ATTACHMENT0]);
+
+    const w = sampler.width;
+    const h = sampler.height;
+
+    if (sampler.itemSize !== 4) {
+        throw new Error(`Expected sampler.itemSize to be 4, instead was '${sampler.itemSize}'`);
+    }
+
+    gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, sampler.data);
+}

package/engine/asset/loaders/material/computeImageBitmapEquality.js

@@ -1,6 +1,7 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 import { assert } from "../../../../core/assert.js";
 import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
+import { bitmap2sampler_gl } from "./bitmap2sampler_gl.js";
 
 /**
  *
@@ -8,23 +9,6 @@ import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqu
  */
 const sampler_cache = new WeakMap();
 
-/**
- *
- * @param {WebGL2RenderingContext} gl
- * @param {Sampler2D} sampler
- * @param {ImageBitmap} bitmap
- */
-function bitmap2sampler_gl(gl, sampler, bitmap) {
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
-    gl.drawBuffers([gl.COLOR_ATTACHMENT0]);
-
-    const data = new Uint8Array(sampler.width * sampler.height * 4);
-
-    gl.readPixels(0, 0, sampler.width, sampler.height, gl.RGBA, gl.UNSIGNED_BYTE, data);
-
-    sampler.data = data;
-}
-
 /**
  *
  * @param {ImageBitmap} bitmap
@@ -45,7 +29,7 @@ function obtainSampler(bitmap, ctx) {
     const width = bitmap.width;
     const height = bitmap.height;
 
-    const sampler = new Sampler2D(null, 4, width, height);
+    const sampler = Sampler2D.uint8(4, width, height);
 
     bitmap2sampler_gl(ctx, sampler, bitmap);
 
@@ -75,15 +59,19 @@ function obtainCanvasCtx(width, height) {
 
     if (ctx_ref === null || (gl = ctx_ref.deref()) === undefined) {
         const canvas = document.createElement('canvas');
+
         gl = canvas.getContext("webgl2");
         gl.activeTexture(gl.TEXTURE0);
+
         const texture = gl.createTexture();
+
         gl.bindTexture(gl.TEXTURE_2D, texture);
+
         const framebuffer = gl.createFramebuffer();
+
         gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
         gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
 
-
         ctx_ref = new WeakRef(gl);
     }
 

package/engine/graphics/geometry/instancing/InstancedMeshGroup.js

@@ -8,6 +8,7 @@ import {
 import ThreeFactory from "../../three/ThreeFactory.js";
 import { StaticMaterialCache } from "../../../asset/loaders/material/StaticMaterialCache.js";
 import { composeCompile } from "../../material/composeCompile.js";
+import { typed_array_copy } from "../../../../core/collection/array/typed/typed_array_copy.js";
 
 /**
  *
@@ -29,14 +30,14 @@ function InstancedMeshGroup() {
      * Minimum spare capacity increase during growing
      * @type {number}
      */
-    this.growConstant = 1;
+    this.growConstant = 4;
 
-    this.shrinkFactor = 0.8;
+    this.shrinkFactor = 0.5;
     /**
      * Minimum capacity reduction for shrinkage to occur
      * @type {number}
      */
-    this.shrinkConstant = 32;
+    this.shrinkConstant = 64;
 
     /**
      *
@@ -217,14 +218,30 @@ InstancedMeshGroup.prototype.setCapacity = function (size) {
  * @param {number} size
  */
 InstancedMeshGroup.prototype.ensureCapacity = function (size) {
+
     const currentCapacity = this.capacity;
+
     if (currentCapacity < size) {
-        const newCapacityRaw = Math.max(size, currentCapacity * this.growFactor, currentCapacity + this.growConstant);
+        // grow
+
+        const newCapacityRaw = Math.max(
+            size,
+            currentCapacity * this.growFactor,
+            currentCapacity + this.growConstant
+        );
+
         const newCapacityInteger = Math.ceil(newCapacityRaw);
+
         this.setCapacity(newCapacityInteger);
-    } else if (currentCapacity * this.shrinkFactor > size && currentCapacity - this.shrinkConstant > size) {
+
+    } else if (
+        currentCapacity * this.shrinkFactor > size
+        && currentCapacity - this.shrinkConstant > size
+    ) {
+        // shrink
         this.setCapacity(size);
     }
+
 };
 
 /**
@@ -375,14 +392,6 @@ InstancedMeshGroup.prototype.remove = function (reference) {
     this.setCount(this.count - 1);
 };
 
-/**
- * @param {Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} source
- * @param {Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array}target
- */
-function copyArray(source, target) {
-    target.set(source.subarray(0, Math.min(target.length, source.length)), 0)
-}
-
 InstancedMeshGroup.prototype.build = function () {
     if (this.__threeGeometry !== null) {
         // dispose old geometry's GPU memory
@@ -415,16 +424,16 @@ InstancedMeshGroup.prototype.build = function () {
     if (this.__attributePosition !== null) {
         //copy old data
         const oldPositionArray = this.__attributePosition.array;
-        copyArray(oldPositionArray, newPositionArray);
+        typed_array_copy(oldPositionArray, newPositionArray);
     }
     if (this.__attributeRotation !== null) {
         //copy old data
         const oldRotationArray = this.__attributeRotation.array;
-        copyArray(oldRotationArray, newRotationArray);
+        typed_array_copy(oldRotationArray, newRotationArray);
     }
     if (this.__attributeScale !== null) {
         const oldScaleArray = this.__attributeScale.array;
-        copyArray(oldScaleArray, newScaleArray);
+        typed_array_copy(oldScaleArray, newScaleArray);
 
         if (newScaleArray.length > oldScaleArray.length) {
             //fill the rest of the array with scale factor of 1 as a default

package/engine/graphics/material/SplatMaterial.js

@@ -4,7 +4,7 @@
 import {
     ClampToEdgeWrapping,
     Color,
-    DoubleSide,
+    FrontSide,
     GLSL3,
     LinearFilter,
     NormalBlending,
@@ -15,95 +15,10 @@ import {
     Vector4 as ThreeVector4
 } from 'three';
 import TerrainShader from "../shaders/TerrainShader.js";
-import Vector4 from "../../../core/geom/Vector4.js";
 import { Sampler2D } from "../texture/sampler/Sampler2D.js";
 import sampler2D2Texture from "../texture/sampler/Sampler2D2Texture.js";
 
-/**
- *
- * @param {Vector4} tex0
- * @param {Vector4} tex1
- * @param {Vector4} tex2
- * @param {Vector4} tex3
- * @param {Vector4} splat
- * @param {Vector4} result
- */
-export function blendSplatTextures(tex0, tex1, tex2, tex3, splat, result) {
-    const b0 = splat.x;
-    const b1 = splat.y;
-    const b2 = splat.z;
-    const b3 = splat.w;
-
-    const bT = b0 + b1 + b2 + b3;
-
-
-    result.set(
-        (tex0.x * b0 + tex1.x * b1 + tex2.x * b2 + tex3.x * b3) / bT,
-        (tex0.y * b0 + tex1.y * b1 + tex2.y * b2 + tex3.y * b3) / bT,
-        (tex0.z * b0 + tex1.z * b1 + tex2.z * b2 + tex3.z * b3) / bT,
-        (tex0.w * b0 + tex1.w * b1 + tex2.w * b2 + tex3.w * b3) / bT
-    );
-}
-
-/**
- *
- * @param {Sampler2D[]} diffuse
- * @param {Vector2} diffuseRepeat
- * @param {Sampler2D} splat
- * @param {Vector2} gridSize
- * @param {Vector2} resultTextureSize
- * @returns {Sampler2D}
- */
-export function buildTerrainTexture({ diffuse, diffuseRepeat, splat, gridSize, resultTextureSize }) {
-    const texture0 = diffuse[0];
-    const texture1 = diffuse[1];
-    const texture2 = diffuse[2];
-    const texture3 = diffuse[3];
-
-    const resultData = new Uint8Array(resultTextureSize.x * resultTextureSize.y * 4);
-
-    const result = new Sampler2D(resultData, 4, resultTextureSize.x, resultTextureSize.y);
-
-    //do the splatting
-    let x, y, u, v;
-
-    const tex0 = new Vector4(0, 0, 0, 0);
-    const tex1 = new Vector4(0, 0, 0, 0);
-    const tex2 = new Vector4(0, 0, 0, 0);
-    const tex3 = new Vector4(0, 0, 0, 0);
-
-    const vSplat = new Vector4(0, 0, 0, 0);
-
-    const vTemp = new Vector4(0, 0, 0, 0);
-
-    for (x = 0; x < resultTextureSize.x; x++) {
-
-        u = x / (resultTextureSize.x - 1);
-
-        for (y = 0; y < resultTextureSize.y; y++) {
-
-            v = y / (resultTextureSize.y - 1);
-
-            const dU = (u * diffuseRepeat.x) % 1;
-            const dV = (v * diffuseRepeat.y) % 1;
-
-            texture0.sample(dU, dV, tex0);
-            texture1.sample(dU, dV, tex1);
-            texture2.sample(dU, dV, tex2);
-            texture3.sample(dU, dV, tex3);
-
-            splat.sample(u, v, vSplat);
-
-            blendSplatTextures(tex0, tex1, tex2, tex3, vSplat, vTemp);
-
-            result.set(x, y, [vTemp.x, vTemp.y, vTemp.z, 255]);
-        }
-    }
-
-    return result;
-}
-
-function whitePixelTexture() {
+export function whitePixelTexture() {
     const sampler = Sampler2D.uint8(4, 1, 1);
 
     for (let i = 0; i < sampler.data.length; i++) {
@@ -205,17 +120,12 @@ export function SplatMaterial(
         uniforms.gridResolution.value.set(gridResolution.x, gridResolution.y);
     }
 
-
-    //this is for the water shader, so that back of the terrain reflects in the water, otherwise edges of shoreline look odd
-    //TODO check how this can be removed, it would speed water(and ordinary) rendering if back faces could be culled
-    const side = DoubleSide;
-
     const sm = new ShaderMaterial({
 
         uniforms: uniforms,
         vertexShader: TerrainShader.vertexShader,
         fragmentShader: TerrainShader.fragmentShader,
-        side: side,
+        side: FrontSide,
         blending: NormalBlending,
         depthTest: true,
         depthWrite: true,
@@ -249,11 +159,8 @@ export function SplatMaterial(
         sm.aoMap = true;
         uniforms.aoMap.value = lightMap;
         uniforms.aoMapIntensity.value = 0.7;
-        //
-        // sm.lightMap = true;
-        // uniforms.lightMap.value = options.lightMap;
-        // uniforms.lightMapIntensity.value = 1;
     }
+
     sm.extensions.derivatives = true; //needed for rendering grid
     sm.needsUpdate = true;
 

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -4,7 +4,6 @@ import { MicronGeometry } from "../format/MicronGeometry.js";
 import { buildAbstractPatchHierarchy } from "./hierarchy/buildAbstractPatchHierarchy.js";
 import { MicronGeometryBufferAttributeSpec } from "../format/MicronGeometryBufferAttributeSpec.js";
 import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
-import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import { DataType } from "../../../../core/collection/table/DataType.js";
 import { MicronGeometryPatch } from "../format/MicronGeometryPatch.js";
 import { build_clustering_info } from "./debug/build_clustering_info.js";
@@ -202,11 +201,8 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
     // console.time('build geometry');
 
     const vertex_attributes = attributes_from_buffer_geometry(input);
-    const data_types = buildVertexDataTypeMap(vertex_attributes);
-    const vertex_data_spec = RowFirstTableSpec.get(data_types);
 
-    r.vertex_spec.data = vertex_data_spec;
-    r.vertex_spec.attributes = vertex_attributes;
+    r.vertex_spec.setAttributes(vertex_attributes);
     r.root = compilePatchGraph(root, input, r.vertex_spec);
 
     r.initialize();

package/engine/graphics/micron/build/fill_patch_geometry_data.js

@@ -198,6 +198,8 @@ export function fill_patch_geometry_data(result, buffer_geometry, topo, vertex_d
     const micron_attributes = vertex_data_spec.attributes;
     const attribute_count = micron_attributes.length;
 
+    //TODO create a single ArrayBuffer for all attributes to get better cache coherence for rendering
+
     for (let i = 0; i < attribute_count; i++) {
         const attribute_spec = micron_attributes[i];
 

package/engine/graphics/micron/format/MicronGeometryPatch.js

@@ -13,22 +13,30 @@ export class MicronGeometryPatch {
          */
         this.id = 0;
 
+        /**
+         * Continuous memory region for various pieces of data to get better memory access patterns
+         * All pieces of data end up in a continuous piece of memory, resulting in better cache coherence
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer((6 + 6 + 24) * 4);
+
         /**
          * Bounds are used to determine screen error and whether a patch should be subdivided or not for rendering
          * @type {number[]}
          */
-        this.bounding_box = new Float32Array(6);
+        this.bounding_box = new Float32Array(array_buffer, 0, 6);
 
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box = new Float32Array(6);
+        this.group_bounding_box = new Float32Array(array_buffer, 6 * 4, 6);
+
         /**
          *
          * @type {number[]|Float32Array}
          */
-        this.group_bounding_box_corners = new Float32Array(24);
+        this.group_bounding_box_corners = new Float32Array(array_buffer, 12 * 4, 24);
 
         /**
          *