@equinor/videx-3d 1.1.1 → 2.0.0

package/dist/chunk-ChG5d4HC.js

@@ -0,0 +1,675 @@
+import R from "proj4";
+import { UniformsGroup as I, Uniform as p, Vector4 as k, Vector3 as H, Vector2 as P, DataTexture as B, RedIntegerFormat as G, UnsignedShortType as N, Material as L, ShaderMaterial as y, CustomBlending as W, NoBlending as Z, AddEquation as _, SrcAlphaFactor as Q, OneMinusSrcAlphaFactor as w, OneFactor as S, MinEquation as O, UniformsUtils as q, ShaderLib as $ } from "three";
+function cn(n, e, t) {
+  const o = /* @__PURE__ */ new Map(), r = {};
+  e.sort((i, c) => i.id === t ? -1 : c.id === t ? 1 : i.drilled && c.drilled ? c.drilled.getTime() - i.drilled.getTime() : i.name.localeCompare(c.name));
+  for (let i = 0; i < e.length; i++) {
+    const c = e[i];
+    if (!c) continue;
+    let l = c.parent && c.kickoffDepthMsl !== null ? c.kickoffDepthMsl : -c.depthReferenceElevation;
+    if (o.has(c.id))
+      l = o.get(c.id);
+    else {
+      let g = c.parent;
+      for (; g; ) {
+        const u = n[g];
+        if (!u) break;
+        if (o.has(u.id)) {
+          const s = o.get(u.id);
+          l >= s && (o.set(u.id, l), l = s);
+          break;
+        } else
+          o.set(u.id, l), l = u.parent && u.kickoffDepthMsl !== null ? u.kickoffDepthMsl : -u.depthReferenceElevation;
+        g = u.parent;
+      }
+    }
+    r[c.id] = [l, i], o.set(c.id, c.depthMdMsl);
+  }
+  return r;
+}
+const j = "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs";
+class ln {
+  utmDef;
+  originWgs84;
+  originUtm;
+  _projection;
+  constructor(e, t, o = "lnglat") {
+    this.utmDef = e, this._projection = R(j, e), o === "lnglat" ? (this.originWgs84 = t, this.originUtm = this.wgs84ToUtm(t)) : (this.originWgs84 = this.utmToWgs84(t), this.originUtm = t);
+  }
+  utmToWgs84(e) {
+    return this._projection.inverse(e);
+  }
+  wgs84ToUtm(e) {
+    return this._projection.forward(e);
+  }
+  utmToWorld(e, t, o) {
+    return {
+      x: e - this.originUtm[0],
+      y: o,
+      z: this.originUtm[1] - t
+    };
+  }
+  worldToUtm(e, t, o) {
+    return {
+      easting: e + this.originUtm[0],
+      altitude: t,
+      northing: this.originUtm[1] - o
+    };
+  }
+  wgs84ToWorld(e, t, o = 0) {
+    const r = this.wgs84ToUtm([e, t]);
+    return this.utmToWorld(r[0], r[1], o);
+  }
+  worldToWgs84(e, t, o) {
+    const r = this.worldToUtm(e, t, o), i = this.utmToWgs84([r.easting, r.northing]);
+    return {
+      lng: i[0],
+      lat: i[1],
+      alt: t
+    };
+  }
+}
+function fn(n) {
+  const [, e, t] = new RegExp(/^([0-9]{2})([N|S]?)$/).exec(n) || [];
+  return `+proj=utm +zone=${e}${t === "S" ? " +south" : ""} +ellps=intl +towgs84=-87,-98,-121,0,0,0,0 +units=m +no_defs`;
+}
+function un([n, e]) {
+  if (e > 55 && e < 64 && n > 2 && n < 6)
+    return "32N";
+  if (e > 71 && n >= 6 && n < 9)
+    return "31N";
+  if (e > 71 && (n >= 9 && n < 12 || n >= 18 && n < 21))
+    return "33N";
+  if (e > 71 && (n >= 21 && n < 24 || n >= 30 && n < 33))
+    return "35N";
+  if (n >= -180 && n <= 180) {
+    const t = Math.floor((n + 180) / 6) % 60 + 1;
+    return e < 0 ? `${t}S` : `${t}N`;
+  }
+  throw new Error(
+    `getUtmZoneFromLatLng: Cannot figure out UTM zone from give Lat: ${e}, Lng: ${n}`
+  );
+}
+function an(n) {
+  const e = new Map(
+    n.chars.map((s, f) => [s.id, { index: f, spacing: s.xadvance }])
+  ), t = 32, o = (s) => {
+    const f = [];
+    let a = 0;
+    for (let m = 0; m < s.length; m++) {
+      let h = s.charCodeAt(m);
+      e.has(h) || (h = t);
+      const d = e.get(h);
+      d && (f.push(d.index), a += d.spacing);
+    }
+    return {
+      indices: f,
+      width: a
+    };
+  }, r = (s) => {
+    s = Array.isArray(s) ? s : [s];
+    const f = [], a = [];
+    for (let d = 0; d < s.length; d++) {
+      const V = s[d], x = o(V), z = a.length;
+      a.push(...x.indices), f.push([z, a.length, x.width]);
+    }
+    a.length || a.push(0);
+    const m = a.length;
+    f.forEach((d) => a.push(...d));
+    const h = new B(
+      new Uint16Array(a),
+      a.length,
+      1,
+      G,
+      N
+    );
+    return h.needsUpdate = !0, { texture: h, textPointersOffset: m, textPointersCount: f.length };
+  }, i = new I();
+  i.setName("GlyphData");
+  const c = [], l = [];
+  n.chars.forEach((s) => {
+    c.push(
+      new p(new k(s.x, s.y, s.width, s.height))
+    ), l.push(
+      new p(new H(s.xoffset, s.yoffset, s.xadvance))
+    );
+  }), i.add(c), i.add(l), i.add(
+    new p(new P(n.common.scaleW, n.common.scaleH))
+  ), i.add(new p(n.info.size)), i.add(new p(n.distanceField.distanceRange)), i.add(new p(n.common.lineHeight)), i.add(new p(n.common.base));
+  const g = () => {
+    i.dispose();
+  };
+  return {
+    glyphsCount: n.chars.length,
+    glyphData: i,
+    encodeText: o,
+    encodeTextTexture: r,
+    dispose: g
+  };
+}
+function dn(n, e, t) {
+  if (n.length === 0) return [];
+  n.sort((i, c) => e(i) - e(c));
+  const o = [];
+  let r = { start: e(n[0]), end: t(n[0]) };
+  for (let i = 1; i < n.length; i += 1)
+    e(n[i]) === r.end ? r.end = t(n[i]) : (o.push(r), r = { start: e(n[i]), end: t(n[i]) });
+  return o.push(r), o;
+}
+var J = `#ifdef USE_OIT
+
+uniform float oitDepthFar;          
+uniform vec2 oitScreenSize;         
+uniform sampler2D oitMinDepthTexture; 
+uniform int oitSkipFront;           
+uniform float oitOcclusionThreshold; 
+
+vec4 oitProcess(vec4 color) {
+  #ifdef OIT_OCCLUSION_PASS
+  
+  
+  
+  
+  
+  if(color.a < oitOcclusionThreshold)
+    discard;
+  return color;
+  #endif
+
+  
+  
+  float linZ = abs(vViewPosition.z) / oitDepthFar;
+
+  #ifdef OIT_DEPTH_PASS
+
+  
+  return vec4(linZ, 0.0, 0.0, 1.0);
+
+  #else
+
+  
+  
+  
+  vec2 uv = gl_FragCoord.xy / oitScreenSize;
+  float minZ = texture2D(oitMinDepthTexture, uv).r;
+  
+  
+  
+  
+  
+  
+  float tol = minZ * 1e-3 + 1e-6;
+  bool isFront = (linZ - minZ) <= tol;
+
+  #ifdef OIT_FRONT_PASS
+
+  
+  if(!isFront)
+    discard;
+  return color;
+
+  #else
+
+  
+  
+  if(isFront && oitSkipFront == 0)
+    discard;
+
+  float alpha = color.a;
+
+  
+  
+  
+  
+  
+  float b = -log(1.0 - clamp(alpha, 0.0, 0.9999));
+  return vec4(color.rgb * b, b);
+
+  #endif 
+  #endif 
+}
+
+#endif`;
+const pn = [
+  "color",
+  "emissive",
+  "emissiveIntensity",
+  "metalness",
+  "roughness"
+];
+function hn(n) {
+  return !!n && typeof n.getOitVariants == "function" && typeof n.getOitUniforms == "function";
+}
+function b(n) {
+  return n.isShaderMaterial === !0;
+}
+function D(n) {
+  return typeof n == "object" && n !== null && typeof n.copy == "function";
+}
+function M() {
+  return {
+    oitDepthFar: new p(1),
+    oitScreenSize: new p(new P(1, 1)),
+    oitMinDepthTexture: new p(null),
+    oitSkipFront: new p(0),
+    oitOcclusionThreshold: new p(1)
+  };
+}
+const Y = {
+  depthMin: "OIT_DEPTH_PASS",
+  accum: null,
+  front: "OIT_FRONT_PASS",
+  occlusion: "OIT_OCCLUSION_PASS"
+};
+function K(n, e, t) {
+  switch (n.transparent = !0, n.depthTest = !0, n.depthWrite = !1, n.blending = W, n.toneMapped = !1, t !== void 0 && (n.side = t), e) {
+    case "depthMin":
+      n.blendEquation = O, n.blendSrc = S, n.blendDst = S, n.blendEquationAlpha = O, n.blendSrcAlpha = S, n.blendDstAlpha = S;
+      break;
+    case "accum":
+      n.blendEquation = _, n.blendSrc = S, n.blendDst = S, n.blendEquationAlpha = _, n.blendSrcAlpha = S, n.blendDstAlpha = S;
+      break;
+    case "front":
+      n.blendEquation = _, n.blendSrc = Q, n.blendDst = w, n.blendEquationAlpha = _, n.blendSrcAlpha = S, n.blendDstAlpha = w;
+      break;
+    case "occlusion":
+      n.transparent = !1, n.depthWrite = !0, n.colorWrite = !1, n.blending = Z;
+      break;
+  }
+}
+function C(n) {
+  const e = n;
+  return [
+    JSON.stringify(e.defines ?? {}),
+    e.wireframe ? 1 : 0,
+    e.flatShading ? 1 : 0,
+    e.uniformsGroups ? e.uniformsGroups.length : 0,
+    n.vertexColors ? 1 : 0
+  ].join("|");
+}
+function A(n, e, t) {
+  const o = e, r = n, i = {
+    ...o.defines ?? {},
+    USE_OIT: ""
+  }, c = Y[t];
+  c && (i[c] = ""), r.defines = i, "wireframe" in o && (r.wireframe = o.wireframe), "flatShading" in o && (r.flatShading = o.flatShading), o.uniformsGroups && (r.uniformsGroups = o.uniformsGroups), n.vertexColors = e.vertexColors, n.needsUpdate = !0;
+}
+function v(n, e, t) {
+  let o;
+  if (b(n)) {
+    const r = new y();
+    r.copy(n), r.uniforms = n.uniforms, o = r;
+  } else
+    o = n.clone();
+  if (t?.shareUniforms) {
+    const r = n, i = o;
+    for (const c of t.shareUniforms)
+      i[c] = r[c];
+  }
+  return o.onBeforeCompile = n.onBeforeCompile, o.customProgramCacheKey = n.customProgramCacheKey, K(o, e, t?.side), A(o, n, e), o;
+}
+const T = ["depthMin", "accum", "front", "occlusion"];
+function U(n, e, t) {
+  const o = n;
+  let r = null, i = "";
+  const c = !b(n), l = n, g = c && t?.syncProperties ? t.syncProperties.filter((s) => s !== "opacity" && s in l) : [];
+  o.getOitUniforms = () => e, o.getOitVariants = () => {
+    if (!r)
+      r = {
+        depthMin: v(n, "depthMin", t),
+        accum: v(n, "accum", t),
+        front: v(n, "front", t),
+        occlusion: v(n, "occlusion", t)
+      }, i = C(n);
+    else {
+      const s = C(n);
+      if (s !== i) {
+        i = s;
+        for (const f of T)
+          A(r[f], n, f);
+      }
+    }
+    if (c)
+      for (const s of T) {
+        const f = r[s];
+        if (f.opacity = n.opacity, g.length) {
+          const a = f;
+          for (const m of g) {
+            const h = l[m], d = a[m];
+            D(d) && D(h) && d.constructor === h.constructor ? d.copy(h) : a[m] = h;
+          }
+        }
+      }
+    return r;
+  };
+  const u = n.dispose.bind(n);
+  return n.dispose = () => {
+    if (r) {
+      for (const s of T)
+        L.prototype.dispose.call(r[s]);
+      r = null;
+    }
+    u();
+  }, o;
+}
+function X(n, e) {
+  const t = M(), o = n.uniforms;
+  o.oitDepthFar ??= t.oitDepthFar, o.oitScreenSize ??= t.oitScreenSize, o.oitMinDepthTexture ??= t.oitMinDepthTexture, o.oitSkipFront ??= t.oitSkipFront, o.oitOcclusionThreshold ??= t.oitOcclusionThreshold;
+  const r = {
+    oitDepthFar: o.oitDepthFar,
+    oitScreenSize: o.oitScreenSize,
+    oitMinDepthTexture: o.oitMinDepthTexture,
+    oitSkipFront: o.oitSkipFront,
+    oitOcclusionThreshold: o.oitOcclusionThreshold
+  };
+  return U(n, r, e);
+}
+const E = /\bvoid\s+main\s*\(\s*\)\s*\{/;
+function nn(n) {
+  return /\bvViewPosition\b/.test(n);
+}
+function en(n) {
+  const e = E.exec(n);
+  if (!e) return null;
+  const t = e.index + e[0].length;
+  let o = 1;
+  for (let r = t; r < n.length; r++) {
+    const i = n[r];
+    if (i === "{") o++;
+    else if (i === "}" && (o--, o === 0))
+      return { open: t, close: r };
+  }
+  return null;
+}
+function F(n, e, t) {
+  const o = E.exec(n);
+  if (!o) return n;
+  const r = n.slice(0, o.index) + e + n.slice(o.index), i = en(r);
+  return i ? r.slice(0, i.close) + t + r.slice(i.close) : r;
+}
+function gn(n, e) {
+  const t = M(), o = b(n) ? n : null;
+  if (o) {
+    const i = o.uniforms;
+    i.oitDepthFar ??= t.oitDepthFar, i.oitScreenSize ??= t.oitScreenSize, i.oitMinDepthTexture ??= t.oitMinDepthTexture, i.oitSkipFront ??= t.oitSkipFront, i.oitOcclusionThreshold ??= t.oitOcclusionThreshold;
+  }
+  const r = n.onBeforeCompile;
+  return n.onBeforeCompile = function(i, c) {
+    r?.call(this, i, c), i.uniforms.oitDepthFar = t.oitDepthFar, i.uniforms.oitScreenSize = t.oitScreenSize, i.uniforms.oitMinDepthTexture = t.oitMinDepthTexture, i.uniforms.oitSkipFront = t.oitSkipFront, i.uniforms.oitOcclusionThreshold = t.oitOcclusionThreshold;
+    const l = !nn(i.fragmentShader), g = (l ? `#ifdef USE_OIT
+varying vec3 vViewPosition;
+#endif
+` : "") + `#ifdef USE_OIT
+` + J + `
+#endif
+`, u = `
+#ifdef USE_OIT
+  gl_FragColor = oitProcess(gl_FragColor);
+#endif
+`;
+    if (i.fragmentShader = F(
+      i.fragmentShader,
+      g,
+      u
+    ), l) {
+      const s = `#ifdef USE_OIT
+varying vec3 vViewPosition;
+#endif
+`, f = `
+#ifdef USE_OIT
+  vViewPosition = -(modelViewMatrix * vec4(position, 1.0)).xyz;
+#endif
+`;
+      i.vertexShader = F(
+        i.vertexShader,
+        s,
+        f
+      );
+    }
+  }, n.needsUpdate = !0, U(n, t, e);
+}
+var on = `#define TRAJECTORY_MATERIAL
+
+uniform vec3 diffuse;
+uniform float opacity;
+
+#ifndef FLAT_SHADED
+varying vec3 vNormal;
+#endif
+varying vec3 vViewPosition;
+#include <common>
+#include <color_pars_fragment>
+#include <uv_pars_fragment>
+#include <map_pars_fragment>
+#include <fog_pars_fragment>
+#include <logdepthbuf_pars_fragment>
+#include <clipping_planes_pars_fragment>
+
+vec3 hue2rgb(in float H) {
+  float R = abs(H * 6. - 3.) - 1.;
+  float G = 2. - abs(H * 6. - 2.);
+  float B = 2. - abs(H * 6. - 4.);
+  return saturate(vec3(R, G, B));
+}
+
+vec3 hsl2rgb(in vec3 HSL) {
+  vec3 RGB = hue2rgb(HSL.x);
+  float C = (1. - abs(2. * HSL.z - 1.)) * HSL.y;
+  return (RGB - 0.5) * C + HSL.z;
+}
+
+vec3 rgb2hsv(in vec3 RGB) {
+  
+  vec4 P = (RGB.g < RGB.b) ? vec4(RGB.bg, -1.0, 2.0 / 3.0) : vec4(RGB.gb, 0.0, -1.0 / 3.0);
+  vec4 Q = (RGB.r < P.x) ? vec4(P.xyw, RGB.r) : vec4(RGB.r, P.yzx);
+  float C = Q.x - min(Q.w, Q.y);
+  float H = abs((Q.w - Q.y) / (6. * C + EPSILON) + Q.z);
+  return vec3(H, C, Q.x);
+}
+
+vec3 rgb2hsl(in vec3 RGB) {
+  vec3 HCV = rgb2hsv(RGB);
+  float L = HCV.z - HCV.y * 0.5;
+  float S = HCV.y / (1. - abs(L * 2. - 1.) + EPSILON);
+  return vec3(HCV.x, S, L);
+}
+
+vec3 hsv2rgb(in vec3 HSV) {
+  vec3 RGB = hue2rgb(HSV.x);
+  return ((RGB - 1.) * HSV.y + 1.) * HSV.z;
+}
+
+#ifdef USE_OIT
+#ifdef USE_OIT
+
+uniform float oitDepthFar;          
+uniform vec2 oitScreenSize;         
+uniform sampler2D oitMinDepthTexture; 
+uniform int oitSkipFront;           
+uniform float oitOcclusionThreshold; 
+
+vec4 oitProcess(vec4 color) {
+  #ifdef OIT_OCCLUSION_PASS
+  
+  
+  
+  
+  
+  if(color.a < oitOcclusionThreshold)
+    discard;
+  return color;
+  #endif
+
+  
+  
+  float linZ = abs(vViewPosition.z) / oitDepthFar;
+
+  #ifdef OIT_DEPTH_PASS
+
+  
+  return vec4(linZ, 0.0, 0.0, 1.0);
+
+  #else
+
+  
+  
+  
+  vec2 uv = gl_FragCoord.xy / oitScreenSize;
+  float minZ = texture2D(oitMinDepthTexture, uv).r;
+  
+  
+  
+  
+  
+  
+  float tol = minZ * 1e-3 + 1e-6;
+  bool isFront = (linZ - minZ) <= tol;
+
+  #ifdef OIT_FRONT_PASS
+
+  
+  if(!isFront)
+    discard;
+  return color;
+
+  #else
+
+  
+  
+  if(isFront && oitSkipFront == 0)
+    discard;
+
+  float alpha = color.a;
+
+  
+  
+  
+  
+  
+  float b = -log(1.0 - clamp(alpha, 0.0, 0.9999));
+  return vec4(color.rgb * b, b);
+
+  #endif 
+  #endif 
+}
+
+#endif
+#endif
+
+void main() {
+	#include <clipping_planes_fragment>
+
+  vec3 color = diffuse.rgb;
+
+  vec4 diffuseColor = vec4(color.rgb, opacity);
+
+	#include <logdepthbuf_fragment>
+	#include <map_fragment>
+	#include <color_fragment>
+  #include <normal_fragment_begin>
+
+  #ifdef DEPTH_SHADE
+  float ndv = clamp(dot(normalize(vNormal), normalize(vViewPosition)), 0.0, 1.0);
+  
+  
+  
+  
+  
+  
+  
+  float ndvAA = max(ndv, fwidth(ndv));
+  float depthFactor = pow(ndvAA, 0.8);
+  float darkenFactor = clamp(vViewPosition.z / 5000.0, 0.1, 0.8);
+  vec3 hsv = rgb2hsv(diffuseColor.rgb);
+  hsv.z = hsv.z * darkenFactor;
+  vec3 mixColor = hsv2rgb(hsv);
+  diffuseColor.rgb = mix(mixColor, diffuseColor.rgb, depthFactor);
+  #else
+  float alphaFactor = clamp(vViewPosition.z / 100000.0, 0.0, 0.9);
+
+  diffuseColor.a = 1.0 - alphaFactor;
+  #endif
+
+  gl_FragColor = diffuseColor.rgba;
+
+	#include <tonemapping_fragment>
+	#include <colorspace_fragment>
+	#include <fog_fragment>
+
+	#ifdef OPAQUE
+
+  gl_FragColor.a = 1.0;
+
+	#endif
+
+  #ifdef USE_OIT
+  gl_FragColor = oitProcess(gl_FragColor);
+  #endif
+}`, tn = `#define TRAJECTORY_MATERIAL
+
+varying vec3 vViewPosition;
+
+#include <common>
+#include <batching_pars_vertex>
+#include <uv_pars_vertex>
+#include <envmap_pars_vertex>
+#include <color_pars_vertex>
+#include <fog_pars_vertex>
+#include <normal_pars_fragment>
+#include <logdepthbuf_pars_vertex>
+#include <clipping_planes_pars_vertex>
+
+void main() {
+
+	#include <uv_vertex>
+	#include <color_vertex>
+  #include <batching_vertex>
+  #include <beginnormal_vertex>
+  #include <defaultnormal_vertex>
+  #include <normal_vertex>
+
+	#include <begin_vertex>
+	#include <project_vertex>
+	#include <logdepthbuf_vertex>
+	#include <clipping_planes_vertex>
+
+  vViewPosition = - mvPosition.xyz;
+
+	#include <worldpos_vertex>
+	#include <fog_vertex>
+}`;
+class mn extends y {
+  isTubeMaterial = !0;
+  constructor(e) {
+    super({
+      vertexShader: tn,
+      fragmentShader: on,
+      uniforms: q.clone($.basic.uniforms),
+      defines: {
+        DEPTH_SHADE: !0
+      },
+      clipping: !0,
+      fog: !0
+    }), e && this.setValues(e), X(this);
+  }
+  get color() {
+    return this.uniforms.diffuse.value;
+  }
+  set color(e) {
+    this.uniforms.diffuse.value.set(e);
+  }
+}
+export {
+  ln as C,
+  mn as T,
+  X as a,
+  an as b,
+  cn as c,
+  pn as d,
+  un as e,
+  fn as g,
+  hn as i,
+  gn as m,
+  dn as t,
+  j as w
+};