@woosh/meep-engine 2.48.12 → 2.48.14

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/physics/fluid/FluidField.js

@@ -1,9 +1,161 @@
+import { clamp } from "../../../core/math/clamp.js";
+import { lerp } from "../../../core/math/lerp.js";
+
+/**
+ *
+ * @param {Float32Array} data
+ * @param {number[]} resolution
+ */
+function v3_grid_apply_advection_forward(data, resolution) {
+
+}
+
+/**
+ *
+ * @param {Float32Array} data
+ * @param {number[]} resolution
+ */
+function v3_grid_apply_advection_reverse(data, resolution) {
+
+}
+
 /**
  * Represents a space where fluid simulation happens
  *
  * @see 2019 GDC talk by Runard Rupert "Wind Simulation in God of War" https://www.youtube.com/watch?v=dDgyBKkSf7A
  * @see Inspired by GDC talk "Interactive Wind and Vegetation in 'God of War'" - https://www.youtube.com/watch?v=MKX45_riWQA
  */
-export class FluidField{
+export class FluidField {
+    data = new Float32Array(0)
+    #size = [0, 0, 0]
+    #resolution = [0, 0, 0]
+
+
+    build() {
+        this.data = new Float32Array(
+            this.#resolution[0] * this.#resolution[1] * this.#resolution[2] * 3
+        );
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} u
+     * @param {number} v
+     * @param {number} w
+     */
+    sample_linear_uv(out, u, v, w) {
+        const max_x = this.#resolution[0] - 1;
+        const max_y = this.#resolution[1] - 1;
+        const max_z = this.#resolution[2] - 1;
+
+        this.sample_linear(out, u * max_x, v * max_y, w * max_z);
+    }
+
+    /**
+     *
+     * @param {number[]} out
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    sample_linear(out, x, y, z) {
+        out[0] = this.sample_channel_linear(x, y, z, 0);
+        out[1] = this.sample_channel_linear(x, y, z, 1);
+        out[2] = this.sample_channel_linear(x, y, z, 2);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} channel
+     * @returns {number}
+     */
+    sample_channel_linear(x, y, z, channel) {
+        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) * 3;
+
+        const y0_offset = y0 * res_x * 3;
+
+        const x0_offset = x0 * 3 + channel;
+        const x1_offset = x1 * 3 + channel;
+
+        const x0y0z0 = data[z0_offset + y0_offset + x0_offset];
+        const x1y0z0 = data[z0_offset + y0_offset + x1_offset];
+
+        const y1_offset = y1 * res_x * 3;
+
+        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) * 3;
+
+        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);
+    }
+
+    set size(v) {
+        const width = v[0];
+        const height = v[1];
+        const depth = v[2];
+
+        this.#size[0] = width;
+        this.#size[1] = height;
+        this.#size[2] = depth
+    }
+
+    set resolution(v) {
+        const width = v[0];
+        const height = v[1];
+        const depth = v[2];
 
+        this.#resolution[0] = width;
+        this.#resolution[1] = height;
+        this.#resolution[2] = depth
+    }
 }

package/src/engine/physics/fluid/prototype.js

