three-stdlib 2.22.7 → 2.22.8

package/dist/postprocessing/SSAARenderPass.mjs

@@ -0,0 +1,171 @@
+import { Color, UniformsUtils, ShaderMaterial, AdditiveBlending, WebGLRenderTarget, LinearFilter, RGBAFormat } from "three";
+import { FullScreenQuad, Pass } from "./Pass.mjs";
+import { CopyShader } from "../shaders/CopyShader.mjs";
+var SSAARenderPass = function(scene, camera, clearColor, clearAlpha) {
+  this.scene = scene;
+  this.camera = camera;
+  this.sampleLevel = 4;
+  this.unbiased = true;
+  this.clearColor = clearColor !== void 0 ? clearColor : 0;
+  this.clearAlpha = clearAlpha !== void 0 ? clearAlpha : 0;
+  this._oldClearColor = new Color();
+  if (CopyShader === void 0)
+    console.error("THREE.SSAARenderPass relies on CopyShader");
+  var copyShader = CopyShader;
+  this.copyUniforms = UniformsUtils.clone(copyShader.uniforms);
+  this.copyMaterial = new ShaderMaterial({
+    uniforms: this.copyUniforms,
+    vertexShader: copyShader.vertexShader,
+    fragmentShader: copyShader.fragmentShader,
+    premultipliedAlpha: true,
+    transparent: true,
+    blending: AdditiveBlending,
+    depthTest: false,
+    depthWrite: false
+  });
+  this.fsQuad = new FullScreenQuad(this.copyMaterial);
+};
+SSAARenderPass.prototype = Object.assign(Object.create(Pass.prototype), {
+  constructor: SSAARenderPass,
+  dispose: function() {
+    if (this.sampleRenderTarget) {
+      this.sampleRenderTarget.dispose();
+      this.sampleRenderTarget = null;
+    }
+  },
+  setSize: function(width, height) {
+    if (this.sampleRenderTarget)
+      this.sampleRenderTarget.setSize(width, height);
+  },
+  render: function(renderer, writeBuffer, readBuffer) {
+    if (!this.sampleRenderTarget) {
+      this.sampleRenderTarget = new WebGLRenderTarget(readBuffer.width, readBuffer.height, {
+        minFilter: LinearFilter,
+        magFilter: LinearFilter,
+        format: RGBAFormat
+      });
+      this.sampleRenderTarget.texture.name = "SSAARenderPass.sample";
+    }
+    var jitterOffsets = SSAARenderPass.JitterVectors[Math.max(0, Math.min(this.sampleLevel, 5))];
+    var autoClear = renderer.autoClear;
+    renderer.autoClear = false;
+    renderer.getClearColor(this._oldClearColor);
+    var oldClearAlpha = renderer.getClearAlpha();
+    var baseSampleWeight = 1 / jitterOffsets.length;
+    var roundingRange = 1 / 32;
+    this.copyUniforms["tDiffuse"].value = this.sampleRenderTarget.texture;
+    var width = readBuffer.width, height = readBuffer.height;
+    for (let i = 0; i < jitterOffsets.length; i++) {
+      var jitterOffset = jitterOffsets[i];
+      if (this.camera.setViewOffset) {
+        this.camera.setViewOffset(
+          width,
+          height,
+          jitterOffset[0] * 0.0625,
+          jitterOffset[1] * 0.0625,
+          // 0.0625 = 1 / 16
+          width,
+          height
+        );
+      }
+      var sampleWeight = baseSampleWeight;
+      if (this.unbiased) {
+        var uniformCenteredDistribution = -0.5 + (i + 0.5) / jitterOffsets.length;
+        sampleWeight += roundingRange * uniformCenteredDistribution;
+      }
+      this.copyUniforms["opacity"].value = sampleWeight;
+      renderer.setClearColor(this.clearColor, this.clearAlpha);
+      renderer.setRenderTarget(this.sampleRenderTarget);
+      renderer.clear();
+      renderer.render(this.scene, this.camera);
+      renderer.setRenderTarget(this.renderToScreen ? null : writeBuffer);
+      if (i === 0) {
+        renderer.setClearColor(0, 0);
+        renderer.clear();
+      }
+      this.fsQuad.render(renderer);
+    }
+    if (this.camera.clearViewOffset)
+      this.camera.clearViewOffset();
+    renderer.autoClear = autoClear;
+    renderer.setClearColor(this._oldClearColor, oldClearAlpha);
+  }
+});
+SSAARenderPass.JitterVectors = [
+  [[0, 0]],
+  [
+    [4, 4],
+    [-4, -4]
+  ],
+  [
+    [-2, -6],
+    [6, -2],
+    [-6, 2],
+    [2, 6]
+  ],
+  [
+    [1, -3],
+    [-1, 3],
+    [5, 1],
+    [-3, -5],
+    [-5, 5],
+    [-7, -1],
+    [3, 7],
+    [7, -7]
+  ],
+  [
+    [1, 1],
+    [-1, -3],
+    [-3, 2],
+    [4, -1],
+    [-5, -2],
+    [2, 5],
+    [5, 3],
+    [3, -5],
+    [-2, 6],
+    [0, -7],
+    [-4, -6],
+    [-6, 4],
+    [-8, 0],
+    [7, -4],
+    [6, 7],
+    [-7, -8]
+  ],
+  [
+    [-4, -7],
+    [-7, -5],
+    [-3, -5],
+    [-5, -4],
+    [-1, -4],
+    [-2, -2],
+    [-6, -1],
+    [-4, 0],
+    [-7, 1],
+    [-1, 2],
+    [-6, 3],
+    [-3, 3],
+    [-7, 6],
+    [-3, 6],
+    [-5, 7],
+    [-1, 7],
+    [5, -7],
+    [1, -6],
+    [6, -5],
+    [4, -4],
+    [2, -3],
+    [7, -2],
+    [1, -1],
+    [4, -1],
+    [2, 1],
+    [6, 2],
+    [0, 4],
+    [4, 4],
+    [2, 5],
+    [7, 5],
+    [5, 6],
+    [3, 7]
+  ]
+];
+export {
+  SSAARenderPass
+};

