@cesium/engine 10.0.0 → 11.0.0

package/Source/Renderer/CubeMapFace.js

@@ -86,26 +86,30 @@ CubeMapFace.prototype.copyFrom = function (options) {
   Check.defined("options", options);
   //>>includeEnd('debug');
 
-  const xOffset = defaultValue(options.xOffset, 0);
-  const yOffset = defaultValue(options.yOffset, 0);
+  const {
+    xOffset = 0,
+    yOffset = 0,
+    source,
+    skipColorSpaceConversion = false,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
-  Check.defined("options.source", options.source);
+  Check.defined("options.source", source);
   Check.typeOf.number.greaterThanOrEquals("xOffset", xOffset, 0);
   Check.typeOf.number.greaterThanOrEquals("yOffset", yOffset, 0);
-  if (xOffset + options.source.width > this._size) {
+  if (xOffset + source.width > this._size) {
     throw new DeveloperError(
       "xOffset + options.source.width must be less than or equal to width."
     );
   }
-  if (yOffset + options.source.height > this._size) {
+  if (yOffset + source.height > this._size) {
     throw new DeveloperError(
       "yOffset + options.source.height must be less than or equal to height."
     );
   }
   //>>includeEnd('debug');
 
-  const source = options.source;
+  const { width, height } = source;
 
   const gl = this._context._gl;
   const target = this._textureTarget;
@@ -114,8 +118,6 @@ CubeMapFace.prototype.copyFrom = function (options) {
   gl.activeTexture(gl.TEXTURE0);
   gl.bindTexture(target, this._texture);
 
-  const width = source.width;
-  const height = source.height;
   let arrayBufferView = source.arrayBufferView;
 
   const size = this._size;
@@ -125,10 +127,6 @@ CubeMapFace.prototype.copyFrom = function (options) {
 
   const preMultiplyAlpha = this._preMultiplyAlpha;
   const flipY = this._flipY;
-  const skipColorSpaceConversion = defaultValue(
-    options.skipColorSpaceConversion,
-    false
-  );
 
   let unpackAlignment = 4;
   if (defined(arrayBufferView)) {
@@ -138,7 +136,6 @@ CubeMapFace.prototype.copyFrom = function (options) {
       width
     );
   }
-
   gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
 
   if (skipColorSpaceConversion) {
@@ -152,12 +149,12 @@ CubeMapFace.prototype.copyFrom = function (options) {
 
   let uploaded = false;
   if (!this._initialized) {
+    let pixels;
     if (xOffset === 0 && yOffset === 0 && width === size && height === size) {
       // initialize the entire texture
       if (defined(arrayBufferView)) {
         gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-
         if (flipY) {
           arrayBufferView = PixelFormat.flipY(
             arrayBufferView,
@@ -167,55 +164,36 @@ CubeMapFace.prototype.copyFrom = function (options) {
             size
           );
         }
-        gl.texImage2D(
-          targetFace,
-          0,
-          internalFormat,
-          size,
-          size,
-          0,
-          pixelFormat,
-          PixelDatatype.toWebGLConstant(pixelDatatype, this._context),
-          arrayBufferView
-        );
+        pixels = arrayBufferView;
       } else {
         // Only valid for DOM-Element uploads
         gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
-
-        gl.texImage2D(
-          targetFace,
-          0,
-          internalFormat,
-          pixelFormat,
-          PixelDatatype.toWebGLConstant(pixelDatatype, this._context),
-          source
-        );
+        pixels = source;
       }
       uploaded = true;
     } else {
+      // initialize the entire texture to zero
       gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
       gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-
-      // initialize the entire texture to zero
-      const bufferView = PixelFormat.createTypedArray(
+      pixels = PixelFormat.createTypedArray(
         pixelFormat,
         pixelDatatype,
         size,
         size
       );
-      gl.texImage2D(
-        targetFace,
-        0,
-        internalFormat,
-        size,
-        size,
-        0,
-        pixelFormat,
-        PixelDatatype.toWebGLConstant(pixelDatatype, this._context),
-        bufferView
-      );
     }
+    gl.texImage2D(
+      targetFace,
+      0,
+      internalFormat,
+      size,
+      size,
+      0,
+      pixelFormat,
+      PixelDatatype.toWebGLConstant(pixelDatatype, this._context),
+      pixels
+    );
     this._initialized = true;
   }
 

package/Source/Renderer/PixelDatatype.js

@@ -95,4 +95,27 @@ PixelDatatype.validate = function (pixelDatatype) {
   );
 };
 
+/**
+ * Determine which TypedArray class should be used for a given PixelDatatype.
+ *
+ * @param {PixelDatatype} pixelDatatype The pixel datatype.
+ * @returns {function} The constructor for the appropriate TypedArray class.
+ *
+ * @private
+ */
+PixelDatatype.getTypedArrayConstructor = function (pixelDatatype) {
+  const sizeInBytes = PixelDatatype.sizeInBytes(pixelDatatype);
+  if (sizeInBytes === Uint8Array.BYTES_PER_ELEMENT) {
+    return Uint8Array;
+  } else if (sizeInBytes === Uint16Array.BYTES_PER_ELEMENT) {
+    return Uint16Array;
+  } else if (
+    sizeInBytes === Float32Array.BYTES_PER_ELEMENT &&
+    pixelDatatype === PixelDatatype.FLOAT
+  ) {
+    return Float32Array;
+  }
+  return Uint32Array;
+};
+
 export default Object.freeze(PixelDatatype);

package/Source/Renderer/Sampler.js

@@ -12,19 +12,13 @@ import TextureWrap from "./TextureWrap.js";
 function Sampler(options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
-  const wrapS = defaultValue(options.wrapS, TextureWrap.CLAMP_TO_EDGE);
-  const wrapT = defaultValue(options.wrapT, TextureWrap.CLAMP_TO_EDGE);
-  const minificationFilter = defaultValue(
-    options.minificationFilter,
-    TextureMinificationFilter.LINEAR
-  );
-  const magnificationFilter = defaultValue(
-    options.magnificationFilter,
-    TextureMagnificationFilter.LINEAR
-  );
-  const maximumAnisotropy = defined(options.maximumAnisotropy)
-    ? options.maximumAnisotropy
-    : 1.0;
+  const {
+    wrapS = TextureWrap.CLAMP_TO_EDGE,
+    wrapT = TextureWrap.CLAMP_TO_EDGE,
+    minificationFilter = TextureMinificationFilter.LINEAR,
+    magnificationFilter = TextureMagnificationFilter.LINEAR,
+    maximumAnisotropy = 1.0,
+  } = options;
 
   //>>includeStart('debug', pragmas.debug);
   if (!TextureWrap.validate(wrapS)) {

package/Source/Renderer/ShaderProgram.js

@@ -556,6 +556,13 @@ ShaderProgram.prototype._setUniforms = function (
     len = manualUniforms.length;
     for (i = 0; i < len; ++i) {
       const mu = manualUniforms[i];
+
+      //>>includeStart('debug', pragmas.debug);
+      if (!defined(uniformMap[mu.name])) {
+        throw new DeveloperError(`Unknown uniform: ${mu.name}`);
+      }
+      //>>includeEnd('debug');
+
       mu.value = uniformMap[mu.name]();
     }
   }