@shjjs/visual-ui 1.0.0

package/es/components/scene-map3d/index.vue2.mjs

@@ -0,0 +1,282 @@
+import { defineComponent as R, ref as g, onMounted as K, onBeforeUnmount as Q, computed as X, watch as b, openBlock as d, createElementBlock as u, normalizeClass as H, normalizeStyle as f, createCommentVNode as S, Fragment as W, renderList as M, createElementVNode as B, toDisplayString as k, unref as Y } from "vue";
+import { cloneDeep as v, isEqual as h } from "lodash";
+import z from "gsap";
+import { useFps as Z } from "@vueuse/core";
+import { World as x } from "./map3d/map.mjs";
+import { initWatch as ee } from "./watch.mjs";
+import { autoInstallFont as L, jsonToCssStyle as E } from "../../utils/json2css.mjs";
+import "three";
+import "d3-geo";
+import "three/examples/jsm/controls/OrbitControls";
+import "three/examples/jsm/loaders/GLTFLoader";
+import "three/examples/jsm/loaders/DRACOLoader.js";
+import { createHistory as te } from "../../utils/mini3d/utils/CreateHistory.mjs";
+import "three/examples/jsm/libs/lil-gui.module.min";
+import "three/examples/jsm/utils/BufferGeometryUtils";
+import "three/examples/jsm/renderers/CSS3DRenderer";
+const oe = { class: "value" }, ae = ["onClick"], le = {
+  key: 3,
+  class: "fps"
+}, ne = R({ name: "zv-scene-map3d" }), ke = /* @__PURE__ */ R({
+  ...ne,
+  props: {
+    basicOption: {},
+    sources: {},
+    globalEvent: {},
+    uuid: {}
+  },
+  emits: [
+    "on-loaded",
+    "on-animated",
+    "on-drill-down",
+    "on-area-mouseover",
+    "on-area-mouseout",
+    "on-area-click",
+    "on-bar-click",
+    "on-scatter-click",
+    "on-flyline-click",
+    "on-return",
+    "on-data-change"
+  ],
+  setup(T, { expose: $, emit: V }) {
+    const i = V, a = T, l = g(), O = g(!1), C = g(!1), w = "zerov-map3d-scene", I = "zerov-map3d-scene-wrap", r = new te(), p = g(!1), y = (e = !0) => {
+      l.value.cleanAllBar(), l.value.cleanAllScatter(), l.value.cleanAllFlyLine(), l.value.createAllRegionalLevel(), a.sources && a.sources.length > 0 && window.SHJDatasourceV2({
+        tId: a.uuid,
+        sources: a.sources,
+        callback: (o) => {
+          try {
+            const t = a.basicOption.widgets && a.basicOption.widgets.find((s) => s._sourceId === o.id);
+            t && t.type === "bar" && l.value.createBar(t, o.data[0].data, !0, e), t && t.type === "scatter" && l.value.createScatter(t, o.data[0].data, !0, e), t && t.type === "flyline" && l.value.createFlyLine(t, o.data[0].data, !0, e), t && t.type === "regionalLevel" && l.value.createRegionalLevel(t, o.data[0].data, !0, e), e && (l.value.createBarTimeLine(), l.value.createScatterTimeLine(), l.value.createFlyLineTimeLine(), l.value.createRegionalLevelTimeLine()), i("on-data-change", o), window.SHJParseEvent(a.globalEvent, "on-data-change", o);
+          } catch {
+            i("on-data-change", null), window.SHJParseEvent(a.globalEvent, "on-data-change", null);
+          }
+        }
+      });
+    }, N = () => {
+      document.getElementById(w) && document.getElementById(I).removeChild(document.getElementById(w));
+      const e = document.createElement("canvas");
+      e.id = w, e.className = "zerov-map-3d", e.style.width = "100%", e.style.height = "100%", document.getElementById(I).appendChild(e);
+    }, m = (e) => (O.value = !1, C.value = !1, l.value && (l.value.destroy(), l.value = null), N(), new x(document.getElementById(w), { geoProjectionCenter: [108.55, 36.32] }, e, {
+      onAreaMouseover: (t) => {
+        i("on-area-mouseover", t), window.SHJParseEvent(a.globalEvent, "on-area-mouseover", t);
+      },
+      onAreaMouseout: (t) => {
+        i("on-area-mouseout", t), window.SHJParseEvent(a.globalEvent, "on-area-mouseout", t);
+      },
+      onLoadChild: (t) => {
+        if (i("on-area-click", t), window.SHJParseEvent(a.globalEvent, "on-area-click", t), t.adcode !== r.present && a.basicOption.scene.isDrilling && a.basicOption.scene.defaultMapAdcode !== 1) {
+          i("on-drill-down", t), window.SHJParseEvent(a.globalEvent, "on-drill-down", t);
+          const s = v(a.basicOption);
+          s.scene.defaultMapAdcode = t.adcode, l.value = m(s), r.push(t.adcode), r.past.length <= 0 ? p.value = !1 : p.value = !0;
+        }
+      },
+      onMapSuccess: () => {
+        O.value = !0, i("on-loaded"), window.SHJParseEvent(a.globalEvent, "on-loaded", null);
+      },
+      onMapAnimationSuccess: () => {
+        y(), C.value = !0, i("on-animated"), window.SHJParseEvent(a.globalEvent, "on-animated", null);
+      },
+      onClickBar: (t) => {
+        i("on-bar-click", t), window.SHJParseEvent(a.globalEvent, "on-bar-click", t);
+      },
+      onClickScatter: (t) => {
+        i("on-scatter-click", t), window.SHJParseEvent(a.globalEvent, "on-scatter-click", t);
+      },
+      onClickFlyline: (t) => {
+        i("on-flyline-click", t), window.SHJParseEvent(a.globalEvent, "on-flyline-click", t);
+      }
+    }));
+    K(() => {
+      setTimeout(() => {
+        l.value = m(a.basicOption), r.push(a.basicOption.scene.defaultMapAdcode), ee(a, l, m, y, j);
+      }, 0);
+    }), Q(() => {
+      l.value && l.value.destroy();
+    });
+    const P = () => {
+      i("on-return", { adcode: r.present }), window.SHJParseEvent(a.globalEvent, "on-return", { adcode: r.present }), r.undo();
+      const e = v(a.basicOption);
+      e.scene.defaultMapAdcode = r.present, l.value = m(e), r.past.length <= 0 ? p.value = !1 : p.value = !0;
+    }, j = () => {
+      r.empty(), r.push(a.basicOption.scene.defaultMapAdcode), l.value = m(a.basicOption), r.past.length <= 0 ? p.value = !1 : p.value = !0;
+    }, D = (e, o, t) => {
+      z.timeline().add(z.to(l.value.camera.instance.position, {
+        duration: 2,
+        delay: 0,
+        x: e,
+        y: o,
+        z: t,
+        ease: "circ.out"
+      }));
+    };
+    $({
+      refresh: () => y(),
+      refreshView: () => y(),
+      refreshData: () => y(),
+      // 返回上一级
+      goBack: () => P(),
+      // 更新相机位置
+      setCameraPosition: (e, o, t) => D(e, o, t)
+    });
+    const U = Z(), F = g(), _ = (e) => {
+      if (F.value && e) {
+        L(a.basicOption.backButtonCss.fontFamily);
+        const o = `url(${e.backgroundImage})`;
+        return {
+          ...E(e),
+          left: a.basicOption.backButtonLeft + "%",
+          bottom: a.basicOption.backButtonBottom + "%",
+          "background-image": o
+        };
+      }
+      return {};
+    }, c = g(v(a.basicOption.widgets)), n = X(() => {
+      try {
+        const e = c.value.filter((o) => o.type === "regionalLevel");
+        return e.length > 0 ? (L(e[0].labelStyle.fontFamily), e[0].isHide ? null : e[0]) : null;
+      } catch {
+        return null;
+      }
+    });
+    b(() => v(a.basicOption.widgets), (e, o) => {
+      try {
+        !h(e, o) && l.value && (c.value = v(a.basicOption.widgets));
+      } catch {
+      }
+    }, {
+      deep: !0
+    }), b(() => v(c.value.filter((e) => e.type === "bar")), (e, o) => {
+      try {
+        !h(e, o) && l.value && e.length === o.length && e.forEach((t) => {
+          l.value.createBar(t, void 0, !1);
+        });
+      } catch {
+      }
+    }, {
+      deep: !0
+    }), b(() => v(c.value.filter((e) => e.type === "scatter")), (e, o) => {
+      try {
+        !h(e, o) && l.value && e.length === o.length && e.forEach((t) => {
+          l.value.createScatter(t, void 0, !1);
+        });
+      } catch {
+      }
+    }, {
+      deep: !0
+    }), b(() => v(c.value.filter((e) => e.type === "flyline")), (e, o) => {
+      try {
+        !h(e, o) && l.value && e.length === o.length && e.forEach((t) => {
+          l.value.createFlyLine(t, void 0, !1);
+        });
+      } catch {
+      }
+    }, {
+      deep: !0
+    }), b(() => v(c.value.filter((e) => e.type === "regionalLevel")), (e, o) => {
+      try {
+        !h(e, o) && l.value && e.length === o.length && e.forEach((t) => {
+          l.value.createRegionalLevel(t, void 0, !1);
+        });
+      } catch {
+      }
+    }, {
+      deep: !0
+    });
+    const q = (e) => {
+      try {
+        e.isHide === void 0 ? e.isHide = !0 : e.isHide = !e.isHide;
+      } catch {
+      }
+    }, G = () => {
+      try {
+        const e = c.value.every((o) => !o.isHide);
+        c.value.forEach((o) => o.isHide = e);
+      } catch {
+      }
+    }, J = (e) => {
+      L(a.basicOption.widgetControlStyle.fontFamily);
+      const o = `url(${e.backgroundImage})`, t = `url(${A(e.hover.backgroundImage)})`, s = `url(${A(e.active.backgroundImage)})`;
+      return {
+        ...E(e),
+        ...E(e.hover, "hover"),
+        ...E(e.active, "active"),
+        "background-image": o,
+        "--hover-background-image": t,
+        "--active-background-image": s
+      };
+    }, A = (e) => !e.startsWith("http") && !e.startsWith("//") ? "../" + e : e;
+    return (e, o) => (d(), u("div", {
+      id: "zerov-map3d-scene-wrap",
+      class: H(["map-3d-wrap", { show: O.value }])
+    }, [
+      C.value && p.value && e.basicOption.backButton ? (d(), u("div", {
+        key: 0,
+        ref_key: "buttonRef",
+        ref: F,
+        class: "return-btn",
+        style: f(_(e.basicOption.backButtonCss)),
+        onClick: P
+      }, " 返回上一级 ", 4)) : S("", !0),
+      n.value ? (d(), u("div", {
+        key: 1,
+        class: "regional-level",
+        style: f({
+          left: n.value.labelStyle.left + "%",
+          top: n.value.labelStyle.top + "%",
+          flexDirection: n.value.labelStyle.direction,
+          gap: n.value.labelStyle.gap + "px",
+          fontSize: n.value.labelStyle.fontSize + "px",
+          fontFamily: n.value.labelStyle.fontFamily,
+          fontStyle: n.value.labelStyle.fontStyle,
+          color: n.value.labelStyle.color,
+          "--color-width": n.value.labelStyle.colorStyle.width + "px",
+          "--color-height": n.value.labelStyle.colorStyle.height + "px",
+          "--color-borderRadius": n.value.labelStyle.colorStyle.borderRadius + "px"
+        })
+      }, [
+        (d(!0), u(W, null, M(n.value.rules, (t, s) => (d(), u("div", {
+          key: s,
+          class: "item"
+        }, [
+          B("div", {
+            class: "color",
+            style: f({ backgroundColor: t.color })
+          }, null, 4),
+          B("span", oe, k(t.label), 1)
+        ]))), 128))
+      ], 4)) : S("", !0),
+      e.basicOption.widgets.length > 0 && e.basicOption.widgetControlStyle && e.basicOption.widgetControlStyle.show ? (d(), u("div", {
+        key: 2,
+        class: "widget-control",
+        style: f({
+          left: e.basicOption.widgetControlStyle.left + "%",
+          top: e.basicOption.widgetControlStyle.top + "%",
+          flexDirection: e.basicOption.widgetControlStyle.direction,
+          gap: e.basicOption.widgetControlStyle.gap + "px",
+          "--widget-width": e.basicOption.widgetControlStyle.width + "px",
+          "--widget-height": e.basicOption.widgetControlStyle.height + "px"
+        })
+      }, [
+        B("div", {
+          class: H(["control-button", {
+            active: c.value.every((t) => !t.isHide)
+          }]),
+          style: f(J(e.basicOption.widgetControlStyle)),
+          onClick: G
+        }, k(c.value.every((t) => !t.isHide) ? "隐藏" : "显示") + "/全部 ", 7),
+        (d(!0), u(W, null, M(c.value, (t) => (d(), u("div", {
+          key: t.id,
+          class: H(["control-button", {
+            active: !t.isHide
+          }]),
+          style: f(J(e.basicOption.widgetControlStyle)),
+          onClick: (s) => q(t)
+        }, k(t.name || "-"), 15, ae))), 128))
+      ], 4)) : S("", !0),
+      e.basicOption.debugger ? (d(), u("div", le, " fps:" + k(Y(U)), 1)) : S("", !0)
+    ], 2));
+  }
+});
+export {
+  ke as default
+};