@@ -0,0 +1,201 @@
+import { EngineHarness } from "../../EngineHarness.js";
+import { SingleChannelSampler3D } from "../../graphics/texture/3d/SingleChannelSampler3D.js";
+import GUIElementSystem from "../../ecs/gui/GUIElementSystem.js";
+import EntityBuilder from "../../ecs/EntityBuilder.js";
+import GUIElement from "../../ecs/gui/GUIElement.js";
+import EmptyView from "../../../view/elements/EmptyView.js";
+import { Sampler2D } from "../../graphics/texture/sampler/Sampler2D.js";
+import { CanvasView } from "../../../view/elements/CanvasView.js";
+import { float2uint8 } from "../../../core/binary/float2uint8.js";
+import { clamp } from "../../../core/math/clamp.js";
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { BehaviorComponent } from "../../intelligence/behavior/ecs/BehaviorComponent.js";
+import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { v3_grid_apply_diffusion } from "./solver/v3_grid_apply_diffusion.js";
+import { max2 } from "../../../core/math/max2.js";
+import { MetricCollection } from "../../development/performance/MetricCollection.js";
+import { PeriodicConsolePrinter } from "../../development/performance/monitor/PeriodicConsolePrinter.js";
+import { MetricStatistics } from "../../development/performance/MetricStatistics.js";
+
+const harness = new EngineHarness();
+
+class SliceVisualiser extends EmptyView {
+
+    /**
+     *
+     * @param {SingleChannelSampler3D} source
+     */
+    constructor(source) {
+        super({ classList: ['slice-visualizer'] });
+
+        this.source = source;
+
+        const slices = [];
+        const views = [];
+
+        const resolution = source.resolution;
+        const resolution_x = resolution[0];
+        const resolution_y = resolution[1];
+        const resolution_z = resolution[2];
+
+        const slice_size = resolution_x * resolution_y;
+
+        /**
+         *
+         * @type {ImageData|null}
+         */
+        let imageData = null;
+
+        for (let i = 0; i < resolution_z; i++) {
+            slices[i] = new Sampler2D(new Float32Array(source.data.buffer, i * slice_size * 4, slice_size), 1, resolution_x, resolution_y);
+
+            const child = new CanvasView();
+            child.size.set(resolution_x, resolution_y);
+
+            if (imageData === null) {
+                imageData = child.context2d.getImageData(0, 0, resolution_x, resolution_y);
+            }
+
+            child.css({
+                position: "absolute",
+                left: 0,
+                top: 0
+            });
+
+            views[i] = child;
+
+            this.addChild(child);
+        }
+
+        this.draw = () => {
+
+            for (let i = 0; i < resolution_z; i++) {
+                const view = views[i];
+                const slice = slices[i];
+
+                for (let j = 0; j < slice_size; j++) {
+                    const j4 = j * 4;
+
+
+                    const uint8_value = float2uint8(slice.data[j]);
+
+                    imageData.data[j4] = clamp(uint8_value, 0, 255);
+                    imageData.data[j4 + 3] = 255;
+                }
+
+                view.context2d.putImageData(imageData, 0, 0);
+            }
+
+        };
+
+        const layout = () => {
+            const width = this.size.x;
+
+            const grid_width = max2(1, Math.floor(width / resolution_x));
+
+            for (let i = 0; i < resolution_z; i++) {
+                const view = views[i];
+
+                const grid_x = i % grid_width;
+                const grid_y = Math.floor(i / grid_width);
+
+                view.position.set(grid_x * resolution_x, grid_y * resolution_y);
+            }
+        }
+
+        this.on.linked.add(layout);
+        this.size.onChanged.add(layout);
+    }
+
+
+}
+
+const metrics = new MetricCollection();
+
+metrics.create({ name: 'sim' })
+
+/**
+ *
+ * @param {Engine} engine
+ */
+function main(engine) {
+
+    const ecd = engine.entityManager.dataset;
+
+    const sampler = new SingleChannelSampler3D();
+
+    sampler.resolution = [32, 32, 16];
+
+    const random = seededRandom();
+
+    sampler.data.fill(1000, 20, 40);
+
+    for (let i = 0; i < 100; i++) {
+
+        sampler.write(
+            randomIntegerBetween(random, 0, 16),
+            randomIntegerBetween(random, 0, 16),
+            randomIntegerBetween(random, 0, 4),
+            random()
+        );
+
+    }
+
+
+    const slice_view = new SliceVisualiser(sampler);
+
+    slice_view.size.set(432, 1000);
+    slice_view.scale.setScalar(2);
+    slice_view.transformOrigin.set(0, 0);
+
+    const sampler_0 = sampler.clone();
+    const sampler_1 = sampler.clone();
+
+    const ping_pong = [sampler_0, sampler_1];
+    let ping_pong_index = 0;
+
+
+    new EntityBuilder()
+        .add(BehaviorComponent.looping_function(time_delta => {
+
+            const source = ping_pong[ping_pong_index % 2];
+            const target = ping_pong[(ping_pong_index + 1) % 2];
+
+            ping_pong_index++;
+
+            const t0 = performance.now();
+
+            for (let i = 0; i < 5; i++) {
+                v3_grid_apply_diffusion(target.data, source.data, source.resolution);
+            }
+
+            metrics.get('sim').record(performance.now() - t0);
+
+            sampler.copy(target);
+
+            slice_view.draw();
+
+        }))
+        .build(ecd);
+
+    const metric_stats = new MetricStatistics();
+
+    new PeriodicConsolePrinter(3, () => metrics.list().map(m => {
+        metrics.get(m).computeStats(metric_stats);
+
+        return `${m}: ${metric_stats}`;
+    }).join('\n')).start()
+
+    new EntityBuilder()
+        .add(GUIElement.fromView(slice_view))
+        .build(ecd);
+
+}
+
+harness.initialize({
+    configuration(config, engine) {
+        config.addSystem(new GUIElementSystem(engine.gameView, engine))
+        config.addSystem(new BehaviorSystem(engine))
+    }
+}).then(main)

