@takram/three-geospatial-effects 0.0.1-alpha.7 → 0.0.1-alpha.9

package/build/shared.js

@@ -1,11 +1,8 @@
-var D = Object.defineProperty;
-var y = (r, e, t) => e in r ? D(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var u = (r, e, t) => y(r, typeof e != "symbol" ? e + "" : e, t);
-import { BlendFunction as f, Effect as h, EffectAttribute as p, RenderPass as M, Resolution as d, ShaderPass as g, MipmapBlurPass as P, KawaseBlurPass as A, KernelSize as z } from "postprocessing";
-import { Uniform as s, ShaderLib as c, HalfFloatType as m, ShaderMaterial as U, NoBlending as T, Vector2 as S, WebGLRenderTarget as w, Matrix4 as x } from "three";
-import { resolveIncludes as b } from "@takram/three-geospatial";
-import { turbo as F, depth as B, packing as C, transform as O } from "@takram/three-geospatial/shaders";
-const N = `#include "core/depth"
+import { BlendFunction as v, Effect as f, EffectAttribute as d, RenderPass as A, Resolution as h, ShaderPass as g, MipmapBlurPass as P, KawaseBlurPass as z, KernelSize as D } from "postprocessing";
+import { Uniform as s, ShaderLib as l, HalfFloatType as m, ShaderMaterial as U, NoBlending as S, Vector2 as T, WebGLRenderTarget as w, Matrix4 as x } from "three";
+import { define as p, resolveIncludes as b } from "@takram/three-geospatial";
+import { turbo as M, depth as B, packing as C, transform as F } from "@takram/three-geospatial/shaders";
+const O = `#include "core/depth"
 #include "core/turbo"
 
 uniform float near;
@@ -24,40 +21,40 @@ void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
 
   outputColor = vec4(color, inputColor.a);
 }
-`, L = {
-  blendFunction: f.SRC,
+`;
+var N = Object.defineProperty, L = (o, e, t, i) => {
+  for (var n = void 0, r = o.length - 1, a; r >= 0; r--)
+    (a = o[r]) && (n = a(e, t, n) || n);
+  return n && N(e, t, n), n;
+};
+const j = {
+  blendFunction: v.SRC,
   useTurbo: !1,
   near: 1,
   far: 1e3
 };
