/**
 * @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 tt } from "./chunk-BMHPVZ4H.js";
import { a as At } from "./chunk-EFZKO5RU.js";
import { a as yt } from "./chunk-QB3MDM4J.js";
import { a as G } from "./chunk-ILGBPNP6.js";
import { a as z } from "./chunk-HEEMUCG6.js";
import { a as at } from "./chunk-P37AI2DW.js";
import { a as ht } from "./chunk-T6BE4RZK.js";
import { b as mt, c as st, d as S } from "./chunk-X5IHHI6X.js";
import { a as dt, d as rt } from "./chunk-TMSETF7M.js";
import { f as it, h as bt } from "./chunk-7Z5IIKOJ.js";
import { a as F } from "./chunk-KZNJOCYU.js";
import { a, b as _t, c as W, d as v, e as R } from "./chunk-POASMU2N.js";
import { a as I } from "./chunk-R6KGAEF6.js";
import { a as T } from "./chunk-IUA6FAOZ.js";
import { a as nt, b as H } from "./chunk-UH2WFNTA.js";
import { e as K } from "./chunk-PEYJTJPE.js";
var et = new a(),
  pt = new a(),
  xt = new a(),
  wt = new a(),
  w = new W(),
  Mt = new R(),
  Vt = new R(),
  gt = new it(),
  Tt = new a(),
  Nt = new a(),
  Et = new a(),
  lt = new _t(),
  Pt = new a(),
  Ft = new W(),
  St = new W();
function Ot(o, e, t) {
  let n = e.vertexFormat,
    s = e.center,
    i = e.semiMajorAxis,
    r = e.semiMinorAxis,
    f = e.ellipsoid,
    h = e.stRotation,
    E = t ? (o.length / 3) * 2 : o.length / 3,
    g = e.shadowVolume,
    c = n.st ? new Float32Array(E * 2) : void 0,
    l = n.normal ? new Float32Array(E * 3) : void 0,
    A = n.tangent ? new Float32Array(E * 3) : void 0,
    x = n.bitangent ? new Float32Array(E * 3) : void 0,
    O = g ? new Float32Array(E * 3) : void 0,
    B = 0,
    b = Tt,
    M = Nt,
    d = Et,
    _ = new dt(f),
    L = _.project(f.cartesianToCartographic(s, lt), Pt),
    J = f.scaleToGeodeticSurface(s, et);
  f.geodeticSurfaceNormal(J, J);
  let Z = Mt,
    q = Vt;
  if (h !== 0) {
    let m = it.fromAxisAngle(J, h, gt);
    ((Z = R.fromQuaternion(m, Z)),
      (m = it.fromAxisAngle(J, -h, gt)),
      (q = R.fromQuaternion(m, q)));
  } else ((Z = R.clone(R.IDENTITY, Z)), (q = R.clone(R.IDENTITY, q)));
  let k = W.fromElements(
      Number.POSITIVE_INFINITY,
      Number.POSITIVE_INFINITY,
      Ft,
    ),
    Q = W.fromElements(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, St),
    j = o.length,
    y = t ? j : 0,
    p = (y / 3) * 2;
  for (let m = 0; m < j; m += 3) {
    let u = m + 1,
      N = m + 2,
      D = a.fromArray(o, m, et);
    if (n.st) {
      let P = R.multiplyByVector(Z, D, pt),
        C = _.project(f.cartesianToCartographic(P, lt), xt);
      (a.subtract(C, L, C),
        (w.x = (C.x + i) / (2 * i)),
        (w.y = (C.y + r) / (2 * r)),
        (k.x = Math.min(w.x, k.x)),
        (k.y = Math.min(w.y, k.y)),
        (Q.x = Math.max(w.x, Q.x)),
        (Q.y = Math.max(w.y, Q.y)),
        t && ((c[B + p] = w.x), (c[B + 1 + p] = w.y)),
        (c[B++] = w.x),
        (c[B++] = w.y));
    }
    (n.normal || n.tangent || n.bitangent || g) &&
      ((b = f.geodeticSurfaceNormal(D, b)),
      g && ((O[m + y] = -b.x), (O[u + y] = -b.y), (O[N + y] = -b.z)),
      (n.normal || n.tangent || n.bitangent) &&
        ((n.tangent || n.bitangent) &&
          ((M = a.normalize(a.cross(a.UNIT_Z, b, M), M)),
          R.multiplyByVector(q, M, M)),
        n.normal &&
          ((l[m] = b.x),
          (l[u] = b.y),
          (l[N] = b.z),
          t && ((l[m + y] = -b.x), (l[u + y] = -b.y), (l[N + y] = -b.z))),
        n.tangent &&
          ((A[m] = M.x),
          (A[u] = M.y),
          (A[N] = M.z),
          t && ((A[m + y] = -M.x), (A[u + y] = -M.y), (A[N + y] = -M.z))),
        n.bitangent &&
          ((d = a.normalize(a.cross(b, M, d), d)),
          (x[m] = d.x),
          (x[u] = d.y),
          (x[N] = d.z),
          t && ((x[m + y] = d.x), (x[u + y] = d.y), (x[N + y] = d.z)))));
  }
  if (n.st) {
    j = c.length;
    for (let m = 0; m < j; m += 2)
      ((c[m] = (c[m] - k.x) / (Q.x - k.x)),
        (c[m + 1] = (c[m + 1] - k.y) / (Q.y - k.y)));
  }
  let V = new ht();
  if (n.position) {
    let m = tt.raisePositionsToHeight(o, e, t);
    V.position = new S({
      componentDatatype: F.DOUBLE,
      componentsPerAttribute: 3,
      values: m,
    });
  }
  if (
    (n.st &&
      (V.st = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 2,
        values: c,
      })),
    n.normal &&
      (V.normal = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: l,
      })),
    n.tangent &&
      (V.tangent = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: A,
      })),
    n.bitangent &&
      (V.bitangent = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: x,
      })),
    g &&
      (V.extrudeDirection = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: O,
      })),
    t && K(e.offsetAttribute))
  ) {
    let m = new Uint8Array(E);
    if (e.offsetAttribute === G.TOP) m = m.fill(1, 0, E / 2);
    else {
      let u = e.offsetAttribute === G.NONE ? 0 : 1;
      m = m.fill(u);
    }
    V.applyOffset = new S({
      componentDatatype: F.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: m,
    });
  }
  return V;
}
function jt(o) {
  let e = new Array(12 * (o * (o + 1)) - 6),
    t = 0,
    n,
    s,
    i,
    r,
    f;
  for (n = 0, i = 1, r = 0; r < 3; r++)
    ((e[t++] = i++), (e[t++] = n), (e[t++] = i));
  for (r = 2; r < o + 1; ++r) {
    for (
      i = r * (r + 1) - 1,
        n = (r - 1) * r - 1,
        e[t++] = i++,
        e[t++] = n,
        e[t++] = i,
        s = 2 * r,
        f = 0;
      f < s - 1;
      ++f
    )
      ((e[t++] = i),
        (e[t++] = n++),
        (e[t++] = n),
        (e[t++] = i++),
        (e[t++] = n),
        (e[t++] = i));
    ((e[t++] = i++), (e[t++] = n), (e[t++] = i));
  }
  for (s = o * 2, ++i, ++n, r = 0; r < s - 1; ++r)
    ((e[t++] = i),
      (e[t++] = n++),
      (e[t++] = n),
      (e[t++] = i++),
      (e[t++] = n),
      (e[t++] = i));
  for (
    e[t++] = i,
      e[t++] = n++,
      e[t++] = n,
      e[t++] = i++,
      e[t++] = n++,
      e[t++] = n,
      ++n,
      r = o - 1;
    r > 1;
    --r
  ) {
    for (e[t++] = n++, e[t++] = n, e[t++] = i, s = 2 * r, f = 0; f < s - 1; ++f)
      ((e[t++] = i),
        (e[t++] = n++),
        (e[t++] = n),
        (e[t++] = i++),
        (e[t++] = n),
        (e[t++] = i));
    ((e[t++] = n++), (e[t++] = n++), (e[t++] = i++));
  }
  for (r = 0; r < 3; r++) ((e[t++] = n++), (e[t++] = n), (e[t++] = i));
  return e;
}
var X = new a();
function Dt(o) {
  let e = o.center;
  ((X = a.multiplyByScalar(
    o.ellipsoid.geodeticSurfaceNormal(e, X),
    o.height,
    X,
  )),
    (X = a.add(e, X, X)));
  let t = new rt(X, o.semiMajorAxis),
    n = tt.computeEllipsePositions(o, !0, !1),
    s = n.positions,
    i = n.numPts,
    r = Ot(s, o, !1),
    f = jt(i);
  return (
    (f = at.createTypedArray(s.length / 3, f)),
    { boundingSphere: t, attributes: r, indices: f }
  );
}
function vt(o, e) {
  let t = e.vertexFormat,
    n = e.center,
    s = e.semiMajorAxis,
    i = e.semiMinorAxis,
    r = e.ellipsoid,
    f = e.height,
    h = e.extrudedHeight,
    E = e.stRotation,
    g = (o.length / 3) * 2,
    c = new Float64Array(g * 3),
    l = t.st ? new Float32Array(g * 2) : void 0,
    A = t.normal ? new Float32Array(g * 3) : void 0,
    x = t.tangent ? new Float32Array(g * 3) : void 0,
    O = t.bitangent ? new Float32Array(g * 3) : void 0,
    B = e.shadowVolume,
    b = B ? new Float32Array(g * 3) : void 0,
    M = 0,
    d = Tt,
    _ = Nt,
    L = Et,
    J = new dt(r),
    Z = J.project(r.cartesianToCartographic(n, lt), Pt),
    q = r.scaleToGeodeticSurface(n, et);
  r.geodeticSurfaceNormal(q, q);
  let k = it.fromAxisAngle(q, E, gt),
    Q = R.fromQuaternion(k, Mt),
    j = W.fromElements(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Ft),
    y = W.fromElements(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, St),
    p = o.length,
    V = (p / 3) * 2;
  for (let u = 0; u < p; u += 3) {
    let N = u + 1,
      D = u + 2,
      P = a.fromArray(o, u, et),
      C;
    if (t.st) {
      let ot = R.multiplyByVector(Q, P, pt),
        $ = J.project(r.cartesianToCartographic(ot, lt), xt);
      (a.subtract($, Z, $),
        (w.x = ($.x + s) / (2 * s)),
        (w.y = ($.y + i) / (2 * i)),
        (j.x = Math.min(w.x, j.x)),
        (j.y = Math.min(w.y, j.y)),
        (y.x = Math.max(w.x, y.x)),
        (y.y = Math.max(w.y, y.y)),
        (l[M + V] = w.x),
        (l[M + 1 + V] = w.y),
        (l[M++] = w.x),
        (l[M++] = w.y));
    }
    ((P = r.scaleToGeodeticSurface(P, P)),
      (C = a.clone(P, pt)),
      (d = r.geodeticSurfaceNormal(P, d)),
      B && ((b[u + p] = -d.x), (b[N + p] = -d.y), (b[D + p] = -d.z)));
    let ct = a.multiplyByScalar(d, f, wt);
    if (
      ((P = a.add(P, ct, P)),
      (ct = a.multiplyByScalar(d, h, ct)),
      (C = a.add(C, ct, C)),
      t.position &&
        ((c[u + p] = C.x),
        (c[N + p] = C.y),
        (c[D + p] = C.z),
        (c[u] = P.x),
        (c[N] = P.y),
        (c[D] = P.z)),
      t.normal || t.tangent || t.bitangent)
    ) {
      L = a.clone(d, L);
      let ot = a.fromArray(o, (u + 3) % p, wt);
      a.subtract(ot, P, ot);
      let $ = a.subtract(C, P, xt);
      ((d = a.normalize(a.cross($, ot, d), d)),
        t.normal &&
          ((A[u] = d.x),
          (A[N] = d.y),
          (A[D] = d.z),
          (A[u + p] = d.x),
          (A[N + p] = d.y),
          (A[D + p] = d.z)),
        t.tangent &&
          ((_ = a.normalize(a.cross(L, d, _), _)),
          (x[u] = _.x),
          (x[N] = _.y),
          (x[D] = _.z),
          (x[u + p] = _.x),
          (x[u + 1 + p] = _.y),
          (x[u + 2 + p] = _.z)),
        t.bitangent &&
          ((O[u] = L.x),
          (O[N] = L.y),
          (O[D] = L.z),
          (O[u + p] = L.x),
          (O[N + p] = L.y),
          (O[D + p] = L.z)));
    }
  }
  if (t.st) {
    p = l.length;
    for (let u = 0; u < p; u += 2)
      ((l[u] = (l[u] - j.x) / (y.x - j.x)),
        (l[u + 1] = (l[u + 1] - j.y) / (y.y - j.y)));
  }
  let m = new ht();
  if (
    (t.position &&
      (m.position = new S({
        componentDatatype: F.DOUBLE,
        componentsPerAttribute: 3,
        values: c,
      })),
    t.st &&
      (m.st = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 2,
        values: l,
      })),
    t.normal &&
      (m.normal = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: A,
      })),
    t.tangent &&
      (m.tangent = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: x,
      })),
    t.bitangent &&
      (m.bitangent = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: O,
      })),
    B &&
      (m.extrudeDirection = new S({
        componentDatatype: F.FLOAT,
        componentsPerAttribute: 3,
        values: b,
      })),
    K(e.offsetAttribute))
  ) {
    let u = new Uint8Array(g);
    if (e.offsetAttribute === G.TOP) u = u.fill(1, 0, g / 2);
    else {
      let N = e.offsetAttribute === G.NONE ? 0 : 1;
      u = u.fill(N);
    }
    m.applyOffset = new S({
      componentDatatype: F.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: u,
    });
  }
  return m;
}
function zt(o) {
  let e = o.length / 3,
    t = at.createTypedArray(e, e * 6),
    n = 0;
  for (let s = 0; s < e; s++) {
    let i = s,
      r = s + e,
      f = (i + 1) % e,
      h = f + e;
    ((t[n++] = i),
      (t[n++] = r),
      (t[n++] = f),
      (t[n++] = f),
      (t[n++] = r),
      (t[n++] = h));
  }
  return t;
}
var ut = new rt(),
  ft = new rt();
function Bt(o) {
  let e = o.center,
    t = o.ellipsoid,
    n = o.semiMajorAxis,
    s = a.multiplyByScalar(t.geodeticSurfaceNormal(e, et), o.height, et);
  ((ut.center = a.add(e, s, ut.center)),
    (ut.radius = n),
    (s = a.multiplyByScalar(
      t.geodeticSurfaceNormal(e, s),
      o.extrudedHeight,
      s,
    )),
    (ft.center = a.add(e, s, ft.center)),
    (ft.radius = n));
  let i = tt.computeEllipsePositions(o, !0, !0),
    r = i.positions,
    f = i.numPts,
    h = i.outerPositions,
    E = rt.union(ut, ft),
    g = Ot(r, o, !0),
    c = jt(f),
    l = c.length;
  c.length = l * 2;
  let A = r.length / 3;
  for (let _ = 0; _ < l; _ += 3)
    ((c[_ + l] = c[_ + 2] + A),
      (c[_ + 1 + l] = c[_ + 1] + A),
      (c[_ + 2 + l] = c[_] + A));
  let x = at.createTypedArray((A * 2) / 3, c),
    O = new st({ attributes: g, indices: x, primitiveType: mt.TRIANGLES }),
    B = vt(h, o);
  c = zt(h);
  let b = at.createTypedArray((h.length * 2) / 3, c),
    M = new st({ attributes: B, indices: b, primitiveType: mt.TRIANGLES }),
    d = yt.combineInstances([new At({ geometry: O }), new At({ geometry: M })]);
  return {
    boundingSphere: E,
    attributes: d[0].attributes,
    indices: d[0].indices,
  };
}
function Ct(o, e, t, n, s, i, r) {
  let h = tt.computeEllipsePositions(
      {
        center: o,
        semiMajorAxis: e,
        semiMinorAxis: t,
        rotation: n,
        granularity: s,
      },
      !1,
      !0,
    ).outerPositions,
    E = h.length / 3,
    g = new Array(E);
  for (let l = 0; l < E; ++l) g[l] = a.fromArray(h, l * 3);
  let c = bt.fromCartesianArray(g, i, r);
  return (
    c.width > I.PI &&
      ((c.north = c.north > 0 ? I.PI_OVER_TWO - I.EPSILON7 : c.north),
      (c.south = c.south < 0 ? I.EPSILON7 - I.PI_OVER_TWO : c.south),
      (c.east = I.PI),
      (c.west = -I.PI)),
    c
  );
}
function U(o) {
  o = T(o, T.EMPTY_OBJECT);
  let e = o.center,
    t = T(o.ellipsoid, v.default),
    n = o.semiMajorAxis,
    s = o.semiMinorAxis,
    i = T(o.granularity, I.RADIANS_PER_DEGREE),
    r = T(o.vertexFormat, z.DEFAULT);
  if (
    (H.defined("options.center", e),
    H.typeOf.number("options.semiMajorAxis", n),
    H.typeOf.number("options.semiMinorAxis", s),
    n < s)
  )
    throw new nt(
      "semiMajorAxis must be greater than or equal to the semiMinorAxis.",
    );
  if (i <= 0) throw new nt("granularity must be greater than zero.");
  let f = T(o.height, 0),
    h = T(o.extrudedHeight, f);
  ((this._center = a.clone(e)),
    (this._semiMajorAxis = n),
    (this._semiMinorAxis = s),
    (this._ellipsoid = v.clone(t)),
    (this._rotation = T(o.rotation, 0)),
    (this._stRotation = T(o.stRotation, 0)),
    (this._height = Math.max(h, f)),
    (this._granularity = i),
    (this._vertexFormat = z.clone(r)),
    (this._extrudedHeight = Math.min(h, f)),
    (this._shadowVolume = T(o.shadowVolume, !1)),
    (this._workerName = "createEllipseGeometry"),
    (this._offsetAttribute = o.offsetAttribute),
    (this._rectangle = void 0),
    (this._textureCoordinateRotationPoints = void 0));
}
U.packedLength = a.packedLength + v.packedLength + z.packedLength + 9;
U.pack = function (o, e, t) {
  return (
    H.defined("value", o),
    H.defined("array", e),
    (t = T(t, 0)),
    a.pack(o._center, e, t),
    (t += a.packedLength),
    v.pack(o._ellipsoid, e, t),
    (t += v.packedLength),
    z.pack(o._vertexFormat, e, t),
    (t += z.packedLength),
    (e[t++] = o._semiMajorAxis),
    (e[t++] = o._semiMinorAxis),
    (e[t++] = o._rotation),
    (e[t++] = o._stRotation),
    (e[t++] = o._height),
    (e[t++] = o._granularity),
    (e[t++] = o._extrudedHeight),
    (e[t++] = o._shadowVolume ? 1 : 0),
    (e[t] = T(o._offsetAttribute, -1)),
    e
  );
};
var Rt = new a(),
  It = new v(),
  Lt = new z(),
  Y = {
    center: Rt,
    ellipsoid: It,
    vertexFormat: Lt,
    semiMajorAxis: void 0,
    semiMinorAxis: void 0,
    rotation: void 0,
    stRotation: void 0,
    height: void 0,
    granularity: void 0,
    extrudedHeight: void 0,
    shadowVolume: void 0,
    offsetAttribute: void 0,
  };
U.unpack = function (o, e, t) {
  (H.defined("array", o), (e = T(e, 0)));
  let n = a.unpack(o, e, Rt);
  e += a.packedLength;
  let s = v.unpack(o, e, It);
  e += v.packedLength;
  let i = z.unpack(o, e, Lt);
  e += z.packedLength;
  let r = o[e++],
    f = o[e++],
    h = o[e++],
    E = o[e++],
    g = o[e++],
    c = o[e++],
    l = o[e++],
    A = o[e++] === 1,
    x = o[e];
  return K(t)
    ? ((t._center = a.clone(n, t._center)),
      (t._ellipsoid = v.clone(s, t._ellipsoid)),
      (t._vertexFormat = z.clone(i, t._vertexFormat)),
      (t._semiMajorAxis = r),
      (t._semiMinorAxis = f),
      (t._rotation = h),
      (t._stRotation = E),
      (t._height = g),
      (t._granularity = c),
      (t._extrudedHeight = l),
      (t._shadowVolume = A),
      (t._offsetAttribute = x === -1 ? void 0 : x),
      t)
    : ((Y.height = g),
      (Y.extrudedHeight = l),
      (Y.granularity = c),
      (Y.stRotation = E),
      (Y.rotation = h),
      (Y.semiMajorAxis = r),
      (Y.semiMinorAxis = f),
      (Y.shadowVolume = A),
      (Y.offsetAttribute = x === -1 ? void 0 : x),
      new U(Y));
};
U.computeRectangle = function (o, e) {
  o = T(o, T.EMPTY_OBJECT);
  let t = o.center,
    n = T(o.ellipsoid, v.default),
    s = o.semiMajorAxis,
    i = o.semiMinorAxis,
    r = T(o.granularity, I.RADIANS_PER_DEGREE),
    f = T(o.rotation, 0);
  if (
    (H.defined("options.center", t),
    H.typeOf.number("options.semiMajorAxis", s),
    H.typeOf.number("options.semiMinorAxis", i),
    s < i)
  )
    throw new nt(
      "semiMajorAxis must be greater than or equal to the semiMinorAxis.",
    );
  if (r <= 0) throw new nt("granularity must be greater than zero.");
  return Ct(t, s, i, f, r, n, e);
};
U.createGeometry = function (o) {
  if (o._semiMajorAxis <= 0 || o._semiMinorAxis <= 0) return;
  let e = o._height,
    t = o._extrudedHeight,
    n = !I.equalsEpsilon(e, t, 0, I.EPSILON2);
  o._center = o._ellipsoid.scaleToGeodeticSurface(o._center, o._center);
  let s = {
      center: o._center,
      semiMajorAxis: o._semiMajorAxis,
      semiMinorAxis: o._semiMinorAxis,
      ellipsoid: o._ellipsoid,
      rotation: o._rotation,
      height: e,
      granularity: o._granularity,
      vertexFormat: o._vertexFormat,
      stRotation: o._stRotation,
    },
    i;
  if (n)
    ((s.extrudedHeight = t),
      (s.shadowVolume = o._shadowVolume),
      (s.offsetAttribute = o._offsetAttribute),
      (i = Bt(s)));
  else if (((i = Dt(s)), K(o._offsetAttribute))) {
    let r = i.attributes.position.values.length,
      f = o._offsetAttribute === G.NONE ? 0 : 1,
      h = new Uint8Array(r / 3).fill(f);
    i.attributes.applyOffset = new S({
      componentDatatype: F.UNSIGNED_BYTE,
      componentsPerAttribute: 1,
      values: h,
    });
  }
  return new st({
    attributes: i.attributes,
    indices: i.indices,
    primitiveType: mt.TRIANGLES,
    boundingSphere: i.boundingSphere,
    offsetAttribute: o._offsetAttribute,
  });
};
U.createShadowVolume = function (o, e, t) {
  let n = o._granularity,
    s = o._ellipsoid,
    i = e(n, s),
    r = t(n, s);
  return new U({
    center: o._center,
    semiMajorAxis: o._semiMajorAxis,
    semiMinorAxis: o._semiMinorAxis,
    ellipsoid: s,
    rotation: o._rotation,
    stRotation: o._stRotation,
    granularity: n,
    extrudedHeight: i,
    height: r,
    vertexFormat: z.POSITION_ONLY,
    shadowVolume: !0,
  });
};
function kt(o) {
  let e = -o._stRotation;
  if (e === 0) return [0, 0, 0, 1, 1, 0];
  let n = tt.computeEllipsePositions(
      {
        center: o._center,
        semiMajorAxis: o._semiMajorAxis,
        semiMinorAxis: o._semiMinorAxis,
        rotation: o._rotation,
        granularity: o._granularity,
      },
      !1,
      !0,
    ).outerPositions,
    s = n.length / 3,
    i = new Array(s);
  for (let h = 0; h < s; ++h) i[h] = a.fromArray(n, h * 3);
  let r = o._ellipsoid,
    f = o.rectangle;
  return st._textureCoordinateRotationPoints(i, e, r, f);
}
Object.defineProperties(U.prototype, {
  rectangle: {
    get: function () {
      return (
        K(this._rectangle) ||
          (this._rectangle = Ct(
            this._center,
            this._semiMajorAxis,
            this._semiMinorAxis,
            this._rotation,
            this._granularity,
            this._ellipsoid,
          )),
        this._rectangle
      );
    },
  },
  textureCoordinateRotationPoints: {
    get: function () {
      return (
        K(this._textureCoordinateRotationPoints) ||
          (this._textureCoordinateRotationPoints = kt(this)),
        this._textureCoordinateRotationPoints
      );
    },
  },
});
var de = U;
export { de as a };
