@cesium/engine 6.2.0 → 8.0.0

package/Source/Core/Ellipsoid.js

@@ -363,6 +363,12 @@ Ellipsoid.prototype.geodeticSurfaceNormalCartographic = function (
  * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided, or undefined if a normal cannot be found.
  */
 Ellipsoid.prototype.geodeticSurfaceNormal = function (cartesian, result) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.object("cartesian", cartesian);
+  if (isNaN(cartesian.x) || isNaN(cartesian.y) || isNaN(cartesian.z)) {
+    throw new DeveloperError("cartesian has a NaN component");
+  }
+  //>>includeEnd('debug');
   if (
     Cartesian3.equalsEpsilon(cartesian, Cartesian3.ZERO, CesiumMath.EPSILON14)
   ) {

package/Source/Core/GregorianDate.js

@@ -1,3 +1,10 @@
+import Check from "./Check.js";
+import defaultValue from "./defaultValue.js";
+import DeveloperError from "./DeveloperError.js";
+import isLeapYear from "./isLeapYear.js";
+
+const daysInYear = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
 /**
  * Represents a Gregorian date in a more precise format than the JavaScript Date object.
  * In addition to submillisecond precision, this object can also represent leap seconds.
@@ -25,6 +32,27 @@ function GregorianDate(
   millisecond,
   isLeapSecond
 ) {
+  const minimumYear = 1;
+  const minimumMonth = 1;
+  const minimumDay = 1;
+  const minimumHour = 0;
+  const minimumMinute = 0;
+  const minimumSecond = 0;
+  const minimumMillisecond = 0;
+
+  year = defaultValue(year, minimumYear);
+  month = defaultValue(month, minimumMonth);
+  day = defaultValue(day, minimumDay);
+  hour = defaultValue(hour, minimumHour);
+  minute = defaultValue(minute, minimumMinute);
+  second = defaultValue(second, minimumSecond);
+  millisecond = defaultValue(millisecond, minimumMillisecond);
+  isLeapSecond = defaultValue(isLeapSecond, false);
+  //>>includeStart('debug', pragmas.debug);
+  validateRange();
+  validateDate();
+  //>>includeEnd('debug');
+
   /**
    * Gets or sets the year as a whole number.
    * @type {number}
@@ -65,5 +93,62 @@ function GregorianDate(
    * @type {boolean}
    */
   this.isLeapSecond = isLeapSecond;
+
+  function validateRange() {
+    const maximumYear = 9999;
+    const maximumMonth = 12;
+    const maximumDay = 31;
+    const maximumHour = 23;
+    const maximumMinute = 59;
+    const maximumSecond = 59;
+    const excludedMaximumMilisecond = 1000;
+
+    Check.typeOf.number.greaterThanOrEquals("Year", year, minimumYear);
+    Check.typeOf.number.lessThanOrEquals("Year", year, maximumYear);
+
+    Check.typeOf.number.greaterThanOrEquals("Month", month, minimumMonth);
+    Check.typeOf.number.lessThanOrEquals("Month", month, maximumMonth);
+
+    Check.typeOf.number.greaterThanOrEquals("Day", day, minimumDay);
+    Check.typeOf.number.lessThanOrEquals("Day", day, maximumDay);
+
+    Check.typeOf.number.greaterThanOrEquals("Hour", hour, minimumHour);
+    Check.typeOf.number.lessThanOrEquals("Hour", hour, maximumHour);
+
+    Check.typeOf.number.greaterThanOrEquals("Minute", minute, minimumMinute);
+    Check.typeOf.number.lessThanOrEquals("Minute", minute, maximumMinute);
+
+    Check.typeOf.bool("IsLeapSecond", isLeapSecond);
+
+    Check.typeOf.number.greaterThanOrEquals("Second", second, minimumSecond);
+    Check.typeOf.number.lessThanOrEquals(
+      "Second",
+      second,
+      isLeapSecond ? maximumSecond + 1 : maximumSecond
+    );
+
+    Check.typeOf.number.greaterThanOrEquals(
+      "Millisecond",
+      millisecond,
+      minimumMillisecond
+    );
+    Check.typeOf.number.lessThan(
+      "Millisecond",
+      millisecond,
+      excludedMaximumMilisecond
+    );
+  }
+
+  // Javascript date object supports only dates greater than 1901. Thus validating with custom logic
+  function validateDate() {
+    const daysInMonth =
+      month === 2 && isLeapYear(year)
+        ? daysInYear[month - 1] + 1
+        : daysInYear[month - 1];
+
+    if (day > daysInMonth) {
+      throw new DeveloperError("Month and Day represents invalid date");
+    }
+  }
 }
 export default GregorianDate;

package/Source/Core/HeadingPitchRange.js

@@ -3,7 +3,7 @@ import defined from "./defined.js";
 
 /**
  * Defines a heading angle, pitch angle, and range in a local frame.
- * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+ * Heading is the rotation from the local east direction where a positive angle is increasing southward.
  * Pitch is the rotation from the local xy-plane. Positive pitch angles are above the plane. Negative pitch
  * angles are below the plane. Range is the distance from the center of the frame.
  * @alias HeadingPitchRange
@@ -15,7 +15,7 @@ import defined from "./defined.js";
  */
 function HeadingPitchRange(heading, pitch, range) {
   /**
-   * Heading is the rotation from the local north direction where a positive angle is increasing eastward.
+   * Heading is the rotation from the local east direction where a positive angle is increasing southward.
    * @type {number}
    * @default 0.0
    */

package/Source/Core/IntersectionTests.js

@@ -508,7 +508,10 @@ function addWithCancellationCheck(left, right, tolerance) {
   return difference;
 }
 
-function quadraticVectorExpression(A, b, c, x, w) {
+/**
+ * @private
+ */
+IntersectionTests.quadraticVectorExpression = function (A, b, c, x, w) {
   const xSquared = x * x;
   const wSquared = w * w;
 
@@ -634,7 +637,7 @@ function quadraticVectorExpression(A, b, c, x, w) {
   }
 
   return solutions;
-}
+};
 
 const firstAxisScratch = new Cartesian3();
 const secondAxisScratch = new Cartesian3();
@@ -740,7 +743,7 @@ IntersectionTests.grazingAltitudeLocation = function (ray, ellipsoid) {
   const b = Matrix3.multiplyByVector(temp, position, bCart);
 
   // Solve for the solutions to the expression in standard form:
-  const solutions = quadraticVectorExpression(
+  const solutions = IntersectionTests.quadraticVectorExpression(
     A,
     Cartesian3.negate(b, firstAxisScratch),
     0.0,

package/Source/Core/Ion.js

@@ -4,7 +4,7 @@ import Resource from "./Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJkNzEwOTRhMi05YmYyLTQyY2EtYTU2My04YTM1MWE2YjhjNjAiLCJpZCI6MjU5LCJpYXQiOjE3MDQyMTcxMzh9.rE7KTaFyZydhuP1Z7ohzClO3J1tMOvaHODzt3_5jo7s";
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI2MThmZGJiNi1kMDRlLTQ4ZGMtYjU0Ny0yNTljMjM1NzliN2MiLCJpZCI6MjU5LCJpYXQiOjE3MDkzMDQzNjZ9.7gsbNN-OaPZJ7QwMDB2vdF2geQDd8lMBAEK77_5Qol4";
 /**
  * Default settings for accessing the Cesium ion API.
  *

package/Source/Core/PixelFormat.js

@@ -402,6 +402,11 @@ PixelFormat.alignmentInBytes = function (pixelFormat, pixelDatatype, width) {
 
 /**
  * @private
+ * @param {PixelFormat} pixelFormat The pixel format.
+ * @param {PixelDatatype} pixelDatatype The pixel datatype.
+ * @param {Number} width The width of the texture.
+ * @param {Number} height The height of the texture.
+ * @returns {TypedArray} The typed array.
  */
 PixelFormat.createTypedArray = function (
   pixelFormat,

package/Source/Core/PolygonGeometry.js

@@ -8,10 +8,8 @@ import Check from "./Check.js";
 import ComponentDatatype from "./ComponentDatatype.js";
 import defaultValue from "./defaultValue.js";
 import defined from "./defined.js";
-import deprecationWarning from "./deprecationWarning.js";
 import DeveloperError from "./DeveloperError.js";
 import Ellipsoid from "./Ellipsoid.js";
-import EllipsoidGeodesic from "./EllipsoidGeodesic.js";
 import EllipsoidTangentPlane from "./EllipsoidTangentPlane.js";
 import Geometry from "./Geometry.js";
 import GeometryAttribute from "./GeometryAttribute.js";
@@ -425,123 +423,6 @@ function computeAttributes(options) {
   return geometry;
 }
 
-const startCartographicScratch = new Cartographic();
-const endCartographicScratch = new Cartographic();
-const idlCross = {
-  westOverIDL: 0.0,
-  eastOverIDL: 0.0,
-};
-let ellipsoidGeodesic = new EllipsoidGeodesic();
-function computeRectangle(positions, ellipsoid, arcType, granularity, result) {
-  result = defaultValue(result, new Rectangle());
-  if (!defined(positions) || positions.length < 3) {
-    result.west = 0.0;
-    result.north = 0.0;
-    result.south = 0.0;
-    result.east = 0.0;
-    return result;
-  }
-
-  if (arcType === ArcType.RHUMB) {
-    return Rectangle.fromCartesianArray(positions, ellipsoid, result);
-  }
-
-  if (!ellipsoidGeodesic.ellipsoid.equals(ellipsoid)) {
-    ellipsoidGeodesic = new EllipsoidGeodesic(undefined, undefined, ellipsoid);
-  }
-
-  result.west = Number.POSITIVE_INFINITY;
-  result.east = Number.NEGATIVE_INFINITY;
-  result.south = Number.POSITIVE_INFINITY;
-  result.north = Number.NEGATIVE_INFINITY;
-
-  idlCross.westOverIDL = Number.POSITIVE_INFINITY;
-  idlCross.eastOverIDL = Number.NEGATIVE_INFINITY;
-
-  const inverseChordLength =
-    1.0 / CesiumMath.chordLength(granularity, ellipsoid.maximumRadius);
-  const positionsLength = positions.length;
-  let endCartographic = ellipsoid.cartesianToCartographic(
-    positions[0],
-    endCartographicScratch
-  );
-  let startCartographic = startCartographicScratch;
-  let swap;
-
-  for (let i = 1; i < positionsLength; i++) {
-    swap = startCartographic;
-    startCartographic = endCartographic;
-    endCartographic = ellipsoid.cartesianToCartographic(positions[i], swap);
-    ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
-    interpolateAndGrowRectangle(
-      ellipsoidGeodesic,
-      inverseChordLength,
-      result,
-      idlCross
-    );
-  }
-
-  swap = startCartographic;
-  startCartographic = endCartographic;
-  endCartographic = ellipsoid.cartesianToCartographic(positions[0], swap);
-  ellipsoidGeodesic.setEndPoints(startCartographic, endCartographic);
-  interpolateAndGrowRectangle(
-    ellipsoidGeodesic,
-    inverseChordLength,
-    result,
-    idlCross
-  );
-
-  if (result.east - result.west > idlCross.eastOverIDL - idlCross.westOverIDL) {
-    result.west = idlCross.westOverIDL;
-    result.east = idlCross.eastOverIDL;
-
-    if (result.east > CesiumMath.PI) {
-      result.east = result.east - CesiumMath.TWO_PI;
-    }
-    if (result.west > CesiumMath.PI) {
-      result.west = result.west - CesiumMath.TWO_PI;
-    }
-  }
-
-  return result;
-}
-
-const interpolatedCartographicScratch = new Cartographic();
-function interpolateAndGrowRectangle(
-  ellipsoidGeodesic,
-  inverseChordLength,
-  result,
-  idlCross
-) {
-  const segmentLength = ellipsoidGeodesic.surfaceDistance;
-
-  const numPoints = Math.ceil(segmentLength * inverseChordLength);
-  const subsegmentDistance =
-    numPoints > 0 ? segmentLength / (numPoints - 1) : Number.POSITIVE_INFINITY;
-  let interpolationDistance = 0.0;
-
-  for (let i = 0; i < numPoints; i++) {
-    const interpolatedCartographic = ellipsoidGeodesic.interpolateUsingSurfaceDistance(
-      interpolationDistance,
-      interpolatedCartographicScratch
-    );
-    interpolationDistance += subsegmentDistance;
-    const longitude = interpolatedCartographic.longitude;
-    const latitude = interpolatedCartographic.latitude;
-
-    result.west = Math.min(result.west, longitude);
-    result.east = Math.max(result.east, longitude);
-    result.south = Math.min(result.south, latitude);
-    result.north = Math.max(result.north, latitude);
-
-    const lonAdjusted =
-      longitude >= 0 ? longitude : longitude + CesiumMath.TWO_PI;
-    idlCross.westOverIDL = Math.min(idlCross.westOverIDL, lonAdjusted);
-    idlCross.eastOverIDL = Math.max(idlCross.eastOverIDL, lonAdjusted);
-  }
-}
-
 const createGeometryFromPositionsExtrudedPositions = [];
 
 function createGeometryFromPositionsExtruded(
@@ -1264,56 +1145,6 @@ PolygonGeometry.computeRectangleFromPositions = function (
   return result;
 };
 
-/**
- * Returns the bounding rectangle given the provided options
- *
- * @param {object} options Object with the following properties:
- * @param {PolygonHierarchy} options.polygonHierarchy A polygon hierarchy that can include holes.
- * @param {number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions sampled.
- * @param {ArcType} [options.arcType=ArcType.GEODESIC] The type of line the polygon edges must follow. Valid options are {@link ArcType.GEODESIC} and {@link ArcType.RHUMB}.
- * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
- * @param {Rectangle} [result] An object in which to store the result.
- *
- * @returns {Rectangle} The result rectangle
- *
- * @deprecated
- */
-PolygonGeometry.computeRectangle = function (options, result) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("options", options);
-  Check.typeOf.object("options.polygonHierarchy", options.polygonHierarchy);
-  //>>includeEnd('debug');
-
-  deprecationWarning(
-    "PolygonGeometry.computeRectangle",
-    "PolygonGeometry.computeRectangle was deprecated in CesiumJS 1.110.  It will be removed in CesiumJS 1.112. Use PolygonGeometry.computeRectangleFromPositions instead."
-  );
-
-  const granularity = defaultValue(
-    options.granularity,
-    CesiumMath.RADIANS_PER_DEGREE
-  );
-  const arcType = defaultValue(options.arcType, ArcType.GEODESIC);
-  //>>includeStart('debug', pragmas.debug);
-  if (arcType !== ArcType.GEODESIC && arcType !== ArcType.RHUMB) {
-    throw new DeveloperError(
-      "Invalid arcType. Valid options are ArcType.GEODESIC and ArcType.RHUMB."
-    );
-  }
-  //>>includeEnd('debug');
-
-  const polygonHierarchy = options.polygonHierarchy;
-  const ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
-
-  return computeRectangle(
-    polygonHierarchy.positions,
-    ellipsoid,
-    arcType,
-    granularity,
-    result
-  );
-};
-
 const scratchPolarForPlane = new Stereographic();
 function getTangentPlane(rectangle, positions, ellipsoid) {
   if (rectangle.height >= CesiumMath.PI || rectangle.width >= CesiumMath.PI) {

package/Source/Core/Resource.js

@@ -2045,17 +2045,6 @@ Resource.createImageBitmapFromBlob = function (blob, options) {
   });
 };
 
-function decodeResponse(loadWithHttpResponse, responseType) {
-  switch (responseType) {
-    case "text":
-      return loadWithHttpResponse.toString("utf8");
-    case "json":
-      return JSON.parse(loadWithHttpResponse.toString("utf8"));
-    default:
-      return new Uint8Array(loadWithHttpResponse).buffer;
-  }
-}
-
 function loadWithHttpRequest(
   url,
   responseType,
@@ -2066,64 +2055,36 @@ function loadWithHttpRequest(
   overrideMimeType
 ) {
   // Note: only the 'json' and 'text' responseTypes transforms the loaded buffer
-  let URL;
-  let zlib;
-  Promise.all([import("url"), import("zlib")])
-    .then(([urlImport, zlibImport]) => {
-      URL = urlImport.parse(url);
-      zlib = zlibImport;
-
-      return URL.protocol === "https:" ? import("https") : import("http");
-    })
-    .then((http) => {
-      const options = {
-        protocol: URL.protocol,
-        hostname: URL.hostname,
-        port: URL.port,
-        path: URL.path,
-        query: URL.query,
-        method: method,
-        headers: headers,
-      };
-      http
-        .request(options)
-        .on("response", function (res) {
-          if (res.statusCode < 200 || res.statusCode >= 300) {
-            deferred.reject(
-              new RequestErrorEvent(res.statusCode, res, res.headers)
-            );
-            return;
-          }
-
-          const chunkArray = [];
-          res.on("data", function (chunk) {
-            chunkArray.push(chunk);
-          });
+  fetch(url, {
+    method,
+    headers,
+  })
+    .then(async (response) => {
+      if (!response.ok) {
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        deferred.reject(
+          new RequestErrorEvent(response.status, response, responseHeaders)
+        );
+        return;
+      }
 
-          res.on("end", function () {
-            // eslint-disable-next-line no-undef
-            const result = Buffer.concat(chunkArray);
-            if (res.headers["content-encoding"] === "gzip") {
-              zlib.gunzip(result, function (error, resultUnzipped) {
-                if (error) {
-                  deferred.reject(
-                    new RuntimeError("Error decompressing response.")
-                  );
-                } else {
-                  deferred.resolve(
-                    decodeResponse(resultUnzipped, responseType)
-                  );
-                }
-              });
-            } else {
-              deferred.resolve(decodeResponse(result, responseType));
-            }
-          });
-        })
-        .on("error", function (e) {
-          deferred.reject(new RequestErrorEvent());
-        })
-        .end();
+      switch (responseType) {
+        case "text":
+          deferred.resolve(response.text());
+          break;
+        case "json":
+          deferred.resolve(response.json());
+          break;
+        default:
+          deferred.resolve(new Uint8Array(await response.arrayBuffer()).buffer);
+          break;
+      }
+    })
+    .catch(() => {
+      deferred.reject(new RequestErrorEvent());
     });
 }
 
@@ -2226,7 +2187,7 @@ Resource._Implementations.loadWithXhr = function (
     //or do not support the xhr.response property.
     if (xhr.status === 204) {
       // accept no content
-      deferred.resolve();
+      deferred.resolve(undefined);
     } else if (
       defined(response) &&
       (!defined(responseType) || browserResponseType === responseType)

package/Source/Core/Transforms.js

@@ -127,6 +127,9 @@ Transforms.localFrameToFixedFrameGenerator = function (firstAxis, secondAxis) {
       if (!defined(origin)) {
         throw new DeveloperError("origin is required.");
       }
+      if (isNaN(origin.x) || isNaN(origin.y) || isNaN(origin.z)) {
+        throw new DeveloperError("origin has a NaN component");
+      }
       //>>includeEnd('debug');
       if (!defined(result)) {
         result = new Matrix4();
@@ -360,7 +363,7 @@ const scratchHPRMatrix4 = new Matrix4();
 
 /**
  * Computes a 4x4 transformation matrix from a reference frame with axes computed from the heading-pitch-roll angles
- * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local north
+ * centered at the provided origin to the provided ellipsoid's fixed reference frame. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -415,7 +418,7 @@ const scratchHPRMatrix3 = new Matrix3();
 
 /**
  * Computes a quaternion from a reference frame with axes computed from the heading-pitch-roll angles
- * centered at the provided origin. Heading is the rotation from the local north
+ * centered at the provided origin. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -465,7 +468,7 @@ const hprTransformScratch = new Matrix4();
 const hprRotationScratch = new Matrix3();
 const hprQuaternionScratch = new Quaternion();
 /**
- * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local north
+ * Computes heading-pitch-roll angles from a transform in a particular reference frame. Heading is the rotation from the local east
  * direction where a positive angle is increasing eastward. Pitch is the rotation from the local east-north plane. Positive pitch angles
  * are above the plane. Negative pitch angles are below the plane. Roll is the first rotation applied about the local east axis.
  *
@@ -1045,21 +1048,30 @@ Transforms.basisTo2D = function (projection, matrix, result) {
   const rtcCenter = Matrix4.getTranslation(matrix, scratchCenter);
   const ellipsoid = projection.ellipsoid;
 
-  // Get the 2D Center
-  const cartographic = ellipsoid.cartesianToCartographic(
-    rtcCenter,
-    scratchCartographic
-  );
-  const projectedPosition = projection.project(
-    cartographic,
-    scratchCartesian3Projection
-  );
-  Cartesian3.fromElements(
-    projectedPosition.z,
-    projectedPosition.x,
-    projectedPosition.y,
-    projectedPosition
-  );
+  let projectedPosition;
+  if (Cartesian3.equals(rtcCenter, Cartesian3.ZERO)) {
+    projectedPosition = Cartesian3.clone(
+      Cartesian3.ZERO,
+      scratchCartesian3Projection
+    );
+  } else {
+    // Get the 2D Center
+    const cartographic = ellipsoid.cartesianToCartographic(
+      rtcCenter,
+      scratchCartographic
+    );
+
+    projectedPosition = projection.project(
+      cartographic,
+      scratchCartesian3Projection
+    );
+    Cartesian3.fromElements(
+      projectedPosition.z,
+      projectedPosition.x,
+      projectedPosition.y,
+      projectedPosition
+    );
+  }
 
   // Assuming the instance are positioned in WGS84, invert the WGS84 transform to get the local transform and then convert to 2D
   const fromENU = Transforms.eastNorthUpToFixedFrame(

package/Source/Core/createWorldBathymetryAsync.js

@@ -0,0 +1,45 @@
+import CesiumTerrainProvider from "./CesiumTerrainProvider.js";
+import defaultValue from "./defaultValue.js";
+
+/**
+ * Creates a {@link CesiumTerrainProvider} instance for the {@link https://cesium.com/content/#cesium-world-bathymetry|Cesium World Bathymetry}.
+ *
+ * @function
+ *
+ * @param {Object} [options] Object with the following properties:
+ * @param {Boolean} [options.requestVertexNormals=false] Flag that indicates if the client should request additional lighting information from the server if available.
+ * @returns {Promise<CesiumTerrainProvider>} A promise that resolves to the created CesiumTerrainProvider
+ *
+ * @see Ion
+ *
+ * @example
+ * // Create Cesium World Bathymetry with default settings
+ * try {
+ *   const viewer = new Cesium.Viewer("cesiumContainer", {
+ *     terrainProvider: await Cesium.createWorldBathymetryAsync();
+ *   });
+ * } catch (error) {
+ *   console.log(error);
+ * }
+ *
+ * @example
+ * // Create Cesium World Bathymetry with normals.
+ * try {
+ *   const viewer1 = new Cesium.Viewer("cesiumContainer", {
+ *     terrainProvider: await Cesium.createWorldBathymetryAsync({
+ *       requestVertexNormals: true
+ *     });
+ *   });
+ * } catch (error) {
+ *   console.log(error);
+ * }
+ *
+ */
+function createWorldBathymetryAsync(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+  return CesiumTerrainProvider.fromIonAssetId(2426648, {
+    requestVertexNormals: defaultValue(options.requestVertexNormals, false),
+  });
+}
+export default createWorldBathymetryAsync;

package/Source/Core/srgbToLinear.js

@@ -0,0 +1,32 @@
+import Check from "./Check.js";
+
+/**
+ * Converts the value from sRGB color space to linear color space.
+ *
+ * @function
+ *
+ * @param {number} value The color value in sRGB color space.
+ * @returns {number} Returns the color value in linear color space.
+ *
+ * @example
+ * const srgbColor = [0.5, 0.5, 0.5];
+ * const linearColor = srgbColor.map(function (c) {
+ *     return Cesium.srgbToLinear(c);
+ * });
+ */
+function srgbToLinear(value) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.defined("value", value);
+  //>>includeEnd('debug');
+
+  if (value <= 0.04045) {
+    // eslint-disable-next-line no-loss-of-precision
+    return value * 0.07739938080495356037151702786378;
+  }
+  return Math.pow(
+    // eslint-disable-next-line no-loss-of-precision
+    (value + 0.055) * 0.94786729857819905213270142180095,
+    2.4
+  );
+}
+export default srgbToLinear;