three-base 2.0.137 → 2.0.145

package/WaterFlow/SPHField.d.ts

@@ -0,0 +1,35 @@
+import * as THREE from 'three';
+import type { SPHFieldOptions } from './types';
+/**
+ * SPH（光滑粒子流体）栅格场：把每个粒子的密度/动量 splat 进一张 3D 切片图集，
+ * 供 GPUFluidSimulation 的 updateMaterial 采样（网格辅助 SPH 的「场」那一半）。
+ */
+export declare 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 }?: SPHFieldOptions);
+    updateCellSize(): void;
+    setDomain(minimum: THREE.Vector3, maximum: THREE.Vector3): void;
+    setActiveCount(count: number): void;
+    build(positionTexture: THREE.Texture, velocityTexture: THREE.Texture): void;
+    get densityTexture(): THREE.Texture;
+    get momentumTexture(): THREE.Texture;
+    dispose(): void;
+}

package/WaterFlow/SPHField.js

@@ -0,0 +1,204 @@
+import * as THREE from 'three';
+function createFieldTarget(width, height) {
+    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, sliceLayers) {
+    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 {
+    renderer;
+    particleTextureSize;
+    particleCount;
+    grid;
+    tiles;
+    atlasSize;
+    domainMin;
+    domainMax;
+    cellSize;
+    gridDenominator;
+    previousClearColor;
+    kernelRadius;
+    sliceLayers;
+    target;
+    geometry;
+    scene;
+    camera;
+    material;
+    points;
+    constructor(renderer, particleTextureSize, { mobile = false } = {}) {
+        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() {
+        this.cellSize.copy(this.domainMax).sub(this.domainMin).divide(this.gridDenominator);
+    }
+    setDomain(minimum, maximum) {
+        this.domainMin.copy(minimum);
+        this.domainMax.copy(maximum);
+        this.updateCellSize();
+    }
+    setActiveCount(count) {
+        const activeCount = THREE.MathUtils.clamp(Math.floor(count), 1, this.particleCount);
+        this.geometry.setDrawRange(0, activeCount * this.sliceLayers.length);
+    }
+    build(positionTexture, velocityTexture) {
+        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() {
+        return this.target.textures[0];
+    }
+    get momentumTexture() {
+        return this.target.textures[1];
+    }
+    dispose() {
+        this.target.dispose();
+        this.geometry.dispose();
+        this.material.dispose();
+    }
+}

package/WaterFlow/SPHField.ts

@@ -0,0 +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();
+    }
+}

package/WaterFlow/ScreenSpaceFluidPass.d.ts

@@ -0,0 +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;
+}