@woosh/meep-engine 2.48.12 → 2.48.14

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.js

@@ -99,13 +99,10 @@ class ClingToTerrainSystem extends System {
      * @param {int} entityId
      */
     link(cling, transform, entityId) {
-        const self = this;
 
-        function update() {
-            self.requestUpdate(entityId);
-        }
+        const update = () => this.requestUpdate(entityId);
 
-        self.data[entityId] = {
+        this.data[entityId] = {
             update,
             transform,
             component: cling
@@ -139,21 +136,6 @@ class ClingToTerrainSystem extends System {
         this.updateQueue.remove(entityId);
     }
 
-    reset() {
-        this.updateQueue.clear();
-
-        const data = this.data;
-        for (let entity in data) {
-            if (!data.hasOwnProperty(entity)) {
-                continue;
-            }
-            const datum = data[entity];
-            deregister(datum);
-        }
-
-        this.data = [];
-    }
-
     update(timeDelta) {
         const em = this.entityManager;
 
@@ -192,7 +174,7 @@ class ClingToTerrainSystem extends System {
                     the entity is gone
                  */
 
-                console.warn("ClingToTerrain component was in the update queue, but no data found. Skipping");
+                //console.warn("ClingToTerrain component was in the update queue, but no data found. Skipping");
                 continue;
             }
 

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -20,7 +20,7 @@ export class SplatMapping {
          * How large is the map
          * @type {Vector2}
          */
-        this.size = new Vector2(512, 512);
+        this.size = new Vector2(1, 1);
 
         /**
          *
@@ -475,8 +475,9 @@ export class SplatMapping {
      * @param {number} width
      * @param {number} height
      * @param {number} depth
+     * @param {boolean} [keep_data]
      */
-    resize(width, height, depth) {
+    resize(width, height, depth, keep_data = true) {
         const oldWidth = this.size.x;
         const oldHeight = this.size.y;
         const oldDepth = this.depth;
@@ -506,19 +507,23 @@ export class SplatMapping {
             weightImage.depth = depth;
             weightImage.data = new Uint8Array(newLayerSize * depth);
 
-            if (oldWidth === width && oldHeight === height) {
-                // dimensions haven't changed, we can copy data directly
-                typed_array_copy(oldWeightData, weightImage.data);
-            } else {
+            if (keep_data) {
 
-                // different dimensions, copy layer-by-layer
-                for (let d = 0; d < min2(depth, oldDepth); d++) {
+                if (oldWidth === width && oldHeight === height) {
+                    // dimensions haven't changed, we can copy data directly
+                    typed_array_copy(oldWeightData, weightImage.data);
+                } else {
 
-                    const source = new Sampler2D(oldWeightData.subarray(d * oldLayerSize, (d + 1) * oldLayerSize), 1, oldWidth, oldHeight);
-                    const target = new Sampler2D(weightImage.data.subarray(d * newLayerSize, (d + 1) * newLayerSize), 1, width, height);
+                    // different dimensions, copy layer-by-layer
+                    for (let d = 0; d < min2(depth, oldDepth); d++) {
 
-                    scaleSampler2D(source, target);
+                        const source = new Sampler2D(oldWeightData.subarray(d * oldLayerSize, (d + 1) * oldLayerSize), 1, oldWidth, oldHeight);
+                        const target = new Sampler2D(weightImage.data.subarray(d * newLayerSize, (d + 1) * newLayerSize), 1, width, height);
+
+                        scaleSampler2D(source, target);
+                    }
                 }
+
             }
 
             weightTexture.needsUpdate = true;

package/src/engine/ecs/terrain/serialization/TerrainSerializationAdapter.js

@@ -164,7 +164,7 @@ export class TerrainSerializationAdapter extends BinaryClassSerializationAdapter
         const splat_size_x = buffer.readUintVar();
         const splat_size_y = buffer.readUintVar();
 
-        value.splat.resize(splat_size_x, splat_size_y, layer_count);
+        value.splat.resize(splat_size_x, splat_size_y, layer_count, false);
 
         const weightData = value.splat.weightData;
 

package/src/engine/graphics/ecs/animation/animator/graph/definition/serialization/AnimationGraphDefinitionAssetLoader.js

@@ -4,25 +4,28 @@ import { Asset } from "../../../../../../../asset/Asset.js";
 import { readAnimationGraphDefinitionFromJSON } from "./readAnimationGraphDefinitionFromJSON.js";
 
 export class AnimationGraphDefinitionAssetLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
 
         this.assetManager.get(
-            path,
-            GameAssetType.JSON,
-            jsonAsset => {
-                const json = jsonAsset.create();
+            {
+                scope: scope,
+                path: path,
+                type: GameAssetType.JSON,
+                callback: jsonAsset => {
+                    const json = jsonAsset.create();
 
-                const asset = new Asset(
-                    () => {
-                        return readAnimationGraphDefinitionFromJSON(json);
-                    },
-                    1
-                );
+                    const asset = new Asset(
+                        () => {
+                            return readAnimationGraphDefinitionFromJSON(json);
+                        },
+                        1
+                    );
 
-                success(asset);
-            },
-            failure,
-             progress
+                    success(asset);
+                },
+                failure: failure,
+                progress: progress
+            }
         );
 
     }

package/src/engine/graphics/ecs/camera/pp/PerfectPanner.js

@@ -80,6 +80,8 @@ export class PerfectPanner {
 
         const ray = make_ray_from_viewport_position(engine, new Vector2(viewport_x, viewport_y));
 
+        // console.log(`Ray origin:${ray.origin}, direction:${ray.direction}`);
+
         this.#camera.rayPlaneIntersection(
             out,
             ray.origin.x, ray.origin.y, ray.origin.z,
@@ -93,7 +95,7 @@ export class PerfectPanner {
      * @param {Vector2} screen_position
      */
     update(screen_position) {
-        //console.log(`PerfectPanner/update: ${screen_position}`)
+        // console.log(`PerfectPanner/update: ${screen_position}`)
 
         const C = this.#grab_world_reference;
         const A = this.#grab_eye_position;
@@ -121,7 +123,7 @@ export class PerfectPanner {
     }
 
     start(screen_position) {
-        //console.log(`PerfectPanner/start: ${screen_position}`)
+        // console.log(`PerfectPanner/start: ${screen_position}`)
 
         // obtain reference point
 

package/src/engine/graphics/ecs/mesh/MeshSystem.js

@@ -427,7 +427,7 @@ export class MeshSystem extends System {
 
             } else {
                 // load the asset
-                am.get(component.url, assetType, assetLoaded, assetFailure);
+                am.get({ path: component.url, type: assetType, callback: assetLoaded, failure: assetFailure });
             }
         }
 

package/src/engine/graphics/ecs/path/tube/build/TubePathBuilder.js

@@ -67,11 +67,13 @@ function make_material(style, am) {
 
         material_def = new MeshMatcapMaterial();
 
-        am.get(style.material.texture, GameAssetType.Texture, asset => {
-            material_def.matcap = asset.create();
+        am.get({
+            path: style.material.texture, type: GameAssetType.Texture, callback: asset => {
+                material_def.matcap = asset.create();
 
-            material_def.needsUpdate = true;
-        }, console.error);
+                material_def.needsUpdate = true;
+            }, failure: console.error
+        });
 
     } else {
         throw new Error(`Unsupported material type '${material_type}'`);

package/src/engine/graphics/material/getTextureImmediate.js

@@ -11,9 +11,11 @@ export function getTextureImmediate(url, assetManager) {
 
     let t;
 
-    assetManager.get(url, GameAssetType.DeferredTexture, function (asset) {
-        t = asset.create();
-    }, noop);
+    assetManager.get({
+        path: url, type: GameAssetType.DeferredTexture, callback: function (asset) {
+            t = asset.create();
+        }, failure: noop
+    });
 
     return t;
 }

package/src/engine/graphics/texture/3d/SingleChannelSampler3D.js

@@ -0,0 +1,146 @@
+import { clamp } from "../../../../core/math/clamp.js";
+import { lerp } from "../../../../core/math/lerp.js";
+
+export class SingleChannelSampler3D {
+
+    data = new Float32Array(0)
+    #resolution = [0, 0, 0]
+
+    set resolution(v) {
+        const width = v[0];
+        const height = v[1];
+        const depth = v[2];
+
+        const old_width = this.#resolution[0];
+        const old_height = this.#resolution[1];
+        const old_depth = this.#resolution[2];
+
+        if (old_width === width && old_height === height && old_depth === depth) {
+            // no change
+            return;
+        }
+
+        this.#resolution[0] = width;
+        this.#resolution[1] = height;
+        this.#resolution[2] = depth
+
+        const new_data_size = width * height * depth;
+
+        if (new_data_size !== old_width * old_height * old_depth) {
+
+            this.data = new Float32Array(new_data_size);
+
+        }
+    }
+
+    get resolution() {
+        return this.#resolution;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} value
+     */
+    write(x, y, z, value) {
+        const resolution = this.#resolution;
+
+        const res_x = resolution[0];
+        const res_y = resolution[1];
+
+        this.data[z * res_y * res_x + y * res_x + x] = value;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    sample_channel_linear(x, y, z) {
+        const resolution = this.#resolution;
+
+        const res_x = resolution[0];
+        const res_y = resolution[1];
+        const res_z = resolution[2];
+
+        const x_max = res_x - 1;
+        const y_max = res_y - 1;
+        const z_max = res_z - 1;
+
+        const x_clamped = clamp(x, 0, x_max);
+        const y_clamped = clamp(y, 0, y_max);
+        const z_clamped = clamp(z, 0, z_max);
+
+        const x0 = x_clamped | 0;
+        const y0 = y_clamped | 0;
+        const z0 = z_clamped | 0;
+
+        const f_x = x_clamped - x0;
+        const f_y = y_clamped - y0;
+        const f_z = z_clamped - z0;
+
+        const x1 = x_clamped === x0 ? x0 : x0 + 1;
+        const y1 = y_clamped === y0 ? y0 : y0 + 1;
+        const z1 = z_clamped === z0 ? z0 : z0 + 1;
+
+        // get 8 points
+        const data = this.data;
+
+        const z0_offset = z0 * (res_x * res_y);
+
+        const y0_offset = y0 * res_x;
+
+        const x0_offset = x0;
+        const x1_offset = x1;
+
+        const x0y0z0 = data[z0_offset + y0_offset + x0_offset];
+        const x1y0z0 = data[z0_offset + y0_offset + x1_offset];
+
+        const y1_offset = y1 * res_x;
+
+        const x0y1z0 = data[z0_offset + y1_offset + x0_offset];
+        const x1y1z0 = data[z0_offset + y1_offset + x1_offset];
+
+        const z1_offset = z1 * (res_x * res_y);
+
+        const x0y0z1 = data[z1_offset + y0_offset + x0_offset];
+        const x1y0z1 = data[z1_offset + y0_offset + x1_offset];
+
+        const x0y1z1 = data[z1_offset + y1_offset + x0_offset];
+        const x1y1z1 = data[z1_offset + y1_offset + x1_offset];
+
+        // filter on z0
+        const lerp_z0_y0 = lerp(x0y0z0, x1y0z0, f_x);
+        const lerp_z0_y1 = lerp(x0y1z0, x1y1z0, f_x);
+        const lerp_z0 = lerp(lerp_z0_y0, lerp_z0_y1, f_y);
+
+        // filter on z1
+        const lerp_z1_y0 = lerp(x0y0z1, x1y0z1, f_x);
+        const lerp_z1_y1 = lerp(x0y1z1, x1y1z1, f_x);
+        const lerp_z1 = lerp(lerp_z1_y0, lerp_z1_y1, f_y);
+
+        return lerp(lerp_z0, lerp_z1, f_z);
+    }
+
+    /**
+     *
+     * @param {SingleChannelSampler3D} other
+     */
+    copy(other) {
+        this.resolution = other.#resolution;
+
+        this.data.set(other.data);
+    }
+
+    clone() {
+        const r = new SingleChannelSampler3D();
+
+        r.copy(this);
+
+        return r;
+    }
+}

package/src/engine/graphics/texture/3d/scs3d_read_2d_slice.js

@@ -0,0 +1,26 @@
+import { array_copy } from "../../../../core/collection/array/copyArray.js";
+
+/**
+ *
+ * @param {SingleChannelSampler3D} source
+ * @param {Sampler2D} output
+ * @param {number} z_index
+ */
+export function scs3d_read_2d_slice(source, output, z_index) {
+    const source_resolution = source.resolution;
+
+    const source_width = source_resolution[0];
+    const source_height = source_resolution[1];
+
+    if (source_width !== output.width || source_height !== output.height) {
+        throw new Error('Incompatible resolutions');
+    }
+
+    if (output.itemSize !== 1) {
+        throw new Error(`Expected output to have 1 channel, instead got ${output.itemSize}`);
+    }
+
+    const slice_size = source_width * source_height;
+
+    array_copy(source.data, slice_size * z_index, output.data, 0, slice_size);
+}

package/src/engine/graphics/texture/atlas/ManagedTextureAtlas.js

@@ -161,7 +161,7 @@ export class ManagedAtlas {
 
                 counterLoadingAssets++;
 
-                assetManager.get(url, GameAssetType.Image, onLoad, onFailure);
+                assetManager.get({ path: url, type: GameAssetType.Image, callback: onLoad, failure: onFailure });
 
             });
         }

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

@@ -192,8 +192,8 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelCatmullRomUV(u, v, channel) {
-        const x = u * (this.width - 1);
-        const y = v * (this.height - 1);
+        const x = u * (this.width) - 0.5;
+        const y = v * (this.height) - 0.5;
 
         return this.sampleChannelCatmullRom(x, y, channel);
     }
@@ -210,8 +210,8 @@ export class Sampler2D {
         // We're going to sample a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
         // down the sample location to get the exact center of our "starting" texel. The starting texel will be at
         // location [1, 1] in the grid, where [0, 0] is the top-left corner.
-        const texPos1_x = Math.floor(x - 0.5) + 0.5;
-        const texPos1_y = Math.floor(y - 0.5) + 0.5;
+        const texPos1_x = Math.floor(x);
+        const texPos1_y = Math.floor(y);
 
         // Compute the fractional offset from our starting texel to our original sample location, which we'll
         // feed into the Catmull-Rom spline function to get our filter weights.
@@ -287,8 +287,8 @@ export class Sampler2D {
      * @returns {number}
      */
     sampleChannelBicubicUV(u, v, channel) {
-        const x = u * (this.width - 1);
-        const y = v * (this.height - 1);
+        const x = u * (this.width);
+        const y = v * (this.height);
 
         return this.sampleChannelBicubic(x - 0.5, y - 0.5, channel);
     }
@@ -432,8 +432,8 @@ export class Sampler2D {
      * @return {number}
      */
     sampleChannelBilinearUV(u, v, channel) {
-        const x = u * (this.width - 1);
-        const y = v * (this.height - 1);
+        const x = u * this.width - 0.5;
+        const y = v * this.height - 0.5;
 
         return this.sampleChannelBilinear(x, y, channel);
     }
@@ -474,14 +474,14 @@ export class Sampler2D {
         //
         let x1, y1;
 
-        if (clamped_x === x0 || x0 >= x_max) {
+        if (clamped_x === x0) {
             x1 = x0;
         } else {
             x1 = x0 + 1;
         }
 
 
-        if (clamped_y === y0 || y0 >= y_max) {
+        if (clamped_y === y0) {
             y1 = y0;
         } else {
             y1 = y0 + 1;
@@ -519,11 +519,20 @@ export class Sampler2D {
         return mix(s0, s1, yd);
     }
 
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {ArrayLike<number>} result
+     */
     sampleNearestUV(u, v, result) {
-        const x = Math.round(u * (this.width - 1));
-        const y = Math.round(v * (this.height - 1));
+        const w = this.width;
+        const h = this.height;
+
+        const x = Math.round(u * w - 0.5);
+        const y = Math.round(v * h - 0.5);
 
-        this.read(min2(x, this.width - 1), min2(y, this.height - 1), result);
+        this.read(clamp(x, 0, w - 1), clamp(y, 0, h - 1), result);
     }
 
     /**

package/src/engine/graphics/texture/sampler/filter/box.js

@@ -4,13 +4,13 @@
  * @returns {number}
  */
 export function box(x) {
-    if (x < -0.5) {
+    if (x < -1) {
         return 0;
     }
-    if (x <= 0.5) {
+    if (x <= 1) {
         return 1;
     }
     return 0;
 }
 
-box.support = 0.5;
+box.support = 1;

package/src/engine/graphics/texture/sampler/filter/kaiser_bessel_window.js

@@ -3,6 +3,7 @@ import { clamp } from "../../../../../core/math/clamp.js";
 
 const PI3 = 3.0 * Math.PI;
 const BESSEL_3_PI_3 = bessel_3(PI3);
+const INV_BESSEL_3_PI_3 = 1 / BESSEL_3_PI_3;
 
 /**
  *
@@ -13,7 +14,7 @@ const BESSEL_3_PI_3 = bessel_3(PI3);
 export function kaiser_bessel_window(x) {
     const i = clamp(x * 0.6666666666666666, -1.0, 1.0);
     const t = Math.sqrt(1.0 - i * i);
-    return bessel_3(PI3 * t) / BESSEL_3_PI_3;
+    return bessel_3(PI3 * t) * INV_BESSEL_3_PI_3;
 }
 
 kaiser_bessel_window.support = 2;

package/src/engine/graphics/texture/sampler/genericResampleSampler2D.js

@@ -18,6 +18,7 @@ export function genericResampleSampler2D(source, target) {
     const kernel_height = max2(1, Math.ceil(v_scale));
 
     const kernel_size = kernel_width * kernel_height;
+    const kernel_size_inv = 1 / kernel_size;
 
     const itemSize = source.itemSize;
 
@@ -30,16 +31,15 @@ export function genericResampleSampler2D(source, target) {
     let i;
 
     for (column_index = 0; column_index < target_height; column_index++) {
+
+        const source_y = column_index * v_scale;
+
         for (row_index = 0; row_index < target_width; row_index++) {
 
             // figure out source offset
             const source_x = row_index * u_scale;
-            const source_y = column_index * v_scale;
 
-            // reset sample
-            for (i = 0; i < itemSize; i++) {
-                sample[i] = 0;
-            }
+            const output_texel_address = (column_index * target_width + row_index) * itemSize;
 
             // accumulate kernel samples
             for (k_y = 0; k_y < kernel_height; k_y++) {
@@ -55,9 +55,10 @@ export function genericResampleSampler2D(source, target) {
 
             for (i = 0; i < itemSize; i++) {
                 // dilute sample
-                const channel_value = sample[i] / kernel_size;
-                // write out
-                target.data[(column_index * target_width + row_index) * itemSize + i] = channel_value;
+                target.data[output_texel_address + i] = sample[i] * kernel_size_inv;
+
+                //reset sample
+                sample[i] = 0;
             }
 
         }

package/src/engine/graphics/texture/sampler/loadSampler2D.js

@@ -13,24 +13,26 @@ import { GameAssetType } from "../../../asset/GameAssetType.js";
  */
 export default function loadSampler2D(url, assetManager) {
     return new Promise(function (resolve, reject) {
-        assetManager.get(url, GameAssetType.Image, (asset) => {
-            const imageData = asset.create();
+        assetManager.get({
+            path: url, type: GameAssetType.Image, callback: (asset) => {
+                const imageData = asset.create();
 
-            const width = imageData.width;
-            const height = imageData.height;
+                const width = imageData.width;
+                const height = imageData.height;
 
-            const data = imageData.data;
+                const data = imageData.data;
 
-            //
-            const bufferSize = width * height;
-            const buffer = new Float32Array(bufferSize);
-            //
-            for (let i = 0; i < bufferSize; i++) {
-                const j = (i * 4);
-                buffer[i] = (data[j] + data[j + 1] + data[j + 2]) / 765;
-            }
-            const sampler2D = new Sampler2D(buffer, 1, width, height);
-            resolve(sampler2D);
-        }, reject);
+                //
+                const bufferSize = width * height;
+                const buffer = new Float32Array(bufferSize);
+                //
+                for (let i = 0; i < bufferSize; i++) {
+                    const j = (i * 4);
+                    buffer[i] = (data[j] + data[j + 1] + data[j + 2]) / 765;
+                }
+                const sampler2D = new Sampler2D(buffer, 1, width, height);
+                resolve(sampler2D);
+            }, failure: reject
+        });
     });
 };

package/src/engine/graphics/texture/sampler/sampler2d_scale_down_linear.js

@@ -29,13 +29,13 @@ export function sampler2d_scale_down_linear(input, output) {
 
     const itemSize = input.itemSize;
 
-    const sample = new Array(itemSize);
+    const sample = new Float64Array(itemSize);
 
     const sampleSize = sW * sH;
     const sampleSizeInv = 1 / sampleSize;
 
-    const iData = input.data;
-    const oData = output.data;
+    const input_data = input.data;
+    const output_data = output.data;
 
     let i, j, k;
     let x, y;
@@ -50,11 +50,6 @@ export function sampler2d_scale_down_linear(input, output) {
 
             const output_texel_address = row_address + x * itemSize;
 
-            for (i = 0; i < itemSize; i++) {
-                // reset sample
-                sample[i] = 0;
-            }
-
             const sampleOffsetX = x * sW;
 
             // accumulate sample
@@ -67,15 +62,17 @@ export function sampler2d_scale_down_linear(input, output) {
                     const iAddress = (texel_offset + i) * itemSize;
 
                     for (k = 0; k < itemSize; k++) {
-                        sample[k] += iData[k + iAddress];
+                        sample[k] += input_data[k + iAddress];
                     }
 
                 }
             }
 
-            // dilute the sample
             for (i = 0; i < itemSize; i++) {
-                oData[output_texel_address + i] = sample[i] * sampleSizeInv;
+                // dilute the sample
+                output_data[output_texel_address + i] = sample[i] * sampleSizeInv;
+                //reset sample
+                sample[i] = 0;
             }