create-swdg-frontend 0.1.0

package/template/public/Cesium1.119/Workers/createVectorTilePoints.js

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import { a as x } from "./chunk-PXCJYT2S.js";
+import { a as w } from "./chunk-ABGXSJNX.js";
+import { h as c } from "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import { a as h, b as l, d as p } from "./chunk-POASMU2N.js";
+import { a as i } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import "./chunk-PEYJTJPE.js";
+var u = 32767,
+  F = new l(),
+  L = new h(),
+  b = new c(),
+  y = new p(),
+  a = { min: void 0, max: void 0 };
+function V(t) {
+  t = new Float64Array(t);
+  let o = 0;
+  ((a.min = t[o++]),
+    (a.max = t[o++]),
+    c.unpack(t, o, b),
+    (o += c.packedLength),
+    p.unpack(t, o, y));
+}
+function z(t, o) {
+  let s = new Uint16Array(t.positions);
+  V(t.packedBuffer);
+  let e = b,
+    C = y,
+    A = a.min,
+    P = a.max,
+    n = s.length / 3,
+    f = s.subarray(0, n),
+    g = s.subarray(n, 2 * n),
+    d = s.subarray(2 * n, 3 * n);
+  w.zigZagDeltaDecode(f, g, d);
+  let m = new Float64Array(s.length);
+  for (let r = 0; r < n; ++r) {
+    let k = f[r],
+      E = g[r],
+      H = d[r],
+      M = i.lerp(e.west, e.east, k / u),
+      R = i.lerp(e.south, e.north, E / u),
+      T = i.lerp(A, P, H / u),
+      v = l.fromRadians(M, R, T, F),
+      D = C.cartographicToCartesian(v, L);
+    h.pack(D, m, r * 3);
+  }
+  return (o.push(m.buffer), { positions: m.buffer });
+}
+var G = x(z);
+export { G as default };

package/template/public/Cesium1.119/Workers/createVectorTilePolygons.js

