@cesium/engine 23.0.1 → 25.0.0

package/Source/Scene/VectorGltf3DTileContent.js

@@ -0,0 +1,403 @@
+// @ts-check
+
+import BufferPoint from "./BufferPoint.js";
+import BufferPointCollection from "./BufferPointCollection.js";
+import BufferPointMaterial from "./BufferPointMaterial.js";
+import BufferPolygon from "./BufferPolygon.js";
+import BufferPolygonCollection from "./BufferPolygonCollection.js";
+import BufferPolygonMaterial from "./BufferPolygonMaterial.js";
+import BufferPolyline from "./BufferPolyline.js";
+import BufferPolylineCollection from "./BufferPolylineCollection.js";
+import BufferPolylineMaterial from "./BufferPolylineMaterial.js";
+import Cesium3DTileStyle from "./Cesium3DTileStyle.js";
+import Color from "../Core/Color.js";
+import Matrix4 from "../Core/Matrix4.js";
+import Model from "./Model/Model.js";
+import ModelUtility from "./Model/ModelUtility.js";
+import Pass from "../Renderer/Pass.js";
+import createVectorTileBuffersFromModelComponents from "./Model/createVectorTileBuffersFromModelComponents.js";
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import DeveloperError from "../Core/DeveloperError.js";
+
+/** @import BufferPrimitive from "./BufferPrimitive.js"; */
+/** @import BufferPrimitiveCollection from "./BufferPrimitiveCollection.js"; */
+/** @import Cartesian3 from "../Core/Cartesian3.js"; */
+/** @import Cesium3DContentGroup from "./Cesium3DContentGroup.js"; */
+/** @import Cesium3DTile from "./Cesium3DTile.js"; */
+/** @import Cesium3DTileBatchTable from "./Cesium3DTileBatchTable.js"; */
+/** @import Cesium3DTileVectorFeature from "./Cesium3DTileVectorFeature.js";*/
+/** @import Cesium3DTileset from "./Cesium3DTileset.js"; */
+/** @import FrameState from "./FrameState.js"; */
+/** @import ImplicitMetadataView from "./ImplicitMetadataView.js"; */
+/** @import Ray from "../Core/Ray.js"; */
+/** @import Resource from "../Core/Resource.js"; */
+
+/** @ignore */
+const point = new BufferPoint();
+/** @ignore */
+const polyline = new BufferPolyline();
+/** @ignore */
+const polygon = new BufferPolygon();
+
+/** @ignore */
+const pointMaterial = new BufferPointMaterial();
+/** @ignore */
+const polylineMaterial = new BufferPolylineMaterial();
+/** @ignore */
+const polygonMaterial = new BufferPolygonMaterial();
+
+/** @ignore */
+const scratchTileModelMatrix = new Matrix4();
+
+/**
+ * Vector glTF tile content. This path decodes glTF primitives into vector
+ * buffers, then renders with dedicated vector primitives.
+ *
+ * @ignore
+ */
+class VectorGltf3DTileContent {
+  /**
+   * @param {Cesium3DTileset} tileset
+   * @param {Cesium3DTile} tile
+   * @param {Resource} resource
+   */
+  constructor(tileset, tile, resource) {
+    /** @type {Cesium3DTileset} */
+    this._tileset = tileset;
+    /** @type {Cesium3DTile} */
+    this._tile = tile;
+    /** @type {Resource} */
+    this._resource = resource;
+
+    /** @type {Model} */
+    this._model = undefined;
+
+    /** @type {Array<BufferPrimitiveCollection<BufferPrimitive>>} */
+    this._collections = [];
+
+    /** @type {Array<Matrix4>} */
+    this._collectionLocalMatrices = [];
+
+    /** @type {Map<number, Cesium3DTileVectorFeature>} */
+    this._features = new Map();
+
+    /** @type {ImplicitMetadataView} */
+    this._metadata = undefined;
+    /** @type {Cesium3DContentGroup} */
+    this._group = undefined;
+
+    /** @type {boolean} */
+    this.featurePropertiesDirty = false;
+
+    /** @type {boolean} */
+    this._ready = false;
+
+    /** @type {Matrix4} */
+    this._modelMatrix = Matrix4.clone(Matrix4.IDENTITY);
+  }
+
+  get featuresLength() {
+    return this._collections.reduce(
+      (acc, collection) => acc + collection.primitiveCount,
+      0,
+    );
+  }
+
+  get pointsLength() {
+    return this._collections
+      .filter((collection) => collection instanceof BufferPointCollection)
+      .reduce((acc, collection) => acc + collection.primitiveCount, 0);
+  }
+
+  get trianglesLength() {
+    return this._collections.reduce((acc, collection) => {
+      if (collection instanceof BufferPolygonCollection) {
+        return acc + collection.triangleCount;
+      } else if (collection instanceof BufferPolylineCollection) {
+        return acc + (collection.vertexCount - collection.primitiveCount) * 2;
+      }
+      return acc;
+    }, 0);
+  }
+
+  get geometryByteLength() {
+    return this._collections.reduce((totalByteLength, collection) => {
+      return totalByteLength + collection.byteLength;
+    }, 0);
+  }
+
+  get texturesByteLength() {
+    return 0;
+  }
+
+  get batchTableByteLength() {
+    return 0;
+  }
+
+  /** @returns {undefined} */
+  get innerContents() {
+    return undefined;
+  }
+
+  get ready() {
+    return this._ready;
+  }
+
+  get tileset() {
+    return this._tileset;
+  }
+
+  get tile() {
+    return this._tile;
+  }
+
+  get url() {
+    return this._resource.getUrlComponent(true);
+  }
+
+  /** @type {Cesium3DTileBatchTable[]} */
+  get batchTables() {
+    return this._model._featureTables;
+  }
+
+  /**
+   * @type {Cesium3DTileBatchTable}
+   * @deprecated See {@link batchTables}.
+   */
+  get batchTable() {
+    throw new DeveloperError("Deprecated: Use `content.batchTables`.");
+  }
+
+  /** @type {ImplicitMetadataView} */
+  get metadata() {
+    return this._metadata;
+  }
+
+  set metadata(value) {
+    this._metadata = value;
+  }
+
+  /** @type {Cesium3DContentGroup} */
+  get group() {
+    return this._group;
+  }
+
+  set group(value) {
+    this._group = value;
+  }
+
+  /**
+   * @param {number} featureId
+   * @returns {Cesium3DTileVectorFeature}
+   */
+  getFeature(featureId) {
+    return this._features.get(featureId);
+  }
+
+  /**
+   * @param {number} featureId
+   * @param {string} name
+   * @returns {boolean}
+   */
+  hasProperty(featureId, name) {
+    const feature = this.getFeature(featureId);
+    return feature ? feature.hasProperty(name) : false;
+  }
+
+  /**
+   * @param {boolean} enabled
+   * @param {Color} color
+   */
+  applyDebugSettings(enabled, color) {
+    color = enabled ? color : Color.WHITE;
+    this.applyStyle(new Cesium3DTileStyle({ color }));
+  }
+
+  /**
+   * @param {*} style
+   */
+  applyStyle(style) {
+    const isPointCollection = /** @param {unknown} c */ (c) =>
+      c instanceof BufferPointCollection;
+    const isPolylineCollection = /** @param {unknown} c */ (c) =>
+      c instanceof BufferPolylineCollection;
+    const isPolygonCollection = /** @param {unknown} c */ (c) =>
+      c instanceof BufferPolygonCollection;
+
+    for (const collection of this._collections.filter(isPointCollection)) {
+      for (let i = 0, il = collection.primitiveCount; i < il; i++) {
+        collection.get(i, point);
+        const feature = this.getFeature(point.featureId);
+
+        point.show = style.show?.evaluate(feature) ?? true;
+        style.color?.evaluate(feature, pointMaterial.color);
+        pointMaterial.size = style.pointSize?.evaluate(feature);
+        pointMaterial.outlineWidth = style.pointOutlineWidth?.evaluate(feature);
+        style.pointOutlineColor?.evaluate(feature, pointMaterial.outlineColor);
+
+        point.setMaterial(pointMaterial);
+      }
+    }
+
+    for (const collection of this._collections.filter(isPolylineCollection)) {
+      for (let i = 0, il = collection.primitiveCount; i < il; i++) {
+        collection.get(i, polyline);
+        const feature = this.getFeature(polyline.featureId);
+
+        polyline.show = style.show?.evaluate(feature) ?? true;
+        style.color?.evaluate(feature, polylineMaterial.color);
+        polylineMaterial.width = style.lineWidth?.evaluate(feature) ?? 1;
+
+        polyline.setMaterial(polylineMaterial);
+      }
+    }
+
+    for (const collection of this._collections.filter(isPolygonCollection)) {
+      for (let i = 0, il = collection.primitiveCount; i < il; i++) {
+        collection.get(i, polygon);
+        const feature = this.getFeature(polygon.featureId);
+
+        polygon.show = style.show?.evaluate(feature) ?? true;
+        style.color?.evaluate(feature, polygonMaterial.color);
+
+        polygon.setMaterial(polygonMaterial);
+      }
+    }
+  }
+
+  /**
+   * @param {Cesium3DTileset} _tileset
+   * @param {FrameState} frameState
+   */
+  update(_tileset, frameState) {
+    if (defined(this._model) && !this._ready) {
+      const model = this._model;
+      model.modelMatrix = this._tile.computedTransform;
+      model.update(frameState);
+
+      // @ts-expect-error Requires Model conversion to ES6 class.
+      if (model.ready) {
+        initializeVectorPrimitives(this);
+        this._ready = true;
+      }
+    }
+
+    Matrix4.multiplyTransformation(
+      this._tile.computedTransform,
+      this._modelMatrix,
+      scratchTileModelMatrix,
+    );
+
+    for (let i = 0; i < this._collections.length; i++) {
+      Matrix4.multiplyTransformation(
+        scratchTileModelMatrix,
+        this._collectionLocalMatrices[i],
+        this._collections[i].modelMatrix,
+      );
+      this._collections[i].update(frameState);
+    }
+  }
+
+  /**
+   * @param {Ray} _ray
+   * @param {FrameState} _frameState
+   * @param {Cartesian3|undefined} _result
+   * @returns {Cartesian3|undefined}
+   */
+  pick(_ray, _frameState, _result) {
+    return undefined;
+  }
+
+  isDestroyed() {
+    return false;
+  }
+
+  destroy() {
+    this._model?.destroy();
+    this._model = undefined;
+    this._collections.forEach((collection) => collection.destroy());
+    this._collections.length = 0;
+    return destroyObject(this);
+  }
+
+  /**
+   * @param {Cesium3DTileset} tileset
+   * @param {Cesium3DTile} tile
+   * @param {Resource} resource
+   * @param {unknown} gltf
+   * @returns {Promise<VectorGltf3DTileContent>}
+   */
+  static async fromGltf(tileset, tile, resource, gltf) {
+    const content = new VectorGltf3DTileContent(tileset, tile, resource);
+    const modelOptions = makeModelOptions(tileset, tile, content, gltf);
+    const model = await Model.fromGltfAsync(modelOptions);
+    // @ts-expect-error Requires Model conversion to ES6 class.
+    model.show = false;
+    content._model = model;
+    return content;
+  }
+}
+
+/**
+ * @param {Cesium3DTileset} tileset
+ * @param {Cesium3DTile} tile
+ * @param {VectorGltf3DTileContent} content
+ * @param {unknown} gltf
+ * @returns {*}
+ * @ignore
+ */
+function makeModelOptions(tileset, tile, content, gltf) {
+  return {
+    gltf: gltf,
+    basePath: content._resource,
+    cull: false,
+    releaseGltfJson: true,
+    opaquePass: Pass.CESIUM_3D_TILE,
+    modelMatrix: tile.computedTransform,
+    upAxis: tileset._modelUpAxis,
+    forwardAxis: tileset._modelForwardAxis,
+    incrementallyLoadTextures: false,
+    content: content,
+    // @ts-expect-error Requires Cesium3DTileset conversion to ES6 class.
+    featureIdLabel: tileset.featureIdLabel,
+    // @ts-expect-error Requires Cesium3DTileset conversion to ES6 class.
+    instanceFeatureIdLabel: tileset.instanceFeatureIdLabel,
+    projectTo2D: tileset._projectTo2D,
+    enablePick: tileset._enablePick,
+    enableDebugWireframe: tileset._enableDebugWireframe,
+    enableShowOutline: false,
+  };
+}
+
+/**
+ * @param {VectorGltf3DTileContent} content
+ * @ignore
+ */
+function initializeVectorPrimitives(content) {
+  // @ts-expect-error Requires Model conversion to ES6 class.
+  const components = content._model.sceneGraph.components;
+
+  const axisCorrection = ModelUtility.getAxisCorrectionMatrix(
+    components.upAxis,
+    components.forwardAxis,
+    new Matrix4(),
+  );
+
+  Matrix4.multiplyTransformation(
+    components.transform,
+    axisCorrection,
+    content._modelMatrix,
+  );
+
+  const result = createVectorTileBuffersFromModelComponents(
+    content,
+    components,
+  );
+
+  content._collections = result.collections;
+  content._collectionLocalMatrices = result.collectionLocalMatrices;
+  content._features = result.features;
+}
+
+export default VectorGltf3DTileContent;

