@woosh/meep-engine 2.39.2 → 2.39.5

package/core/bvh2/{traversal/__detailed_box_volume_intersection.js → aabb3/aabb3_detailed_volume_intersection.js}

@@ -1,11 +1,11 @@
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
 import { aabb_build_frustum } from "../../geom/3d/aabb/aabb3_build_frustum.js";
 import { computePointDistanceToPlane, plane3_computeLineSegmentIntersection } from "../../geom/Plane.js";
-import { aabb3_corner_edge_mapping } from "../aabb3/aabb3_corner_edge_mapping.js";
-import { aabb3_edge_corner_mapping } from "../aabb3/aabb3_edge_corner_mapping.js";
-import { __process_point_if_within_planes } from "./__process_point_if_within_planes.js";
+import { aabb3_corner_edge_mapping } from "./aabb3_corner_edge_mapping.js";
+import { aabb3_edge_corner_mapping } from "./aabb3_edge_corner_mapping.js";
 import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 import { EPSILON } from "../../math/MathUtils.js";
+import { is_point_within_planes } from "../../geom/3d/plane/is_point_within_planes.js";
 
 /**
  * Common piece of continuous memory for better cache coherence
@@ -50,28 +50,26 @@ const scratch_v3_array = new Float32Array(__scratch_buffer, 224, 3);
  * where where traditionally only AABB corners would be considered,
  * we're instead able to compute minimum bounds of the overlap of the two
  *
- * @param {AABB3} box
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
  * @param {number[]} planes
- * @param {number} plane_count
  * @param {number} plane_mask
- * @param {function(x:number,y:number,z:number)} callback
- * @param {*} [thisArg]
- * @private
+ * @param {number} plane_count
+ * @returns {number}
  */
