three-base 2.0.142 → 2.0.166

package/WaterFlow/SPHField.d.ts

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

@@ -1,204 +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);
+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++;
         }
-      `,
-            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();
-    }
-}
+    }
+    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();
+    }
+}