cesium-to-three 0.1.0

package/dist/arrow.js

@@ -0,0 +1,523 @@
+const St = 298.257223563, et = 1 / St, ht = 2 * et - et * et, ct = Math.PI / 180, lt = 180 / Math.PI, dt = 1e-9;
+function q(t, n) {
+  if (t.length === 0)
+    return [];
+  let e = 0, c = 0;
+  for (const o of t) {
+    if (!Number.isFinite(o[0]) || !Number.isFinite(o[1]))
+      return [];
+    e += o[0], c += o[1];
+  }
+  const s = 1 / t.length, a = e * s, r = c * s, u = r * ct, i = Math.sin(u), f = Math.cos(u), l = 1 - ht * i * i, _ = 6378137 / Math.sqrt(l), A = 6378137 * (1 - ht) / (l * Math.sqrt(l)), T = _ * f, d = A;
+  if (Math.abs(T) < 1e-6 || !Number.isFinite(T) || !Number.isFinite(d))
+    return [];
+  const h = t.map((o) => [
+    (o[0] - a) * ct * T,
+    (o[1] - r) * ct * d
+  ]);
+  return n(h).map((o) => [
+    a + o[0] / T * lt,
+    r + o[1] / d * lt
+  ]);
+}
+function y(t, n) {
+  const e = t[0] - n[0], c = t[1] - n[1], s = e * e + c * c;
+  return s > 0 ? Math.sqrt(s) : 0;
+}
+function At(t) {
+  let n = 0;
+  for (let e = 1; e < t.length; e++)
+    n += y(t[e - 1], t[e]);
+  return n;
+}
+function st(t) {
+  const n = At(t);
+  return n > 0 ? Math.pow(n, 0.99) : 0;
+}
+function ut(t, n) {
+  return [(t[0] + n[0]) / 2, (t[1] + n[1]) / 2];
+}
+function Rt(t, n) {
+  const e = t[0] - n[0], c = t[1] - n[1];
+  return Math.abs(e) < dt && Math.abs(c) < dt ? 0 : Math.atan2(c, e);
+}
+function Lt(t, n, e, c, s) {
+  if (!Number.isFinite(t[0]) || !Number.isFinite(t[1]) || !Number.isFinite(n[0]) || !Number.isFinite(n[1]) || !Number.isFinite(e) || !Number.isFinite(c))
+    return [n[0], n[1]];
+  const r = Rt(t, n) + e;
+  return [
+    n[0] + c * Math.cos(r),
+    n[1] + c * Math.sin(r)
+  ];
+}
+const Dt = 120, ft = 1e-10;
+function Mt(t) {
+  if (t.length === 0)
+    return [];
+  const n = [[t[0][0], t[0][1]]];
+  for (let e = 1; e < t.length; e++) {
+    const c = t[e], s = n[n.length - 1];
+    y(c, s) > ft && n.push([c[0], c[1]]);
+  }
+  if (n.length >= 2) {
+    const e = n[0], c = n[n.length - 1];
+    y(e, c) <= ft && n.pop();
+  }
+  return n;
+}
+function It(t) {
+  const n = t.length;
+  if (n < 3)
+    return 0;
+  let e = 0;
+  for (let c = 0; c < n; c++) {
+    const s = t[c], a = t[(c + 1) % n];
+    e += s[0] * a[1] - a[0] * s[1];
+  }
+  return e * 0.5;
+}
+function mt(t) {
+  if (It(t) < 0) {
+    const e = new Array(t.length);
+    for (let c = 0; c < t.length; c++) {
+      const s = t[t.length - 1 - c];
+      e[c] = [s[0], s[1]];
+    }
+    return e;
+  }
+  return t.map((e) => [e[0], e[1]]);
+}
+function Wt(t, n) {
+  const e = Math.max(Math.floor(n), 4);
+  if (t.length <= e)
+    return t.map((a) => [a[0], a[1]]);
+  const c = new Array(e), s = (t.length - 1) / (e - 1);
+  for (let a = 0; a < e; a++) {
+    const r = Math.round(a * s), u = Math.min(r, t.length - 1), i = t[u];
+    c[a] = [i[0], i[1]];
+  }
+  return c;
+}
+function Ht(t, n = Math.PI / 6) {
+  let e = t.map((r) => [r[0], r[1]]);
+  const c = Math.PI - n;
+  let s = !0, a = 0;
+  for (; s && e.length >= 4 && a < 1e3; ) {
+    a++, s = !1;
+    const r = [], u = e.length;
+    for (let i = 0; i < u; i++) {
+      const f = e[(i - 1 + u) % u], l = e[i], _ = e[(i + 1) % u], A = l[0] - f[0], T = l[1] - f[1], d = _[0] - l[0], h = _[1] - l[1], g = A * h - T * d, o = A * d + T * h;
+      if (Math.abs(Math.atan2(g, o)) > c) {
+        s = !0;
+        continue;
+      }
+      r.push([l[0], l[1]]);
+    }
+    e = r;
+  }
+  return e;
+}
+function J(t, n = Dt) {
+  const e = Mt(t);
+  if (e.length < 3)
+    return [];
+  const c = Ht(e);
+  if (c.length < 3)
+    return [];
+  const s = mt(c);
+  return Wt(s, n);
+}
+const kt = 0.1, yt = 0.2, wt = 0.25, xt = Math.PI / 8.5, Nt = Math.PI / 13;
+function gt(t, n, e = {}) {
+  return q(
+    [t, n],
+    (c) => Ct(
+      c[0],
+      c[1],
+      e
+    )
+  );
+}
+function Ct(t, n, e = {}) {
+  const c = e.tailWidthFactor ?? kt, s = e.neckWidthFactor ?? yt, a = e.headWidthFactor ?? wt, r = e.headAngleRadians ?? xt, u = e.neckAngleRadians ?? Nt, i = y(t, n);
+  if (i <= 0)
+    return [];
+  const f = st([t, n]);
+  if (f <= 0)
+    return [];
+  const l = f * c, _ = f * s, A = f * a, T = (n[0] - t[0]) / i, d = (n[1] - t[1]) / i, h = -d, g = T, o = Math.cos(u) * _, S = Math.sin(u) * _, E = Math.cos(r) * A, L = Math.sin(r) * A, M = [
+    t[0] - h * l,
+    t[1] - g * l
+  ], v = [
+    n[0] - T * o - h * S,
+    n[1] - d * o - g * S
+  ], H = [
+    n[0] - T * E - h * L,
+    n[1] - d * E - g * L
+  ], D = [
+    n[0] - T * E + h * L,
+    n[1] - d * E + g * L
+  ], w = [
+    n[0] - T * o + h * S,
+    n[1] - d * o + g * S
+  ], I = [
+    t[0] + h * l,
+    t[1] + g * l
+  ], x = [
+    [t[0], t[1]],
+    // 尾中(下方衔接 tailRight,上方衔接 tailLeft)
+    M,
+    v,
+    H,
+    [n[0], n[1]],
+    // 箭尖
+    D,
+    w,
+    I
+  ];
+  return J(x);
+}
+const Ot = 1.5, bt = 0.08, Ut = 0.1, vt = 0.13, Gt = Math.PI / 4, pt = Math.PI * 0.17741;
+function hn(t, n, e = {}) {
+  return q(
+    [t, n],
+    (c) => Bt(
+      c[0],
+      c[1],
+      e
+    )
+  );
+}
+function Bt(t, n, e = {}) {
+  const c = e.lengthScale ?? Ot, s = e.tailWidthFactor ?? bt, a = e.neckWidthFactor ?? Ut, r = e.headWidthFactor ?? vt, u = e.headAngleRadians ?? Gt, i = e.neckAngleRadians ?? pt, f = y(t, n);
+  if (f <= 0)
+    return [];
+  const l = st([t, n]) * c;
+  if (l <= 0)
+    return [];
+  const _ = l * s, A = l * a, T = l * r, d = (n[0] - t[0]) / f, h = (n[1] - t[1]) / f, g = -h, o = d, S = Math.cos(i) * A, E = Math.sin(i) * A, L = Math.cos(u) * T, M = Math.sin(u) * T, v = [
+    t[0] - g * _,
+    t[1] - o * _
+  ], H = [
+    n[0] - d * S - g * E,
+    n[1] - h * S - o * E
+  ], D = [
+    n[0] - d * L - g * M,
+    n[1] - h * L - o * M
+  ], w = [
+    n[0] - d * L + g * M,
+    n[1] - h * L + o * M
+  ], I = [
+    n[0] - d * S + g * E,
+    n[1] - h * S + o * E
+  ], x = [
+    t[0] + g * _,
+    t[1] + o * _
+  ], k = [
+    [t[0], t[1]],
+    v,
+    H,
+    D,
+    [n[0], n[1]],
+    w,
+    I,
+    x
+  ];
+  return J(k);
+}
+function Tt(t, n) {
+  if (t.length < 2)
+    return t.map((A) => [A[0], A[1]]);
+  if (t.length === 2)
+    return Yt(t[0], t[1], n);
+  const e = t[0], c = t[1], s = [
+    2 * e[0] - c[0],
+    2 * e[1] - c[1]
+  ], a = t[t.length - 1], r = t[t.length - 2], u = [
+    2 * a[0] - r[0],
+    2 * a[1] - r[1]
+  ], i = [s, ...t, u], f = [], l = Math.max(Math.floor(n), 1), _ = t.length - 1;
+  for (let A = 0; A < _; A++) {
+    const T = i[A], d = i[A + 1], h = i[A + 2], g = i[A + 3], o = 1e-12, S = 0, E = S + Math.max(Math.pow(y(T, d), 0.5), o), L = E + Math.max(Math.pow(y(d, h), 0.5), o), M = L + Math.max(Math.pow(y(h, g), 0.5), o), H = A === 0 ? 0 : 1, w = A === _ - 1 ? l + 1 : l;
+    for (let I = H; I < w; I++) {
+      const x = E + (L - E) * (I / l);
+      f.push(Xt(T, d, h, g, S, E, L, M, x));
+    }
+  }
+  return f;
+}
+function Xt(t, n, e, c, s, a, r, u, i) {
+  const f = V(t, n, (i - s) / (a - s)), l = V(n, e, (i - a) / (r - a)), _ = V(e, c, (i - r) / (u - r)), A = V(f, l, (i - s) / (r - s)), T = V(l, _, (i - a) / (u - a));
+  return V(A, T, (i - a) / (r - a));
+}
+function V(t, n, e) {
+  return [
+    t[0] + (n[0] - t[0]) * e,
+    t[1] + (n[1] - t[1]) * e
+  ];
+}
+function Yt(t, n, e) {
+  const c = Math.max(Math.floor(e), 1), s = new Array(c + 1);
+  for (let a = 0; a <= c; a++) {
+    const r = a / c;
+    s[a] = [
+      t[0] + (n[0] - t[0]) * r,
+      t[1] + (n[1] - t[1]) * r
+    ];
+  }
+  return s;
+}
+function _t(t) {
+  const n = t.length, e = new Array(n);
+  if (n === 0)
+    return e;
+  if (n === 1)
+    return e[0] = [1, 0], e;
+  for (let c = 0; c < n; c++) {
+    const s = c > 0 ? c - 1 : c, a = c < n - 1 ? c + 1 : c, r = t[a][0] - t[s][0], u = t[a][1] - t[s][1], i = Math.sqrt(r * r + u * u);
+    i > 0 ? e[c] = [r / i, u / i] : e[c] = [1, 0];
+  }
+  return e;
+}
+function Et(t, n) {
+  const e = t.length;
+  if (e < 2)
+    return null;
+  if (n <= 0)
+    return {
+      segmentIdx: e - 2,
+      localT: 1,
+      point: [t[e - 1][0], t[e - 1][1]]
+    };
+  let c = 0;
+  for (let s = e - 1; s > 0; s--) {
+    const a = y(t[s], t[s - 1]);
+    if (c + a >= n) {
+      const r = n - c, u = a > 0 ? 1 - r / a : 1, i = t[s - 1][0], f = t[s - 1][1], l = t[s][0], _ = t[s][1];
+      return {
+        segmentIdx: s - 1,
+        localT: u,
+        point: [
+          i + (l - i) * u,
+          f + (_ - f) * u
+        ]
+      };
+    }
+    c += a;
+  }
+  return null;
+}
+const Vt = 0.28, $t = 0.55, Kt = 0.85, qt = 0.22, Jt = 1.25, zt = 12;
+function ln(t, n = {}) {
+  return q(
+    t,
+    (e) => Qt(e, n)
+  );
+}
+function Qt(t, n = {}) {
+  if (t.length < 2)
+    return [];
+  if (t.length === 2)
+    return gt(t[0], t[1]);
+  const e = Ft(t, n);
+  if (!e)
+    return [];
+  const c = [
+    ...e.leftSide,
+    // tailLeft → ... → neckLeft
+    e.headLeft,
+    // 左翼尖
+    e.tip,
+    // 箭尖
+    e.headRight,
+    // 右翼尖
+    ...e.rightSide.slice().reverse()
+    // neckRight → ... → tailRight
+  ];
+  return J(c);
+}
+function Ft(t, n) {
+  const e = n.headHeightFactor ?? Vt, c = n.headWidthFactor ?? $t, s = n.neckHeightFactor ?? Kt, a = n.neckWidthFactor ?? qt, r = n.headTailFactor ?? Jt, u = n.bodySmoothingSegments ?? zt, i = ut(t[0], t[1]), f = t[2][0] - i[0], l = t[2][1] - i[1], _ = t[0][0] - i[0], A = t[0][1] - i[1], T = f * A - l * _;
+  let d = t[0], h = t[1];
+  T < 0 && (d = t[1], h = t[0]);
+  const g = ut(d, h), o = [g];
+  for (let R = 2; R < t.length; R++)
+    o.push(t[R]);
+  if (o.length < 2)
+    return null;
+  const S = Tt(
+    o,
+    u
+  );
+  if (S.length < 2)
+    return null;
+  const E = y(d, h), L = st(o), M = [
+    o[o.length - 1][0],
+    o[o.length - 1][1]
+  ], v = o[o.length - 2], H = y(M, v);
+  let D = L * e;
+  if (D > E * r && (D = E * r), D > H && (D = H), D <= 0)
+    return null;
+  const w = D * s, I = D * c, x = D * a, k = Et(S, w);
+  if (k === null)
+    return null;
+  const m = [];
+  for (let R = 0; R <= k.segmentIdx; R++)
+    m.push([S[R][0], S[R][1]]);
+  const z = S[k.segmentIdx][0], Q = S[k.segmentIdx][1], $ = k.point[0] - z, j = k.point[1] - Q;
+  if ($ * $ + j * j > 1e-24 && m.push([k.point[0], k.point[1]]), m.length < 2)
+    return null;
+  const Y = _t(m), P = E / 2, N = m.length - 1, F = new Array(m.length), G = new Array(m.length);
+  for (let R = 0; R <= N; R++) {
+    const Z = N > 0 ? R / N : 0;
+    let U;
+    R === N ? U = x : U = P * (1 - Z) + x * Z;
+    const tt = Y[R][0], at = -Y[R][1], ot = tt, it = m[R][0], rt = m[R][1];
+    F[R] = [it + at * U, rt + ot * U], G[R] = [it - at * U, rt - ot * U];
+  }
+  F[0] = [d[0], d[1]], G[0] = [h[0], h[1]];
+  const W = Y[N][0], p = -Y[N][1], C = W, O = m[N][0], b = m[N][1], B = [
+    O + p * I,
+    b + C * I
+  ], X = [
+    O - p * I,
+    b - C * I
+  ];
+  return {
+    leftSide: F,
+    rightSide: G,
+    headLeft: B,
+    headRight: X,
+    tip: M,
+    tailLeft: [d[0], d[1]],
+    tailRight: [h[0], h[1]],
+    midTail: [g[0], g[1]],
+    spineSecond: [o[1][0], o[1][1]],
+    spineBaseLen: L
+  };
+}
+const jt = 0.08, Zt = 0.7;
+function dn(t, n = {}) {
+  return q(
+    t,
+    (e) => Pt(e, n)
+  );
+}
+function Pt(t, n = {}) {
+  if (t.length < 2)
+    return [];
+  if (t.length === 2)
+    return gt(t[0], t[1]);
+  const e = Ft(t, n);
+  if (!e)
+    return [];
+  const c = n.tailWidthFactor ?? jt, s = n.swallowtailFactor ?? Zt, a = e.spineBaseLen * c * s, r = Lt(
+    e.spineSecond,
+    e.midTail,
+    0,
+    a
+  ), u = [
+    ...e.leftSide,
+    // tailLeft → ... → neckLeft
+    e.headLeft,
+    // 左翼尖
+    e.tip,
+    // 箭尖
+    e.headRight,
+    // 右翼尖
+    ...e.rightSide.slice().reverse(),
+    // neckRight → ... → tailRight
+    r
+    // 燕尾凹口顶点
+  ];
+  return J(u);
+}
+const tn = 0.05, nn = 0.16, en = 0.18, cn = 0.4, sn = 16, an = 0, on = 0.6;
+function un(t, n = {}) {
+  return q(
+    t,
+    (e) => rn(e, n)
+  );
+}
+function rn(t, n = {}) {
+  if (t.length < 2)
+    return [];
+  const e = n.bodyWidthFactor ?? tn, c = n.headWidthFactor ?? nn, s = n.headLengthFactor ?? en, a = n.neckWidthRelativeToHead ?? cn, r = n.curveSmoothingSegments ?? sn, u = n.bodyTaperRatio ?? an, i = Tt(
+    t,
+    r
+  );
+  if (i.length < 2)
+    return [];
+  const f = At(i);
+  if (f <= 0)
+    return [];
+  const l = f * e / 2, _ = f * c / 2, A = _ * a, T = Math.min(
+    f * s,
+    f * on
+  ), d = Et(i, T);
+  if (d === null)
+    return [];
+  const h = i.slice(0, d.segmentIdx + 1).map((F) => [F[0], F[1]]);
+  if (h.push(d.point), h.length < 2)
+    return [];
+  const g = _t(h), o = h.length - 1, S = 0.5;
+  let E = 1 / 0;
+  for (let F = 1; F < o; F++) {
+    const G = h[F - 1], W = h[F], K = h[F + 1], p = W[0] - G[0], C = W[1] - G[1], O = K[0] - W[0], b = K[1] - W[1], B = Math.hypot(p, C), X = Math.hypot(O, b);
+    if (B < 1e-9 || X < 1e-9)
+      continue;
+    const R = p * b - C * O, Z = p * O + C * b, U = Math.abs(Math.atan2(R, Z)), tt = (B + X) * 0.5;
+    if (U < 1e-9)
+      continue;
+    const nt = tt / U;
+    nt < E && (E = nt);
+  }
+  let L = 1 / 0;
+  Number.isFinite(E) && (L = E * S);
+  let M = 1;
+  l > L && l > 0 && (M = L / l);
+  const v = l * M, H = A * M, D = _ * M, w = new Array(h.length), I = new Array(h.length);
+  for (let F = 0; F < h.length; F++) {
+    const G = o > 0 ? F / o : 0;
+    let W;
+    if (F === o)
+      W = H;
+    else {
+      const X = G * u;
+      W = v * (1 - X) + H * X;
+    }
+    const K = g[F][0], C = -g[F][1], O = K, b = h[F][0], B = h[F][1];
+    w[F] = [b + C * W, B + O * W], I[F] = [b - C * W, B - O * W];
+  }
+  const x = g[o][0], m = -g[o][1], z = x, Q = d.point[0], $ = d.point[1], j = [
+    Q + m * D,
+    $ + z * D
+  ], Y = [
+    Q - m * D,
+    $ - z * D
+  ], P = [
+    t[t.length - 1][0],
+    t[t.length - 1][1]
+  ], N = [
+    ...w,
+    // tailLeft → neckLeft
+    j,
+    // 翼尖
+    P,
+    // 箭尖
+    Y,
+    // 翼尖
+    ...I.slice().reverse()
+    // neckRight → tailRight
+  ];
+  return J(N);
+}
+export {
+  Dt as ARROW_OUTPUT_MAX_VERTICES,
+  hn as createAssaultDirectionArrow,
+  ln as createAttackArrow,
+  un as createCurvedArrow,
+  gt as createFineArrow,
+  dn as createSwallowtailAttackArrow
+};
+//# sourceMappingURL=arrow.js.map