Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | 11x 11x 11x 11x 9x 1x 1x 6x 5x 1x 1x 1x 4x 3x 3x 3x 3x 3x 3x 1x 9x | import Cartesian3 from "./Cartesian3.js";
import Check from "./Check.js";
import defined from "./defined.js";
import EllipsoidGeometry from "./EllipsoidGeometry.js";
import VertexFormat from "./VertexFormat.js";
/**
* A description of a sphere centered at the origin.
*
* @alias SphereGeometry
* @constructor
*
* @param {object} [options] Object with the following properties:
* @param {number} [options.radius=1.0] The radius of the sphere.
* @param {number} [options.stackPartitions=64] The number of times to partition the ellipsoid into stacks.
* @param {number} [options.slicePartitions=64] The number of times to partition the ellipsoid into radial slices.
* @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
*
* @exception {DeveloperError} options.slicePartitions cannot be less than three.
* @exception {DeveloperError} options.stackPartitions cannot be less than three.
*
* @see SphereGeometry#createGeometry
*
* @example
* const sphere = new Cesium.SphereGeometry({
* radius : 100.0,
* vertexFormat : Cesium.VertexFormat.POSITION_ONLY
* });
* const geometry = Cesium.SphereGeometry.createGeometry(sphere);
*/
function SphereGeometry(options) {
const radius = options.radius ?? 1.0;
const radii = new Cartesian3(radius, radius, radius);
const ellipsoidOptions = {
radii: radii,
stackPartitions: options.stackPartitions,
slicePartitions: options.slicePartitions,
vertexFormat: options.vertexFormat,
};
this._ellipsoidGeometry = new EllipsoidGeometry(ellipsoidOptions);
this._workerName = "createSphereGeometry";
}
/**
* The number of elements used to pack the object into an array.
* @type {number}
*/
SphereGeometry.packedLength = EllipsoidGeometry.packedLength;
/**
* Stores the provided instance into the provided array.
*
* @param {SphereGeometry} 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
*/
SphereGeometry.pack = function (value, array, startingIndex) {
//>>includeStart('debug', pragmas.debug);
Check.typeOf.object("value", value);
//>>includeEnd('debug');
return EllipsoidGeometry.pack(value._ellipsoidGeometry, array, startingIndex);
};
const scratchEllipsoidGeometry = new EllipsoidGeometry();
const scratchOptions = {
radius: undefined,
radii: new Cartesian3(),
vertexFormat: new VertexFormat(),
stackPartitions: undefined,
slicePartitions: 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 {SphereGeometry} [result] The object into which to store the result.
* @returns {SphereGeometry} The modified result parameter or a new SphereGeometry instance if one was not provided.
*/
SphereGeometry.unpack = function (array, startingIndex, result) {
const ellipsoidGeometry = EllipsoidGeometry.unpack(
array,
startingIndex,
scratchEllipsoidGeometry,
);
scratchOptions.vertexFormat = VertexFormat.clone(
ellipsoidGeometry._vertexFormat,
scratchOptions.vertexFormat,
);
scratchOptions.stackPartitions = ellipsoidGeometry._stackPartitions;
scratchOptions.slicePartitions = ellipsoidGeometry._slicePartitions;
Eif (!defined(result)) {
scratchOptions.radius = ellipsoidGeometry._radii.x;
return new SphereGeometry(scratchOptions);
}
Cartesian3.clone(ellipsoidGeometry._radii, scratchOptions.radii);
result._ellipsoidGeometry = new EllipsoidGeometry(scratchOptions);
return result;
};
/**
* Computes the geometric representation of a sphere, including its vertices, indices, and a bounding sphere.
*
* @param {SphereGeometry} sphereGeometry A description of the sphere.
* @returns {Geometry|undefined} The computed vertices and indices.
*/
SphereGeometry.createGeometry = function (sphereGeometry) {
return EllipsoidGeometry.createGeometry(sphereGeometry._ellipsoidGeometry);
};
export default SphereGeometry;
|