three-base 2.0.142 → 2.0.166

package/WaterFlow/SPHField.ts

@@ -1,228 +1,228 @@
-import * as THREE from 'three';
-import type { SPHFieldOptions } from './types';
-
-function createFieldTarget(width: number, height: number): THREE.WebGLRenderTarget {
-    const target = new THREE.WebGLRenderTarget(width, height, {
-        count: 2,
-        format: THREE.RGBAFormat,
-        type: THREE.HalfFloatType,
-        minFilter: THREE.LinearFilter,
-        magFilter: THREE.LinearFilter,
-        wrapS: THREE.ClampToEdgeWrapping,
-        wrapT: THREE.ClampToEdgeWrapping,
-        depthBuffer: false,
-        stencilBuffer: false,
-    });
-    target.textures[0].name = 'SPHDensityField';
-    target.textures[1].name = 'SPHMomentumField';
-    return target;
-}
-
-function createSplatGeometry(size: number, sliceLayers: number[]): THREE.BufferGeometry {
-    const particleCount = size * size;
-    const vertexCount = particleCount * sliceLayers.length;
-    const positions = new Float32Array(vertexCount * 3);
-    const lookup = new Float32Array(vertexCount * 2);
-    const sliceOffset = new Float32Array(vertexCount);
-
-    let vertex = 0;
-    for (let particle = 0; particle < particleCount; particle++) {
-        const x = particle % size;
-        const y = Math.floor(particle / size);
-        for (const offset of sliceLayers) {
-            lookup[vertex * 2] = (x + 0.5) / size;
-            lookup[vertex * 2 + 1] = (y + 0.5) / size;
-            sliceOffset[vertex] = offset;
-            vertex++;
-        }
-    }
-
-    const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
-    geometry.setAttribute('aLookup', new THREE.BufferAttribute(lookup, 2));
-    geometry.setAttribute('aSliceOffset', new THREE.BufferAttribute(sliceOffset, 1));
-    return geometry;
-}
-
-/**
- * SPH（光滑粒子流体）栅格场：把每个粒子的密度/动量 splat 进一张 3D 切片图集，
- * 供 GPUFluidSimulation 的 updateMaterial 采样（网格辅助 SPH 的「场」那一半）。
- */
-export class SPHField {
-    readonly renderer: THREE.WebGLRenderer;
-    readonly particleTextureSize: number;
-    readonly particleCount: number;
-    readonly grid: THREE.Vector3;
-    readonly tiles: THREE.Vector2;
-    readonly atlasSize: THREE.Vector2;
-    readonly domainMin: THREE.Vector3;
-    readonly domainMax: THREE.Vector3;
-    readonly cellSize: THREE.Vector3;
-    readonly gridDenominator: THREE.Vector3;
-    readonly previousClearColor: THREE.Color;
-    readonly kernelRadius: number;
-    readonly sliceLayers: number[];
-
-    readonly target: THREE.WebGLRenderTarget;
-    readonly geometry: THREE.BufferGeometry;
-    readonly scene: THREE.Scene;
-    readonly camera: THREE.OrthographicCamera;
-    readonly material: THREE.ShaderMaterial;
-    readonly points: THREE.Points;
-
-    constructor(
-        renderer: THREE.WebGLRenderer,
-        particleTextureSize: number,
-        { mobile = false }: SPHFieldOptions = {},
-    ) {
-        this.renderer = renderer;
-        this.particleTextureSize = particleTextureSize;
-        this.particleCount = particleTextureSize * particleTextureSize;
-        this.grid = new THREE.Vector3(mobile ? 48 : 64, mobile ? 30 : 36, mobile ? 20 : 28);
-        this.tiles = new THREE.Vector2(mobile ? 5 : 7, 4);
-        this.atlasSize = new THREE.Vector2(this.grid.x * this.tiles.x, this.grid.y * this.tiles.y);
-        this.domainMin = new THREE.Vector3(0.2, -0.34, -1.55);
-        this.domainMax = new THREE.Vector3(4.9, 1.92, 1.55);
-        this.cellSize = new THREE.Vector3();
-        this.gridDenominator = new THREE.Vector3(this.grid.x - 1, this.grid.y - 1, this.grid.z - 1);
-        this.previousClearColor = new THREE.Color();
-        this.kernelRadius = mobile ? 0.125 : 0.105;
-        this.sliceLayers = mobile ? [0, 1] : [-1, 0, 1];
-
-        this.target = createFieldTarget(this.atlasSize.x, this.atlasSize.y);
-        this.geometry = createSplatGeometry(particleTextureSize, this.sliceLayers);
-        this.geometry.setDrawRange(0, this.particleCount * this.sliceLayers.length);
-        this.scene = new THREE.Scene();
-        this.camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
-
-        this.material = new THREE.ShaderMaterial({
-            glslVersion: THREE.GLSL3,
-            uniforms: {
-                uPosition: { value: null },
-                uVelocity: { value: null },
-                uDomainMin: { value: this.domainMin },
-                uDomainMax: { value: this.domainMax },
-                uGrid: { value: this.grid },
-                uTiles: { value: this.tiles },
-                uAtlasSize: { value: this.atlasSize },
-                uKernelRadius: { value: this.kernelRadius },
-            },
-            vertexShader: /* glsl */`
-        precision highp float;
-        uniform sampler2D uPosition;
-        uniform sampler2D uVelocity;
-        uniform vec3 uDomainMin;
-        uniform vec3 uDomainMax;
-        uniform vec3 uGrid;
-        uniform vec2 uTiles;
-        uniform vec2 uAtlasSize;
-        uniform float uKernelRadius;
-        in vec2 aLookup;
-        in float aSliceOffset;
-        out vec3 vVelocity;
-        out float vSliceDistance;
-        out float vAlive;
-
-        void main() {
-          vec4 state = texture(uPosition, aLookup);
-          vec3 velocity = texture(uVelocity, aLookup).xyz;
-          vec3 normalizedPosition = (state.xyz - uDomainMin) / (uDomainMax - uDomainMin);
-          float sliceCoordinate = normalizedPosition.z * (uGrid.z - 1.0);
-          float slice = floor(sliceCoordinate) + aSliceOffset;
-          bool inDomain = all(greaterThanEqual(normalizedPosition, vec3(0.0)))
-                       && all(lessThanEqual(normalizedPosition, vec3(1.0)));
-          bool validSlice = slice >= 0.0 && slice < uGrid.z;
-          vAlive = step(0.0, state.w) * float(inDomain && validSlice);
-          vVelocity = velocity;
-          float cellDepth = (uDomainMax.z - uDomainMin.z) / max(uGrid.z - 1.0, 1.0);
-          vSliceDistance = (slice - sliceCoordinate) * cellDepth;
-
-          vec2 tile = vec2(mod(slice, uTiles.x), floor(slice / uTiles.x));
-          vec2 localCell = normalizedPosition.xy * (uGrid.xy - 1.0) + vec2(0.5);
-          vec2 atlasUv = (tile * uGrid.xy + localCell) / uAtlasSize;
-          gl_Position = vAlive > 0.5 ? vec4(atlasUv * 2.0 - 1.0, 0.0, 1.0) : vec4(2.0, 2.0, 2.0, 1.0);
-          vec2 cellWorld = (uDomainMax.xy - uDomainMin.xy) / max(uGrid.xy - 1.0, vec2(1.0));
-          gl_PointSize = 2.0 * uKernelRadius / max(min(cellWorld.x, cellWorld.y), 0.0001);
-        }
-      `,
-            fragmentShader: /* glsl */`
-        precision highp float;
-        uniform float uKernelRadius;
-        in vec3 vVelocity;
-        in float vSliceDistance;
-        in float vAlive;
-        layout(location = 0) out vec4 outDensity;
-        layout(location = 1) out vec4 outMomentum;
-
-        void main() {
-          if (vAlive < 0.5) discard;
-          vec2 radial = gl_PointCoord * 2.0 - 1.0;
-          float distanceSquared = dot(radial, radial)
-            + (vSliceDistance * vSliceDistance) / max(uKernelRadius * uKernelRadius, 0.000001);
-          if (distanceSquared >= 1.0) discard;
-          float kernel = pow(1.0 - distanceSquared, 3.0);
-          outDensity = vec4(kernel, 0.0, 0.0, kernel);
-          outMomentum = vec4(vVelocity * kernel, kernel);
-        }
-      `,
-            transparent: true,
-            depthTest: false,
-            depthWrite: false,
-            blending: THREE.AdditiveBlending,
-            toneMapped: false,
-        });
-
-        this.points = new THREE.Points(this.geometry, this.material);
-        this.points.frustumCulled = false;
-        this.scene.add(this.points);
-        this.updateCellSize();
-    }
-
-    updateCellSize(): void {
-        this.cellSize.copy(this.domainMax).sub(this.domainMin).divide(this.gridDenominator);
-    }
-
-    setDomain(minimum: THREE.Vector3, maximum: THREE.Vector3): void {
-        this.domainMin.copy(minimum);
-        this.domainMax.copy(maximum);
-        this.updateCellSize();
-    }
-
-    setActiveCount(count: number): void {
-        const activeCount = THREE.MathUtils.clamp(Math.floor(count), 1, this.particleCount);
-        this.geometry.setDrawRange(0, activeCount * this.sliceLayers.length);
-    }
-
-    build(positionTexture: THREE.Texture, velocityTexture: THREE.Texture): void {
-        this.material.uniforms.uPosition.value = positionTexture;
-        this.material.uniforms.uVelocity.value = velocityTexture;
-        const previousTarget = this.renderer.getRenderTarget();
-        const previousColor = this.renderer.getClearColor(this.previousClearColor);
-        const previousAlpha = this.renderer.getClearAlpha();
-        const previousAutoClear = this.renderer.autoClear;
-
-        this.renderer.autoClear = true;
-        this.renderer.setClearColor(0x000000, 0);
-        this.renderer.setRenderTarget(this.target);
-        this.renderer.clear(true, false, false);
-        this.renderer.render(this.scene, this.camera);
-
-        this.renderer.setRenderTarget(previousTarget);
-        this.renderer.setClearColor(previousColor, previousAlpha);
-        this.renderer.autoClear = previousAutoClear;
-    }
-
-    get densityTexture(): THREE.Texture {
-        return this.target.textures[0];
-    }
-
-    get momentumTexture(): THREE.Texture {
-        return this.target.textures[1];
-    }
-
-    dispose(): void {
-        this.target.dispose();
-        this.geometry.dispose();
-        this.material.dispose();
-    }
-}
+import * as THREE from 'three';
+import type { SPHFieldOptions } from './types';
+
+function createFieldTarget(width: number, height: number): THREE.WebGLRenderTarget {
+    const target = new THREE.WebGLRenderTarget(width, height, {
+        count: 2,
+        format: THREE.RGBAFormat,
+        type: THREE.HalfFloatType,
+        minFilter: THREE.LinearFilter,
+        magFilter: THREE.LinearFilter,
+        wrapS: THREE.ClampToEdgeWrapping,
+        wrapT: THREE.ClampToEdgeWrapping,
+        depthBuffer: false,
+        stencilBuffer: false,
+    });
+    target.textures[0].name = 'SPHDensityField';
+    target.textures[1].name = 'SPHMomentumField';
+    return target;
+}
+
+function createSplatGeometry(size: number, sliceLayers: number[]): THREE.BufferGeometry {
+    const particleCount = size * size;
+    const vertexCount = particleCount * sliceLayers.length;
+    const positions = new Float32Array(vertexCount * 3);
+    const lookup = new Float32Array(vertexCount * 2);
+    const sliceOffset = new Float32Array(vertexCount);
+
+    let vertex = 0;
+    for (let particle = 0; particle < particleCount; particle++) {
+        const x = particle % size;
+        const y = Math.floor(particle / size);
+        for (const offset of sliceLayers) {
+            lookup[vertex * 2] = (x + 0.5) / size;
+            lookup[vertex * 2 + 1] = (y + 0.5) / size;
+            sliceOffset[vertex] = offset;
+            vertex++;
+        }
+    }
+
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+    geometry.setAttribute('aLookup', new THREE.BufferAttribute(lookup, 2));
+    geometry.setAttribute('aSliceOffset', new THREE.BufferAttribute(sliceOffset, 1));
+    return geometry;
+}
+
+/**
+ * SPH（光滑粒子流体）栅格场：把每个粒子的密度/动量 splat 进一张 3D 切片图集，
+ * 供 GPUFluidSimulation 的 updateMaterial 采样（网格辅助 SPH 的「场」那一半）。
+ */
+export class SPHField {
+    readonly renderer: THREE.WebGLRenderer;
+    readonly particleTextureSize: number;
+    readonly particleCount: number;
+    readonly grid: THREE.Vector3;
+    readonly tiles: THREE.Vector2;
+    readonly atlasSize: THREE.Vector2;
+    readonly domainMin: THREE.Vector3;
+    readonly domainMax: THREE.Vector3;
+    readonly cellSize: THREE.Vector3;
+    readonly gridDenominator: THREE.Vector3;
+    readonly previousClearColor: THREE.Color;
+    readonly kernelRadius: number;
+    readonly sliceLayers: number[];
+
+    readonly target: THREE.WebGLRenderTarget;
+    readonly geometry: THREE.BufferGeometry;
+    readonly scene: THREE.Scene;
+    readonly camera: THREE.OrthographicCamera;
+    readonly material: THREE.ShaderMaterial;
+    readonly points: THREE.Points;
+
+    constructor(
+        renderer: THREE.WebGLRenderer,
+        particleTextureSize: number,
+        { mobile = false }: SPHFieldOptions = {},
+    ) {
+        this.renderer = renderer;
+        this.particleTextureSize = particleTextureSize;
+        this.particleCount = particleTextureSize * particleTextureSize;
+        this.grid = new THREE.Vector3(mobile ? 48 : 64, mobile ? 30 : 36, mobile ? 20 : 28);
+        this.tiles = new THREE.Vector2(mobile ? 5 : 7, 4);
+        this.atlasSize = new THREE.Vector2(this.grid.x * this.tiles.x, this.grid.y * this.tiles.y);
+        this.domainMin = new THREE.Vector3(0.2, -0.34, -1.55);
+        this.domainMax = new THREE.Vector3(4.9, 1.92, 1.55);
+        this.cellSize = new THREE.Vector3();
+        this.gridDenominator = new THREE.Vector3(this.grid.x - 1, this.grid.y - 1, this.grid.z - 1);
+        this.previousClearColor = new THREE.Color();
+        this.kernelRadius = mobile ? 0.125 : 0.105;
+        this.sliceLayers = mobile ? [0, 1] : [-1, 0, 1];
+
+        this.target = createFieldTarget(this.atlasSize.x, this.atlasSize.y);
+        this.geometry = createSplatGeometry(particleTextureSize, this.sliceLayers);
+        this.geometry.setDrawRange(0, this.particleCount * this.sliceLayers.length);
+        this.scene = new THREE.Scene();
+        this.camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+
+        this.material = new THREE.ShaderMaterial({
+            glslVersion: THREE.GLSL3,
+            uniforms: {
+                uPosition: { value: null },
+                uVelocity: { value: null },
+                uDomainMin: { value: this.domainMin },
+                uDomainMax: { value: this.domainMax },
+                uGrid: { value: this.grid },
+                uTiles: { value: this.tiles },
+                uAtlasSize: { value: this.atlasSize },
+                uKernelRadius: { value: this.kernelRadius },
+            },
+            vertexShader: /* glsl */`
+        precision highp float;
+        uniform sampler2D uPosition;
+        uniform sampler2D uVelocity;
+        uniform vec3 uDomainMin;
+        uniform vec3 uDomainMax;
+        uniform vec3 uGrid;
+        uniform vec2 uTiles;
+        uniform vec2 uAtlasSize;
+        uniform float uKernelRadius;
+        in vec2 aLookup;
+        in float aSliceOffset;
+        out vec3 vVelocity;
+        out float vSliceDistance;
+        out float vAlive;
+
+        void main() {
+          vec4 state = texture(uPosition, aLookup);
+          vec3 velocity = texture(uVelocity, aLookup).xyz;
+          vec3 normalizedPosition = (state.xyz - uDomainMin) / (uDomainMax - uDomainMin);
+          float sliceCoordinate = normalizedPosition.z * (uGrid.z - 1.0);
+          float slice = floor(sliceCoordinate) + aSliceOffset;
+          bool inDomain = all(greaterThanEqual(normalizedPosition, vec3(0.0)))
+                       && all(lessThanEqual(normalizedPosition, vec3(1.0)));
+          bool validSlice = slice >= 0.0 && slice < uGrid.z;
+          vAlive = step(0.0, state.w) * float(inDomain && validSlice);
+          vVelocity = velocity;
+          float cellDepth = (uDomainMax.z - uDomainMin.z) / max(uGrid.z - 1.0, 1.0);
+          vSliceDistance = (slice - sliceCoordinate) * cellDepth;
+
+          vec2 tile = vec2(mod(slice, uTiles.x), floor(slice / uTiles.x));
+          vec2 localCell = normalizedPosition.xy * (uGrid.xy - 1.0) + vec2(0.5);
+          vec2 atlasUv = (tile * uGrid.xy + localCell) / uAtlasSize;
+          gl_Position = vAlive > 0.5 ? vec4(atlasUv * 2.0 - 1.0, 0.0, 1.0) : vec4(2.0, 2.0, 2.0, 1.0);
+          vec2 cellWorld = (uDomainMax.xy - uDomainMin.xy) / max(uGrid.xy - 1.0, vec2(1.0));
+          gl_PointSize = 2.0 * uKernelRadius / max(min(cellWorld.x, cellWorld.y), 0.0001);
+        }
+      `,
+            fragmentShader: /* glsl */`
+        precision highp float;
+        uniform float uKernelRadius;
+        in vec3 vVelocity;
+        in float vSliceDistance;
+        in float vAlive;
+        layout(location = 0) out vec4 outDensity;
+        layout(location = 1) out vec4 outMomentum;
+
+        void main() {
+          if (vAlive < 0.5) discard;
+          vec2 radial = gl_PointCoord * 2.0 - 1.0;
+          float distanceSquared = dot(radial, radial)
+            + (vSliceDistance * vSliceDistance) / max(uKernelRadius * uKernelRadius, 0.000001);
+          if (distanceSquared >= 1.0) discard;
+          float kernel = pow(1.0 - distanceSquared, 3.0);
+          outDensity = vec4(kernel, 0.0, 0.0, kernel);
+          outMomentum = vec4(vVelocity * kernel, kernel);
+        }
+      `,
+            transparent: true,
+            depthTest: false,
+            depthWrite: false,
+            blending: THREE.AdditiveBlending,
+            toneMapped: false,
+        });
+
+        this.points = new THREE.Points(this.geometry, this.material);
+        this.points.frustumCulled = false;
+        this.scene.add(this.points);
+        this.updateCellSize();
+    }
+
+    updateCellSize(): void {
+        this.cellSize.copy(this.domainMax).sub(this.domainMin).divide(this.gridDenominator);
+    }
+
+    setDomain(minimum: THREE.Vector3, maximum: THREE.Vector3): void {
+        this.domainMin.copy(minimum);
+        this.domainMax.copy(maximum);
+        this.updateCellSize();
+    }
+
+    setActiveCount(count: number): void {
+        const activeCount = THREE.MathUtils.clamp(Math.floor(count), 1, this.particleCount);
+        this.geometry.setDrawRange(0, activeCount * this.sliceLayers.length);
+    }
+
+    build(positionTexture: THREE.Texture, velocityTexture: THREE.Texture): void {
+        this.material.uniforms.uPosition.value = positionTexture;
+        this.material.uniforms.uVelocity.value = velocityTexture;
+        const previousTarget = this.renderer.getRenderTarget();
+        const previousColor = this.renderer.getClearColor(this.previousClearColor);
+        const previousAlpha = this.renderer.getClearAlpha();
+        const previousAutoClear = this.renderer.autoClear;
+
+        this.renderer.autoClear = true;
+        this.renderer.setClearColor(0x000000, 0);
+        this.renderer.setRenderTarget(this.target);
+        this.renderer.clear(true, false, false);
+        this.renderer.render(this.scene, this.camera);
+
+        this.renderer.setRenderTarget(previousTarget);
+        this.renderer.setClearColor(previousColor, previousAlpha);
+        this.renderer.autoClear = previousAutoClear;
+    }
+
+    get densityTexture(): THREE.Texture {
+        return this.target.textures[0];
+    }
+
+    get momentumTexture(): THREE.Texture {
+        return this.target.textures[1];
+    }
+
+    dispose(): void {
+        this.target.dispose();
+        this.geometry.dispose();
+        this.material.dispose();
+    }
+}

