three-stdlib 2.22.7 → 2.22.9

package/dist/postprocessing/SSAOPass.mjs

@@ -0,0 +1,265 @@
+import { DepthTexture, DepthStencilFormat, UnsignedInt248Type, WebGLRenderTarget, NearestFilter, ShaderMaterial, UniformsUtils, NoBlending, MeshNormalMaterial, DstColorFactor, ZeroFactor, AddEquation, DstAlphaFactor, Color, LuminanceFormat, CustomBlending, Vector3, MathUtils, DataTexture, RedFormat, FloatType, RepeatWrapping } from "three";
+import { Pass, FullScreenQuad } from "./Pass.mjs";
+import { SimplexNoise } from "../math/SimplexNoise.mjs";
+import { SSAOShader, SSAOBlurShader, SSAODepthShader } from "../shaders/SSAOShader.mjs";
+import { CopyShader } from "../shaders/CopyShader.mjs";
+class SSAOPass extends Pass {
+  constructor(scene, camera, width, height) {
+    super();
+    this.width = width !== void 0 ? width : 512;
+    this.height = height !== void 0 ? height : 512;
+    this.clear = true;
+    this.camera = camera;
+    this.scene = scene;
+    this.kernelRadius = 8;
+    this.kernelSize = 32;
+    this.kernel = [];
+    this.noiseTexture = null;
+    this.output = 0;
+    this.minDistance = 5e-3;
+    this.maxDistance = 0.1;
+    this._visibilityCache = /* @__PURE__ */ new Map();
+    this.generateSampleKernel();
+    this.generateRandomKernelRotations();
+    const depthTexture = new DepthTexture();
+    depthTexture.format = DepthStencilFormat;
+    depthTexture.type = UnsignedInt248Type;
+    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height);
+    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      depthTexture
+    });
+    this.ssaoRenderTarget = new WebGLRenderTarget(this.width, this.height);
+    this.blurRenderTarget = this.ssaoRenderTarget.clone();
+    if (SSAOShader === void 0) {
+      console.error("THREE.SSAOPass: The pass relies on SSAOShader.");
+    }
+    this.ssaoMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSAOShader.defines),
+      uniforms: UniformsUtils.clone(SSAOShader.uniforms),
+      vertexShader: SSAOShader.vertexShader,
+      fragmentShader: SSAOShader.fragmentShader,
+      blending: NoBlending
+    });
+    this.ssaoMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+    this.ssaoMaterial.uniforms["tNormal"].value = this.normalRenderTarget.texture;
+    this.ssaoMaterial.uniforms["tDepth"].value = this.normalRenderTarget.depthTexture;
+    this.ssaoMaterial.uniforms["tNoise"].value = this.noiseTexture;
+    this.ssaoMaterial.uniforms["kernel"].value = this.kernel;
+    this.ssaoMaterial.uniforms["cameraNear"].value = this.camera.near;
+    this.ssaoMaterial.uniforms["cameraFar"].value = this.camera.far;
+    this.ssaoMaterial.uniforms["resolution"].value.set(this.width, this.height);
+    this.ssaoMaterial.uniforms["cameraProjectionMatrix"].value.copy(this.camera.projectionMatrix);
+    this.ssaoMaterial.uniforms["cameraInverseProjectionMatrix"].value.copy(this.camera.projectionMatrixInverse);
+    this.normalMaterial = new MeshNormalMaterial();
+    this.normalMaterial.blending = NoBlending;
+    this.blurMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSAOBlurShader.defines),
+      uniforms: UniformsUtils.clone(SSAOBlurShader.uniforms),
+      vertexShader: SSAOBlurShader.vertexShader,
+      fragmentShader: SSAOBlurShader.fragmentShader
+    });
+    this.blurMaterial.uniforms["tDiffuse"].value = this.ssaoRenderTarget.texture;
+    this.blurMaterial.uniforms["resolution"].value.set(this.width, this.height);
+    this.depthRenderMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSAODepthShader.defines),
+      uniforms: UniformsUtils.clone(SSAODepthShader.uniforms),
+      vertexShader: SSAODepthShader.vertexShader,
+      fragmentShader: SSAODepthShader.fragmentShader,
+      blending: NoBlending
+    });
+    this.depthRenderMaterial.uniforms["tDepth"].value = this.normalRenderTarget.depthTexture;
+    this.depthRenderMaterial.uniforms["cameraNear"].value = this.camera.near;
+    this.depthRenderMaterial.uniforms["cameraFar"].value = this.camera.far;
+    this.copyMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(CopyShader.uniforms),
+      vertexShader: CopyShader.vertexShader,
+      fragmentShader: CopyShader.fragmentShader,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      blendSrc: DstColorFactor,
+      blendDst: ZeroFactor,
+      blendEquation: AddEquation,
+      blendSrcAlpha: DstAlphaFactor,
+      blendDstAlpha: ZeroFactor,
+      blendEquationAlpha: AddEquation
+    });
+    this.fsQuad = new FullScreenQuad(null);
+    this.originalClearColor = new Color();
+  }
+  dispose() {
+    this.beautyRenderTarget.dispose();
+    this.normalRenderTarget.dispose();
+    this.ssaoRenderTarget.dispose();
+    this.blurRenderTarget.dispose();
+    this.normalMaterial.dispose();
+    this.blurMaterial.dispose();
+    this.copyMaterial.dispose();
+    this.depthRenderMaterial.dispose();
+    this.fsQuad.dispose();
+  }
+  render(renderer, writeBuffer) {
+    if (renderer.capabilities.isWebGL2 === false)
+      this.noiseTexture.format = LuminanceFormat;
+    renderer.setRenderTarget(this.beautyRenderTarget);
+    renderer.clear();
+    renderer.render(this.scene, this.camera);
+    this.overrideVisibility();
+    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 7829503, 1);
+    this.restoreVisibility();
+    this.ssaoMaterial.uniforms["kernelRadius"].value = this.kernelRadius;
+    this.ssaoMaterial.uniforms["minDistance"].value = this.minDistance;
+    this.ssaoMaterial.uniforms["maxDistance"].value = this.maxDistance;
+    this.renderPass(renderer, this.ssaoMaterial, this.ssaoRenderTarget);
+    this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget);
+    switch (this.output) {
+      case SSAOPass.OUTPUT.SSAO:
+        this.copyMaterial.uniforms["tDiffuse"].value = this.ssaoRenderTarget.texture;
+        this.copyMaterial.blending = NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      case SSAOPass.OUTPUT.Blur:
+        this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget.texture;
+        this.copyMaterial.blending = NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      case SSAOPass.OUTPUT.Beauty:
+        this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+        this.copyMaterial.blending = NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      case SSAOPass.OUTPUT.Depth:
+        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      case SSAOPass.OUTPUT.Normal:
+        this.copyMaterial.uniforms["tDiffuse"].value = this.normalRenderTarget.texture;
+        this.copyMaterial.blending = NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      case SSAOPass.OUTPUT.Default:
+        this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+        this.copyMaterial.blending = NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget.texture;
+        this.copyMaterial.blending = CustomBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      default:
+        console.warn("THREE.SSAOPass: Unknown output type.");
+    }
+  }
+  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+    renderer.getClearColor(this.originalClearColor);
+    const originalClearAlpha = renderer.getClearAlpha();
+    const originalAutoClear = renderer.autoClear;
+    renderer.setRenderTarget(renderTarget);
+    renderer.autoClear = false;
+    if (clearColor !== void 0 && clearColor !== null) {
+      renderer.setClearColor(clearColor);
+      renderer.setClearAlpha(clearAlpha || 0);
+      renderer.clear();
+    }
+    this.fsQuad.material = passMaterial;
+    this.fsQuad.render(renderer);
+    renderer.autoClear = originalAutoClear;
+    renderer.setClearColor(this.originalClearColor);
+    renderer.setClearAlpha(originalClearAlpha);
+  }
+  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+    renderer.getClearColor(this.originalClearColor);
+    const originalClearAlpha = renderer.getClearAlpha();
+    const originalAutoClear = renderer.autoClear;
+    renderer.setRenderTarget(renderTarget);
+    renderer.autoClear = false;
+    clearColor = overrideMaterial.clearColor || clearColor;
+    clearAlpha = overrideMaterial.clearAlpha || clearAlpha;
+    if (clearColor !== void 0 && clearColor !== null) {
+      renderer.setClearColor(clearColor);
+      renderer.setClearAlpha(clearAlpha || 0);
+      renderer.clear();
+    }
+    this.scene.overrideMaterial = overrideMaterial;
+    renderer.render(this.scene, this.camera);
+    this.scene.overrideMaterial = null;
+    renderer.autoClear = originalAutoClear;
+    renderer.setClearColor(this.originalClearColor);
+    renderer.setClearAlpha(originalClearAlpha);
+  }
+  setSize(width, height) {
+    this.width = width;
+    this.height = height;
+    this.beautyRenderTarget.setSize(width, height);
+    this.ssaoRenderTarget.setSize(width, height);
+    this.normalRenderTarget.setSize(width, height);
+    this.blurRenderTarget.setSize(width, height);
+    this.ssaoMaterial.uniforms["resolution"].value.set(width, height);
+    this.ssaoMaterial.uniforms["cameraProjectionMatrix"].value.copy(this.camera.projectionMatrix);
+    this.ssaoMaterial.uniforms["cameraInverseProjectionMatrix"].value.copy(this.camera.projectionMatrixInverse);
+    this.blurMaterial.uniforms["resolution"].value.set(width, height);
+  }
+  generateSampleKernel() {
+    const kernelSize = this.kernelSize;
+    const kernel = this.kernel;
+    for (let i = 0; i < kernelSize; i++) {
+      const sample = new Vector3();
+      sample.x = Math.random() * 2 - 1;
+      sample.y = Math.random() * 2 - 1;
+      sample.z = Math.random();
+      sample.normalize();
+      let scale = i / kernelSize;
+      scale = MathUtils.lerp(0.1, 1, scale * scale);
+      sample.multiplyScalar(scale);
+      kernel.push(sample);
+    }
+  }
+  generateRandomKernelRotations() {
+    const width = 4, height = 4;
+    if (SimplexNoise === void 0) {
+      console.error("THREE.SSAOPass: The pass relies on SimplexNoise.");
+    }
+    const simplex = new SimplexNoise();
+    const size = width * height;
+    const data = new Float32Array(size);
+    for (let i = 0; i < size; i++) {
+      const x = Math.random() * 2 - 1;
+      const y = Math.random() * 2 - 1;
+      const z = 0;
+      data[i] = simplex.noise3d(x, y, z);
+    }
+    this.noiseTexture = new DataTexture(data, width, height, RedFormat, FloatType);
+    this.noiseTexture.wrapS = RepeatWrapping;
+    this.noiseTexture.wrapT = RepeatWrapping;
+    this.noiseTexture.needsUpdate = true;
+  }
+  overrideVisibility() {
+    const scene = this.scene;
+    const cache = this._visibilityCache;
+    scene.traverse(function(object) {
+      cache.set(object, object.visible);
+      if (object.isPoints || object.isLine)
+        object.visible = false;
+    });
+  }
+  restoreVisibility() {
+    const scene = this.scene;
+    const cache = this._visibilityCache;
+    scene.traverse(function(object) {
+      const visible = cache.get(object);
+      object.visible = visible;
+    });
+    cache.clear();
+  }
+}
+SSAOPass.OUTPUT = {
+  Default: 0,
+  SSAO: 1,
+  Blur: 2,
+  Beauty: 3,
+  Depth: 4,
+  Normal: 5
+};
+export {
+  SSAOPass
+};

