import ApproximateTerrainHeights from "./ApproximateTerrainHeights.js";

import ArcType from "./ArcType.js";

import arrayRemoveDuplicates from "./arrayRemoveDuplicates.js";

import BoundingSphere from "./BoundingSphere.js";

import Cartesian3 from "./Cartesian3.js";

import Cartographic from "./Cartographic.js";

import Check from "./Check.js";

import ComponentDatatype from "./ComponentDatatype.js";

import defaultValue from "./defaultValue.js";

import defined from "./defined.js";

import DeveloperError from "./DeveloperError.js";

import Ellipsoid from "./Ellipsoid.js";

import EllipsoidGeodesic from "./EllipsoidGeodesic.js";

import EllipsoidRhumbLine from "./EllipsoidRhumbLine.js";

import EncodedCartesian3 from "./EncodedCartesian3.js";

import GeographicProjection from "./GeographicProjection.js";

import Geometry from "./Geometry.js";

import GeometryAttribute from "./GeometryAttribute.js";

import IntersectionTests from "./IntersectionTests.js";

import CesiumMath from "./Math.js";

import Matrix3 from "./Matrix3.js";

import Plane from "./Plane.js";

import Quaternion from "./Quaternion.js";

import Rectangle from "./Rectangle.js";

import WebMercatorProjection from "./WebMercatorProjection.js";

const PROJECTIONS = [GeographicProjection, WebMercatorProjection];

const PROJECTION_COUNT = PROJECTIONS.length;

const MITER_BREAK_SMALL = Math.cos(CesiumMath.toRadians(30.0));

const MITER_BREAK_LARGE = Math.cos(CesiumMath.toRadians(150.0));

// Initial heights for constructing the wall.

// Keeping WALL_INITIAL_MIN_HEIGHT near the ellipsoid surface helps

// prevent precision problems with planes in the shader.

// Putting the start point of a plane at ApproximateTerrainHeights._defaultMinTerrainHeight,

// which is a highly conservative bound, usually puts the plane origin several thousands

// of meters away from the actual terrain, causing floating point problems when checking

// fragments on terrain against the plane.

// Ellipsoid height is generally much closer.

// The initial max height is arbitrary.

// Both heights are corrected using ApproximateTerrainHeights for computing the actual volume geometry.

const WALL_INITIAL_MIN_HEIGHT = 0.0;

const WALL_INITIAL_MAX_HEIGHT = 1000.0;

/**

* A description of a polyline on terrain or 3D Tiles. Only to be used with {@link GroundPolylinePrimitive}.

*

* @alias GroundPolylineGeometry

* @constructor

*

* @param {Object} options Options with the following properties:

* @param {Cartesian3[]} options.positions An array of {@link Cartesian3} defining the polyline's points. Heights above the ellipsoid will be ignored.

* @param {Number} [options.width=1.0] The screen space width in pixels.

* @param {Number} [options.granularity=9999.0] The distance interval in meters used for interpolating options.points. Defaults to 9999.0 meters. Zero indicates no interpolation.

* @param {Boolean} [options.loop=false] Whether during geometry creation a line segment will be added between the last and first line positions to make this Polyline a loop.

* @param {ArcType} [options.arcType=ArcType.GEODESIC] The type of line the polyline segments must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.

*

* @exception {DeveloperError} At least two positions are required.

*

* @see GroundPolylinePrimitive

*

* @example

* const positions = Cesium.Cartesian3.fromDegreesArray([

* -112.1340164450331, 36.05494287836128,

* -112.08821010582645, 36.097804071380715,

* -112.13296079730024, 36.168769146801104

* ]);

*

* const geometry = new Cesium.GroundPolylineGeometry({

* positions : positions

* });

*/

function GroundPolylineGeometry(options) {

}

Object.defineProperties(GroundPolylineGeometry.prototype, {

/**

* The number of elements used to pack the object into an array.

* @memberof GroundPolylineGeometry.prototype

* @type {Number}

* @readonly

* @private

*/

packedLength: {

get: function () {

},

},

});

/**

* Set the GroundPolylineGeometry's projection and ellipsoid.

* Used by GroundPolylinePrimitive to signal scene information to the geometry for generating 2D attributes.

*

* @param {GroundPolylineGeometry} groundPolylineGeometry GroundPolylinGeometry describing a polyline on terrain or 3D Tiles.

* @param {Projection} mapProjection A MapProjection used for projecting cartographic coordinates to 2D.

* @private

*/

GroundPolylineGeometry.setProjectionAndEllipsoid = function (

};

const cart3Scratch1 = new Cartesian3();

const cart3Scratch2 = new Cartesian3();

const cart3Scratch3 = new Cartesian3();

function computeRightNormal(start, end, maxHeight, ellipsoid, result) {

}

const interpolatedCartographicScratch = new Cartographic();

