thing_web/public/cdn/three/EffectComposer.js

(function () {
  class EffectComposer {
    constructor(renderer, renderTarget) {
      this.renderer = renderer;

      if (renderTarget === undefined) {
        const size = renderer.getSize(new THREE.Vector2());
        this._pixelRatio = renderer.getPixelRatio();
        this._width = size.width;
        this._height = size.height;
        renderTarget = new THREE.WebGLRenderTarget(
          this._width * this._pixelRatio,
          this._height * this._pixelRatio
        );
        renderTarget.texture.name = "EffectComposer.rt1";
      } else {
        this._pixelRatio = 1;
        this._width = renderTarget.width;
        this._height = renderTarget.height;
      }

      this.renderTarget1 = renderTarget;
      this.renderTarget2 = renderTarget.clone();
      this.renderTarget2.texture.name = "EffectComposer.rt2";
      this.writeBuffer = this.renderTarget1;
      this.readBuffer = this.renderTarget2;
      this.renderToScreen = true;
      this.passes = []; // dependencies

      if (THREE.CopyShader === undefined) {
        console.error("THREE.EffectComposer relies on THREE.CopyShader");
      }

      if (THREE.ShaderPass === undefined) {
        console.error("THREE.EffectComposer relies on THREE.ShaderPass");
      }

      this.copyPass = new THREE.ShaderPass(THREE.CopyShader);
      this.clock = new THREE.Clock();
    }

    swapBuffers() {
      const tmp = this.readBuffer;
      this.readBuffer = this.writeBuffer;
      this.writeBuffer = tmp;
    }

    addPass(pass) {
      this.passes.push(pass);
      pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
    }

    insertPass(pass, index) {
      this.passes.splice(index, 0, pass);
      pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
    }

    removePass(pass) {
      const index = this.passes.indexOf(pass);

      if (index !== -1) {
        this.passes.splice(index, 1);
      }
    }

    isLastEnabledPass(passIndex) {
      for (let i = passIndex + 1; i < this.passes.length; i++) {
        if (this.passes[i].enabled) {
          return false;
        }
      }

      return true;
    }

    render(deltaTime) {
      // deltaTime value is in seconds
      if (deltaTime === undefined) {
        deltaTime = this.clock.getDelta();
      }

      const currentRenderTarget = this.renderer.getRenderTarget();
      let maskActive = false;

      for (let i = 0, il = this.passes.length; i < il; i++) {
        const pass = this.passes[i];
        if (pass.enabled === false) continue;
        pass.renderToScreen = this.renderToScreen && this.isLastEnabledPass(i);
        pass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime, maskActive);

        if (pass.needsSwap) {
          if (maskActive) {
            const context = this.renderer.getContext();
            const stencil = this.renderer.state.buffers.stencil; //context.stencilFunc( context.NOTEQUAL, 1, 0xffffffff );

            stencil.setFunc(context.NOTEQUAL, 1, 0xffffffff);
            this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime); //context.stencilFunc( context.EQUAL, 1, 0xffffffff );

            stencil.setFunc(context.EQUAL, 1, 0xffffffff);
          }

          this.swapBuffers();
        }

        if (THREE.MaskPass !== undefined) {
          if (pass instanceof THREE.MaskPass) {
            maskActive = true;
          } else if (pass instanceof THREE.ClearMaskPass) {
            maskActive = false;
          }
        }
      }

      this.renderer.setRenderTarget(currentRenderTarget);
    }

    reset(renderTarget) {
      if (renderTarget === undefined) {
        const size = this.renderer.getSize(new THREE.Vector2());
        this._pixelRatio = this.renderer.getPixelRatio();
        this._width = size.width;
        this._height = size.height;
        renderTarget = this.renderTarget1.clone();
        renderTarget.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
      }

      this.renderTarget1.dispose();
      this.renderTarget2.dispose();
      this.renderTarget1 = renderTarget;
      this.renderTarget2 = renderTarget.clone();
      this.writeBuffer = this.renderTarget1;
      this.readBuffer = this.renderTarget2;
    }

    setSize(width, height) {
      this._width = width;
      this._height = height;
      const effectiveWidth = this._width * this._pixelRatio;
      const effectiveHeight = this._height * this._pixelRatio;
      this.renderTarget1.setSize(effectiveWidth, effectiveHeight);
      this.renderTarget2.setSize(effectiveWidth, effectiveHeight);

      for (let i = 0; i < this.passes.length; i++) {
        this.passes[i].setSize(effectiveWidth, effectiveHeight);
      }
    }

    setPixelRatio(pixelRatio) {
      this._pixelRatio = pixelRatio;
      this.setSize(this._width, this._height);
    }
  }

  class Pass {
    constructor() {
      // if set to true, the pass is processed by the composer
      this.enabled = true; // if set to true, the pass indicates to swap read and write buffer after rendering

      this.needsSwap = true; // if set to true, the pass clears its buffer before rendering

      this.clear = false; // if set to true, the result of the pass is rendered to screen. This is set automatically by EffectComposer.

      this.renderToScreen = false;
    }

    setSize() {}

    render() {
      console.error("THREE.Pass: .render() must be implemented in derived pass.");
    }
  } // Helper for passes that need to fill the viewport with a single quad.

  const _camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1); // https://github.com/mrdoob/three.js/pull/21358

  const _geometry = new THREE.BufferGeometry();

  _geometry.setAttribute(
    "position",
    new THREE.Float32BufferAttribute([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)
  );

  _geometry.setAttribute("uv", new THREE.Float32BufferAttribute([0, 2, 0, 0, 2, 0], 2));

  class FullScreenQuad {
    constructor(material) {
      this._mesh = new THREE.Mesh(_geometry, material);
    }

    dispose() {
      this._mesh.geometry.dispose();
    }

    render(renderer) {
      renderer.render(this._mesh, _camera);
    }

    get material() {
      return this._mesh.material;
    }

    set material(value) {
      this._mesh.material = value;
    }
  }

  THREE.EffectComposer = EffectComposer;
  THREE.FullScreenQuad = FullScreenQuad;
  THREE.Pass = Pass;
})();