@cesium/engine 12.0.1 → 13.1.0

package/Source/Scene/DynamicEnvironmentMapManager.js

@@ -12,6 +12,7 @@ import PixelFormat from "../Core/PixelFormat.js";
 import SceneMode from "./SceneMode.js";
 import Transforms from "../Core/Transforms.js";
 import ComputeCommand from "../Renderer/ComputeCommand.js";
+import ContextLimits from "../Renderer/ContextLimits.js";
 import CubeMap from "../Renderer/CubeMap.js";
 import Framebuffer from "../Renderer/Framebuffer.js";
 import Texture from "../Renderer/Texture.js";
@@ -32,7 +33,7 @@ import ConvolveSpecularMapVS from "../Shaders/ConvolveSpecularMapVS.js";
  * @typedef {object} DynamicEnvironmentMapManager.ConstructorOptions
  * Options for the DynamicEnvironmentMapManager constructor
  * @property {boolean} [enabled=true] If true, the environment map and related properties will continue to update.
- * @property {number} [mipmapLevels=10] The number of mipmap levels to generate for specular maps. More mipmap levels will produce a higher resolution specular reflection.
+ * @property {number} [mipmapLevels=7] The number of mipmap levels to generate for specular maps. More mipmap levels will produce a higher resolution specular reflection.
  * @property {number} [maximumSecondsDifference=3600] The maximum amount of elapsed seconds before a new environment map is created.
  * @property {number} [maximumPositionEpsilon=1000] The maximum difference in position before a new environment map is created, in meters. Small differences in position will not visibly affect results.
  * @property {number} [atmosphereScatteringIntensity=2.0] The intensity of the scattered light emitted from the atmosphere. This should be adjusted relative to the value of {@link Scene.light} intensity.
@@ -76,10 +77,15 @@ function DynamicEnvironmentMapManager(options) {
   this._sphericalHarmonicCoefficientsDirty = false;
 
   this._shouldRegenerateShaders = false;
+  this._shouldReset = false;
 
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
-  const mipmapLevels = defaultValue(options.mipmapLevels, 10);
+  const mipmapLevels = Math.min(
+    defaultValue(options.mipmapLevels, 7),
+    Math.log2(ContextLimits.maximumCubeMapSize),
+  );
+
   this._mipmapLevels = mipmapLevels;
   this._radianceMapComputeCommands = new Array(6);
   this._convolutionComputeCommands = new Array((mipmapLevels - 1) * 6);
@@ -246,7 +252,7 @@ Object.defineProperties(DynamicEnvironmentMapManager.prototype, {
       }
 
       this._position = Cartesian3.clone(value, this._position);
-      this.reset();
+      this._shouldReset = true;
     },
   },
 
@@ -295,6 +301,67 @@ Object.defineProperties(DynamicEnvironmentMapManager.prototype, {
   },
 });
 
