@cesium/engine 18.3.1-ion.0 → 19.0.0

package/Source/DataSources/StaticGroundGeometryPerMaterialBatch.js

@@ -23,24 +23,18 @@ function Batch(
   usingSphericalTextureCoordinates,
   zIndex,
 ) {
-  this.primitives = primitives; // scene level primitive collection
+  this.primitives = primitives; // scene level primitive collection (each Batch manages its own Primitive from this collection)
   this.classificationType = classificationType;
   this.appearanceType = appearanceType;
   this.materialProperty = materialProperty;
-  this.updaters = new AssociativeArray();
+  this.updaters = new AssociativeArray(); // GeometryUpdaters that manage the visual representation of the primitive.
   this.createPrimitive = true;
   this.primitive = undefined; // a GroundPrimitive encapsulating all the entities
-  this.oldPrimitive = undefined;
+  this.oldPrimitive = undefined; // a GroundPrimitive that is being replaced by the current primitive, but will still be shown until the current primitive is ready.
   this.geometry = new AssociativeArray();
   this.material = undefined;
   this.updatersWithAttributes = new AssociativeArray();
   this.attributes = new AssociativeArray();
-  this.invalidated = false;
-  this.removeMaterialSubscription =
-    materialProperty.definitionChanged.addEventListener(
-      Batch.prototype.onMaterialChanged,
-      this,
-    );
   this.subscriptions = new AssociativeArray();
   this.showsUpdated = new AssociativeArray();
   this.usingSphericalTextureCoordinates = usingSphericalTextureCoordinates;
@@ -48,10 +42,6 @@ function Batch(
   this.rectangleCollisionCheck = new RectangleCollisionChecker();
 }
 
-Batch.prototype.onMaterialChanged = function () {
-  this.invalidated = true;
-};
-
 Batch.prototype.overlapping = function (rectangle) {
   return this.rectangleCollisionCheck.collides(rectangle);
 };
@@ -71,6 +61,13 @@ Batch.prototype.isMaterial = function (updater) {
   return defined(material) && material.equals(updaterMaterial);
 };
 
+/**
+ * Adds an updater to the Batch, and signals for a new Primitive to be created on the next update.
+ * @param {JulianDate} time
+ * @param {GeometryUpdater} updater
+ * @param {GeometryInstance} geometryInstance
+ * @private
+ */
 Batch.prototype.add = function (time, updater, geometryInstance) {
   const id = updater.id;
   this.updaters.set(id, updater);
@@ -100,6 +97,13 @@ Batch.prototype.add = function (time, updater, geometryInstance) {
   this.createPrimitive = true;
 };
 
+/**
+ * Remove an updater from the Batch, and potentially signals for a new Primitive to be created
+ * on the next update.
+ * @param {GeometryUpdater} updater
+ * @returns true if the updater was removed, false if it was not found.
+ * @private
+ */
 Batch.prototype.remove = function (updater) {
   const id = updater.id;
   const geometryInstance = this.geometry.get(id);
@@ -120,6 +124,13 @@ Batch.prototype.remove = function (updater) {
   return false;
 };
 
+/**
+ * Update a Batch, creating a new primitive, if necessary, or swapping out an old primitive for a new one that's ready.
+ * A new primitive is created whenever an updater is added to or removed from a Batch.
+ * @param {JulianDate} time
+ * @returns a boolean indicating whether the Batch was updated.
+ * @private
+ */
 Batch.prototype.update = function (time) {
   let isUpdated = true;
   let primitive = this.primitive;
@@ -295,6 +306,10 @@ Batch.prototype.getBoundingSphere = function (updater, result) {
   return BoundingSphereState.DONE;
 };
 
+/**
+ * Removes a Batch's primitive (and oldPrimitive, if it exists).
+ * @private
+ */
 Batch.prototype.destroy = function () {
   const primitive = this.primitive;
   const primitives = this.primitives;
@@ -305,10 +320,11 @@ Batch.prototype.destroy = function () {
   if (defined(oldPrimitive)) {
     primitives.remove(oldPrimitive);
   }
-  this.removeMaterialSubscription();
 };
 
 /**
+ * A container of Batch objects of ground geometry primitives, where a Batch is grouped by material,
+ * texture coordinate type, and spatial overlap.
  * @private
  */
 function StaticGroundGeometryPerMaterialBatch(
@@ -316,12 +332,20 @@ function StaticGroundGeometryPerMaterialBatch(
   classificationType,
   appearanceType,
 ) {
-  this._items = [];
-  this._primitives = primitives;
+  this._items = []; // array of Batch objects, each containing representing a primitive and a set of updaters that manage the visual representation of the primitive.
+  this._primitives = primitives; // scene level primitive collection
   this._classificationType = classificationType;
   this._appearanceType = appearanceType;
 }
 
+/**
+ * Adds an geometry updater to a Batch. Tries to find a preexisting compatible Batch, or else creates a new Batch.
+ * Used by Visualizer classes to add and update (remove->add) a primitive's Updater set.
+ *
+ * @param {JulianDate} time
+ * @param {GeometryUpdater} updater A GeometryUpdater that manages the visual representation of a primitive.
+ * @private
+ */
 StaticGroundGeometryPerMaterialBatch.prototype.add = function (time, updater) {
   const items = this._items;
   const length = items.length;
@@ -361,21 +385,30 @@ StaticGroundGeometryPerMaterialBatch.prototype.add = function (time, updater) {
   items.push(batch);
 };
 
+/**
+ * Removes an updater from a Batch. Defers potential deletion until the next update.
+ * @param {GeometryUpdater} updater A GeometryUpdater that manages the visual representation of a primitive.
+ * @private
+ */
 StaticGroundGeometryPerMaterialBatch.prototype.remove = function (updater) {
   const items = this._items;
   const length = items.length;
   for (let i = length - 1; i >= 0; i--) {
     const item = items[i];
     if (item.remove(updater)) {
-      if (item.updaters.length === 0) {
-        items.splice(i, 1);
-        item.destroy();
-      }
+      // If the item is now empty, delete it (deferred until the next update,
+      // in case a new updater is added to the same item first).
       break;
     }
   }
 };
 
+/**
+ * Updates all the items (Batches) in the collection, and deletes any that are empty.
+ * @param {JulianDate} time
+ * @returns a boolean indicating whether any of the items (Batches) were updated.
+ * @private
+ */
 StaticGroundGeometryPerMaterialBatch.prototype.update = function (time) {
   let i;
   const items = this._items;
@@ -383,13 +416,8 @@ StaticGroundGeometryPerMaterialBatch.prototype.update = function (time) {
 
   for (i = length - 1; i >= 0; i--) {
     const item = items[i];
-    if (item.invalidated) {
+    if (item.updaters.length === 0) {
       items.splice(i, 1);
-      const updaters = item.updaters.values;
-      const updatersLength = updaters.length;
-      for (let h = 0; h < updatersLength; h++) {
-        this.add(time, updaters[h]);
-      }
       item.destroy();
     }
   }

package/Source/Renderer/Context.js

@@ -1415,6 +1415,10 @@ Context.prototype.draw = function (
   continueDraw(this, drawCommand, shaderProgram, uniformMap);
 };
 
+Context.prototype.beginFrame = function () {
+  // A no-op. Overridden when drawing to a SharedContext.
+};
+
 Context.prototype.endFrame = function () {
   const gl = this._gl;
   gl.useProgram(null);
@@ -1442,8 +1446,8 @@ Context.prototype.endFrame = function () {
  * @param {object} readState An object with the following properties:
  * @param {number} [readState.x=0] The x offset of the rectangle to read from.
  * @param {number} [readState.y=0] The y offset of the rectangle to read from.
- * @param {number} [readState.width=gl.drawingBufferWidth] The width of the rectangle to read from.
- * @param {number} [readState.height=gl.drawingBufferHeight] The height of the rectangle to read from.
+ * @param {number} [readState.width=this.drawingBufferWidth] The width of the rectangle to read from.
+ * @param {number} [readState.height=this.drawingBufferHeight] The height of the rectangle to read from.
  * @param {Framebuffer} [readState.framebuffer] The framebuffer to read from. If undefined, the read will be from the default framebuffer.
  * @returns {Uint8Array|Uint16Array|Float32Array|Uint32Array} The pixels in the specified rectangle.
  */
@@ -1453,8 +1457,8 @@ Context.prototype.readPixels = function (readState) {
   readState = readState ?? Frozen.EMPTY_OBJECT;
   const x = Math.max(readState.x ?? 0, 0);
   const y = Math.max(readState.y ?? 0, 0);
-  const width = readState.width ?? gl.drawingBufferWidth;
-  const height = readState.height ?? gl.drawingBufferHeight;
+  const width = readState.width ?? this.drawingBufferWidth;
+  const height = readState.height ?? this.drawingBufferHeight;
   const framebuffer = readState.framebuffer;
 
   //>>includeStart('debug', pragmas.debug);

package/Source/Renderer/Renderbuffer.js

@@ -21,10 +21,12 @@ function Renderbuffer(options) {
   const maximumRenderbufferSize = ContextLimits.maximumRenderbufferSize;
 
   const format = options.format ?? RenderbufferFormat.RGBA4;
-  const width = defined(options.width) ? options.width : gl.drawingBufferWidth;
+  const width = defined(options.width)
+    ? options.width
+    : context.drawingBufferWidth;
   const height = defined(options.height)
     ? options.height
-    : gl.drawingBufferHeight;
+    : context.drawingBufferHeight;
   const numSamples = options.numSamples ?? 1;
 
   //>>includeStart('debug', pragmas.debug);

package/Source/Renderer/Sampler.js

@@ -13,6 +13,7 @@ function Sampler(options) {
   options = options ?? Frozen.EMPTY_OBJECT;
 
   const {
+    wrapR = TextureWrap.CLAMP_TO_EDGE,
     wrapS = TextureWrap.CLAMP_TO_EDGE,
     wrapT = TextureWrap.CLAMP_TO_EDGE,
     minificationFilter = TextureMinificationFilter.LINEAR,
@@ -21,6 +22,10 @@ function Sampler(options) {
   } = options;
 
   //>>includeStart('debug', pragmas.debug);
+  if (!TextureWrap.validate(wrapR)) {
+    throw new DeveloperError("Invalid sampler.wrapR.");
+  }
+
   if (!TextureWrap.validate(wrapS)) {
     throw new DeveloperError("Invalid sampler.wrapS.");
   }
@@ -44,6 +49,7 @@ function Sampler(options) {
   );
   //>>includeEnd('debug');
 
+  this._wrapR = wrapR;
   this._wrapS = wrapS;
   this._wrapT = wrapT;
   this._minificationFilter = minificationFilter;
@@ -52,6 +58,11 @@ function Sampler(options) {
 }
 
 Object.defineProperties(Sampler.prototype, {
+  wrapR: {
+    get: function () {
+      return this._wrapR;
+    },
+  },
   wrapS: {
     get: function () {
       return this._wrapS;
@@ -84,6 +95,7 @@ Sampler.equals = function (left, right) {
     left === right ||
     (defined(left) &&
       defined(right) &&
+      left._wrapR === right._wrapR &&
       left._wrapS === right._wrapS &&
       left._wrapT === right._wrapT &&
       left._minificationFilter === right._minificationFilter &&
@@ -94,6 +106,7 @@ Sampler.equals = function (left, right) {
 
 Sampler.NEAREST = Object.freeze(
   new Sampler({
+    wrapR: TextureWrap.CLAMP_TO_EDGE,
     wrapS: TextureWrap.CLAMP_TO_EDGE,
     wrapT: TextureWrap.CLAMP_TO_EDGE,
     minificationFilter: TextureMinificationFilter.NEAREST,

package/Source/Renderer/ShaderBuilder.js

@@ -7,6 +7,7 @@ import ShaderProgram from "./ShaderProgram.js";
 import ShaderSource from "./ShaderSource.js";
 import ShaderStruct from "./ShaderStruct.js";
 import ShaderFunction from "./ShaderFunction.js";
+import addAllToArray from "../Core/addAllToArray.js";
 
 /**
  * An object that makes it easier to build the text of a {@link ShaderProgram}. This tracks GLSL code for both the vertex shader and the fragment shader.
@@ -413,7 +414,7 @@ ShaderBuilder.prototype.addVertexLines = function (lines) {
 
   const vertexLines = this._vertexShaderParts.shaderLines;
   if (Array.isArray(lines)) {
-    vertexLines.push.apply(vertexLines, lines);
+    addAllToArray(vertexLines, lines);
   } else {
     // Single string case
     vertexLines.push(lines);
@@ -448,7 +449,7 @@ ShaderBuilder.prototype.addFragmentLines = function (lines) {
 
   const fragmentLines = this._fragmentShaderParts.shaderLines;
   if (Array.isArray(lines)) {
-    fragmentLines.push.apply(fragmentLines, lines);
+    addAllToArray(fragmentLines, lines);
   } else {
     // Single string case
     fragmentLines.push(lines);
@@ -533,7 +534,7 @@ function generateStructLines(shaderBuilder) {
     structId = structIds[i];
     struct = shaderBuilder._structs[structId];
     structLines = struct.generateGlslLines();
-    vertexLines.push.apply(vertexLines, structLines);
+    addAllToArray(vertexLines, structLines);
   }
 
   structIds = shaderBuilder._fragmentShaderParts.structIds;
@@ -541,7 +542,7 @@ function generateStructLines(shaderBuilder) {
     structId = structIds[i];
     struct = shaderBuilder._structs[structId];
     structLines = struct.generateGlslLines();
-    fragmentLines.push.apply(fragmentLines, structLines);
+    addAllToArray(fragmentLines, structLines);
   }
 
   return {
@@ -576,7 +577,7 @@ function generateFunctionLines(shaderBuilder) {
     functionId = functionIds[i];
     func = shaderBuilder._functions[functionId];
     functionLines = func.generateGlslLines();
-    vertexLines.push.apply(vertexLines, functionLines);
+    addAllToArray(vertexLines, functionLines);
   }
 
   functionIds = shaderBuilder._fragmentShaderParts.functionIds;
@@ -584,7 +585,7 @@ function generateFunctionLines(shaderBuilder) {
     functionId = functionIds[i];
     func = shaderBuilder._functions[functionId];
     functionLines = func.generateGlslLines();
-    fragmentLines.push.apply(fragmentLines, functionLines);
+    addAllToArray(fragmentLines, functionLines);
   }
 
   return {

package/Source/Renderer/SharedContext.js

@@ -0,0 +1,186 @@
+import clone from "../Core/clone.js";
+import destroyObject from "../Core/destroyObject.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import Context from "./Context.js";
+
+/**
+ * Enables a single WebGL context to be used by any number of {@link Scene}s.
+ * You can pass a SharedContext in place of a {@link ContextOptions} to the constructors of {@link Scene}, {@link CesiumWidget}, and {@link Viewer}.
+ * {@link Primitive}s associated with the shared WebGL context can be displayed in any Scene that uses the same context.
+ * The context renders each Scene to an off-screen canvas, then blits the result to that Scene's on-screen canvas.
+ *
+ * @private
+ * @alias SharedContext
+ * @constructor
+ *
+ * @param {object} [options] Object with the following properties:
+ * @param {ContextOptions} [options.contextOptions] Context and WebGL creation properties.
+ * @param {boolean} [options.autoDestroy=true] Destroys this context and all of its WebGL resources after all Scenes using the context are destroyed.
+
+ * @see {@link http://www.khronos.org/registry/webgl/specs/latest/#5.2|WebGLContextAttributes}
+ *
+ * @example
+ * // Create two Scenes sharing a single WebGL context
+ * const context = new Cesium.SharedContext();
+ * const scene1 = new Cesium.Scene({
+ *   canvas: canvas1,
+ *   contextOptions: context,
+ * });
+ * const scene2 = new Cesium.Scene({
+ *   canvas: canvas2,
+ *   contextOptions: context,
+ * });
+ */
+function SharedContext(options) {
+  this._autoDestroy = options?.autoDestroy ?? true;
+  this._canvas = document.createElement("canvas");
+  this._context = new Context(this._canvas, clone(options?.contextOptions));
+  this._canvases = [];
+}
+
+/**
+ * Creates an instance of {@link Context} that manages the shared WebGL context for a specific canvas.
+ * @param {HTMLCanvasElement} canvas The canvas element to which the context will be associated
+ * @returns {Context} The created context instance
+ * @private
+ */
+SharedContext.prototype.createSceneContext = function (canvas) {
+  const context2d = canvas.getContext("2d", { alpha: true });
+
+  //>>includeStart('debug', pragmas.debug);
+  if (!context2d) {
+    throw new DeveloperError(
+      "canvas used with SharedContext must provide a 2d context",
+    );
+  }
+
+  if (this._canvases.includes(canvas)) {
+    throw new DeveloperError("canvas is already associated with a scene");
+  }
+  //>>includeEnd('debug');
+
+  const sharedContext = this;
+  sharedContext._canvases.push(canvas);
+
+  let isDestroyed = false;
+  const destroy = function () {
+    isDestroyed = true;
+    const index = sharedContext._canvases.indexOf(canvas);
+    if (-1 !== index) {
+      sharedContext._canvases.splice(index, 1);
+      if (sharedContext._autoDestroy && sharedContext._canvases.length === 0) {
+        sharedContext.destroy();
+      }
+    }
+  };
+
+  const beginFrame = function () {
+    // Ensure the off-screen canvas is at least as large as the on-screen canvas.
+    const sharedCanvas = sharedContext._context.canvas;
+
+    const width = this.drawingBufferWidth;
+    if (sharedCanvas.width < width) {
+      sharedCanvas.width = width;
+    }
+
+    const height = this.drawingBufferHeight;
+    if (sharedCanvas.height < height) {
+      sharedCanvas.height = height;
+    }
+  };
+
+  const endFrame = function () {
+    // Blit the image from the off-screen canvas to the on-screen canvas.
+    const w = this.drawingBufferWidth;
+    const h = this.drawingBufferHeight;
+    const yOffset = sharedContext._context.canvas.height - h; // drawImage has top as Y=0, GL has bottom as Y=0
+    context2d.drawImage(
+      sharedContext._context.canvas,
+      0,
+      yOffset,
+      w,
+      h,
+      0,
+      0,
+      w,
+      h,
+    );
+
+    // Do normal post-frame cleanup.
+    sharedContext._context.endFrame();
+  };
+
+  const proxy = new Proxy(this._context, {
+    get(target, prop, receiver) {
+      if (prop === "isDestroyed") {
+        return function () {
+          return isDestroyed;
+        };
+      } else if (isDestroyed) {
+        //>>includeStart('debug', pragmas.debug);
+        throw new DeveloperError(
+          "This object was destroyed, i.e., destroy() was called.",
+        );
+        //>>includeEnd('debug');
+      }
+
+      switch (prop) {
+        case "_canvas":
+          return canvas;
+        case "destroy":
+          return destroy;
+        case "drawingBufferWidth":
+          return canvas.width;
+        case "drawingBufferHeight":
+          return canvas.height;
+        case "beginFrame":
+          return beginFrame;
+        case "endFrame":
+          return endFrame;
+        default:
+          return Reflect.get(target, prop, receiver);
+      }
+    },
+  });
+
+  return proxy;
+};
+
+/**
+ * Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
+ * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+ * <br /><br />
+ * Once an object is destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
+ * assign the return value (<code>undefined</code>) to the object as done in the example.
+ * <br /><br />
+ * By default, a SharedContext is destroyed automatically once the last Scene using it is destroyed, in which case it
+ * is not necessary to call this method directly.
+ *
+ * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+ *
+ * @example
+ * context = context && context.destroy();
+ *
+ * @see SharedContext#isDestroyed
+ */
+SharedContext.prototype.destroy = function () {
+  this._context.destroy();
+  destroyObject(this);
+};
+
+/**
+ * Returns true if this object was destroyed; otherwise, false.
+ * <br /><br />
+ * If this object was destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+ *
+ * @returns {boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ *
+ * @see SharedContext#destroy
+ */
+SharedContext.prototype.isDestroyed = function () {
+  return false;
+};
+
+export default SharedContext;

package/Source/Renderer/Texture.js

@@ -623,13 +623,12 @@ Texture.fromFramebuffer = function (options) {
   //>>includeEnd('debug');
 
   const context = options.context;
-  const gl = context._gl;
   const {
     pixelFormat = PixelFormat.RGB,
     framebufferXOffset = 0,
     framebufferYOffset = 0,
-    width = gl.drawingBufferWidth,
-    height = gl.drawingBufferHeight,
+    width = context.drawingBufferWidth,
+    height = context.drawingBufferHeight,
     framebuffer,
   } = options;
 
@@ -656,12 +655,12 @@ Texture.fromFramebuffer = function (options) {
     framebufferYOffset,
     0,
   );
-  if (framebufferXOffset + width > gl.drawingBufferWidth) {
+  if (framebufferXOffset + width > context.drawingBufferWidth) {
     throw new DeveloperError(
       "framebufferXOffset + width must be less than or equal to drawingBufferWidth",
     );
   }
-  if (framebufferYOffset + height > gl.drawingBufferHeight) {
+  if (framebufferYOffset + height > context.drawingBufferHeight) {
     throw new DeveloperError(
       "framebufferYOffset + height must be less than or equal to drawingBufferHeight.",
     );

package/Source/Renderer/Texture3D.js

@@ -13,21 +13,30 @@ import Sampler from "./Sampler.js";
 import TextureMagnificationFilter from "./TextureMagnificationFilter.js";
 import TextureMinificationFilter from "./TextureMinificationFilter.js";
 
+/**
+ * @typedef {object} Texture3D.Source
+ * @property {number} width The width (in pixels) of the 3D texture source data.
+ * @property {number} height The height (in pixels) of the 3D texture source data.
+ * @property {number} depth The depth (in pixels) of the 3D texture source data.
+ * @property {TypedArray|DataView} arrayBufferView The source data for a 3D texture. The type of each element needs to match the pixelDatatype.
+ * @property {TypedArray|DataView} [mipLevels] An array of mip level data. Each element in the array should be a TypedArray or DataView that matches the pixelDatatype.
+ */
+
 /**
  * @typedef {object} Texture3D.ConstructorOptions
  *
  * @property {Context} context
- * @property {object} [source] The source for texel values to be loaded into the texture3D.
+ * @property {Texture3D.Source} [source] The source for texel values to be loaded into the 3D texture.
  * @property {PixelFormat} [pixelFormat=PixelFormat.RGBA] The format of each pixel, i.e., the number of components it has and what they represent.
  * @property {PixelDatatype} [pixelDatatype=PixelDatatype.UNSIGNED_BYTE] The data type of each pixel.
  * @property {boolean} [flipY=true] If true, the source values will be read as if the y-axis is inverted (y=0 at the top).
  * @property {boolean} [skipColorSpaceConversion=false] If true, color space conversions will be skipped when reading the texel values.
- * @property {Sampler} [sampler] Information about how to sample the texture3D.
- * @property {number} [width] The pixel width of the texture3D. If not supplied, must be available from the source.
- * @property {number} [height] The pixel height of the texture3D. If not supplied, must be available from the source.
- * @property {number} [depth] The pixel depth of the texture3D. If not supplied, must be available from the source.
+ * @property {Sampler} [sampler] Information about how to sample the 3D texture.
+ * @property {number} [width] The width (in pixels) of the 3D texture. If not supplied, must be available from the source.
+ * @property {number} [height] The height (in pixels) of the 3D texture. If not supplied, must be available from the source.
+ * @property {number} [depth] The depth (in pixels) of the 3D texture. If not supplied, must be available from the source.
  * @property {boolean} [preMultiplyAlpha] If true, the alpha channel will be multiplied into the other channels.
- * @property {string} [id] A unique identifier for the texture3D. If this is not given, then a GUID will be created.
+ * @property {string} [id] A unique identifier for the 3D texture. If this is not given, then a GUID will be created.
  *
  * @private
  */
@@ -253,7 +262,7 @@ function Texture3D(options) {
  * Load texel data from a buffer into a texture3D.
  *
  * @param {Texture3D} texture3D The texture3D to which texel values will be loaded.
- * @param {object} source The source for texel values to be loaded into the texture3D.
+ * @param {Texture3D.Source} source The source for texel values to be loaded into the texture3D.
  *
  * @private
  */
@@ -503,6 +512,7 @@ function setupSampler(texture3D, sampler) {
   gl.bindTexture(target, texture3D._texture);
   gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, minificationFilter);
   gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, magnificationFilter);
+  gl.texParameteri(target, gl.TEXTURE_WRAP_R, sampler.wrapR);
   gl.texParameteri(target, gl.TEXTURE_WRAP_S, sampler.wrapS);
   gl.texParameteri(target, gl.TEXTURE_WRAP_T, sampler.wrapT);
   if (defined(texture3D._textureFilterAnisotropic)) {

package/Source/Scene/ArcGisMapService.js

@@ -4,7 +4,7 @@ import Resource from "../Core/Resource.js";
 
 let defaultTokenCredit;
 const defaultAccessToken =
-  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmTvj0sIevECBw-bvZAvk8zYQRQq68aswXB6_yVObhIYNHapUAk3eqDIvpDZAUjFHpy1wJdPnkcKqSGXXGM22C1fqVC0gbU2S_RjRHuIHK5WVIYP7fUJQPjRGD1weDGyD5vBqwZX1Ah4LLUPG9474k1fvB1_vIROH9r9R-Sd9f9pbBFr9FjKfISJZiiJdaXVas4.AT1_eWrg8X2i";
+  "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmRpOZfBt2Ic5blmnx9xwwyG_Mt0EmBxpEa6xCqXn5V_qFEgJ0edE9ixiefKjMiv986NGSn2HB8y6x0GtSOCBkg19K6rBgZ7Upl7ABEnaFh4dD73GW0gUAJ9hHWhqd1qgHkBuctWiFEJUmQjs_52tdx6l5bDGoeXVvmelklmEJOshCRV_s3kLPC19ENRNLc18eA.AT1_EXUMUBsi";
 /**
  * Default options for accessing the ArcGIS image tile service.
  *

package/Source/Scene/BillboardCollection.js

@@ -1118,7 +1118,7 @@ function writeCompressedAttrib1(
     }
   }
 
-  const imageWidth = billboard.width ?? 0;
+  const imageWidth = Math.round(billboard.width ?? 0);
   billboardCollection._maxSize = Math.max(
     billboardCollection._maxSize,
     imageWidth,

package/Source/Scene/Cesium3DTileBatchTable.js

@@ -23,6 +23,7 @@ import getBinaryAccessor from "./getBinaryAccessor.js";
 import StencilConstants from "./StencilConstants.js";
 import StencilFunction from "./StencilFunction.js";
 import StencilOperation from "./StencilOperation.js";
+import addAllToArray from "../Core/addAllToArray.js";
 
 const DEFAULT_COLOR_VALUE = BatchTexture.DEFAULT_COLOR_VALUE;
 const DEFAULT_SHOW_VALUE = BatchTexture.DEFAULT_SHOW_VALUE;
@@ -369,13 +370,14 @@ Cesium3DTileBatchTable.prototype.getPropertyIds = function (batchId, results) {
   results.length = 0;
 
   const scratchPropertyIds = Object.keys(this._properties);
-  results.push.apply(results, scratchPropertyIds);
+  addAllToArray(results, scratchPropertyIds);
 
   if (defined(this._batchTableHierarchy)) {
-    results.push.apply(
-      results,
-      this._batchTableHierarchy.getPropertyIds(batchId, scratchPropertyIds),
+    const propertyIds = this._batchTableHierarchy.getPropertyIds(
+      batchId,
+      scratchPropertyIds,
     );
+    addAllToArray(results, propertyIds);
   }
 
   return results;