@woosh/meep-engine 2.39.39 → 2.39.40

package/core/bvh2/bvh3/bvh_query_user_data_nearest_to_point.js

@@ -41,7 +41,7 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
     traversal_stack[traversal_cursor++] = root;
 
     let best_leaf_data = -1;
-    let best_distance = max_distance;
+    let best_distance_sqr = max_distance * max_distance;
 
     while (traversal_cursor > stack_frame_address) {
         traversal_cursor--;
@@ -55,13 +55,13 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
         bvh.node_get_aabb(node, scratch_aabb);
 
         // compute distance to box
-        const distance = max2(0, aabb3_signed_distance_sqr_to_point(
+        const distance_sqr = max2(0, aabb3_signed_distance_sqr_to_point(
             scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
             scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
             x, y, z
         ));
 
-        if (distance > best_distance) {
+        if (distance_sqr > best_distance_sqr) {
             // node is too far
             continue;
         }
@@ -81,8 +81,8 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
         } else {
 
             // leaf node
-            if (distance < best_distance) {
-                best_distance = distance;
+            if (distance_sqr < best_distance_sqr) {
+                best_distance_sqr = distance_sqr;
                 best_leaf_data = bvh.node_get_user_data(node);
             }
 

package/core/bvh2/bvh3/bvh_query_user_data_nearest_to_point.spec.js

@@ -0,0 +1,70 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_user_data_nearest_to_point } from "./bvh_query_user_data_nearest_to_point.js";
+
+/**
+ *
+ * @param {number[]} boxes
+ * @return {ExplicitBinaryBoundingVolumeHierarchy}
+ */
+function makeBvh(...boxes) {
+    const r = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    for (let i = 0; i < boxes.length; i++) {
+        const box = boxes[i];
+
+        const node = r.allocate_node();
+
+        r.node_set_aabb(node, box);
+        r.node_set_user_data(node, i);
+
+        r.insert_leaf(node);
+    }
+
+    return r;
+}
+
+test('no data, infinite distance', () => {
+    const bvh = makeBvh();
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, Infinity);
+
+    expect(result).toBe(-1);
+});
+
+test('single point, distance too short', () => {
+    const bvh = makeBvh([1, 0, 0, 1, 0, 0]);
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 0.5);
+
+    expect(result).toBe(-1);
+});
+
+test('single point, distance sufficient', () => {
+    const bvh = makeBvh([1, 0, 0, 1, 0, 0]);
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 1.5);
+
+    expect(result).not.toBe(-1);
+});
+
+test('two point, distance sufficient to one', () => {
+    const bvh = makeBvh(
+        [1, 0, 0, 1, 0, 0],
+        [2, 0, 0, 2, 0, 0],
+    );
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 1.5);
+
+    expect(result).toBe(0);
+});
+
+test('two point, distance sufficient to both', () => {
+    const bvh = makeBvh(
+        [1, 0, 0, 1, 0, 0],
+        [2, 0, 0, 2, 0, 0],
+    );
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 2.5);
+
+    expect(result).toBe(0);
+});

package/editor/ecs/component/editors/ecs/terrain/TerrainEditor.js

@@ -27,20 +27,26 @@ export class TerrainEditor extends ObjectEditor {
 
             // splats
             view.bindSignal(terrain.layers.layers.on.added, () => {
-                terrain.splat.addWeightLayer();
-                updateLayers();
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.addWeightLayer();
+                    updateLayers();
+                }
             });
             view.bindSignal(terrain.layers.layers.on.removed, (a, index) => {
-                terrain.splat.removeWeightLayer(index);
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.removeWeightLayer(index);
 
-                updateLayers();
+                    updateLayers();
+                }
             });
 
             // mapping sizes
             view.bindSignal(terrain.splat.size.onChanged, (x, y) => {
-                terrain.splat.resize(x, y, terrain.splat.depth);
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.resize(x, y, terrain.splat.depth);
 
-                terrain.updateMaterial();
+                    terrain.updateMaterial();
+                }
             });
         }
 

package/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -390,16 +390,18 @@ export class TerrainLayers {
 
         const resolution = this.resolution;
 
-        const singleLayerByteSize = resolution.x * resolution.y * 3;
+        const single_layer_byte_size = resolution.x * resolution.y * 3;
 
-        if (arrayData.length < singleLayerByteSize * index) {
+        if (arrayData.length < single_layer_byte_size * index) {
             throw new Error('Texture data is too small, make sure you rebuild texture data before attempting to write');
         }
 
-        const address = singleLayerByteSize * index;
+        const address = single_layer_byte_size * index;
 
         const sampler = this.__obtain_layer_data_at_resolution(layer, resolution);
 
+        assert.equal(sampler.data.length, single_layer_byte_size, 'Incorrect layer data size');
+
         arrayData.set(sampler.data, address);
 
         //mark texture for update

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -523,6 +523,7 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelBilinear(x, y, channel) {
+        assert.isNonNegativeInteger(channel, 'channel');
 
         const itemSize = this.itemSize;
 
@@ -1477,7 +1478,7 @@ export class Sampler2D {
 
             this.data = new CTOR(data);
 
-        }else{
+        } else {
 
             throw new Error('Unsupported data format');
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.39.39",
+  "version": "2.39.40",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",