package/dist/postprocessing/SSAOPass.d.ts

@@ -0,0 +1,71 @@
+import {
+  Camera,
+  Color,
+  DataTexture,
+  Material,
+  MeshNormalMaterial,
+  Scene,
+  ShaderMaterial,
+  Vector3,
+  WebGLRenderer,
+  WebGLRenderTarget,
+  ColorRepresentation,
+} from 'three'
+
+import { Pass } from './Pass'
+
+export enum SSAOPassOUTPUT {
+  Default,
+  SSAO,
+  Blur,
+  Beauty,
+  Depth,
+  Normal,
+}
+
+export class SSAOPass extends Pass {
+  constructor(scene: Scene, camera: Camera, width?: number, height?: number)
+  scene: Scene
+  camera: Camera
+  width: number
+  height: boolean
+  clear: boolean
+  kernelRadius: number
+  kernelSize: number
+  kernel: Vector3[]
+  noiseTexture: DataTexture
+  output: SSAOPassOUTPUT
+  minDistance: number
+  maxDistance: number
+  beautyRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+  ssaoRenderTarget: WebGLRenderTarget
+  blurRenderTarget: WebGLRenderTarget
+  ssaoMaterial: ShaderMaterial
+  normalMaterial: MeshNormalMaterial
+  blurMaterial: ShaderMaterial
+  depthRenderMaterial: ShaderMaterial
+  copyMaterial: ShaderMaterial
+  fsQuad: object
+  originalClearColor: Color
+
+  static OUTPUT: SSAOPassOUTPUT
+
+  dipose(): void
+  generateSampleKernel(): Vector3[]
+  generateRandomKernelRotations(): void
+  renderPass(
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor?: ColorRepresentation,
+    clearAlpha?: number,
+  ): void
+  renderOverride(
+    renderer: WebGLRenderer,
+    overrideMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor?: ColorRepresentation,
+    clearAlpha?: number,
+  ): void
+}

