@buley/hexgrid-3d 3.1.0 → 3.2.0

package/dist/algorithms/FlowField3D.js

@@ -0,0 +1,327 @@
+/**
+ * 3D Flow Field
+ *
+ * A 3D vector field supporting vortices, attractors, and streamline tracing.
+ * Used for creating swirling "fluid soup" motion in the Pensieve.
+ */
+import { Vector3 } from '../math/Vector3';
+/**
+ * 3D Flow Field with vortices, attractors, and sources
+ */
+export class FlowField3D {
+    constructor(config) {
+        // Sources
+        this.vortices = [];
+        this.attractors = [];
+        this.sources = [];
+        // Noise for turbulence
+        this.noiseTime = 0;
+        this.width = Math.max(1, Math.round(config.width));
+        this.height = Math.max(1, Math.round(config.height));
+        this.depth = Math.max(1, Math.round(config.depth));
+        this.resolution = config.resolution;
+        this.size = this.width * this.height * this.depth;
+        this.fieldX = new Float32Array(this.size);
+        this.fieldY = new Float32Array(this.size);
+        this.fieldZ = new Float32Array(this.size);
+    }
+    /**
+     * Add a vortex to the field
+     */
+    addVortex(center, axis, strength, radius, falloff = 'quadratic') {
+        // Normalize axis
+        const len = Math.sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
+        const normalizedAxis = new Vector3(axis.x / len, axis.y / len, axis.z / len);
+        this.vortices.push({
+            center,
+            axis: normalizedAxis,
+            strength,
+            radius,
+            falloff,
+        });
+    }
+    /**
+     * Add an attractor (positive strength) or repeller (negative strength)
+     */
+    addAttractor(center, strength, radius = 10, falloff = 'inverse-square') {
+        this.attractors.push({
+            center,
+            strength,
+            radius,
+            falloff,
+        });
+    }
+    /**
+     * Add a directional source
+     */
+    addSource(position, velocity, strength, radius = 5) {
+        // Normalize direction
+        const len = Math.sqrt(velocity.x * velocity.x +
+            velocity.y * velocity.y +
+            velocity.z * velocity.z);
+        const direction = len > 0
+            ? new Vector3(velocity.x / len, velocity.y / len, velocity.z / len)
+            : new Vector3(0, 1, 0);
+        this.sources.push({
+            position,
+            direction,
+            strength,
+            radius,
+        });
+    }
+    /**
+     * Clear all sources
+     */
+    clearSources() {
+        this.vortices = [];
+        this.attractors = [];
+        this.sources = [];
+    }
+    /**
+     * Sample the velocity at a world position
+     */
+    sample(position) {
+        let vx = 0;
+        let vy = 0;
+        let vz = 0;
+        // Contribution from vortices
+        for (const vortex of this.vortices) {
+            const contribution = this.sampleVortex(position, vortex);
+            vx += contribution.x;
+            vy += contribution.y;
+            vz += contribution.z;
+        }
+        // Contribution from attractors
+        for (const attractor of this.attractors) {
+            const contribution = this.sampleAttractor(position, attractor);
+            vx += contribution.x;
+            vy += contribution.y;
+            vz += contribution.z;
+        }
+        // Contribution from directional sources
+        for (const source of this.sources) {
+            const contribution = this.sampleSource(position, source);
+            vx += contribution.x;
+            vy += contribution.y;
+            vz += contribution.z;
+        }
+        return new Vector3(vx, vy, vz);
+    }
+    /**
+     * Sample the full field including curl and divergence
+     */
+    sampleFull(position) {
+        const velocity = this.sample(position);
+        // Compute curl numerically
+        const h = this.resolution * 0.5;
+        const vxp = this.sample(new Vector3(position.x + h, position.y, position.z));
+        const vxm = this.sample(new Vector3(position.x - h, position.y, position.z));
+        const vyp = this.sample(new Vector3(position.x, position.y + h, position.z));
+        const vym = this.sample(new Vector3(position.x, position.y - h, position.z));
+        const vzp = this.sample(new Vector3(position.x, position.y, position.z + h));
+        const vzm = this.sample(new Vector3(position.x, position.y, position.z - h));
+        const curl = new Vector3((vyp.z - vym.z - vzp.y + vzm.y) / (2 * h), (vzp.x - vzm.x - vxp.z + vxm.z) / (2 * h), (vxp.y - vxm.y - vyp.x + vym.x) / (2 * h));
+        const divergence = (vxp.x - vxm.x + vyp.y - vym.y + vzp.z - vzm.z) / (2 * h);
+        return { velocity, curl, divergence };
+    }
+    /**
+     * Trace a streamline from a starting point
+     */
+    traceStreamline(start, options = {}) {
+        const maxSteps = options.maxSteps ?? 100;
+        const stepSize = options.stepSize ?? this.resolution;
+        const minVelocity = options.minVelocity ?? 0.001;
+        const bidirectional = options.bidirectional ?? false;
+        const points = [start];
+        // Trace forward
+        let pos = new Vector3(start.x, start.y, start.z);
+        for (let i = 0; i < maxSteps; i++) {
+            const vel = this.sample(pos);
+            const speed = Math.sqrt(vel.x * vel.x + vel.y * vel.y + vel.z * vel.z);
+            if (speed < minVelocity)
+                break;
+            // Normalize and step
+            pos = new Vector3(pos.x + (vel.x / speed) * stepSize, pos.y + (vel.y / speed) * stepSize, pos.z + (vel.z / speed) * stepSize);
+            points.push(pos);
+        }
+        // Trace backward
+        if (bidirectional) {
+            pos = new Vector3(start.x, start.y, start.z);
+            const backwardPoints = [];
+            for (let i = 0; i < maxSteps; i++) {
+                const vel = this.sample(pos);
+                const speed = Math.sqrt(vel.x * vel.x + vel.y * vel.y + vel.z * vel.z);
+                if (speed < minVelocity)
+                    break;
+                // Normalize and step backward
+                pos = new Vector3(pos.x - (vel.x / speed) * stepSize, pos.y - (vel.y / speed) * stepSize, pos.z - (vel.z / speed) * stepSize);
+                backwardPoints.unshift(pos);
+            }
+            return [...backwardPoints, ...points];
+        }
+        return points;
+    }
+    /**
+     * Update the flow field (for time-varying fields)
+     */
+    update(dt) {
+        this.noiseTime += dt;
+    }
+    /**
+     * Get field dimensions
+     */
+    getDimensions() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            resolution: this.resolution,
+        };
+    }
+    // =========================================================================
+    // PRIVATE METHODS
+    // =========================================================================
+    sampleVortex(pos, vortex) {
+        // Vector from vortex center to position
+        const dx = pos.x - vortex.center.x;
+        const dy = pos.y - vortex.center.y;
+        const dz = pos.z - vortex.center.z;
+        // Project onto plane perpendicular to axis
+        // p_proj = p - (p . axis) * axis
+        const dot = dx * vortex.axis.x + dy * vortex.axis.y + dz * vortex.axis.z;
+        const px = dx - dot * vortex.axis.x;
+        const py = dy - dot * vortex.axis.y;
+        const pz = dz - dot * vortex.axis.z;
+        // Distance in plane
+        const planeDist = Math.sqrt(px * px + py * py + pz * pz);
+        if (planeDist < 0.001) {
+            return new Vector3(0, 0, 0);
+        }
+        // Calculate falloff
+        let falloff;
+        const normalizedDist = planeDist / vortex.radius;
+        if (normalizedDist > 1) {
+            falloff = 0;
+        }
+        else {
+            switch (vortex.falloff) {
+                case 'linear':
+                    falloff = 1 - normalizedDist;
+                    break;
+                case 'quadratic':
+                    falloff = (1 - normalizedDist) * (1 - normalizedDist);
+                    break;
+                case 'gaussian':
+                    falloff = Math.exp(-normalizedDist * normalizedDist * 3);
+                    break;
+                default:
+                    falloff = 1 - normalizedDist;
+            }
+        }
+        // Cross product: axis x (pos - center) gives tangent direction
+        // This creates circular motion around the axis
+        const tx = vortex.axis.y * pz - vortex.axis.z * py;
+        const ty = vortex.axis.z * px - vortex.axis.x * pz;
+        const tz = vortex.axis.x * py - vortex.axis.y * px;
+        // Normalize and apply strength
+        const tLen = Math.sqrt(tx * tx + ty * ty + tz * tz);
+        if (tLen < 0.001) {
+            return new Vector3(0, 0, 0);
+        }
+        const strength = vortex.strength * falloff;
+        return new Vector3((tx / tLen) * strength, (ty / tLen) * strength, (tz / tLen) * strength);
+    }
+    sampleAttractor(pos, attractor) {
+        const dx = attractor.center.x - pos.x;
+        const dy = attractor.center.y - pos.y;
+        const dz = attractor.center.z - pos.z;
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist < 0.001 || dist > attractor.radius) {
+            return new Vector3(0, 0, 0);
+        }
+        // Calculate falloff
+        let strength;
+        const normalizedDist = dist / attractor.radius;
+        switch (attractor.falloff) {
+            case 'linear':
+                strength = attractor.strength * (1 - normalizedDist);
+                break;
+            case 'quadratic':
+                strength =
+                    attractor.strength * (1 - normalizedDist) * (1 - normalizedDist);
+                break;
+            case 'inverse-square':
+                // Clamped inverse square to avoid singularity
+                strength = attractor.strength / Math.max(1, dist * dist);
+                break;
+            default:
+                strength = attractor.strength * (1 - normalizedDist);
+        }
+        // Direction towards/away from attractor
+        const invDist = 1 / dist;
+        return new Vector3(dx * invDist * strength, dy * invDist * strength, dz * invDist * strength);
+    }
+    sampleSource(pos, source) {
+        const dx = pos.x - source.position.x;
+        const dy = pos.y - source.position.y;
+        const dz = pos.z - source.position.z;
+        const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (dist > source.radius) {
+            return new Vector3(0, 0, 0);
+        }
+        const falloff = 1 - dist / source.radius;
+        const strength = source.strength * falloff;
+        return new Vector3(source.direction.x * strength, source.direction.y * strength, source.direction.z * strength);
+    }
+}
+/**
+ * Pensieve-specific flow field with aesthetic presets
+ */
+export class PensieveFlowField extends FlowField3D {
+    constructor(size = 100) {
+        super({
+            width: size,
+            height: size,
+            depth: size,
+            resolution: 1,
+        });
+        // Add default swirling vortices for the pensieve "soup" effect
+        this.addDefaultVortices();
+    }
+    /**
+     * Add default vortices for pensieve aesthetic
+     */
+    addDefaultVortices() {
+        const dims = this.getDimensions();
+        const center = dims.width / 2;
+        // Central upward spiral
+        this.addVortex(new Vector3(center, center * 0.3, center), new Vector3(0, 1, 0), 2, center * 0.8, 'gaussian');
+        // Secondary horizontal vortices
+        this.addVortex(new Vector3(center * 0.7, center, center), new Vector3(1, 0.3, 0), 1, center * 0.4, 'quadratic');
+        this.addVortex(new Vector3(center * 1.3, center, center), new Vector3(-1, 0.3, 0), 1, center * 0.4, 'quadratic');
+        // Gentle central attractor to keep particles from flying away
+        this.addAttractor(new Vector3(center, center, center), 0.5, center * 1.5, 'linear');
+    }
+    /**
+     * Add mouse interaction force
+     */
+    addMouseForce(position, direction, strength = 5) {
+        // Temporarily add a directional source
+        this.addSource(position, direction, strength, 10);
+    }
+    /**
+     * Clear mouse forces (call after interaction ends)
+     */
+    clearMouseForces() {
+        // Remove all directional sources but keep vortices and attractors
+        const vorticesCopy = [...this.vortices];
+        const attractorsCopy = [...this.attractors];
+        this.clearSources();
+        for (const v of vorticesCopy) {
+            this.addVortex(v.center, v.axis, v.strength, v.radius, v.falloff);
+        }
+        for (const a of attractorsCopy) {
+            this.addAttractor(a.center, a.strength, a.radius, a.falloff);
+        }
+    }
+}

