@hztxi/cesium-engine 25.0.0 → 25.0.2

package/Source/DataSources/StaticGroundGeometryPerMaterialBatch.js

@@ -16,6 +16,7 @@ const defaultDistanceDisplayCondition = new DistanceDisplayCondition();
 
 // Encapsulates a Primitive and all the entities that it represents.
 function Batch(
+  scene,
   primitives,
   classificationType,
   appearanceType,
@@ -23,6 +24,7 @@ function Batch(
   usingSphericalTextureCoordinates,
   zIndex,
 ) {
+  this.scene = scene;
   this.primitives = primitives; // scene level primitive collection (each Batch manages its own Primitive from this collection)
   this.classificationType = classificationType;
   this.appearanceType = appearanceType;
@@ -157,6 +159,9 @@ Batch.prototype.update = function (time) {
         this.materialProperty,
         this.material,
       );
+      if (defined(this.scene)) {
+        this.material.update(this.scene.context);
+      }
 
       const AppearanceType = this.appearanceType;
 
@@ -200,6 +205,9 @@ Batch.prototype.update = function (time) {
       this.materialProperty,
       this.material,
     );
+    if (defined(this.scene)) {
+      this.material.update(this.scene.context);
+    }
     this.primitive.appearance.material = this.material;
 
     const updatersWithAttributes = this.updatersWithAttributes.values;
@@ -331,10 +339,12 @@ Batch.prototype.destroy = function () {
  * @private
  */
 function StaticGroundGeometryPerMaterialBatch(
+  scene,
   primitives,
   classificationType,
   appearanceType,
 ) {
+  this._scene = scene;
   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;
@@ -377,6 +387,7 @@ StaticGroundGeometryPerMaterialBatch.prototype.add = function (time, updater) {
   }
   // If a compatible batch wasn't found, create a new batch.
   const batch = new Batch(
+    this._scene,
     this._primitives,
     this._classificationType,
     this._appearanceType,

package/Source/Renderer/Context.js

@@ -342,6 +342,7 @@ function Context(canvas, options) {
   // default emissive texture has a value of (0, 0, 0)
   // default normal texture is +z which is encoded as (0.5, 0.5, 1)
   this._defaultTexture = undefined;
+  this._defaultTransparentTexture = undefined;
   this._defaultEmissiveTexture = undefined;
   this._defaultNormalTexture = undefined;
   this._defaultCubeMap = undefined;
@@ -1032,6 +1033,30 @@ Object.defineProperties(Context.prototype, {
       return this._defaultTexture;
     },
   },
+  /**
+   * A 1x1 RGBA texture initialized to [0, 0, 0, 0]. Used as a placeholder for
+   * image uniforms while asynchronous textures are downloaded so geometry does not
+   * briefly appear filled with white.
+   * @memberof Context.prototype
+   * @type {Texture}
+   */
+  defaultTransparentTexture: {
+    get: function () {
+      if (this._defaultTransparentTexture === undefined) {
+        this._defaultTransparentTexture = new Texture({
+          context: this,
+          source: {
+            width: 1,
+            height: 1,
+            arrayBufferView: new Uint8Array([0, 0, 0, 0]),
+          },
+          flipY: false,
+        });
+      }
+
+      return this._defaultTransparentTexture;
+    },
+  },
   /**
    * A 1x1 RGB texture initialized to [0, 0, 0] representing a material that is
    * not emissive. This can be used as a placeholder texture for emissive
@@ -1714,6 +1739,9 @@ Context.prototype.destroy = function () {
   this._shaderCache = this._shaderCache.destroy();
   this._textureCache = this._textureCache.destroy();
   this._defaultTexture = this._defaultTexture && this._defaultTexture.destroy();
+  this._defaultTransparentTexture =
+    this._defaultTransparentTexture &&
+    this._defaultTransparentTexture.destroy();
   this._defaultEmissiveTexture =
     this._defaultEmissiveTexture && this._defaultEmissiveTexture.destroy();
   this._defaultNormalTexture =

package/Source/Scene/GroundPolylinePrimitive.js

@@ -182,6 +182,9 @@ function GroundPolylinePrimitive(options) {
 
   this._retainedGeometryInstances = undefined;
 
+  /** @private Root {@link GroundPolylineGeometry} ref from the last inner {@link Primitive} build. */
+  this._lastGroundPolylineRootGeometry = undefined;
+
   this._ready = false;
   this._primitive = undefined;
 
@@ -316,19 +319,30 @@ GroundPolylinePrimitive.initializeTerrainHeights = function () {
   return ApproximateTerrainHeights.initialize();
 };
 
+function normalizeGeometryInstances(instances) {
+  if (!defined(instances)) {
+    return instances;
+  }
+  return Array.isArray(instances) ? instances : [instances];
+}
+
 function verticalExaggerationMatchesFrameState(geometryInstances, frameState) {
-  if (!defined(geometryInstances)) {
+  const instances = normalizeGeometryInstances(geometryInstances);
+  if (!defined(instances)) {
     return true;
   }
   const ex = frameState.verticalExaggeration;
   const exRel = frameState.verticalExaggerationRelativeHeight;
-  const length = geometryInstances.length;
+  const length = instances.length;
   for (let i = 0; i < length; ++i) {
-    const geom = geometryInstances[i].geometry;
-    if (
-      geom._verticalExaggeration !== ex ||
-      geom._verticalExaggerationRelativeHeight !== exRel
-    ) {
+    const instance = instances[i];
+    if (!defined(instance) || !defined(instance.geometry)) {
+      return false;
+    }
+    const geom = instance.geometry;
+    const geomEx = geom._verticalExaggeration ?? 1.0;
+    const geomExRel = geom._verticalExaggerationRelativeHeight ?? 0.0;
+    if (geomEx !== ex || geomExRel !== exRel) {
       return false;
     }
   }
@@ -689,6 +703,20 @@ GroundPolylinePrimitive.prototype.update = function (frameState) {
     return;
   }
 
+  let i;
+
+  const that = this;
+  const primitiveOptions = this._primitiveOptions;
+
+  if (
+    defined(this.geometryInstances) &&
+    !defined(this._retainedGeometryInstances)
+  ) {
+    this._retainedGeometryInstances = Array.isArray(this.geometryInstances)
+      ? this.geometryInstances.slice()
+      : [this.geometryInstances];
+  }
+
   if (!ApproximateTerrainHeights.initialized) {
     //>>includeStart('debug', pragmas.debug);
     if (!this.asynchronous) {
@@ -702,23 +730,37 @@ GroundPolylinePrimitive.prototype.update = function (frameState) {
     return;
   }
 
-  let i;
+  const sourceGeometryInstances = normalizeGeometryInstances(
+    this.geometryInstances ?? this._retainedGeometryInstances,
+  );
 
-  const that = this;
-  const primitiveOptions = this._primitiveOptions;
+  let rootGeometryFromSource;
+  if (defined(sourceGeometryInstances)) {
+    const src0 = sourceGeometryInstances[0];
+    if (defined(src0) && defined(src0.geometry)) {
+      rootGeometryFromSource = src0.geometry;
+    }
+  }
 
+  // New GeometryInstances (e.g. dynamic Entity polylines) assign a fresh GroundPolylineGeometry
+  // each frame. Destroy the inner Primitive when the source geometry object changes; otherwise
+  // we would keep rendering the previous combineGeometry result.
   if (
-    defined(this.geometryInstances) &&
-    !defined(this._retainedGeometryInstances)
+    defined(this._primitive) &&
+    defined(rootGeometryFromSource) &&
+    rootGeometryFromSource !== this._lastGroundPolylineRootGeometry
   ) {
-    this._retainedGeometryInstances = Array.isArray(this.geometryInstances)
-      ? this.geometryInstances.slice()
-      : [this.geometryInstances];
+    this._primitive = this._primitive.destroy();
+    this._primitive = undefined;
+    this._ready = false;
+    if (defined(this._sp)) {
+      this._sp = this._sp.destroy();
+    }
+    this._sp2D = undefined;
+    this._spMorph = undefined;
+    this._lastGroundPolylineRootGeometry = undefined;
   }
 
-  const sourceGeometryInstances =
-    this.geometryInstances ?? this._retainedGeometryInstances;
-
   if (
     defined(this._primitive) &&
     !verticalExaggerationMatchesFrameState(sourceGeometryInstances, frameState)
@@ -740,6 +782,7 @@ GroundPolylinePrimitive.prototype.update = function (frameState) {
 
     let attributes;
 
+    this._hasPerInstanceColors = true;
     // Check if each instance has a color attribute.
     for (i = 0; i < geometryInstancesLength; ++i) {
       attributes = geometryInstances[i].attributes;
@@ -752,7 +795,7 @@ GroundPolylinePrimitive.prototype.update = function (frameState) {
     for (i = 0; i < geometryInstancesLength; ++i) {
       const geometryInstance = geometryInstances[i];
       attributes = {};
-      const instanceAttributes = geometryInstance.attributes;
+      const instanceAttributes = geometryInstance.attributes ?? {};
       for (const attributeKey in instanceAttributes) {
         if (instanceAttributes.hasOwnProperty(attributeKey)) {
           attributes[attributeKey] = instanceAttributes[attributeKey];
@@ -837,6 +880,7 @@ GroundPolylinePrimitive.prototype.update = function (frameState) {
     };
 
     this._primitive = new Primitive(primitiveOptions);
+    this._lastGroundPolylineRootGeometry = rootGeometryFromSource;
   }
 
   if (
@@ -932,6 +976,7 @@ GroundPolylinePrimitive.prototype.isDestroyed = function () {
  * @see GroundPolylinePrimitive#isDestroyed
  */
 GroundPolylinePrimitive.prototype.destroy = function () {
+  this._lastGroundPolylineRootGeometry = undefined;
   this._primitive = this._primitive && this._primitive.destroy();
   this._sp = this._sp && this._sp.destroy();
 

package/Source/Scene/Material.js

@@ -326,6 +326,7 @@ function Material(options) {
   this._updateFunctions = [];
 
   this._defaultTexture = undefined;
+  this._transparentPlaceholderTexture = undefined;
 
   /**
    * Any and all promises that are created when initializing the material.
@@ -530,6 +531,7 @@ Material.prototype.isTranslucent = function () {
  */
 Material.prototype.update = function (context) {
   this._defaultTexture = context.defaultTexture;
+  this._transparentPlaceholderTexture = context.defaultTransparentTexture;
 
   let i;
   let uniformId;
@@ -582,7 +584,10 @@ Material.prototype.update = function (context) {
     // This will ensure a smooth swap of textures and prevent the default texture
     // from appearing for a few frames.
     const oldTexture = this._textures[uniformId];
-    if (defined(oldTexture) && oldTexture !== this._defaultTexture) {
+    if (
+      defined(oldTexture) &&
+      !isContextOwnedPlaceholderTexture(this, oldTexture)
+    ) {
       oldTexture.destroy();
     }
 
@@ -676,7 +681,7 @@ Material.prototype.destroy = function () {
   for (const texture in textures) {
     if (textures.hasOwnProperty(texture)) {
       const instance = textures[texture];
-      if (instance !== this._defaultTexture) {
+      if (!isContextOwnedPlaceholderTexture(this, instance)) {
         instance.destroy();
       }
     }
@@ -895,6 +900,13 @@ const matrixMap = {
 
 const ktx2Regex = /\.ktx2$/i;
 
+function isContextOwnedPlaceholderTexture(material, texture) {
+  return (
+    texture === material._defaultTexture ||
+    texture === material._transparentPlaceholderTexture
+  );
+}
+
 function createTexture2DUpdateFunction(uniformId) {
   let oldUniformValue;
   return function (material, context) {
@@ -946,7 +958,7 @@ function createTexture2DUpdateFunction(uniformId) {
     if (uniformValue instanceof Texture && uniformValue !== texture) {
       material._texturePaths[uniformId] = undefined;
       const tmp = material._textures[uniformId];
-      if (defined(tmp) && tmp !== material._defaultTexture) {
+      if (defined(tmp) && !isContextOwnedPlaceholderTexture(material, tmp)) {
         tmp.destroy();
       }
       material._textures[uniformId] = uniformValue;
@@ -965,7 +977,7 @@ function createTexture2DUpdateFunction(uniformId) {
       // If the newly-assigned texture is the default texture,
       // we don't need to wait for a new image to load before destroying
       // the old texture.
-      if (texture !== material._defaultTexture) {
+      if (!isContextOwnedPlaceholderTexture(material, texture)) {
         texture.destroy();
       }
       texture = undefined;
@@ -973,7 +985,28 @@ function createTexture2DUpdateFunction(uniformId) {
     }
 
     if (!defined(texture)) {
-      texture = material._textures[uniformId] = material._defaultTexture;
+      const useTransparentImagePlaceholder =
+        material.type === Material.ImageType &&
+        uniformId === "image" &&
+        !uniformValueIsDefaultImage;
+      texture = material._textures[uniformId] = useTransparentImagePlaceholder
+        ? context.defaultTransparentTexture
+        : material._defaultTexture;
+
+      uniformDimensionsName = `${uniformId}Dimensions`;
+      if (uniforms.hasOwnProperty(uniformDimensionsName)) {
+        uniformDimensions = uniforms[uniformDimensionsName];
+        uniformDimensions.x = texture._width;
+        uniformDimensions.y = texture._height;
+      }
+    } else if (
+      material.type === Material.ImageType &&
+      uniformId === "image" &&
+      !uniformValueIsDefaultImage &&
+      texture === material._defaultTexture
+    ) {
+      texture = material._textures[uniformId] =
+        context.defaultTransparentTexture;
 
       uniformDimensionsName = `${uniformId}Dimensions`;
       if (uniforms.hasOwnProperty(uniformDimensionsName)) {
@@ -1061,7 +1094,10 @@ function loadTexture2DImageForUniform(material, uniformId) {
     .catch(function (error) {
       material._initializationError = error;
       const texture = material._textures[uniformId];
-      if (defined(texture) && texture !== material._defaultTexture) {
+      if (
+        defined(texture) &&
+        !isContextOwnedPlaceholderTexture(material, texture)
+      ) {
         texture.destroy();
       }
       material._textures[uniformId] = material._defaultTexture;
@@ -1440,7 +1476,15 @@ Material._materialCache.addMaterial(Material.ImageType, {
     },
   },
   translucent: function (material) {
-    return material.uniforms.color.alpha < 1.0;
+    if (material.uniforms.color.alpha < 1.0) {
+      return true;
+    }
+    const tex = material._textures.image;
+    return (
+      defined(tex) &&
+      defined(material._transparentPlaceholderTexture) &&
+      tex === material._transparentPlaceholderTexture
+    );
   },
 });
 

package/Source/Scene/Primitive.js

@@ -485,7 +485,14 @@ function getCommonPerInstanceAttributeNames(instances) {
   const length = instances.length;
 
   const attributesInAllInstances = [];
+  if (length === 0 || !defined(instances[0])) {
+    return attributesInAllInstances;
+  }
+
   const attributes0 = instances[0].attributes;
+  if (!defined(attributes0)) {
+    return attributesInAllInstances;
+  }
   let name;
 
   for (name in attributes0) {
@@ -495,7 +502,13 @@ function getCommonPerInstanceAttributeNames(instances) {
 
       // Does this same attribute exist in all instances?
       for (let i = 1; i < length; ++i) {
-        const otherAttribute = instances[i].attributes[name];
+        const otherInstance = instances[i];
+        const otherAttributes = defined(otherInstance)
+          ? otherInstance.attributes
+          : undefined;
+        const otherAttribute = defined(otherAttributes)
+          ? otherAttributes[name]
+          : undefined;
 
         if (
           !defined(otherAttribute) ||
@@ -537,11 +550,14 @@ function getAttributeValue(value) {
 
 function createBatchTable(primitive, context) {
   const geometryInstances = primitive.geometryInstances;
+  if (!defined(geometryInstances)) {
+    return;
+  }
   const instances = Array.isArray(geometryInstances)
     ? geometryInstances
     : [geometryInstances];
   const numberOfInstances = instances.length;
-  if (numberOfInstances === 0) {
+  if (numberOfInstances === 0 || !defined(instances[0])) {
     return;
   }
 
@@ -2109,6 +2125,9 @@ Primitive.prototype.update = function (frameState) {
   if (!defined(this._batchTable)) {
     createBatchTable(this, context);
   }
+  if (!defined(this._batchTable)) {
+    return;
+  }
   if (this._batchTable.attributes.length > 0) {
     if (ContextLimits.maximumVertexTextureImageUnits === 0) {
       throw new RuntimeError(