@@ -0,0 +1,275 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import { a as R } from "./chunk-V7JEDBOE.js";
+import { a as It } from "./chunk-PXCJYT2S.js";
+import { a as M } from "./chunk-Q6L7X3LP.js";
+import { a as bt } from "./chunk-ABGXSJNX.js";
+import "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as W } from "./chunk-P37AI2DW.js";
+import "./chunk-TMSETF7M.js";
+import { h as z } from "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import { a as o, b as nt, d as j } from "./chunk-POASMU2N.js";
+import { a as et } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import { e as A } from "./chunk-PEYJTJPE.js";
+var kt = new o(),
+  Bt = new j(),
+  Nt = new z(),
+  E = { min: void 0, max: void 0, indexBytesPerElement: void 0 };
+function Pt(s) {
+  let u = new Float64Array(s),
+    n = 0;
+  ((E.indexBytesPerElement = u[n++]),
+    (E.min = u[n++]),
+    (E.max = u[n++]),
+    o.unpack(u, n, kt),
+    (n += o.packedLength),
+    j.unpack(u, n, Bt),
+    (n += j.packedLength),
+    z.unpack(u, n, Nt));
+}
+function Tt(s) {
+  let u = s.length,
+    n = 0;
+  for (let y = 0; y < u; ++y) n += R.packedLength + 3 + s[y].batchIds.length;
+  return n;
+}
+function Ct(s, u, n) {
+  let y = u.length,
+    O = 2 + y * M.packedLength + 1 + Tt(n),
+    c = new Float64Array(O),
+    i = 0;
+  ((c[i++] = s), (c[i++] = y));
+  for (let x = 0; x < y; ++x) (M.pack(u[x], c, i), (i += M.packedLength));
+  let V = n.length;
+  c[i++] = V;
+  for (let x = 0; x < V; ++x) {
+    let B = n[x];
+    (R.pack(B.color, c, i),
+      (i += R.packedLength),
+      (c[i++] = B.offset),
+      (c[i++] = B.count));
+    let P = B.batchIds,
+      w = P.length;
+    c[i++] = w;
+    for (let h = 0; h < w; ++h) c[i++] = P[h];
+  }
+  return c;
+}
+var yt = 32767,
+  wt = new o(),
+  Ht = new o(),
+  St = new o(),
+  Ut = new o(),
+  Ft = new o(),
+  Lt = new nt(),
+  Mt = new z();
+function Rt(s, u) {
+  Pt(s.packedBuffer);
+  let n;
+  E.indexBytesPerElement === 2
+    ? (n = new Uint16Array(s.indices))
+    : (n = new Uint32Array(s.indices));
+  let O = new Uint16Array(s.positions),
+    c = new Uint32Array(s.counts),
+    i = new Uint32Array(s.indexCounts),
+    V = new Uint32Array(s.batchIds),
+    x = new Uint32Array(s.batchTableColors),
+    B = new Array(c.length),
+    P = kt,
+    w = Bt,
+    h = Nt,
+    ot = E.min,
+    st = E.max,
+    T = s.minimumHeights,
+    C = s.maximumHeights;
+  A(T) && A(C) && ((T = new Float32Array(T)), (C = new Float32Array(C)));
+  let t,
+    f,
+    l,
+    N = O.length / 2,
+    ct = O.subarray(0, N),
+    it = O.subarray(N, 2 * N);
+  bt.zigZagDeltaDecode(ct, it);
+  let rt = new Float64Array(N * 3);
+  for (t = 0; t < N; ++t) {
+    let e = ct[t],
+      p = it[t],
+      L = et.lerp(h.west, h.east, e / yt),
+      k = et.lerp(h.south, h.north, p / yt),
+      b = nt.fromRadians(L, k, 0, Lt),
+      Y = w.cartographicToCartesian(b, wt);
+    o.pack(Y, rt, t * 3);
+  }
+  let H = c.length,
+    at = new Array(H),
+    Z = new Array(H),
+    ft = 0,
+    lt = 0;
+  for (t = 0; t < H; ++t)
+    ((at[t] = ft), (Z[t] = lt), (ft += c[t]), (lt += i[t]));
+  let S = new Float32Array(N * 3 * 2),
+    _ = new Uint16Array(N * 2),
+    D = new Uint32Array(Z.length),
+    G = new Uint32Array(i.length),
+    r = [],
+    g = {};
+  for (t = 0; t < H; ++t)
+    ((l = x[t]),
+      A(g[l])
+        ? ((g[l].positionLength += c[t]),
+          (g[l].indexLength += i[t]),
+          g[l].batchIds.push(t))
+        : (g[l] = {
+            positionLength: c[t],
+            indexLength: i[t],
+            offset: 0,
+            indexOffset: 0,
+            batchIds: [t],
+          }));
+  let a,
+    dt = 0,
+    ht = 0;
+  for (l in g)
+    if (g.hasOwnProperty(l)) {
+      ((a = g[l]), (a.offset = dt), (a.indexOffset = ht));
+      let e = a.positionLength * 2,
+        p = a.indexLength * 2 + a.positionLength * 6;
+      ((dt += e), (ht += p), (a.indexLength = p));
+    }
+  let U = [];
+  for (l in g)
+    g.hasOwnProperty(l) &&
+      ((a = g[l]),
+      U.push({
+        color: R.fromRgba(parseInt(l)),
+        offset: a.indexOffset,
+        count: a.indexLength,
+        batchIds: a.batchIds,
+      }));
+  for (t = 0; t < H; ++t) {
+    ((l = x[t]), (a = g[l]));
+    let e = a.offset,
+      p = e * 3,
+      L = e,
+      k = at[t],
+      b = c[t],
+      Y = V[t],
+      mt = ot,
+      gt = st;
+    A(T) && A(C) && ((mt = T[t]), (gt = C[t]));
+    let q = Number.POSITIVE_INFINITY,
+      J = Number.NEGATIVE_INFINITY,
+      K = Number.POSITIVE_INFINITY,
+      Q = Number.NEGATIVE_INFINITY;
+    for (f = 0; f < b; ++f) {
+      let m = o.unpack(rt, k * 3 + f * 3, wt);
+      w.scaleToGeodeticSurface(m, m);
+      let I = w.cartesianToCartographic(m, Lt),
+        F = I.latitude,
+        pt = I.longitude;
+      ((q = Math.min(F, q)),
+        (J = Math.max(F, J)),
+        (K = Math.min(pt, K)),
+        (Q = Math.max(pt, Q)));
+      let xt = w.geodeticSurfaceNormal(m, Ht),
+        v = o.multiplyByScalar(xt, mt, St),
+        $ = o.add(m, v, Ut);
+      v = o.multiplyByScalar(xt, gt, v);
+      let tt = o.add(m, v, Ft);
+      (o.subtract(tt, P, tt),
+        o.subtract($, P, $),
+        o.pack(tt, S, p),
+        o.pack($, S, p + 3),
+        (_[L] = Y),
+        (_[L + 1] = Y),
+        (p += 6),
+        (L += 2));
+    }
+    ((h = Mt),
+      (h.west = K),
+      (h.east = Q),
+      (h.south = q),
+      (h.north = J),
+      (B[t] = M.fromRectangle(h, ot, st, w)));
+    let d = a.indexOffset,
+      X = Z[t],
+      Ot = i[t];
+    for (D[t] = d, f = 0; f < Ot; f += 3) {
+      let m = n[X + f] - k,
+        I = n[X + f + 1] - k,
+        F = n[X + f + 2] - k;
+      ((r[d++] = m * 2 + e),
+        (r[d++] = I * 2 + e),
+        (r[d++] = F * 2 + e),
+        (r[d++] = F * 2 + 1 + e),
+        (r[d++] = I * 2 + 1 + e),
+        (r[d++] = m * 2 + 1 + e));
+    }
+    for (f = 0; f < b; ++f) {
+      let m = f,
+        I = (f + 1) % b;
+      ((r[d++] = m * 2 + 1 + e),
+        (r[d++] = I * 2 + e),
+        (r[d++] = m * 2 + e),
+        (r[d++] = m * 2 + 1 + e),
+        (r[d++] = I * 2 + 1 + e),
+        (r[d++] = I * 2 + e));
+    }
+    ((a.offset += b * 2), (a.indexOffset = d), (G[t] = d - D[t]));
+  }
+  r = W.createTypedArray(S.length / 3, r);
+  let At = U.length;
+  for (let e = 0; e < At; ++e) {
+    let p = U[e].batchIds,
+      L = 0,
+      k = p.length;
+    for (let b = 0; b < k; ++b) L += G[p[b]];
+    U[e].count = L;
+  }
+  let Et = r.BYTES_PER_ELEMENT === 2 ? W.UNSIGNED_SHORT : W.UNSIGNED_INT,
+    ut = Ct(Et, B, U);
+  return (
+    u.push(S.buffer, r.buffer, D.buffer, G.buffer, _.buffer, ut.buffer),
+    {
+      positions: S.buffer,
+      indices: r.buffer,
+      indexOffsets: D.buffer,
+      indexCounts: G.buffer,
+      batchIds: _.buffer,
+      packedBuffer: ut.buffer,
+    }
+  );
+}
+var Jt = It(Rt);
+export { Jt as default };