package/src/engine/physics/fluid/solver/v3_grid_apply_diffusion.js

@@ -0,0 +1,67 @@
+/**
+ *
+ * @param {Float32Array} output
+ * @param {Float32Array} input
+ * @param {number[]} resolution
+ */
+export function v3_grid_apply_diffusion(output, input, resolution) {
+    const res_x = resolution[0];
+    const res_y = resolution[1];
+    const res_z = resolution[2];
+
+    const factor = 1 / 7;
+
+    let sum = 0;
+
+    const slice_size = res_y * res_x;
+
+    for (let z = 0; z < res_z; z++) {
+        for (let y = 0; y < res_y; y++) {
+            for (let x = 0; x < res_x; x++) {
+
+                let sample_count = 1;
+
+                sum = 0;
+
+                // sample cells around
+                if (z > 0) {
+                    sample_count++;
+                    sum += input[(z - 1) * slice_size + y * res_x + x]
+                }
+
+                if (y > 0) {
+                    sample_count++;
+                    sum += input[z * slice_size + (y - 1) * res_x + x]
+                }
+
+                if (x > 0) {
+                    sample_count++;
+                    sum += input[z * slice_size + y * res_x + (x - 1)]
+                }
+
+
+                const current = z * slice_size + y * res_x + x;
+
+                sum += input[current];
+
+                if (x < res_x - 1) {
+                    sample_count++;
+                    sum += input[z * slice_size + y * res_x + (x + 1)]
+                }
+
+                if (y < res_y - 1) {
+                    sample_count++;
+                    sum += input[z * slice_size + (y + 1) * res_x + x]
+                }
+
+                if (z < res_z - 1) {
+                    sample_count++;
+                    sum += input[(z + 1) * slice_size + y * res_x + x]
+                }
+
+                output[current] = sum / sample_count;
+
+            }
+        }
+    }
+}

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

