@xiping/react-components 1.0.19 → 1.0.20

package/dist/es/node_modules/.pnpm/three@0.171.0/node_modules/three/examples/jsm/postprocessing/EffectComposer.js

@@ -0,0 +1,77 @@
+import "../../../build/three.module.js";
+import { CopyShader as d } from "../shaders/CopyShader.js";
+import { ShaderPass as p } from "./ShaderPass.js";
+import { MaskPass as a, ClearMaskPass as l } from "./MaskPass.js";
+import { Vector2 as o, WebGLRenderTarget as c, HalfFloatType as g, NoBlending as _, Clock as u } from "../../../build/three.core.js";
+class P {
+  constructor(e, t) {
+    if (this.renderer = e, this._pixelRatio = e.getPixelRatio(), t === void 0) {
+      const s = e.getSize(new o());
+      this._width = s.width, this._height = s.height, t = new c(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: g }), t.texture.name = "EffectComposer.rt1";
+    } else
+      this._width = t.width, this._height = t.height;
+    this.renderTarget1 = t, this.renderTarget2 = t.clone(), this.renderTarget2.texture.name = "EffectComposer.rt2", this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2, this.renderToScreen = !0, this.passes = [], this.copyPass = new p(d), this.copyPass.material.blending = _, this.clock = new u();
+  }
+  swapBuffers() {
+    const e = this.readBuffer;
+    this.readBuffer = this.writeBuffer, this.writeBuffer = e;
+  }
+  addPass(e) {
+    this.passes.push(e), e.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+  }
+  insertPass(e, t) {
+    this.passes.splice(t, 0, e), e.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+  }
+  removePass(e) {
+    const t = this.passes.indexOf(e);
+    t !== -1 && this.passes.splice(t, 1);
+  }
+  isLastEnabledPass(e) {
+    for (let t = e + 1; t < this.passes.length; t++)
+      if (this.passes[t].enabled)
+        return !1;
+    return !0;
+  }
+  render(e) {
+    e === void 0 && (e = this.clock.getDelta());
+    const t = this.renderer.getRenderTarget();
+    let s = !1;
+    for (let i = 0, r = this.passes.length; i < r; i++) {
+      const h = this.passes[i];
+      if (h.enabled !== !1) {
+        if (h.renderToScreen = this.renderToScreen && this.isLastEnabledPass(i), h.render(this.renderer, this.writeBuffer, this.readBuffer, e, s), h.needsSwap) {
+          if (s) {
+            const f = this.renderer.getContext(), n = this.renderer.state.buffers.stencil;
+            n.setFunc(f.NOTEQUAL, 1, 4294967295), this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, e), n.setFunc(f.EQUAL, 1, 4294967295);
+          }
+          this.swapBuffers();
+        }
+        a !== void 0 && (h instanceof a ? s = !0 : h instanceof l && (s = !1));
+      }
+    }
+    this.renderer.setRenderTarget(t);
+  }
+  reset(e) {
+    if (e === void 0) {
+      const t = this.renderer.getSize(new o());
+      this._pixelRatio = this.renderer.getPixelRatio(), this._width = t.width, this._height = t.height, e = this.renderTarget1.clone(), e.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+    }
+    this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.renderTarget1 = e, this.renderTarget2 = e.clone(), this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2;
+  }
+  setSize(e, t) {
+    this._width = e, this._height = t;
+    const s = this._width * this._pixelRatio, i = this._height * this._pixelRatio;
+    this.renderTarget1.setSize(s, i), this.renderTarget2.setSize(s, i);
+    for (let r = 0; r < this.passes.length; r++)
+      this.passes[r].setSize(s, i);
+  }
+  setPixelRatio(e) {
+    this._pixelRatio = e, this.setSize(this._width, this._height);
+  }
+  dispose() {
+    this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.copyPass.dispose();
+  }
+}
+export {
+  P as EffectComposer
+};

package/dist/es/node_modules/.pnpm/three@0.171.0/node_modules/three/examples/jsm/postprocessing/MaskPass.js

@@ -0,0 +1,24 @@
+import { Pass as r } from "./Pass.js";
+class o extends r {
+  constructor(s, f) {
+    super(), this.scene = s, this.camera = f, this.clear = !0, this.needsSwap = !1, this.inverse = !1;
+  }
+  render(s, f, u) {
+    const t = s.getContext(), e = s.state;
+    e.buffers.color.setMask(!1), e.buffers.depth.setMask(!1), e.buffers.color.setLocked(!0), e.buffers.depth.setLocked(!0);
+    let c, a;
+    this.inverse ? (c = 0, a = 1) : (c = 1, a = 0), e.buffers.stencil.setTest(!0), e.buffers.stencil.setOp(t.REPLACE, t.REPLACE, t.REPLACE), e.buffers.stencil.setFunc(t.ALWAYS, c, 4294967295), e.buffers.stencil.setClear(a), e.buffers.stencil.setLocked(!0), s.setRenderTarget(u), this.clear && s.clear(), s.render(this.scene, this.camera), s.setRenderTarget(f), this.clear && s.clear(), s.render(this.scene, this.camera), e.buffers.color.setLocked(!1), e.buffers.depth.setLocked(!1), e.buffers.color.setMask(!0), e.buffers.depth.setMask(!0), e.buffers.stencil.setLocked(!1), e.buffers.stencil.setFunc(t.EQUAL, 1, 4294967295), e.buffers.stencil.setOp(t.KEEP, t.KEEP, t.KEEP), e.buffers.stencil.setLocked(!0);
+  }
+}
+class n extends r {
+  constructor() {
+    super(), this.needsSwap = !1;
+  }
+  render(s) {
+    s.state.buffers.stencil.setLocked(!1), s.state.buffers.stencil.setTest(!1);
+  }
+}
+export {
+  n as ClearMaskPass,
+  o as MaskPass
+};