package/dist/postprocessing/SSRPass.d.ts

@@ -0,0 +1,124 @@
+import {
+  Color,
+  MeshNormalMaterial,
+  MeshBasicMaterial,
+  ShaderMaterial,
+  WebGLRenderTarget,
+  Scene,
+  WebGLRenderer,
+  Camera,
+  Mesh,
+  Material,
+  ColorRepresentation,
+} from 'three'
+import { Pass, FullScreenQuad } from '../postprocessing/Pass'
+import { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass'
+
+export interface SSRPassParams {
+  renderer: WebGLRenderer
+  scene: Scene
+  camera: Camera
+  width?: number | undefined
+  height?: number | undefined
+  selects: Mesh[] | null
+  isPerspectiveCamera?: boolean | undefined
+  isBouncing?: boolean | undefined
+  groundReflector: ReflectorForSSRPass | null
+}
+
+export class SSRPass extends Pass {
+  width: number
+  height: number
+  clear: boolean
+  renderer: WebGLRenderer
+  scene: Scene
+  camera: Camera
+  groundReflector: ReflectorForSSRPass | null
+  opacity: number
+  output: number
+  maxDistance: number
+  thickness: number
+  tempColor: Color
+
+  get selects(): Mesh[] | null
+  set selects(val: Mesh[] | null)
+  selective: boolean
+  get isBouncing(): boolean
+  set isBouncing(val: boolean)
+
+  blur: boolean
+
+  get isDistanceAttenuation(): boolean
+  set isDistanceAttenuation(val: boolean)
+  get isFresnel(): boolean
+  set isFresnel(val: boolean)
+  get isInfiniteThick(): boolean
+  set isInfiniteThick(val: boolean)
+
+  thickTolerance: number
+
+  beautyRenderTarget: WebGLRenderTarget
+  prevRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+  metalnessRenderTarget: WebGLRenderTarget
+  ssrRenderTarget: WebGLRenderTarget
+
+  blurRenderTarget: WebGLRenderTarget
+  blurRenderTarget2: WebGLRenderTarget
+
+  ssrMaterial: ShaderMaterial
+
+  normalMaterial: MeshNormalMaterial
+
+  metalnessOnMaterial: MeshBasicMaterial
+
+  metalnessOffMaterial: MeshBasicMaterial
+
+  blurMaterial: ShaderMaterial
+  blurMaterial2: ShaderMaterial
+
+  depthRenderMaterial: ShaderMaterial
+
+  copyMaterial: ShaderMaterial
+
+  fsQuad: FullScreenQuad
+
+  originalClearColor: Color
+
+  static OUTPUT: {
+    Default: 0
+    SSR: 1
+    Beauty: 3
+    Depth: 4
+    Normal: 5
+    Metalness: 7
+  }
+
+  constructor(params: SSRPassParams)
+
+  dispose: () => void
+
+  renderPass: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: ColorRepresentation,
+    clearAlpha: ColorRepresentation,
+  ) => void
+
+  renderOverride: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: ColorRepresentation,
+    clearAlpha: ColorRepresentation,
+  ) => void
+
+  renderMetalness: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: ColorRepresentation,
+    clearAlpha: ColorRepresentation,
+  ) => void
+}