@woosh/meep-engine 2.48.13 → 2.48.14

package/src/engine/ecs/foliage/ecs/Foliage2System.js

@@ -38,12 +38,14 @@ export function loadFoliageLayer(layer, assetManager) {
             reject(`Undetermined asset type for url='${modelURL}'`);
         }
 
-        assetManager.get(modelURL, assetType, function (asset) {
-            const mesh = asset.create();
-            instancedFoliage.setInstance(mesh.geometry, mesh.material);
+        assetManager.get({
+            path: modelURL, type: assetType, callback: function (asset) {
+                const mesh = asset.create();
+                instancedFoliage.setInstance(mesh.geometry, mesh.material);
 
-            resolve();
-        }, reject);
+                resolve();
+            }, failure: reject
+        });
     });
 
     const result = mesh.then(function () {

package/src/engine/ecs/sockets/serialization/AttachmentSocketsAssetLoader.js

@@ -4,9 +4,9 @@ import { AttachmentSockets } from "../AttachmentSockets.js";
 import { Asset } from "../../../asset/Asset.js";
 
 export class AttachmentSocketsAssetLoader extends AssetLoader {
-    load(path, success, failure, progress) {
+    load(scope, path, success, failure, progress) {
 
-        this.assetManager.promise(path, GameAssetType.JSON)
+        this.assetManager.promise(path, GameAssetType.JSON, { scope })
             .then(asset => {
 
                 const json = asset.create();

package/src/engine/ecs/terrain/ecs/PromiseSamplerHeight.js

@@ -41,19 +41,26 @@ export function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
             fulfill(defaultSampler);
         } else if (heightMapURL.endsWith('.bin')) {
             //load texture from a binary file
-            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
+            assetManager.get({
+                path: heightMapURL,
+                type: GameAssetType.ArrayBuffer,
+                callback: assetObtained,
+                failure: reject
+            });
         } else {
-            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
-                const image = asset.create();
+            assetManager.get({
+                path: heightMapURL, type: GameAssetType.Image, callback: function (asset) {
+                    const image = asset.create();
 
-                // plane
-                const imgWidth = image.width;
-                const imgHeight = image.height;
+                    // plane
+                    const imgWidth = image.width;
+                    const imgHeight = image.height;
 
-                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
+                    const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
 
-                fulfill(samplerHeight);
-            }, reject);
+                    fulfill(samplerHeight);
+                }, failure: reject
+            });
         }
     });
 }

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/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/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);
     }
@@ -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;
             }
 
 

package/src/engine/graphics/texture/virtual/tile/TileLoader.js

@@ -147,7 +147,7 @@ export class TileLoader {
         }
 
         //do load
-        this.assetManager.get('image', url, success, failure);
+        this.assetManager.get({ path: 'image', type: url, callback: success, failure: failure });
     }
 
     /**

package/src/engine/graphics/trail/x/RibbonXPlugin.js

@@ -115,9 +115,11 @@ export class RibbonXPlugin extends EnginePlugin {
         if (spec.diffuse !== null) {
             const am = this.engine.assetManager;
 
-            am.get(spec.diffuse, GameAssetType.Texture, (asset) => {
-                material.uniforms.uDiffuse.value = asset.create();
-            }, console.warn);
+            am.get({
+                path: spec.diffuse, type: GameAssetType.Texture, callback: (asset) => {
+                    material.uniforms.uDiffuse.value = asset.create();
+                }, failure: console.warn
+            });
 
             material.defines.USE_TEXTURE = true;
         }

package/src/engine/knowledge/database/StaticKnowledgeDataTable.js

@@ -116,7 +116,7 @@ export class StaticKnowledgeDataTable {
      * @returns {T|null}
      */
     get(id) {
-        assert.typeOf(id, 'string', 'id');
+        assert.isString(id, 'id');
 
         const element = this.elements[id];
 

package/src/engine/sound/ecs/emitter/loadSoundTrackAsset.js

@@ -37,5 +37,5 @@ export function loadSoundTrackAsset(track, assetManager, resolve = noop, reject
         asset_path = track_url;
     }
 
-    assetManager.get(asset_path, GameAssetType.Sound, resolve, reject);
+    assetManager.get({ path: asset_path, type: GameAssetType.Sound, callback: resolve, failure: reject });
 }