create-swdg-frontend 0.1.0

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

@@ -0,0 +1,262 @@
+/**
+ * @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 M } from "./chunk-3JW36LZF.js";
+import { a as W } from "./chunk-QB3MDM4J.js";
+import "./chunk-ABGXSJNX.js";
+import "./chunk-DQO6B4EQ.js";
+import { a as x, b as I, c as j } from "./chunk-K4ASOM65.js";
+import "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import { a as g } from "./chunk-HEEMUCG6.js";
+import "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import { a as $, b as V } from "./chunk-O5IJ3OGP.js";
+import { a as Z } from "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as X } from "./chunk-P37AI2DW.js";
+import { a as Q } from "./chunk-T6BE4RZK.js";
+import { b as Y, c as z, d as U } from "./chunk-X5IHHI6X.js";
+import { d as K } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as B } from "./chunk-KZNJOCYU.js";
+import { a as T, c as C, d as f } from "./chunk-POASMU2N.js";
+import { a as J } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as k } from "./chunk-IUA6FAOZ.js";
+import { a as D } from "./chunk-UH2WFNTA.js";
+import { e as _ } from "./chunk-PEYJTJPE.js";
+function oe(t, e, n, o) {
+  let l = new Q();
+  o.position &&
+    (l.position = new U({
+      componentDatatype: B.DOUBLE,
+      componentsPerAttribute: 3,
+      values: t,
+    }));
+  let i = e.length,
+    u = t.length / 3,
+    L = (u - i * 2) / (i * 2),
+    E = V.triangulate(e),
+    q = (L - 1) * i * 6 + E.length * 2,
+    r = X.createTypedArray(u, q),
+    m,
+    s,
+    d,
+    b,
+    A,
+    F,
+    G = i * 2,
+    p = 0;
+  for (m = 0; m < L - 1; m++) {
+    for (s = 0; s < i - 1; s++)
+      ((d = s * 2 + m * i * 2),
+        (F = d + G),
+        (b = d + 1),
+        (A = b + G),
+        (r[p++] = b),
+        (r[p++] = d),
+        (r[p++] = A),
+        (r[p++] = A),
+        (r[p++] = d),
+        (r[p++] = F));
+    ((d = i * 2 - 2 + m * i * 2),
+      (b = d + 1),
+      (A = b + G),
+      (F = d + G),
+      (r[p++] = b),
+      (r[p++] = d),
+      (r[p++] = A),
+      (r[p++] = A),
+      (r[p++] = d),
+      (r[p++] = F));
+  }
+  if (o.st || o.tangent || o.bitangent) {
+    let c = new Float32Array(u * 2),
+      O = 1 / (L - 1),
+      w = 1 / n.height,
+      S = n.height / 2,
+      y,
+      a,
+      h = 0;
+    for (m = 0; m < L; m++) {
+      for (
+        y = m * O, a = w * (e[0].y + S), c[h++] = y, c[h++] = a, s = 1;
+        s < i;
+        s++
+      )
+        ((a = w * (e[s].y + S)),
+          (c[h++] = y),
+          (c[h++] = a),
+          (c[h++] = y),
+          (c[h++] = a));
+      ((a = w * (e[0].y + S)), (c[h++] = y), (c[h++] = a));
+    }
+    for (s = 0; s < i; s++)
+      ((y = 0), (a = w * (e[s].y + S)), (c[h++] = y), (c[h++] = a));
+    for (s = 0; s < i; s++)
+      ((y = (L - 1) * O), (a = w * (e[s].y + S)), (c[h++] = y), (c[h++] = a));
+    l.st = new U({
+      componentDatatype: B.FLOAT,
+      componentsPerAttribute: 2,
+      values: new Float32Array(c),
+    });
+  }
+  let N = u - i * 2;
+  for (m = 0; m < E.length; m += 3) {
+    let c = E[m] + N,
+      O = E[m + 1] + N,
+      w = E[m + 2] + N;
+    ((r[p++] = c),
+      (r[p++] = O),
+      (r[p++] = w),
+      (r[p++] = w + i),
+      (r[p++] = O + i),
+      (r[p++] = c + i));
+  }
+  let P = new z({
+    attributes: l,
+    indices: r,
+    boundingSphere: K.fromVertices(t),
+    primitiveType: Y.TRIANGLES,
+  });
+  if ((o.normal && (P = W.computeNormal(P)), o.tangent || o.bitangent)) {
+    try {
+      P = W.computeTangentAndBitangent(P);
+    } catch {
+      I(
+        "polyline-volume-tangent-bitangent",
+        "Unable to compute tangents and bitangents for polyline volume geometry",
+      );
+    }
+    (o.tangent || (P.attributes.tangent = void 0),
+      o.bitangent || (P.attributes.bitangent = void 0),
+      o.st || (P.attributes.st = void 0));
+  }
+  return P;
+}
+function R(t) {
+  t = k(t, k.EMPTY_OBJECT);
+  let e = t.polylinePositions,
+    n = t.shapePositions;
+  if (!_(e)) throw new D("options.polylinePositions is required.");
+  if (!_(n)) throw new D("options.shapePositions is required.");
+  ((this._positions = e),
+    (this._shape = n),
+    (this._ellipsoid = f.clone(k(t.ellipsoid, f.default))),
+    (this._cornerType = k(t.cornerType, x.ROUNDED)),
+    (this._vertexFormat = g.clone(k(t.vertexFormat, g.DEFAULT))),
+    (this._granularity = k(t.granularity, J.RADIANS_PER_DEGREE)),
+    (this._workerName = "createPolylineVolumeGeometry"));
+  let o = 1 + e.length * T.packedLength;
+  ((o += 1 + n.length * C.packedLength),
+    (this.packedLength = o + f.packedLength + g.packedLength + 2));
+}
+R.pack = function (t, e, n) {
+  if (!_(t)) throw new D("value is required");
+  if (!_(e)) throw new D("array is required");
+  n = k(n, 0);
+  let o,
+    l = t._positions,
+    i = l.length;
+  for (e[n++] = i, o = 0; o < i; ++o, n += T.packedLength) T.pack(l[o], e, n);
+  let u = t._shape;
+  for (i = u.length, e[n++] = i, o = 0; o < i; ++o, n += C.packedLength)
+    C.pack(u[o], e, n);
+  return (
+    f.pack(t._ellipsoid, e, n),
+    (n += f.packedLength),
+    g.pack(t._vertexFormat, e, n),
+    (n += g.packedLength),
+    (e[n++] = t._cornerType),
+    (e[n] = t._granularity),
+    e
+  );
+};
+var ee = f.clone(f.UNIT_SPHERE),
+  te = new g(),
+  v = {
+    polylinePositions: void 0,
+    shapePositions: void 0,
+    ellipsoid: ee,
+    vertexFormat: te,
+    cornerType: void 0,
+    granularity: void 0,
+  };
+R.unpack = function (t, e, n) {
+  if (!_(t)) throw new D("array is required");
+  e = k(e, 0);
+  let o,
+    l = t[e++],
+    i = new Array(l);
+  for (o = 0; o < l; ++o, e += T.packedLength) i[o] = T.unpack(t, e);
+  l = t[e++];
+  let u = new Array(l);
+  for (o = 0; o < l; ++o, e += C.packedLength) u[o] = C.unpack(t, e);
+  let L = f.unpack(t, e, ee);
+  e += f.packedLength;
+  let E = g.unpack(t, e, te);
+  e += g.packedLength;
+  let q = t[e++],
+    r = t[e];
+  return _(n)
+    ? ((n._positions = i),
+      (n._shape = u),
+      (n._ellipsoid = f.clone(L, n._ellipsoid)),
+      (n._vertexFormat = g.clone(E, n._vertexFormat)),
+      (n._cornerType = q),
+      (n._granularity = r),
+      n)
+    : ((v.polylinePositions = i),
+      (v.shapePositions = u),
+      (v.cornerType = q),
+      (v.granularity = r),
+      new R(v));
+};
+var ne = new M();
+R.createGeometry = function (t) {
+  let e = t._positions,
+    n = Z(e, T.equalsEpsilon),
+    o = t._shape;
+  if (((o = j.removeDuplicatesFromShape(o)), n.length < 2 || o.length < 3))
+    return;
+  V.computeWindingOrder2D(o) === $.CLOCKWISE && o.reverse();
+  let l = M.fromPoints(o, ne),
+    i = j.computePositions(n, o, l, t, !0);
+  return oe(i, o, l, t._vertexFormat);
+};
+var H = R;
+function ie(t, e) {
+  return (
+    _(e) && (t = H.unpack(t, e)),
+    (t._ellipsoid = f.clone(t._ellipsoid)),
+    H.createGeometry(t)
+  );
+}
+var Re = ie;
+export { Re as default };

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

@@ -0,0 +1,177 @@
+/**
+ * @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 w } from "./chunk-3JW36LZF.js";
+import { a as N, c as E } from "./chunk-K4ASOM65.js";
+import "./chunk-AMQUWUD4.js";
+import "./chunk-W23CU777.js";
+import "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import { a as v, b as G } from "./chunk-O5IJ3OGP.js";
+import { a as q } from "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as k } from "./chunk-P37AI2DW.js";
+import { a as O } from "./chunk-T6BE4RZK.js";
+import { b as A, c as R, d as S } from "./chunk-X5IHHI6X.js";
+import { d as C } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as b } from "./chunk-KZNJOCYU.js";
+import { a, c as _, d as s } from "./chunk-POASMU2N.js";
+import { a as D } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as d } from "./chunk-IUA6FAOZ.js";
+import { a as y } from "./chunk-UH2WFNTA.js";
+import { e as u } from "./chunk-PEYJTJPE.js";
+function W(o, i) {
+  let t = new O();
+  t.position = new S({
+    componentDatatype: b.DOUBLE,
+    componentsPerAttribute: 3,
+    values: o,
+  });
+  let e = i.length,
+    r = t.position.values.length / 3,
+    f = o.length / 3 / e,
+    p = k.createTypedArray(r, 2 * e * (f + 1)),
+    m,
+    n,
+    l = 0;
+  m = 0;
+  let h = m * e;
+  for (n = 0; n < e - 1; n++) ((p[l++] = n + h), (p[l++] = n + h + 1));
+  for (
+    p[l++] = e - 1 + h, p[l++] = h, m = f - 1, h = m * e, n = 0;
+    n < e - 1;
+    n++
+  )
+    ((p[l++] = n + h), (p[l++] = n + h + 1));
+  for (p[l++] = e - 1 + h, p[l++] = h, m = 0; m < f - 1; m++) {
+    let T = e * m,
+      U = T + e;
+    for (n = 0; n < e; n++) ((p[l++] = n + T), (p[l++] = n + U));
+  }
+  return new R({
+    attributes: t,
+    indices: k.createTypedArray(r, p),
+    boundingSphere: C.fromVertices(o),
+    primitiveType: A.LINES,
+  });
+}
+function g(o) {
+  o = d(o, d.EMPTY_OBJECT);
+  let i = o.polylinePositions,
+    t = o.shapePositions;
+  if (!u(i)) throw new y("options.polylinePositions is required.");
+  if (!u(t)) throw new y("options.shapePositions is required.");
+  ((this._positions = i),
+    (this._shape = t),
+    (this._ellipsoid = s.clone(d(o.ellipsoid, s.default))),
+    (this._cornerType = d(o.cornerType, N.ROUNDED)),
+    (this._granularity = d(o.granularity, D.RADIANS_PER_DEGREE)),
+    (this._workerName = "createPolylineVolumeOutlineGeometry"));
+  let e = 1 + i.length * a.packedLength;
+  ((e += 1 + t.length * _.packedLength),
+    (this.packedLength = e + s.packedLength + 2));
+}
+g.pack = function (o, i, t) {
+  if (!u(o)) throw new y("value is required");
+  if (!u(i)) throw new y("array is required");
+  t = d(t, 0);
+  let e,
+    r = o._positions,
+    c = r.length;
+  for (i[t++] = c, e = 0; e < c; ++e, t += a.packedLength) a.pack(r[e], i, t);
+  let f = o._shape;
+  for (c = f.length, i[t++] = c, e = 0; e < c; ++e, t += _.packedLength)
+    _.pack(f[e], i, t);
+  return (
+    s.pack(o._ellipsoid, i, t),
+    (t += s.packedLength),
+    (i[t++] = o._cornerType),
+    (i[t] = o._granularity),
+    i
+  );
+};
+var B = s.clone(s.UNIT_SPHERE),
+  P = {
+    polylinePositions: void 0,
+    shapePositions: void 0,
+    ellipsoid: B,
+    height: void 0,
+    cornerType: void 0,
+    granularity: void 0,
+  };
+g.unpack = function (o, i, t) {
+  if (!u(o)) throw new y("array is required");
+  i = d(i, 0);
+  let e,
+    r = o[i++],
+    c = new Array(r);
+  for (e = 0; e < r; ++e, i += a.packedLength) c[e] = a.unpack(o, i);
+  r = o[i++];
+  let f = new Array(r);
+  for (e = 0; e < r; ++e, i += _.packedLength) f[e] = _.unpack(o, i);
+  let p = s.unpack(o, i, B);
+  i += s.packedLength;
+  let m = o[i++],
+    n = o[i];
+  return u(t)
+    ? ((t._positions = c),
+      (t._shape = f),
+      (t._ellipsoid = s.clone(p, t._ellipsoid)),
+      (t._cornerType = m),
+      (t._granularity = n),
+      t)
+    : ((P.polylinePositions = c),
+      (P.shapePositions = f),
+      (P.cornerType = m),
+      (P.granularity = n),
+      new g(P));
+};
+var M = new w();
+g.createGeometry = function (o) {
+  let i = o._positions,
+    t = q(i, a.equalsEpsilon),
+    e = o._shape;
+  if (((e = E.removeDuplicatesFromShape(e)), t.length < 2 || e.length < 3))
+    return;
+  G.computeWindingOrder2D(e) === v.CLOCKWISE && e.reverse();
+  let r = w.fromPoints(e, M),
+    c = E.computePositions(t, e, r, o, !1);
+  return W(c, e);
+};
+var L = g;
+function j(o, i) {
+  return (
+    u(i) && (o = L.unpack(o, i)),
+    (o._ellipsoid = s.clone(o._ellipsoid)),
+    L.createGeometry(o)
+  );
+}
+var he = j;
+export { he as default };