@cesium/engine 13.0.0 → 14.0.0

package/Source/Scene/DynamicEnvironmentMapManager.js

@@ -33,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.
@@ -77,11 +77,12 @@ function DynamicEnvironmentMapManager(options) {
   this._sphericalHarmonicCoefficientsDirty = false;
 
   this._shouldRegenerateShaders = false;
+  this._shouldReset = false;
 
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
   const mipmapLevels = Math.min(
-    defaultValue(options.mipmapLevels, 10),
+    defaultValue(options.mipmapLevels, 7),
     Math.log2(ContextLimits.maximumCubeMapSize),
   );
 
@@ -251,7 +252,7 @@ Object.defineProperties(DynamicEnvironmentMapManager.prototype, {
       }
 
       this._position = Cartesian3.clone(value, this._position);
-      this.reset();
+      this._shouldReset = true;
     },
   },
 
@@ -345,7 +346,7 @@ DynamicEnvironmentMapManager._updateCommandQueue = (frameState) => {
       DynamicEnvironmentMapManager._activeComputeCommandCount <
         DynamicEnvironmentMapManager._maximumComputeCommandCount
     ) {
-      if (command.canceled) {
+      if (command.owner.isDestroyed() || command.canceled) {
         command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
         continue;
       }
@@ -354,6 +355,10 @@ DynamicEnvironmentMapManager._updateCommandQueue = (frameState) => {
       DynamicEnvironmentMapManager._activeComputeCommandCount++;
       command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
     }
+
+    if (defined(command)) {
+      DynamicEnvironmentMapManager._nextFrameCommandQueue.push(command);
+    }
   }
 };
 
@@ -398,7 +403,6 @@ DynamicEnvironmentMapManager.prototype.reset = function () {
   for (let i = 0; i < length; ++i) {
     if (defined(this._radianceMapComputeCommands[i])) {
       this._radianceMapComputeCommands[i].canceled = true;
-      DynamicEnvironmentMapManager._activeComputeCommandCount--;
     }
     this._radianceMapComputeCommands[i] = undefined;
   }
@@ -407,19 +411,19 @@ DynamicEnvironmentMapManager.prototype.reset = function () {
   for (let i = 0; i < length; ++i) {
     if (defined(this._convolutionComputeCommands[i])) {
       this._convolutionComputeCommands[i].canceled = true;
-      DynamicEnvironmentMapManager._activeComputeCommandCount--;
     }
     this._convolutionComputeCommands[i] = undefined;
   }
 
   if (defined(this._irradianceComputeCommand)) {
     this._irradianceComputeCommand.canceled = true;
-    DynamicEnvironmentMapManager._activeComputeCommandCount--;
     this._irradianceComputeCommand = undefined;
   }
 
   this._radianceMapDirty = true;
   this._radianceCommandsDirty = true;
+  this._convolutionsCommandsDirty = false;
+  this._irradianceCommandDirty = false;
 };
 
 const scratchPackedAtmosphere = new Cartesian3();
@@ -539,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();
       }
 
@@ -570,36 +575,35 @@ 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();
-
+      });
+      command.postExecute = () => {
+        if (manager.isDestroyed() || command.canceled) {
           DynamicEnvironmentMapManager._activeComputeCommandCount--;
+          return;
+        }
 
-          if (!commands.some(defined)) {
-            manager._convolutionsCommandsDirty = true;
-            manager._shouldRegenerateShaders = true;
-          }
-        },
-      });
+        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);
@@ -626,32 +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]) || commands[index].canceled) {
-      // 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--;
 
-    // All faces and levels have been copied
-    if (facesCopied === manager._specularMapTextures.length) {
+    texture.destroy();
+    manager._specularMapTextures[index] = undefined;
+
+    // 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,
@@ -683,6 +703,8 @@ 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: {
@@ -692,8 +714,14 @@ function updateSpecularMaps(manager, frameState) {
             return CubeMap.getDirection(face, scratchCartesian);
           },
         },
-        postExecute: getPostExecute(index, texture, face, level),
       });
