three-base 2.0.130 → 2.0.137

package/pass/ssao_pass.js

@@ -0,0 +1,372 @@
+import { LinearFilter, NoBlending, RGBAFormat, RawShaderMaterial, Vector2, WebGLRenderTarget, Matrix4, MultiplyBlending, } from "three";
+import fsQuad from "./fsQuad";
+const ssaoTextureTarget = new WebGLRenderTarget(512, 512, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+});
+const blurTextureTarget = new WebGLRenderTarget(512, 512, {
+    minFilter: LinearFilter,
+    magFilter: LinearFilter,
+    format: RGBAFormat,
+});
+const size = new Vector2();
+const projectionMatrix = new Matrix4();
+const inverseProjectionMatrix = new Matrix4();
+// SSAO 着色器 — 随机采样 + 法线半球判断 + 深度连续性 + 视距自适应半径
+const ssaoShader = new RawShaderMaterial({
+    uniforms: {
+        depthTexture: { value: null },
+        resolution: { value: new Vector2(1 / 512, 1 / 512) },
+        projectionMatrix: { value: new Matrix4() },
+        inverseProjectionMatrix: { value: new Matrix4() },
+        ssaoRadius: { value: 2.0 },
+        ssaoFalloff: { value: 5.0 },
+        ssaoBias: { value: 0.3 },
+        ssaoIntensity: { value: 1.0 },
+        sampleCount: { value: 16 },
+        cameraFar: { value: 20000 },
+    },
+    vertexShader: `
+    attribute vec3 position;
+    attribute vec2 uv;
+    varying vec2 vUv;
+    void main() {
+      vUv = uv;
+      gl_Position = vec4(position, 1.0);
+    }`,
+    fragmentShader: `
+    #ifdef GL_ES
+      precision highp float;
+    #endif
+
+    uniform sampler2D depthTexture;
+    uniform vec2 resolution;
+    uniform mat4 projectionMatrix;
+    uniform mat4 inverseProjectionMatrix;
+    uniform float ssaoRadius;
+    uniform float ssaoFalloff;
+    uniform float ssaoBias;
+    uniform float ssaoIntensity;
+    uniform int sampleCount;
+    uniform float cameraFar;
+
+    varying vec2 vUv;
+
+    float linearizeLogDepth(float logDepth) {
+      return pow(cameraFar + 1.0, logDepth) - 1.0;
+    }
+
+    vec3 reconstructPosition(vec2 uv, float viewZ) {
+      vec4 ndc = vec4(uv * 2.0 - 1.0, 0.0, 1.0);
+      vec4 viewDir4 = inverseProjectionMatrix * ndc;
+      vec3 viewDir = viewDir4.xyz / viewDir4.w;
+      return viewDir * (viewZ / (-viewDir.z));
+    }
+
+    // 从深度图重建视空间法线（有限差分法）
+    vec3 reconstructNormal(vec2 uv, vec2 res) {
+      vec2 step = res * 2.0;
+
+      float dC = texture2D(depthTexture, uv).r;
+      float dL = texture2D(depthTexture, uv - vec2(step.x, 0.0)).r;
+      float dR = texture2D(depthTexture, uv + vec2(step.x, 0.0)).r;
+      float dD = texture2D(depthTexture, uv - vec2(0.0, step.y)).r;
+      float dU = texture2D(depthTexture, uv + vec2(0.0, step.y)).r;
+
+      if (dL >= 1.0 || dR >= 1.0 || dD >= 1.0 || dU >= 1.0 || dC >= 1.0) {
+        return vec3(0.0, 0.0, 1.0);
+      }
+
+      // 深度不连续时回退为中心深度
+      float edgeThreshold = 0.003;
+      float dL2 = abs(dL - dC) < edgeThreshold ? dL : dC;
+      float dR2 = abs(dR - dC) < edgeThreshold ? dR : dC;
+      float dD2 = abs(dD - dC) < edgeThreshold ? dD : dC;
+      float dU2 = abs(dU - dC) < edgeThreshold ? dU : dC;
+
+      float vC = linearizeLogDepth(dC);
+      float vL = linearizeLogDepth(dL2);
+      float vR = linearizeLogDepth(dR2);
+      float vD = linearizeLogDepth(dD2);
+      float vU = linearizeLogDepth(dU2);
+
+      vec3 pC = reconstructPosition(uv, vC);
+      vec3 pL = reconstructPosition(uv - vec2(step.x, 0.0), vL);
+      vec3 pR = reconstructPosition(uv + vec2(step.x, 0.0), vR);
+      vec3 pD = reconstructPosition(uv - vec2(0.0, step.y), vD);
+      vec3 pU = reconstructPosition(uv + vec2(0.0, step.y), vU);
+
+      vec3 tangentX = pR - pL;
+      vec3 tangentY = pU - pD;
+
+      if (length(tangentX) < 0.001 || length(tangentY) < 0.001) {
+        return vec3(0.0, 0.0, 1.0);
+      }
+
+      vec3 normal = cross(normalize(tangentX), normalize(tangentY));
+      return normalize(normal);
+    }
+
+    float random(vec2 seed) {
+      return fract(sin(dot(seed, vec2(12.9898, 78.233))) * 43758.5453);
+    }
+
+    void main() {
+      float logDepth = texture2D(depthTexture, vUv).r;
+
+      // 背景 / 无穷远 → 无遮挡
+      if (logDepth >= 1.0) {
+        gl_FragColor = vec4(1.0);
+        return;
+      }
+
+      float viewZ = linearizeLogDepth(logDepth);
+      vec3 position = reconstructPosition(vUv, viewZ);
+      vec3 normal = reconstructNormal(vUv, resolution);
+
+      // 视距自适应：ssaoRadius 是世界空间遮蔽半径，换算为像素半径
+      // 近处像素多 → 像素半径大；远处像素少 → 像素半径小
+      float projScale = 1.0 / (2.0 * abs(viewZ) * resolution.x);
+      float pixelRadius = max(ssaoRadius * projScale, 1.0);
+
+      float occlusion = 0.0;
+      float angle = random(vUv) * 6.2831853;
+      float stepAngle = 6.2831853 / float(sampleCount);
+
+      for (int i = 0; i < 64; i++) {
+        if (i >= sampleCount) break;
+
+        float theta = angle + float(i) * stepAngle;
+        float r = sqrt(float(i + 1)) * (pixelRadius / sqrt(float(sampleCount)));
+
+        // 屏幕空间偏移（像素 → UV）
+        vec2 sampleUv = vUv + vec2(cos(theta), sin(theta)) * r * resolution;
+
+        if (sampleUv.x < 0.0 || sampleUv.x > 1.0 || sampleUv.y < 0.0 || sampleUv.y > 1.0) {
+          continue;
+        }
+
+        float sampleLogDepth = texture2D(depthTexture, sampleUv).r;
+        // 背景像素跳过
+        if (sampleLogDepth >= 1.0) continue;
+
+        // 深度连续性：不同表面跳过（真正夹角深度值接近，假夹角深度差大）
+        float depthDiff = abs(sampleLogDepth - logDepth);
+        if (depthDiff > 0.002) continue;
+
+        float sampleViewZ = linearizeLogDepth(sampleLogDepth);
+        vec3 samplePosition = reconstructPosition(sampleUv, sampleViewZ);
+
+        vec3 diff = samplePosition - position;
+        float dist = length(diff);
+
+        // 半球判断：采样方向必须在法线半球侧
+        // tangentDist = dot(diff, normal) 是到切面平面的有符号距离
+        // 平坦面 ≈ 0（不会超过 bias）；夹角处显著 > 0
+        float tangentDist = dot(diff, normal);
+        if (tangentDist < ssaoBias) continue;
+
+        // 在衰减范围内
+        if (dist < ssaoFalloff) {
+          float rangeCheck = smoothstep(0.0, ssaoFalloff, dist);
+          occlusion += (1.0 - rangeCheck) * (1.0 - tangentDist / ssaoFalloff);
+        }
+      }
+
+      occlusion = 1.0 - (occlusion * ssaoIntensity / float(sampleCount));
+      occlusion = clamp(occlusion, 0.0, 1.0);
+
+      gl_FragColor = vec4(vec3(occlusion), 1.0);
+    }`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+const blurHShader = new RawShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        resolution: { value: new Vector2(1 / 512, 1 / 512) },
+        blurRadius: { value: 2.0 },
+        depthTexture: { value: null },
+    },
+    vertexShader: `
+    attribute vec3 position;
+    attribute vec2 uv;
+    varying vec2 vUv;
+    void main() {
+      vUv = uv;
+      gl_Position = vec4(position, 1.0);
+    }`,
+    fragmentShader: `
+    #ifdef GL_ES
+      precision highp float;
+    #endif
+
+    uniform sampler2D tDiffuse;
+    uniform vec2 resolution;
+    uniform float blurRadius;
+    uniform sampler2D depthTexture;
+
+    varying vec2 vUv;
+
+    void main() {
+      float centerDepth = texture2D(depthTexture, vUv).r;
+      vec4 color = vec4(0.0);
+      float totalWeight = 0.0;
+
+      for (int i = -4; i <= 4; i++) {
+        float weight = exp(-float(i * i) / 8.0);
+        vec2 offset = vec2(float(i) * blurRadius * resolution.x, 0.0);
+        vec2 sampleUv = vUv + offset;
+        float sampleDepth = texture2D(depthTexture, sampleUv).r;
+        float depthWeight = abs(sampleDepth - centerDepth) < 0.001 ? 1.0 : 0.1;
+        color += texture2D(tDiffuse, sampleUv) * weight * depthWeight;
+        totalWeight += weight * depthWeight;
+      }
+
+      gl_FragColor = color / totalWeight;
+    }`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+const blurVShader = new RawShaderMaterial({
+    uniforms: {
+        tDiffuse: { value: null },
+        resolution: { value: new Vector2(1 / 512, 1 / 512) },
+        blurRadius: { value: 2.0 },
+        depthTexture: { value: null },
+    },
+    vertexShader: `
+    attribute vec3 position;
+    attribute vec2 uv;
+    varying vec2 vUv;
+    void main() {
+      vUv = uv;
+      gl_Position = vec4(position, 1.0);
+    }`,
+    fragmentShader: `
+    #ifdef GL_ES
+      precision highp float;
+    #endif
+
+    uniform sampler2D tDiffuse;
+    uniform vec2 resolution;
+    uniform float blurRadius;
+    uniform sampler2D depthTexture;
+
+    varying vec2 vUv;
+
+    void main() {
+      float centerDepth = texture2D(depthTexture, vUv).r;
+      vec4 color = vec4(0.0);
+      float totalWeight = 0.0;
+
+      for (int i = -4; i <= 4; i++) {
+        float weight = exp(-float(i * i) / 8.0);
+        vec2 offset = vec2(0.0, float(i) * blurRadius * resolution.y);
+        vec2 sampleUv = vUv + offset;
+        float sampleDepth = texture2D(depthTexture, sampleUv).r;
+        float depthWeight = abs(sampleDepth - centerDepth) < 0.001 ? 1.0 : 0.1;
+        color += texture2D(tDiffuse, sampleUv) * weight * depthWeight;
+        totalWeight += weight * depthWeight;
+      }
+
+      gl_FragColor = color / totalWeight;
+    }`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+const outputShader = new RawShaderMaterial({
+    uniforms: {
+        ssaoTexture: { value: null },
+        ssaoStrength: { value: 1.0 },
+        debug: { value: 0.0 },
+    },
+    vertexShader: `
+    attribute vec3 position;
+    attribute vec2 uv;
+    varying vec2 vUv;
+    void main() {
+      vUv = uv;
+      gl_Position = vec4(position, 1.0);
+    }`,
+    fragmentShader: `
+    #ifdef GL_ES
+      precision highp float;
+    #endif
+
+    uniform sampler2D ssaoTexture;
+    uniform float ssaoStrength;
+    uniform float debug;
+
+    varying vec2 vUv;
+
+    void main() {
+      float ssao = texture2D(ssaoTexture, vUv).r;
+      float finalOcclusion = mix(1.0, ssao, ssaoStrength);
+
+      if (debug > 0.5) {
+        gl_FragColor = vec4(vec3(ssao), 1.0);
+      } else {
+        gl_FragColor = vec4(vec3(finalOcclusion), 1.0);
+      }
+    }`,
+    blending: MultiplyBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+export default function ssao_pass(renderer, camera, depthTexture, devicePixelRatio, options) {
+    if (!options.enable || !options.strength) {
+        return;
+    }
+    renderer.getSize(size);
+    size.multiplyScalar(devicePixelRatio);
+    ssaoTextureTarget.setSize(size.x, size.y);
+    blurTextureTarget.setSize(size.x, size.y);
+    projectionMatrix.copy(camera.projectionMatrix);
+    inverseProjectionMatrix.copy(projectionMatrix).invert();
+    // === 1. SSAO 遮蔽计算 ===
+    ssaoShader.uniforms.depthTexture.value = depthTexture;
+    ssaoShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    ssaoShader.uniforms.projectionMatrix.value = projectionMatrix;
+    ssaoShader.uniforms.inverseProjectionMatrix.value = inverseProjectionMatrix;
+    ssaoShader.uniforms.ssaoRadius.value = options.radius || 2.0;
+    ssaoShader.uniforms.ssaoFalloff.value = options.falloff || 5.0;
+    ssaoShader.uniforms.ssaoBias.value = options.bias || 0.3;
+    ssaoShader.uniforms.ssaoIntensity.value = options.intensity || 1.0;
+    ssaoShader.uniforms.sampleCount.value = options.sampleCount || 16;
+    ssaoShader.uniforms.cameraFar.value = options.cameraFar || camera.far || 20000;
+    renderer.setRenderTarget(ssaoTextureTarget);
+    renderer.clear();
+    fsQuad.render(renderer, ssaoShader);
+    // === 2. 双向模糊 ===
+    const blurRes = new Vector2(1 / size.x, 1 / size.y);
+    const blurR = options.blurRadius || 2.0;
+    blurHShader.uniforms.tDiffuse.value = ssaoTextureTarget.texture;
+    blurHShader.uniforms.resolution.value.copy(blurRes);
+    blurHShader.uniforms.blurRadius.value = blurR;
+    blurHShader.uniforms.depthTexture.value = depthTexture;
+    renderer.setRenderTarget(blurTextureTarget);
+    renderer.clear();
+    fsQuad.render(renderer, blurHShader);
+    blurVShader.uniforms.tDiffuse.value = blurTextureTarget.texture;
+    blurVShader.uniforms.resolution.value.copy(blurRes);
+    blurVShader.uniforms.blurRadius.value = blurR;
+    blurVShader.uniforms.depthTexture.value = depthTexture;
+    renderer.setRenderTarget(ssaoTextureTarget);
+    renderer.clear();
+    fsQuad.render(renderer, blurVShader);
+    // === 3. 乘法混合到屏幕 ===
+    renderer.setRenderTarget(null);
+    outputShader.uniforms.ssaoTexture.value = ssaoTextureTarget.texture;
+    outputShader.uniforms.ssaoStrength.value = options.strength || 1.0;
+    outputShader.uniforms.debug.value = options.debug ? 1.0 : 0.0;
+    fsQuad.render(renderer, outputShader);
+}

package/pass/stroke_pass.d.ts

@@ -1,2 +1,2 @@
-import { Camera, DepthTexture, Object3D, WebGLRenderer } from "three";
-export default function stroke_pass(renderer: WebGLRenderer, camera: Camera, object3d: Object3D, baseDepthTexture: DepthTexture, devicePixelRatio: number): void;
+import { Camera, DepthTexture, Object3D, WebGLRenderer } from "three";
+export default function stroke_pass(renderer: WebGLRenderer, camera: Camera, object3d: Object3D, baseDepthTexture: DepthTexture, devicePixelRatio: number): void;