create-swdg-frontend 0.1.0

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

@@ -0,0 +1,293 @@
+/**
+ * @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 et } from "./chunk-3JW36LZF.js";
+import { a as U } from "./chunk-ED3TLP6D.js";
+import "./chunk-Q6L7X3LP.js";
+import { a as y } from "./chunk-HSWA4OEL.js";
+import "./chunk-ATPDRNKI.js";
+import { a as I } from "./chunk-EFZKO5RU.js";
+import { a as $ } from "./chunk-QB3MDM4J.js";
+import "./chunk-ABGXSJNX.js";
+import "./chunk-DQO6B4EQ.js";
+import { a as u } from "./chunk-HEEMUCG6.js";
+import "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import { b as ot } from "./chunk-O5IJ3OGP.js";
+import { a as tt } from "./chunk-RXTBM4OI.js";
+import "./chunk-FYOYUPXG.js";
+import "./chunk-TAMCUKAR.js";
+import "./chunk-PDMQLSBL.js";
+import { a as J } from "./chunk-P37AI2DW.js";
+import { a as X } from "./chunk-T6BE4RZK.js";
+import { b as W, c as Y, d as z } from "./chunk-X5IHHI6X.js";
+import { d as K } from "./chunk-TMSETF7M.js";
+import { f as Q } from "./chunk-7Z5IIKOJ.js";
+import { a as N } from "./chunk-KZNJOCYU.js";
+import { a as i, c as x, d as m, e as P } from "./chunk-POASMU2N.js";
+import { a as q } from "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as f } from "./chunk-IUA6FAOZ.js";
+import { b as B } from "./chunk-UH2WFNTA.js";
+import { e as g } from "./chunk-PEYJTJPE.js";
+var st = new i(),
+  at = new et(),
+  pt = new x(),
+  lt = new x(),
+  mt = new i(),
+  ft = new i(),
+  ut = new i(),
+  V = new i(),
+  yt = new i(),
+  ht = new i(),
+  nt = new Q(),
+  dt = new P(),
+  gt = new P(),
+  Pt = new i();
+function wt(e, t, o, a, h, A, r, n, p) {
+  let b = e.positions,
+    c = ot.triangulate(e.positions2D, e.holes);
+  c.length < 3 && (c = [0, 1, 2]);
+  let w = J.createTypedArray(b.length, c.length);
+  w.set(c);
+  let D = dt;
+  if (a !== 0) {
+    let d = Q.fromAxisAngle(r, a, nt);
+    if (((D = P.fromQuaternion(d, D)), t.tangent || t.bitangent)) {
+      d = Q.fromAxisAngle(r, -a, nt);
+      let G = P.fromQuaternion(d, gt);
+      ((n = i.normalize(P.multiplyByVector(G, n, n), n)),
+        t.bitangent && (p = i.normalize(i.cross(r, n, p), p)));
+    }
+  } else D = P.clone(P.IDENTITY, D);
+  let j = lt;
+  t.st && ((j.x = o.x), (j.y = o.y));
+  let k = b.length,
+    C = k * 3,
+    L = new Float64Array(C),
+    T = t.normal ? new Float32Array(C) : void 0,
+    R = t.tangent ? new Float32Array(C) : void 0,
+    S = t.bitangent ? new Float32Array(C) : void 0,
+    H = t.st ? new Float32Array(k * 2) : void 0,
+    M = 0,
+    F = 0,
+    l = 0,
+    O = 0,
+    s = 0;
+  for (let d = 0; d < k; d++) {
+    let G = b[d];
+    if (((L[M++] = G.x), (L[M++] = G.y), (L[M++] = G.z), t.st))
+      if (g(h) && h.positions.length === k)
+        ((H[s++] = h.positions[d].x), (H[s++] = h.positions[d].y));
+      else {
+        let it = P.multiplyByVector(D, G, st),
+          v = A(it, pt);
+        x.subtract(v, j, v);
+        let rt = q.clamp(v.x / o.width, 0, 1),
+          ct = q.clamp(v.y / o.height, 0, 1);
+        ((H[s++] = rt), (H[s++] = ct));
+      }
+    (t.normal && ((T[F++] = r.x), (T[F++] = r.y), (T[F++] = r.z)),
+      t.tangent && ((R[O++] = n.x), (R[O++] = n.y), (R[O++] = n.z)),
+      t.bitangent && ((S[l++] = p.x), (S[l++] = p.y), (S[l++] = p.z)));
+  }
+  let _ = new X();
+  return (
+    t.position &&
+      (_.position = new z({
+        componentDatatype: N.DOUBLE,
+        componentsPerAttribute: 3,
+        values: L,
+      })),
+    t.normal &&
+      (_.normal = new z({
+        componentDatatype: N.FLOAT,
+        componentsPerAttribute: 3,
+        values: T,
+      })),
+    t.tangent &&
+      (_.tangent = new z({
+        componentDatatype: N.FLOAT,
+        componentsPerAttribute: 3,
+        values: R,
+      })),
+    t.bitangent &&
+      (_.bitangent = new z({
+        componentDatatype: N.FLOAT,
+        componentsPerAttribute: 3,
+        values: S,
+      })),
+    t.st &&
+      (_.st = new z({
+        componentDatatype: N.FLOAT,
+        componentsPerAttribute: 2,
+        values: H,
+      })),
+    new Y({ attributes: _, indices: w, primitiveType: W.TRIANGLES })
+  );
+}
+function E(e) {
+  e = f(e, f.EMPTY_OBJECT);
+  let t = e.polygonHierarchy,
+    o = e.textureCoordinates;
+  B.defined("options.polygonHierarchy", t);
+  let a = f(e.vertexFormat, u.DEFAULT);
+  ((this._vertexFormat = u.clone(a)),
+    (this._polygonHierarchy = t),
+    (this._stRotation = f(e.stRotation, 0)),
+    (this._ellipsoid = m.clone(f(e.ellipsoid, m.default))),
+    (this._workerName = "createCoplanarPolygonGeometry"),
+    (this._textureCoordinates = o),
+    (this.packedLength =
+      y.computeHierarchyPackedLength(t, i) +
+      u.packedLength +
+      m.packedLength +
+      (g(o) ? y.computeHierarchyPackedLength(o, x) : 1) +
+      2));
+}
+E.fromPositions = function (e) {
+  ((e = f(e, f.EMPTY_OBJECT)), B.defined("options.positions", e.positions));
+  let t = {
+    polygonHierarchy: { positions: e.positions },
+    vertexFormat: e.vertexFormat,
+    stRotation: e.stRotation,
+    ellipsoid: e.ellipsoid,
+    textureCoordinates: e.textureCoordinates,
+  };
+  return new E(t);
+};
+E.pack = function (e, t, o) {
+  return (
+    B.typeOf.object("value", e),
+    B.defined("array", t),
+    (o = f(o, 0)),
+    (o = y.packPolygonHierarchy(e._polygonHierarchy, t, o, i)),
+    m.pack(e._ellipsoid, t, o),
+    (o += m.packedLength),
+    u.pack(e._vertexFormat, t, o),
+    (o += u.packedLength),
+    (t[o++] = e._stRotation),
+    g(e._textureCoordinates)
+      ? (o = y.packPolygonHierarchy(e._textureCoordinates, t, o, x))
+      : (t[o++] = -1),
+    (t[o++] = e.packedLength),
+    t
+  );
+};
+var _t = m.clone(m.UNIT_SPHERE),
+  At = new u(),
+  bt = { polygonHierarchy: {} };
+E.unpack = function (e, t, o) {
+  (B.defined("array", e), (t = f(t, 0)));
+  let a = y.unpackPolygonHierarchy(e, t, i);
+  ((t = a.startingIndex), delete a.startingIndex);
+  let h = m.unpack(e, t, _t);
+  t += m.packedLength;
+  let A = u.unpack(e, t, At);
+  t += u.packedLength;
+  let r = e[t++],
+    n = e[t] === -1 ? void 0 : y.unpackPolygonHierarchy(e, t, x);
+  g(n) ? ((t = n.startingIndex), delete n.startingIndex) : t++;
+  let p = e[t++];
+  return (
+    g(o) || (o = new E(bt)),
+    (o._polygonHierarchy = a),
+    (o._ellipsoid = m.clone(h, o._ellipsoid)),
+    (o._vertexFormat = u.clone(A, o._vertexFormat)),
+    (o._stRotation = r),
+    (o._textureCoordinates = n),
+    (o.packedLength = p),
+    o
+  );
+};
+E.createGeometry = function (e) {
+  let t = e._vertexFormat,
+    o = e._polygonHierarchy,
+    a = e._stRotation,
+    h = e._textureCoordinates,
+    A = g(h),
+    r = o.positions;
+  if (((r = tt(r, i.equalsEpsilon, !0)), r.length < 3)) return;
+  let n = mt,
+    p = ft,
+    b = ut,
+    c = yt,
+    w = ht;
+  if (!U.computeProjectTo2DArguments(r, V, c, w)) return;
+  if (
+    ((n = i.cross(c, w, n)),
+    (n = i.normalize(n, n)),
+    !i.equalsEpsilon(V, i.ZERO, q.EPSILON6))
+  ) {
+    let s = e._ellipsoid.geodeticSurfaceNormal(V, Pt);
+    i.dot(n, s) < 0 && ((n = i.negate(n, n)), (c = i.negate(c, c)));
+  }
+  let j = U.createProjectPointsTo2DFunction(V, c, w),
+    k = U.createProjectPointTo2DFunction(V, c, w);
+  (t.tangent && (p = i.clone(c, p)), t.bitangent && (b = i.clone(w, b)));
+  let C = y.polygonsFromHierarchy(o, A, j, !1),
+    L = C.hierarchy,
+    T = C.polygons,
+    R = function (s) {
+      return s;
+    },
+    S = A ? y.polygonsFromHierarchy(h, !0, R, !1).polygons : void 0;
+  if (L.length === 0) return;
+  r = L[0].outerRing;
+  let H = K.fromPoints(r),
+    M = y.computeBoundingRectangle(n, k, r, a, at),
+    F = [];
+  for (let s = 0; s < T.length; s++) {
+    let _ = new I({
+      geometry: wt(T[s], t, M, a, A ? S[s] : void 0, k, n, p, b),
+    });
+    F.push(_);
+  }
+  let l = $.combineInstances(F)[0];
+  ((l.attributes.position.values = new Float64Array(
+    l.attributes.position.values,
+  )),
+    (l.indices = J.createTypedArray(
+      l.attributes.position.values.length / 3,
+      l.indices,
+    )));
+  let O = l.attributes;
+  return (
+    t.position || delete O.position,
+    new Y({
+      attributes: O,
+      indices: l.indices,
+      primitiveType: l.primitiveType,
+      boundingSphere: H,
+    })
+  );
+};
+var Z = E;
+function kt(e, t) {
+  return (g(t) && (e = Z.unpack(e, t)), Z.createGeometry(e));
+}
+var Xt = kt;
+export { Xt as default };

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

@@ -0,0 +1,143 @@
+/**
+ * @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 T } from "./chunk-ED3TLP6D.js";
+import "./chunk-Q6L7X3LP.js";
+import { a as f } from "./chunk-HSWA4OEL.js";
+import "./chunk-ATPDRNKI.js";
+import { a as G } from "./chunk-EFZKO5RU.js";
+import { a as C } from "./chunk-QB3MDM4J.js";
+import "./chunk-ABGXSJNX.js";
+import "./chunk-DQO6B4EQ.js";
+import "./chunk-KF5NF354.js";
+import "./chunk-4WRMLZA7.js";
+import "./chunk-O5IJ3OGP.js";
+import { a as L } from "./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 O } from "./chunk-T6BE4RZK.js";
+import { b, c as d, d as k } from "./chunk-X5IHHI6X.js";
+import { d as P } from "./chunk-TMSETF7M.js";
+import "./chunk-7Z5IIKOJ.js";
+import { a as H } from "./chunk-KZNJOCYU.js";
+import { a as l, d as g } from "./chunk-POASMU2N.js";
+import "./chunk-R6KGAEF6.js";
+import "./chunk-3C7WC463.js";
+import "./chunk-II4VNKYR.js";
+import { a as c } from "./chunk-IUA6FAOZ.js";
+import { b as a } from "./chunk-UH2WFNTA.js";
+import { e as u } from "./chunk-PEYJTJPE.js";
+function E(o) {
+  let e = o.length,
+    t = new Float64Array(e * 3),
+    r = w.createTypedArray(e, e * 2),
+    i = 0,
+    s = 0;
+  for (let n = 0; n < e; n++) {
+    let p = o[n];
+    ((t[i++] = p.x),
+      (t[i++] = p.y),
+      (t[i++] = p.z),
+      (r[s++] = n),
+      (r[s++] = (n + 1) % e));
+  }
+  let y = new O({
+    position: new k({
+      componentDatatype: H.DOUBLE,
+      componentsPerAttribute: 3,
+      values: t,
+    }),
+  });
+  return new d({ attributes: y, indices: r, primitiveType: b.LINES });
+}
+function m(o) {
+  o = c(o, c.EMPTY_OBJECT);
+  let e = o.polygonHierarchy;
+  (a.defined("options.polygonHierarchy", e),
+    (this._polygonHierarchy = e),
+    (this._workerName = "createCoplanarPolygonOutlineGeometry"),
+    (this.packedLength = f.computeHierarchyPackedLength(e, l) + 1));
+}
+m.fromPositions = function (o) {
+  ((o = c(o, c.EMPTY_OBJECT)), a.defined("options.positions", o.positions));
+  let e = { polygonHierarchy: { positions: o.positions } };
+  return new m(e);
+};
+m.pack = function (o, e, t) {
+  return (
+    a.typeOf.object("value", o),
+    a.defined("array", e),
+    (t = c(t, 0)),
+    (t = f.packPolygonHierarchy(o._polygonHierarchy, e, t, l)),
+    (e[t] = o.packedLength),
+    e
+  );
+};
+var v = { polygonHierarchy: {} };
+m.unpack = function (o, e, t) {
+  (a.defined("array", o), (e = c(e, 0)));
+  let r = f.unpackPolygonHierarchy(o, e, l);
+  ((e = r.startingIndex), delete r.startingIndex);
+  let i = o[e];
+  return (
+    u(t) || (t = new m(v)),
+    (t._polygonHierarchy = r),
+    (t.packedLength = i),
+    t
+  );
+};
+m.createGeometry = function (o) {
+  let e = o._polygonHierarchy,
+    t = e.positions;
+  if (((t = L(t, l.equalsEpsilon, !0)), t.length < 3 || !T.validOutline(t)))
+    return;
+  let i = f.polygonOutlinesFromHierarchy(e, !1);
+  if (i.length === 0) return;
+  let s = [];
+  for (let p = 0; p < i.length; p++) {
+    let _ = new G({ geometry: E(i[p]) });
+    s.push(_);
+  }
+  let y = C.combineInstances(s)[0],
+    n = P.fromPoints(e.positions);
+  return new d({
+    attributes: y.attributes,
+    indices: y.indices,
+    primitiveType: y.primitiveType,
+    boundingSphere: n,
+  });
+};
+var h = m;
+function A(o, e) {
+  return (
+    u(e) && (o = h.unpack(o, e)),
+    (o._ellipsoid = g.clone(o._ellipsoid)),
+    h.createGeometry(o)
+  );
+}
+var Z = A;
+export { Z as default };