@woosh/meep-engine 2.48.11 → 2.48.13

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