const interpolatedBottomScratch = new Cartesian3();

const interpolatedTopScratch = new Cartesian3();

const interpolatedNormalScratch = new Cartesian3();

function interpolateSegment(

}

const heightlessCartographicScratch = new Cartographic();

function getPosition(ellipsoid, cartographic, height, result) {

}

/**

* Stores the provided instance into the provided array.

*

* @param {PolygonGeometry} value The value to pack.

* @param {Number[]} array The array to pack into.

* @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.

*

* @returns {Number[]} The array that was packed into

*/

GroundPolylineGeometry.pack = function (value, array, startingIndex) {

};

/**

* Retrieves an instance from a packed array.

*

* @param {Number[]} array The packed array.

* @param {Number} [startingIndex=0] The starting index of the element to be unpacked.

* @param {PolygonGeometry} [result] The object into which to store the result.

*/

GroundPolylineGeometry.unpack = function (array, startingIndex, result) {

};

function direction(target, origin, result) {

}

function tangentDirection(target, origin, up, result) {

}

const toPreviousScratch = new Cartesian3();

const toNextScratch = new Cartesian3();

const forwardScratch = new Cartesian3();

const vertexUpScratch = new Cartesian3();

const cosine90 = 0.0;

const cosine180 = -1.0;

function computeVertexMiterNormal(

}

const XZ_PLANE = Plane.fromPointNormal(Cartesian3.ZERO, Cartesian3.UNIT_Y);

const previousBottomScratch = new Cartesian3();

const vertexBottomScratch = new Cartesian3();

const vertexTopScratch = new Cartesian3();

const nextBottomScratch = new Cartesian3();

const vertexNormalScratch = new Cartesian3();

const intersectionScratch = new Cartesian3();

const cartographicScratch0 = new Cartographic();

const cartographicScratch1 = new Cartographic();

const cartographicIntersectionScratch = new Cartographic();

/**

* Computes shadow volumes for the ground polyline, consisting of its vertices, indices, and a bounding sphere.

* Vertices are "fat," packing all the data needed in each volume to describe a line on terrain or 3D Tiles.

* Should not be called independent of {@link GroundPolylinePrimitive}.

*

* @param {GroundPolylineGeometry} groundPolylineGeometry

* @private

*/

GroundPolylineGeometry.createGeometry = function (groundPolylineGeometry) {

};

// If the end normal angle is too steep compared to the direction of the line segment,

// "break" the miter by rotating the normal 90 degrees around the "up" direction at the point

// For ultra precision we would want to project into a plane, but in practice this is sufficient.

const lineDirectionScratch = new Cartesian3();

const matrix3Scratch = new Matrix3();

const quaternionScratch = new Quaternion();

function breakMiter(endGeometryNormal, startBottom, endBottom, endTop) {

}

const endPosCartographicScratch = new Cartographic();

const normalStartpointScratch = new Cartesian3();

const normalEndpointScratch = new Cartesian3();

function projectNormal(

}

const adjustHeightNormalScratch = new Cartesian3();

const adjustHeightOffsetScratch = new Cartesian3();

function adjustHeights(

}

const nudgeDirectionScratch = new Cartesian3();

function nudgeXZ(start, end) {

}

// "Nudge" cartographic coordinates so start and end are on the same side of the IDL.

// Nudge amounts are tiny, basically just an IDL flip.

// Only used for 2D/CV.

function nudgeCartographic(start, end) {

}

const startCartographicScratch = new Cartographic();

const endCartographicScratch = new Cartographic();

const segmentStartTopScratch = new Cartesian3();

const segmentEndTopScratch = new Cartesian3();

const segmentStartBottomScratch = new Cartesian3();

const segmentEndBottomScratch = new Cartesian3();

const segmentStartNormalScratch = new Cartesian3();

const segmentEndNormalScratch = new Cartesian3();

const getHeightCartographics = [

startCartographicScratch,

endCartographicScratch,

];

const getHeightRectangleScratch = new Rectangle();

const adjustHeightStartTopScratch = new Cartesian3();

const adjustHeightEndTopScratch = new Cartesian3();

const adjustHeightStartBottomScratch = new Cartesian3();

const adjustHeightEndBottomScratch = new Cartesian3();

const segmentStart2DScratch = new Cartesian3();

const segmentEnd2DScratch = new Cartesian3();

const segmentStartNormal2DScratch = new Cartesian3();

const segmentEndNormal2DScratch = new Cartesian3();

const offsetScratch = new Cartesian3();

const startUpScratch = new Cartesian3();

const endUpScratch = new Cartesian3();

const rightScratch = new Cartesian3();

const startPlaneNormalScratch = new Cartesian3();

const endPlaneNormalScratch = new Cartesian3();

const encodeScratch = new EncodedCartesian3();