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";
var PROJECTIONS = [GeographicProjection, WebMercatorProjection];
var PROJECTION_COUNT = PROJECTIONS.length;
var MITER_BREAK_SMALL = Math.cos(CesiumMath.toRadians(30.0));
var 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.
var WALL_INITIAL_MIN_HEIGHT = 0.0;
var 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
* var positions = Cesium.Cartesian3.fromDegreesArray([
* -112.1340164450331, 36.05494287836128,
* -112.08821010582645, 36.097804071380715,
* -112.13296079730024, 36.168769146801104
* ]);
*
* var geometry = new Cesium.GroundPolylineGeometry({
* positions : positions
* });
*/
function GroundPolylineGeometry(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var positions = options.positions;
//>>includeStart('debug', pragmas.debug);
if (!defined(positions) || positions.length < 2) {
throw new DeveloperError("At least two positions are required.");
}
if (
defined(options.arcType) &&
options.arcType !== ArcType.GEODESIC &&
options.arcType !== ArcType.RHUMB
) {
throw new DeveloperError(
"Valid options for arcType are ArcType.GEODESIC and ArcType.RHUMB."
);
}
//>>includeEnd('debug');
/**
* The screen space width in pixels.
* @type {Number}
*/
this.width = defaultValue(options.width, 1.0); // Doesn't get packed, not necessary for computing geometry.
this._positions = positions;
/**
* The distance interval used for interpolating options.points. Zero indicates no interpolation.
* Default of 9999.0 allows centimeter accuracy with 32 bit floating point.
* @type {Boolean}
* @default 9999.0
*/
this.granularity = defaultValue(options.granularity, 9999.0);
/**
* Whether during geometry creation a line segment will be added between the last and first line positions to make this Polyline a loop.
* If the geometry has two positions this parameter will be ignored.
* @type {Boolean}
* @default false
*/
this.loop = defaultValue(options.loop, false);
/**
* The type of path the polyline must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.
* @type {ArcType}
* @default ArcType.GEODESIC
*/
this.arcType = defaultValue(options.arcType, ArcType.GEODESIC);
this._ellipsoid = Ellipsoid.WGS84;
// MapProjections can't be packed, so store the index to a known MapProjection.
this._projectionIndex = 0;
this._workerName = "createGroundPolylineGeometry";
// Used by GroundPolylinePrimitive to signal worker that scenemode is 3D only.
this._scene3DOnly = false;
}
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 () {
return (
1.0 +
this._positions.length * 3 +
1.0 +
1.0 +
1.0 +
Ellipsoid.packedLength +
1.0 +
1.0
);
},
},
});
/**
* 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 (
groundPolylineGeometry,
mapProjection
) {
var projectionIndex = 0;
for (var i = 0; i < PROJECTION_COUNT; i++) {
if (mapProjection instanceof PROJECTIONS[i]) {
projectionIndex = i;
break;
}
}
groundPolylineGeometry._projectionIndex = projectionIndex;
groundPolylineGeometry._ellipsoid = mapProjection.ellipsoid;
};
var cart3Scratch1 = new Cartesian3();
var cart3Scratch2 = new Cartesian3();
var cart3Scratch3 = new Cartesian3();
function computeRightNormal(start, end, maxHeight, ellipsoid, result) {
var startBottom = getPosition(ellipsoid, start, 0.0, cart3Scratch1);
var startTop = getPosition(ellipsoid, start, maxHeight, cart3Scratch2);
var endBottom = getPosition(ellipsoid, end, 0.0, cart3Scratch3);
var up = direction(startTop, startBottom, cart3Scratch2);
var forward = direction(endBottom, startBottom, cart3Scratch3);
Cartesian3.cross(forward, up, result);
return Cartesian3.normalize(result, result);
}
var interpolatedCartographicScratch = new Cartographic();
var interpolatedBottomScratch = new Cartesian3();
var interpolatedTopScratch = new Cartesian3();
var interpolatedNormalScratch = new Cartesian3();
function interpolateSegment(
start,
end,
minHeight,
maxHeight,
granularity,
arcType,
ellipsoid,
normalsArray,
bottomPositionsArray,
topPositionsArray,
cartographicsArray
) {
if (granularity === 0.0) {
return;
}
var ellipsoidLine;
if (arcType === ArcType.GEODESIC) {
ellipsoidLine = new EllipsoidGeodesic(start, end, ellipsoid);
} else if (arcType === ArcType.RHUMB) {
ellipsoidLine = new EllipsoidRhumbLine(start, end, ellipsoid);
}
var surfaceDistance = ellipsoidLine.surfaceDistance;
if (surfaceDistance < granularity) {
return;
}
// Compute rightwards normal applicable at all interpolated points
var interpolatedNormal = computeRightNormal(
start,
end,
maxHeight,
ellipsoid,
interpolatedNormalScratch
);
var segments = Math.ceil(surfaceDistance / granularity);
var interpointDistance = surfaceDistance / segments;
var distanceFromStart = interpointDistance;
var pointsToAdd = segments - 1;
var packIndex = normalsArray.length;
for (var i = 0; i < pointsToAdd; i++) {
var interpolatedCartographic = ellipsoidLine.interpolateUsingSurfaceDistance(
distanceFromStart,
interpolatedCartographicScratch
);
var interpolatedBottom = getPosition(
ellipsoid,
interpolatedCartographic,
minHeight,
interpolatedBottomScratch
);
var interpolatedTop = getPosition(
ellipsoid,
interpolatedCartographic,
maxHeight,
interpolatedTopScratch
);
Cartesian3.pack(interpolatedNormal, normalsArray, packIndex);
Cartesian3.pack(interpolatedBottom, bottomPositionsArray, packIndex);
Cartesian3.pack(interpolatedTop, topPositionsArray, packIndex);
cartographicsArray.push(interpolatedCartographic.latitude);
cartographicsArray.push(interpolatedCartographic.longitude);
packIndex += 3;
distanceFromStart += interpointDistance;
}
}
var heightlessCartographicScratch = new Cartographic();
function getPosition(ellipsoid, cartographic, height, result) {
Cartographic.clone(cartographic, heightlessCartographicScratch);
heightlessCartographicScratch.height = height;
return Cartographic.toCartesian(
heightlessCartographicScratch,
ellipsoid,
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) {
//>>includeStart('debug', pragmas.debug);
Check.typeOf.object("value", value);
Check.defined("array", array);
//>>includeEnd('debug');
var index = defaultValue(startingIndex, 0);
var positions = value._positions;
var positionsLength = positions.length;
array[index++] = positionsLength;
for (var i = 0; i < positionsLength; ++i) {
var cartesian = positions[i];
Cartesian3.pack(cartesian, array, index);
index += 3;
}
array[index++] = value.granularity;
array[index++] = value.loop ? 1.0 : 0.0;
array[index++] = value.arcType;
Ellipsoid.pack(value._ellipsoid, array, index);
index += Ellipsoid.packedLength;
array[index++] = value._projectionIndex;
array[index++] = value._scene3DOnly ? 1.0 : 0.0;
return array;
};
/**
* 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) {
//>>includeStart('debug', pragmas.debug);
Check.defined("array", array);
//>>includeEnd('debug');
var index = defaultValue(startingIndex, 0);
var positionsLength = array[index++];
var positions = new Array(positionsLength);
for (var i = 0; i < positionsLength; i++) {
positions[i] = Cartesian3.unpack(array, index);
index += 3;
}
var granularity = array[index++];
var loop = array[index++] === 1.0;
var arcType = array[index++];
var ellipsoid = Ellipsoid.unpack(array, index);
index += Ellipsoid.packedLength;
var projectionIndex = array[index++];
var scene3DOnly = array[index++] === 1.0;
if (!defined(result)) {
result = new GroundPolylineGeometry({
positions: positions,
});
}
result._positions = positions;
result.granularity = granularity;
result.loop = loop;
result.arcType = arcType;
result._ellipsoid = ellipsoid;
result._projectionIndex = projectionIndex;
result._scene3DOnly = scene3DOnly;
return result;
};
function direction(target, origin, result) {
Cartesian3.subtract(target, origin, result);
Cartesian3.normalize(result, result);
return result;
}
function tangentDirection(target, origin, up, result) {
result = direction(target, origin, result);
// orthogonalize
result = Cartesian3.cross(result, up, result);
result = Cartesian3.normalize(result, result);
result = Cartesian3.cross(up, result, result);
return result;
}
var toPreviousScratch = new Cartesian3();
var toNextScratch = new Cartesian3();
var forwardScratch = new Cartesian3();
var vertexUpScratch = new Cartesian3();
var cosine90 = 0.0;
var cosine180 = -1.0;
function computeVertexMiterNormal(
previousBottom,
vertexBottom,
vertexTop,
nextBottom,
result
) {
var up = direction(vertexTop, vertexBottom, vertexUpScratch);
// Compute vectors pointing towards neighboring points but tangent to this point on the ellipsoid
var toPrevious = tangentDirection(
previousBottom,
vertexBottom,
up,
toPreviousScratch
);
var toNext = tangentDirection(nextBottom, vertexBottom, up, toNextScratch);
// Check if tangents are almost opposite - if so, no need to miter.
if (
CesiumMath.equalsEpsilon(
Cartesian3.dot(toPrevious, toNext),
cosine180,
CesiumMath.EPSILON5
)
) {
result = Cartesian3.cross(up, toPrevious, result);
result = Cartesian3.normalize(result, result);
return result;
}
// Average directions to previous and to next in the plane of Up
result = Cartesian3.add(toNext, toPrevious, result);
result = Cartesian3.normalize(result, result);
// Flip the normal if it isn't pointing roughly bound right (aka if forward is pointing more "backwards")
var forward = Cartesian3.cross(up, result, forwardScratch);
if (Cartesian3.dot(toNext, forward) < cosine90) {
result = Cartesian3.negate(result, result);
}
return result;
}
var XZ_PLANE = Plane.fromPointNormal(Cartesian3.ZERO, Cartesian3.UNIT_Y);
var previousBottomScratch = new Cartesian3();
var vertexBottomScratch = new Cartesian3();
var vertexTopScratch = new Cartesian3();
var nextBottomScratch = new Cartesian3();
var vertexNormalScratch = new Cartesian3();
var intersectionScratch = new Cartesian3();
var cartographicScratch0 = new Cartographic();
var cartographicScratch1 = new Cartographic();
var 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) {
var compute2dAttributes = !groundPolylineGeometry._scene3DOnly;
var loop = groundPolylineGeometry.loop;
var ellipsoid = groundPolylineGeometry._ellipsoid;
var granularity = groundPolylineGeometry.granularity;
var arcType = groundPolylineGeometry.arcType;
var projection = new PROJECTIONS[groundPolylineGeometry._projectionIndex](
ellipsoid
);
var minHeight = WALL_INITIAL_MIN_HEIGHT;
var maxHeight = WALL_INITIAL_MAX_HEIGHT;
var index;
var i;
var positions = groundPolylineGeometry._positions;
var positionsLength = positions.length;
if (positionsLength === 2) {
loop = false;
}
// Split positions across the IDL and the Prime Meridian as well.
// Split across prime meridian because very large geometries crossing the Prime Meridian but not the IDL
// may get split by the plane of IDL + Prime Meridian.
var p0;
var p1;
var c0;
var c1;
var rhumbLine = new EllipsoidRhumbLine(undefined, undefined, ellipsoid);
var intersection;
var intersectionCartographic;
var intersectionLongitude;
var splitPositions = [positions[0]];
for (i = 0; i < positionsLength - 1; i++) {
p0 = positions[i];
p1 = positions[i + 1];
intersection = IntersectionTests.lineSegmentPlane(
p0,
p1,
XZ_PLANE,
intersectionScratch
);
if (
defined(intersection) &&
!Cartesian3.equalsEpsilon(intersection, p0, CesiumMath.EPSILON7) &&
!Cartesian3.equalsEpsilon(intersection, p1, CesiumMath.EPSILON7)
) {
if (groundPolylineGeometry.arcType === ArcType.GEODESIC) {
splitPositions.push(Cartesian3.clone(intersection));
} else if (groundPolylineGeometry.arcType === ArcType.RHUMB) {
intersectionLongitude = ellipsoid.cartesianToCartographic(
intersection,
cartographicScratch0
).longitude;
c0 = ellipsoid.cartesianToCartographic(p0, cartographicScratch0);
c1 = ellipsoid.cartesianToCartographic(p1, cartographicScratch1);
rhumbLine.setEndPoints(c0, c1);
intersectionCartographic = rhumbLine.findIntersectionWithLongitude(
intersectionLongitude,
cartographicIntersectionScratch
);
intersection = ellipsoid.cartographicToCartesian(
intersectionCartographic,
intersectionScratch
);
if (
defined(intersection) &&
!Cartesian3.equalsEpsilon(intersection, p0, CesiumMath.EPSILON7) &&
!Cartesian3.equalsEpsilon(intersection, p1, CesiumMath.EPSILON7)
) {
splitPositions.push(Cartesian3.clone(intersection));
}
}
}
splitPositions.push(p1);
}
if (loop) {
p0 = positions[positionsLength - 1];
p1 = positions[0];
intersection = IntersectionTests.lineSegmentPlane(
p0,
p1,
XZ_PLANE,
intersectionScratch
);
if (
defined(intersection) &&
!Cartesian3.equalsEpsilon(intersection, p0, CesiumMath.EPSILON7) &&
!Cartesian3.equalsEpsilon(intersection, p1, CesiumMath.EPSILON7)
) {
if (groundPolylineGeometry.arcType === ArcType.GEODESIC) {
splitPositions.push(Cartesian3.clone(intersection));
} else if (groundPolylineGeometry.arcType === ArcType.RHUMB) {
intersectionLongitude = ellipsoid.cartesianToCartographic(
intersection,
cartographicScratch0
).longitude;
c0 = ellipsoid.cartesianToCartographic(p0, cartographicScratch0);
c1 = ellipsoid.cartesianToCartographic(p1, cartographicScratch1);
rhumbLine.setEndPoints(c0, c1);
intersectionCartographic = rhumbLine.findIntersectionWithLongitude(
intersectionLongitude,
cartographicIntersectionScratch
);
intersection = ellipsoid.cartographicToCartesian(
intersectionCartographic,
intersectionScratch
);
if (
defined(intersection) &&
!Cartesian3.equalsEpsilon(intersection, p0, CesiumMath.EPSILON7) &&
!Cartesian3.equalsEpsilon(intersection, p1, CesiumMath.EPSILON7)
) {
splitPositions.push(Cartesian3.clone(intersection));
}
}
}
}
var cartographicsLength = splitPositions.length;
var cartographics = new Array(cartographicsLength);
for (i = 0; i < cartographicsLength; i++) {
var cartographic = Cartographic.fromCartesian(splitPositions[i], ellipsoid);
cartographic.height = 0.0;
cartographics[i] = cartographic;
}
cartographics = arrayRemoveDuplicates(
cartographics,
Cartographic.equalsEpsilon
);
cartographicsLength = cartographics.length;
if (cartographicsLength < 2) {
return undefined;
}
/**** Build heap-side arrays for positions, interpolated cartographics, and normals from which to compute vertices ****/
// We build a "wall" and then decompose it into separately connected component "volumes" because we need a lot
// of information about the wall. Also, this simplifies interpolation.
// Convention: "next" and "end" are locally forward to each segment of the wall,
// and we are computing normals pointing towards the local right side of the vertices in each segment.
var cartographicsArray = [];
var normalsArray = [];
var bottomPositionsArray = [];
var topPositionsArray = [];
var previousBottom = previousBottomScratch;
var vertexBottom = vertexBottomScratch;
var vertexTop = vertexTopScratch;
var nextBottom = nextBottomScratch;
var vertexNormal = vertexNormalScratch;
// First point - either loop or attach a "perpendicular" normal
var startCartographic = cartographics[0];
var nextCartographic = cartographics[1];
var prestartCartographic = cartographics[cartographicsLength - 1];
previousBottom = getPosition(
ellipsoid,
prestartCartographic,
minHeight,
previousBottom
);
nextBottom = getPosition(ellipsoid, nextCartographic, minHeight, nextBottom);
vertexBottom = getPosition(
ellipsoid,
startCartographic,
minHeight,
vertexBottom
);
vertexTop = getPosition(ellipsoid, startCartographic, maxHeight, vertexTop);
if (loop) {
vertexNormal = computeVertexMiterNormal(
previousBottom,
vertexBottom,
vertexTop,
nextBottom,
vertexNormal
);
} else {
vertexNormal = computeRightNormal(
startCartographic,
nextCartographic,
maxHeight,
ellipsoid,
vertexNormal
);
}
Cartesian3.pack(vertexNormal, normalsArray, 0);
Cartesian3.pack(vertexBottom, bottomPositionsArray, 0);
Cartesian3.pack(vertexTop, topPositionsArray, 0);
cartographicsArray.push(startCartographic.latitude);
cartographicsArray.push(startCartographic.longitude);
interpolateSegment(
startCartographic,
nextCartographic,
minHeight,
maxHeight,
granularity,
arcType,
ellipsoid,
normalsArray,
bottomPositionsArray,
topPositionsArray,
cartographicsArray
);
// All inbetween points
for (i = 1; i < cartographicsLength - 1; ++i) {
previousBottom = Cartesian3.clone(vertexBottom, previousBottom);
vertexBottom = Cartesian3.clone(nextBottom, vertexBottom);
var vertexCartographic = cartographics[i];
getPosition(ellipsoid, vertexCartographic, maxHeight, vertexTop);
getPosition(ellipsoid, cartographics[i + 1], minHeight, nextBottom);
computeVertexMiterNormal(
previousBottom,
vertexBottom,
vertexTop,
nextBottom,
vertexNormal
);
index = normalsArray.length;
Cartesian3.pack(vertexNormal, normalsArray, index);
Cartesian3.pack(vertexBottom, bottomPositionsArray, index);
Cartesian3.pack(vertexTop, topPositionsArray, index);
cartographicsArray.push(vertexCartographic.latitude);
cartographicsArray.push(vertexCartographic.longitude);
interpolateSegment(
cartographics[i],
cartographics[i + 1],
minHeight,
maxHeight,
granularity,
arcType,
ellipsoid,
normalsArray,
bottomPositionsArray,
topPositionsArray,
cartographicsArray
);
}
// Last point - either loop or attach a normal "perpendicular" to the wall.
var endCartographic = cartographics[cartographicsLength - 1];
var preEndCartographic = cartographics[cartographicsLength - 2];
vertexBottom = getPosition(
ellipsoid,
endCartographic,
minHeight,
vertexBottom
);
vertexTop = getPosition(ellipsoid, endCartographic, maxHeight, vertexTop);
if (loop) {
var postEndCartographic = cartographics[0];
previousBottom = getPosition(
ellipsoid,
preEndCartographic,
minHeight,
previousBottom
);
nextBottom = getPosition(
ellipsoid,
postEndCartographic,
minHeight,
nextBottom
);
vertexNormal = computeVertexMiterNormal(
previousBottom,
vertexBottom,
vertexTop,
nextBottom,
vertexNormal
);
} else {
vertexNormal = computeRightNormal(
preEndCartographic,
endCartographic,
maxHeight,
ellipsoid,
vertexNormal
);
}
index = normalsArray.length;
Cartesian3.pack(vertexNormal, normalsArray, index);
Cartesian3.pack(vertexBottom, bottomPositionsArray, index);
Cartesian3.pack(vertexTop, topPositionsArray, index);
cartographicsArray.push(endCartographic.latitude);
cartographicsArray.push(endCartographic.longitude);
if (loop) {
interpolateSegment(
endCartographic,
startCartographic,
minHeight,
maxHeight,
granularity,
arcType,
ellipsoid,
normalsArray,
bottomPositionsArray,
topPositionsArray,
cartographicsArray
);
index = normalsArray.length;
for (i = 0; i < 3; ++i) {
normalsArray[index + i] = normalsArray[i];
bottomPositionsArray[index + i] = bottomPositionsArray[i];
topPositionsArray[index + i] = topPositionsArray[i];
}
cartographicsArray.push(startCartographic.latitude);
cartographicsArray.push(startCartographic.longitude);
}
return generateGeometryAttributes(
loop,
projection,
bottomPositionsArray,
topPositionsArray,
normalsArray,
cartographicsArray,
compute2dAttributes
);
};
// 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.
var lineDirectionScratch = new Cartesian3();
var matrix3Scratch = new Matrix3();
var quaternionScratch = new Quaternion();
function breakMiter(endGeometryNormal, startBottom, endBottom, endTop) {
var lineDirection = direction(endBottom, startBottom, lineDirectionScratch);
var dot = Cartesian3.dot(lineDirection, endGeometryNormal);
if (dot > MITER_BREAK_SMALL || dot < MITER_BREAK_LARGE) {
var vertexUp = direction(endTop, endBottom, vertexUpScratch);
var angle =
dot < MITER_BREAK_LARGE
? CesiumMath.PI_OVER_TWO
: -CesiumMath.PI_OVER_TWO;
var quaternion = Quaternion.fromAxisAngle(
vertexUp,
angle,
quaternionScratch
);
var rotationMatrix = Matrix3.fromQuaternion(quaternion, matrix3Scratch);
Matrix3.multiplyByVector(
rotationMatrix,
endGeometryNormal,
endGeometryNormal
);
return true;
}
return false;
}
var endPosCartographicScratch = new Cartographic();
var normalStartpointScratch = new Cartesian3();
var normalEndpointScratch = new Cartesian3();
function projectNormal(
projection,
cartographic,
normal,
projectedPosition,
result
) {
var position = Cartographic.toCartesian(
cartographic,
projection._ellipsoid,
normalStartpointScratch
);
var normalEndpoint = Cartesian3.add(position, normal, normalEndpointScratch);
var flipNormal = false;
var ellipsoid = projection._ellipsoid;
var normalEndpointCartographic = ellipsoid.cartesianToCartographic(
normalEndpoint,
endPosCartographicScratch
);
// If normal crosses the IDL, go the other way and flip the result.
// In practice this almost never happens because the cartographic start
// and end points of each segment are "nudged" to be on the same side
// of the IDL and slightly away from the IDL.
if (
Math.abs(cartographic.longitude - normalEndpointCartographic.longitude) >
CesiumMath.PI_OVER_TWO
) {
flipNormal = true;
normalEndpoint = Cartesian3.subtract(
position,
normal,
normalEndpointScratch
);
normalEndpointCartographic = ellipsoid.cartesianToCartographic(
normalEndpoint,
endPosCartographicScratch
);
}
normalEndpointCartographic.height = 0.0;
var normalEndpointProjected = projection.project(
normalEndpointCartographic,
result
);
result = Cartesian3.subtract(
normalEndpointProjected,
projectedPosition,
result
);
result.z = 0.0;
result = Cartesian3.normalize(result, result);
if (flipNormal) {
Cartesian3.negate(result, result);
}
return result;
}
var adjustHeightNormalScratch = new Cartesian3();
var adjustHeightOffsetScratch = new Cartesian3();
function adjustHeights(
bottom,
top,
minHeight,
maxHeight,
adjustHeightBottom,
adjustHeightTop
) {
// bottom and top should be at WALL_INITIAL_MIN_HEIGHT and WALL_INITIAL_MAX_HEIGHT, respectively
var adjustHeightNormal = Cartesian3.subtract(
top,
bottom,
adjustHeightNormalScratch
);
Cartesian3.normalize(adjustHeightNormal, adjustHeightNormal);
var distanceForBottom = minHeight - WALL_INITIAL_MIN_HEIGHT;
var adjustHeightOffset = Cartesian3.multiplyByScalar(
adjustHeightNormal,
distanceForBottom,
adjustHeightOffsetScratch
);
Cartesian3.add(bottom, adjustHeightOffset, adjustHeightBottom);
var distanceForTop = maxHeight - WALL_INITIAL_MAX_HEIGHT;
adjustHeightOffset = Cartesian3.multiplyByScalar(
adjustHeightNormal,
distanceForTop,
adjustHeightOffsetScratch
);
Cartesian3.add(top, adjustHeightOffset, adjustHeightTop);
}
var nudgeDirectionScratch = new Cartesian3();
function nudgeXZ(start, end) {
var startToXZdistance = Plane.getPointDistance(XZ_PLANE, start);
var endToXZdistance = Plane.getPointDistance(XZ_PLANE, end);
var offset = nudgeDirectionScratch;
// Larger epsilon than what's used in GeometryPipeline, a centimeter in world space
if (CesiumMath.equalsEpsilon(startToXZdistance, 0.0, CesiumMath.EPSILON2)) {
offset = direction(end, start, offset);
Cartesian3.multiplyByScalar(offset, CesiumMath.EPSILON2, offset);
Cartesian3.add(start, offset, start);
} else if (
CesiumMath.equalsEpsilon(endToXZdistance, 0.0, CesiumMath.EPSILON2)
) {
offset = direction(start, end, offset);
Cartesian3.multiplyByScalar(offset, CesiumMath.EPSILON2, offset);
Cartesian3.add(end, offset, 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) {
var absStartLon = Math.abs(start.longitude);
var absEndLon = Math.abs(end.longitude);
if (
CesiumMath.equalsEpsilon(absStartLon, CesiumMath.PI, CesiumMath.EPSILON11)
) {
var endSign = CesiumMath.sign(end.longitude);
start.longitude = endSign * (absStartLon - CesiumMath.EPSILON11);
return 1;
} else if (
CesiumMath.equalsEpsilon(absEndLon, CesiumMath.PI, CesiumMath.EPSILON11)
) {
var startSign = CesiumMath.sign(start.longitude);
end.longitude = startSign * (absEndLon - CesiumMath.EPSILON11);
return 2;
}
return 0;
}
var startCartographicScratch = new Cartographic();
var endCartographicScratch = new Cartographic();
var segmentStartTopScratch = new Cartesian3();
var segmentEndTopScratch = new Cartesian3();
var segmentStartBottomScratch = new Cartesian3();
var segmentEndBottomScratch = new Cartesian3();
var segmentStartNormalScratch = new Cartesian3();
var segmentEndNormalScratch = new Cartesian3();
var getHeightCartographics = [startCartographicScratch, endCartographicScratch];
var getHeightRectangleScratch = new Rectangle();
var adjustHeightStartTopScratch = new Cartesian3();
var adjustHeightEndTopScratch = new Cartesian3();
var adjustHeightStartBottomScratch = new Cartesian3();
var adjustHeightEndBottomScratch = new Cartesian3();
var segmentStart2DScratch = new Cartesian3();
var segmentEnd2DScratch = new Cartesian3();
var segmentStartNormal2DScratch = new Cartesian3();
var segmentEndNormal2DScratch = new Cartesian3();
var offsetScratch = new Cartesian3();
var startUpScratch = new Cartesian3();
var endUpScratch = new Cartesian3();
var rightScratch = new Cartesian3();
var startPlaneNormalScratch = new Cartesian3();
var endPlaneNormalScratch = new Cartesian3();
var encodeScratch = new EncodedCartesian3();
var encodeScratch2D = new EncodedCartesian3();
var forwardOffset2DScratch = new Cartesian3();
var right2DScratch = new Cartesian3();
var normalNudgeScratch = new Cartesian3();
var scratchBoundingSpheres = [new BoundingSphere(), new BoundingSphere()];
// Winding order is reversed so each segment's volume is inside-out
var REFERENCE_INDICES = [
0,
2,
1,
0,
3,
2, // right
0,
7,
3,
0,
4,
7, // start
0,
5,
4,
0,
1,
5, // bottom
5,
7,
4,
5,
6,
7, // left
5,
2,
6,
5,
1,
2, // end
3,
6,
2,
3,
7,
6, // top
];
var REFERENCE_INDICES_LENGTH = REFERENCE_INDICES.length;
// Decompose the "wall" into a series of shadow volumes.
// Each shadow volume's vertices encode a description of the line it contains,
// including mitering planes at the end points, a plane along the line itself,
// and attributes for computing length-wise texture coordinates.
function generateGeometryAttributes(
loop,
projection,
bottomPositionsArray,
topPositionsArray,
normalsArray,
cartographicsArray,
compute2dAttributes
) {
var i;
var index;
var ellipsoid = projection._ellipsoid;
// Each segment will have 8 vertices
var segmentCount = bottomPositionsArray.length / 3 - 1;
var vertexCount = segmentCount * 8;
var arraySizeVec4 = vertexCount * 4;
var indexCount = segmentCount * 36;
var indices =
vertexCount > 65535
? new Uint32Array(indexCount)
: new Uint16Array(indexCount);
var positionsArray = new Float64Array(vertexCount * 3);
var startHiAndForwardOffsetX = new Float32Array(arraySizeVec4);
var startLoAndForwardOffsetY = new Float32Array(arraySizeVec4);
var startNormalAndForwardOffsetZ = new Float32Array(arraySizeVec4);
var endNormalAndTextureCoordinateNormalizationX = new Float32Array(
arraySizeVec4
);
var rightNormalAndTextureCoordinateNormalizationY = new Float32Array(
arraySizeVec4
);
var startHiLo2D;
var offsetAndRight2D;
var startEndNormals2D;
var texcoordNormalization2D;
if (compute2dAttributes) {
startHiLo2D = new Float32Array(arraySizeVec4);
offsetAndRight2D = new Float32Array(arraySizeVec4);
startEndNormals2D = new Float32Array(arraySizeVec4);
texcoordNormalization2D = new Float32Array(vertexCount * 2);
}
/*** Compute total lengths for texture coordinate normalization ***/
// 2D
var cartographicsLength = cartographicsArray.length / 2;
var length2D = 0.0;
var startCartographic = startCartographicScratch;
startCartographic.height = 0.0;
var endCartographic = endCartographicScratch;
endCartographic.height = 0.0;
var segmentStartCartesian = segmentStartTopScratch;
var segmentEndCartesian = segmentEndTopScratch;
if (compute2dAttributes) {
index = 0;
for (i = 1; i < cartographicsLength; i++) {
// Don't clone anything from previous segment b/c possible IDL touch
startCartographic.latitude = cartographicsArray[index];
startCartographic.longitude = cartographicsArray[index + 1];
endCartographic.latitude = cartographicsArray[index + 2];
endCartographic.longitude = cartographicsArray[index + 3];
segmentStartCartesian = projection.project(
startCartographic,
segmentStartCartesian
);
segmentEndCartesian = projection.project(
endCartographic,
segmentEndCartesian
);
length2D += Cartesian3.distance(
segmentStartCartesian,
segmentEndCartesian
);
index += 2;
}
}
// 3D
var positionsLength = topPositionsArray.length / 3;
segmentEndCartesian = Cartesian3.unpack(
topPositionsArray,
0,
segmentEndCartesian
);
var length3D = 0.0;
index = 3;
for (i = 1; i < positionsLength; i++) {
segmentStartCartesian = Cartesian3.clone(
segmentEndCartesian,
segmentStartCartesian
);
segmentEndCartesian = Cartesian3.unpack(
topPositionsArray,
index,
segmentEndCartesian
);
length3D += Cartesian3.distance(segmentStartCartesian, segmentEndCartesian);
index += 3;
}
/*** Generate segments ***/
var j;
index = 3;
var cartographicsIndex = 0;
var vec2sWriteIndex = 0;
var vec3sWriteIndex = 0;
var vec4sWriteIndex = 0;
var miterBroken = false;
var endBottom = Cartesian3.unpack(
bottomPositionsArray,
0,
segmentEndBottomScratch
);
var endTop = Cartesian3.unpack(topPositionsArray, 0, segmentEndTopScratch);
var endGeometryNormal = Cartesian3.unpack(
normalsArray,
0,
segmentEndNormalScratch
);
if (loop) {
var preEndBottom = Cartesian3.unpack(
bottomPositionsArray,
bottomPositionsArray.length - 6,
segmentStartBottomScratch
);
if (breakMiter(endGeometryNormal, preEndBottom, endBottom, endTop)) {
// Miter broken as if for the last point in the loop, needs to be inverted for first point (clone of endBottom)
endGeometryNormal = Cartesian3.negate(
endGeometryNormal,
endGeometryNormal
);
}
}
var lengthSoFar3D = 0.0;
var lengthSoFar2D = 0.0;
// For translating bounding volume
var sumHeights = 0.0;
for (i = 0; i < segmentCount; i++) {
var startBottom = Cartesian3.clone(endBottom, segmentStartBottomScratch);
var startTop = Cartesian3.clone(endTop, segmentStartTopScratch);
var startGeometryNormal = Cartesian3.clone(
endGeometryNormal,
segmentStartNormalScratch
);
if (miterBroken) {
startGeometryNormal = Cartesian3.negate(
startGeometryNormal,
startGeometryNormal
);
}
endBottom = Cartesian3.unpack(
bottomPositionsArray,
index,
segmentEndBottomScratch
);
endTop = Cartesian3.unpack(topPositionsArray, index, segmentEndTopScratch);
endGeometryNormal = Cartesian3.unpack(
normalsArray,
index,
segmentEndNormalScratch
);
miterBroken = breakMiter(endGeometryNormal, startBottom, endBottom, endTop);
// 2D - don't clone anything from previous segment b/c possible IDL touch
startCartographic.latitude = cartographicsArray[cartographicsIndex];
startCartographic.longitude = cartographicsArray[cartographicsIndex + 1];
endCartographic.latitude = cartographicsArray[cartographicsIndex + 2];
endCartographic.longitude = cartographicsArray[cartographicsIndex + 3];
var start2D;
var end2D;
var startGeometryNormal2D;
var endGeometryNormal2D;
if (compute2dAttributes) {
var nudgeResult = nudgeCartographic(startCartographic, endCartographic);
start2D = projection.project(startCartographic, segmentStart2DScratch);
end2D = projection.project(endCartographic, segmentEnd2DScratch);
var direction2D = direction(end2D, start2D, forwardOffset2DScratch);
direction2D.y = Math.abs(direction2D.y);
startGeometryNormal2D = segmentStartNormal2DScratch;
endGeometryNormal2D = segmentEndNormal2DScratch;
if (
nudgeResult === 0 ||
Cartesian3.dot(direction2D, Cartesian3.UNIT_Y) > MITER_BREAK_SMALL
) {
// No nudge - project the original normal
// Or, if the line's angle relative to the IDL is very acute,
// in which case snapping will produce oddly shaped volumes.
startGeometryNormal2D = projectNormal(
projection,
startCartographic,
startGeometryNormal,
start2D,
segmentStartNormal2DScratch
);
endGeometryNormal2D = projectNormal(
projection,
endCartographic,
endGeometryNormal,
end2D,
segmentEndNormal2DScratch
);
} else if (nudgeResult === 1) {
// Start is close to IDL - snap start normal to align with IDL
endGeometryNormal2D = projectNormal(
projection,
endCartographic,
endGeometryNormal,
end2D,
segmentEndNormal2DScratch
);
startGeometryNormal2D.x = 0.0;
// If start longitude is negative and end longitude is less negative, relative right is unit -Y
// If start longitude is positive and end longitude is less positive, relative right is unit +Y
startGeometryNormal2D.y = CesiumMath.sign(
startCartographic.longitude - Math.abs(endCartographic.longitude)
);
startGeometryNormal2D.z = 0.0;
} else {
// End is close to IDL - snap end normal to align with IDL
startGeometryNormal2D = projectNormal(
projection,
startCartographic,
startGeometryNormal,
start2D,
segmentStartNormal2DScratch
);
endGeometryNormal2D.x = 0.0;
// If end longitude is negative and start longitude is less negative, relative right is unit Y
// If end longitude is positive and start longitude is less positive, relative right is unit -Y
endGeometryNormal2D.y = CesiumMath.sign(
startCartographic.longitude - endCartographic.longitude
);
endGeometryNormal2D.z = 0.0;
}
}
/****************************************
* Geometry descriptors of a "line on terrain,"
* as opposed to the "shadow volume used to draw
* the line on terrain":
* - position of start + offset to end
* - start, end, and right-facing planes
* - encoded texture coordinate offsets
****************************************/
/* 3D */
var segmentLength3D = Cartesian3.distance(startTop, endTop);
var encodedStart = EncodedCartesian3.fromCartesian(
startBottom,
encodeScratch
);
var forwardOffset = Cartesian3.subtract(
endBottom,
startBottom,
offsetScratch
);
var forward = Cartesian3.normalize(forwardOffset, rightScratch);
var startUp = Cartesian3.subtract(startTop, startBottom, startUpScratch);
startUp = Cartesian3.normalize(startUp, startUp);
var rightNormal = Cartesian3.cross(forward, startUp, rightScratch);
rightNormal = Cartesian3.normalize(rightNormal, rightNormal);
var startPlaneNormal = Cartesian3.cross(
startUp,
startGeometryNormal,
startPlaneNormalScratch
);
startPlaneNormal = Cartesian3.normalize(startPlaneNormal, startPlaneNormal);
var endUp = Cartesian3.subtract(endTop, endBottom, endUpScratch);
endUp = Cartesian3.normalize(endUp, endUp);
var endPlaneNormal = Cartesian3.cross(
endGeometryNormal,
endUp,
endPlaneNormalScratch
);
endPlaneNormal = Cartesian3.normalize(endPlaneNormal, endPlaneNormal);
var texcoordNormalization3DX = segmentLength3D / length3D;
var texcoordNormalization3DY = lengthSoFar3D / length3D;
/* 2D */
var segmentLength2D = 0.0;
var encodedStart2D;
var forwardOffset2D;
var right2D;
var texcoordNormalization2DX = 0.0;
var texcoordNormalization2DY = 0.0;
if (compute2dAttributes) {
segmentLength2D = Cartesian3.distance(start2D, end2D);
encodedStart2D = EncodedCartesian3.fromCartesian(
start2D,
encodeScratch2D
);
forwardOffset2D = Cartesian3.subtract(
end2D,
start2D,
forwardOffset2DScratch
);
// Right direction is just forward direction rotated by -90 degrees around Z
// Similarly with plane normals
right2D = Cartesian3.normalize(forwardOffset2D, right2DScratch);
var swap = right2D.x;
right2D.x = right2D.y;
right2D.y = -swap;
texcoordNormalization2DX = segmentLength2D / length2D;
texcoordNormalization2DY = lengthSoFar2D / length2D;
}
/** Pack **/
for (j = 0; j < 8; j++) {
var vec4Index = vec4sWriteIndex + j * 4;
var vec2Index = vec2sWriteIndex + j * 2;
var wIndex = vec4Index + 3;
// Encode sidedness of vertex relative to right plane in texture coordinate normalization X,
// whether vertex is top or bottom of volume in sign/magnitude of normalization Y.
var rightPlaneSide = j < 4 ? 1.0 : -1.0;
var topBottomSide = j === 2 || j === 3 || j === 6 || j === 7 ? 1.0 : -1.0;
// 3D
Cartesian3.pack(encodedStart.high, startHiAndForwardOffsetX, vec4Index);
startHiAndForwardOffsetX[wIndex] = forwardOffset.x;
Cartesian3.pack(encodedStart.low, startLoAndForwardOffsetY, vec4Index);
startLoAndForwardOffsetY[wIndex] = forwardOffset.y;
Cartesian3.pack(
startPlaneNormal,
startNormalAndForwardOffsetZ,
vec4Index
);
startNormalAndForwardOffsetZ[wIndex] = forwardOffset.z;
Cartesian3.pack(
endPlaneNormal,
endNormalAndTextureCoordinateNormalizationX,
vec4Index
);
endNormalAndTextureCoordinateNormalizationX[wIndex] =
texcoordNormalization3DX * rightPlaneSide;
Cartesian3.pack(
rightNormal,
rightNormalAndTextureCoordinateNormalizationY,
vec4Index
);
var texcoordNormalization = texcoordNormalization3DY * topBottomSide;
if (texcoordNormalization === 0.0 && topBottomSide < 0.0) {
texcoordNormalization = 9.0; // some value greater than 1.0
}
rightNormalAndTextureCoordinateNormalizationY[
wIndex
] = texcoordNormalization;
// 2D
if (compute2dAttributes) {
startHiLo2D[vec4Index] = encodedStart2D.high.x;
startHiLo2D[vec4Index + 1] = encodedStart2D.high.y;
startHiLo2D[vec4Index + 2] = encodedStart2D.low.x;
startHiLo2D[vec4Index + 3] = encodedStart2D.low.y;
startEndNormals2D[vec4Index] = -startGeometryNormal2D.y;
startEndNormals2D[vec4Index + 1] = startGeometryNormal2D.x;
startEndNormals2D[vec4Index + 2] = endGeometryNormal2D.y;
startEndNormals2D[vec4Index + 3] = -endGeometryNormal2D.x;
offsetAndRight2D[vec4Index] = forwardOffset2D.x;
offsetAndRight2D[vec4Index + 1] = forwardOffset2D.y;
offsetAndRight2D[vec4Index + 2] = right2D.x;
offsetAndRight2D[vec4Index + 3] = right2D.y;
texcoordNormalization2D[vec2Index] =
texcoordNormalization2DX * rightPlaneSide;
texcoordNormalization = texcoordNormalization2DY * topBottomSide;
if (texcoordNormalization === 0.0 && topBottomSide < 0.0) {
texcoordNormalization = 9.0; // some value greater than 1.0
}
texcoordNormalization2D[vec2Index + 1] = texcoordNormalization;
}
}
// Adjust height of volume in 3D
var adjustHeightStartBottom = adjustHeightStartBottomScratch;
var adjustHeightEndBottom = adjustHeightEndBottomScratch;
var adjustHeightStartTop = adjustHeightStartTopScratch;
var adjustHeightEndTop = adjustHeightEndTopScratch;
var getHeightsRectangle = Rectangle.fromCartographicArray(
getHeightCartographics,
getHeightRectangleScratch
);
var minMaxHeights = ApproximateTerrainHeights.getMinimumMaximumHeights(
getHeightsRectangle,
ellipsoid
);
var minHeight = minMaxHeights.minimumTerrainHeight;
var maxHeight = minMaxHeights.maximumTerrainHeight;
sumHeights += minHeight;
sumHeights += maxHeight;
adjustHeights(
startBottom,
startTop,
minHeight,
maxHeight,
adjustHeightStartBottom,
adjustHeightStartTop
);
adjustHeights(
endBottom,
endTop,
minHeight,
maxHeight,
adjustHeightEndBottom,
adjustHeightEndTop
);
// Nudge the positions away from the "polyline" a little bit to prevent errors in GeometryPipeline
var normalNudge = Cartesian3.multiplyByScalar(
rightNormal,
CesiumMath.EPSILON5,
normalNudgeScratch
);
Cartesian3.add(
adjustHeightStartBottom,
normalNudge,
adjustHeightStartBottom
);
Cartesian3.add(adjustHeightEndBottom, normalNudge, adjustHeightEndBottom);
Cartesian3.add(adjustHeightStartTop, normalNudge, adjustHeightStartTop);
Cartesian3.add(adjustHeightEndTop, normalNudge, adjustHeightEndTop);
// If the segment is very close to the XZ plane, nudge the vertices slightly to avoid touching it.
nudgeXZ(adjustHeightStartBottom, adjustHeightEndBottom);
nudgeXZ(adjustHeightStartTop, adjustHeightEndTop);
Cartesian3.pack(adjustHeightStartBottom, positionsArray, vec3sWriteIndex);
Cartesian3.pack(adjustHeightEndBottom, positionsArray, vec3sWriteIndex + 3);
Cartesian3.pack(adjustHeightEndTop, positionsArray, vec3sWriteIndex + 6);
Cartesian3.pack(adjustHeightStartTop, positionsArray, vec3sWriteIndex + 9);
normalNudge = Cartesian3.multiplyByScalar(
rightNormal,
-2.0 * CesiumMath.EPSILON5,
normalNudgeScratch
);
Cartesian3.add(
adjustHeightStartBottom,
normalNudge,
adjustHeightStartBottom
);
Cartesian3.add(adjustHeightEndBottom, normalNudge, adjustHeightEndBottom);
Cartesian3.add(adjustHeightStartTop, normalNudge, adjustHeightStartTop);
Cartesian3.add(adjustHeightEndTop, normalNudge, adjustHeightEndTop);
nudgeXZ(adjustHeightStartBottom, adjustHeightEndBottom);
nudgeXZ(adjustHeightStartTop, adjustHeightEndTop);
Cartesian3.pack(
adjustHeightStartBottom,
positionsArray,
vec3sWriteIndex + 12
);
Cartesian3.pack(
adjustHeightEndBottom,
positionsArray,
vec3sWriteIndex + 15
);
Cartesian3.pack(adjustHeightEndTop, positionsArray, vec3sWriteIndex + 18);
Cartesian3.pack(adjustHeightStartTop, positionsArray, vec3sWriteIndex + 21);
cartographicsIndex += 2;
index += 3;
vec2sWriteIndex += 16;
vec3sWriteIndex += 24;
vec4sWriteIndex += 32;
lengthSoFar3D += segmentLength3D;
lengthSoFar2D += segmentLength2D;
}
index = 0;
var indexOffset = 0;
for (i = 0; i < segmentCount; i++) {
for (j = 0; j < REFERENCE_INDICES_LENGTH; j++) {
indices[index + j] = REFERENCE_INDICES[j] + indexOffset;
}
indexOffset += 8;
index += REFERENCE_INDICES_LENGTH;
}
var boundingSpheres = scratchBoundingSpheres;
BoundingSphere.fromVertices(
bottomPositionsArray,
Cartesian3.ZERO,
3,
boundingSpheres[0]
);
BoundingSphere.fromVertices(
topPositionsArray,
Cartesian3.ZERO,
3,
boundingSpheres[1]
);
var boundingSphere = BoundingSphere.fromBoundingSpheres(boundingSpheres);
// Adjust bounding sphere height and radius to cover more of the volume
boundingSphere.radius += sumHeights / (segmentCount * 2.0);
var attributes = {
position: new GeometryAttribute({
componentDatatype: ComponentDatatype.DOUBLE,
componentsPerAttribute: 3,
normalize: false,
values: positionsArray,
}),
startHiAndForwardOffsetX: getVec4GeometryAttribute(
startHiAndForwardOffsetX
),
startLoAndForwardOffsetY: getVec4GeometryAttribute(
startLoAndForwardOffsetY
),
startNormalAndForwardOffsetZ: getVec4GeometryAttribute(
startNormalAndForwardOffsetZ
),
endNormalAndTextureCoordinateNormalizationX: getVec4GeometryAttribute(
endNormalAndTextureCoordinateNormalizationX
),
rightNormalAndTextureCoordinateNormalizationY: getVec4GeometryAttribute(
rightNormalAndTextureCoordinateNormalizationY
),
};
if (compute2dAttributes) {
attributes.startHiLo2D = getVec4GeometryAttribute(startHiLo2D);
attributes.offsetAndRight2D = getVec4GeometryAttribute(offsetAndRight2D);
attributes.startEndNormals2D = getVec4GeometryAttribute(startEndNormals2D);
attributes.texcoordNormalization2D = new GeometryAttribute({
componentDatatype: ComponentDatatype.FLOAT,
componentsPerAttribute: 2,
normalize: false,
values: texcoordNormalization2D,
});
}
return new Geometry({
attributes: attributes,
indices: indices,
boundingSphere: boundingSphere,
});
}
function getVec4GeometryAttribute(typedArray) {
return new GeometryAttribute({
componentDatatype: ComponentDatatype.FLOAT,
componentsPerAttribute: 4,
normalize: false,
values: typedArray,
});
}
/**
* Approximates an ellipsoid-tangent vector in 2D by projecting the end point into 2D.
* Exposed for testing.
*
* @param {MapProjection} projection Map Projection for projecting coordinates to 2D.
* @param {Cartographic} cartographic The cartographic origin point of the normal.
* Used to check if the normal crosses the IDL during projection.
* @param {Cartesian3} normal The normal in 3D.
* @param {Cartesian3} projectedPosition The projected origin point of the normal in 2D.
* @param {Cartesian3} result Result parameter on which to store the projected normal.
* @private
*/
GroundPolylineGeometry._projectNormal = projectNormal;
export default GroundPolylineGeometry;
