@woosh/meep-engine 2.48.12 → 2.48.13

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/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/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/sampler/Sampler2D.js

@@ -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;

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