package/dist/algorithms/FluidEngineFactory.d.ts

@@ -0,0 +1,15 @@
+import { StableFluids3D, FluidConfig3D } from './FluidSimulation3D';
+import { FluidSimulationWebNN } from './FluidSimulationWebNN';
+import { FluidSimulation3DGPU } from './FluidSimulation3DGPU';
+export type FluidEngine = StableFluids3D | FluidSimulationWebNN | FluidSimulation3DGPU;
+/**
+ * Factory to select the best available Fluid Engine.
+ * Priority:
+ * 1. WebNN (NPU)
+ * 2. WebGPU (GPU)
+ * 3. CPU (Fallback)
+ */
+export declare class FluidEngineFactory {
+    static create(config: FluidConfig3D): Promise<FluidEngine>;
+}
+//# sourceMappingURL=FluidEngineFactory.d.ts.map

package/dist/algorithms/FluidEngineFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluidEngineFactory.d.ts","sourceRoot":"","sources":["../../src/algorithms/FluidEngineFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,MAAM,WAAW,GAAG,cAAc,GAAG,oBAAoB,GAAG,oBAAoB,CAAC;AAEvF;;;;;;GAMG;AACH,qBAAa,kBAAkB;WAChB,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,WAAW,CAAC;CA6BjE"}

