three-stdlib 2.22.7 → 2.22.8

package/dist/postprocessing/SSRPass.js

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const Pass = require("./Pass.js");
+const SSRShader = require("../shaders/SSRShader.js");
+const CopyShader = require("../shaders/CopyShader.js");
+var SSRPass = function({
+  renderer,
+  scene,
+  camera,
+  width,
+  height,
+  selects,
+  encoding,
+  isPerspectiveCamera = true,
+  isBouncing = false,
+  morphTargets = false,
+  groundReflector
+}) {
+  this.width = width !== void 0 ? width : 512;
+  this.height = height !== void 0 ? height : 512;
+  this.clear = true;
+  this.renderer = renderer;
+  this.scene = scene;
+  this.camera = camera;
+  this.groundReflector = groundReflector;
+  this.opacity = SSRShader.SSRShader.uniforms.opacity.value;
+  this.output = 0;
+  this.maxDistance = SSRShader.SSRShader.uniforms.maxDistance.value;
+  this.surfDist = SSRShader.SSRShader.uniforms.surfDist.value;
+  this.encoding = encoding;
+  this.tempColor = new THREE.Color();
+  this._selects = selects;
+  this.isSelective = Array.isArray(this._selects);
+  Object.defineProperty(this, "selects", {
+    get() {
+      return this._selects;
+    },
+    set(val) {
+      if (this._selects === val)
+        return;
+      this._selects = val;
+      if (Array.isArray(val)) {
+        this.isSelective = true;
+        this.ssrMaterial.defines.isSelective = true;
+        this.ssrMaterial.needsUpdate = true;
+      } else {
+        this.isSelective = false;
+        this.ssrMaterial.defines.isSelective = false;
+        this.ssrMaterial.needsUpdate = true;
+      }
+    }
+  });
+  this._isBouncing = isBouncing;
+  Object.defineProperty(this, "isBouncing", {
+    get() {
+      return this._isBouncing;
+    },
+    set(val) {
+      if (this._isBouncing === val)
+        return;
+      this._isBouncing = val;
+      if (val) {
+        this.ssrMaterial.uniforms["tDiffuse"].value = this.prevRenderTarget.texture;
+      } else {
+        this.ssrMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+      }
+    }
+  });
+  this.isBlur = true;
+  this._isDistanceAttenuation = SSRShader.SSRShader.defines.isDistanceAttenuation;
+  Object.defineProperty(this, "isDistanceAttenuation", {
+    get() {
+      return this._isDistanceAttenuation;
+    },
+    set(val) {
+      if (this._isDistanceAttenuation === val)
+        return;
+      this._isDistanceAttenuation = val;
+      this.ssrMaterial.defines.isDistanceAttenuation = val;
+      this.ssrMaterial.needsUpdate = true;
+    }
+  });
+  this._isFresnel = SSRShader.SSRShader.defines.isFresnel;
+  Object.defineProperty(this, "isFresnel", {
+    get() {
+      return this._isFresnel;
+    },
+    set(val) {
+      if (this._isFresnel === val)
+        return;
+      this._isFresnel = val;
+      this.ssrMaterial.defines.isFresnel = val;
+      this.ssrMaterial.needsUpdate = true;
+    }
+  });
+  this._isInfiniteThick = SSRShader.SSRShader.defines.isInfiniteThick;
+  Object.defineProperty(this, "isInfiniteThick", {
+    get() {
+      return this._isInfiniteThick;
+    },
+    set(val) {
+      if (this._isInfiniteThick === val)
+        return;
+      this._isInfiniteThick = val;
+      this.ssrMaterial.defines.isInfiniteThick = val;
+      this.ssrMaterial.needsUpdate = true;
+    }
+  });
+  this.thickTolerance = SSRShader.SSRShader.uniforms.thickTolerance.value;
+  var depthTexture = new THREE.DepthTexture();
+  depthTexture.type = THREE.UnsignedShortType;
+  depthTexture.minFilter = THREE.NearestFilter;
+  depthTexture.maxFilter = THREE.NearestFilter;
+  this.beautyRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+    minFilter: THREE.LinearFilter,
+    magFilter: THREE.LinearFilter,
+    format: THREE.RGBAFormat,
+    depthTexture,
+    depthBuffer: true
+  });
+  this.prevRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+    minFilter: THREE.LinearFilter,
+    magFilter: THREE.LinearFilter,
+    format: THREE.RGBAFormat
+  });
+  this.normalRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+    minFilter: THREE.NearestFilter,
+    magFilter: THREE.NearestFilter,
+    format: THREE.RGBAFormat,
+    type: THREE.HalfFloatType
+  });
+  this.metalnessRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+    minFilter: THREE.NearestFilter,
+    magFilter: THREE.NearestFilter,
+    format: THREE.RGBAFormat
+  });
+  this.ssrRenderTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+    minFilter: THREE.LinearFilter,
+    magFilter: THREE.LinearFilter,
+    format: THREE.RGBAFormat
+  });
+  this.blurRenderTarget = this.ssrRenderTarget.clone();
+  this.blurRenderTarget2 = this.ssrRenderTarget.clone();
+  if (SSRShader.SSRShader === void 0) {
+    console.error("THREE.SSRPass: The pass relies on SSRShader.");
+  }
+  this.ssrMaterial = new THREE.ShaderMaterial({
+    defines: Object.assign(
+      {
+        MAX_STEP: Math.sqrt(window.innerWidth * window.innerWidth + window.innerHeight * window.innerHeight)
+      },
+      SSRShader.SSRShader.defines
+    ),
+    uniforms: THREE.UniformsUtils.clone(SSRShader.SSRShader.uniforms),
+    vertexShader: SSRShader.SSRShader.vertexShader,
+    fragmentShader: SSRShader.SSRShader.fragmentShader,
+    blending: THREE.NoBlending
+  });
+  if (!isPerspectiveCamera) {
+    this.ssrMaterial.defines.isPerspectiveCamera = isPerspectiveCamera;
+    this.ssrMaterial.needsUpdate = true;
+  }
+  this.ssrMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+  this.ssrMaterial.uniforms["tNormal"].value = this.normalRenderTarget.texture;
+  this.ssrMaterial.defines.isSelective = this.isSelective;
+  this.ssrMaterial.needsUpdate = true;
+  this.ssrMaterial.uniforms["tMetalness"].value = this.metalnessRenderTarget.texture;
+  this.ssrMaterial.uniforms["tDepth"].value = this.beautyRenderTarget.depthTexture;
+  this.ssrMaterial.uniforms["cameraNear"].value = this.camera.near;
+  this.ssrMaterial.uniforms["cameraFar"].value = this.camera.far;
+  this.ssrMaterial.uniforms["surfDist"].value = this.surfDist;
+  this.ssrMaterial.uniforms["resolution"].value.set(this.width, this.height);
+  this.ssrMaterial.uniforms["cameraProjectionMatrix"].value.copy(this.camera.projectionMatrix);
+  this.ssrMaterial.uniforms["cameraInverseProjectionMatrix"].value.copy(this.camera.projectionMatrixInverse);
+  this.normalMaterial = new THREE.MeshNormalMaterial({ morphTargets });
+  this.normalMaterial.blending = THREE.NoBlending;
+  this.metalnessOnMaterial = new THREE.MeshBasicMaterial({
+    color: "white"
+  });
+  this.metalnessOffMaterial = new THREE.MeshBasicMaterial({
+    color: "black"
+  });
+  this.blurMaterial = new THREE.ShaderMaterial({
+    defines: Object.assign({}, SSRShader.SSRBlurShader.defines),
+    uniforms: THREE.UniformsUtils.clone(SSRShader.SSRBlurShader.uniforms),
+    vertexShader: SSRShader.SSRBlurShader.vertexShader,
+    fragmentShader: SSRShader.SSRBlurShader.fragmentShader
+  });
+  this.blurMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
+  this.blurMaterial.uniforms["resolution"].value.set(this.width, this.height);
+  this.blurMaterial2 = new THREE.ShaderMaterial({
+    defines: Object.assign({}, SSRShader.SSRBlurShader.defines),
+    uniforms: THREE.UniformsUtils.clone(SSRShader.SSRBlurShader.uniforms),
+    vertexShader: SSRShader.SSRBlurShader.vertexShader,
+    fragmentShader: SSRShader.SSRBlurShader.fragmentShader
+  });
+  this.blurMaterial2.uniforms["tDiffuse"].value = this.blurRenderTarget.texture;
+  this.blurMaterial2.uniforms["resolution"].value.set(this.width, this.height);
+  this.depthRenderMaterial = new THREE.ShaderMaterial({
+    defines: Object.assign({}, SSRShader.SSRDepthShader.defines),
+    uniforms: THREE.UniformsUtils.clone(SSRShader.SSRDepthShader.uniforms),
+    vertexShader: SSRShader.SSRDepthShader.vertexShader,
+    fragmentShader: SSRShader.SSRDepthShader.fragmentShader,
+    blending: THREE.NoBlending
+  });
+  this.depthRenderMaterial.uniforms["tDepth"].value = this.beautyRenderTarget.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.SrcAlphaFactor,
+    blendDst: THREE.OneMinusSrcAlphaFactor,
+    blendEquation: THREE.AddEquation,
+    blendSrcAlpha: THREE.SrcAlphaFactor,
+    blendDstAlpha: THREE.OneMinusSrcAlphaFactor,
+    blendEquationAlpha: THREE.AddEquation
+    // premultipliedAlpha:true,
+  });
+  this.fsQuad = new Pass.FullScreenQuad(null);
+  this.originalClearColor = new THREE.Color();
+};
+SSRPass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
+  constructor: SSRPass,
+  dispose: function() {
+    this.beautyRenderTarget.dispose();
+    this.prevRenderTarget.dispose();
+    this.normalRenderTarget.dispose();
+    this.metalnessRenderTarget.dispose();
+    this.ssrRenderTarget.dispose();
+    this.blurRenderTarget.dispose();
+    this.blurRenderTarget2.dispose();
+    this.normalMaterial.dispose();
+    this.metalnessOnMaterial.dispose();
+    this.metalnessOffMaterial.dispose();
+    this.blurMaterial.dispose();
+    this.blurMaterial2.dispose();
+    this.copyMaterial.dispose();
+    this.depthRenderMaterial.dispose();
+    this.fsQuad.dispose();
+  },
+  render: function(renderer, writeBuffer) {
+    if (this.encoding) {
+      if ("colorSpace" in this.beautyRenderTarget.texture) {
+        this.beautyRenderTarget.texture.colorSpace = this.encoding === 3001 ? "srgb" : "srgb-linear";
+      } else {
+        this.beautyRenderTarget.texture.encoding = this.encoding;
+      }
+    }
+    renderer.setRenderTarget(this.beautyRenderTarget);
+    renderer.clear();
+    if (this.groundReflector) {
+      this.groundReflector.doRender(this.renderer, this.scene, this.camera);
+      this.groundReflector.visible = true;
+    }
+    renderer.render(this.scene, this.camera);
+    if (this.groundReflector)
+      this.groundReflector.visible = false;
+    this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0);
+    if (this.isSelective) {
+      this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0);
+    }
+    this.ssrMaterial.uniforms["opacity"].value = this.opacity;
+    this.ssrMaterial.uniforms["maxDistance"].value = this.maxDistance;
+    this.ssrMaterial.uniforms["surfDist"].value = this.surfDist;
+    this.ssrMaterial.uniforms["thickTolerance"].value = this.thickTolerance;
+    this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget);
+    if (this.isBlur) {
+      this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget);
+      this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2);
+    }
+    switch (this.output) {
+      case SSRPass.OUTPUT.Default:
+        if (this.isBouncing) {
+          this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+          this.copyMaterial.blending = THREE.NoBlending;
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+          if (this.isBlur)
+            this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget2.texture;
+          else
+            this.copyMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
+          this.copyMaterial.blending = THREE.NormalBlending;
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+          this.copyMaterial.uniforms["tDiffuse"].value = this.prevRenderTarget.texture;
+          this.copyMaterial.blending = THREE.NoBlending;
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        } else {
+          this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+          this.copyMaterial.blending = THREE.NoBlending;
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+          if (this.isBlur)
+            this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget2.texture;
+          else
+            this.copyMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
+          this.copyMaterial.blending = THREE.NormalBlending;
+          this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        }
+        break;
+      case SSRPass.OUTPUT.SSR:
+        if (this.isBlur)
+          this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget2.texture;
+        else
+          this.copyMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
+        this.copyMaterial.blending = THREE.NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        if (this.isBouncing) {
+          if (this.isBlur)
+            this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget2.texture;
+          else
+            this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+          this.copyMaterial.blending = THREE.NoBlending;
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+          this.copyMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
+          this.copyMaterial.blending = THREE.NormalBlending;
+          this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+        }
+        break;
+      case SSRPass.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 SSRPass.OUTPUT.Depth:
+        this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      case SSRPass.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 SSRPass.OUTPUT.Metalness:
+        this.copyMaterial.uniforms["tDiffuse"].value = this.metalnessRenderTarget.texture;
+        this.copyMaterial.blending = THREE.NoBlending;
+        this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+        break;
+      default:
+        console.warn("THREE.SSRPass: Unknown output type.");
+    }
+  },
+  renderPass: function(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+    this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
+    var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+    var 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: function(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+    this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
+    var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+    var 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);
+  },
+  renderMetalness: function(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+    this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
+    var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+    var 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.traverseVisible((child) => {
+      child._SSRPassMaterialBack = child.material;
+      if (this._selects.includes(child)) {
+        child.material = this.metalnessOnMaterial;
+      } else {
+        child.material = this.metalnessOffMaterial;
+      }
+    });
+    renderer.render(this.scene, this.camera);
+    this.scene.traverseVisible((child) => {
+      child.material = child._SSRPassMaterialBack;
+    });
+    renderer.autoClear = originalAutoClear;
+    renderer.setClearColor(this.originalClearColor);
+    renderer.setClearAlpha(originalClearAlpha);
+  },
+  setSize: function(width, height) {
+    this.width = width;
+    this.height = height;
+    this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height);
+    this.ssrMaterial.needsUpdate = true;
+    this.beautyRenderTarget.setSize(width, height);
+    this.prevRenderTarget.setSize(width, height);
+    this.ssrRenderTarget.setSize(width, height);
+    this.normalRenderTarget.setSize(width, height);
+    this.metalnessRenderTarget.setSize(width, height);
+    this.blurRenderTarget.setSize(width, height);
+    this.blurRenderTarget2.setSize(width, height);
+    this.ssrMaterial.uniforms["resolution"].value.set(width, height);
+    this.ssrMaterial.uniforms["cameraProjectionMatrix"].value.copy(this.camera.projectionMatrix);
+    this.ssrMaterial.uniforms["cameraInverseProjectionMatrix"].value.copy(this.camera.projectionMatrixInverse);
+    this.blurMaterial.uniforms["resolution"].value.set(width, height);
+    this.blurMaterial2.uniforms["resolution"].value.set(width, height);
+  }
+});
+SSRPass.OUTPUT = {
+  Default: 0,
+  SSR: 1,
+  Beauty: 3,
+  Depth: 4,
+  Normal: 5,
+  Metalness: 7
+};
+exports.SSRPass = SSRPass;