three-base 2.0.130 → 2.0.134

package/pass/ssao_pass.js

@@ -0,0 +1,294 @@
+import { AddEquation, CustomBlending, LinearFilter, NoBlending, NormalBlending, OneFactor, RGBAFormat, RawShaderMaterial, SrcColorFactor, Vector2, WebGLRenderTarget, Matrix4, } 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();
+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: 0.5 },
+        ssaoBias: { value: 0.025 },
+        ssaoIntensity: { value: 1.5 },
+        sampleCount: { value: 16 },
+        // 对数深度缓冲区的 far 参数，用于反算线性视距
+        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 ssaoBias;
+    uniform float ssaoIntensity;
+    uniform int sampleCount;
+    uniform float cameraFar;
+    
+    varying vec2 vUv;
+    
+    // 将对数深度值反算回线性视距（正数，单位与世界坐标一致）
+    // Three.js 对数深度编码: logDepth = log2(viewZ + 1.0) / log2(cameraFar + 1.0)
+    float linearizeLogDepth(float logDepth) {
+      return pow(cameraFar + 1.0, logDepth) - 1.0;
+    }
+    
+    // 从屏幕 UV 和视距重建视空间坐标
+    // viewDistance: 相机到该像素的视距（正数）
+    vec3 reconstructPosition(vec2 uv, float viewDistance) {
+      // 用 inverseProjectionMatrix 求出该像素的视空间射线方向
+      vec4 ndc = vec4(uv * 2.0 - 1.0, 0.0, 1.0);
+      vec4 viewDir4 = inverseProjectionMatrix * ndc;
+      vec3 viewDir = viewDir4.xyz / viewDir4.w;
+      // viewDir.z 为负数（相机看向 -Z），viewDistance 为正数
+      return viewDir * (viewDistance / (-viewDir.z));
+    }
+    
+    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 viewDistance = linearizeLogDepth(logDepth);
+      vec3 position = reconstructPosition(vUv, viewDistance);
+      
+      float occlusion = 0.0;
+      float radius = ssaoRadius;
+      
+      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)) * (radius / sqrt(float(sampleCount)));
+        
+        vec2 offset = vec2(cos(theta), sin(theta)) * r;
+        vec2 sampleUv = vUv + offset * 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;
+        float sampleDistance = linearizeLogDepth(sampleLogDepth);
+        vec3 samplePosition = reconstructPosition(sampleUv, sampleDistance);
+        
+        vec3 diff = samplePosition - position;
+        float dist = length(diff);
+        
+        if (dist < radius && diff.z > ssaoBias) {
+          float rangeCheck = smoothstep(0.0, radius, dist);
+          occlusion += (1.0 - rangeCheck) * (1.0 - diff.z / radius);
+        }
+      }
+      
+      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 },
+    },
+    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;
+    
+    varying vec2 vUv;
+    
+    void main() {
+      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);
+        color += texture2D(tDiffuse, vUv + offset) * weight;
+        totalWeight += weight;
+      }
+      
+      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 },
+    },
+    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;
+    
+    varying vec2 vUv;
+    
+    void main() {
+      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);
+        color += texture2D(tDiffuse, vUv + offset) * weight;
+        totalWeight += weight;
+      }
+      
+      gl_FragColor = color / totalWeight;
+    }`,
+    blending: NoBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true,
+});
+const compositeShader = new RawShaderMaterial({
+    uniforms: {
+        ssaoTexture: { value: null },
+        ssaoStrength: { value: 1.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;
+    
+    varying vec2 vUv;
+    
+    void main() {
+      float ssao = texture2D(ssaoTexture, vUv).r;
+      float finalOcclusion = mix(1.0, ssao, ssaoStrength);
+      
+      gl_FragColor = vec4(finalOcclusion, finalOcclusion, finalOcclusion, 1.0);
+    }`,
+    blending: CustomBlending,
+    blendSrc: SrcColorFactor,
+    blendDst: OneFactor,
+    blendEquation: AddEquation,
+    depthTest: false,
+    depthWrite: false,
+    transparent: false,
+});
+export default function ssao_pass(renderer, camera, depthTexture, devicePixelRatio, options) {
+    if (!options.enable) {
+        return;
+    }
+    const originRenderTarget = renderer.getRenderTarget();
+    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();
+    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 || 0.5;
+    ssaoShader.uniforms.ssaoBias.value = options.bias || 0.025;
+    ssaoShader.uniforms.ssaoIntensity.value = options.intensity || 1.5;
+    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);
+    blurHShader.uniforms.tDiffuse.value = ssaoTextureTarget.texture;
+    blurHShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    blurHShader.uniforms.blurRadius.value = options.blurRadius || 2.0;
+    renderer.setRenderTarget(blurTextureTarget);
+    renderer.clear();
+    fsQuad.render(renderer, blurHShader);
+    blurVShader.uniforms.tDiffuse.value = blurTextureTarget.texture;
+    blurVShader.uniforms.resolution.value.set(1 / size.x, 1 / size.y);
+    blurVShader.uniforms.blurRadius.value = options.blurRadius || 2.0;
+    renderer.setRenderTarget(ssaoTextureTarget);
+    renderer.clear();
+    fsQuad.render(renderer, blurVShader);
+    compositeShader.uniforms.ssaoTexture.value = ssaoTextureTarget.texture;
+    compositeShader.uniforms.ssaoStrength.value = options.strength || 1.0;
+    renderer.setRenderTarget(originRenderTarget);
+    compositeShader.blending = NormalBlending;
+    compositeShader.transparent = false;
+    fsQuad.render(renderer, compositeShader);
+}

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;