package/dist/algorithms/FluidEngineFactory.js

@@ -0,0 +1,41 @@
+import { StableFluids3D } from './FluidSimulation3D';
+import { FluidSimulationWebNN } from './FluidSimulationWebNN';
+import { FluidSimulation3DGPU } from './FluidSimulation3DGPU';
+/**
+ * Factory to select the best available Fluid Engine.
+ * Priority:
+ * 1. WebNN (NPU)
+ * 2. WebGPU (GPU)
+ * 3. CPU (Fallback)
+ */
+export class FluidEngineFactory {
+    static async create(config) {
+        // 1. Try WebNN
+        try {
+            const webnn = new FluidSimulationWebNN(config);
+            const webnnSupported = await webnn.initialize();
+            if (webnnSupported) {
+                console.log("Fluid Engine: Using WebNN (NPU)");
+                return webnn;
+            }
+        }
+        catch (e) {
+            console.warn("Fluid Engine: WebNN init failed", e);
+        }
+        // 2. Try WebGPU
+        try {
+            const webgpu = new FluidSimulation3DGPU(config);
+            const webgpuSupported = await webgpu.initialize();
+            if (webgpuSupported) {
+                console.log("Fluid Engine: Using WebGPU");
+                return webgpu;
+            }
+        }
+        catch (e) {
+            console.warn("Fluid Engine: WebGPU init failed", e);
+        }
+        // 3. Fallback to CPU
+        console.log("Fluid Engine: using CPU Fallback");
+        return new StableFluids3D(config);
+    }
+}