+// Internally manage a queue of commands across all instances to prevent too many commands from being added in a single frame and using too much memory at once.
+DynamicEnvironmentMapManager._maximumComputeCommandCount = 8; // This value is updated once a context is created.
+DynamicEnvironmentMapManager._activeComputeCommandCount = 0;
+DynamicEnvironmentMapManager._nextFrameCommandQueue = [];
+/**
+ * Add a command to the queue. If possible, it will be added to the list of commands for the next frame. Otherwise, it will be added to a backlog
+ * and attempted next frame.
+ * @private
+ * @param {ComputeCommand} command The created command
+ * @param {FrameState} frameState The current frame state
+ */
+DynamicEnvironmentMapManager._queueCommand = (command, frameState) => {
+  if (
+    DynamicEnvironmentMapManager._activeComputeCommandCount >=
+    DynamicEnvironmentMapManager._maximumComputeCommandCount
+  ) {
+    // Command will instead be scheduled next frame
+    DynamicEnvironmentMapManager._nextFrameCommandQueue.push(command);
+    return;
+  }
+
+  frameState.commandList.push(command);
+  DynamicEnvironmentMapManager._activeComputeCommandCount++;
+};
+/**
+ * If there are any backlogged commands, queue up as many as possible for the next frame.
+ * @private
+ * @param {FrameState} frameState The current frame state
+ */
+DynamicEnvironmentMapManager._updateCommandQueue = (frameState) => {
+  DynamicEnvironmentMapManager._maximumComputeCommandCount = Math.log2(
+    ContextLimits.maximumCubeMapSize,
+  ); // Scale relative to GPU resources available
+
+  if (
+    DynamicEnvironmentMapManager._nextFrameCommandQueue.length > 0 &&
+    DynamicEnvironmentMapManager._activeComputeCommandCount <
+      DynamicEnvironmentMapManager._maximumComputeCommandCount
+  ) {
+    let command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
+    while (
+      defined(command) &&
+      DynamicEnvironmentMapManager._activeComputeCommandCount <
+        DynamicEnvironmentMapManager._maximumComputeCommandCount
+    ) {
+      if (command.owner.isDestroyed() || command.canceled) {
+        command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
+        continue;
+      }
+
+      frameState.commandList.push(command);
+      DynamicEnvironmentMapManager._activeComputeCommandCount++;
+      command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
+    }
+
+    if (defined(command)) {
+      DynamicEnvironmentMapManager._nextFrameCommandQueue.push(command);
+    }
+  }
+};
+
 /**
  * Sets the owner for the input DynamicEnvironmentMapManager if there wasn't another owner.
  * Destroys the owner's previous DynamicEnvironmentMapManager if setting is successful.
@@ -334,20 +401,29 @@ DynamicEnvironmentMapManager.setOwner = function (
 DynamicEnvironmentMapManager.prototype.reset = function () {
   let length = this._radianceMapComputeCommands.length;
   for (let i = 0; i < length; ++i) {
+    if (defined(this._radianceMapComputeCommands[i])) {
+      this._radianceMapComputeCommands[i].canceled = true;
+    }
     this._radianceMapComputeCommands[i] = undefined;
   }
 
   length = this._convolutionComputeCommands.length;
   for (let i = 0; i < length; ++i) {
+    if (defined(this._convolutionComputeCommands[i])) {
+      this._convolutionComputeCommands[i].canceled = true;
+    }
     this._convolutionComputeCommands[i] = undefined;
   }
 
   if (defined(this._irradianceComputeCommand)) {
+    this._irradianceComputeCommand.canceled = true;
     this._irradianceComputeCommand = undefined;
   }
 
   this._radianceMapDirty = true;
   this._radianceCommandsDirty = true;
+  this._convolutionsCommandsDirty = false;
+  this._irradianceCommandDirty = false;
 };
 
 const scratchPackedAtmosphere = new Cartesian3();
@@ -467,7 +543,8 @@ function updateRadianceMap(manager, frameState) {
     let i = 0;
     for (const face of CubeMap.faceNames()) {
       let texture = manager._radianceMapTextures[i];
-      if (defined(texture)) {
+      // Destroy any existing textures that have no yet been cleaned up
+      if (defined(texture) && !texture.isDestroyed()) {
         texture.destroy();
       }
 
@@ -498,36 +575,38 @@ function updateRadianceMap(manager, frameState) {
             );
           },
         },
-        persists: true,
         owner: manager,
-        postExecute: () => {
-          const commands = manager._radianceMapComputeCommands;
-          if (!defined(commands[index])) {
-            // This command was cancelled
-            return;
-          }
-          commands[index] = undefined;
-
-          const framebuffer = new Framebuffer({
-            context: context,
-            colorTextures: [manager._radianceMapTextures[index]],
-            destroyAttachments: false,
-          });
-
-          // Copy the output texture into the corresponding cubemap face
-          framebuffer._bind();
-          manager._radianceCubeMap[face].copyFromFramebuffer();
-          framebuffer._unBind();
-          framebuffer.destroy();
-
-          if (!commands.some(defined)) {
-            manager._convolutionsCommandsDirty = true;
-            manager._shouldRegenerateShaders = true;
-          }
-        },
       });
-      frameState.commandList.push(command);
+      command.postExecute = () => {
+        if (manager.isDestroyed() || command.canceled) {
+          DynamicEnvironmentMapManager._activeComputeCommandCount--;
+          return;
+        }
+
+        const commands = manager._radianceMapComputeCommands;
+        commands[index] = undefined;
+
+        const framebuffer = new Framebuffer({
+          context: context,
+          colorTextures: [manager._radianceMapTextures[index]],
+        });
+
+        // Copy the output texture into the corresponding cubemap face
+        framebuffer._bind();
+        manager._radianceCubeMap[face].copyFromFramebuffer();
+        framebuffer._unBind();
+        framebuffer.destroy();
+
+        DynamicEnvironmentMapManager._activeComputeCommandCount--;
+
+        if (!commands.some(defined)) {
+          manager._convolutionsCommandsDirty = true;
+          manager._shouldRegenerateShaders = true;
+        }
+      };
+
       manager._radianceMapComputeCommands[i] = command;
+      DynamicEnvironmentMapManager._queueCommand(command, frameState);
       i++;
     }
     manager._radianceCommandsDirty = false;
@@ -551,31 +630,48 @@ function updateSpecularMaps(manager, frameState) {
   const context = frameState.context;
 
   let facesCopied = 0;
-  const getPostExecute = (index, texture, face, level) => () => {
-    // Copy output texture to corresponding face and mipmap level
-    const commands = manager._convolutionComputeCommands;
-    if (!defined(commands[index])) {
-      // This command was cancelled
+  const getPostExecute = (command, index, texture, face, level) => () => {
+    if (manager.isDestroyed() || command.canceled) {
+      DynamicEnvironmentMapManager._activeComputeCommandCount--;
       return;
     }
+
+    // Copy output texture to corresponding face and mipmap level
+    const commands = manager._convolutionComputeCommands;
     commands[index] = undefined;
 
     radianceCubeMap.copyFace(frameState, texture, face, level);
     facesCopied++;
+    DynamicEnvironmentMapManager._activeComputeCommandCount--;
+
+    texture.destroy();
+    manager._specularMapTextures[index] = undefined;
 
-    // All faces and levels have been copied
-    if (facesCopied === manager._specularMapTextures.length) {
+    // All faces for each mipmap level have been copied
+    const length = manager._specularMapTextures.length;
+    if (facesCopied >= length) {
       manager._irradianceCommandDirty = true;
       radianceCubeMap.sampler = new Sampler({
         minificationFilter: TextureMinificationFilter.LINEAR_MIPMAP_LINEAR,
       });
+
       manager._shouldRegenerateShaders = true;
+
+      // Cleanup shared resources
+      manager._va.destroy();
+      manager._va = undefined;
+      manager._convolveSP.destroy();
+      manager._convolveSP = undefined;
     }
   };
 
   let index = 0;
   for (let level = 1; level < mipmapLevels; ++level) {
     for (const face of CubeMap.faceNames()) {
+      if (defined(manager._specularMapTextures[index])) {
+        manager._specularMapTextures[index].destroy();
+      }
+
       const texture = (manager._specularMapTextures[index] = new Texture({
         context: context,
         width: width,
@@ -607,19 +703,27 @@ function updateSpecularMaps(manager, frameState) {
         shaderProgram: shaderProgram,
         vertexArray: vertexArray,
         outputTexture: texture,
+        // Persist so we can use a shared shader progam and vertex array across all commands
+        // Shared resources are instead destroyed in postExecute
         persists: true,
         owner: manager,
         uniformMap: {
           u_roughness: () => level / (mipmapLevels - 1),
-          u_radianceTexture: () => radianceCubeMap,
+          u_radianceTexture: () => radianceCubeMap ?? context.defaultTexture,
           u_faceDirection: () => {
             return CubeMap.getDirection(face, scratchCartesian);
           },
         },
-        postExecute: getPostExecute(index, texture, face, level),
       });
+      command.postExecute = getPostExecute(
+        command,
+        index,
+        texture,
+        face,
+        level,
+      );
       manager._convolutionComputeCommands[index] = command;
-      frameState.commandList.push(command);
+      DynamicEnvironmentMapManager._queueCommand(command, frameState);
       ++index;
     }
 
@@ -641,17 +745,19 @@ function updateIrradianceResources(manager, frameState) {
   const dimensions = irradianceTextureDimensions;
 
   let texture = manager._irradianceMapTexture;
-  if (!defined(texture)) {
-    texture = new Texture({
-      context: context,
-      width: dimensions.x,
-      height: dimensions.y,
-      pixelDatatype: PixelDatatype.FLOAT,
-      pixelFormat: PixelFormat.RGBA,
-    });
-    manager._irradianceMapTexture = texture;
+  if (defined(texture) && !texture.isDestroyed()) {
+    texture.destroy();
   }
 
+  texture = new Texture({
+    context: context,
+    width: dimensions.x,
+    height: dimensions.y,
+    pixelDatatype: PixelDatatype.FLOAT,
+    pixelFormat: PixelFormat.RGBA,
+  });
+  manager._irradianceMapTexture = texture;
+
   let fs = manager._irradianceMapFS;
   if (!defined(fs)) {
     fs = new ShaderSource({
@@ -663,21 +769,27 @@ function updateIrradianceResources(manager, frameState) {
   const command = new ComputeCommand({
     fragmentShaderSource: fs,
     outputTexture: texture,
+    owner: manager,
     uniformMap: {
-      u_radianceMap: () => manager._radianceCubeMap,
-    },
-    postExecute: () => {
-      if (!defined(manager._irradianceComputeCommand)) {
-        // This command was cancelled
-        return;
-      }
-      manager._irradianceTextureDirty = false;
-      manager._irradianceComputeCommand = undefined;
-      manager._sphericalHarmonicCoefficientsDirty = true;
+      u_radianceMap: () => manager._radianceCubeMap ?? context.defaultTexture,
     },
   });
+
+  command.postExecute = () => {
+    if (manager.isDestroyed() || command.canceled) {
+      DynamicEnvironmentMapManager._activeComputeCommandCount--;
+      return;
+    }
+    manager._irradianceTextureDirty = false;
+    manager._irradianceComputeCommand = undefined;
+    manager._sphericalHarmonicCoefficientsDirty = true;
+    manager._irradianceMapFS = undefined;
+
+    DynamicEnvironmentMapManager._activeComputeCommandCount--;
+  };
+
   manager._irradianceComputeCommand = command;
-  frameState.commandList.push(command);
+  DynamicEnvironmentMapManager._queueCommand(command, frameState);
   manager._irradianceTextureDirty = true;
 }
 
@@ -690,6 +802,11 @@ function updateIrradianceResources(manager, frameState) {
 function updateSphericalHarmonicCoefficients(manager, frameState) {
   const context = frameState.context;
 
+  if (!defined(manager._irradianceMapTexture)) {
+    // Operation was canceled
+    return;
+  }
+
   const framebuffer = new Framebuffer({
     context: context,
     colorTextures: [manager._irradianceMapTexture],
@@ -715,6 +832,8 @@ function updateSphericalHarmonicCoefficients(manager, frameState) {
   }
 
   framebuffer.destroy();
+  manager._irradianceMapTexture.destroy();
+  manager._irradianceMapTexture = undefined;
   manager._shouldRegenerateShaders = true;
 }
 
@@ -744,6 +863,8 @@ DynamicEnvironmentMapManager.prototype.update = function (frameState) {
     return;
   }
 
+  DynamicEnvironmentMapManager._updateCommandQueue(frameState);
+
   const dynamicLighting = frameState.atmosphere.dynamicLighting;
   const regenerateEnvironmentMap =
     atmosphereNeedsUpdate(this, frameState) ||
@@ -754,9 +875,11 @@ DynamicEnvironmentMapManager.prototype.update = function (frameState) {
         this.maximumSecondsDifference,
       ));
 
-  if (regenerateEnvironmentMap) {
+  if (this._shouldReset || regenerateEnvironmentMap) {
     this.reset();
+    this._shouldReset = false;
     this._lastTime = JulianDate.clone(frameState.time, this._lastTime);
+    return;
   }
 
   if (this._radianceMapDirty) {
@@ -830,19 +953,33 @@ DynamicEnvironmentMapManager.prototype.destroy = function () {
   length = this._radianceMapTextures.length;
   for (let i = 0; i < length; ++i) {
     this._radianceMapTextures[i] =
-      this._radianceMapTextures[i] && this._radianceMapTextures[i].destroy();
+      this._radianceMapTextures[i] &&
+      !this._radianceMapTextures[i].isDestroyed() &&
+      this._radianceMapTextures[i].destroy();
   }
 
   length = this._specularMapTextures.length;
   for (let i = 0; i < length; ++i) {
     this._specularMapTextures[i] =
-      this._specularMapTextures[i] && this._specularMapTextures[i].destroy();
+      this._specularMapTextures[i] &&
+      !this._specularMapTextures[i].isDestroyed() &&
+      this._specularMapTextures[i].destroy();
   }
 
   this._radianceCubeMap =
     this._radianceCubeMap && this._radianceCubeMap.destroy();
   this._irradianceMapTexture =
-    this._irradianceMapTexture && this._irradianceMapTexture.destroy();
+    this._irradianceMapTexture &&
+    !this._irradianceMapTexture.isDestroyed() &&
+    this._irradianceMapTexture.destroy();
+
+  if (defined(this._va)) {
+    this._va.destroy();
+  }
+
+  if (defined(this._convolveSP)) {
+    this._convolveSP.destroy();
+  }
 
   return destroyObject(this);
 };

package/Source/Scene/GltfTextureLoader.js

@@ -170,6 +170,7 @@ GltfTextureLoader.prototype.load = async function () {
 function CreateTextureJob() {
   this.gltf = undefined;
   this.textureInfo = undefined;
+  this.textureId = undefined;
   this.image = undefined;
   this.context = undefined;
   this.texture = undefined;
@@ -178,12 +179,14 @@ function CreateTextureJob() {
 CreateTextureJob.prototype.set = function (
   gltf,
   textureInfo,
+  textureId,
   image,
   mipLevels,
   context,
 ) {
   this.gltf = gltf;
   this.textureInfo = textureInfo;
+  this.textureId = textureId;
   this.image = image;
   this.mipLevels = mipLevels;
   this.context = context;
@@ -193,13 +196,21 @@ CreateTextureJob.prototype.execute = function () {
   this.texture = createTexture(
     this.gltf,
     this.textureInfo,
+    this.textureId,
     this.image,
     this.mipLevels,
     this.context,
   );
 };
 
-function createTexture(gltf, textureInfo, image, mipLevels, context) {
+function createTexture(
+  gltf,
+  textureInfo,
+  textureId,
+  image,
+  mipLevels,
+  context,
+) {
   // internalFormat is only defined for CompressedTextureBuffer
   const internalFormat = image.internalFormat;
 
@@ -261,6 +272,7 @@ function createTexture(gltf, textureInfo, image, mipLevels, context) {
     }
 
     texture = Texture.create({
+      id: textureId,
       context: context,
       source: {
         arrayBufferView: image.bufferView, // Only defined for CompressedTextureBuffer
@@ -276,6 +288,7 @@ function createTexture(gltf, textureInfo, image, mipLevels, context) {
       image = resizeImageToNextPowerOfTwo(image);
     }
     texture = Texture.create({
+      id: textureId,
       context: context,
       source: image,
       sampler: sampler,
@@ -332,6 +345,7 @@ GltfTextureLoader.prototype.process = function (frameState) {
     textureJob.set(
       this._gltf,
       this._textureInfo,
+      this._cacheKey,
       this._image,
       this._mipLevels,
       frameState.context,
@@ -346,6 +360,7 @@ GltfTextureLoader.prototype.process = function (frameState) {
     texture = createTexture(
       this._gltf,
       this._textureInfo,
+      this._cacheKey,
       this._image,
       this._mipLevels,
       frameState.context,