import * as THREE from 'three/webgpu';
import type { ComputeNode, Renderer, StorageBufferNode, UniformNode } from 'three/webgpu';
/** Element types used by SDF particle boundary storage buffers. */
export type SDFStorageElementType = 'float' | 'vec3';
/** Buffer attributes or existing storage nodes accepted by the SDF particle passes. */
export type SDFStorageBufferInput<TNodeType extends SDFStorageElementType> = THREE.BufferAttribute | StorageBufferNode<TNodeType>;
/** Required controls for mirrored SDF ghost-density support. */
export interface SDFBoundaryDensityPassOptions {
    particleCount: number;
    mass: number;
    poly6: number;
    h2: number;
    particleRadius: number;
    particleSpacing: number;
    texelSize: THREE.Vector3;
    is3D?: boolean;
    threshold?: number;
}
/** Uniforms attached to the mirrored SDF density-support pass. */
export interface SDFBoundaryDensityUniforms {
    inverseBoundsMatrix: UniformNode<'mat4', THREE.Matrix4>;
    boundsMatrix: UniformNode<'mat4', THREE.Matrix4>;
    texelSize: UniformNode<'vec3', THREE.Vector3>;
    mass: UniformNode<'float', number>;
    poly6: UniformNode<'float', number>;
    h2: UniformNode<'float', number>;
    particleRadius: UniformNode<'float', number>;
    particleSpacing: UniformNode<'float', number>;
    threshold: UniformNode<'float', number>;
}
/** Compute node returned by {@link createSDFBoundaryDensityPass}. */
export interface SDFBoundaryDensityPass extends ComputeNode {
    uniforms: SDFBoundaryDensityUniforms;
}
/** Configuration for particle position/velocity response against an SDF boundary. */
export interface SDFBoundaryPassOptions {
    particleCount: number;
    stiffness?: number;
    damping?: number;
    threshold?: number;
    texelSize?: THREE.Vector3 | null;
    positionCorrection?: boolean;
    velocityResponse?: boolean;
    hardProjection?: boolean;
}
/** Uniforms attached to an SDF particle boundary pass. */
export interface SDFBoundaryUniforms {
    inverseBoundsMatrix: UniformNode<'mat4', THREE.Matrix4>;
    boundsMatrix: UniformNode<'mat4', THREE.Matrix4>;
    texelSize: UniformNode<'vec3', THREE.Vector3>;
    stiffness: UniformNode<'float', number>;
    damping: UniformNode<'float', number>;
    threshold: UniformNode<'float', number>;
    positionCorrection: UniformNode<'uint', number>;
    velocityResponse: UniformNode<'uint', number>;
    hardProjection: UniformNode<'uint', number>;
}
/** Compute node returned by {@link createSDFBoundaryPass}. */
export interface SDFBoundaryPass extends ComputeNode {
    uniforms: SDFBoundaryUniforms;
}
/** SDF generator resource surface consumed by {@link SDFVolumeConstraint}. */
export interface SDFVolumeConstraintSource {
    sdfTexture?: THREE.Storage3DTexture | null;
    resolution: number;
    inverseBoundsMatrix: THREE.Matrix4;
    boundsMatrix: THREE.Matrix4;
}
/** Persistent SDF boundary tuning. */
export interface SDFVolumeConstraintOptions {
    stiffness?: number;
    damping?: number;
    threshold?: number;
    particleRadius?: number;
}
/** Per-dispatch SDF boundary scheduling controls. */
export interface SDFBoundaryApplyOptions {
    particleRadius?: number;
    positionOnly?: boolean;
    velocityOnly?: boolean;
    hardProjection?: boolean;
}
/** Numeric fluid calibration value consumed by density support. */
export interface SDFScalarControl {
    value: number;
}
/** Fluid calibration surface used when contributing mirrored density support. */
export interface SDFDensityFluid {
    buffers: {
        positions: SDFStorageBufferInput<'vec3'>;
        densities: SDFStorageBufferInput<'float'>;
    };
    particleCount: number;
    ubos: {
        mass: SDFScalarControl;
        poly6Kernel: SDFScalarControl;
        h2: SDFScalarControl;
    };
    particleRadius: number;
    _particleSpacing: number;
    is3D: boolean;
}
/** Create mirrored ghost-particle density support for an SDF containment boundary. */
export declare function createSDFBoundaryDensityPass(positionsBuffer: SDFStorageBufferInput<'vec3'>, densitiesBuffer: SDFStorageBufferInput<'float'>, sdfTexture: THREE.Storage3DTexture, inverseBoundsMatrix: THREE.Matrix4, boundsMatrix: THREE.Matrix4, options: SDFBoundaryDensityPassOptions): SDFBoundaryDensityPass;
/**
 * Creates a compute pass that enforces SDF volume boundary constraints for particle simulations.
 *
 * Applies penalty forces to particles that penetrate the SDF boundary, pushing them
 * back inside the volume and reflecting their velocities.
 *
 * **Use Cases:**
 * - SPH simulations with complex boundaries
 * - Boids flocking within defined volumes
 * - Particle systems constrained to arbitrary shapes
 *
 * This implementation-level API is intentionally internal and has no public package import.
 */