package/dist/algorithms/FluidSimulation.d.ts

@@ -0,0 +1,41 @@
+export interface FluidConfig {
+    width: number;
+    height: number;
+    viscosity: number;
+    diffusion: number;
+}
+export declare class StableFluids {
+    private width;
+    private height;
+    private density;
+    private velocityX;
+    private velocityY;
+    constructor(config: FluidConfig);
+    addDensity(x: number, y: number, amount: number, radius: number): void;
+    addForce(x: number, y: number, vx: number, vy: number, _radius: number): void;
+    step(_deltaTime: number): void;
+    getDensity(x: number, y: number): number;
+    getVelocity(x: number, y: number): {
+        x: number;
+        y: number;
+    };
+    getDensityField(): Float32Array;
+    getVelocityField(): {
+        x: Float32Array;
+        y: Float32Array;
+    };
+    clear(): void;
+    private indexFor;
+}
+export declare class LatticeBoltzmann {
+    constructor(_width: number, _height: number);
+}
+export declare class InfectionFluidSimulator {
+    private fluid;
+    constructor(width: number, height: number);
+    registerTerritory(_ownerId: number, x: number, y: number, intensity: number): void;
+    update(deltaTime: number): void;
+    getFluid(): StableFluids;
+    clear(): void;
+}
+//# sourceMappingURL=FluidSimulation.d.ts.map