package/Source/Scene/VertexAttributeSemantic.js

@@ -87,6 +87,13 @@ const VertexAttributeSemantic = {
    * @constant
    */
   ROTATION: "KHR_gaussian_splatting:ROTATION",
+  /**
+   * Per-vertex cumulative distance for line patterning.
+   *
+   * @type {string}
+   * @constant
+   */
+  CUMULATIVE_DISTANCE: "BENTLEY_materials_line_style:CUMULATIVE_DISTANCE",
 };
 
 function semanticToVariableName(semantic) {
@@ -111,6 +118,8 @@ function semanticToVariableName(semantic) {
       return "scale";
     case VertexAttributeSemantic.ROTATION:
       return "rotation";
+    case VertexAttributeSemantic.CUMULATIVE_DISTANCE:
+      return "cumulativeDistance";
     //>>includeStart('debug', pragmas.debug);
     default:
       throw new DeveloperError("semantic is not a valid value.");
@@ -136,6 +145,7 @@ VertexAttributeSemantic.hasSetIndex = function (semantic) {
     case VertexAttributeSemantic.POSITION:
     case VertexAttributeSemantic.NORMAL:
     case VertexAttributeSemantic.TANGENT:
+    case VertexAttributeSemantic.CUMULATIVE_DISTANCE:
       return false;
     case VertexAttributeSemantic.TEXCOORD:
     case VertexAttributeSemantic.COLOR:
@@ -198,6 +208,8 @@ VertexAttributeSemantic.fromGltfSemantic = function (gltfSemantic) {
     case "KHR_gaussian_splatting:ROTATION":
     case "_ROTATION":
       return VertexAttributeSemantic.ROTATION;
+    case "BENTLEY_materials_line_style:CUMULATIVE_DISTANCE":
+      return VertexAttributeSemantic.CUMULATIVE_DISTANCE;
   }
 
   return undefined;
@@ -271,6 +283,8 @@ VertexAttributeSemantic.getGlslType = function (semantic) {
       return "vec3";
     case VertexAttributeSemantic.ROTATION:
       return "vec4";
+    case VertexAttributeSemantic.CUMULATIVE_DISTANCE:
+      return "float";
     case VertexAttributeSemantic.OPACITY:
       return "float";
     //>>includeStart('debug', pragmas.debug);
@@ -302,4 +316,6 @@ VertexAttributeSemantic.getVariableName = function (semantic, setIndex) {
   return variableName;
 };
 
-export default Object.freeze(VertexAttributeSemantic);
+Object.freeze(VertexAttributeSemantic);
+
+export default VertexAttributeSemantic;

package/Source/Scene/VerticalOrigin.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * The vertical location of an origin relative to an object, e.g., a {@link Billboard}
  * or {@link Label}.  For example, setting the vertical origin to <code>TOP</code>
@@ -46,4 +48,7 @@ const VerticalOrigin = {
    */
   TOP: -1,
 };
-export default Object.freeze(VerticalOrigin);
+
+Object.freeze(VerticalOrigin);
+
+export default VerticalOrigin;

package/Source/Scene/VoxelBoxShape.js

@@ -76,10 +76,16 @@ function VoxelBoxShape() {
 
   this._renderBoundPlanes = new VoxelBoundsCollection({ planes: boundPlanes });
 
+  /**
+   * UV space transformation translation (JS-only, not a shader uniform)
+   * @type {Cartesian3}
+   * @private
+   */
+  this._localToShapeUvTranslate = new Cartesian3();
+
   this._shaderUniforms = {
     boxEcToXyz: new Matrix3(),
     boxLocalToShapeUvScale: new Cartesian3(),
-    boxLocalToShapeUvTranslate: new Cartesian3(),
   };
 
   this._shaderDefines = {
@@ -321,13 +327,13 @@ VoxelBoxShape.prototype.update = function (
     boundScale(min.z, max.z),
     shaderUniforms.boxLocalToShapeUvScale,
   );
-  shaderUniforms.boxLocalToShapeUvTranslate = Cartesian3.negate(
+  this._localToShapeUvTranslate = Cartesian3.negate(
     Cartesian3.multiplyComponents(
       boxLocalToShapeUvScale,
       min,
-      shaderUniforms.boxLocalToShapeUvTranslate,
+      this._localToShapeUvTranslate,
     ),
-    shaderUniforms.boxLocalToShapeUvTranslate,
+    this._localToShapeUvTranslate,
   );
 
   this._shaderMaximumIntersectionsLength = intersectionCount;
@@ -381,8 +387,8 @@ VoxelBoxShape.prototype.convertLocalToShapeUvSpace = function (
   Check.typeOf.object("result", result);
   //>>includeEnd('debug');
 
-  const { boxLocalToShapeUvScale, boxLocalToShapeUvTranslate } =
-    this._shaderUniforms;
+  const { boxLocalToShapeUvScale } = this._shaderUniforms;
+  const boxLocalToShapeUvTranslate = this._localToShapeUvTranslate;
 
   return Cartesian3.add(
     Cartesian3.multiplyComponents(

package/Source/Scene/VoxelContent.js

@@ -66,6 +66,8 @@ Object.defineProperties(VoxelContent.prototype, {
    * The metadata for this voxel content.
    * The metadata is an array of typed arrays, one for each field.
    * The data for one field is a flattened 3D array ordered by X, then Y, then Z.
+   *
+   * @memberof VoxelContent.prototype
    * @type {Int8Array[]|Uint8Array[]|Int16Array[]|Uint16Array[]|Int32Array[]|Uint32Array[]|Float32Array[]|Float64Array[]}
    * @readonly
    */

package/Source/Scene/VoxelCylinderShape.js

@@ -54,14 +54,20 @@ function VoxelCylinderShape() {
 
   this._renderBoundPlanes = new VoxelBoundsCollection({ planes: boundPlanes });
 
+  /**
+   * UV space transformation translations (JS-only, not shader uniforms)
+   * Components: [radius, angle, height] translation
+   * @type {Cartesian3}
+   * @private
+   */
+  this._localToShapeUvTranslate = new Cartesian3();
+
   this._shaderUniforms = {
     cameraShapePosition: new Cartesian3(),
     cylinderEcToRadialTangentUp: new Matrix3(),
     cylinderRenderRadiusMinMax: new Cartesian2(),
     cylinderRenderAngleMinMax: new Cartesian2(),
-    cylinderLocalToShapeUvRadius: new Cartesian2(),
-    cylinderLocalToShapeUvAngle: new Cartesian2(),
-    cylinderLocalToShapeUvHeight: new Cartesian2(),
+    cylinderLocalToShapeUvScale: new Cartesian3(),
     cylinderShapeUvAngleRangeOrigin: 0.0,
   };
 
@@ -359,30 +365,22 @@ VoxelCylinderShape.prototype.update = function (
   }
 
   const radiusRange = maxBounds.x - minBounds.x;
+  // Defaults are for the case where radiusRange is zero, to avoid division by zero.
   let radialScale = 0.0;
   let radialOffset = 1.0;
   if (radiusRange !== 0.0) {
     radialScale = 1.0 / radiusRange;
     radialOffset = -minBounds.x * radialScale;
   }
-  shaderUniforms.cylinderLocalToShapeUvRadius = Cartesian2.fromElements(
-    radialScale,
-    radialOffset,
-    shaderUniforms.cylinderLocalToShapeUvRadius,
-  );
 
   const heightRange = maxBounds.z - minBounds.z; // Default 2.0
+  // Defaults are for the case where heightRange is zero, to avoid division by zero.
   let heightScale = 0.0;
   let heightOffset = 1.0;
   if (heightRange !== 0.0) {
     heightScale = 1.0 / heightRange;
     heightOffset = -minBounds.z * heightScale;
   }
-  shaderUniforms.cylinderLocalToShapeUvHeight = Cartesian2.fromElements(
-    heightScale,
-    heightOffset,
-    shaderUniforms.cylinderLocalToShapeUvHeight,
-  );
 
   if (renderHasAngle) {
     shaderDefines["CYLINDER_HAS_RENDER_BOUNDS_ANGLE"] = true;
@@ -414,23 +412,31 @@ VoxelCylinderShape.prototype.update = function (
   const uvAngleRangeOrigin = (uvMaxAngle + 0.5 * uvAngleRangeZero) % 1.0;
   shaderUniforms.cylinderShapeUvAngleRangeOrigin = uvAngleRangeOrigin;
 
-  if (shapeAngleRange <= epsilonAngle) {
-    shaderUniforms.cylinderLocalToShapeUvAngle = Cartesian2.fromElements(
-      0.0,
-      1.0,
-      shaderUniforms.cylinderLocalToShapeUvAngle,
-    );
-  } else {
-    const scale = defaultAngleRange / shapeAngleRange;
+  // Defaults are for the case where shapeAngleRange is zero, to avoid division by zero.
+  let angleScale = 0.0;
+  let angleOffset = 1.0;
+  if (shapeAngleRange > epsilonAngle) {
+    angleScale = defaultAngleRange / shapeAngleRange;
     const shiftedMinAngle = uvMinAngle - uvAngleRangeOrigin;
-    const offset = -scale * (shiftedMinAngle - Math.floor(shiftedMinAngle));
-    shaderUniforms.cylinderLocalToShapeUvAngle = Cartesian2.fromElements(
-      scale,
-      offset,
-      shaderUniforms.cylinderLocalToShapeUvAngle,
-    );
+    angleOffset = -angleScale * (shiftedMinAngle - Math.floor(shiftedMinAngle));
   }
 
+  // Store scales in shader uniforms (GPU)
+  shaderUniforms.cylinderLocalToShapeUvScale = Cartesian3.fromElements(
+    radialScale,
+    angleScale,
+    heightScale,
+    shaderUniforms.cylinderLocalToShapeUvScale,
+  );
+
+  // Store translations in private property (JS-only)
+  this._localToShapeUvTranslate = Cartesian3.fromElements(
+    radialOffset,
+    angleOffset,
+    heightOffset,
+    this._localToShapeUvTranslate,
+  );
+
   this._shaderMaximumIntersectionsLength = intersectionCount;
 
   return true;
@@ -523,25 +529,20 @@ VoxelCylinderShape.prototype.convertLocalToShapeUvSpace = function (
   let angle = Math.atan2(positionLocal.y, positionLocal.x);
   let height = positionLocal.z;
 
-  const {
-    cylinderLocalToShapeUvRadius,
-    cylinderLocalToShapeUvAngle,
-    cylinderShapeUvAngleRangeOrigin,
-    cylinderLocalToShapeUvHeight,
-  } = this._shaderUniforms;
+  const { cylinderLocalToShapeUvScale, cylinderShapeUvAngleRangeOrigin } =
+    this._shaderUniforms;
+  const localToShapeUvTranslate = this._localToShapeUvTranslate;
 
-  radius =
-    radius * cylinderLocalToShapeUvRadius.x + cylinderLocalToShapeUvRadius.y;
+  radius = radius * cylinderLocalToShapeUvScale.x + localToShapeUvTranslate.x;
 
   // Convert angle to a "UV" in [0,1] with 0 defined at the center of the unoccupied space.
   angle = (angle + Math.PI) / (2.0 * Math.PI);
   angle -= cylinderShapeUvAngleRangeOrigin;
   angle = angle - Math.floor(angle);
   // Scale and shift so [0,1] covers the occupied space.
-  angle = angle * cylinderLocalToShapeUvAngle.x + cylinderLocalToShapeUvAngle.y;
+  angle = angle * cylinderLocalToShapeUvScale.y + localToShapeUvTranslate.y;
 
-  height =
-    height * cylinderLocalToShapeUvHeight.x + cylinderLocalToShapeUvHeight.y;
+  height = height * cylinderLocalToShapeUvScale.z + localToShapeUvTranslate.z;
 
   return Cartesian3.fromElements(radius, angle, height, result);
 };