-export function __detailed_box_volume_intersection(
-    box,
+export function aabb3_detailed_volume_intersection(
+    destination, destination_offset,
+    x0, y0, z0, x1, y1, z1,
     plane_mask,
     planes,
-    plane_count,
-    callback,
-    thisArg
+    plane_count
 ) {
-    const x0 = box.x0;
-    const y0 = box.y0;
-    const z0 = box.z0;
-    const x1 = box.x1;
-    const y1 = box.y1;
-    const z1 = box.z1;
 
     aabb3_build_corners(scratch_aabb_corners, 0, x0, y0, z0, x1, y1, z1);
     aabb_build_frustum(scratch_aabb_planes, x0, y0, z0, x1, y1, z1);
@@ -94,7 +92,9 @@ export function __detailed_box_volume_intersection(
      */
     let corner_plane_out_bitfield = 0;
 
-    // find out which corners are outside of the frustum
+    let destination_cursor = destination_offset;
+
+    // find out which corners are outside the frustum
     for (let corner_index = 0; corner_index < 8; corner_index++) {
         const corner_offset = corner_index * 3;
 
@@ -148,7 +148,9 @@ export function __detailed_box_volume_intersection(
 
         if (corner_plane_out_bitfield === 0) {
             // corner is fully inside the frustum
-            callback.call(thisArg, x, y, z);
+            destination[destination_cursor++] = x;
+            destination[destination_cursor++] = y;
+            destination[destination_cursor++] = z;
         }
     }
 
@@ -211,14 +213,18 @@ export function __detailed_box_volume_intersection(
 
             if (edge_intersects) {
                 // a possible candidate, let's see if this point is within rest of the planes
-                __process_point_if_within_planes(
+                const inside_planes = is_point_within_planes(
                     scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2],
                     (plane_mask ^ plane_bit_mask),
                     planes,
-                    plane_count,
-                    callback,
-                    thisArg
+                    plane_count
                 );
+
+                if (inside_planes) {
+                    destination[destination_cursor++] = scratch_v3_array[0];
+                    destination[destination_cursor++] = scratch_v3_array[1];
+                    destination[destination_cursor++] = scratch_v3_array[2];
+                }
             }
 
 
@@ -258,16 +264,30 @@ export function __detailed_box_volume_intersection(
 
             if (intersection_exists) {
 
-                const point_within_box = box.containsPointWithTolerance(scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2], EPSILON);
+                const intersection_point_x = scratch_v3_array[0];
+                const intersection_point_y = scratch_v3_array[1];
+                const intersection_point_z = scratch_v3_array[2];
+
+                const point_within_box = !(
+                    (intersection_point_x + EPSILON) < x0 || (intersection_point_x - EPSILON) > x1
+                    || (intersection_point_y + EPSILON) < y0 || (intersection_point_y - EPSILON) > y1
+                    || (intersection_point_z + EPSILON) < z0 || (intersection_point_z - EPSILON) > z1
+                );
 
                 if (point_within_box) {
                     // point is within the AABB bounds
 
                     // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.send3(scratch_v3.x, scratch_v3.y, scratch_v3.z);
 
-                    callback.call(thisArg, scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2]);
+                    destination[destination_cursor++] = intersection_point_x;
+                    destination[destination_cursor++] = intersection_point_y;
+                    destination[destination_cursor++] = intersection_point_z;
                 }
             }
         }
     }
+
+    const address_change = destination_cursor - destination_offset;
+
+    return address_change / 3;
 }

package/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.js

@@ -0,0 +1,13 @@
+//
+
+
+/**
+ * 
+ * @param result
+ * @param result_offset
+ * @param bvh
+ * @param frustum
+ */
+export function compute_tight_near_far_clipping_planes(result, result_offset, bvh, frustum) {
+
+}

package/core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js

@@ -1,7 +1,9 @@
 import { computePointDistanceToPlane } from "../../geom/Plane.js";
 import { BVHVisitor } from "./BVHVisitor.js";
 import { read_frustum_planes_to_array } from "../../geom/3d/frustum/read_frustum_planes_to_array.js";
-import { __detailed_box_volume_intersection } from "./__detailed_box_volume_intersection.js";
+import {
+    aabb3_detailed_volume_intersection_callback_based
+} from "./aabb3_detailed_volume_intersection_callback_based.js";
 
 export class ThreeClippingPlaneComputingBVHVisitor extends BVHVisitor {
     constructor() {
@@ -131,8 +133,8 @@ export class ThreeClippingPlaneComputingBVHVisitor extends BVHVisitor {
         this.__traverseBoxNearCorner(box);
 
 
-        __detailed_box_volume_intersection(
-            box,
+        aabb3_detailed_volume_intersection_callback_based(
+            box.x0, box.y0, box.z0, box.x1, box.y1, box.z1,
             plane_mask,
             this.__planes_f32,
             this.__planeCount,

package/core/bvh2/traversal/__process_point_if_within_planes.js

@@ -53,3 +53,4 @@ export function __process_point_if_within_planes(
 
     return true;
 }
+

package/core/bvh2/traversal/aabb3_detailed_volume_intersection_callback_based.js

@@ -0,0 +1,60 @@
+import { aabb3_detailed_volume_intersection } from "../aabb3/aabb3_detailed_volume_intersection.js";
+
+
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_points_data = [];
+
+/**
+ * Figures out intersection volume between an AABB and a frustum for much tighter bounds
+ *
+ * Especially beneficial when trying to intersect a large AABB against a small frustum,
+ * where where traditionally only AABB corners would be considered,
+ * we're instead able to compute minimum bounds of the overlap of the two
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number[]} planes
+ * @param {number} plane_count
+ * @param {number} plane_mask
+ * @param {function(x:number,y:number,z:number)} callback
+ * @param {*} [thisArg]
+ */
+export function aabb3_detailed_volume_intersection_callback_based(
+    x0, y0, z0, x1, y1, z1,
+    plane_mask,
+    planes,
+    plane_count,
+    callback,
+    thisArg
+) {
+    const point_count = aabb3_detailed_volume_intersection(
+        scratch_points_data, 0,
+        x0, y0, z0, x1, y1, z1,
+        plane_mask,
+        planes,
+        plane_count
+    );
+
+    for (let i = 0; i < point_count; i++) {
+        const address = i * 3;
+        const x = scratch_points_data[address];
+        const y = scratch_points_data[address + 1];
+        const z = scratch_points_data[address + 2];
+        callback.call(thisArg,
+            x,
+            y,
+            z
+        );
+
+        // Gizmo.color= [1,1,1,1];
+        // Gizmo.draw_solid_sphere([x, y, z], 0.1);
+    }
+}
+

package/core/geom/3d/plane/is_point_within_planes.js

@@ -0,0 +1,46 @@
+import { computePointDistanceToPlane } from "../../Plane.js";
+import { EPSILON } from "../../../math/MathUtils.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} plane_mask
+ * @param {number[]} planes
+ * @param {number} plane_count
+ * @return {boolean}
+ * @private
+ */
+export function is_point_within_planes(
+    x, y, z,
+    plane_mask,
+    planes,
+    plane_count
+) {
+
+    for (let plane_index = 0; plane_index < plane_count; plane_index++) {
+        const plane_bit_mask = 1 << plane_index;
+
+        if ((plane_mask & plane_bit_mask) === 0) {
+            // non-intersecting plane, ignore
+            continue;
+        }
+
+        const plane_address = plane_index * 4;
+
+        const nx = planes[plane_address];
+        const ny = planes[plane_address + 1];
+        const nz = planes[plane_address + 2];
+        const c = planes[plane_address + 3];
+
+        const distance_to_plane = computePointDistanceToPlane(x, y, z, nx, ny, nz, c);
+
+        if (distance_to_plane < -EPSILON) {
+            // point is outside of one of the planes
+            return false;
+        }
+    }
+
+    return true;
+}

package/core/geom/3d/topology/bounds/{computeTraingleClusterNormalBoundingCone.js → computeTriangleClusterNormalBoundingCone.js}

@@ -11,7 +11,7 @@ import { v3_angle_between } from "../../../v3_angle_between.js";
  * @param {ConicRay} result
  * @param {Iterable<TopoTriangle>} faces
  */
-export function computeTraingleClusterNormalBoundingCone(result, faces) {
+export function computeTriangleClusterNormalBoundingCone(result, faces) {
     const normal_data = [];
     let normal_count = 0;
 
@@ -45,6 +45,13 @@ export function computeTraingleClusterNormalBoundingCone(result, faces) {
 
     const miniball_center = miniball.center();
 
+    if (Number.isNaN(miniball_center[0]) || Number.isNaN(miniball_center[1]) || Number.isNaN(miniball_center[2])) {
+        // something went wrong, center is undefined, fall-back to an open cone
+        result_direction.set(1, 0, 0);
+        result.angle = Math.PI;
+        return;
+    }
+
     result_direction.readFromArray(miniball_center, 0);
     const center_vector_magnitude = result_direction.length();
 

package/core/geom/Vector3.d.ts

@@ -13,6 +13,10 @@ export default class Vector3 implements Vector3Like {
     y: number
     z: number
 
+    0: number
+    1: number
+    2: number
+
     public readonly onChanged: Signal<number, number, number, number, number, number>;
 
     constructor()
@@ -87,6 +91,10 @@ export default class Vector3 implements Vector3Like {
 
     writeToArray(array: number[] | ArrayLike<number>, offset: number): void
 
+    static distance(a: Vector3Like, b: Vector3Like): number
+
+    static dot(a: Vector3Like, b: Vector3Like): number
+
     static readonly zero: Vector3
     static readonly one: Vector3
     static readonly up: Vector3

package/editor/actions/concrete/ActionUpdateTexture.js

@@ -0,0 +1,21 @@
+import { Action } from "../../../core/process/undo/Action.js";
+
+export class ActionUpdateTexture extends Action {
+    /**
+     *
+     * @param {THREE.Texture} texture
+     */
+    constructor(texture) {
+        super();
+
+        this.__texture = texture;
+    }
+
+    async apply(context) {
+        this.__texture.needsUpdate = true;
+    }
+
+    async revert(context) {
+        this.__texture.needsUpdate = true;
+    }
+}

package/editor/actions/concrete/ArrayCopyAction.js

@@ -0,0 +1,39 @@
+import { Action } from "../../../core/process/undo/Action.js";
+import { array_copy } from "../../../core/collection/array/copyArray.js";
+
+export class ArrayCopyAction extends Action {
+    /**
+     * @template T
+     * @param {ArrayLike<T>|T[]|Uint8Array|Float32Array} source
+     * @param {ArrayLike<T>|T[]|Uint8Array|Float32Array} destination
+     */
+    constructor(source, destination) {
+        super();
+
+        this.__source = source;
+        this.__destination = destination;
+
+        /**
+         *
+         * @type {ArrayLike<T>|null}
+         * @private
+         */
+        this.__restore_value = null;
+    }
+
+    async apply(context) {
+
+        const CTOR = Object.getPrototypeOf(this.__destination).constructor;
+        this.__restore_value = new CTOR(this.__destination.length);
+
+        // remember old value
+        array_copy(this.__destination, 0, this.__restore_value, 0, this.__destination.length);
+
+        // copy data across
+        array_copy(this.__source, 0, this.__destination, 0, this.__source.length);
+    }
+
+    async revert(context) {
+        array_copy(this.__restore_value, 0, this.__destination, 0, this.__restore_value.length);
+    }
+}

package/editor/actions/concrete/ModifyPatchTextureArray2DAction.js

@@ -0,0 +1,182 @@
+import { Action } from "../../../core/process/undo/Action.js";
+import { assert } from "../../../core/assert.js";
+import { texture_array_2d_copy } from "../../../engine/graphics/texture/texture_array_2d_copy.js";
+import { clamp } from "../../../core/math/clamp.js";
+
+export class ModifyPatchTextureArray2DAction extends Action {
+    /**
+     *
+     * @param {number[]|Uint8Array|Uint32Array|Float32Array} data
+     * @param {number[]} data_resolution
+     * @param {number[]} bounds
+     */
+    constructor(data, data_resolution, bounds) {
+        super();
+
+        assert.isArrayLike(data, 'data');
+
+        this.__data = data;
+        this.__data_resolution = data_resolution;
+        this.__bounds = bounds;
+
+
+        const width = this.__bounds[2] - this.__bounds[0];
+        const height = this.__bounds[3] - this.__bounds[1];
+
+        const depth = data_resolution[2];
+
+        const CTOR = Object.getPrototypeOf(data).constructor;
+
+        /**
+         * @type {ArrayLike<number>}
+         * @private
+         */
+        this.__patch_new = new CTOR(height * width * depth);
+        /**
+         * @type {ArrayLike<number>}
+         * @private
+         */
+        this.__patch_old = new CTOR(height * width * depth);
+    }
+
+    /**
+     *
+     * @param {number} center_x
+     * @param {number} center_y
+     * @param {Sampler2D} stamp
+     * @param {number} layer_index
+     * @param {number} weight
+     * @param {number} clamp_min
+     * @param {number} clamp_max
+     */
+    applyWeightStampToLayer(
+        center_x, center_y,
+        stamp, layer_index, weight,
+        clamp_min = Number.NEGATIVE_INFINITY, clamp_max = Number.POSITIVE_INFINITY
+    ) {
+
+        const bounds_x0 = this.__bounds[0];
+        const bounds_y0 = this.__bounds[1];
+
+        const bounds_x1 = this.__bounds[2];
+        const bounds_y1 = this.__bounds[3];
+
+        const width = bounds_x1 - bounds_x0;
+        const height = bounds_y1 - bounds_y0;
+
+        const center_offset_x = (bounds_x0 + bounds_x1) * 0.5 - center_x;
+        const center_offset_y = (bounds_y0 + bounds_y1) * 0.5 - center_y;
+
+        const source_data = this.__data;
+
+        const source_width = this.__data_resolution[0];
+        const source_height = this.__data_resolution[1];
+        const depth = this.__data_resolution[2];
+
+        for (let y = 0; y < height; y++) {
+            const marker_v = (y + center_offset_y) / (height - 1);
+
+            for (let x = 0; x < width; x++) {
+                const marker_u = (x + center_offset_x) / (width - 1);
+
+                const stamp_value = stamp.sampleChannelBilinearUV(marker_u, marker_v, 3);
+
+                if (Number.isNaN(stamp_value)) {
+                    continue;
+                }
+
+                const weighed_stamp_value = stamp_value * weight;
+
+                const source_x = (x + bounds_x0);
+                const source_y = (y + bounds_y0);
+
+                const weight_reciprocal = weighed_stamp_value / (depth - 1);
+
+                for (let i = 0; i < depth; i++) {
+                    const source_layer_address = source_width * source_height * i;
+                    const source_texel_address = source_layer_address + source_y * source_width + source_x;
+
+                    const destination_texel_address = width * height * i + y * width + x;
+
+                    const source_value = source_data[source_texel_address];
+
+                    let destination_value;
+                    if (i === layer_index) {
+                        // the channel that we are stamping
+                        destination_value = source_value + weighed_stamp_value;
+                    } else {
+                        destination_value = source_value - weight_reciprocal;
+                    }
+
+                    this.__patch_new[destination_texel_address] = clamp(destination_value, clamp_min, clamp_max);
+                }
+            }
+        }
+    }
+
+    get patch_data() {
+        return this.__patch_new;
+    }
+
+    computeByteSize() {
+        // TODO take size of array elements into account
+        return this.__patch_new.length + this.__patch_old.length + 280;
+    }
+
+    async apply(context) {
+        const data = this.__data;
+
+        const depth = this.__data_resolution[2];
+
+        const bounds_x0 = this.__bounds[0];
+        const bounds_y0 = this.__bounds[1];
+
+        const bounds_x1 = this.__bounds[2];
+        const bounds_y1 = this.__bounds[3];
+
+        const width = bounds_x1 - bounds_x0;
+        const height = bounds_y1 - bounds_y0;
+
+        const source_resolution_x = this.__data_resolution[0];
+        const source_resolution_y = this.__data_resolution[1];
+
+        // store old data
+        texture_array_2d_copy(
+            data, bounds_x0, bounds_y0, source_resolution_x, source_resolution_y,
+            this.__patch_old, 0, 0, width, height,
+            width, height, depth
+        );
+
+        texture_array_2d_copy(
+            this.__patch_new, 0, 0, width, height,
+            data, bounds_x0, bounds_y0, source_resolution_x, source_resolution_y,
+            width, height, depth
+        );
+
+    }
+
+    async revert(context) {
+
+        const data = this.__data;
+
+        const depth = this.__data_resolution[2];
+
+        const bounds_x0 = this.__bounds[0];
+        const bounds_y0 = this.__bounds[1];
+
+        const bounds_x1 = this.__bounds[2];
+        const bounds_y1 = this.__bounds[3];
+
+        const width = bounds_x1 - bounds_x0;
+        const height = bounds_y1 - bounds_y0;
+
+        const source_resolution_x = this.__data_resolution[0];
+        const source_resolution_y = this.__data_resolution[1];
+
+        texture_array_2d_copy(
+            this.__patch_old, 0, 0, width, height,
+            data, bounds_x0, bounds_y0, source_resolution_x, source_resolution_y,
+            width, height, depth
+        );
+    }
+}

package/editor/enableEditor.js

@@ -5,14 +5,14 @@ import { noop } from "../core/function/Functions.js";
  *
  * @param {Engine} engine
  * @param {function(Editor):*} [initialization]
+ * @returns {{enable:function, disable: function, toggle: function, editor: Editor}}
  */
 export function enableEditor(engine, initialization = noop) {
     let editor = null;
 
     let enabled = false;
 
-    function attachEditor() {
-        console.log('Enabling editor');
+    function ensureEditor() {
         if (editor === null) {
             editor = new Editor();
             editor.engine = engine;
@@ -21,11 +21,28 @@ export function enableEditor(engine, initialization = noop) {
 
             initialization(editor);
         }
+
+        return editor;
+    }
+
+    function attachEditor() {
+        if (enabled) {
+            return;
+        }
+
+        console.log('Enabling editor');
+
+        ensureEditor();
+
         editor.attach(engine);
         enabled = true;
     }
 
     function detachEditor() {
+        if (!enabled) {
+            return;
+        }
+
         console.log('Disabling editor');
         if (editor !== null) {
             editor.detach();
@@ -54,4 +71,15 @@ export function enableEditor(engine, initialization = noop) {
     });
 
     console.warn('Editor mode enabled, use NumLock key to toggle editor mode');
+
+    return {
+        toggle: toggleEditor,
+        enable: attachEditor,
+        disable: detachEditor,
+        get editor() {
+            ensureEditor();
+
+            return editor;
+        }
+    }
 }

package/editor/tools/paint/TerrainPaintTool.js

@@ -31,13 +31,16 @@ export class TerrainPaintTool extends Tool {
         this.__brushPosition = new Vector2();
 
         this.__brushImage = document.createElement('canvas');
+
+        this.__paint_debt = 0;
+        this.__paint_pending = false;
     }
 
     /**
      *
      * @param {number} timeDelta
      */
-    paint(timeDelta) {
+    async paint(timeDelta) {
 
     }
 
@@ -46,14 +49,25 @@ export class TerrainPaintTool extends Tool {
      * @param {number} timeDelta
      */
     update(timeDelta) {
-
         this.updateBrushPosition();
         this.updateOverlay();
 
         if (this.isRunning()) {
 
-            this.paint(timeDelta);
+            this.__paint_debt += timeDelta;
+
+            if (this.__paint_pending) {
+                return;
+            }
+
+            this.__paint_pending = true;
+
+            const paint_promise = this.paint(timeDelta);
+            this.__paint_debt = 0;
 
+            paint_promise.finally(() => {
+                this.__paint_pending = false;
+            });
         }
 
     }
@@ -156,6 +170,8 @@ export class TerrainPaintTool extends Tool {
         const engine = this.engine;
         const editor = this.editor;
 
+        this.__paint_debt = 0;
+
         this.terrain = obtainTerrain(engine.entityManager.dataset, (t, entity) => {
             this.terrainEntity = entity;
         });