package/template/public/Cesium1.119/Workers/createVectorTilePolylines.js

@@ -0,0 +1,176 @@
+/**
+ * @license
+ * Cesium - https://github.com/CesiumGS/cesium
+ * Version 1.119
+ *
+ * Copyright 2011-2022 Cesium Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Columbus View (Pat. Pend.)
+ *
+ * Portions licensed separately.
+ * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
+ */
+
+import { a as K } from "./chunk-PXCJYT2S.js";
+import { a as G } from "./chunk-ABGXSJNX.js";
+import { a as S } from "./chunk-P37AI2DW.js";
+import { c as B, h as R } from "./chunk-7Z5IIKOJ.js";
+import "./chunk-KZNJOCYU.js";
+import { a as t, b as _, d as L } from "./chunk-POASMU2N.js";
+import { a as F } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import "./chunk-IUA6FAOZ.js";
+import "./chunk-UH2WFNTA.js";
+import "./chunk-PEYJTJPE.js";
+var O = 32767,
+  ct = new _(),
+  rt = new t();
+function it(n, o, p, m, s) {
+  let d = n.length / 3,
+    U = n.subarray(0, d),
+    v = n.subarray(d, 2 * d),
+    P = n.subarray(2 * d, 3 * d);
+  G.zigZagDeltaDecode(U, v, P);
+  let D = new Float64Array(n.length);
+  for (let u = 0; u < d; ++u) {
+    let e = U[u],
+      A = v[u],
+      l = P[u],
+      k = F.lerp(o.west, o.east, e / O),
+      I = F.lerp(o.south, o.north, A / O),
+      E = F.lerp(p, m, l / O),
+      g = _.fromRadians(k, I, E, ct),
+      C = s.cartographicToCartesian(g, rt);
+    t.pack(C, D, u * 3);
+  }
+  return D;
+}
+var Y = it;
+var X = new R(),
+  $ = new L(),
+  j = new t(),
+  H = { min: void 0, max: void 0 };
+function at(n) {
+  n = new Float64Array(n);
+  let o = 0;
+  ((H.min = n[o++]),
+    (H.max = n[o++]),
+    R.unpack(n, o, X),
+    (o += R.packedLength),
+    L.unpack(n, o, $),
+    (o += L.packedLength),
+    t.unpack(n, o, j));
+}
+function ft(n) {
+  let o = n.length,
+    p = new Uint32Array(o + 1),
+    m = 0;
+  for (let s = 0; s < o; ++s) ((p[s] = m), (m += n[s]));
+  return ((p[o] = m), p);
+}
+var Z = new t(),
+  q = new t(),
+  J = new t(),
+  dt = new t(),
+  Q = new t();
+function ut(n, o) {
+  let p = new Uint16Array(n.positions),
+    m = new Uint16Array(n.widths),
+    s = new Uint32Array(n.counts),
+    d = new Uint16Array(n.batchIds);
+  at(n.packedBuffer);
+  let U = X,
+    v = $,
+    P = j,
+    D = H.min,
+    u = H.max,
+    e = Y(p, U, D, u, v),
+    A = e.length / 3,
+    l = A * 4 - 4,
+    k = new Float32Array(l * 3),
+    I = new Float32Array(l * 3),
+    E = new Float32Array(l * 3),
+    g = new Float32Array(l * 2),
+    C = new Uint16Array(l),
+    N = 0,
+    z = 0,
+    tt = 0,
+    r,
+    h = 0,
+    M = s.length;
+  for (r = 0; r < M; ++r) {
+    let a = s[r],
+      nt = m[r],
+      ot = d[r];
+    for (let f = 0; f < a; ++f) {
+      let w;
+      if (f === 0) {
+        let c = t.unpack(e, h * 3, Z),
+          T = t.unpack(e, (h + 1) * 3, q);
+        ((w = t.subtract(c, T, J)), t.add(c, w, w));
+      } else w = t.unpack(e, (h + f - 1) * 3, J);
+      let W = t.unpack(e, (h + f) * 3, dt),
+        x;
+      if (f === a - 1) {
+        let c = t.unpack(e, (h + a - 1) * 3, Z),
+          T = t.unpack(e, (h + a - 2) * 3, q);
+        ((x = t.subtract(c, T, Q)), t.add(c, x, x));
+      } else x = t.unpack(e, (h + f + 1) * 3, Q);
+      (t.subtract(w, P, w), t.subtract(W, P, W), t.subtract(x, P, x));
+      let et = f === 0 ? 2 : 0,
+        st = f === a - 1 ? 2 : 4;
+      for (let c = et; c < st; ++c) {
+        (t.pack(W, k, N), t.pack(w, I, N), t.pack(x, E, N), (N += 3));
+        let T = c - 2 < 0 ? -1 : 1;
+        ((g[z++] = 2 * (c % 2) - 1), (g[z++] = T * nt), (C[tt++] = ot));
+      }
+    }
+    h += a;
+  }
+  let i = S.createTypedArray(l, A * 6 - 6),
+    b = 0,
+    y = 0;
+  for (M = A - 1, r = 0; r < M; ++r)
+    ((i[y++] = b),
+      (i[y++] = b + 2),
+      (i[y++] = b + 1),
+      (i[y++] = b + 1),
+      (i[y++] = b + 2),
+      (i[y++] = b + 3),
+      (b += 4));
+  (o.push(k.buffer, I.buffer, E.buffer), o.push(g.buffer, C.buffer, i.buffer));
+  let V = {
+    indexDatatype:
+      i.BYTES_PER_ELEMENT === 2 ? S.UNSIGNED_SHORT : S.UNSIGNED_INT,
+    currentPositions: k.buffer,
+    previousPositions: I.buffer,
+    nextPositions: E.buffer,
+    expandAndWidth: g.buffer,
+    batchIds: C.buffer,
+    indices: i.buffer,
+  };
+  if (n.keepDecodedPositions) {
+    let a = ft(s);
+    (o.push(e.buffer, a.buffer),
+      (V = B(V, {
+        decodedPositions: e.buffer,
+        decodedPositionOffsets: a.buffer,
+      })));
+  }
+  return V;
+}
+var It = K(ut);
+export { It as default };