package/dist/algorithms/FluidSimulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluidSimulation.d.ts","sourceRoot":"","sources":["../../src/algorithms/FluidSimulation.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,SAAS,CAAe;gBAEpB,MAAM,EAAE,WAAW;IAS/B,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAKtE,QAAQ,CACN,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,MAAM,GACd,IAAI;IAMP,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAQ9B,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAIxC,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAK3D,eAAe,IAAI,YAAY;IAI/B,gBAAgB,IAAI;QAAE,CAAC,EAAE,YAAY,CAAC;QAAC,CAAC,EAAE,YAAY,CAAA;KAAE;IAIxD,KAAK,IAAI,IAAI;IAMb,OAAO,CAAC,QAAQ;CAKjB;AAED,qBAAa,gBAAgB;gBACf,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAC5C;AAED,qBAAa,uBAAuB;IAClC,OAAO,CAAC,KAAK,CAAe;gBAEhB,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IASzC,iBAAiB,CACf,QAAQ,EAAE,MAAM,EAChB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,EAAE,MAAM,GAChB,IAAI;IAIP,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI/B,QAAQ,IAAI,YAAY;IAIxB,KAAK,IAAI,IAAI;CAGd"}

package/dist/algorithms/FluidSimulation.js

@@ -0,0 +1,74 @@
+export class StableFluids {
+    constructor(config) {
+        this.width = Math.max(1, Math.round(config.width));
+        this.height = Math.max(1, Math.round(config.height));
+        const size = this.width * this.height;
+        this.density = new Float32Array(size);
+        this.velocityX = new Float32Array(size);
+        this.velocityY = new Float32Array(size);
+    }
+    addDensity(x, y, amount, radius) {
+        const index = this.indexFor(x, y);
+        this.density[index] += amount;
+    }
+    addForce(x, y, vx, vy, _radius) {
+        const index = this.indexFor(x, y);
+        this.velocityX[index] += vx;
+        this.velocityY[index] += vy;
+    }
+    step(_deltaTime) {
+        // Simple damping
+        for (let i = 0; i < this.velocityX.length; i++) {
+            this.velocityX[i] *= 0.98;
+            this.velocityY[i] *= 0.98;
+        }
+    }
+    getDensity(x, y) {
+        return this.density[this.indexFor(x, y)] || 0;
+    }
+    getVelocity(x, y) {
+        const index = this.indexFor(x, y);
+        return { x: this.velocityX[index] || 0, y: this.velocityY[index] || 0 };
+    }
+    getDensityField() {
+        return this.density;
+    }
+    getVelocityField() {
+        return { x: this.velocityX, y: this.velocityY };
+    }
+    clear() {
+        this.density.fill(0);
+        this.velocityX.fill(0);
+        this.velocityY.fill(0);
+    }
+    indexFor(x, y) {
+        const ix = Math.min(this.width - 1, Math.max(0, Math.floor(x)));
+        const iy = Math.min(this.height - 1, Math.max(0, Math.floor(y)));
+        return iy * this.width + ix;
+    }
+}
+export class LatticeBoltzmann {
+    constructor(_width, _height) { }
+}
+export class InfectionFluidSimulator {
+    constructor(width, height) {
+        this.fluid = new StableFluids({
+            width,
+            height,
+            viscosity: 0,
+            diffusion: 0,
+        });
+    }
+    registerTerritory(_ownerId, x, y, intensity) {
+        this.fluid.addDensity(x, y, intensity, 1);
+    }
+    update(deltaTime) {
+        this.fluid.step(deltaTime);
+    }
+    getFluid() {
+        return this.fluid;
+    }
+    clear() {
+        this.fluid.clear();
+    }
+}

package/dist/algorithms/FluidSimulation3D.d.ts