+      command.postExecute = getPostExecute(
+        command,
+        index,
+        texture,
+        face,
+        level,
+      );
       manager._convolutionComputeCommands[index] = command;
       DynamicEnvironmentMapManager._queueCommand(command, frameState);
       ++index;
@@ -717,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({
@@ -739,21 +769,25 @@ function updateIrradianceResources(manager, frameState) {
   const command = new ComputeCommand({
     fragmentShaderSource: fs,
     outputTexture: texture,
+    owner: manager,
     uniformMap: {
       u_radianceMap: () => manager._radianceCubeMap ?? context.defaultTexture,
     },
-    postExecute: () => {
-      if (!defined(manager._irradianceComputeCommand)) {
-        // This command was cancelled
-        return;
-      }
-      manager._irradianceTextureDirty = false;
-      manager._irradianceComputeCommand = undefined;
-      manager._sphericalHarmonicCoefficientsDirty = true;
+  });
 
+  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;
   DynamicEnvironmentMapManager._queueCommand(command, frameState);
   manager._irradianceTextureDirty = true;
@@ -768,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],
@@ -793,6 +832,8 @@ function updateSphericalHarmonicCoefficients(manager, frameState) {
   }
 
   framebuffer.destroy();
+  manager._irradianceMapTexture.destroy();
+  manager._irradianceMapTexture = undefined;
   manager._shouldRegenerateShaders = true;
 }
 
@@ -834,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) {
@@ -910,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/GltfDracoLoader.js

@@ -1,9 +1,11 @@
 import Check from "../Core/Check.js";
+import ComponentDatatype from "../Core/ComponentDatatype.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
 import DracoLoader from "./DracoLoader.js";
 import ResourceLoader from "./ResourceLoader.js";
 import ResourceLoaderState from "./ResourceLoaderState.js";
+import VertexAttributeSemantic from "./VertexAttributeSemantic.js";
 
 /**
  * Load a draco buffer from a glTF.
@@ -18,6 +20,7 @@ import ResourceLoaderState from "./ResourceLoaderState.js";
  * @param {object} options Object with the following properties:
  * @param {ResourceCache} options.resourceCache The {@link ResourceCache} (to avoid circular dependencies).
  * @param {object} options.gltf The glTF JSON.
+ * @param {object} options.primitive The primitive containing the Draco extension.
  * @param {object} options.draco The Draco extension object.
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
@@ -29,6 +32,7 @@ function GltfDracoLoader(options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);
   const resourceCache = options.resourceCache;
   const gltf = options.gltf;
+  const primitive = options.primitive;
   const draco = options.draco;
   const gltfResource = options.gltfResource;
   const baseResource = options.baseResource;
@@ -37,6 +41,7 @@ function GltfDracoLoader(options) {
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.func("options.resourceCache", resourceCache);
   Check.typeOf.object("options.gltf", gltf);
+  Check.typeOf.object("options.primitive", primitive);
   Check.typeOf.object("options.draco", draco);
   Check.typeOf.object("options.gltfResource", gltfResource);
   Check.typeOf.object("options.baseResource", baseResource);
@@ -46,6 +51,7 @@ function GltfDracoLoader(options) {
   this._gltfResource = gltfResource;
   this._baseResource = baseResource;
   this._gltf = gltf;
+  this._primitive = primitive;
   this._draco = draco;
   this._cacheKey = cacheKey;
   this._bufferViewLoader = undefined;
@@ -169,6 +175,24 @@ async function processDecode(loader, decodePromise) {
   }
 }
 
+const SemanticToDracoAttributeType = {};
+SemanticToDracoAttributeType[VertexAttributeSemantic.POSITION] = "POSITION";
+SemanticToDracoAttributeType[VertexAttributeSemantic.NORMAL] = "NORMAL";
+SemanticToDracoAttributeType[VertexAttributeSemantic.COLOR] = "COLOR";
+SemanticToDracoAttributeType[VertexAttributeSemantic.TEXCOORD] = "TEX_COORD";
+
+function getDracoAttributeType(attribute) {
+  for (const semantic in SemanticToDracoAttributeType) {
+    if (SemanticToDracoAttributeType.hasOwnProperty(semantic)) {
+      if (attribute.startsWith(semantic)) {
+        return SemanticToDracoAttributeType[semantic];
+      }
+    }
+  }
+
+  return undefined;
+}
+
 /**
  * Processes the resource until it becomes ready.
  *
@@ -203,12 +227,31 @@ GltfDracoLoader.prototype.process = function (frameState) {
   }
 
   const draco = this._draco;
+  const primitive = this._primitive;
   const gltf = this._gltf;
   const bufferViews = gltf.bufferViews;
   const bufferViewId = draco.bufferView;
   const bufferView = bufferViews[bufferViewId];
   const compressedAttributes = draco.attributes;
 
+  // Skip de-quantization transform if present for floating point attributes.
+  // They will stay quantized in memory and be dequantized in the shader.
+  const attributesToSkipTransform = [];
+
+  for (const attribute in primitive.attributes) {
+    if (primitive.attributes.hasOwnProperty(attribute)) {
+      const dracoAttributeType = getDracoAttributeType(attribute);
+      if (defined(dracoAttributeType)) {
+        const accessor = gltf.accessors[primitive.attributes[attribute]];
+        if (accessor.componentType === ComponentDatatype.FLOAT) {
+          if (!attributesToSkipTransform.includes(dracoAttributeType)) {
+            attributesToSkipTransform.push(dracoAttributeType);
+          }
+        }
+      }
+    }
+  }
+
   const decodeOptions = {
     // Need to make a copy of the typed array otherwise the underlying
     // ArrayBuffer may be accessed on both the worker and the main thread. This
@@ -218,6 +261,7 @@ GltfDracoLoader.prototype.process = function (frameState) {
     bufferView: bufferView,
     compressedAttributes: compressedAttributes,
     dequantizeInShader: true,
+    attributesToSkipTransform: attributesToSkipTransform,
   };
 
   const decodePromise = DracoLoader.decodeBufferView(decodeOptions);
@@ -243,6 +287,7 @@ GltfDracoLoader.prototype.unload = function () {
   this._bufferViewTypedArray = undefined;
   this._decodedData = undefined;
   this._gltf = undefined;
+  this._primitive = undefined;
 };
 
 export default GltfDracoLoader;

package/Source/Scene/GltfIndexBufferLoader.js

@@ -27,6 +27,7 @@ import ResourceLoaderState from "./ResourceLoaderState.js";
  * @param {number} options.accessorId The accessor ID corresponding to the index buffer.
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
+ * @param {object} [options.primitive] The primitive containing the Draco extension.
  * @param {object} [options.draco] The Draco extension object.
  * @param {string} [options.cacheKey] The cache key of the resource.
  * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
@@ -41,6 +42,7 @@ function GltfIndexBufferLoader(options) {
   const accessorId = options.accessorId;
   const gltfResource = options.gltfResource;
   const baseResource = options.baseResource;
+  const primitive = options.primitive;
   const draco = options.draco;
   const cacheKey = options.cacheKey;
   const asynchronous = defaultValue(options.asynchronous, true);
@@ -68,6 +70,7 @@ function GltfIndexBufferLoader(options) {
   this._gltf = gltf;
   this._accessorId = accessorId;
   this._indexDatatype = indexDatatype;
+  this._primitive = primitive;
   this._draco = draco;
   this._cacheKey = cacheKey;
   this._asynchronous = asynchronous;
@@ -174,6 +177,7 @@ async function loadFromDraco(indexBufferLoader) {
   try {
     const dracoLoader = resourceCache.getDracoLoader({
       gltf: indexBufferLoader._gltf,
+      primitive: indexBufferLoader._primitive,
       draco: indexBufferLoader._draco,
       gltfResource: indexBufferLoader._gltfResource,
       baseResource: indexBufferLoader._baseResource,
@@ -411,6 +415,7 @@ GltfIndexBufferLoader.prototype.unload = function () {
   this._typedArray = undefined;
   this._buffer = undefined;
   this._gltf = undefined;
+  this._primitive = undefined;
 };
 
 export default GltfIndexBufferLoader;

package/Source/Scene/GltfLoader.js

@@ -685,6 +685,7 @@ function getVertexBufferLoader(
   loader,
   accessorId,
   semantic,
+  primitive,
   draco,
   loadBuffer,
   loadTypedArray,
@@ -700,6 +701,7 @@ function getVertexBufferLoader(
     baseResource: loader._baseResource,
     frameState: frameState,
     bufferViewId: bufferViewId,
+    primitive: primitive,
     draco: draco,
     attributeSemantic: semantic,
     accessorId: accessorId,
@@ -714,6 +716,7 @@ function getVertexBufferLoader(
 function getIndexBufferLoader(
   loader,
   accessorId,
+  primitive,
   draco,
   loadBuffer,
   loadTypedArray,
@@ -725,6 +728,7 @@ function getIndexBufferLoader(
     gltfResource: loader._gltfResource,
     baseResource: loader._baseResource,
     frameState: frameState,
+    primitive: primitive,
     draco: draco,
     asynchronous: loader._asynchronous,
     loadBuffer: loadBuffer,
@@ -1154,6 +1158,7 @@ function loadAttribute(
   loader,
   accessorId,
   semanticInfo,
+  primitive,
   draco,
   loadBuffer,
   loadTypedArray,
@@ -1188,6 +1193,7 @@ function loadAttribute(
     loader,
     accessorId,
     gltfSemantic,
+    primitive,
     draco,
     loadBuffer,
     loadTypedArray,
@@ -1232,6 +1238,7 @@ function loadVertexAttribute(
   loader,
   accessorId,
   semanticInfo,
+  primitive,
   draco,
   hasInstances,
   needsPostProcessing,
@@ -1278,6 +1285,7 @@ function loadVertexAttribute(
     loader,
     accessorId,
     semanticInfo,
+    primitive,
     draco,
     loadBuffer,
     loadTypedArray,
@@ -1345,12 +1353,13 @@ function loadInstancedAttribute(
 
   const loadTypedArray = loadAsTypedArrayOnly || loadTranslationAsTypedArray;
 
-  // Don't pass in draco object since instanced attributes can't be draco compressed
+  // Don't pass in primitive or draco object since instanced attributes can't be draco compressed
   return loadAttribute(
     loader,
     accessorId,
     semanticInfo,
     undefined,
+    undefined,
     loadBuffer,
     loadTypedArray,
     frameState,
@@ -1360,6 +1369,7 @@ function loadInstancedAttribute(
 function loadIndices(
   loader,
   accessorId,
+  primitive,
   draco,
   hasFeatureIds,
   needsPostProcessing,
@@ -1403,6 +1413,7 @@ function loadIndices(
   const indexBufferLoader = getIndexBufferLoader(
     loader,
     accessorId,
+    primitive,
     draco,
     loadBuffer,
     loadTypedArray,
@@ -1865,7 +1876,8 @@ function loadMorphTarget(
 ) {
   const morphTarget = new MorphTarget();
 
-  // Don't pass in draco object since morph targets can't be draco compressed
+  // Don't pass in primitive or draco object since morph targets can't be draco compressed
+  const primitive = undefined;
   const draco = undefined;
   const hasInstances = false;
 
@@ -1885,6 +1897,7 @@ function loadMorphTarget(
       loader,
       accessorId,
       semanticInfo,
+      primitive,
       draco,
       hasInstances,
       needsPostProcessing,
@@ -1970,6 +1983,7 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
         loader,
         accessorId,
         semanticInfo,
+        gltfPrimitive,
         draco,
         hasInstances,
         needsPostProcessing,
@@ -2002,6 +2016,7 @@ function loadPrimitive(loader, gltfPrimitive, hasInstances, frameState) {
     const indicesPlan = loadIndices(
       loader,
       indices,
+      gltfPrimitive,
       draco,
       hasFeatureIds,
       needsPostProcessing,