package/dist/es/node_modules/.pnpm/three@0.171.0/node_modules/three/examples/jsm/postprocessing/Pass.js

@@ -0,0 +1,42 @@
+import "../../../build/three.module.js";
+import { Mesh as r, OrthographicCamera as i, BufferGeometry as a, Float32BufferAttribute as t } from "../../../build/three.core.js";
+class c {
+  constructor() {
+    this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
+  }
+  setSize() {
+  }
+  render() {
+    console.error("THREE.Pass: .render() must be implemented in derived pass.");
+  }
+  dispose() {
+  }
+}
+const n = new i(-1, 1, 1, -1, 0, 1);
+class o extends a {
+  constructor() {
+    super(), this.setAttribute("position", new t([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new t([0, 2, 0, 0, 2, 0], 2));
+  }
+}
+const m = new o();
+class u {
+  constructor(e) {
+    this._mesh = new r(m, e);
+  }
+  dispose() {
+    this._mesh.geometry.dispose();
+  }
+  render(e) {
+    e.render(this._mesh, n);
+  }
+  get material() {
+    return this._mesh.material;
+  }
+  set material(e) {
+    this._mesh.material = e;
+  }
+}
+export {
+  u as FullScreenQuad,
+  c as Pass
+};

package/dist/es/node_modules/.pnpm/three@0.171.0/node_modules/three/examples/jsm/postprocessing/RenderPass.js

@@ -0,0 +1,17 @@
+import "../../../build/three.module.js";
+import { Pass as s } from "./Pass.js";
+import { Color as r } from "../../../build/three.core.js";
+class p extends s {
+  constructor(l, i, t = null, e = null, a = null) {
+    super(), this.scene = l, this.camera = i, this.overrideMaterial = t, this.clearColor = e, this.clearAlpha = a, this.clear = !0, this.clearDepth = !1, this.needsSwap = !1, this._oldClearColor = new r();
+  }
+  render(l, i, t) {
+    const e = l.autoClear;
+    l.autoClear = !1;
+    let a, o;
+    this.overrideMaterial !== null && (o = this.scene.overrideMaterial, this.scene.overrideMaterial = this.overrideMaterial), this.clearColor !== null && (l.getClearColor(this._oldClearColor), l.setClearColor(this.clearColor, l.getClearAlpha())), this.clearAlpha !== null && (a = l.getClearAlpha(), l.setClearAlpha(this.clearAlpha)), this.clearDepth == !0 && l.clearDepth(), l.setRenderTarget(this.renderToScreen ? null : t), this.clear === !0 && l.clear(l.autoClearColor, l.autoClearDepth, l.autoClearStencil), l.render(this.scene, this.camera), this.clearColor !== null && l.setClearColor(this._oldClearColor), this.clearAlpha !== null && l.setClearAlpha(a), this.overrideMaterial !== null && (this.scene.overrideMaterial = o), l.autoClear = e;
+  }
+}
+export {
+  p as RenderPass
+};

package/dist/es/node_modules/.pnpm/three@0.171.0/node_modules/three/examples/jsm/postprocessing/ShaderPass.js

@@ -0,0 +1,23 @@
+import "../../../build/three.module.js";
+import { Pass as a, FullScreenQuad as n } from "./Pass.js";
+import { ShaderMaterial as e, UniformsUtils as f } from "../../../build/three.core.js";
+class l extends a {
+  constructor(i, t) {
+    super(), this.textureID = t !== void 0 ? t : "tDiffuse", i instanceof e ? (this.uniforms = i.uniforms, this.material = i) : i && (this.uniforms = f.clone(i.uniforms), this.material = new e({
+      name: i.name !== void 0 ? i.name : "unspecified",
+      defines: Object.assign({}, i.defines),
+      uniforms: this.uniforms,
+      vertexShader: i.vertexShader,
+      fragmentShader: i.fragmentShader
+    })), this.fsQuad = new n(this.material);
+  }
+  render(i, t, s) {
+    this.uniforms[this.textureID] && (this.uniforms[this.textureID].value = s.texture), this.fsQuad.material = this.material, this.renderToScreen ? (i.setRenderTarget(null), this.fsQuad.render(i)) : (i.setRenderTarget(t), this.clear && i.clear(i.autoClearColor, i.autoClearDepth, i.autoClearStencil), this.fsQuad.render(i));
+  }
+  dispose() {
+    this.material.dispose(), this.fsQuad.dispose();
+  }
+}
+export {
+  l as ShaderPass
+};

package/dist/es/node_modules/.pnpm/three@0.171.0/node_modules/three/examples/jsm/shaders/CopyShader.js

@@ -0,0 +1,41 @@
+const e = {
+  name: "CopyShader",
+  uniforms: {
+    tDiffuse: { value: null },
+    opacity: { value: 1 }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+
+		uniform float opacity;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 texel = texture2D( tDiffuse, vUv );
+			gl_FragColor = opacity * texel;
+
+
+		}`
+  )
+};
+export {
+  e as CopyShader
+};