package/es/components/scene-map3d/map3d/map/DiffuseShader.d.ts

@@ -0,0 +1,28 @@
+export declare class DiffuseShader {
+    pointShader: any;
+    time: any;
+    options: {
+        size: number;
+        diffuseSpeed: number;
+        diffuseColor: number;
+        diffuseWidth: number;
+        diffuseDir: number;
+    } & {
+        material: any;
+        size: any;
+        diffuseColor: any;
+        diffuseSpeed: any;
+        diffuseWidth: any;
+        diffuseDir: any;
+    };
+    constructor({ material, time, size, diffuseColor, diffuseSpeed, diffuseWidth, diffuseDir }: {
+        material: any;
+        time: any;
+        size: any;
+        diffuseColor: any;
+        diffuseSpeed: any;
+        diffuseWidth: any;
+        diffuseDir: any;
+    });
+    init(): void;
+}

package/es/components/scene-map3d/map3d/map/DiffuseShader.mjs

@@ -0,0 +1,143 @@
+var s = Object.defineProperty;
+var d = (t, i, o) => i in t ? s(t, i, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[i] = o;
+var r = (t, i, o) => d(t, typeof i != "symbol" ? i + "" : i, o);
+import { Color as g } from "three";
+class c {
+  constructor({
+    material: i,
+    time: o,
+    size: a,
+    diffuseColor: n,
+    diffuseSpeed: f,
+    diffuseWidth: u,
+    diffuseDir: e
+  }) {
+    r(this, "pointShader");
+    r(this, "time");
+    r(this, "options");
+    this.time = o;
+    const l = {
+      size: 100,
+      // 尺寸
+      diffuseSpeed: 15,
+      // 扩散速度
+      diffuseColor: 9345950,
+      // 扩散颜色
+      diffuseWidth: 10,
+      // 扩散圆环宽度
+      diffuseDir: 1
+      // 1.0,2.0
+    };
+    this.options = Object.assign({}, l, {
+      material: i,
+      size: a,
+      diffuseColor: n,
+      diffuseSpeed: f,
+      diffuseWidth: u,
+      diffuseDir: e
+    }), this.init();
+  }
+  init() {
+    this.pointShader = null;
+    const {
+      material: i,
+      size: o,
+      diffuseColor: a,
+      diffuseSpeed: n,
+      diffuseWidth: f,
+      diffuseDir: u
+    } = this.options;
+    i.onBeforeCompile = (e) => {
+      this.pointShader = e, e.uniforms = {
+        ...e.uniforms,
+        uTime: {
+          value: 0
+        },
+        uSpeed: {
+          value: n
+        },
+        uWidth: {
+          value: f
+        },
+        uColor: {
+          value: new g(a)
+        },
+        uDir: {
+          value: u
+          // 1.0-xy,2.0-xz
+        }
+      }, e.vertexShader = e.vertexShader.replace(
+        "void main() {",
+        /* glsl */
+        `
+            varying vec3 vPosition;
+            void main(){
+              vPosition = position;
+          `
+      ), e.fragmentShader = e.fragmentShader.replace(
+        "void main() {",
+        /* glsl */
+        `
+            uniform float uTime;
+            uniform float uSpeed;
+            uniform float uWidth;
+            uniform vec3 uColor;
+            uniform float uDir;
+            varying vec3 vPosition;
+            
+            void main(){
+          `
+      ), e.fragmentShader = e.fragmentShader.replace(
+        "#include <opaque_fragment>",
+        /* glsl */
+        `
+            #ifdef OPAQUE
+            diffuseColor.a = 1.0;
+            #endif
+            
+            #ifdef USE_TRANSMISSION
+            diffuseColor.a *= material.transmissionAlpha;
+            #endif
+            
+            float r = uTime * uSpeed;
+            //光环宽度
+            float w = 0.0; 
+            if(w>uWidth){
+              w = uWidth;
+            }else{
+              w = uTime * 5.0;
+            }
+            //几何中心点
+            vec2 center = vec2(0.0, 0.0); 
+            // 距离圆心的距离
+
+            float rDistance = distance(vPosition.xz, center);
+            if(uDir==2.0){
+              rDistance = distance(vPosition.xy, center);
+            }
+            if(rDistance > r && rDistance < r + 2.0 * w) {
+              float per = 0.0;
+              if(rDistance < r + w) {
+                per = (rDistance - r) / w;
+                outgoingLight = mix(outgoingLight, uColor, per);
+                // 获取0->透明度的插值
+                float alphaV = mix(0.0,diffuseColor.a,per);
+                gl_FragColor = vec4(outgoingLight,  alphaV);
+              } else {
+                per = (rDistance - r - w) / w;
+                outgoingLight = mix(uColor, outgoingLight, per);
+                // 获取0->透明度的插值
+                float alphaV = mix(diffuseColor.a,0.0,per);
+                gl_FragColor = vec4(outgoingLight,  alphaV);
+              }
+            } else {
+              gl_FragColor = vec4(outgoingLight, 0.0);
+            }
+          `
+      );
+    };
+  }
+}
+export {
+  c as DiffuseShader
+};

package/es/components/scene-map3d/map3d/map/Reflector.d.ts

@@ -0,0 +1,10 @@
+import { Mesh, PerspectiveCamera, WebGLRenderTarget } from 'three';
+declare class Reflector extends Mesh {
+    isReflector: boolean;
+    camera: PerspectiveCamera;
+    static ReflectorShader: any;
+    getRenderTarget: () => WebGLRenderTarget;
+    dispose(): void;
+    constructor(geometry: any, options?: any);
+}
+export { Reflector };

package/es/components/scene-map3d/map3d/map/Reflector.mjs

@@ -0,0 +1,135 @@
+var I = Object.defineProperty;
+var N = (d, r, i) => r in d ? I(d, r, { enumerable: !0, configurable: !0, writable: !0, value: i }) : d[r] = i;
+var h = (d, r, i) => N(d, typeof r != "symbol" ? r + "" : r, i);
+import { Mesh as q, PerspectiveCamera as G, Color as C, Plane as L, Vector3 as p, Matrix4 as U, Vector4 as _, WebGLRenderTarget as X, HalfFloatType as J, ShaderMaterial as K, UniformsUtils as Q, NoToneMapping as Y } from "three";
+const R = class R extends q {
+  constructor(i, n = {}) {
+    super(i);
+    h(this, "isReflector");
+    h(this, "camera");
+    h(this, "getRenderTarget");
+    this.isReflector = !0, this.type = "Reflector", this.camera = new G();
+    const s = this, j = n.color !== void 0 ? new C(n.color) : new C(8355711), O = n.textureWidth || 512, D = n.textureHeight || 512, F = n.clipBias || 0, m = n.shader || R.ReflectorShader, V = n.multisample !== void 0 ? n.multisample : 4, c = new L(), l = new p(), u = new p(), W = new p(), f = new U(), M = new p(0, 0, -1), o = new _(), x = new p(), w = new p(), v = new _(), g = new U(), t = this.camera, y = new X(O, D, {
+      samples: V,
+      type: J
+    }), S = new K({
+      name: m.name !== void 0 ? m.name : "unspecified",
+      uniforms: Q.clone(m.uniforms),
+      fragmentShader: m.fragmentShader,
+      vertexShader: m.vertexShader
+    });
+    S.uniforms.tDiffuse.value = y.texture, S.uniforms.color.value = j, S.uniforms.textureMatrix.value = g, this.material = S, this.onBeforeRender = function(e, A, b) {
+      if (u.setFromMatrixPosition(s.matrixWorld), W.setFromMatrixPosition(b.matrixWorld), f.extractRotation(s.matrixWorld), l.set(0, 0, 1), l.applyMatrix4(f), x.subVectors(u, W), x.dot(l) > 0) return;
+      x.reflect(l).negate(), x.add(u), f.extractRotation(b.matrixWorld), M.set(0, 0, -1), M.applyMatrix4(f), M.add(W), w.subVectors(u, M), w.reflect(l).negate(), w.add(u), t.position.copy(x), t.up.set(0, 1, 0), t.up.applyMatrix4(f), t.up.reflect(l), t.lookAt(w), t.far = b.far, t.updateMatrixWorld(), t.projectionMatrix.copy(b.projectionMatrix), g.set(
+        0.5,
+        0,
+        0,
+        0.5,
+        0,
+        0.5,
+        0,
+        0.5,
+        0,
+        0,
+        0.5,
+        0.5,
+        0,
+        0,
+        0,
+        1
+      ), g.multiply(t.projectionMatrix), g.multiply(t.matrixWorldInverse), g.multiply(s.matrixWorld), c.setFromNormalAndCoplanarPoint(
+        l,
+        u
+      ), c.applyMatrix4(t.matrixWorldInverse), o.set(
+        c.normal.x,
+        c.normal.y,
+        c.normal.z,
+        c.constant
+      );
+      const a = t.projectionMatrix;
+      v.x = (Math.sign(o.x) + a.elements[8]) / a.elements[0], v.y = (Math.sign(o.y) + a.elements[9]) / a.elements[5], v.z = -1, v.w = (1 + a.elements[10]) / a.elements[14], o.multiplyScalar(2 / o.dot(v)), a.elements[2] = o.x, a.elements[6] = o.y, a.elements[10] = o.z + 1 - F, a.elements[14] = o.w, s.visible = !1;
+      const k = e.getRenderTarget(), z = e.xr.enabled, B = e.shadowMap.autoUpdate, H = e.outputColorSpace, E = e.toneMapping;
+      e.xr.enabled = !1, e.shadowMap.autoUpdate = !1, e.outputColorSpace = "srgb-linear", e.toneMapping = Y, e.setRenderTarget(y), e.state.buffers.depth.setMask(!0), e.autoClear === !1 && e.clear(), e.render(A, t), e.xr.enabled = z, e.shadowMap.autoUpdate = B, e.outputColorSpace = H, e.toneMapping = E, e.setRenderTarget(k);
+      const T = b.viewport;
+      T !== void 0 && e.state.viewport(T), s.visible = !0;
+    }, this.getRenderTarget = function() {
+      return y;
+    }, this.dispose = function() {
+      y.dispose(), s.material.dispose();
+    };
+  }
+  dispose() {
+    throw new Error("Method not implemented.");
+  }
+};
+h(R, "ReflectorShader");
+let P = R;
+P.ReflectorShader = {
+  name: "ReflectorShader",
+  uniforms: {
+    color: {
+      value: null
+    },
+    tDiffuse: {
+      value: null
+    },
+    textureMatrix: {
+      value: null
+    }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+		uniform mat4 textureMatrix;
+		varying vec4 vUv;
+
+		#include <common>
+		#include <logdepthbuf_pars_vertex>
+
+		void main() {
+
+			vUv = textureMatrix * vec4( position, 1.0 );
+
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+			#include <logdepthbuf_vertex>
+
+		}`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+		uniform vec3 color;
+		uniform sampler2D tDiffuse;
+		varying vec4 vUv;
+
+		#include <logdepthbuf_pars_fragment>
+
+		float blendOverlay( float base, float blend ) {
+
+			return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
+
+		}
+
+		vec3 blendOverlay( vec3 base, vec3 blend ) {
+
+			return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );
+
+		}
+
+		void main() {
+
+			#include <logdepthbuf_fragment>
+
+			vec4 base = texture2DProj( tDiffuse, vUv );
+			gl_FragColor = vec4( blendOverlay( base.rgb, color ),0.15 );
+
+			#include <tonemapping_fragment>
+			#include <colorspace_fragment>
+
+		}`
+  )
+};
+export {
+  P as Reflector
+};