three-base 2.0.169 → 2.0.175

package/WaterFlow/ReservoirSystem.js

@@ -1,621 +0,0 @@
-import * as THREE from 'three';
-import { ShallowWaterSurface } from './ShallowWaterSurface';
-export class ReservoirSystem {
-    /** 几何口径（全部由构造参数推导，构造后不变）。 */
-    length;
-    width;
-    bottomY;
-    rimY;
-    innerBottomY;
-    maxWaterY;
-    innerLength;
-    innerWidth;
-    surfaceArea;
-    capacity;
-    /** 水量与溢流状态（每帧变化）。 */
-    volume;
-    overflowRate;
-    motionOverflowRate;
-    overflowIntensity;
-    active;
-    particleFluidMode;
-    /** 容器晃动（xz 两个分量复用 Vector2 的 x/y）。 */
-    motionPreviousPosition;
-    motionVelocity;
-    motionAcceleration;
-    sloshOffset;
-    sloshVelocity;
-    motionWaveImpulse;
-    /** 池体节点与拾取体。 */
-    renderer;
-    group;
-    hitMeshes;
-    rimFoamMaterial;
-    rimFoamGroup;
-    waterMaterial;
-    waterBody;
-    /** 浅水波面；非WebGL2 或缺浮点扩展时为 null（此时只保留水体盒）。 */
-    surface;
-    overflowMaterial;
-    overflowGroup;
-    /** 溢流粒子（GPU points）的缓冲与状态。 */
-    dropCount;
-    dropPositions;
-    dropVelocities;
-    dropLife;
-    dropMaxLife;
-    dropBounces;
-    dropSizes;
-    dropAlpha;
-    dropCursor;
-    dropAccumulator;
-    dropMaterial;
-    spillPoints;
-    constructor(renderer, { flowTexture, length = 1.72, width = 1.28, bottomY = -0.13, rimY = 1.14, centerX = 1.82, centerZ = 0, waveWidth = 192, waveHeight = 128, } = {}) {
-        this.renderer = renderer;
-        this.length = length;
-        this.width = width;
-        this.bottomY = bottomY;
-        this.rimY = rimY;
-        this.innerBottomY = bottomY + 0.11;
-        this.maxWaterY = rimY - 0.024;
-        this.innerLength = length - 0.14;
-        this.innerWidth = width - 0.14;
-        this.surfaceArea = this.innerLength * this.innerWidth;
-        this.capacity = this.surfaceArea * (this.maxWaterY - this.innerBottomY);
-        this.volume = 0;
-        this.overflowRate = 0;
-        this.motionOverflowRate = 0;
-        this.overflowIntensity = 0;
-        this.active = false;
-        this.motionPreviousPosition = new THREE.Vector2(centerX, centerZ);
-        this.motionVelocity = new THREE.Vector2();
-        this.motionAcceleration = new THREE.Vector2();
-        this.sloshOffset = new THREE.Vector2();
-        this.sloshVelocity = new THREE.Vector2();
-        this.motionWaveImpulse = new THREE.Vector2();
-        this.particleFluidMode = false;
-        this.group = new THREE.Group();
-        this.group.position.set(centerX, 0, centerZ);
-        this.hitMeshes = [];
-        const steel = new THREE.MeshStandardMaterial({ color: 0x71878d, roughness: 0.2, metalness: 0.92 });
-        const darkSteel = new THREE.MeshStandardMaterial({ color: 0x172a30, roughness: 0.36, metalness: 0.78 });
-        const glass = new THREE.MeshPhysicalMaterial({
-            color: 0x9edbe2,
-            metalness: 0,
-            roughness: 0.08,
-            transmission: 0.9,
-            transparent: true,
-            opacity: 0.19,
-            thickness: 0.04,
-            ior: 1.48,
-            clearcoat: 1,
-            clearcoatRoughness: 0.04,
-            depthWrite: false,
-            side: THREE.DoubleSide,
-        });
-        const wallThickness = 0.035;
-        const tankHeight = rimY - bottomY;
-        const frontBackGeometry = new THREE.BoxGeometry(length, tankHeight, wallThickness);
-        const sideGeometry = new THREE.BoxGeometry(wallThickness, tankHeight, width);
-        [-1, 1].forEach((side) => {
-            const wall = new THREE.Mesh(frontBackGeometry, glass);
-            wall.position.set(0, bottomY + tankHeight * 0.5, side * width * 0.5);
-            wall.renderOrder = 6;
-            this.group.add(wall);
-            this.hitMeshes.push(wall);
-        });
-        [-1, 1].forEach((side) => {
-            const wall = new THREE.Mesh(sideGeometry, glass);
-            wall.position.set(side * length * 0.5, bottomY + tankHeight * 0.5, 0);
-            wall.renderOrder = 6;
-            this.group.add(wall);
-            this.hitMeshes.push(wall);
-        });
-        const base = new THREE.Mesh(new THREE.BoxGeometry(length + 0.08, 0.09, width + 0.08), darkSteel);
-        base.position.y = bottomY + 0.025;
-        base.castShadow = true;
-        base.receiveShadow = true;
-        this.group.add(base);
-        this.hitMeshes.push(base);
-        const rail = 0.045;
-        const verticalGeometry = new THREE.BoxGeometry(rail, tankHeight + 0.08, rail);
-        for (const x of [-1, 1]) {
-            for (const z of [-1, 1]) {
-                const post = new THREE.Mesh(verticalGeometry, steel);
-                post.position.set(x * length * 0.5, bottomY + tankHeight * 0.5, z * width * 0.5);
-                post.castShadow = true;
-                this.group.add(post);
-            }
-        }
-        const railXGeometry = new THREE.BoxGeometry(length + 0.08, rail, rail);
-        const railZGeometry = new THREE.BoxGeometry(rail, rail, width + 0.08);
-        for (const y of [bottomY + 0.035, rimY]) {
-            for (const z of [-1, 1]) {
-                const edge = new THREE.Mesh(railXGeometry, steel);
-                edge.position.set(0, y, z * width * 0.5);
-                edge.castShadow = true;
-                this.group.add(edge);
-            }
-            for (const x of [-1, 1]) {
-                const edge = new THREE.Mesh(railZGeometry, steel);
-                edge.position.set(x * length * 0.5, y, 0);
-                edge.castShadow = true;
-                this.group.add(edge);
-            }
-        }
-        this.rimFoamMaterial = new THREE.MeshBasicMaterial({
-            color: 0xbdeff4,
-            transparent: true,
-            opacity: 0,
-            depthWrite: false,
-            blending: THREE.AdditiveBlending,
-        });
-        this.rimFoamGroup = new THREE.Group();
-        const foamX = new THREE.BoxGeometry(this.innerLength * 0.96, 0.012, 0.025);
-        const foamZ = new THREE.BoxGeometry(0.025, 0.012, this.innerWidth * 0.96);
-        for (const z of [-1, 1]) {
-            const foam = new THREE.Mesh(foamX, this.rimFoamMaterial);
-            foam.position.set(0, this.maxWaterY + 0.014, z * this.innerWidth * 0.5);
-            this.rimFoamGroup.add(foam);
-        }
-        for (const x of [-1, 1]) {
-            const foam = new THREE.Mesh(foamZ, this.rimFoamMaterial);
-            foam.position.set(x * this.innerLength * 0.5, this.maxWaterY + 0.014, 0);
-            this.rimFoamGroup.add(foam);
-        }
-        this.group.add(this.rimFoamGroup);
-        this.waterMaterial = new THREE.ShaderMaterial({
-            uniforms: {
-                uTime: { value: 0 },
-                uFlowMap: { value: flowTexture },
-                uOpacity: { value: 0.42 },
-            },
-            vertexShader: /* glsl */ `
-        varying vec2 vUv;
-        varying vec3 vWorldPosition;
-        varying vec3 vWorldNormal;
-        void main() {
-          vUv = uv;
-          vec4 world = modelMatrix * vec4(position, 1.0);
-          vWorldPosition = world.xyz;
-          vWorldNormal = normalize(mat3(modelMatrix) * normal);
-          gl_Position = projectionMatrix * viewMatrix * world;
-        }
-      `,
-            fragmentShader: /* glsl */ `
-        uniform float uTime;
-        uniform float uOpacity;
-        uniform sampler2D uFlowMap;
-        varying vec2 vUv;
-        varying vec3 vWorldPosition;
-        varying vec3 vWorldNormal;
-        void main() {
-          vec3 viewDir = normalize(cameraPosition - vWorldPosition);
-          float fresnel = 0.02 + 0.98 * pow(1.0 - abs(dot(viewDir, normalize(vWorldNormal))), 5.0);
-          vec3 detail = texture2D(uFlowMap, vUv * vec2(1.6, 2.8) + vec2(0.0, uTime * 0.018)).rgb;
-          float depthTint = smoothstep(-0.2, 1.2, vWorldPosition.y);
-          vec3 color = mix(vec3(0.008, 0.12, 0.16), vec3(0.035, 0.34, 0.4), depthTint);
-          color += detail * 0.035 + vec3(0.2, 0.62, 0.68) * fresnel * 0.42;
-          gl_FragColor = vec4(color, uOpacity + fresnel * 0.18);
-        }
-      `,
-            transparent: true,
-            depthWrite: false,
-            side: THREE.DoubleSide,
-        });
-        this.waterBody = new THREE.Mesh(new THREE.BoxGeometry(this.innerLength, 1, this.innerWidth), this.waterMaterial);
-        this.waterBody.renderOrder = 3;
-        this.group.add(this.waterBody);
-        this.surface = renderer.capabilities.isWebGL2 && renderer.extensions.has('EXT_color_buffer_float')
-            ? new ShallowWaterSurface(renderer, {
-                width: waveWidth,
-                height: waveHeight,
-                basinMinX: centerX - this.innerLength * 0.5,
-                basinMaxX: centerX + this.innerLength * 0.5,
-                basinHalfZ: this.innerWidth * 0.5,
-                basinCenterZ: centerZ,
-                waterY: this.innerBottomY,
-                cpuSampling: true,
-            })
-            : null;
-        if (this.surface)
-            this.surface.mesh.renderOrder = 5;
-        this.overflowMaterial = new THREE.ShaderMaterial({
-            uniforms: {
-                uTime: { value: 0 },
-                uOverflow: { value: 0 },
-                uFlowMap: { value: flowTexture },
-            },
-            vertexShader: /* glsl */ `
-        uniform float uTime;
-        uniform float uOverflow;
-        varying vec2 vUv;
-        void main() {
-          vUv = uv;
-          vec3 p = position;
-          float fall = 1.0 - uv.y;
-          p.x *= mix(0.7, 1.0, uv.y);
-          p.z += sin(uv.x * 29.0 + uTime * 5.0) * 0.012 * fall * uOverflow;
-          p.y -= sin(uv.x * 17.0 + uTime * 3.7) * 0.016 * fall;
-          gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
-        }
-      `,
-            fragmentShader: /* glsl */ `
-        uniform float uTime;
-        uniform float uOverflow;
-        uniform sampler2D uFlowMap;
-        varying vec2 vUv;
-        void main() {
-          vec2 flowUvA = vec2(vUv.x * 5.7 + uTime * 0.035, vUv.y * 7.5 + uTime * 0.82);
-          vec2 flowUvB = vec2(vUv.x * 9.3 - uTime * 0.028, vUv.y * 4.2 + uTime * 0.57);
-          float noiseA = dot(texture2D(uFlowMap, flowUvA).rgb, vec3(0.2, 0.58, 0.22));
-          float noiseB = dot(texture2D(uFlowMap, flowUvB).rgb, vec3(0.35, 0.5, 0.15));
-          float noise = mix(noiseA, noiseB, 0.46);
-          float rivuletField = 0.5 + 0.5 * sin(vUv.x * 71.0 + noise * 9.0 + sin(vUv.y * 13.0) * 2.2);
-          float rivulets = smoothstep(0.54 - uOverflow * 0.08, 0.86, rivuletField);
-          float edge = smoothstep(0.0, 0.13, vUv.x) * smoothstep(1.0, 0.87, vUv.x);
-          float verticalFade = smoothstep(0.0, 0.12, vUv.y);
-          float breakup = smoothstep(0.27, 0.76, noise + vUv.y * 0.16);
-          float alpha = edge * verticalFade * rivulets * breakup * (0.2 + uOverflow * 0.62);
-          if (alpha < 0.025 || uOverflow < 0.01) discard;
-          vec3 color = mix(vec3(0.045, 0.32, 0.38), vec3(0.58, 0.92, 0.97), noise * 0.3);
-          gl_FragColor = vec4(color, alpha);
-        }
-      `,
-            transparent: true,
-            depthWrite: false,
-            side: THREE.DoubleSide,
-        });
-        this.overflowGroup = new THREE.Group();
-        const sheetHeight = 0.62;
-        const makeSheet = (sheetWidth, x, z, rotationY = 0) => {
-            const sheet = new THREE.Mesh(new THREE.PlaneGeometry(sheetWidth, sheetHeight, 48, 24), this.overflowMaterial);
-            sheet.position.set(x, rimY - sheetHeight * 0.5 - 0.012, z);
-            sheet.rotation.y = rotationY;
-            sheet.renderOrder = 7;
-            this.overflowGroup.add(sheet);
-        };
-        makeSheet(length * 0.78, 0, -width * 0.5 - 0.026);
-        makeSheet(length * 0.78, 0, width * 0.5 + 0.026);
-        makeSheet(width * 0.72, -length * 0.5 - 0.026, 0, Math.PI * 0.5);
-        makeSheet(width * 0.72, length * 0.5 + 0.026, 0, Math.PI * 0.5);
-        this.group.add(this.overflowGroup);
-        this.dropCount = waveWidth <= 112 ? 650 : 1400;
-        this.dropPositions = new Float32Array(this.dropCount * 3);
-        this.dropVelocities = new Float32Array(this.dropCount * 3);
-        this.dropLife = new Float32Array(this.dropCount);
-        this.dropMaxLife = new Float32Array(this.dropCount);
-        this.dropBounces = new Uint8Array(this.dropCount);
-        this.dropSizes = new Float32Array(this.dropCount);
-        this.dropAlpha = new Float32Array(this.dropCount);
-        this.dropCursor = 0;
-        this.dropAccumulator = 0;
-        this.dropPositions.fill(-100);
-        const dropGeometry = new THREE.BufferGeometry();
-        const positionAttribute = new THREE.BufferAttribute(this.dropPositions, 3);
-        positionAttribute.setUsage(THREE.DynamicDrawUsage);
-        const alphaAttribute = new THREE.BufferAttribute(this.dropAlpha, 1);
-        alphaAttribute.setUsage(THREE.DynamicDrawUsage);
-        const sizeAttribute = new THREE.BufferAttribute(this.dropSizes, 1);
-        sizeAttribute.setUsage(THREE.DynamicDrawUsage);
-        dropGeometry.setAttribute('position', positionAttribute);
-        dropGeometry.setAttribute('aAlpha', alphaAttribute);
-        dropGeometry.setAttribute('aSize', sizeAttribute);
-        this.dropMaterial = new THREE.ShaderMaterial({
-            uniforms: {
-                uPixelRatio: { value: Math.min(devicePixelRatio, 2) },
-            },
-            vertexShader: /* glsl */ `
-        attribute float aAlpha;
-        attribute float aSize;
-        uniform float uPixelRatio;
-        varying float vAlpha;
-        void main() {
-          vec4 mv = modelViewMatrix * vec4(position, 1.0);
-          gl_Position = aAlpha > 0.001 ? projectionMatrix * mv : vec4(2.0, 2.0, 2.0, 1.0);
-          gl_PointSize = min(7.5, aSize * uPixelRatio * (5.0 / max(2.0, -mv.z)));
-          vAlpha = aAlpha;
-        }
-      `,
-            fragmentShader: /* glsl */ `
-        varying float vAlpha;
-        void main() {
-          float d = length(gl_PointCoord - 0.5);
-          if (d > 0.5) discard;
-          float core = smoothstep(0.5, 0.08, d);
-          float glint = 1.0 - smoothstep(0.015, 0.13, distance(gl_PointCoord, vec2(0.34, 0.3)));
-          float alpha = core * vAlpha;
-          gl_FragColor = vec4(vec3(0.42, 0.87, 0.96) + glint * 0.45, alpha);
-        }
-      `,
-            transparent: true,
-            depthWrite: false,
-            blending: THREE.AdditiveBlending,
-            toneMapped: false,
-        });
-        this.spillPoints = new THREE.Points(dropGeometry, this.dropMaterial);
-        this.spillPoints.frustumCulled = false;
-        this.spillPoints.renderOrder = 8;
-        this.reset();
-        this.setActive(false);
-    }
-    setActive(active) {
-        this.active = active;
-        this.group.visible = active;
-        if (this.surface)
-            this.surface.mesh.visible = active && this.volume > 0.0005 && !this.particleFluidMode;
-        if (active)
-            this.motionPreviousPosition.set(this.centerX, this.centerZ);
-    }
-    setParticleFluidMode(enabled) {
-        this.particleFluidMode = Boolean(enabled);
-        this.updateGeometry();
-    }
-    moveTo(x, z) {
-        this.group.position.x = x;
-        this.group.position.z = z;
-        this.updateGeometry();
-    }
-    reset(fillRatio = 0) {
-        this.volume = this.capacity * THREE.MathUtils.clamp(fillRatio, 0, 1);
-        this.overflowRate = 0;
-        this.motionOverflowRate = 0;
-        this.overflowIntensity = 0;
-        this.clearSpillParticles();
-        this.surface?.clear();
-        this.motionPreviousPosition.set(this.centerX, this.centerZ);
-        this.motionVelocity.set(0, 0);
-        this.motionAcceleration.set(0, 0);
-        this.sloshOffset.set(0, 0);
-        this.sloshVelocity.set(0, 0);
-        this.motionWaveImpulse.set(0, 0);
-        this.surface?.setContainerMotion(0, 0, 0, 0);
-        this.updateGeometry();
-    }
-    updateContainerMotion(delta) {
-        const safeDelta = Math.max(delta, 1 / 240);
-        const currentX = this.centerX;
-        const currentZ = this.centerZ;
-        const rawVelocityX = THREE.MathUtils.clamp((currentX - this.motionPreviousPosition.x) / safeDelta, -3.4, 3.4);
-        const rawVelocityZ = THREE.MathUtils.clamp((currentZ - this.motionPreviousPosition.y) / safeDelta, -3.4, 3.4);
-        const previousVelocityX = this.motionVelocity.x;
-        const previousVelocityZ = this.motionVelocity.y;
-        const velocityResponse = 1 - Math.exp(-safeDelta * 18);
-        this.motionVelocity.x = THREE.MathUtils.lerp(previousVelocityX, rawVelocityX, velocityResponse);
-        this.motionVelocity.y = THREE.MathUtils.lerp(previousVelocityZ, rawVelocityZ, velocityResponse);
-        this.motionAcceleration.x = THREE.MathUtils.clamp((this.motionVelocity.x - previousVelocityX) / safeDelta, -22, 22);
-        this.motionAcceleration.y = THREE.MathUtils.clamp((this.motionVelocity.y - previousVelocityZ) / safeDelta, -22, 22);
-        this.motionPreviousPosition.set(currentX, currentZ);
-        const omega = 3.65;
-        const damping = 0.28;
-        const targetX = THREE.MathUtils.clamp(-this.motionAcceleration.x / 9.81 * this.innerLength * 0.5, -0.18, 0.18);
-        const targetZ = THREE.MathUtils.clamp(-this.motionAcceleration.y / 9.81 * this.innerWidth * 0.5, -0.15, 0.15);
-        const dampingForce = 2 * damping * omega;
-        this.sloshVelocity.x += ((targetX - this.sloshOffset.x) * omega * omega - this.sloshVelocity.x * dampingForce) * safeDelta;
-        this.sloshVelocity.y += ((targetZ - this.sloshOffset.y) * omega * omega - this.sloshVelocity.y * dampingForce) * safeDelta;
-        this.sloshOffset.addScaledVector(this.sloshVelocity, safeDelta);
-        this.sloshOffset.x = THREE.MathUtils.clamp(this.sloshOffset.x, -0.16, 0.16);
-        this.sloshOffset.y = THREE.MathUtils.clamp(this.sloshOffset.y, -0.13, 0.13);
-        this.motionWaveImpulse.set(-this.motionAcceleration.x * safeDelta * 0.00015, -this.motionAcceleration.y * safeDelta * 0.00015);
-        if (!this.active || this.volume < 0.0005) {
-            this.sloshOffset.multiplyScalar(Math.exp(-safeDelta * 5));
-            this.sloshVelocity.multiplyScalar(Math.exp(-safeDelta * 5));
-            this.motionWaveImpulse.set(0, 0);
-        }
-        this.surface?.setContainerMotion(this.sloshOffset.x, this.sloshOffset.y, this.motionWaveImpulse.x, this.motionWaveImpulse.y);
-    }
-    clearSpillParticles() {
-        if (!this.dropLife)
-            return;
-        this.dropLife.fill(0);
-        this.dropAlpha.fill(0);
-        this.dropPositions.fill(-100);
-        this.dropAccumulator = 0;
-        if (this.spillPoints) {
-            this.spillPoints.geometry.attributes.position.needsUpdate = true;
-            this.spillPoints.geometry.attributes.aAlpha.needsUpdate = true;
-        }
-    }
-    spawnSpillParticle() {
-        let index = -1;
-        for (let attempt = 0; attempt < this.dropCount; attempt++) {
-            const candidate = (this.dropCursor + attempt) % this.dropCount;
-            if (this.dropLife[candidate] <= 0) {
-                index = candidate;
-                this.dropCursor = (candidate + 1) % this.dropCount;
-                break;
-            }
-        }
-        if (index < 0)
-            return;
-        let edge = Math.floor(Math.random() * 4);
-        if (this.motionOverflowRate > 0.002) {
-            if (Math.abs(this.sloshOffset.x) > Math.abs(this.sloshOffset.y)) {
-                edge = this.sloshOffset.x >= 0 ? 3 : 2;
-            }
-            else {
-                edge = this.sloshOffset.y >= 0 ? 0 : 1;
-            }
-        }
-        const along = Math.random() - 0.5;
-        const speedOut = 0.1 + Math.random() * 0.24 + this.overflowIntensity * 0.22;
-        const velocityOffset = index * 3;
-        const positionOffset = index * 3;
-        let x = this.centerX;
-        let z = this.centerZ;
-        let vx = (Math.random() - 0.5) * 0.08;
-        let vz = (Math.random() - 0.5) * 0.08;
-        if (edge === 0) {
-            x += along * this.innerLength * 0.92;
-            z += this.innerWidth * 0.5 + 0.015;
-            vz += speedOut;
-        }
-        else if (edge === 1) {
-            x += along * this.innerLength * 0.92;
-            z -= this.innerWidth * 0.5 + 0.015;
-            vz -= speedOut;
-        }
-        else if (edge === 2) {
-            x -= this.innerLength * 0.5 + 0.015;
-            z += along * this.innerWidth * 0.9;
-            vx -= speedOut;
-        }
-        else {
-            x += this.innerLength * 0.5 + 0.015;
-            z += along * this.innerWidth * 0.9;
-            vx += speedOut;
-        }
-        this.dropPositions[positionOffset] = x;
-        this.dropPositions[positionOffset + 1] = this.maxWaterY + 0.012 + Math.random() * 0.018;
-        this.dropPositions[positionOffset + 2] = z;
-        this.dropVelocities[velocityOffset] = vx;
-        this.dropVelocities[velocityOffset + 1] = 0.03 + Math.random() * 0.19;
-        this.dropVelocities[velocityOffset + 2] = vz;
-        this.dropLife[index] = 1.25 + Math.random() * 0.8;
-        this.dropMaxLife[index] = this.dropLife[index];
-        this.dropBounces[index] = 0;
-        this.dropSizes[index] = 2.2 + Math.random() * 3.3;
-        this.dropAlpha[index] = 0.75 + Math.random() * 0.25;
-    }
-    updateSpillParticles(delta) {
-        if (this.active && this.overflowRate > 0.0001) {
-            const spawnRate = Math.min(this.dropCount * 0.86, 140 + this.overflowRate * 2600);
-            this.dropAccumulator += spawnRate * delta;
-            const spawnCount = Math.min(48, Math.floor(this.dropAccumulator));
-            this.dropAccumulator -= spawnCount;
-            for (let i = 0; i < spawnCount; i++)
-                this.spawnSpillParticle();
-        }
-        const floorY = -0.17;
-        const drag = Math.exp(-0.18 * delta);
-        for (let i = 0; i < this.dropCount; i++) {
-            if (this.dropLife[i] <= 0)
-                continue;
-            const offset = i * 3;
-            this.dropLife[i] -= delta;
-            this.dropVelocities[offset] *= drag;
-            this.dropVelocities[offset + 1] = this.dropVelocities[offset + 1] * drag - 9.81 * delta;
-            this.dropVelocities[offset + 2] *= drag;
-            this.dropPositions[offset] += this.dropVelocities[offset] * delta;
-            this.dropPositions[offset + 1] += this.dropVelocities[offset + 1] * delta;
-            this.dropPositions[offset + 2] += this.dropVelocities[offset + 2] * delta;
-            if (this.dropPositions[offset + 1] <= floorY && this.dropVelocities[offset + 1] < 0) {
-                if (this.dropBounces[i] === 0) {
-                    const impact = -this.dropVelocities[offset + 1];
-                    const angle = Math.random() * Math.PI * 2;
-                    const radial = impact * (0.08 + Math.random() * 0.11);
-                    this.dropPositions[offset + 1] = floorY + 0.006;
-                    this.dropVelocities[offset] = Math.cos(angle) * radial;
-                    this.dropVelocities[offset + 1] = impact * (0.17 + Math.random() * 0.12);
-                    this.dropVelocities[offset + 2] = Math.sin(angle) * radial;
-                    this.dropBounces[i] = 1;
-                    this.dropLife[i] = Math.min(this.dropLife[i], 0.48 + Math.random() * 0.18);
-                    this.dropSizes[i] *= 0.72;
-                }
-                else {
-                    this.dropLife[i] = 0;
-                }
-            }
-            if (this.dropLife[i] <= 0) {
-                this.dropAlpha[i] = 0;
-                this.dropPositions[offset + 1] = -100;
-            }
-            else {
-                const lifeRatio = this.dropLife[i] / Math.max(this.dropMaxLife[i], 0.001);
-                this.dropAlpha[i] = THREE.MathUtils.clamp(lifeRatio * 1.35, 0, 1);
-            }
-        }
-        this.spillPoints.geometry.attributes.position.needsUpdate = true;
-        this.spillPoints.geometry.attributes.aAlpha.needsUpdate = true;
-        this.spillPoints.geometry.attributes.aSize.needsUpdate = true;
-    }
-    updateGeometry() {
-        const waterHeight = Math.max(0.001, this.waterY - this.innerBottomY);
-        this.waterBody.scale.y = waterHeight;
-        this.waterBody.position.y = this.innerBottomY + waterHeight * 0.5;
-        this.waterBody.visible = this.active && this.volume > 0.0005 && !this.particleFluidMode;
-        if (this.surface) {
-            this.surface.setBounds({
-                basinMinX: this.minX,
-                basinMaxX: this.maxX,
-                basinHalfZ: this.innerWidth * 0.5,
-                basinCenterZ: this.centerZ,
-                waterY: this.waterY,
-            });
-            this.surface.mesh.visible = this.active && this.volume > 0.0005 && !this.particleFluidMode;
-        }
-    }
-    update(delta, elapsed, { flowRate, captureFraction = 0, impactX, impactZ = 0, impactEnergy = 0, emitting = false, }) {
-        this.updateContainerMotion(delta);
-        const effectiveCapture = this.active && emitting ? THREE.MathUtils.clamp(captureFraction, 0, 1) : 0;
-        const captured = effectiveCapture > 0.001;
-        const incomingRate = flowRate * effectiveCapture;
-        const incomingVolume = incomingRate * delta;
-        const available = Math.max(0, this.capacity - this.volume);
-        const stored = Math.min(available, incomingVolume);
-        const overflowVolume = Math.max(0, incomingVolume - stored);
-        this.volume = Math.min(this.capacity, this.volume + stored);
-        const freeboard = Math.max(0, this.maxWaterY - this.waterY);
-        const crestRise = Math.max(Math.abs(this.sloshOffset.x), Math.abs(this.sloshOffset.y));
-        const overtoppingHead = Math.max(0, crestRise - freeboard);
-        this.motionOverflowRate = this.active
-            ? Math.min(0.38, overtoppingHead * this.surfaceArea * 1.25)
-            : 0;
-        const motionOverflowVolume = Math.min(this.volume, this.motionOverflowRate * delta);
-        this.volume = Math.max(0, this.volume - motionOverflowVolume);
-        this.overflowRate = (delta > 0 ? overflowVolume / delta : 0) + this.motionOverflowRate;
-        const targetOverflow = THREE.MathUtils.clamp(this.overflowRate / 0.16, 0, 1);
-        this.overflowIntensity = THREE.MathUtils.lerp(this.overflowIntensity, targetOverflow, 1 - Math.exp(-delta * (targetOverflow > this.overflowIntensity ? 5.5 : 2.2)));
-        this.updateGeometry();
-        this.waterMaterial.uniforms.uTime.value = elapsed;
-        this.overflowMaterial.uniforms.uTime.value = elapsed;
-        this.overflowMaterial.uniforms.uOverflow.value = this.overflowIntensity;
-        this.overflowGroup.visible = this.active && this.overflowIntensity > 0.008;
-        this.rimFoamMaterial.opacity = this.overflowIntensity * 0.38;
-        this.rimFoamGroup.visible = this.active && this.overflowIntensity > 0.025;
-        this.updateSpillParticles(delta);
-        if (this.active) {
-            this.surface?.update(delta, elapsed, impactX, impactEnergy, captured && emitting, impactZ);
-        }
-        return {
-            captured,
-            captureFraction: effectiveCapture,
-            incomingRate,
-            missedRate: Math.max(0, flowRate - incomingRate),
-            overflowRate: this.overflowRate,
-        };
-    }
-    setPixelRatio(pixelRatio) {
-        this.dropMaterial.uniforms.uPixelRatio.value = Math.min(pixelRatio, 2);
-    }
-    get fillRatio() {
-        return this.capacity > 0 ? this.volume / this.capacity : 0;
-    }
-    get waterY() {
-        return THREE.MathUtils.lerp(this.innerBottomY, this.maxWaterY, this.fillRatio);
-    }
-    get centerX() {
-        return this.group.position.x;
-    }
-    get centerZ() {
-        return this.group.position.z;
-    }
-    get minX() {
-        return this.centerX - this.innerLength * 0.5;
-    }
-    get maxX() {
-        return this.centerX + this.innerLength * 0.5;
-    }
-    get collisionBounds() {
-        return {
-            minX: this.minX,
-            maxX: this.maxX,
-            halfZ: this.innerWidth * 0.5,
-            centerZ: this.centerZ,
-            waterY: this.waterY,
-            wallTop: this.rimY,
-            containerFloorY: this.innerBottomY,
-        };
-    }
-}