package/src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -72,12 +72,20 @@ export class CellFilterGaussianBlur extends CellFilter {
          * @private
          */
         this.__kernel = [];
+
         /**
          *
          * @type {number}
          * @private
          */
         this.__kernel_total_power = 0;
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__inv_kernel_total_power = 0;
     }
 
     initialize(grid, seed) {
@@ -94,6 +102,9 @@ export class CellFilterGaussianBlur extends CellFilter {
         // initialize kernel
         this.__kernel_total_power = buildKernel(this.__kernel, this.samples_x, this.samples_y, this.sigma_x, this.sigma_y);
 
+        // store inverse, to be able to use multiply instead of division in execution
+        this.__inv_kernel_total_power = 1 / this.__kernel_total_power;
+
         super.initialize(grid, seed);
     }
 
@@ -132,8 +143,8 @@ export class CellFilterGaussianBlur extends CellFilter {
         const sizeX = this.size_x;
         const sizeY = this.size_y;
 
-        const local_u_scale = 1 / (samplesX - 1);
-        const local_v_scale = 1 / (samplesY - 1);
+        const local_u_scale = sizeX / (samplesX - 1);
+        const local_v_scale = sizeY / (samplesY - 1);
 
         let sum = 0;
         let ix, iy = 0;
@@ -146,9 +157,7 @@ export class CellFilterGaussianBlur extends CellFilter {
         for (; iy < samplesY; iy++) {
             const local_y = iy - half_samples_y;
 
-            const ny = local_y * local_v_scale;
-
-            const offset_y = sizeY * ny;
+            const offset_y = y + local_y * local_v_scale;
 
             const row_address = iy * i_samples_x;
 
@@ -156,13 +165,11 @@ export class CellFilterGaussianBlur extends CellFilter {
 
                 const local_x = ix - half_samples_x;
 
-                const nx = local_x * local_u_scale;
-
-                const offset_x = sizeX * nx;
+                const offset_x = local_x * local_u_scale;
 
                 const power = kernel[row_address + ix];
 
-                const sourceValue = source.execute(grid, x + offset_x, y + offset_y, 0);
+                const sourceValue = source.execute(grid, x + offset_x, offset_y, 0);
 
                 const sample_contribution = sourceValue * power;
 
@@ -171,8 +178,6 @@ export class CellFilterGaussianBlur extends CellFilter {
             }
         }
 
-        const result = sum / this.__kernel_total_power;
-
-        return result;
+        return sum * this.__inv_kernel_total_power;
     }
 }

package/src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js

@@ -1,10 +1,10 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { CellFilter } from "../../CellFilter.js";
-import SimplexNoise from "simplex-noise";
 import { CellFilterAdd } from "../math/algebra/CellFilterAdd.js";
 import { CellFilterMultiply } from "../math/algebra/CellFilterMultiply.js";
 import { CellFilterLiteralFloat } from "../CellFilterLiteralFloat.js";
 import { CellFilterDivide } from "../math/algebra/CellFilterDivide.js";
+import { createNoise2D } from "../../../../core/math/noise/create_noise_2d.js";
 
 export class CellFilterSimplexNoise extends CellFilter {
     constructor() {
@@ -12,7 +12,7 @@ export class CellFilterSimplexNoise extends CellFilter {
 
         /**
          * @private
-         * @type {SimplexNoise}
+         * @type {function(x:number,y:number):number}
          */
         this.noise = null;
 
@@ -25,6 +25,9 @@ export class CellFilterSimplexNoise extends CellFilter {
         this.scale_x = 1;
         this.scale_y = 1;
 
+        this.inv_scale_x = 1;
+        this.inv_scale_y = 1;
+
         /**
          * RNG Seed offset
          * @type {number}
@@ -50,6 +53,8 @@ export class CellFilterSimplexNoise extends CellFilter {
         let amplitude = 1;
         let totalAmplitude = 0;
 
+        const G = Math.pow(2, -persistence);
+
         for (let i = 0; i < octaves; i++) {
             const noise = CellFilterSimplexNoise.from(scale * frequency, scale * frequency, s);
 
@@ -63,7 +68,7 @@ export class CellFilterSimplexNoise extends CellFilter {
             }
 
             totalAmplitude += amplitude;
-            amplitude *= persistence;
+            amplitude *= G;
             frequency *= lacunarity;
 
             s = (s + 1) * 31;
@@ -95,25 +100,24 @@ export class CellFilterSimplexNoise extends CellFilter {
         r.scale_y = scale_y;
         r.__seed = seed;
 
+        r.inv_scale_x = 1 / scale_x;
+        r.inv_scale_y = 1 / scale_y;
+
         return r;
     }
 
     initialize(grid, seed) {
         this.random.setCurrentSeed(seed + this.__seed);
 
-        const noise = new SimplexNoise(this.random);
-
-        this.noise = noise;
+        this.noise = createNoise2D(this.random);
 
         super.initialize(grid, seed);
     }
 
     execute(grid, x, y, rotation) {
-        const noiseValue = this.noise.noise2D(x / this.scale_x, y / this.scale_y);
+        const noiseValue = this.noise(x * this.inv_scale_x, y * this.inv_scale_y);
 
         //noise function returns values in range [-1,1] we need to scale that to [0,1] range
-        const normalizedValue = (noiseValue + 1) / 2;
-
-        return normalizedValue;
+        return (noiseValue + 1) * 0.5;
     }
 }