package/dist/postprocessing/SSAOPass.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const Pass = require("./Pass.js");
+const SimplexNoise = require("../math/SimplexNoise.js");
+const SSAOShader = require("../shaders/SSAOShader.js");
+const CopyShader = require("../shaders/CopyShader.js");
+class SSAOPass extends Pass.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 THREE.DepthTexture();
+    depthTexture.format = THREE.DepthStencilFormat;
+    depthTexture.type = THREE.UnsignedInt248Type;
+    this.beautyRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height);
+    this.normalRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+      minFilter: THREE.NearestFilter,
+      magFilter: THREE.NearestFilter,
+      depthTexture
+    });
+    this.ssaoRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height);
+    this.blurRenderTarget = this.ssaoRenderTarget.clone();
+    if (SSAOShader.SSAOShader === void 0) {
+      console.error("THREE.SSAOPass: The pass relies on SSAOShader.");
+    }
+    this.ssaoMaterial = new THREE.ShaderMaterial({
+      defines: Object.assign({}, SSAOShader.SSAOShader.defines),
+      uniforms: THREE.UniformsUtils.clone(SSAOShader.SSAOShader.uniforms),
+      vertexShader: SSAOShader.SSAOShader.vertexShader,
+      fragmentShader: SSAOShader.SSAOShader.fragmentShader,
+      blending: THREE.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 THREE.MeshNormalMaterial();
+    this.normalMaterial.blending = THREE.NoBlending;
+    this.blurMaterial = new THREE.ShaderMaterial({
+      defines: Object.assign({}, SSAOShader.SSAOBlurShader.defines),
+      uniforms: THREE.UniformsUtils.clone(SSAOShader.SSAOBlurShader.uniforms),
+      vertexShader: SSAOShader.SSAOBlurShader.vertexShader,
+      fragmentShader: SSAOShader.SSAOBlurShader.fragmentShader
+    });
+    this.blurMaterial.uniforms["tDiffuse"].value = this.ssaoRenderTarget.texture;
+    this.blurMaterial.uniforms["resolution"].value.set(this.width, this.height);
+    this.depthRenderMaterial = new THREE.ShaderMaterial({
+      defines: Object.assign({}, SSAOShader.SSAODepthShader.defines),
+      uniforms: THREE.UniformsUtils.clone(SSAOShader.SSAODepthShader.uniforms),
+      vertexShader: SSAOShader.SSAODepthShader.vertexShader,
+      fragmentShader: SSAOShader.SSAODepthShader.fragmentShader,
+      blending: THREE.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 THREE.ShaderMaterial({
+      uniforms: THREE.UniformsUtils.clone(CopyShader.CopyShader.uniforms),
+      vertexShader: CopyShader.CopyShader.vertexShader,
+      fragmentShader: CopyShader.CopyShader.fragmentShader,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      blendSrc: THREE.DstColorFactor,
+      blendDst: THREE.ZeroFactor,
+      blendEquation: THREE.AddEquation,
+      blendSrcAlpha: THREE.DstAlphaFactor,
+      blendDstAlpha: THREE.ZeroFactor,
+      blendEquationAlpha: THREE.AddEquation
+    });
+    this.fsQuad = new Pass.FullScreenQuad(null);
+    this.originalClearColor = new THREE.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 = THREE.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 = THREE.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 = THREE.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 = THREE.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 = THREE.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 = THREE.NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget.texture;
+        this.copyMaterial.blending = THREE.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 THREE.Vector3();
+      sample.x = Math.random() * 2 - 1;
+      sample.y = Math.random() * 2 - 1;
+      sample.z = Math.random();
+      sample.normalize();
+      let scale = i / kernelSize;
+      scale = THREE.MathUtils.lerp(0.1, 1, scale * scale);
+      sample.multiplyScalar(scale);
+      kernel.push(sample);
+    }
+  }
+  generateRandomKernelRotations() {
+    const width = 4, height = 4;
+    if (SimplexNoise.SimplexNoise === void 0) {
+      console.error("THREE.SSAOPass: The pass relies on SimplexNoise.");
+    }
+    const simplex = new SimplexNoise.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 THREE.DataTexture(data, width, height, THREE.RedFormat, THREE.FloatType);
+    this.noiseTexture.wrapS = THREE.RepeatWrapping;
+    this.noiseTexture.wrapT = THREE.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
+};
+exports.SSAOPass = SSAOPass;