/**
 * @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 Ct, b as vt } from "./chunk-CV7DLCWG.js";
import { a as Mt } from "./chunk-PXCJYT2S.js";
import { a as z } from "./chunk-SB224QGV.js";
import "./chunk-ABGXSJNX.js";
import { a as Wt } from "./chunk-4WRMLZA7.js";
import { a as X } from "./chunk-P37AI2DW.js";
import "./chunk-TMSETF7M.js";
import { b as U, g as bt, h as At } from "./chunk-7Z5IIKOJ.js";
import "./chunk-KZNJOCYU.js";
import { a as P, b as wt, c as lt, d as pt } from "./chunk-POASMU2N.js";
import { a as f } from "./chunk-R6KGAEF6.js";
import "./chunk-3C7WC463.js";
import "./chunk-II4VNKYR.js";
import "./chunk-IUA6FAOZ.js";
import { a as m } from "./chunk-UH2WFNTA.js";
import { e as w } from "./chunk-PEYJTJPE.js";
function T() {
  m.throwInstantiationError();
}
Object.defineProperties(T.prototype, {
  errorEvent: { get: m.throwInstantiationError },
  credit: { get: m.throwInstantiationError },
  tilingScheme: { get: m.throwInstantiationError },
  hasWaterMask: { get: m.throwInstantiationError },
  hasVertexNormals: { get: m.throwInstantiationError },
  availability: { get: m.throwInstantiationError },
});
var Ot = [];
T.getRegularGridIndices = function (t, n) {
  if (t * n >= f.FOUR_GIGABYTES)
    throw new m(
      "The total number of vertices (width * height) must be less than 4,294,967,296.",
    );
  let o = Ot[t];
  w(o) || (Ot[t] = o = []);
  let e = o[n];
  return (
    w(e) ||
      (t * n < f.SIXTY_FOUR_KILOBYTES
        ? (e = o[n] = new Uint16Array((t - 1) * (n - 1) * 6))
        : (e = o[n] = new Uint32Array((t - 1) * (n - 1) * 6)),
      Pt(t, n, e, 0)),
    e
  );
};
var Gt = [];
T.getRegularGridIndicesAndEdgeIndices = function (t, n) {
  if (t * n >= f.FOUR_GIGABYTES)
    throw new m(
      "The total number of vertices (width * height) must be less than 4,294,967,296.",
    );
  let o = Gt[t];
  w(o) || (Gt[t] = o = []);
  let e = o[n];
  if (!w(e)) {
    let r = T.getRegularGridIndices(t, n),
      s = Lt(t, n),
      i = s.westIndicesSouthToNorth,
      c = s.southIndicesEastToWest,
      h = s.eastIndicesNorthToSouth,
      E = s.northIndicesWestToEast;
    e = o[n] = {
      indices: r,
      westIndicesSouthToNorth: i,
      southIndicesEastToWest: c,
      eastIndicesNorthToSouth: h,
      northIndicesWestToEast: E,
    };
  }
  return e;
};
var kt = [];
T.getRegularGridAndSkirtIndicesAndEdgeIndices = function (t, n) {
  if (t * n >= f.FOUR_GIGABYTES)
    throw new m(
      "The total number of vertices (width * height) must be less than 4,294,967,296.",
    );
  let o = kt[t];
  w(o) || (kt[t] = o = []);
  let e = o[n];
  if (!w(e)) {
    let r = t * n,
      s = (t - 1) * (n - 1) * 6,
      i = t * 2 + n * 2,
      c = Math.max(0, i - 4) * 6,
      h = r + i,
      E = s + c,
      g = Lt(t, n),
      d = g.westIndicesSouthToNorth,
      p = g.southIndicesEastToWest,
      b = g.eastIndicesNorthToSouth,
      L = g.northIndicesWestToEast,
      N = X.createTypedArray(h, E);
    (Pt(t, n, N, 0),
      T.addSkirtIndices(d, p, b, L, r, N, s),
      (e = o[n] =
        {
          indices: N,
          westIndicesSouthToNorth: d,
          southIndicesEastToWest: p,
          eastIndicesNorthToSouth: b,
          northIndicesWestToEast: L,
          indexCountWithoutSkirts: s,
        }));
  }
  return e;
};
T.addSkirtIndices = function (t, n, o, e, r, s, i) {
  let c = r;
  ((i = Z(t, c, s, i)),
    (c += t.length),
    (i = Z(n, c, s, i)),
    (c += n.length),
    (i = Z(o, c, s, i)),
    (c += o.length),
    Z(e, c, s, i));
};
function Lt(t, n) {
  let o = new Array(n),
    e = new Array(t),
    r = new Array(n),
    s = new Array(t),
    i;
  for (i = 0; i < t; ++i) ((s[i] = i), (e[i] = t * n - 1 - i));
  for (i = 0; i < n; ++i) ((r[i] = (i + 1) * t - 1), (o[i] = (n - i - 1) * t));
  return {
    westIndicesSouthToNorth: o,
    southIndicesEastToWest: e,
    eastIndicesNorthToSouth: r,
    northIndicesWestToEast: s,
  };
}
function Pt(t, n, o, e) {
  let r = 0;
  for (let s = 0; s < n - 1; ++s) {
    for (let i = 0; i < t - 1; ++i) {
      let c = r,
        h = c + t,
        E = h + 1,
        g = c + 1;
      ((o[e++] = c),
        (o[e++] = h),
        (o[e++] = g),
        (o[e++] = g),
        (o[e++] = h),
        (o[e++] = E),
        ++r);
    }
    ++r;
  }
}
function Z(t, n, o, e) {
  let r = t[0],
    s = t.length;
  for (let i = 1; i < s; ++i) {
    let c = t[i];
    ((o[e++] = r),
      (o[e++] = c),
      (o[e++] = n),
      (o[e++] = n),
      (o[e++] = c),
      (o[e++] = n + 1),
      (r = c),
      ++n);
  }
  return e;
}
T.heightmapTerrainQuality = 0.25;
T.getEstimatedLevelZeroGeometricErrorForAHeightmap = function (t, n, o) {
  return (t.maximumRadius * 2 * Math.PI * T.heightmapTerrainQuality) / (n * o);
};
T.prototype.requestTileGeometry = m.throwInstantiationError;
T.prototype.getLevelMaximumGeometricError = m.throwInstantiationError;
T.prototype.getTileDataAvailable = m.throwInstantiationError;
T.prototype.loadTileDataAvailability = m.throwInstantiationError;
var Vt = T;
var ht = 32767,
  D = new P(),
  Xt = new P(),
  Zt = new P(),
  u = new wt(),
  Y = new lt();
function Jt(t, n) {
  let o = t.quantizedVertices,
    e = o.length / 3,
    r = t.octEncodedNormals,
    s =
      t.westIndices.length +
      t.eastIndices.length +
      t.southIndices.length +
      t.northIndices.length,
    i = t.includeWebMercatorT,
    c = t.exaggeration,
    h = t.exaggerationRelativeHeight,
    g = c !== 1,
    d = At.clone(t.rectangle),
    p = d.west,
    b = d.south,
    L = d.east,
    N = d.north,
    I = pt.clone(t.ellipsoid),
    y = t.minimumHeight,
    v = t.maximumHeight,
    S = t.relativeToCenter,
    _ = bt.eastNorthUpToFixedFrame(S, I),
    O = U.inverseTransformation(_, new U()),
    G,
    A;
  i &&
    ((G = z.geodeticLatitudeToMercatorAngle(b)),
    (A = 1 / (z.geodeticLatitudeToMercatorAngle(N) - G)));
  let j = o.subarray(0, e),
    q = o.subarray(e, 2 * e),
    Q = o.subarray(e * 2, 3 * e),
    R = w(r),
    l = new Array(e),
    M = new Array(e),
    et = new Array(e),
    It = i ? new Array(e) : [],
    gt = g ? new Array(e) : [],
    W = Xt;
  ((W.x = Number.POSITIVE_INFINITY),
    (W.y = Number.POSITIVE_INFINITY),
    (W.z = Number.POSITIVE_INFINITY));
  let C = Zt;
  ((C.x = Number.NEGATIVE_INFINITY),
    (C.y = Number.NEGATIVE_INFINITY),
    (C.z = Number.NEGATIVE_INFINITY));
  let ot = Number.POSITIVE_INFINITY,
    nt = Number.NEGATIVE_INFINITY,
    it = Number.POSITIVE_INFINITY,
    rt = Number.NEGATIVE_INFINITY;
  for (let a = 0; a < e; ++a) {
    let x = j[a],
      Kt = q[a],
      St = x / ht,
      xt = Kt / ht,
      yt = f.lerp(y, v, Q[a] / ht);
    ((u.longitude = f.lerp(p, L, St)),
      (u.latitude = f.lerp(b, N, xt)),
      (u.height = yt),
      (ot = Math.min(u.longitude, ot)),
      (nt = Math.max(u.longitude, nt)),
      (it = Math.min(u.latitude, it)),
      (rt = Math.max(u.latitude, rt)));
    let dt = I.cartographicToCartesian(u);
    ((l[a] = new lt(St, xt)),
      (M[a] = yt),
      (et[a] = dt),
      i && (It[a] = (z.geodeticLatitudeToMercatorAngle(u.latitude) - G) * A),
      g && (gt[a] = I.geodeticSurfaceNormal(dt)),
      U.multiplyByPoint(O, dt, D),
      P.minimumByComponent(D, W, W),
      P.maximumByComponent(D, C, C));
  }
  let st = tt(t.westIndices, function (a, x) {
      return l[a].y - l[x].y;
    }),
    ct = tt(t.eastIndices, function (a, x) {
      return l[x].y - l[a].y;
    }),
    at = tt(t.southIndices, function (a, x) {
      return l[x].x - l[a].x;
    }),
    ut = tt(t.northIndices, function (a, x) {
      return l[a].x - l[x].x;
    }),
    mt;
  y < 0 &&
    (mt = new Ct(I).computeHorizonCullingPointPossiblyUnderEllipsoid(S, et, y));
  let k = y;
  ((k = Math.min(k, J(t.westIndices, t.westSkirtHeight, M, l, d, I, O, W, C))),
    (k = Math.min(
      k,
      J(t.southIndices, t.southSkirtHeight, M, l, d, I, O, W, C),
    )),
    (k = Math.min(k, J(t.eastIndices, t.eastSkirtHeight, M, l, d, I, O, W, C))),
    (k = Math.min(
      k,
      J(t.northIndices, t.northSkirtHeight, M, l, d, I, O, W, C),
    )));
  let Ft = new Wt(W, C, S),
    V = new vt(S, Ft, k, v, _, R, i, g, c, h),
    F = V.stride,
    Bt = e * F + s * F,
    B = new Float32Array(Bt),
    ft = 0;
  for (let a = 0; a < e; ++a) {
    if (R) {
      let x = a * 2;
      ((Y.x = r[x]), (Y.y = r[x + 1]));
    }
    ft = V.encode(B, ft, et[a], l[a], M[a], Y, It[a], gt[a]);
  }
  let Ht = Math.max(0, (s - 4) * 2),
    _t = t.indices.length + Ht * 3,
    K = X.createTypedArray(e + s, _t);
  K.set(t.indices, 0);
  let Tt = 1e-4,
    Et = (nt - ot) * Tt,
    Nt = (rt - it) * Tt,
    Yt = -Et,
    Rt = 0,
    Ut = Et,
    zt = 0,
    Dt = 0,
    jt = Nt,
    qt = 0,
    Qt = -Nt,
    H = e * F;
  return (
    $(B, H, st, V, M, l, r, I, d, t.westSkirtHeight, G, A, Yt, Rt),
    (H += t.westIndices.length * F),
    $(B, H, at, V, M, l, r, I, d, t.southSkirtHeight, G, A, qt, Qt),
    (H += t.southIndices.length * F),
    $(B, H, ct, V, M, l, r, I, d, t.eastSkirtHeight, G, A, Ut, zt),
    (H += t.eastIndices.length * F),
    $(B, H, ut, V, M, l, r, I, d, t.northSkirtHeight, G, A, Dt, jt),
    Vt.addSkirtIndices(st, at, ct, ut, e, K, t.indices.length),
    n.push(B.buffer, K.buffer),
    {
      vertices: B.buffer,
      indices: K.buffer,
      westIndicesSouthToNorth: st,
      southIndicesEastToWest: at,
      eastIndicesNorthToSouth: ct,
      northIndicesWestToEast: ut,
      vertexStride: F,
      center: S,
      minimumHeight: y,
      maximumHeight: v,
      occludeePointInScaledSpace: mt,
      encoding: V,
      indexCountWithoutSkirts: t.indices.length,
    }
  );
}
function J(t, n, o, e, r, s, i, c, h) {
  let E = Number.POSITIVE_INFINITY,
    g = r.north,
    d = r.south,
    p = r.east,
    b = r.west;
  p < b && (p += f.TWO_PI);
  let L = t.length;
  for (let N = 0; N < L; ++N) {
    let I = t[N],
      y = o[I],
      v = e[I];
    ((u.longitude = f.lerp(b, p, v.x)),
      (u.latitude = f.lerp(d, g, v.y)),
      (u.height = y - n));
    let S = s.cartographicToCartesian(u, D);
    (U.multiplyByPoint(i, S, S),
      P.minimumByComponent(S, c, c),
      P.maximumByComponent(S, h, h),
      (E = Math.min(E, u.height)));
  }
  return E;
}
function $(t, n, o, e, r, s, i, c, h, E, g, d, p, b) {
  let L = w(i),
    N = h.north,
    I = h.south,
    y = h.east,
    v = h.west;
  y < v && (y += f.TWO_PI);
  let S = o.length;
  for (let _ = 0; _ < S; ++_) {
    let O = o[_],
      G = r[O],
      A = s[O];
    ((u.longitude = f.lerp(v, y, A.x) + p),
      (u.latitude = f.lerp(I, N, A.y) + b),
      (u.height = G - E));
    let j = c.cartographicToCartesian(u, D);
    if (L) {
      let R = O * 2;
      ((Y.x = i[R]), (Y.y = i[R + 1]));
    }
    let q;
    e.hasWebMercatorT &&
      (q = (z.geodeticLatitudeToMercatorAngle(u.latitude) - g) * d);
    let Q;
    (e.hasGeodeticSurfaceNormals && (Q = c.geodeticSurfaceNormal(j)),
      (n = e.encode(t, n, j, A, u.height, Y, q, Q)));
  }
}
function tt(t, n) {
  let o;
  return (
    typeof t.slice == "function" &&
      ((o = t.slice()), typeof o.sort != "function" && (o = void 0)),
    w(o) || (o = Array.prototype.slice.call(t)),
    o.sort(n),
    o
  );
}
var Se = Mt(Jt);
export { Se as default };