package/WaterFlow/ScreenSpaceFluidPass.d.ts

@@ -1,69 +1,69 @@
-import * as THREE from 'three';
-import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
-import type { FluidQuality, PartialBaseTextures, ScreenSpaceFluidPassOptions, ScreenSpaceFluidSource, WaterFlowRenderOptions } from './types';
-export declare class ScreenSpaceFluidPass extends Pass {
-    /**
-     * 字段集中声明。
-     *
-     * 构造器在 `if (!this.supported) return;` 处提前返回，因此下面标注 `T | null` 的这批资源字段
-     * 在「不支持 WebGL2 / 浮点纹理」的空壳实例上**根本没被赋值**（运行时是 undefined，不是 null）。
-     * 一律建模为 `T | null` 而不是用 `!` 硬压，且所有读取点都在 `if (!this.supported) return;`
-     * 守卫之后（setSize/dispose 里原有的 `?.` 也照留），语义与原实现逐字节一致。
-     */
-    private readonly scene;
-    /** setSize 要读 camera.fov 算 pointScale，故按透视相机建模。 */
-    private readonly camera;
-    private readonly simulation;
-    private readonly supported;
-    private scale;
-    private airFraction;
-    private activeCount;
-    /** 外部注入的基础纹理；只在 renderInto 里被赋值，此前为 undefined，setBaseTextures 的 falsy 守卫会直接返回。 */
-    private externalBase;
-    /** 由 setSize 写入（构造器 supported 分支末尾调用过），空壳实例上为 undefined。 */
-    private width;
-    private height;
-    private readonly sceneTarget;
-    private readonly depthTarget;
-    private readonly thicknessTarget;
-    private readonly blurA;
-    private readonly blurB;
-    private readonly thicknessBlurA;
-    private readonly thicknessBlurB;
-    private readonly compositeTarget;
-    private readonly lookupGeometry;
-    private readonly depthMaterial;
-    private readonly thicknessMaterial;
-    private readonly sprayMaterial;
-    private readonly depthBlurMaterial;
-    private readonly thicknessBlurMaterial;
-    private readonly compositeMaterial;
-    private readonly copyMaterial;
-    private readonly particleScene;
-    private readonly sprayScene;
-    private readonly depthPoints;
-    private readonly sprayPoints;
-    private readonly fsQuad;
-    constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, simulation: ScreenSpaceFluidSource, { width, height, scale, activeCount }?: ScreenSpaceFluidPassOptions);
-    setAirFraction(value: number): void;
-    setParticleRadius(value: number): void;
-    setRetainedFluidVisible(visible: boolean): void;
-    setQuality({ scale, activeCount, blurRadius }: FluidQuality): void;
-    /** three-base 等外部调用方在 resize / 切换 baseRT 时刷新注入的基础纹理。 */
-    setBaseTextures({ colorTexture, depthTexture, depthMode }?: PartialBaseTextures): void;
-    setSize(width: number, height: number): void;
-    /** 渲染粒子深度/厚度 + 两轮分离模糊 + 厚度模糊（不输出合成、不渲染 spray）。render/renderInto 共用。 */
-    renderFluidTextures(renderer: THREE.WebGLRenderer, camera?: THREE.Camera): void;
-    /** EffectComposer 链入口（自渲染模式 / base 纹理注入模式通用，保持原行为不变）。 */
-    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget): void;
-    /**
-     * 函数式入口：直接消费调用方已有的基础颜色/深度纹理，把水面合成到指定目标。
-     * 与 three-base 的手写 fsQuad 后处理链（frosted_glass_pass 等）形态一致：
-     * 不创建/自渲染主场景，composite 先写到内部 compositeTarget，再拷回 outputTarget，
-     * 避免「读 baseRenderTarget 写 baseRenderTarget」的反馈未定义行为。
-     * @param {THREE.WebGLRenderer} renderer
-     * @param {{colorTexture:THREE.Texture,depthTexture:THREE.Texture,depthMode?:'standard'|'logarithmic',outputTarget:THREE.WebGLRenderTarget,camera:THREE.Camera}} opts
-     */
-    renderInto(renderer: THREE.WebGLRenderer, opts: WaterFlowRenderOptions): void;
-    dispose(): void;
-}
+import * as THREE from 'three';
+import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
+import type { FluidQuality, PartialBaseTextures, ScreenSpaceFluidPassOptions, ScreenSpaceFluidSource, WaterFlowRenderOptions } from './types';
+export declare class ScreenSpaceFluidPass extends Pass {
+    /**
+     * 字段集中声明。
+     *
+     * 构造器在 `if (!this.supported) return;` 处提前返回，因此下面标注 `T | null` 的这批资源字段
+     * 在「不支持 WebGL2 / 浮点纹理」的空壳实例上**根本没被赋值**（运行时是 undefined，不是 null）。
+     * 一律建模为 `T | null` 而不是用 `!` 硬压，且所有读取点都在 `if (!this.supported) return;`
+     * 守卫之后（setSize/dispose 里原有的 `?.` 也照留），语义与原实现逐字节一致。
+     */
+    private readonly scene;
+    /** setSize 要读 camera.fov 算 pointScale，故按透视相机建模。 */
+    private readonly camera;
+    private readonly simulation;
+    private readonly supported;
+    private scale;
+    private airFraction;
+    private activeCount;
+    /** 外部注入的基础纹理；只在 renderInto 里被赋值，此前为 undefined，setBaseTextures 的 falsy 守卫会直接返回。 */
+    private externalBase;
+    /** 由 setSize 写入（构造器 supported 分支末尾调用过），空壳实例上为 undefined。 */
+    private width;
+    private height;
+    private readonly sceneTarget;
+    private readonly depthTarget;
+    private readonly thicknessTarget;
+    private readonly blurA;
+    private readonly blurB;
+    private readonly thicknessBlurA;
+    private readonly thicknessBlurB;
+    private readonly compositeTarget;
+    private readonly lookupGeometry;
+    private readonly depthMaterial;
+    private readonly thicknessMaterial;
+    private readonly sprayMaterial;
+    private readonly depthBlurMaterial;
+    private readonly thicknessBlurMaterial;
+    private readonly compositeMaterial;
+    private readonly copyMaterial;
+    private readonly particleScene;
+    private readonly sprayScene;
+    private readonly depthPoints;
+    private readonly sprayPoints;
+    private readonly fsQuad;
+    constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, simulation: ScreenSpaceFluidSource, { width, height, scale, activeCount }?: ScreenSpaceFluidPassOptions);
+    setAirFraction(value: number): void;
+    setParticleRadius(value: number): void;
+    setRetainedFluidVisible(visible: boolean): void;
+    setQuality({ scale, activeCount, blurRadius }: FluidQuality): void;
+    /** three-base 等外部调用方在 resize / 切换 baseRT 时刷新注入的基础纹理。 */
+    setBaseTextures({ colorTexture, depthTexture, depthMode }?: PartialBaseTextures): void;
+    setSize(width: number, height: number): void;
+    /** 渲染粒子深度/厚度 + 两轮分离模糊 + 厚度模糊（不输出合成、不渲染 spray）。render/renderInto 共用。 */
+    renderFluidTextures(renderer: THREE.WebGLRenderer, camera?: THREE.Camera): void;
+    /** EffectComposer 链入口（自渲染模式 / base 纹理注入模式通用，保持原行为不变）。 */
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget): void;
+    /**
+     * 函数式入口：直接消费调用方已有的基础颜色/深度纹理，把水面合成到指定目标。
+     * 与 three-base 的手写 fsQuad 后处理链（frosted_glass_pass 等）形态一致：
+     * 不创建/自渲染主场景，composite 先写到内部 compositeTarget，再拷回 outputTarget，
+     * 避免「读 baseRenderTarget 写 baseRenderTarget」的反馈未定义行为。
+     * @param {THREE.WebGLRenderer} renderer
+     * @param {{colorTexture:THREE.Texture,depthTexture:THREE.Texture,depthMode?:'standard'|'logarithmic',outputTarget:THREE.WebGLRenderTarget,camera:THREE.Camera}} opts
+     */
+    renderInto(renderer: THREE.WebGLRenderer, opts: WaterFlowRenderOptions): void;
+    dispose(): void;
+}