You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
467 lines
16 KiB
JavaScript
467 lines
16 KiB
JavaScript
import arrayFill from "./arrayFill.js";
|
|
import BoundingSphere from "./BoundingSphere.js";
|
|
import Cartesian3 from "./Cartesian3.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 Geometry from "./Geometry.js";
|
|
import GeometryAttribute from "./GeometryAttribute.js";
|
|
import GeometryAttributes from "./GeometryAttributes.js";
|
|
import GeometryOffsetAttribute from "./GeometryOffsetAttribute.js";
|
|
import IndexDatatype from "./IndexDatatype.js";
|
|
import CesiumMath from "./Math.js";
|
|
import PrimitiveType from "./PrimitiveType.js";
|
|
|
|
var defaultRadii = new Cartesian3(1.0, 1.0, 1.0);
|
|
var cos = Math.cos;
|
|
var sin = Math.sin;
|
|
|
|
/**
|
|
* A description of the outline of an ellipsoid centered at the origin.
|
|
*
|
|
* @alias EllipsoidOutlineGeometry
|
|
* @constructor
|
|
*
|
|
* @param {Object} [options] Object with the following properties:
|
|
* @param {Cartesian3} [options.radii=Cartesian3(1.0, 1.0, 1.0)] The radii of the ellipsoid in the x, y, and z directions.
|
|
* @param {Cartesian3} [options.innerRadii=options.radii] The inner radii of the ellipsoid in the x, y, and z directions.
|
|
* @param {Number} [options.minimumClock=0.0] The minimum angle lying in the xy-plane measured from the positive x-axis and toward the positive y-axis.
|
|
* @param {Number} [options.maximumClock=2*PI] The maximum angle lying in the xy-plane measured from the positive x-axis and toward the positive y-axis.
|
|
* @param {Number} [options.minimumCone=0.0] The minimum angle measured from the positive z-axis and toward the negative z-axis.
|
|
* @param {Number} [options.maximumCone=PI] The maximum angle measured from the positive z-axis and toward the negative z-axis.
|
|
* @param {Number} [options.stackPartitions=10] The count of stacks for the ellipsoid (1 greater than the number of parallel lines).
|
|
* @param {Number} [options.slicePartitions=8] The count of slices for the ellipsoid (Equal to the number of radial lines).
|
|
* @param {Number} [options.subdivisions=128] The number of points per line, determining the granularity of the curvature.
|
|
*
|
|
* @exception {DeveloperError} options.stackPartitions must be greater than or equal to one.
|
|
* @exception {DeveloperError} options.slicePartitions must be greater than or equal to zero.
|
|
* @exception {DeveloperError} options.subdivisions must be greater than or equal to zero.
|
|
*
|
|
* @example
|
|
* var ellipsoid = new Cesium.EllipsoidOutlineGeometry({
|
|
* radii : new Cesium.Cartesian3(1000000.0, 500000.0, 500000.0),
|
|
* stackPartitions: 6,
|
|
* slicePartitions: 5
|
|
* });
|
|
* var geometry = Cesium.EllipsoidOutlineGeometry.createGeometry(ellipsoid);
|
|
*/
|
|
function EllipsoidOutlineGeometry(options) {
|
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
|
|
|
var radii = defaultValue(options.radii, defaultRadii);
|
|
var innerRadii = defaultValue(options.innerRadii, radii);
|
|
var minimumClock = defaultValue(options.minimumClock, 0.0);
|
|
var maximumClock = defaultValue(options.maximumClock, CesiumMath.TWO_PI);
|
|
var minimumCone = defaultValue(options.minimumCone, 0.0);
|
|
var maximumCone = defaultValue(options.maximumCone, CesiumMath.PI);
|
|
var stackPartitions = Math.round(defaultValue(options.stackPartitions, 10));
|
|
var slicePartitions = Math.round(defaultValue(options.slicePartitions, 8));
|
|
var subdivisions = Math.round(defaultValue(options.subdivisions, 128));
|
|
|
|
//>>includeStart('debug', pragmas.debug);
|
|
if (stackPartitions < 1) {
|
|
throw new DeveloperError("options.stackPartitions cannot be less than 1");
|
|
}
|
|
if (slicePartitions < 0) {
|
|
throw new DeveloperError("options.slicePartitions cannot be less than 0");
|
|
}
|
|
if (subdivisions < 0) {
|
|
throw new DeveloperError(
|
|
"options.subdivisions must be greater than or equal to zero."
|
|
);
|
|
}
|
|
if (
|
|
defined(options.offsetAttribute) &&
|
|
options.offsetAttribute === GeometryOffsetAttribute.TOP
|
|
) {
|
|
throw new DeveloperError(
|
|
"GeometryOffsetAttribute.TOP is not a supported options.offsetAttribute for this geometry."
|
|
);
|
|
}
|
|
//>>includeEnd('debug');
|
|
|
|
this._radii = Cartesian3.clone(radii);
|
|
this._innerRadii = Cartesian3.clone(innerRadii);
|
|
this._minimumClock = minimumClock;
|
|
this._maximumClock = maximumClock;
|
|
this._minimumCone = minimumCone;
|
|
this._maximumCone = maximumCone;
|
|
this._stackPartitions = stackPartitions;
|
|
this._slicePartitions = slicePartitions;
|
|
this._subdivisions = subdivisions;
|
|
this._offsetAttribute = options.offsetAttribute;
|
|
this._workerName = "createEllipsoidOutlineGeometry";
|
|
}
|
|
|
|
/**
|
|
* The number of elements used to pack the object into an array.
|
|
* @type {Number}
|
|
*/
|
|
EllipsoidOutlineGeometry.packedLength = 2 * Cartesian3.packedLength + 8;
|
|
|
|
/**
|
|
* Stores the provided instance into the provided array.
|
|
*
|
|
* @param {EllipsoidOutlineGeometry} 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
|
|
*/
|
|
EllipsoidOutlineGeometry.pack = function (value, array, startingIndex) {
|
|
//>>includeStart('debug', pragmas.debug);
|
|
if (!defined(value)) {
|
|
throw new DeveloperError("value is required");
|
|
}
|
|
if (!defined(array)) {
|
|
throw new DeveloperError("array is required");
|
|
}
|
|
//>>includeEnd('debug');
|
|
|
|
startingIndex = defaultValue(startingIndex, 0);
|
|
|
|
Cartesian3.pack(value._radii, array, startingIndex);
|
|
startingIndex += Cartesian3.packedLength;
|
|
|
|
Cartesian3.pack(value._innerRadii, array, startingIndex);
|
|
startingIndex += Cartesian3.packedLength;
|
|
|
|
array[startingIndex++] = value._minimumClock;
|
|
array[startingIndex++] = value._maximumClock;
|
|
array[startingIndex++] = value._minimumCone;
|
|
array[startingIndex++] = value._maximumCone;
|
|
array[startingIndex++] = value._stackPartitions;
|
|
array[startingIndex++] = value._slicePartitions;
|
|
array[startingIndex++] = value._subdivisions;
|
|
array[startingIndex] = defaultValue(value._offsetAttribute, -1);
|
|
|
|
return array;
|
|
};
|
|
|
|
var scratchRadii = new Cartesian3();
|
|
var scratchInnerRadii = new Cartesian3();
|
|
var scratchOptions = {
|
|
radii: scratchRadii,
|
|
innerRadii: scratchInnerRadii,
|
|
minimumClock: undefined,
|
|
maximumClock: undefined,
|
|
minimumCone: undefined,
|
|
maximumCone: undefined,
|
|
stackPartitions: undefined,
|
|
slicePartitions: undefined,
|
|
subdivisions: undefined,
|
|
offsetAttribute: undefined,
|
|
};
|
|
|
|
/**
|
|
* 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 {EllipsoidOutlineGeometry} [result] The object into which to store the result.
|
|
* @returns {EllipsoidOutlineGeometry} The modified result parameter or a new EllipsoidOutlineGeometry instance if one was not provided.
|
|
*/
|
|
EllipsoidOutlineGeometry.unpack = function (array, startingIndex, result) {
|
|
//>>includeStart('debug', pragmas.debug);
|
|
if (!defined(array)) {
|
|
throw new DeveloperError("array is required");
|
|
}
|
|
//>>includeEnd('debug');
|
|
|
|
startingIndex = defaultValue(startingIndex, 0);
|
|
|
|
var radii = Cartesian3.unpack(array, startingIndex, scratchRadii);
|
|
startingIndex += Cartesian3.packedLength;
|
|
|
|
var innerRadii = Cartesian3.unpack(array, startingIndex, scratchInnerRadii);
|
|
startingIndex += Cartesian3.packedLength;
|
|
|
|
var minimumClock = array[startingIndex++];
|
|
var maximumClock = array[startingIndex++];
|
|
var minimumCone = array[startingIndex++];
|
|
var maximumCone = array[startingIndex++];
|
|
var stackPartitions = array[startingIndex++];
|
|
var slicePartitions = array[startingIndex++];
|
|
var subdivisions = array[startingIndex++];
|
|
var offsetAttribute = array[startingIndex];
|
|
|
|
if (!defined(result)) {
|
|
scratchOptions.minimumClock = minimumClock;
|
|
scratchOptions.maximumClock = maximumClock;
|
|
scratchOptions.minimumCone = minimumCone;
|
|
scratchOptions.maximumCone = maximumCone;
|
|
scratchOptions.stackPartitions = stackPartitions;
|
|
scratchOptions.slicePartitions = slicePartitions;
|
|
scratchOptions.subdivisions = subdivisions;
|
|
scratchOptions.offsetAttribute =
|
|
offsetAttribute === -1 ? undefined : offsetAttribute;
|
|
return new EllipsoidOutlineGeometry(scratchOptions);
|
|
}
|
|
|
|
result._radii = Cartesian3.clone(radii, result._radii);
|
|
result._innerRadii = Cartesian3.clone(innerRadii, result._innerRadii);
|
|
result._minimumClock = minimumClock;
|
|
result._maximumClock = maximumClock;
|
|
result._minimumCone = minimumCone;
|
|
result._maximumCone = maximumCone;
|
|
result._stackPartitions = stackPartitions;
|
|
result._slicePartitions = slicePartitions;
|
|
result._subdivisions = subdivisions;
|
|
result._offsetAttribute =
|
|
offsetAttribute === -1 ? undefined : offsetAttribute;
|
|
|
|
return result;
|
|
};
|
|
|
|
/**
|
|
* Computes the geometric representation of an outline of an ellipsoid, including its vertices, indices, and a bounding sphere.
|
|
*
|
|
* @param {EllipsoidOutlineGeometry} ellipsoidGeometry A description of the ellipsoid outline.
|
|
* @returns {Geometry|undefined} The computed vertices and indices.
|
|
*/
|
|
EllipsoidOutlineGeometry.createGeometry = function (ellipsoidGeometry) {
|
|
var radii = ellipsoidGeometry._radii;
|
|
if (radii.x <= 0 || radii.y <= 0 || radii.z <= 0) {
|
|
return;
|
|
}
|
|
|
|
var innerRadii = ellipsoidGeometry._innerRadii;
|
|
if (innerRadii.x <= 0 || innerRadii.y <= 0 || innerRadii.z <= 0) {
|
|
return;
|
|
}
|
|
|
|
var minimumClock = ellipsoidGeometry._minimumClock;
|
|
var maximumClock = ellipsoidGeometry._maximumClock;
|
|
var minimumCone = ellipsoidGeometry._minimumCone;
|
|
var maximumCone = ellipsoidGeometry._maximumCone;
|
|
var subdivisions = ellipsoidGeometry._subdivisions;
|
|
var ellipsoid = Ellipsoid.fromCartesian3(radii);
|
|
|
|
// Add an extra slice and stack to remain consistent with EllipsoidGeometry
|
|
var slicePartitions = ellipsoidGeometry._slicePartitions + 1;
|
|
var stackPartitions = ellipsoidGeometry._stackPartitions + 1;
|
|
|
|
slicePartitions = Math.round(
|
|
(slicePartitions * Math.abs(maximumClock - minimumClock)) /
|
|
CesiumMath.TWO_PI
|
|
);
|
|
stackPartitions = Math.round(
|
|
(stackPartitions * Math.abs(maximumCone - minimumCone)) / CesiumMath.PI
|
|
);
|
|
|
|
if (slicePartitions < 2) {
|
|
slicePartitions = 2;
|
|
}
|
|
if (stackPartitions < 2) {
|
|
stackPartitions = 2;
|
|
}
|
|
|
|
var extraIndices = 0;
|
|
var vertexMultiplier = 1.0;
|
|
var hasInnerSurface =
|
|
innerRadii.x !== radii.x ||
|
|
innerRadii.y !== radii.y ||
|
|
innerRadii.z !== radii.z;
|
|
var isTopOpen = false;
|
|
var isBotOpen = false;
|
|
if (hasInnerSurface) {
|
|
vertexMultiplier = 2.0;
|
|
// Add 2x slicePartitions to connect the top/bottom of the outer to
|
|
// the top/bottom of the inner
|
|
if (minimumCone > 0.0) {
|
|
isTopOpen = true;
|
|
extraIndices += slicePartitions;
|
|
}
|
|
if (maximumCone < Math.PI) {
|
|
isBotOpen = true;
|
|
extraIndices += slicePartitions;
|
|
}
|
|
}
|
|
|
|
var vertexCount =
|
|
subdivisions * vertexMultiplier * (stackPartitions + slicePartitions);
|
|
var positions = new Float64Array(vertexCount * 3);
|
|
|
|
// Multiply by two because two points define each line segment
|
|
var numIndices =
|
|
2 *
|
|
(vertexCount +
|
|
extraIndices -
|
|
(slicePartitions + stackPartitions) * vertexMultiplier);
|
|
var indices = IndexDatatype.createTypedArray(vertexCount, numIndices);
|
|
|
|
var i;
|
|
var j;
|
|
var theta;
|
|
var phi;
|
|
var index = 0;
|
|
|
|
// Calculate sin/cos phi
|
|
var sinPhi = new Array(stackPartitions);
|
|
var cosPhi = new Array(stackPartitions);
|
|
for (i = 0; i < stackPartitions; i++) {
|
|
phi =
|
|
minimumCone + (i * (maximumCone - minimumCone)) / (stackPartitions - 1);
|
|
sinPhi[i] = sin(phi);
|
|
cosPhi[i] = cos(phi);
|
|
}
|
|
|
|
// Calculate sin/cos theta
|
|
var sinTheta = new Array(subdivisions);
|
|
var cosTheta = new Array(subdivisions);
|
|
for (i = 0; i < subdivisions; i++) {
|
|
theta =
|
|
minimumClock + (i * (maximumClock - minimumClock)) / (subdivisions - 1);
|
|
sinTheta[i] = sin(theta);
|
|
cosTheta[i] = cos(theta);
|
|
}
|
|
|
|
// Calculate the latitude lines on the outer surface
|
|
for (i = 0; i < stackPartitions; i++) {
|
|
for (j = 0; j < subdivisions; j++) {
|
|
positions[index++] = radii.x * sinPhi[i] * cosTheta[j];
|
|
positions[index++] = radii.y * sinPhi[i] * sinTheta[j];
|
|
positions[index++] = radii.z * cosPhi[i];
|
|
}
|
|
}
|
|
|
|
// Calculate the latitude lines on the inner surface
|
|
if (hasInnerSurface) {
|
|
for (i = 0; i < stackPartitions; i++) {
|
|
for (j = 0; j < subdivisions; j++) {
|
|
positions[index++] = innerRadii.x * sinPhi[i] * cosTheta[j];
|
|
positions[index++] = innerRadii.y * sinPhi[i] * sinTheta[j];
|
|
positions[index++] = innerRadii.z * cosPhi[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Calculate sin/cos phi
|
|
sinPhi.length = subdivisions;
|
|
cosPhi.length = subdivisions;
|
|
for (i = 0; i < subdivisions; i++) {
|
|
phi = minimumCone + (i * (maximumCone - minimumCone)) / (subdivisions - 1);
|
|
sinPhi[i] = sin(phi);
|
|
cosPhi[i] = cos(phi);
|
|
}
|
|
|
|
// Calculate sin/cos theta for each slice partition
|
|
sinTheta.length = slicePartitions;
|
|
cosTheta.length = slicePartitions;
|
|
for (i = 0; i < slicePartitions; i++) {
|
|
theta =
|
|
minimumClock +
|
|
(i * (maximumClock - minimumClock)) / (slicePartitions - 1);
|
|
sinTheta[i] = sin(theta);
|
|
cosTheta[i] = cos(theta);
|
|
}
|
|
|
|
// Calculate the longitude lines on the outer surface
|
|
for (i = 0; i < subdivisions; i++) {
|
|
for (j = 0; j < slicePartitions; j++) {
|
|
positions[index++] = radii.x * sinPhi[i] * cosTheta[j];
|
|
positions[index++] = radii.y * sinPhi[i] * sinTheta[j];
|
|
positions[index++] = radii.z * cosPhi[i];
|
|
}
|
|
}
|
|
|
|
// Calculate the longitude lines on the inner surface
|
|
if (hasInnerSurface) {
|
|
for (i = 0; i < subdivisions; i++) {
|
|
for (j = 0; j < slicePartitions; j++) {
|
|
positions[index++] = innerRadii.x * sinPhi[i] * cosTheta[j];
|
|
positions[index++] = innerRadii.y * sinPhi[i] * sinTheta[j];
|
|
positions[index++] = innerRadii.z * cosPhi[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create indices for the latitude lines
|
|
index = 0;
|
|
for (i = 0; i < stackPartitions * vertexMultiplier; i++) {
|
|
var topOffset = i * subdivisions;
|
|
for (j = 0; j < subdivisions - 1; j++) {
|
|
indices[index++] = topOffset + j;
|
|
indices[index++] = topOffset + j + 1;
|
|
}
|
|
}
|
|
|
|
// Create indices for the outer longitude lines
|
|
var offset = stackPartitions * subdivisions * vertexMultiplier;
|
|
for (i = 0; i < slicePartitions; i++) {
|
|
for (j = 0; j < subdivisions - 1; j++) {
|
|
indices[index++] = offset + i + j * slicePartitions;
|
|
indices[index++] = offset + i + (j + 1) * slicePartitions;
|
|
}
|
|
}
|
|
|
|
// Create indices for the inner longitude lines
|
|
if (hasInnerSurface) {
|
|
offset =
|
|
stackPartitions * subdivisions * vertexMultiplier +
|
|
slicePartitions * subdivisions;
|
|
for (i = 0; i < slicePartitions; i++) {
|
|
for (j = 0; j < subdivisions - 1; j++) {
|
|
indices[index++] = offset + i + j * slicePartitions;
|
|
indices[index++] = offset + i + (j + 1) * slicePartitions;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasInnerSurface) {
|
|
var outerOffset = stackPartitions * subdivisions * vertexMultiplier;
|
|
var innerOffset = outerOffset + subdivisions * slicePartitions;
|
|
if (isTopOpen) {
|
|
// Draw lines from the top of the inner surface to the top of the outer surface
|
|
for (i = 0; i < slicePartitions; i++) {
|
|
indices[index++] = outerOffset + i;
|
|
indices[index++] = innerOffset + i;
|
|
}
|
|
}
|
|
|
|
if (isBotOpen) {
|
|
// Draw lines from the top of the inner surface to the top of the outer surface
|
|
outerOffset += subdivisions * slicePartitions - slicePartitions;
|
|
innerOffset += subdivisions * slicePartitions - slicePartitions;
|
|
for (i = 0; i < slicePartitions; i++) {
|
|
indices[index++] = outerOffset + i;
|
|
indices[index++] = innerOffset + i;
|
|
}
|
|
}
|
|
}
|
|
|
|
var attributes = new GeometryAttributes({
|
|
position: new GeometryAttribute({
|
|
componentDatatype: ComponentDatatype.DOUBLE,
|
|
componentsPerAttribute: 3,
|
|
values: positions,
|
|
}),
|
|
});
|
|
|
|
if (defined(ellipsoidGeometry._offsetAttribute)) {
|
|
var length = positions.length;
|
|
var applyOffset = new Uint8Array(length / 3);
|
|
var offsetValue =
|
|
ellipsoidGeometry._offsetAttribute === GeometryOffsetAttribute.NONE
|
|
? 0
|
|
: 1;
|
|
arrayFill(applyOffset, offsetValue);
|
|
attributes.applyOffset = new GeometryAttribute({
|
|
componentDatatype: ComponentDatatype.UNSIGNED_BYTE,
|
|
componentsPerAttribute: 1,
|
|
values: applyOffset,
|
|
});
|
|
}
|
|
|
|
return new Geometry({
|
|
attributes: attributes,
|
|
indices: indices,
|
|
primitiveType: PrimitiveType.LINES,
|
|
boundingSphere: BoundingSphere.fromEllipsoid(ellipsoid),
|
|
offsetAttribute: ellipsoidGeometry._offsetAttribute,
|
|
});
|
|
};
|
|
export default EllipsoidOutlineGeometry;
|