export declare function createSDFBoundaryPass(positionsBuffer: SDFStorageBufferInput<'vec3'>, velocitiesBuffer: SDFStorageBufferInput<'vec3'>, sdfTexture: THREE.Storage3DTexture, inverseBoundsMatrix: THREE.Matrix4, boundsMatrix: THREE.Matrix4, options: SDFBoundaryPassOptions): SDFBoundaryPass;
/**
 * SDFVolumeConstraint class wrapper for easier integration with simulation systems.
 *
 * @example
 * const constraint = new SDFVolumeConstraint(sdfGenerator, {
 *   stiffness: 1000,
 *   damping: 0.5
 * });
 *
 * // In simulation loop
 * await constraint.apply(renderer, positionsBuffer, velocitiesBuffer, particleCount);
 */
export declare class SDFVolumeConstraint {
    sdfGenerator: SDFVolumeConstraintSource | null;
    stiffness: number;
    damping: number;
    threshold: number;
    private _computeNode;
    private _cachedParticleCount;
    private _cachedSDFTexture;
    private _cachedPositionsBuffer;
    private _cachedVelocitiesBuffer;
    private _densityComputeNode;
    private _cachedDensityBuffer;
    private _cachedDensityParticleCount;
    private _cachedDensitySDFTexture;
    private _cachedDensityPositionsBuffer;
    /**
     * @param {ComputeSDFGenerator} sdfGenerator - SDF generator instance
     * @param {Object} [options] - Configuration options
     * @param {number} [options.stiffness=1000.0] - Boundary stiffness
     * @param {number} [options.damping=0.5] - Velocity damping
     * @param {number} [options.threshold=0.0] - SDF boundary threshold
     * @param {number} [options.particleRadius=0] - Per-apply inward center offset, supplied through `apply()` options.
     */
    constructor(sdfGenerator: SDFVolumeConstraintSource | null, options?: SDFVolumeConstraintOptions);
    /** Add mirrored ghost density samples near the SDF surface. */
    contributeDensity(renderer: Renderer, fluid: SDFDensityFluid): Promise<void>;
    /**
     * Applies the SDF boundary constraint to particle buffers.
     *
     * @param {THREE.WebGPURenderer} renderer - WebGPU renderer
     * @param {THREE.StorageBufferAttribute} positionsBuffer - Particle positions
     * @param {THREE.StorageBufferAttribute} velocitiesBuffer - Particle velocities
     * @param {number} particleCount - Number of particles
     * @param {Object} [options] - Scheduling options.
     * @param {number} [options.particleRadius=0] - Inward center offset in world-distance units.
     * @param {boolean} [options.positionOnly=false] - Apply position projection without velocity response.
     * @param {boolean} [options.velocityOnly=false] - Apply velocity response without position projection.
     * @param {boolean} [options.hardProjection=false] - Fully resolve penetration in one dispatch.
     * @returns {Promise<void>}
     */
    apply(renderer: Renderer, positionsBuffer: SDFStorageBufferInput<'vec3'>, velocitiesBuffer: SDFStorageBufferInput<'vec3'>, particleCount: number, options?: SDFBoundaryApplyOptions): Promise<void>;
    /**
     * Updates the SDF generator (useful when SDF is regenerated).
     *
     * @param {ComputeSDFGenerator} sdfGenerator - New SDF generator
     */
    updateSDF(sdfGenerator: SDFVolumeConstraintSource | null): void;
    /** Release cached compute nodes. */
    dispose(): void;
}