-class se extends h {
+class G extends f {
   constructor(e) {
-    const { blendFunction: t, useTurbo: n, near: o, far: i } = {
-      ...L,
+    const { blendFunction: t, useTurbo: i, near: n, far: r } = {
+      ...j,
       ...e
     };
     super(
       "DepthEffect",
-      b(N, {
-        core: { depth: B, turbo: F }
+      b(O, {
+        core: { depth: B, turbo: M }
       }),
       {
         blendFunction: t,
-        attributes: p.DEPTH,
+        attributes: d.DEPTH,
         uniforms: new Map(
           Object.entries({
-            near: new s(o),
-            far: new s(i)
+            near: new s(n),
+            far: new s(r)
           })
         )
       }
-    ), this.useTurbo = n;
-  }
-  get useTurbo() {
-    return this.defines.has("USE_TURBO");
-  }
-  set useTurbo(e) {
-    this.useTurbo !== e && (e ? this.defines.set("USE_TURBO", "1") : this.defines.delete("USE_TURBO"), this.setChanged());
+    ), this.useTurbo = i;
   }
   get near() {
     return this.uniforms.get("near").value;
@@ -72,30 +69,33 @@ class se extends h {
     this.uniforms.get("far").value = e;
   }
 }
-const G = `#define DITHERING
+L([
+  p("USE_TURBO")
+], G.prototype, "useTurbo");
+const H = `#define DITHERING
 
 #include <dithering_pars_fragment>
 
 void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
   outputColor = vec4(saturate(dithering(inputColor.rgb)), inputColor.a);
 }
-`, j = {
-  blendFunction: f.NORMAL
+`, $ = {
+  blendFunction: v.NORMAL
 };
-class ae extends h {
+class ue extends f {
   constructor(e) {
     const { blendFunction: t } = {
-      ...j,
+      ...$,
       ...e
     };
-    super("DitheringEffect", G, {
+    super("DitheringEffect", H, {
       blendFunction: t
     });
   }
 }
 const R = Symbol("SETUP");
-function H(r) {
-  const e = r.vertexShader.replace(
+function I(o) {
+  const e = o.vertexShader.replace(
     /* glsl */
     "#include <fog_pars_vertex>",
     /* glsl */
@@ -125,13 +125,13 @@ function H(r) {
         vViewPosition = - mvPosition.xyz;
       `
   );
-  r.vertexShader = /* glsl */
+  o.vertexShader = /* glsl */
   `
     #undef FLAT_SHADED
     varying vec3 vViewPosition;
     ${e}
   `;
-  const t = r.fragmentShader.replace(
+  const t = o.fragmentShader.replace(
     /#ifndef FLAT_SHADED\s+varying vec3 vNormal;\s+#endif/m,
     /* glsl */
     "#include <normal_pars_fragment>"
@@ -153,17 +153,17 @@ function H(r) {
         #include <normal_fragment_maps>
       `
   );
-  return r.fragmentShader = /* glsl */
+  return o.fragmentShader = /* glsl */
   `
     #undef FLAT_SHADED
     varying vec3 vViewPosition;
     ${t}
-  `, r;
+  `, o;
 }
-function v(r, { type: e } = {}) {
-  if (r[R] === !0)
-    return r;
-  e === "basic" && H(r);
+function c(o, { type: e } = {}) {
+  if (o[R] === !0)
+    return o;
+  e === "basic" && I(o);
   const t = e === "physical" ? (
     /* glsl */
     `
@@ -183,7 +183,7 @@ function v(r, { type: e } = {}) {
           );
         `
   );
-  return r.fragmentShader = /* glsl */
+  return o.fragmentShader = /* glsl */
   `
     layout(location = 1) out vec4 outputBuffer1;
 
@@ -192,7 +192,7 @@ function v(r, { type: e } = {}) {
     #endif // !defined(USE_ENVMAP)
 
     ${C}
-    ${r.fragmentShader.replace(
+    ${o.fragmentShader.replace(
     /}\s*$/m,
     // Assume the last curly brace is of main()
     /* glsl */
@@ -201,25 +201,23 @@ function v(r, { type: e } = {}) {
         }
       `
   )}
-  `, r[R] = !0, r;
+  `, o[R] = !0, o;
 }
-function I() {
-  v(c.lambert), v(c.phong), v(c.basic, { type: "basic" }), v(c.standard, { type: "physical" }), v(c.physical, { type: "physical" });
+function V() {
+  c(l.lambert), c(l.phong), c(l.basic, { type: "basic" }), c(l.standard, { type: "physical" }), c(l.physical, { type: "physical" });
 }
-class ue extends M {
-  constructor(t, n, o, i) {
-    super(n, o, i);
-    u(this, "geometryTexture");
-    this.geometryTexture = t.texture.clone(), this.geometryTexture.isRenderTargetTexture = !0, this.geometryTexture.type = m, I();
+class le extends A {
+  constructor(e, t, i, n) {
+    super(t, i, n), this.geometryTexture = e.texture.clone(), this.geometryTexture.isRenderTargetTexture = !0, this.geometryTexture.type = m, V();
   }
-  render(t, n, o, i, a) {
-    n != null && (n.textures[1] = this.geometryTexture), super.render(t, n, null), n != null && (n.textures.length = 1);
+  render(e, t, i, n, r) {
+    t != null && (t.textures[1] = this.geometryTexture), super.render(e, t, null), t != null && (t.textures.length = 1);
   }
-  setSize(t, n) {
-    this.geometryTexture.image.width = t, this.geometryTexture.image.height = n;
+  setSize(e, t) {
+    this.geometryTexture.image.width = e, this.geometryTexture.image.height = t;
   }
 }
-const V = `#include <common>
+const k = `#include <common>
 
 uniform sampler2D inputBuffer;
 
@@ -297,7 +295,7 @@ void main() {
   float scale = saturate(smoothstep(thresholdLevel, thresholdLevel + thresholdRange, l));
   gl_FragColor = vec4(color * scale, 1.0);
 }
-`, k = `uniform vec2 texelSize;
+`, W = `uniform vec2 texelSize;
 
 out vec2 vCenterUv1;
 out vec2 vCenterUv2;
@@ -331,36 +329,36 @@ void main() {
 
   gl_Position = vec4(position.xy, 1.0, 1.0);
 }
-`, $ = {
+`, K = {
   thresholdLevel: 10,
   thresholdRange: 1
 };
-class W extends U {
+class Z extends U {
   constructor(e) {
     const {
       inputBuffer: t = null,
-      thresholdLevel: n,
-      thresholdRange: o,
-      ...i
+      thresholdLevel: i,
+      thresholdRange: n,
+      ...r
     } = {
-      ...$,
+      ...K,
       ...e
     };
     super({
       name: "DownsampleThresholdMaterial",
-      fragmentShader: V,
-      vertexShader: k,
-      blending: T,
+      fragmentShader: k,
+      vertexShader: W,
+      blending: S,
       toneMapped: !1,
       depthWrite: !1,
       depthTest: !1,
-      ...i,
+      ...r,
       uniforms: {
         inputBuffer: new s(t),
-        texelSize: new s(new S()),
-        thresholdLevel: new s(n),
-        thresholdRange: new s(o),
-        ...i.uniforms
+        texelSize: new s(new T()),
+        thresholdLevel: new s(i),
+        thresholdRange: new s(n),
+        ...r.uniforms
       }
     });
   }
@@ -386,7 +384,7 @@ class W extends U {
     this.uniforms.thresholdRange.value = e;
   }
 }
-const K = `#include <common>
+const Q = `#include <common>
 
 #define SQRT_2 (0.7071067811865476)
 
@@ -459,7 +457,7 @@ void main() {
   gl_FragColor += sampleHalos(haloAmount);
 }
 
-`, Z = `uniform vec2 texelSize;
+`, X = `uniform vec2 texelSize;
 
 out vec2 vUv;
 out vec2 vAspectRatio;
@@ -469,37 +467,37 @@ void main() {
   vAspectRatio = vec2(texelSize.x / texelSize.y, 1.0);
   gl_Position = vec4(position.xy, 1.0, 1.0);
 }
-`, Q = {
+`, Y = {
   ghostAmount: 1e-3,
   haloAmount: 1e-3,
   chromaticAberration: 10
 };
-class X extends U {
+class q extends U {
   constructor(e) {
     const {
       inputBuffer: t = null,
-      ghostAmount: n,
-      haloAmount: o,
-      chromaticAberration: i,
+      ghostAmount: i,
+      haloAmount: n,
+      chromaticAberration: r,
       ...a
     } = {
-      ...Q,
+      ...Y,
       ...e
     };
     super({
       name: "LensFlareFeaturesMaterial",
-      fragmentShader: K,
-      vertexShader: Z,
-      blending: T,
+      fragmentShader: Q,
+      vertexShader: X,
+      blending: S,
       toneMapped: !1,
       depthWrite: !1,
       depthTest: !1,
       uniforms: {
         inputBuffer: new s(t),
-        texelSize: new s(new S()),
-        ghostAmount: new s(n),
-        haloAmount: new s(o),
-        chromaticAberration: new s(i),
+        texelSize: new s(new T()),
+        ghostAmount: new s(i),
+        haloAmount: new s(n),
+        chromaticAberration: new s(r),
         ...a.uniforms
       }
     });
@@ -532,7 +530,7 @@ class X extends U {
     this.uniforms.chromaticAberration.value = e;
   }
 }
-const Y = `uniform sampler2D bloomBuffer;
+const J = `uniform sampler2D bloomBuffer;
 uniform sampler2D featuresBuffer;
 uniform float intensity;
 
@@ -541,30 +539,30 @@ void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
   vec3 features = texture(featuresBuffer, uv).rgb;
   outputColor = vec4(inputColor.rgb + (bloom + features) * intensity, inputColor.a);
 }
-`, q = {
-  blendFunction: f.NORMAL,
+`, ee = {
+  blendFunction: v.NORMAL,
   resolutionScale: 0.5,
-  width: d.AUTO_SIZE,
-  height: d.AUTO_SIZE,
+  width: h.AUTO_SIZE,
+  height: h.AUTO_SIZE,
   intensity: 5e-3
 };
-class le extends h {
-  constructor(t) {
+class ce extends f {
+  constructor(e) {
     const {
-      blendFunction: n,
-      resolutionScale: o,
-      width: i,
-      height: a,
-      resolutionX: l = i,
-      resolutionY: E = a,
-      intensity: _
+      blendFunction: t,
+      resolutionScale: i,
+      width: n,
+      height: r,
+      resolutionX: a = n,
+      resolutionY: u = r,
+      intensity: E
     } = {
-      ...q,
-      ...t
+      ...ee,
+      ...e
     };
-    super("LensFlareEffect", Y, {
-      blendFunction: n,
-      attributes: p.CONVOLUTION,
+    super("LensFlareEffect", J, {
+      blendFunction: t,
+      attributes: d.CONVOLUTION,
       uniforms: new Map(
         Object.entries({
           bloomBuffer: new s(null),
@@ -572,20 +570,9 @@ class le extends h {
           intensity: new s(1)
         })
       )
-    });
-    u(this, "resolution");
-    u(this, "renderTarget1");
-    u(this, "renderTarget2");
-    u(this, "thresholdMaterial");
-    u(this, "thresholdPass");
-    u(this, "blurPass");
-    u(this, "preBlurPass");
-    u(this, "featuresMaterial");
-    u(this, "featuresPass");
-    u(this, "onResolutionChange", () => {
+    }), this.onResolutionChange = () => {
       this.setSize(this.resolution.baseWidth, this.resolution.baseHeight);
-    });
-    this.renderTarget1 = new w(1, 1, {
+    }, this.renderTarget1 = new w(1, 1, {
       depthBuffer: !1,
       stencilBuffer: !1,
       type: m
@@ -593,47 +580,47 @@ class le extends h {
       depthBuffer: !1,
       stencilBuffer: !1,
       type: m
-    }), this.renderTarget2.texture.name = "LensFlare.Target2", this.thresholdMaterial = new W(), this.thresholdPass = new g(this.thresholdMaterial), this.blurPass = new P(), this.blurPass.levels = 8, this.preBlurPass = new A({
-      kernelSize: z.SMALL
-    }), this.featuresMaterial = new X(), this.featuresPass = new g(this.featuresMaterial), this.uniforms.get("bloomBuffer").value = this.blurPass.texture, this.uniforms.get("featuresBuffer").value = this.renderTarget1.texture, this.resolution = new d(
+    }), this.renderTarget2.texture.name = "LensFlare.Target2", this.thresholdMaterial = new Z(), this.thresholdPass = new g(this.thresholdMaterial), this.blurPass = new P(), this.blurPass.levels = 8, this.preBlurPass = new z({
+      kernelSize: D.SMALL
+    }), this.featuresMaterial = new q(), this.featuresPass = new g(this.featuresMaterial), this.uniforms.get("bloomBuffer").value = this.blurPass.texture, this.uniforms.get("featuresBuffer").value = this.renderTarget1.texture, this.resolution = new h(
       this,
-      l,
-      E,
-      o
-    ), this.resolution.addEventListener("change", this.onResolutionChange), this.intensity = _;
+      a,
+      u,
+      i
+    ), this.resolution.addEventListener("change", this.onResolutionChange), this.intensity = E;
   }
-  initialize(t, n, o) {
-    this.thresholdPass.initialize(t, n, o), this.blurPass.initialize(t, n, o), this.preBlurPass.initialize(t, n, o), this.featuresPass.initialize(t, n, o);
+  initialize(e, t, i) {
+    this.thresholdPass.initialize(e, t, i), this.blurPass.initialize(e, t, i), this.preBlurPass.initialize(e, t, i), this.featuresPass.initialize(e, t, i);
   }
-  update(t, n, o) {
-    this.thresholdPass.render(t, n, this.renderTarget1), this.blurPass.render(t, this.renderTarget1, null), this.preBlurPass.render(t, this.renderTarget1, this.renderTarget2), this.featuresPass.render(t, this.renderTarget2, this.renderTarget1);
+  update(e, t, i) {
+    this.thresholdPass.render(e, t, this.renderTarget1), this.blurPass.render(e, this.renderTarget1, null), this.preBlurPass.render(e, this.renderTarget1, this.renderTarget2), this.featuresPass.render(e, this.renderTarget2, this.renderTarget1);
   }
-  setSize(t, n) {
-    const o = this.resolution;
-    o.setBaseSize(t, n);
-    const { width: i, height: a } = o;
-    this.renderTarget1.setSize(i, a), this.renderTarget2.setSize(i, a), this.thresholdMaterial.setSize(i, a), this.blurPass.setSize(i, a), this.preBlurPass.setSize(i, a), this.featuresMaterial.setSize(i, a);
+  setSize(e, t) {
+    const i = this.resolution;
+    i.setBaseSize(e, t);
+    const { width: n, height: r } = i;
+    this.renderTarget1.setSize(n, r), this.renderTarget2.setSize(n, r), this.thresholdMaterial.setSize(n, r), this.blurPass.setSize(n, r), this.preBlurPass.setSize(n, r), this.featuresMaterial.setSize(n, r);
   }
   get intensity() {
     return this.uniforms.get("intensity").value;
   }
-  set intensity(t) {
-    this.uniforms.get("intensity").value = t;
+  set intensity(e) {
+    this.uniforms.get("intensity").value = e;
   }
   get thresholdLevel() {
     return this.thresholdMaterial.thresholdLevel;
   }
-  set thresholdLevel(t) {
-    this.thresholdMaterial.thresholdLevel = t;
+  set thresholdLevel(e) {
+    this.thresholdMaterial.thresholdLevel = e;
   }
   get thresholdRange() {
     return this.thresholdMaterial.thresholdRange;
   }
-  set thresholdRange(t) {
-    this.thresholdMaterial.thresholdRange = t;
+  set thresholdRange(e) {
+    this.thresholdMaterial.thresholdRange = e;
   }
 }
-const J = `#include "core/depth"
+const te = `#include "core/depth"
 #include "core/packing"
 #include "core/transform"
 
@@ -674,43 +661,49 @@ void mainImage(const vec4 inputColor, const vec2 uv, out vec4 outputColor) {
 
   outputColor = vec4(normal * 0.5 + 0.5, inputColor.a);
 }
-`, ee = {
-  blendFunction: f.SRC,
+`;
+var ne = Object.defineProperty, _ = (o, e, t, i) => {
+  for (var n = void 0, r = o.length - 1, a; r >= 0; r--)
+    (a = o[r]) && (n = a(e, t, n) || n);
+  return n && ne(e, t, n), n;
+};
+const re = {
+  blendFunction: v.SRC,
   octEncoded: !1,
   reconstructFromDepth: !1
 };
-class ce extends h {
+class y extends f {
   constructor(e, t) {
     const {
-      blendFunction: n,
-      normalBuffer: o = null,
-      octEncoded: i,
+      blendFunction: i,
+      normalBuffer: n = null,
+      octEncoded: r,
       reconstructFromDepth: a
     } = {
-      ...ee,
+      ...re,
       ...t
     };
     super(
       "NormalEffect",
-      b(J, {
+      b(te, {
         core: {
           depth: B,
           packing: C,
-          transform: O
+          transform: F
         }
       }),
       {
-        blendFunction: n,
-        attributes: p.DEPTH,
+        blendFunction: i,
+        attributes: d.DEPTH,
         uniforms: new Map(
           Object.entries({
-            normalBuffer: new s(o),
+            normalBuffer: new s(n),
             projectionMatrix: new s(new x()),
             inverseProjectionMatrix: new s(new x())
           })
         )
       }
-    ), this.camera = e, e != null && (this.mainCamera = e), this.octEncoded = i, this.reconstructFromDepth = a;
+    ), this.camera = e, e != null && (this.mainCamera = e), this.octEncoded = r, this.reconstructFromDepth = a;
   }
   get mainCamera() {
     return this.camera;
@@ -718,9 +711,9 @@ class ce extends h {
   set mainCamera(e) {
     this.camera = e;
   }
-  update(e, t, n) {
-    const o = this.uniforms, i = o.get("projectionMatrix"), a = o.get("inverseProjectionMatrix"), l = this.camera;
-    l != null && (i.value.copy(l.projectionMatrix), a.value.copy(l.projectionMatrixInverse));
+  update(e, t, i) {
+    const n = this.uniforms, r = n.get("projectionMatrix"), a = n.get("inverseProjectionMatrix"), u = this.camera;
+    u != null && (r.value.copy(u.projectionMatrix), a.value.copy(u.projectionMatrixInverse));
   }
   get normalBuffer() {
     return this.uniforms.get("normalBuffer").value;
@@ -728,29 +721,23 @@ class ce extends h {
   set normalBuffer(e) {
     this.uniforms.get("normalBuffer").value = e;
   }
-  get octEncoded() {
-    return this.defines.has("OCT_ENCODED");
-  }
-  set octEncoded(e) {
-    e !== this.octEncoded && (e ? this.defines.set("OCT_ENCODED", "1") : this.defines.delete("OCT_ENCODED"), this.setChanged());
-  }
-  get reconstructFromDepth() {
-    return this.defines.has("RECONSTRUCT_FROM_DEPTH");
-  }
-  set reconstructFromDepth(e) {
-    e !== this.reconstructFromDepth && (e ? this.defines.set("RECONSTRUCT_FROM_DEPTH", "1") : this.defines.delete("RECONSTRUCT_FROM_DEPTH"), this.setChanged());
-  }
 }
+_([
+  p("OCT_ENCODED")
+], y.prototype, "octEncoded");
+_([
+  p("RECONSTRUCT_FROM_DEPTH")
+], y.prototype, "reconstructFromDepth");
 export {
-  se as D,
-  ue as G,
-  le as L,
-  ce as N,
-  j as a,
-  ae as b,
-  L as d,
-  q as l,
-  ee as n,
-  I as s
+  G as D,
+  le as G,
+  ce as L,
+  y as N,
+  $ as a,
+  ue as b,
+  j as d,
+  ee as l,
+  re as n,
+  V as s
 };
 //# sourceMappingURL=shared.js.map