create-swdg-frontend 0.1.0

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

@@ -0,0 +1,320 @@
+/**
+ * @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 nt } from "./chunk-IRH46BDL.js";
+import "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import { a as _ } from "./chunk-HEEMUCG6.js";
+import "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as ot } from "./chunk-P37AI2DW.js";
+import { a as it } from "./chunk-T6BE4RZK.js";
+import { b as tt, c as et, d as S } from "./chunk-X5IHHI6X.js";
+import { d as I } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as R } from "./chunk-KZNJOCYU.js";
+import { a as s, d as l } from "./chunk-POASMU2N.js";
+import { a as J } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as w } from "./chunk-IUA6FAOZ.js";
+import { a as P } from "./chunk-UH2WFNTA.js";
+import { e as r } from "./chunk-PEYJTJPE.js";
+var Q = new s(),
+  Y = new s(),
+  lt = new s(),
+  st = new s(),
+  pt = new s(),
+  ut = new s(),
+  ft = new s();
+function k(t) {
+  t = w(t, w.EMPTY_OBJECT);
+  let e = t.positions,
+    o = t.maximumHeights,
+    n = t.minimumHeights;
+  if (!r(e)) throw new P("options.positions is required.");
+  if (r(o) && o.length !== e.length)
+    throw new P(
+      "options.positions and options.maximumHeights must have the same length.",
+    );
+  if (r(n) && n.length !== e.length)
+    throw new P(
+      "options.positions and options.minimumHeights must have the same length.",
+    );
+  let i = w(t.vertexFormat, _.DEFAULT),
+    c = w(t.granularity, J.RADIANS_PER_DEGREE),
+    a = w(t.ellipsoid, l.default);
+  ((this._positions = e),
+    (this._minimumHeights = n),
+    (this._maximumHeights = o),
+    (this._vertexFormat = _.clone(i)),
+    (this._granularity = c),
+    (this._ellipsoid = l.clone(a)),
+    (this._workerName = "createWallGeometry"));
+  let m = 1 + e.length * s.packedLength + 2;
+  (r(n) && (m += n.length),
+    r(o) && (m += o.length),
+    (this.packedLength = m + l.packedLength + _.packedLength + 1));
+}
+k.pack = function (t, e, o) {
+  if (!r(t)) throw new P("value is required");
+  if (!r(e)) throw new P("array is required");
+  o = w(o, 0);
+  let n,
+    i = t._positions,
+    c = i.length;
+  for (e[o++] = c, n = 0; n < c; ++n, o += s.packedLength) s.pack(i[n], e, o);
+  let a = t._minimumHeights;
+  if (((c = r(a) ? a.length : 0), (e[o++] = c), r(a)))
+    for (n = 0; n < c; ++n) e[o++] = a[n];
+  let m = t._maximumHeights;
+  if (((c = r(m) ? m.length : 0), (e[o++] = c), r(m)))
+    for (n = 0; n < c; ++n) e[o++] = m[n];
+  return (
+    l.pack(t._ellipsoid, e, o),
+    (o += l.packedLength),
+    _.pack(t._vertexFormat, e, o),
+    (o += _.packedLength),
+    (e[o] = t._granularity),
+    e
+  );
+};
+var mt = l.clone(l.UNIT_SPHERE),
+  rt = new _(),
+  V = {
+    positions: void 0,
+    minimumHeights: void 0,
+    maximumHeights: void 0,
+    ellipsoid: mt,
+    vertexFormat: rt,
+    granularity: void 0,
+  };
+k.unpack = function (t, e, o) {
+  if (!r(t)) throw new P("array is required");
+  e = w(e, 0);
+  let n,
+    i = t[e++],
+    c = new Array(i);
+  for (n = 0; n < i; ++n, e += s.packedLength) c[n] = s.unpack(t, e);
+  i = t[e++];
+  let a;
+  if (i > 0) for (a = new Array(i), n = 0; n < i; ++n) a[n] = t[e++];
+  i = t[e++];
+  let m;
+  if (i > 0) for (m = new Array(i), n = 0; n < i; ++n) m[n] = t[e++];
+  let q = l.unpack(t, e, mt);
+  e += l.packedLength;
+  let H = _.unpack(t, e, rt);
+  e += _.packedLength;
+  let f = t[e];
+  return r(o)
+    ? ((o._positions = c),
+      (o._minimumHeights = a),
+      (o._maximumHeights = m),
+      (o._ellipsoid = l.clone(q, o._ellipsoid)),
+      (o._vertexFormat = _.clone(H, o._vertexFormat)),
+      (o._granularity = f),
+      o)
+    : ((V.positions = c),
+      (V.minimumHeights = a),
+      (V.maximumHeights = m),
+      (V.granularity = f),
+      new k(V));
+};
+k.fromConstantHeights = function (t) {
+  t = w(t, w.EMPTY_OBJECT);
+  let e = t.positions;
+  if (!r(e)) throw new P("options.positions is required.");
+  let o,
+    n,
+    i = t.minimumHeight,
+    c = t.maximumHeight,
+    a = r(i),
+    m = r(c);
+  if (a || m) {
+    let H = e.length;
+    ((o = a ? new Array(H) : void 0), (n = m ? new Array(H) : void 0));
+    for (let f = 0; f < H; ++f) (a && (o[f] = i), m && (n[f] = c));
+  }
+  let q = {
+    positions: e,
+    maximumHeights: n,
+    minimumHeights: o,
+    ellipsoid: t.ellipsoid,
+    vertexFormat: t.vertexFormat,
+  };
+  return new k(q);
+};
+k.createGeometry = function (t) {
+  let e = t._positions,
+    o = t._minimumHeights,
+    n = t._maximumHeights,
+    i = t._vertexFormat,
+    c = t._granularity,
+    a = t._ellipsoid,
+    m = nt.computePositions(a, e, n, o, c, !0);
+  if (!r(m)) return;
+  let q = m.bottomPositions,
+    H = m.topPositions,
+    f = m.numCorners,
+    B = H.length,
+    y = B * 2,
+    h = i.position ? new Float64Array(y) : void 0,
+    b = i.normal ? new Float32Array(y) : void 0,
+    x = i.tangent ? new Float32Array(y) : void 0,
+    F = i.bitangent ? new Float32Array(y) : void 0,
+    M = i.st ? new Float32Array((y / 3) * 2) : void 0,
+    v = 0,
+    T = 0,
+    C = 0,
+    z = 0,
+    W = 0,
+    g = ft,
+    d = ut,
+    A = pt,
+    Z = !0;
+  B /= 3;
+  let p,
+    j = 0,
+    ct = 1 / (B - f - 1);
+  for (p = 0; p < B; ++p) {
+    let E = p * 3,
+      u = s.fromArray(H, E, Q),
+      U = s.fromArray(q, E, Y);
+    if (
+      (i.position &&
+        ((h[v++] = U.x),
+        (h[v++] = U.y),
+        (h[v++] = U.z),
+        (h[v++] = u.x),
+        (h[v++] = u.y),
+        (h[v++] = u.z)),
+      i.st && ((M[W++] = j), (M[W++] = 0), (M[W++] = j), (M[W++] = 1)),
+      i.normal || i.tangent || i.bitangent)
+    ) {
+      let N = s.clone(s.ZERO, st),
+        K = s.subtract(u, a.geodeticSurfaceNormal(u, Y), Y);
+      if ((p + 1 < B && (N = s.fromArray(H, E + 3, st)), Z)) {
+        let G = s.subtract(N, u, lt),
+          at = s.subtract(K, u, Q);
+        ((g = s.normalize(s.cross(at, G, g), g)), (Z = !1));
+      }
+      (s.equalsEpsilon(u, N, J.EPSILON10)
+        ? (Z = !0)
+        : ((j += ct),
+          i.tangent && (d = s.normalize(s.subtract(N, u, d), d)),
+          i.bitangent && (A = s.normalize(s.cross(g, d, A), A))),
+        i.normal &&
+          ((b[T++] = g.x),
+          (b[T++] = g.y),
+          (b[T++] = g.z),
+          (b[T++] = g.x),
+          (b[T++] = g.y),
+          (b[T++] = g.z)),
+        i.tangent &&
+          ((x[z++] = d.x),
+          (x[z++] = d.y),
+          (x[z++] = d.z),
+          (x[z++] = d.x),
+          (x[z++] = d.y),
+          (x[z++] = d.z)),
+        i.bitangent &&
+          ((F[C++] = A.x),
+          (F[C++] = A.y),
+          (F[C++] = A.z),
+          (F[C++] = A.x),
+          (F[C++] = A.y),
+          (F[C++] = A.z)));
+    }
+  }
+  let D = new it();
+  (i.position &&
+    (D.position = new S({
+      componentDatatype: R.DOUBLE,
+      componentsPerAttribute: 3,
+      values: h,
+    })),
+    i.normal &&
+      (D.normal = new S({
+        componentDatatype: R.FLOAT,
+        componentsPerAttribute: 3,
+        values: b,
+      })),
+    i.tangent &&
+      (D.tangent = new S({
+        componentDatatype: R.FLOAT,
+        componentsPerAttribute: 3,
+        values: x,
+      })),
+    i.bitangent &&
+      (D.bitangent = new S({
+        componentDatatype: R.FLOAT,
+        componentsPerAttribute: 3,
+        values: F,
+      })),
+    i.st &&
+      (D.st = new S({
+        componentDatatype: R.FLOAT,
+        componentsPerAttribute: 2,
+        values: M,
+      })));
+  let $ = y / 3;
+  y -= 6 * (f + 1);
+  let L = ot.createTypedArray($, y),
+    O = 0;
+  for (p = 0; p < $ - 2; p += 2) {
+    let E = p,
+      u = p + 2,
+      U = s.fromArray(h, E * 3, Q),
+      N = s.fromArray(h, u * 3, Y);
+    if (s.equalsEpsilon(U, N, J.EPSILON10)) continue;
+    let K = p + 1,
+      G = p + 3;
+    ((L[O++] = K),
+      (L[O++] = E),
+      (L[O++] = G),
+      (L[O++] = G),
+      (L[O++] = E),
+      (L[O++] = u));
+  }
+  return new et({
+    attributes: D,
+    indices: L,
+    primitiveType: tt.TRIANGLES,
+    boundingSphere: new I.fromVertices(h),
+  });
+};
+var X = k;
+function ht(t, e) {
+  return (
+    r(e) && (t = X.unpack(t, e)),
+    (t._ellipsoid = l.clone(t._ellipsoid)),
+    X.createGeometry(t)
+  );
+}
+var Ot = ht;
+export { Ot as default };

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

@@ -0,0 +1,229 @@
+/**
+ * @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 B } from "./chunk-IRH46BDL.js";
+import "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as W } from "./chunk-P37AI2DW.js";
+import { a as N } from "./chunk-T6BE4RZK.js";
+import { b as R, c as S, d as M } from "./chunk-X5IHHI6X.js";
+import { d as D } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as q } from "./chunk-KZNJOCYU.js";
+import { a as p, d as l } from "./chunk-POASMU2N.js";
+import { a as O } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as d } from "./chunk-IUA6FAOZ.js";
+import { a as _ } from "./chunk-UH2WFNTA.js";
+import { e as m } from "./chunk-PEYJTJPE.js";
+var U = new p(),
+  z = new p();
+function w(i) {
+  i = d(i, d.EMPTY_OBJECT);
+  let t = i.positions,
+    e = i.maximumHeights,
+    o = i.minimumHeights;
+  if (!m(t)) throw new _("options.positions is required.");
+  if (m(e) && e.length !== t.length)
+    throw new _(
+      "options.positions and options.maximumHeights must have the same length.",
+    );
+  if (m(o) && o.length !== t.length)
+    throw new _(
+      "options.positions and options.minimumHeights must have the same length.",
+    );
+  let s = d(i.granularity, O.RADIANS_PER_DEGREE),
+    r = d(i.ellipsoid, l.default);
+  ((this._positions = t),
+    (this._minimumHeights = o),
+    (this._maximumHeights = e),
+    (this._granularity = s),
+    (this._ellipsoid = l.clone(r)),
+    (this._workerName = "createWallOutlineGeometry"));
+  let n = 1 + t.length * p.packedLength + 2;
+  (m(o) && (n += o.length),
+    m(e) && (n += e.length),
+    (this.packedLength = n + l.packedLength + 1));
+}
+w.pack = function (i, t, e) {
+  if (!m(i)) throw new _("value is required");
+  if (!m(t)) throw new _("array is required");
+  e = d(e, 0);
+  let o,
+    s = i._positions,
+    r = s.length;
+  for (t[e++] = r, o = 0; o < r; ++o, e += p.packedLength) p.pack(s[o], t, e);
+  let n = i._minimumHeights;
+  if (((r = m(n) ? n.length : 0), (t[e++] = r), m(n)))
+    for (o = 0; o < r; ++o) t[e++] = n[o];
+  let c = i._maximumHeights;
+  if (((r = m(c) ? c.length : 0), (t[e++] = r), m(c)))
+    for (o = 0; o < r; ++o) t[e++] = c[o];
+  return (
+    l.pack(i._ellipsoid, t, e),
+    (e += l.packedLength),
+    (t[e] = i._granularity),
+    t
+  );
+};
+var G = l.clone(l.UNIT_SPHERE),
+  b = {
+    positions: void 0,
+    minimumHeights: void 0,
+    maximumHeights: void 0,
+    ellipsoid: G,
+    granularity: void 0,
+  };
+w.unpack = function (i, t, e) {
+  if (!m(i)) throw new _("array is required");
+  t = d(t, 0);
+  let o,
+    s = i[t++],
+    r = new Array(s);
+  for (o = 0; o < s; ++o, t += p.packedLength) r[o] = p.unpack(i, t);
+  s = i[t++];
+  let n;
+  if (s > 0) for (n = new Array(s), o = 0; o < s; ++o) n[o] = i[t++];
+  s = i[t++];
+  let c;
+  if (s > 0) for (c = new Array(s), o = 0; o < s; ++o) c[o] = i[t++];
+  let E = l.unpack(i, t, G);
+  t += l.packedLength;
+  let u = i[t];
+  return m(e)
+    ? ((e._positions = r),
+      (e._minimumHeights = n),
+      (e._maximumHeights = c),
+      (e._ellipsoid = l.clone(E, e._ellipsoid)),
+      (e._granularity = u),
+      e)
+    : ((b.positions = r),
+      (b.minimumHeights = n),
+      (b.maximumHeights = c),
+      (b.granularity = u),
+      new w(b));
+};
+w.fromConstantHeights = function (i) {
+  i = d(i, d.EMPTY_OBJECT);
+  let t = i.positions;
+  if (!m(t)) throw new _("options.positions is required.");
+  let e,
+    o,
+    s = i.minimumHeight,
+    r = i.maximumHeight,
+    n = m(s),
+    c = m(r);
+  if (n || c) {
+    let u = t.length;
+    ((e = n ? new Array(u) : void 0), (o = c ? new Array(u) : void 0));
+    for (let a = 0; a < u; ++a) (n && (e[a] = s), c && (o[a] = r));
+  }
+  let E = {
+    positions: t,
+    maximumHeights: o,
+    minimumHeights: e,
+    ellipsoid: i.ellipsoid,
+  };
+  return new w(E);
+};
+w.createGeometry = function (i) {
+  let t = i._positions,
+    e = i._minimumHeights,
+    o = i._maximumHeights,
+    s = i._granularity,
+    r = i._ellipsoid,
+    n = B.computePositions(r, t, o, e, s, !1);
+  if (!m(n)) return;
+  let c = n.bottomPositions,
+    E = n.topPositions,
+    u = E.length,
+    a = u * 2,
+    f = new Float64Array(a),
+    P = 0;
+  u /= 3;
+  let h;
+  for (h = 0; h < u; ++h) {
+    let A = h * 3,
+      k = p.fromArray(E, A, U),
+      L = p.fromArray(c, A, z);
+    ((f[P++] = L.x),
+      (f[P++] = L.y),
+      (f[P++] = L.z),
+      (f[P++] = k.x),
+      (f[P++] = k.y),
+      (f[P++] = k.z));
+  }
+  let V = new N({
+      position: new M({
+        componentDatatype: q.DOUBLE,
+        componentsPerAttribute: 3,
+        values: f,
+      }),
+    }),
+    y = a / 3;
+  a = 2 * y - 4 + y;
+  let g = W.createTypedArray(y, a),
+    H = 0;
+  for (h = 0; h < y - 2; h += 2) {
+    let A = h,
+      k = h + 2,
+      L = p.fromArray(f, A * 3, U),
+      v = p.fromArray(f, k * 3, z);
+    if (p.equalsEpsilon(L, v, O.EPSILON10)) continue;
+    let T = h + 1,
+      x = h + 3;
+    ((g[H++] = T),
+      (g[H++] = A),
+      (g[H++] = T),
+      (g[H++] = x),
+      (g[H++] = A),
+      (g[H++] = k));
+  }
+  return (
+    (g[H++] = y - 2),
+    (g[H++] = y - 1),
+    new S({
+      attributes: V,
+      indices: g,
+      primitiveType: R.LINES,
+      boundingSphere: new D.fromVertices(f),
+    })
+  );
+};
+var C = w;
+function J(i, t) {
+  return (
+    m(t) && (i = C.unpack(i, t)),
+    (i._ellipsoid = l.clone(i._ellipsoid)),
+    C.createGeometry(i)
+  );
+}
+var pi = J;
+export { pi as default };