@cazala/party 0.1.1 → 0.2.0

package/dist/index.js

@@ -2366,7 +2366,35 @@ fn grid_cell_index(pos: vec2<f32>) -> u32 { let col = i32(floor((pos.x - GRID_MI
 fn grid_cell_index_from_rc(r: i32, c: i32) -> u32 { let rr = max(0, min(r, i32(GRID_ROWS()) - 1)); let cc = max(0, min(c, i32(GRID_COLS()) - 1)); return u32(rr) * GRID_COLS() + u32(cc); }
 struct NeighborIter { cx: i32, cy: i32, r: i32, c: i32, k: u32, reach: i32, maxK: u32, base: u32, emitted: u32, maxEmit: u32 }
 fn neighbor_iter_init(pos: vec2<f32>, radius: f32) -> NeighborIter { let cx = i32(floor((pos.x - GRID_MINX()) / GRID_CELL_SIZE())); let cy = i32(floor((pos.y - GRID_MINY()) / GRID_CELL_SIZE())); let reach = max(1, i32(ceil(radius / GRID_CELL_SIZE()))); var it: NeighborIter; it.cx = cx; it.cy = cy; it.reach = reach; it.r = cy - reach; it.c = cx - reach; let firstCell = grid_cell_index_from_rc(it.r, it.c); let cnt = atomicLoad(&GRID_COUNTS[firstCell]); it.maxK = min(cnt, GRID_MAX_PER_CELL()); it.base = firstCell * GRID_MAX_PER_CELL(); it.k = 0u; it.emitted = 0u; it.maxEmit = max(1u, SIM_MAX_NEIGHBORS()); return it; }
-fn neighbor_iter_next(it: ptr<function, NeighborIter>, selfIndex: u32) -> u32 { loop { if ((*it).emitted >= (*it).maxEmit) { return NEIGHBOR_NONE; } if ((*it).r > (*it).cy + (*it).reach) { return NEIGHBOR_NONE; } if ((*it).k < (*it).maxK) { let id = GRID_INDICES[(*it).base + (*it).k]; (*it).k = (*it).k + 1u; if (id != selfIndex) { (*it).emitted = (*it).emitted + 1u; return id; } else { continue; } } (*it).c = (*it).c + 1; if ((*it).c > (*it).cx + (*it).reach) { (*it).c = (*it).cx - (*it).reach; (*it).r = (*it).r + 1; } if ((*it).r > (*it).cy + (*it).reach) { return NEIGHBOR_NONE; } let cell = grid_cell_index_from_rc((*it).r, (*it).c); let cnt = atomicLoad(&GRID_COUNTS[cell]); (*it).maxK = min(cnt, GRID_MAX_PER_CELL()); (*it).base = cell * GRID_MAX_PER_CELL(); (*it).k = 0u; } }`);
+fn neighbor_iter_next(it: ptr<function, NeighborIter>, selfIndex: u32) -> u32 {
+  // Naga (Firefox) sometimes fails to prove that a loop always returns, so
+  // we structure this as break + return result to keep validation happy.
+  var result: u32 = NEIGHBOR_NONE;
+  loop {
+    if ((*it).emitted >= (*it).maxEmit) { break; }
+    if ((*it).r > (*it).cy + (*it).reach) { break; }
+    if ((*it).k < (*it).maxK) {
+      let id = GRID_INDICES[(*it).base + (*it).k];
+      (*it).k = (*it).k + 1u;
+      if (id != selfIndex) {
+        (*it).emitted = (*it).emitted + 1u;
+        result = id;
+        break;
+      } else {
+        continue;
+      }
+    }
+    (*it).c = (*it).c + 1;
+    if ((*it).c > (*it).cx + (*it).reach) { (*it).c = (*it).cx - (*it).reach; (*it).r = (*it).r + 1; }
+    if ((*it).r > (*it).cy + (*it).reach) { break; }
+    let cell = grid_cell_index_from_rc((*it).r, (*it).c);
+    let cnt = atomicLoad(&GRID_COUNTS[cell]);
+    (*it).maxK = min(cnt, GRID_MAX_PER_CELL());
+    (*it).base = cell * GRID_MAX_PER_CELL();
+    (*it).k = 0u;
+  }
+  return result;
+}`);
     // Optional: allow force modules to inject globals
     const addGlobal = (module, descriptor) => {
         if (module.role !== ModuleRole.Force)
@@ -3566,7 +3594,12 @@ class WebGPUEngine extends AbstractEngine {
         this.registry.initialize(this.resources);
         const program = this.registry.getProgram();
         if (program.extraBindings.simState) {
-            this.resources.createSimStateBuffer(this.bufferMaxParticles, 4);
+            // SIM_STATE is a per-particle float array used by integration and force-module state.
+            // Its stride is program-dependent (base 4 + per-module state slots), so we must
+            // allocate using the generated program's stride. Allocating a fixed 4-float stride
+            // causes out-of-bounds reads/writes for particles beyond a threshold (e.g. ~40k),
+            // resulting in "exploding" velocities/positions.
+            this.resources.createSimStateBuffer(this.bufferMaxParticles, program.simStateStride);
         }
         // Build compute pipelines
         this.sim.initialize(this.resources, program);
@@ -6241,14 +6274,30 @@ class Collisions extends Module {
  * - apply(): compute pressure gradient and viscosity forces; clamp max accel
  * Stores per-particle state in shared SIM_STATE via the Program-provided helpers.
  */
+var FluidsMethod;
+(function (FluidsMethod) {
+    FluidsMethod["Sph"] = "sph";
+    FluidsMethod["Picflip"] = "picflip";
+})(FluidsMethod || (FluidsMethod = {}));
 const DEFAULT_FLUIDS_INFLUENCE_RADIUS = 100;
-const DEFAULT_FLUIDS_TARGET_DENSITY = 1;
+const DEFAULT_FLUIDS_TARGET_DENSITY = 2;
 const DEFAULT_FLUIDS_PRESSURE_MULTIPLIER = 30;
 const DEFAULT_FLUIDS_VISCOSITY = 1;
 const DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER = 50;
 const DEFAULT_FLUIDS_NEAR_THRESHOLD = 20;
 const DEFAULT_FLUIDS_ENABLE_NEAR_PRESSURE = true;
 const DEFAULT_FLUIDS_MAX_ACCELERATION = 75;
+// Default values for PIC/FLIP parameters (exposed via Fluids when method=picflip)
+const DEFAULT_PICFLIP_FLIP_RATIO = 0.9;
+const DEFAULT_PICFLIP_TARGET_DENSITY = 2.0;
+const DEFAULT_PICFLIP_INFLUENCE_RADIUS = 50.0;
+const DEFAULT_PICFLIP_PRESSURE_MULTIPLIER = 500.0;
+const DEFAULT_PICFLIP_INTERNAL_MAX_ACCELERATION = 20000.0;
+// Backwards-compatible aliases for previous standalone Picflip module constants.
+// (The recommended names are the *_TARGET_DENSITY / *_INFLUENCE_RADIUS / *_PRESSURE_MULTIPLIER ones.)
+const DEFAULT_PICFLIP_DENSITY = DEFAULT_PICFLIP_TARGET_DENSITY;
+const DEFAULT_PICFLIP_RADIUS = DEFAULT_PICFLIP_INFLUENCE_RADIUS;
+const DEFAULT_PICFLIP_PRESSURE = DEFAULT_PICFLIP_PRESSURE_MULTIPLIER;
 class Fluids extends Module {
     constructor(opts) {
         super();
@@ -6269,6 +6318,7 @@ class Fluids extends Module {
             configurable: true,
             writable: true,
             value: {
+                method: DataType.NUMBER,
                 influenceRadius: DataType.NUMBER,
                 targetDensity: DataType.NUMBER,
                 pressureMultiplier: DataType.NUMBER,
@@ -6277,22 +6327,56 @@ class Fluids extends Module {
                 nearThreshold: DataType.NUMBER,
                 enableNearPressure: DataType.NUMBER,
                 maxAcceleration: DataType.NUMBER,
+                flipRatio: DataType.NUMBER,
             }
         });
-        this.write({
-            influenceRadius: opts?.influenceRadius ?? DEFAULT_FLUIDS_INFLUENCE_RADIUS,
-            targetDensity: opts?.targetDensity ?? DEFAULT_FLUIDS_TARGET_DENSITY,
-            pressureMultiplier: opts?.pressureMultiplier ?? DEFAULT_FLUIDS_PRESSURE_MULTIPLIER,
-            viscosity: opts?.viscosity ?? DEFAULT_FLUIDS_VISCOSITY,
-            nearPressureMultiplier: opts?.nearPressureMultiplier ?? DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER,
-            nearThreshold: opts?.nearThreshold ?? DEFAULT_FLUIDS_NEAR_THRESHOLD,
-            enableNearPressure: opts?.enableNearPressure ?? DEFAULT_FLUIDS_ENABLE_NEAR_PRESSURE ? 1 : 0,
-            maxAcceleration: opts?.maxAcceleration ?? DEFAULT_FLUIDS_MAX_ACCELERATION,
-        });
+        const method = opts?.method ?? FluidsMethod.Sph;
+        const isPicflip = method === FluidsMethod.Picflip;
+        if (isPicflip) {
+            const o = opts;
+            this.write({
+                method: 1,
+                influenceRadius: o?.influenceRadius ?? DEFAULT_PICFLIP_INFLUENCE_RADIUS,
+                targetDensity: o?.targetDensity ?? DEFAULT_PICFLIP_TARGET_DENSITY,
+                pressureMultiplier: o?.pressureMultiplier ?? DEFAULT_PICFLIP_PRESSURE_MULTIPLIER,
+                // SPH-only; keep initialized but unused for PICFLIP
+                viscosity: 0,
+                // Keep SPH-only uniforms initialized (unused when method=picflip)
+                nearPressureMultiplier: DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER,
+                nearThreshold: DEFAULT_FLUIDS_NEAR_THRESHOLD,
+                enableNearPressure: 1 ,
+                maxAcceleration: DEFAULT_FLUIDS_MAX_ACCELERATION,
+                flipRatio: o?.flipRatio ?? DEFAULT_PICFLIP_FLIP_RATIO,
+            });
+        }
+        else {
+            const o = opts;
+            this.write({
+                method: 0,
+                influenceRadius: o?.influenceRadius ?? DEFAULT_FLUIDS_INFLUENCE_RADIUS,
+                targetDensity: o?.targetDensity ?? DEFAULT_FLUIDS_TARGET_DENSITY,
+                pressureMultiplier: o?.pressureMultiplier ?? DEFAULT_FLUIDS_PRESSURE_MULTIPLIER,
+                viscosity: o?.viscosity ?? DEFAULT_FLUIDS_VISCOSITY,
+                nearPressureMultiplier: o?.nearPressureMultiplier ?? DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER,
+                nearThreshold: o?.nearThreshold ?? DEFAULT_FLUIDS_NEAR_THRESHOLD,
+                enableNearPressure: o?.enableNearPressure ?? DEFAULT_FLUIDS_ENABLE_NEAR_PRESSURE ? 1 : 0,
+                maxAcceleration: o?.maxAcceleration ?? DEFAULT_FLUIDS_MAX_ACCELERATION,
+                // Keep PICFLIP-only uniform initialized (unused when method=sph)
+                flipRatio: DEFAULT_PICFLIP_FLIP_RATIO,
+            });
+        }
         if (opts?.enabled !== undefined) {
             this.setEnabled(!!opts.enabled);
         }
     }
+    setMethod(method) {
+        this.write({ method: method === FluidsMethod.Picflip ? 1 : 0 });
+    }
+    getMethod() {
+        return this.readValue("method") >= 0.5
+            ? FluidsMethod.Picflip
+            : FluidsMethod.Sph;
+    }
     setInfluenceRadius(v) {
         this.write({ influenceRadius: v });
     }
@@ -6305,6 +6389,9 @@ class Fluids extends Module {
     setViscosity(v) {
         this.write({ viscosity: v });
     }
+    setFlipRatio(v) {
+        this.write({ flipRatio: v });
+    }
     setNearPressureMultiplier(v) {
         this.write({ nearPressureMultiplier: v });
     }
@@ -6329,6 +6416,9 @@ class Fluids extends Module {
     getViscosity() {
         return this.readValue("viscosity");
     }
+    getFlipRatio() {
+        return this.readValue("flipRatio");
+    }
     getNearPressureMultiplier() {
         return this.readValue("nearPressureMultiplier");
     }
@@ -6343,111 +6433,94 @@ class Fluids extends Module {
     }
     webgpu() {
         return {
-            states: ["density", "nearDensity"],
-            // State pass: precompute density and near-density per particle
+            states: ["density", "nearDensity", "prevVelX", "prevVelY"],
+            // State pass:
+            // - SPH: precompute density and near-density per particle
+            // - PICFLIP: store previous velocity per particle (for FLIP delta)
             state: ({ particleVar, dtVar, getUniform, setState }) => `{
-  // Predict current particle position for this frame (approximate)
-  let rad = ${getUniform("influenceRadius")};
-  let posPred = ${particleVar}.position + ${particleVar}.velocity * (${dtVar});
-  var density: f32 = 0.0;
-  var nearDensity: f32 = 0.0;
+  let method = ${getUniform("method")};
 
-  // Precompute radius powers for kernels
-  let r2 = rad * rad;
-  let r4 = r2 * r2;
-  let r6 = r4 * r2;
-  let r8 = r4 * r4;
+  if (method < 0.5) {
+    // SPH: Predict current particle position for this frame (approximate)
+    let rad = ${getUniform("influenceRadius")};
+    let posPred = ${particleVar}.position + ${particleVar}.velocity * (${dtVar});
+    var density: f32 = 0.0;
+    var nearDensity: f32 = 0.0;
 
-  // Iterate neighbors using the spatial grid
-  var it = neighbor_iter_init(posPred, rad);
-  loop {
-    let j = neighbor_iter_next(&it, index);
-    if (j == NEIGHBOR_NONE) { break; }
-    let other = particles[j];
-    // Skip removed or pinned neighbors
-    if (other.mass <= 0.0) { continue; }
+    // Precompute radius powers for kernels
+    let r2 = rad * rad;
+    let r4 = r2 * r2;
+    let r6 = r4 * r2;
+    let r8 = r4 * r4;
 
-    let d = posPred - other.position;
-    let dist2 = dot(d, d);
-    if (dist2 <= 0.0) { continue; }
-    let dist = sqrt(dist2);
-    let factor = max(rad - dist, 0.0);
-    if (factor <= 0.0) { continue; }
+    // Iterate neighbors using the spatial grid
+    var it = neighbor_iter_init(posPred, rad);
+    loop {
+      let j = neighbor_iter_next(&it, index);
+      if (j == NEIGHBOR_NONE) { break; }
+      let other = particles[j];
+      // Skip removed or pinned neighbors
+      if (other.mass <= 0.0) { continue; }
 
-    // Density kernel (CPU: (factor^2) / (pi/6 * r^4))
-    let kDensity = (factor * factor) / ((3.14159265 / 6.0) * r4);
-    density = density + kDensity * 1000.0 * other.mass;
+      let d = posPred - other.position;
+      let dist2 = dot(d, d);
+      if (dist2 <= 0.0) { continue; }
+      let dist = sqrt(dist2);
+      let factor = max(rad - dist, 0.0);
+      if (factor <= 0.0) { continue; }
 
-    // Near-density kernel (CPU: (factor^4) / (pi/15 * r^6))
-    if (${getUniform("enableNearPressure")} != 0.0) {
-      let f2 = factor * factor;
-      let kNear = (f2 * f2) / ((3.14159265 / 15.0) * r6);
-      nearDensity = nearDensity + kNear * 1000.0 * other.mass;
+      // Density kernel (CPU: (factor^2) / (pi/6 * r^4))
+      let kDensity = (factor * factor) / ((3.14159265 / 6.0) * r4);
+      density = density + kDensity * 1000.0 * other.mass;
+
+      // Near-density kernel (CPU: (factor^4) / (pi/15 * r^6))
+      if (${getUniform("enableNearPressure")} != 0.0) {
+        let f2 = factor * factor;
+        let kNear = (f2 * f2) / ((3.14159265 / 15.0) * r6);
+        nearDensity = nearDensity + kNear * 1000.0 * other.mass;
+      }
     }
-  }
 
-  // Store results in shared SIM_STATE for use in apply pass
-  ${setState("density", "density")};
-  ${setState("nearDensity", "nearDensity")};
+    // Store results in shared SIM_STATE for use in apply pass
+    ${setState("density", "density")};
+    ${setState("nearDensity", "nearDensity")};
+  } else {
+    // PICFLIP: Store current velocity before blend/pressure
+    ${setState("prevVelX", `${particleVar}.velocity.x`)};
+    ${setState("prevVelY", `${particleVar}.velocity.y`)};
+  }
 }`,
-            // Apply pass: compute pressure and viscosity forces using precomputed densities
-            apply: ({ particleVar, getUniform, getState }) => `{
-  let rad = ${getUniform("influenceRadius")};
-  let targetDensity = ${getUniform("targetDensity")};
-  let pressureMul = ${getUniform("pressureMultiplier")};
-  let visc = ${getUniform("viscosity")};
-  let nearMul = ${getUniform("nearPressureMultiplier")};
-  let nearThreshold = ${getUniform("nearThreshold")};
-  let useNear = ${getUniform("enableNearPressure")};
-
-  let myDensity = max(${getState("density")}, 1e-6);
-
-  // Precompute radius powers for kernels
-  let r2 = rad * rad;
-  let r4 = r2 * r2;
-  let r6 = r4 * r2;
-  let r8 = r4 * r4;
-
-  // Pressure gradient accumulation
-  var gradSum: vec2<f32> = vec2<f32>(0.0, 0.0);
-  var it1 = neighbor_iter_init(${particleVar}.position, rad);
-  loop {
-    let j = neighbor_iter_next(&it1, index);
-    if (j == NEIGHBOR_NONE) { break; }
-    let other = particles[j];
-    // Skip removed or pinned neighbors
-    if (other.mass <= 0.0) { continue; }
-    let delta = other.position - ${particleVar}.position;
-    let dist2 = dot(delta, delta);
-    if (dist2 <= 0.0) { continue; }
-    let dist = sqrt(dist2);
-    if (dist <= 0.0 || dist >= rad) { continue; }
-    let dir = delta / dist;
+            // Apply pass:
+            // - SPH: pressure + viscosity using precomputed densities
+            // - PICFLIP: simplified local-pressure PIC/FLIP blend (+ optional viscosity)
+            apply: ({ particleVar, dtVar, getUniform, getState }) => `{
+  let method = ${getUniform("method")};
 
-    // Derivative kernel (CPU: scale * (dist - rad), scale = (-12/pi)/r^4)
-    let scale = (-12.0 / 3.14159265) / r4;
-    let slope = (dist - rad) * scale;
+  if (method < 0.5) {
+    // ==========================
+    // SPH
+    // ==========================
+    let rad = ${getUniform("influenceRadius")};
+    let targetDensity = ${getUniform("targetDensity")};
+    let pressureMul = ${getUniform("pressureMultiplier")};
+    let visc = ${getUniform("viscosity")};
+    let nearMul = ${getUniform("nearPressureMultiplier")};
+    let nearThreshold = ${getUniform("nearThreshold")};
+    let useNear = ${getUniform("enableNearPressure")};
 
-    // Neighbor pressures from precomputed densities
-    let dN = max(${getState("density", "j")}, 1e-6);
-    let nearN = select(0.0, ${getState("nearDensity", "j")}, useNear != 0.0);
-    let densityDiff = dN - targetDensity;
-    let pressure = densityDiff * pressureMul;
-    let nearPressure = nearN * nearMul;
-    let effectivePressure = select(pressure, nearPressure, dist < nearThreshold);
+    let myDensity = max(${getState("density")}, 1e-6);
 
-    // Gradient contribution
-    gradSum = gradSum + (dir * (effectivePressure * slope) / dN);
-  }
-  // Pressure force is negative gradient
-  var pressureForce = -gradSum;
+    // Precompute radius powers for kernels
+    let r2 = rad * rad;
+    let r4 = r2 * r2;
+    let r6 = r4 * r2;
+    let r8 = r4 * r4;
 
-  // Viscosity accumulation
-  var viscosityForce: vec2<f32> = vec2<f32>(0.0, 0.0);
-  if (visc != 0.0) {
-    var it2 = neighbor_iter_init(${particleVar}.position, rad);
+    // Pressure gradient accumulation
+    var gradSum: vec2<f32> = vec2<f32>(0.0, 0.0);
+    var it1 = neighbor_iter_init(${particleVar}.position, rad);
     loop {
-      let j = neighbor_iter_next(&it2, index);
+      let j = neighbor_iter_next(&it1, index);
       if (j == NEIGHBOR_NONE) { break; }
       let other = particles[j];
       // Skip removed or pinned neighbors
@@ -6456,141 +6529,249 @@ class Fluids extends Module {
       let dist2 = dot(delta, delta);
       if (dist2 <= 0.0) { continue; }
       let dist = sqrt(dist2);
-      if (dist >= rad) { continue; }
-      // Viscosity kernel (CPU: (max(0, r^2 - d^2)^3) / (pi/4 * r^8))
-      let val = max(0.0, r2 - dist2);
-      let kVisc = (val * val * val) / ((3.14159265 / 4.0) * r8);
-      viscosityForce = viscosityForce + (other.velocity - ${particleVar}.velocity) * kVisc;
+      if (dist <= 0.0 || dist >= rad) { continue; }
+      let dir = delta / dist;
+
+      // Derivative kernel (CPU: scale * (dist - rad), scale = (-12/pi)/r^4)
+      let scale = (-12.0 / 3.14159265) / r4;
+      let slope = (dist - rad) * scale;
+
+      // Neighbor pressures from precomputed densities
+      let dN = max(${getState("density", "j")}, 1e-6);
+      let nearN = select(0.0, ${getState("nearDensity", "j")}, useNear != 0.0);
+      let densityDiff = dN - targetDensity;
+      let pressure = densityDiff * pressureMul;
+      let nearPressure = nearN * nearMul;
+      let effectivePressure = select(pressure, nearPressure, dist < nearThreshold);
+
+      // Gradient contribution
+      gradSum = gradSum + (dir * (effectivePressure * slope) / dN);
     }
-    viscosityForce = viscosityForce * visc;
-  }
+    // Pressure force is negative gradient
+    var pressureForce = -gradSum;
 
-  // Convert to acceleration-like effect: a = F / density
-  var force = (pressureForce / myDensity) * 1000000.0;
-  if (visc != 0.0) {
-    force = force + (viscosityForce * 1000.0) / myDensity;
-  }
+    // Viscosity accumulation
+    var viscosityForce: vec2<f32> = vec2<f32>(0.0, 0.0);
+    if (visc != 0.0) {
+      var it2 = neighbor_iter_init(${particleVar}.position, rad);
+      loop {
+        let j = neighbor_iter_next(&it2, index);
+        if (j == NEIGHBOR_NONE) { break; }
+        let other = particles[j];
+        // Skip removed or pinned neighbors
+        if (other.mass <= 0.0) { continue; }
+        let delta = other.position - ${particleVar}.position;
+        let dist2 = dot(delta, delta);
+        if (dist2 <= 0.0) { continue; }
+        let dist = sqrt(dist2);
+        if (dist >= rad) { continue; }
+        // Viscosity kernel (CPU: (max(0, r^2 - d^2)^3) / (pi/4 * r^8))
+        let val = max(0.0, r2 - dist2);
+        let kVisc = (val * val * val) / ((3.14159265 / 4.0) * r8);
+        viscosityForce = viscosityForce + (other.velocity - ${particleVar}.velocity) * kVisc;
+      }
+      viscosityForce = viscosityForce * visc;
+    }
 
-  // Clamp force magnitude to avoid instabilities (tunable)
-  let maxLen = ${getUniform("maxAcceleration")};
-  let f2 = dot(force, force);
-  if (f2 > maxLen * maxLen) {
-    let fLen = sqrt(f2);
-    force = force * (maxLen / fLen);
-  }
+    // Convert to acceleration-like effect: a = F / density
+    var force = (pressureForce / myDensity) * 1000000.0;
+    if (visc != 0.0) {
+      force = force + (viscosityForce * 1000.0) / myDensity;
+    }
+
+    // Clamp force magnitude to avoid instabilities (tunable)
+    let maxLen = ${getUniform("maxAcceleration")};
+    let f2 = dot(force, force);
+    if (f2 > maxLen * maxLen) {
+      let fLen = sqrt(f2);
+      force = force * (maxLen / fLen);
+    }
+
+    // Apply directly to velocity (CPU mirrors this behavior)
+    ${particleVar}.velocity = ${particleVar}.velocity + force;
+  } else {
+    // ==========================
+    // PICFLIP (simplified local-pressure approximation)
+    // ==========================
+    // Scale UI-friendly values to PIC/FLIP internal tuning:
+    // - influenceRadius: /2
+    // - targetDensity: *3
+    // - pressureMultiplier: *30
+    let flipRatio = ${getUniform("flipRatio")};
+    let rad = ${getUniform("influenceRadius")} * 0.5;
+    let targetDensity = ${getUniform("targetDensity")} * 3.0;
+    let pressureScale = ${getUniform("pressureMultiplier")} * 30.0;
+
+    // Get stored previous velocity
+    let prevVelX = ${getState("prevVelX")};
+    let prevVelY = ${getState("prevVelY")};
+
+    var newVelX = ${particleVar}.velocity.x;
+    var newVelY = ${particleVar}.velocity.y;
+
+    // Local density + average neighbor velocity (PIC grid approximation)
+    var density: f32 = 0.0;
+    var avgVelX: f32 = 0.0;
+    var avgVelY: f32 = 0.0;
+    var count: f32 = 0.0;
+
+    var it = neighbor_iter_init(${particleVar}.position, rad);
+    loop {
+      let j = neighbor_iter_next(&it, index);
+      if (j == NEIGHBOR_NONE) { break; }
+      let other = particles[j];
+      if (other.mass <= 0.0) { continue; }
+
+      let d = ${particleVar}.position - other.position;
+      let dist2 = dot(d, d);
+      if (dist2 <= 0.0 || dist2 > rad * rad) { continue; }
+
+      let dist = sqrt(dist2);
+      let weight = 1.0 - dist / rad;
+
+      density = density + weight;
+      avgVelX = avgVelX + other.velocity.x * weight;
+      avgVelY = avgVelY + other.velocity.y * weight;
+      count = count + weight;
+    }
+
+    if (count > 0.0) {
+      avgVelX = avgVelX / count;
+      avgVelY = avgVelY / count;
+
+      // PIC/FLIP blend
+      let picVelX = avgVelX;
+      let picVelY = avgVelY;
+      let flipVelX = newVelX + (avgVelX - prevVelX);
+      let flipVelY = newVelY + (avgVelY - prevVelY);
+
+      newVelX = mix(picVelX, flipVelX, flipRatio);
+      newVelY = mix(picVelY, flipVelY, flipRatio);
+
+      // Simple pressure force based on local density
+      let maxPressureFactor = abs(pressureScale) * 10.0;
+      let pressureFactor = clamp(
+        (density - targetDensity) * pressureScale,
+        -maxPressureFactor,
+        maxPressureFactor
+      );
+
+      // Apply pressure gradient (push away from high density regions)
+      var gradX: f32 = 0.0;
+      var gradY: f32 = 0.0;
+
+      var it2 = neighbor_iter_init(${particleVar}.position, rad);
+      loop {
+        let j = neighbor_iter_next(&it2, index);
+        if (j == NEIGHBOR_NONE) { break; }
+        let other = particles[j];
+        if (other.mass <= 0.0) { continue; }
 
-  // Apply directly to velocity (CPU mirrors this behavior)
-  ${particleVar}.velocity = ${particleVar}.velocity + force;
+        let d = ${particleVar}.position - other.position;
+        let dist2 = dot(d, d);
+        if (dist2 <= 1.0 || dist2 > rad * rad) { continue; }
+
+        let dist = sqrt(dist2);
+        let dir = d / dist;
+        let weight = 1.0 - dist / rad;
+
+        gradX = gradX + dir.x * weight * pressureFactor;
+        gradY = gradY + dir.y * weight * pressureFactor;
+      }
+
+      // NOTE: no max-acceleration clamp for PIC/FLIP (it tends to need the max anyway)
+      newVelX = newVelX + gradX * ${dtVar};
+      newVelY = newVelY + gradY * ${dtVar};
+    }
+
+    ${particleVar}.velocity.x = newVelX;
+    ${particleVar}.velocity.y = newVelY;
+  }
 }`,
         };
     }
     cpu() {
         return {
-            states: ["density", "nearDensity"],
-            // State pass: precompute density and near-density per particle
+            states: ["density", "nearDensity", "prevVelX", "prevVelY"],
+            // State pass:
+            // - SPH: precompute density and near-density per particle
+            // - PICFLIP: store previous velocity per particle
             state: ({ particle, getNeighbors, dt, setState }) => {
-                // Get fluid parameters
-                const rad = this.readValue("influenceRadius");
-                const enableNearPressure = this.readValue("enableNearPressure");
-                // Predict current particle position for this frame (approximate)
-                const posPredX = particle.position.x + particle.velocity.x * dt;
-                const posPredY = particle.position.y + particle.velocity.y * dt;
-                let density = 0.0;
-                let nearDensity = 0.0;
-                // Precompute radius powers for kernels
-                const r2 = rad * rad;
-                const r4 = r2 * r2;
-                const r6 = r4 * r2;
-                // Get neighbors using predicted position
-                const neighbors = getNeighbors({ x: posPredX, y: posPredY }, rad);
-                for (const other of neighbors) {
-                    if (other.id === particle.id)
-                        continue; // Skip self
-                    // Skip removed or pinned neighbors
-                    if (other.mass <= 0)
-                        continue;
-                    const dX = posPredX - other.position.x;
-                    const dY = posPredY - other.position.y;
-                    const dist2 = dX * dX + dY * dY;
-                    if (dist2 <= 0.0)
-                        continue;
-                    const dist = Math.sqrt(dist2);
-                    const factor = Math.max(rad - dist, 0.0);
-                    if (factor <= 0.0)
-                        continue;
-                    // Density kernel: (factor^2) / (pi/6 * r^4)
-                    const kDensity = (factor * factor) / ((Math.PI / 6.0) * r4);
-                    density += kDensity * 1000.0 * other.mass;
-                    // Near-density kernel: (factor^4) / (pi/15 * r^6)
-                    if (enableNearPressure !== 0.0) {
-                        const f2 = factor * factor;
-                        const kNear = (f2 * f2) / ((Math.PI / 15.0) * r6);
-                        nearDensity += kNear * 1000.0 * other.mass;
+                const method = this.readValue("method");
+                if (method < 0.5) {
+                    // SPH
+                    const rad = this.readValue("influenceRadius");
+                    const enableNearPressure = this.readValue("enableNearPressure");
+                    // Predict current particle position for this frame (approximate)
+                    const posPredX = particle.position.x + particle.velocity.x * dt;
+                    const posPredY = particle.position.y + particle.velocity.y * dt;
+                    let density = 0.0;
+                    let nearDensity = 0.0;
+                    // Precompute radius powers for kernels
+                    const r2 = rad * rad;
+                    const r4 = r2 * r2;
+                    const r6 = r4 * r2;
+                    // Get neighbors using predicted position
+                    const neighbors = getNeighbors({ x: posPredX, y: posPredY }, rad);
+                    for (const other of neighbors) {
+                        if (other.id === particle.id)
+                            continue; // Skip self
+                        // Skip removed or pinned neighbors
+                        if (other.mass <= 0)
+                            continue;
+                        const dX = posPredX - other.position.x;
+                        const dY = posPredY - other.position.y;
+                        const dist2 = dX * dX + dY * dY;
+                        if (dist2 <= 0.0)
+                            continue;
+                        const dist = Math.sqrt(dist2);
+                        const factor = Math.max(rad - dist, 0.0);
+                        if (factor <= 0.0)
+                            continue;
+                        // Density kernel: (factor^2) / (pi/6 * r^4)
+                        const kDensity = (factor * factor) / ((Math.PI / 6.0) * r4);
+                        density += kDensity * 1000.0 * other.mass;
+                        // Near-density kernel: (factor^4) / (pi/15 * r^6)
+                        if (enableNearPressure !== 0.0) {
+                            const f2 = factor * factor;
+                            const kNear = (f2 * f2) / ((Math.PI / 15.0) * r6);
+                            nearDensity += kNear * 1000.0 * other.mass;
+                        }
                     }
+                    // Store results in shared state for use in apply pass
+                    setState("density", density);
+                    setState("nearDensity", nearDensity);
                 }
-                // Store results in shared state for use in apply pass
-                setState("density", density);
-                setState("nearDensity", nearDensity);
-            },
-            // Apply pass: compute pressure and viscosity forces using precomputed densities
-            apply: ({ particle, getNeighbors, getState }) => {
-                // Get fluid parameters
-                const rad = this.readValue("influenceRadius");
-                const targetDensity = this.readValue("targetDensity");
-                const pressureMul = this.readValue("pressureMultiplier");
-                const visc = this.readValue("viscosity");
-                const nearMul = this.readValue("nearPressureMultiplier");
-                const nearThreshold = this.readValue("nearThreshold");
-                const useNear = this.readValue("enableNearPressure");
-                const maxAccel = this.readValue("maxAcceleration");
-                const myDensity = Math.max(getState("density"), 1e-6);
-                // Precompute radius powers for kernels
-                const r2 = rad * rad;
-                const r4 = r2 * r2;
-                const r8 = r4 * r4;
-                // Pressure gradient accumulation
-                let gradSumX = 0.0;
-                let gradSumY = 0.0;
-                const neighbors = getNeighbors(particle.position, rad);
-                for (const other of neighbors) {
-                    if (other.id === particle.id)
-                        continue; // Skip self
-                    // Skip removed or pinned neighbors
-                    if (other.mass <= 0)
-                        continue;
-                    const deltaX = other.position.x - particle.position.x;
-                    const deltaY = other.position.y - particle.position.y;
-                    const dist2 = deltaX * deltaX + deltaY * deltaY;
-                    if (dist2 <= 0.0)
-                        continue;
-                    const dist = Math.sqrt(dist2);
-                    if (dist <= 0.0 || dist >= rad)
-                        continue;
-                    const dirX = deltaX / dist;
-                    const dirY = deltaY / dist;
-                    // Derivative kernel: scale * (dist - rad), scale = (-12/pi)/r^4
-                    const scale = -12 / Math.PI / r4;
-                    const slope = (dist - rad) * scale;
-                    // Neighbor pressures from precomputed densities
-                    const dN = Math.max(getState("density", other.id), 1e-6);
-                    const nearN = useNear !== 0.0 ? getState("nearDensity", other.id) : 0.0;
-                    const densityDiff = dN - targetDensity;
-                    const pressure = densityDiff * pressureMul;
-                    const nearPressure = nearN * nearMul;
-                    const effectivePressure = dist < nearThreshold ? nearPressure : pressure;
-                    // Gradient contribution
-                    const gradContribX = (dirX * (effectivePressure * slope)) / dN;
-                    const gradContribY = (dirY * (effectivePressure * slope)) / dN;
-                    gradSumX += gradContribX;
-                    gradSumY += gradContribY;
+                else {
+                    // PICFLIP
+                    setState("prevVelX", particle.velocity.x);
+                    setState("prevVelY", particle.velocity.y);
                 }
-                // Pressure force is negative gradient
-                let pressureForceX = -gradSumX;
-                let pressureForceY = -gradSumY;
-                // Viscosity accumulation
-                let viscosityForceX = 0.0;
-                let viscosityForceY = 0.0;
-                if (visc !== 0.0) {
+            },
+            // Apply pass:
+            // - SPH: pressure + viscosity using precomputed densities
+            // - PICFLIP: simplified local-pressure PIC/FLIP blend (+ optional viscosity)
+            apply: ({ particle, getNeighbors, dt, getState }) => {
+                const method = this.readValue("method");
+                if (method < 0.5) {
+                    // SPH
+                    const rad = this.readValue("influenceRadius");
+                    const targetDensity = this.readValue("targetDensity");
+                    const pressureMul = this.readValue("pressureMultiplier");
+                    const visc = this.readValue("viscosity");
+                    const nearMul = this.readValue("nearPressureMultiplier");
+                    const nearThreshold = this.readValue("nearThreshold");
+                    const useNear = this.readValue("enableNearPressure");
+                    const maxAccel = this.readValue("maxAcceleration");
+                    const myDensity = Math.max(getState("density"), 1e-6);
+                    // Precompute radius powers for kernels
+                    const r2 = rad * rad;
+                    const r4 = r2 * r2;
+                    const r8 = r4 * r4;
+                    // Pressure gradient accumulation
+                    let gradSumX = 0.0;
+                    let gradSumY = 0.0;
+                    const neighbors = getNeighbors(particle.position, rad);
                     for (const other of neighbors) {
                         if (other.id === particle.id)
                             continue; // Skip self
@@ -6603,34 +6784,155 @@ class Fluids extends Module {
                         if (dist2 <= 0.0)
                             continue;
                         const dist = Math.sqrt(dist2);
-                        if (dist >= rad)
+                        if (dist <= 0.0 || dist >= rad)
                             continue;
-                        // Viscosity kernel: (max(0, r^2 - d^2)^3) / (pi/4 * r^8)
-                        const val = Math.max(0.0, r2 - dist2);
-                        const kVisc = (val * val * val) / ((Math.PI / 4.0) * r8);
-                        viscosityForceX += (other.velocity.x - particle.velocity.x) * kVisc;
-                        viscosityForceY += (other.velocity.y - particle.velocity.y) * kVisc;
+                        const dirX = deltaX / dist;
+                        const dirY = deltaY / dist;
+                        // Derivative kernel: scale * (dist - rad), scale = (-12/pi)/r^4
+                        const scale = -12 / Math.PI / r4;
+                        const slope = (dist - rad) * scale;
+                        // Neighbor pressures from precomputed densities
+                        const dN = Math.max(getState("density", other.id), 1e-6);
+                        const nearN = useNear !== 0.0 ? getState("nearDensity", other.id) : 0.0;
+                        const densityDiff = dN - targetDensity;
+                        const pressure = densityDiff * pressureMul;
+                        const nearPressure = nearN * nearMul;
+                        const effectivePressure = dist < nearThreshold ? nearPressure : pressure;
+                        // Gradient contribution
+                        const gradContribX = (dirX * (effectivePressure * slope)) / dN;
+                        const gradContribY = (dirY * (effectivePressure * slope)) / dN;
+                        gradSumX += gradContribX;
+                        gradSumY += gradContribY;
                     }
-                    viscosityForceX *= visc;
-                    viscosityForceY *= visc;
-                }
-                // Convert to acceleration-like effect: a = F / density
-                let forceX = (pressureForceX / myDensity) * 1000000.0;
-                let forceY = (pressureForceY / myDensity) * 1000000.0;
-                if (visc !== 0.0) {
-                    forceX += (viscosityForceX * 1000.0) / myDensity;
-                    forceY += (viscosityForceY * 1000.0) / myDensity;
+                    // Pressure force is negative gradient
+                    let pressureForceX = -gradSumX;
+                    let pressureForceY = -gradSumY;
+                    // Viscosity accumulation
+                    let viscosityForceX = 0.0;
+                    let viscosityForceY = 0.0;
+                    if (visc !== 0.0) {
+                        for (const other of neighbors) {
+                            if (other.id === particle.id)
+                                continue; // Skip self
+                            // Skip removed or pinned neighbors
+                            if (other.mass <= 0)
+                                continue;
+                            const deltaX = other.position.x - particle.position.x;
+                            const deltaY = other.position.y - particle.position.y;
+                            const dist2 = deltaX * deltaX + deltaY * deltaY;
+                            if (dist2 <= 0.0)
+                                continue;
+                            const dist = Math.sqrt(dist2);
+                            if (dist >= rad)
+                                continue;
+                            // Viscosity kernel: (max(0, r^2 - d^2)^3) / (pi/4 * r^8)
+                            const val = Math.max(0.0, r2 - dist2);
+                            const kVisc = (val * val * val) / ((Math.PI / 4.0) * r8);
+                            viscosityForceX +=
+                                (other.velocity.x - particle.velocity.x) * kVisc;
+                            viscosityForceY +=
+                                (other.velocity.y - particle.velocity.y) * kVisc;
+                        }
+                        viscosityForceX *= visc;
+                        viscosityForceY *= visc;
+                    }
+                    // Convert to acceleration-like effect: a = F / density
+                    let forceX = (pressureForceX / myDensity) * 1000000.0;
+                    let forceY = (pressureForceY / myDensity) * 1000000.0;
+                    if (visc !== 0.0) {
+                        forceX += (viscosityForceX * 1000.0) / myDensity;
+                        forceY += (viscosityForceY * 1000.0) / myDensity;
+                    }
+                    // Clamp force magnitude to avoid instabilities
+                    const f2 = forceX * forceX + forceY * forceY;
+                    if (f2 > maxAccel * maxAccel) {
+                        const fLen = Math.sqrt(f2);
+                        forceX = forceX * (maxAccel / fLen);
+                        forceY = forceY * (maxAccel / fLen);
+                    }
+                    // Apply directly to velocity (matching WebGPU behavior)
+                    particle.velocity.x += forceX;
+                    particle.velocity.y += forceY;
                 }
-                // Clamp force magnitude to avoid instabilities
-                const f2 = forceX * forceX + forceY * forceY;
-                if (f2 > maxAccel * maxAccel) {
-                    const fLen = Math.sqrt(f2);
-                    forceX = forceX * (maxAccel / fLen);
-                    forceY = forceY * (maxAccel / fLen);
+                else {
+                    // PICFLIP
+                    // Scale UI-friendly values to PIC/FLIP internal tuning:
+                    // - influenceRadius: /2
+                    // - targetDensity: *3
+                    // - pressureMultiplier: *30
+                    const flipRatio = this.readValue("flipRatio");
+                    const targetDensity = this.readValue("targetDensity") * 3.0;
+                    const rad = this.readValue("influenceRadius") * 0.5;
+                    const pressureScale = this.readValue("pressureMultiplier") * 30.0;
+                    // Get stored previous velocity
+                    const prevVelX = getState("prevVelX");
+                    const prevVelY = getState("prevVelY");
+                    let newVelX = particle.velocity.x;
+                    let newVelY = particle.velocity.y;
+                    // Local pressure approximation using neighbor density
+                    let density = 0.0;
+                    let avgVelX = 0.0;
+                    let avgVelY = 0.0;
+                    let count = 0.0;
+                    const neighbors = getNeighbors(particle.position, rad);
+                    for (const other of neighbors) {
+                        if (other.id === particle.id)
+                            continue;
+                        if (other.mass <= 0)
+                            continue;
+                        const dx = particle.position.x - other.position.x;
+                        const dy = particle.position.y - other.position.y;
+                        const dist2 = dx * dx + dy * dy;
+                        if (dist2 <= 0 || dist2 > rad * rad)
+                            continue;
+                        const dist = Math.sqrt(dist2);
+                        const weight = 1.0 - dist / rad;
+                        density += weight;
+                        avgVelX += other.velocity.x * weight;
+                        avgVelY += other.velocity.y * weight;
+                        count += weight;
+                    }
+                    if (count > 0) {
+                        avgVelX /= count;
+                        avgVelY /= count;
+                        // PIC/FLIP blend
+                        const picVelX = avgVelX;
+                        const picVelY = avgVelY;
+                        const flipVelX = newVelX + (avgVelX - prevVelX);
+                        const flipVelY = newVelY + (avgVelY - prevVelY);
+                        newVelX = picVelX * (1 - flipRatio) + flipVelX * flipRatio;
+                        newVelY = picVelY * (1 - flipRatio) + flipVelY * flipRatio;
+                        // Simple pressure force based on local density
+                        const maxPressureFactor = Math.abs(pressureScale) * 10.0;
+                        const rawPressureFactor = (density - targetDensity) * pressureScale;
+                        const pressureFactor = Math.max(-maxPressureFactor, Math.min(maxPressureFactor, rawPressureFactor));
+                        // Apply pressure gradient
+                        let gradX = 0.0;
+                        let gradY = 0.0;
+                        for (const other of neighbors) {
+                            if (other.id === particle.id)
+                                continue;
+                            if (other.mass <= 0)
+                                continue;
+                            const dx = particle.position.x - other.position.x;
+                            const dy = particle.position.y - other.position.y;
+                            const dist2 = dx * dx + dy * dy;
+                            if (dist2 <= 1.0 || dist2 > rad * rad)
+                                continue;
+                            const dist = Math.sqrt(dist2);
+                            const dirX = dx / dist;
+                            const dirY = dy / dist;
+                            const weight = 1.0 - dist / rad;
+                            gradX += dirX * weight * pressureFactor;
+                            gradY += dirY * weight * pressureFactor;
+                        }
+                        // NOTE: no max-acceleration clamp for PIC/FLIP (it tends to need the max anyway)
+                        newVelX += gradX * dt;
+                        newVelY += gradY * dt;
+                    }
+                    particle.velocity.x = newVelX;
+                    particle.velocity.y = newVelY;
                 }
-                // Apply directly to velocity (matching WebGPU behavior)
-                particle.velocity.x += forceX;
-                particle.velocity.y += forceY;
             },
         };
     }
@@ -9680,5 +9982,5 @@ class Particles extends Module {
     }
 }
 
-export { AbstractEngine, Behavior, Boundary, CanvasComposition, Collisions, DEFAULT_BEHAVIOR_ALIGNMENT, DEFAULT_BEHAVIOR_AVOID, DEFAULT_BEHAVIOR_CHASE, DEFAULT_BEHAVIOR_COHESION, DEFAULT_BEHAVIOR_REPULSION, DEFAULT_BEHAVIOR_SEPARATION, DEFAULT_BEHAVIOR_VIEW_ANGLE, DEFAULT_BEHAVIOR_VIEW_RADIUS, DEFAULT_BEHAVIOR_WANDER, DEFAULT_BOUNDARY_FRICTION, DEFAULT_BOUNDARY_MODE, DEFAULT_BOUNDARY_REPEL_DISTANCE, DEFAULT_BOUNDARY_REPEL_STRENGTH, DEFAULT_BOUNDARY_RESTITUTION, DEFAULT_COLLISIONS_RESTITUTION, DEFAULT_ENVIRONMENT_DAMPING, DEFAULT_ENVIRONMENT_FRICTION, DEFAULT_ENVIRONMENT_GRAVITY_ANGLE, DEFAULT_ENVIRONMENT_GRAVITY_DIRECTION, DEFAULT_ENVIRONMENT_GRAVITY_STRENGTH, DEFAULT_ENVIRONMENT_INERTIA, DEFAULT_FLUIDS_ENABLE_NEAR_PRESSURE, DEFAULT_FLUIDS_INFLUENCE_RADIUS, DEFAULT_FLUIDS_MAX_ACCELERATION, DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_NEAR_THRESHOLD, DEFAULT_FLUIDS_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_TARGET_DENSITY, DEFAULT_FLUIDS_VISCOSITY, DEFAULT_GRAB_GRABBED_INDEX, DEFAULT_GRAB_POSITION_X, DEFAULT_GRAB_POSITION_Y, DEFAULT_INTERACTION_MODE, DEFAULT_INTERACTION_RADIUS, DEFAULT_INTERACTION_STRENGTH, DEFAULT_JOINTS_ENABLE_JOINT_COLLISIONS, DEFAULT_JOINTS_ENABLE_PARTICLE_COLLISIONS, DEFAULT_JOINTS_FRICTION, DEFAULT_JOINTS_MOMENTUM, DEFAULT_JOINTS_RESTITUTION, DEFAULT_JOINTS_SEPARATION, DEFAULT_JOINTS_STEPS, DEFAULT_SENSORS_COLOR_SIMILARITY_THRESHOLD, DEFAULT_SENSORS_FLEE_ANGLE, DEFAULT_SENSORS_FLEE_BEHAVIOR, DEFAULT_SENSORS_FOLLOW_BEHAVIOR, DEFAULT_SENSORS_SENSOR_ANGLE, DEFAULT_SENSORS_SENSOR_DISTANCE, DEFAULT_SENSORS_SENSOR_RADIUS, DEFAULT_SENSORS_SENSOR_STRENGTH, DEFAULT_SENSORS_SENSOR_THRESHOLD, DEFAULT_TRAILS_TRAIL_DECAY, DEFAULT_TRAILS_TRAIL_DIFFUSE, DataType, Engine, Environment, Fluids, Grab, Interaction, Joints, Lines, Module, ModuleRole, OscillatorManager, Particles, ParticlesColorType, RenderPassKind, Sensors, Spawner, Trails, Vector, degToRad, radToDeg };
+export { AbstractEngine, Behavior, Boundary, CanvasComposition, Collisions, DEFAULT_BEHAVIOR_ALIGNMENT, DEFAULT_BEHAVIOR_AVOID, DEFAULT_BEHAVIOR_CHASE, DEFAULT_BEHAVIOR_COHESION, DEFAULT_BEHAVIOR_REPULSION, DEFAULT_BEHAVIOR_SEPARATION, DEFAULT_BEHAVIOR_VIEW_ANGLE, DEFAULT_BEHAVIOR_VIEW_RADIUS, DEFAULT_BEHAVIOR_WANDER, DEFAULT_BOUNDARY_FRICTION, DEFAULT_BOUNDARY_MODE, DEFAULT_BOUNDARY_REPEL_DISTANCE, DEFAULT_BOUNDARY_REPEL_STRENGTH, DEFAULT_BOUNDARY_RESTITUTION, DEFAULT_COLLISIONS_RESTITUTION, DEFAULT_ENVIRONMENT_DAMPING, DEFAULT_ENVIRONMENT_FRICTION, DEFAULT_ENVIRONMENT_GRAVITY_ANGLE, DEFAULT_ENVIRONMENT_GRAVITY_DIRECTION, DEFAULT_ENVIRONMENT_GRAVITY_STRENGTH, DEFAULT_ENVIRONMENT_INERTIA, DEFAULT_FLUIDS_ENABLE_NEAR_PRESSURE, DEFAULT_FLUIDS_INFLUENCE_RADIUS, DEFAULT_FLUIDS_MAX_ACCELERATION, DEFAULT_FLUIDS_NEAR_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_NEAR_THRESHOLD, DEFAULT_FLUIDS_PRESSURE_MULTIPLIER, DEFAULT_FLUIDS_TARGET_DENSITY, DEFAULT_FLUIDS_VISCOSITY, DEFAULT_GRAB_GRABBED_INDEX, DEFAULT_GRAB_POSITION_X, DEFAULT_GRAB_POSITION_Y, DEFAULT_INTERACTION_MODE, DEFAULT_INTERACTION_RADIUS, DEFAULT_INTERACTION_STRENGTH, DEFAULT_JOINTS_ENABLE_JOINT_COLLISIONS, DEFAULT_JOINTS_ENABLE_PARTICLE_COLLISIONS, DEFAULT_JOINTS_FRICTION, DEFAULT_JOINTS_MOMENTUM, DEFAULT_JOINTS_RESTITUTION, DEFAULT_JOINTS_SEPARATION, DEFAULT_JOINTS_STEPS, DEFAULT_PICFLIP_DENSITY, DEFAULT_PICFLIP_FLIP_RATIO, DEFAULT_PICFLIP_INFLUENCE_RADIUS, DEFAULT_PICFLIP_INTERNAL_MAX_ACCELERATION, DEFAULT_PICFLIP_PRESSURE, DEFAULT_PICFLIP_PRESSURE_MULTIPLIER, DEFAULT_PICFLIP_RADIUS, DEFAULT_PICFLIP_TARGET_DENSITY, DEFAULT_SENSORS_COLOR_SIMILARITY_THRESHOLD, DEFAULT_SENSORS_FLEE_ANGLE, DEFAULT_SENSORS_FLEE_BEHAVIOR, DEFAULT_SENSORS_FOLLOW_BEHAVIOR, DEFAULT_SENSORS_SENSOR_ANGLE, DEFAULT_SENSORS_SENSOR_DISTANCE, DEFAULT_SENSORS_SENSOR_RADIUS, DEFAULT_SENSORS_SENSOR_STRENGTH, DEFAULT_SENSORS_SENSOR_THRESHOLD, DEFAULT_TRAILS_TRAIL_DECAY, DEFAULT_TRAILS_TRAIL_DIFFUSE, DataType, Engine, Environment, Fluids, FluidsMethod, Grab, Interaction, Joints, Lines, Module, ModuleRole, OscillatorManager, Particles, ParticlesColorType, RenderPassKind, Sensors, Spawner, Trails, Vector, degToRad, radToDeg };
 //# sourceMappingURL=index.js.map