@@ -0,0 +1,137 @@
+/**
+ * 3D Stable Fluids Implementation
+ *
+ * Based on Jos Stam's "Stable Fluids" paper (SIGGRAPH 1999)
+ * Extended to 3D for the Pensieve particle visualization.
+ *
+ * Key operations:
+ * 1. Add sources (density, velocity)
+ * 2. Diffuse (spread quantities)
+ * 3. Advect (move quantities along velocity field)
+ * 4. Project (make velocity field divergence-free)
+ */
+import { Vector3 } from '../math/Vector3';
+export interface FluidConfig3D {
+    /** Grid width in cells */
+    width: number;
+    /** Grid height in cells */
+    height: number;
+    /** Grid depth in cells */
+    depth: number;
+    /** Viscosity coefficient (0 = inviscid, higher = more viscous) */
+    viscosity: number;
+    /** Diffusion rate for density (0 = no diffusion) */
+    diffusion: number;
+    /** Number of iterations for linear solver (higher = more accurate but slower) */
+    iterations?: number;
+}
+/**
+ * 3D Stable Fluids solver for realistic fluid dynamics
+ */
+export declare class StableFluids3D {
+    private width;
+    private height;
+    private depth;
+    private size;
+    private viscosity;
+    private diffusion;
+    private iterations;
+    private density;
+    private velocityX;
+    private velocityY;
+    private velocityZ;
+    private density0;
+    private velocityX0;
+    private velocityY0;
+    private velocityZ0;
+    constructor(config: FluidConfig3D);
+    /**
+     * Add density at a point with radius falloff
+     */
+    addDensity(x: number, y: number, z: number, amount: number, radius: number): void;
+    /**
+     * Add force at a point with radius falloff
+     */
+    addForce(pos: Vector3, force: Vector3, radius: number): void;
+    /**
+     * Step the simulation forward by dt seconds
+     */
+    step(dt: number): void;
+    /**
+     * Get velocity at a point (with trilinear interpolation)
+     */
+    getVelocityAt(pos: Vector3): Vector3;
+    /**
+     * Get density at a point (with trilinear interpolation)
+     */
+    getDensityAt(pos: Vector3): number;
+    /**
+     * Get the raw velocity fields for direct access
+     */
+    getVelocityFields(): {
+        x: Float32Array;
+        y: Float32Array;
+        z: Float32Array;
+    };
+    /**
+     * Get the raw density field
+     */
+    getDensityField(): Float32Array;
+    /**
+     * Get grid dimensions
+     */
+    getDimensions(): {
+        width: number;
+        height: number;
+        depth: number;
+    };
+    /**
+     * Clear all fields
+     */
+    clear(): void;
+    private velocityStep;
+    private densityStep;
+    private addSource;
+    private diffuse;
+    private advect;
+    private project;
+    private linearSolve;
+    private setBoundary;
+    private sampleField;
+    private indexFor;
+    private indexForClamped;
+    private swap;
+}
+/**
+ * Pensieve-specific fluid simulator with aesthetic presets
+ */
+export declare class PensieveFluidSimulator {
+    private fluid;
+    private time;
+    constructor(size?: number);
+    /**
+     * Add a "memory splash" - when a particle enters the pensieve
+     */
+    addMemorySplash(position: Vector3, intensity: number): void;
+    /**
+     * Add ambient swirling motion
+     */
+    addSwirl(dt: number): void;
+    /**
+     * Step the simulation
+     */
+    step(dt: number): void;
+    /**
+     * Get velocity at a point for particle advection
+     */
+    getVelocityAt(pos: Vector3): Vector3;
+    /**
+     * Get the underlying fluid for direct access
+     */
+    getFluid(): StableFluids3D;
+    /**
+     * Clear the simulation
+     */
+    clear(): void;
+}
+//# sourceMappingURL=FluidSimulation3D.d.ts.map

package/dist/algorithms/FluidSimulation3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FluidSimulation3D.d.ts","sourceRoot":"","sources":["../../src/algorithms/FluidSimulation3D.ts"],"names":[],"mappings":"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"}