@cesium/engine 1.0.0 → 2.0.0

package/Source/Scene/Cesium3DTileset.js

@@ -167,6 +167,7 @@ function Cesium3DTileset(options) {
   this._asset = undefined; // Metadata for the entire tileset
   this._properties = undefined; // Metadata for per-model/point/etc properties
   this._geometricError = undefined; // Geometric error when the tree is not rendered at all
+  this._scaledGeometricError = undefined; // Geometric error scaled by root tile scale
   this._extensionsUsed = undefined;
   this._extensions = undefined;
   this._modelUpAxis = undefined;
@@ -1007,6 +1008,11 @@ function Cesium3DTileset(options) {
         return;
       }
 
+      // Set these before loading the tileset since _geometricError
+      // and _scaledGeometricError get accessed during tile creation
+      that._geometricError = tilesetJson.geometricError;
+      that._scaledGeometricError = tilesetJson.geometricError;
+
       that._root = that.loadTileset(resource, tilesetJson);
 
       // Handle legacy gltfUpAxis option
@@ -1019,7 +1025,6 @@ function Cesium3DTileset(options) {
       const asset = tilesetJson.asset;
       that._asset = asset;
       that._properties = tilesetJson.properties;
-      that._geometricError = tilesetJson.geometricError;
       that._extensionsUsed = tilesetJson.extensionsUsed;
       that._extensions = tilesetJson.extensions;
       that._modelUpAxis = modelUpAxis;

package/Source/Scene/Cesium3DTilesetMetadata.js

@@ -168,7 +168,7 @@ Object.defineProperties(Cesium3DTilesetMetadata.prototype, {
   },
 
   /**
-   * Extras in the JSON object.
+   * Extra user-defined properties.
    *
    * @memberof Cesium3DTilesetMetadata.prototype
    * @type {*}
@@ -182,7 +182,7 @@ Object.defineProperties(Cesium3DTilesetMetadata.prototype, {
   },
 
   /**
-   * Extensions in the JSON object.
+   * An object containing extensions.
    *
    * @memberof Cesium3DTilesetMetadata.prototype
    * @type {Object}

package/Source/Scene/ClassificationPrimitive.js

@@ -493,22 +493,17 @@ function modifyForEncodedNormals(primitive, vertexShaderSource) {
     return vertexShaderSource;
   }
 
-  if (
-    vertexShaderSource.search(/attribute\s+vec3\s+extrudeDirection;/g) !== -1
-  ) {
+  if (vertexShaderSource.search(/in\s+vec3\s+extrudeDirection;/g) !== -1) {
     const attributeName = "compressedAttributes";
 
     //only shadow volumes use extrudeDirection, and shadow volumes use vertexFormat: POSITION_ONLY so we don't need to check other attributes
-    const attributeDecl = `attribute vec2 ${attributeName};`;
+    const attributeDecl = `in vec2 ${attributeName};`;
 
     const globalDecl = "vec3 extrudeDirection;\n";
     const decode = `    extrudeDirection = czm_octDecode(${attributeName}, 65535.0);\n`;
 
     let modifiedVS = vertexShaderSource;
-    modifiedVS = modifiedVS.replace(
-      /attribute\s+vec3\s+extrudeDirection;/g,
-      ""
-    );
+    modifiedVS = modifiedVS.replace(/in\s+vec3\s+extrudeDirection;/g, "");
     modifiedVS = ShaderSource.replaceMain(
       modifiedVS,
       "czm_non_compressed_main"

package/Source/Scene/ContentMetadata.js

@@ -50,7 +50,7 @@ Object.defineProperties(ContentMetadata.prototype, {
   },
 
   /**
-   * Extras in the JSON object.
+   * Extra user-defined properties.
    *
    * @memberof ContentMetadata.prototype
    * @type {Object}
@@ -64,7 +64,7 @@ Object.defineProperties(ContentMetadata.prototype, {
   },
 
   /**
-   * Extensions in the JSON object.
+   * An object containing extensions.
    *
    * @memberof ContentMetadata.prototype
    * @type {Object}

package/Source/Scene/DebugAppearance.js

@@ -88,14 +88,12 @@ function DebugAppearance(options) {
 
   const vs =
     `${
-      "attribute vec3 position3DHigh;\n" +
-      "attribute vec3 position3DLow;\n" +
-      "attribute float batchId;\n"
+      "in vec3 position3DHigh;\n" +
+      "in vec3 position3DLow;\n" +
+      "in float batchId;\n"
     }${
-      perInstanceAttribute
-        ? ""
-        : `attribute ${glslDatatype} ${attributeName};\n`
-    }varying ${glslDatatype} ${varyingName};\n` +
+      perInstanceAttribute ? "" : `in ${glslDatatype} ${attributeName};\n`
+    }out ${glslDatatype} ${varyingName};\n` +
     `void main()\n` +
     `{\n` +
     `vec4 p = czm_translateRelativeToEye(position3DHigh, position3DLow);\n${
@@ -105,10 +103,10 @@ function DebugAppearance(options) {
     }gl_Position = czm_modelViewProjectionRelativeToEye * p;\n` +
     `}`;
   const fs =
-    `varying ${glslDatatype} ${varyingName};\n${getColor}\n` +
+    `in ${glslDatatype} ${varyingName};\n${getColor}\n` +
     `void main()\n` +
     `{\n` +
-    `gl_FragColor = getColor();\n` +
+    `out_FragColor = getColor();\n` +
     `}`;
 
   /**

package/Source/Scene/DebugInspector.js

@@ -31,7 +31,7 @@ function createDebugShowFrustumsShaderProgram(scene, shaderProgram) {
   const targets = [];
   fs.sources = fs.sources.map(function (source) {
     source = ShaderSource.replaceMain(source, "czm_Debug_main");
-    const re = /gl_FragData\[(\d+)\]/g;
+    const re = /out_FragData_(\d+)/g;
     let match;
     while ((match = re.exec(source)) !== null) {
       if (targets.indexOf(match[1]) === -1) {
@@ -52,12 +52,12 @@ function createDebugShowFrustumsShaderProgram(scene, shaderProgram) {
   let i;
   if (length > 0) {
     for (i = 0; i < length; ++i) {
-      newMain += `    gl_FragData[${targets[i]}].rgb *= debugShowCommandsColor;\n`;
-      newMain += `    gl_FragData[${targets[i]}].rgb *= debugShowFrustumsColor;\n`;
+      newMain += `    out_FragData_${targets[i]}.rgb *= debugShowCommandsColor;\n`;
+      newMain += `    out_FragData_${targets[i]}.rgb *= debugShowFrustumsColor;\n`;
     }
   } else {
-    newMain += "    gl_FragColor.rgb *= debugShowCommandsColor;\n";
-    newMain += "    gl_FragColor.rgb *= debugShowFrustumsColor;\n";
+    newMain += "    out_FragColor.rgb *= debugShowCommandsColor;\n";
+    newMain += "    out_FragColor.rgb *= debugShowFrustumsColor;\n";
   }
   newMain += "}";
 

package/Source/Scene/DepthPlane.js

@@ -173,12 +173,6 @@ DepthPlane.prototype.update = function (frameState) {
       sources: [DepthPlaneFS],
     });
     if (useLogDepth) {
-      const extension =
-        "#ifdef GL_EXT_frag_depth \n" +
-        "#extension GL_EXT_frag_depth : enable \n" +
-        "#endif \n\n";
-
-      fs.sources.push(extension);
       fs.defines.push("LOG_DEPTH");
       vs.defines.push("LOG_DEPTH");
     }

package/Source/Scene/DerivedCommand.js

@@ -8,7 +8,7 @@ import ShaderSource from "../Renderer/ShaderSource.js";
  */
 function DerivedCommand() {}
 
-const fragDepthRegex = /\bgl_FragDepthEXT\b/;
+const fragDepthRegex = /\bgl_FragDepth\b/;
 const discardRegex = /\bdiscard\b/;
 
 function getDepthOnlyShaderProgram(context, shaderProgram) {
@@ -44,18 +44,18 @@ function getDepthOnlyShaderProgram(context, shaderProgram) {
     let source;
     if (!writesDepthOrDiscards && !usesLogDepth) {
       source =
-        "void main() \n" + "{ \n" + "    gl_FragColor = vec4(1.0); \n" + "} \n";
+        "void main() \n" +
+        "{ \n" +
+        "    out_FragColor = vec4(1.0); \n" +
+        "} \n";
       fs = new ShaderSource({
         sources: [source],
       });
     } else if (!writesDepthOrDiscards && usesLogDepth) {
       source =
-        "#ifdef GL_EXT_frag_depth \n" +
-        "#extension GL_EXT_frag_depth : enable \n" +
-        "#endif \n\n" +
         "void main() \n" +
         "{ \n" +
-        "    gl_FragColor = vec4(1.0); \n" +
+        "    out_FragColor = vec4(1.0); \n" +
         "    czm_writeLogDepth(); \n" +
         "} \n";
       fs = new ShaderSource({
@@ -145,9 +145,15 @@ DerivedCommand.createDepthOnlyDerivedCommand = function (
 
 const writeLogDepthRegex = /\s+czm_writeLogDepth\(/;
 const vertexlogDepthRegex = /\s+czm_vertexLogDepth\(/;
-const extensionRegex = /\s*#extension\s+GL_EXT_frag_depth\s*:\s*enable/;
 
 function getLogDepthShaderProgram(context, shaderProgram) {
+  const disableLogDepthWrite =
+    shaderProgram.fragmentShaderSource.defines.indexOf("LOG_DEPTH_READ_ONLY") >=
+    0;
+  if (disableLogDepthWrite) {
+    return shaderProgram;
+  }
+
   let shader = context.shaderCache.getDerivedShaderProgram(
     shaderProgram,
     "logDepth"
@@ -203,20 +209,7 @@ function getLogDepthShaderProgram(context, shaderProgram) {
       writesLogDepth = true;
     }
 
-    let addExtension = true;
-    for (i = 0; i < length; ++i) {
-      if (extensionRegex.test(sources[i])) {
-        addExtension = false;
-      }
-    }
-
     let logSource = "";
-    if (addExtension) {
-      logSource +=
-        "#ifdef GL_EXT_frag_depth \n" +
-        "#extension GL_EXT_frag_depth : enable \n" +
-        "#endif \n\n";
-    }
 
     if (!writesLogDepth) {
       for (i = 0; i < length; i++) {
@@ -290,10 +283,10 @@ function getPickShaderProgram(context, shaderProgram, pickId) {
         "void main() \n" +
         "{ \n" +
         "    czm_non_pick_main(); \n" +
-        "    if (gl_FragColor.a == 0.0) { \n" +
+        "    if (out_FragColor.a == 0.0) { \n" +
         "        discard; \n" +
         "    } \n" +
-        "    gl_FragColor = "
+        "    out_FragColor = "
       }${pickId}; \n` + `} \n`;
     const newSources = new Array(length + 1);
     for (let i = 0; i < length; ++i) {

package/Source/Scene/EllipsoidPrimitive.js

@@ -238,11 +238,6 @@ function getVertexArray(context) {
   return vertexArray;
 }
 
-const logDepthExtension =
-  "#ifdef GL_EXT_frag_depth \n" +
-  "#extension GL_EXT_frag_depth : enable \n" +
-  "#endif \n\n";
-
 /**
  * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
  * get the draw commands needed to render this primitive.
@@ -378,7 +373,6 @@ EllipsoidPrimitive.prototype.update = function (frameState) {
     if (this._useLogDepth) {
       vs.defines.push("LOG_DEPTH");
       fs.defines.push("LOG_DEPTH");
-      fs.sources.push(logDepthExtension);
     }
 
     this._sp = ShaderProgram.replaceCache({
@@ -443,7 +437,6 @@ EllipsoidPrimitive.prototype.update = function (frameState) {
       if (this._useLogDepth) {
         vs.defines.push("LOG_DEPTH");
         fs.defines.push("LOG_DEPTH");
-        fs.sources.push(logDepthExtension);
       }
 
       this._pickSP = ShaderProgram.replaceCache({

package/Source/Scene/Expression.js

@@ -659,7 +659,7 @@ function parseCall(expression, ast) {
     const object = ast.callee.object;
     if (call === "test" || call === "exec") {
       // Make sure this is called on a valid type
-      if (object.callee.name !== "regExp") {
+      if (!defined(object.callee) || object.callee.name !== "regExp") {
         throw new RuntimeError(`${call} is not a function.`);
       }
       if (argsLength === 0) {

package/Source/Scene/Globe.js

@@ -379,6 +379,15 @@ function Globe(ellipsoid) {
 
   this._oceanNormalMap = undefined;
   this._zoomedOutOceanSpecularIntensity = undefined;
+
+  /**
+   * Determines the darkness of the vertex shadow.
+   * This only takes effect when <code>enableLighting</code> is <code>true</code>.
+   *
+   * @type {Number}
+   * @default 0.3
+   */
+  this.vertexShadowDarkness = 0.3;
 }
 
 Object.defineProperties(Globe.prototype, {
@@ -1046,6 +1055,7 @@ Globe.prototype.beginFrame = function (frameState) {
     tileProvider.fillHighlightColor = this.fillHighlightColor;
     tileProvider.showSkirts = this.showSkirts;
     tileProvider.backFaceCulling = this.backFaceCulling;
+    tileProvider.vertexShadowDarkness = this.vertexShadowDarkness;
     tileProvider.undergroundColor = this._undergroundColor;
     tileProvider.undergroundColorAlphaByDistance = this._undergroundColorAlphaByDistance;
     tileProvider.lambertDiffuseMultiplier = this.lambertDiffuseMultiplier;

package/Source/Scene/GlobeSurfaceTileProvider.js

@@ -89,6 +89,7 @@ function GlobeSurfaceTileProvider(options) {
   this.dynamicAtmosphereLightingFromSun = false;
   this.showGroundAtmosphere = false;
   this.shadows = ShadowMode.RECEIVE_ONLY;
+  this.vertexShadowDarkness = 0.3;
 
   /**
    * The color to use to highlight terrain fill tiles. If undefined, fill tiles are not
@@ -1785,6 +1786,9 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
     u_lambertDiffuseMultiplier: function () {
       return this.properties.lambertDiffuseMultiplier;
     },
+    u_vertexShadowDarkness: function () {
+      return this.properties.vertexShadowDarkness;
+    },
 
     // make a separate object so that changes to the properties are seen on
     // derived commands that combine another uniform map with this one.
@@ -1846,6 +1850,7 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
       undergroundColor: Color.clone(Color.TRANSPARENT),
       undergroundColorAlphaByDistance: new Cartesian4(),
       lambertDiffuseMultiplier: 0.0,
+      vertexShadowDarkness: 0.0,
     },
   };
 
@@ -2112,6 +2117,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       undergroundColorAlphaByDistance.farValue > 0.0);
 
   const lambertDiffuseMultiplier = tileProvider.lambertDiffuseMultiplier;
+  const vertexShadowDarkness = tileProvider.vertexShadowDarkness;
 
   const showReflectiveOcean =
     tileProvider.hasWaterMask && defined(waterMaskTexture);
@@ -2416,6 +2422,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
     Color.clone(undergroundColor, uniformMapProperties.undergroundColor);
 
     uniformMapProperties.lambertDiffuseMultiplier = lambertDiffuseMultiplier;
+    uniformMapProperties.vertexShadowDarkness = vertexShadowDarkness;
 
     const highlightFillTile =
       !defined(surfaceTile.vertexArray) &&

package/Source/Scene/GlobeTranslucencyState.js

@@ -401,7 +401,7 @@ function getDepthOnlyShaderProgram(vs, fs) {
   }
 
   const depthOnlyShader =
-    "void main() \n" + "{ \n" + "    gl_FragColor = vec4(1.0); \n" + "} \n";
+    "void main() \n" + "{ \n" + "    out_FragColor = vec4(1.0); \n" + "} \n";
 
   fs.sources = [depthOnlyShader];
 }
@@ -423,7 +423,7 @@ function getTranslucentShaderProgram(vs, fs) {
     "{ \n" +
     "    vec2 st = gl_FragCoord.xy / czm_viewport.zw; \n" +
     "#ifdef MANUAL_DEPTH_TEST \n" +
-    "    float logDepthOrDepth = czm_unpackDepth(texture2D(czm_globeDepthTexture, st)); \n" +
+    "    float logDepthOrDepth = czm_unpackDepth(texture(czm_globeDepthTexture, st)); \n" +
     "    if (logDepthOrDepth != 0.0) \n" +
     "    { \n" +
     "        vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, logDepthOrDepth); \n" +
@@ -435,13 +435,13 @@ function getTranslucentShaderProgram(vs, fs) {
     "    } \n" +
     "#endif \n" +
     "    czm_globe_translucency_main(); \n" +
-    "    vec4 classificationColor = texture2D(u_classificationTexture, st); \n" +
+    "    vec4 classificationColor = texture(u_classificationTexture, st); \n" +
     "    if (classificationColor.a > 0.0) \n" +
     "    { \n" +
     "        // Reverse premultiplication process to get the correct composited result of the classification primitives \n" +
     "        classificationColor.rgb /= classificationColor.a; \n" +
     "    } \n" +
-    "    gl_FragColor = classificationColor * vec4(classificationColor.aaa, 1.0) + gl_FragColor * (1.0 - classificationColor.a); \n" +
+    "    out_FragColor = classificationColor * vec4(classificationColor.aaa, 1.0) + out_FragColor * (1.0 - classificationColor.a); \n" +
     "} \n";
 
   sources.push(globeTranslucencyMain);
@@ -473,12 +473,12 @@ function getPickShaderProgram(vs, fs) {
     "void main() \n" +
     "{ \n" +
     "    vec2 st = gl_FragCoord.xy / czm_viewport.zw; \n" +
-    "    vec4 pickColor = texture2D(u_classificationTexture, st); \n" +
+    "    vec4 pickColor = texture(u_classificationTexture, st); \n" +
     "    if (pickColor == vec4(0.0)) \n" +
     "    { \n" +
     "        discard; \n" +
     "    } \n" +
-    "    gl_FragColor = pickColor; \n" +
+    "    out_FragColor = pickColor; \n" +
     "} \n";
 
   fs.sources = [pickShader];

package/Source/Scene/GltfImageLoader.js

@@ -293,7 +293,7 @@ function loadImageFromBufferTypedArray(typedArray) {
 const ktx2Regex = /(^data:image\/ktx2)|(\.ktx2$)/i;
 
 function loadImageFromUri(resource) {
-  const uri = resource.url;
+  const uri = resource.getUrlComponent(false, true);
   if (ktx2Regex.test(uri)) {
     // Resolves to a CompressedTextureBuffer
     return loadKTX2(resource);

package/Source/Scene/GltfVertexBufferLoader.js

@@ -67,7 +67,7 @@ function GltfVertexBufferLoader(options) {
   }
 
   const hasBufferViewId = defined(bufferViewId);
-  const hasDraco = defined(draco);
+  const hasDraco = hasDracoCompression(draco, attributeSemantic);
   const hasAttributeSemantic = defined(attributeSemantic);
   const hasAccessorId = defined(accessorId);
 
@@ -196,6 +196,14 @@ Object.defineProperties(GltfVertexBufferLoader.prototype, {
   },
 });
 
+function hasDracoCompression(draco, semantic) {
+  return (
+    defined(draco) &&
+    defined(draco.attributes) &&
+    defined(draco.attributes[semantic])
+  );
+}
+
 /**
  * Loads the resource.
  * @returns {Promise.<GltfVertexBufferLoader>} A promise which resolves to the loader when the resource loading is completed.
@@ -204,7 +212,7 @@ Object.defineProperties(GltfVertexBufferLoader.prototype, {
 GltfVertexBufferLoader.prototype.load = function () {
   let promise;
 
-  if (defined(this._draco)) {
+  if (hasDracoCompression(this._draco, this._attributeSemantic)) {
     promise = loadFromDraco(this);
   } else {
     promise = loadFromBufferView(this);

package/Source/Scene/GroundPolylinePrimitive.js

@@ -405,12 +405,10 @@ function createShaderProgram(groundPolylinePrimitive, frameState, appearance) {
 
     // Check for use of v_width and v_polylineAngle in material shader
     // to determine whether these varyings should be active in the vertex shader.
-    if (
-      materialShaderSource.search(/varying\s+float\s+v_polylineAngle;/g) !== -1
-    ) {
+    if (materialShaderSource.search(/in\s+float\s+v_polylineAngle;/g) !== -1) {
       vsDefines.push("ANGLE_VARYING");
     }
-    if (materialShaderSource.search(/varying\s+float\s+v_width;/g) !== -1) {
+    if (materialShaderSource.search(/in\s+float\s+v_width;/g) !== -1) {
       vsDefines.push("WIDTH_VARYING");
     }
   } else {

package/Source/Scene/GroupMetadata.js

@@ -69,7 +69,7 @@ Object.defineProperties(GroupMetadata.prototype, {
   },
 
   /**
-   * Extras in the JSON object.
+   * Extra user-defined properties.
    *
    * @memberof GroupMetadata.prototype
    * @type {*}
@@ -83,7 +83,7 @@ Object.defineProperties(GroupMetadata.prototype, {
   },
 
   /**
-   * Extensions in the JSON object.
+   * An object containing extensions.
    *
    * @memberof GroupMetadata.prototype
    * @type {Object}

package/Source/Scene/ImplicitMetadataView.js

@@ -56,7 +56,7 @@ Object.defineProperties(ImplicitMetadataView.prototype, {
   },
 
   /**
-   * Extras in the JSON object.
+   * Extra user-defined properties.
    *
    * @memberof ImplicitMetadataView.prototype
    * @type {Object}
@@ -69,7 +69,7 @@ Object.defineProperties(ImplicitMetadataView.prototype, {
   },
 
   /**
-   * Extensions in the JSON object.
+   * An object containing extensions.
    *
    * @memberof ImplicitMetadataView.prototype
    * @type {Object}

package/Source/Scene/ImplicitSubtreeCache.js

@@ -0,0 +1,127 @@
+import defaultValue from "../Core/defaultValue.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import DoubleEndedPriorityQueue from "../Core/DoubleEndedPriorityQueue.js";
+
+/**
+ * @alias ImplicitSubtreeCache
+ * @constructor
+ *
+ * @param {Object} [options] Object with the following properties
+ * @param {Number} [options.maximumSubtreeCount=0] The total number of subtrees this cache can store. If adding a new subtree would exceed this limit, the lowest priority subtrees will be removed until there is room, unless the subtree that is going to be removed is the parent of the new subtree, in which case it will not be removed and the new subtree will still be added, exceeding the memory limit.
+ *
+ * @private
+ */
+function ImplicitSubtreeCache(options) {
+  options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+  /**
+   * @type {Number}
+   * @private
+   */
+  this._maximumSubtreeCount = defaultValue(options.maximumSubtreeCount, 0);
+
+  /**
+   * A counter that goes up whenever a subtree is added. Used to sort subtrees by recency.
+   * @type {Number}
+   * @private
+   */
+  this._subtreeRequestCounter = 0;
+
+  /**
+   * @type {DoubleEndedPriorityQueue}
+   * @private
+   */
+  this._queue = new DoubleEndedPriorityQueue({
+    comparator: ImplicitSubtreeCache.comparator,
+  });
+}
+
+/**
+ * @param {ImplicitSubtree} subtree
+ */
+ImplicitSubtreeCache.prototype.addSubtree = function (subtree) {
+  const cacheNode = new ImplicitSubtreeCacheNode(
+    subtree,
+    this._subtreeRequestCounter
+  );
+  this._subtreeRequestCounter++;
+  this._queue.insert(cacheNode);
+
+  // Make sure the parent subtree exists in the cache
+  const subtreeCoord = subtree.implicitCoordinates;
+  if (subtreeCoord.level > 0) {
+    const parentCoord = subtreeCoord.getParentSubtreeCoordinates();
+    const parentNode = this.find(parentCoord);
+
+    //>>includeStart('debug', pragmas.debug)
+    if (parentNode === undefined) {
+      throw new DeveloperError("parent node needs to exist");
+    }
+    //>>includeEnd('debug');
+  }
+
+  if (this._maximumSubtreeCount > 0) {
+    while (this._queue.length > this._maximumSubtreeCount) {
+      const lowestPriorityNode = this._queue.getMinimum();
+      if (lowestPriorityNode === cacheNode) {
+        // Don't remove itself
+        break;
+      }
+
+      this._queue.removeMinimum();
+    }
+  }
+};
+
+/**
+ * @param {ImplicitTileCoordinates} subtreeCoord
+ * @returns {ImplicitSubtree|undefined}
+ */
+ImplicitSubtreeCache.prototype.find = function (subtreeCoord) {
+  const queue = this._queue;
+  const array = queue.internalArray;
+  const arrayLength = queue.length;
+
+  for (let i = 0; i < arrayLength; i++) {
+    const other = array[i];
+    const otherSubtree = other.subtree;
+    const otherCoord = otherSubtree.implicitCoordinates;
+    if (subtreeCoord.isEqual(otherCoord)) {
+      return other.subtree;
+    }
+  }
+  return undefined;
+};
+
+/**
+ * @param {ImplicitSubtreeCacheNode} a
+ * @param {ImplicitSubtreeCacheNode} b
+ * @returns {Number}
+ */
+ImplicitSubtreeCache.comparator = function (a, b) {
+  const aCoord = a.subtree.implicitCoordinates;
+  const bCoord = b.subtree.implicitCoordinates;
+  if (aCoord.isAncestor(bCoord)) {
+    // Technically this shouldn't happen because the ancestor subtree was supposed to be added to the cache first.
+    return +1.0;
+  } else if (bCoord.isAncestor(aCoord)) {
+    return -1.0;
+  }
+  return a.stamp - b.stamp;
+};
+
+/**
+ * @alias ImplicitSubtreeCacheNode
+ * @constructor
+ *
+ * @param {ImplicitSubtree} subtree
+ * @param {Number} stamp
+ *
+ * @private
+ */
+function ImplicitSubtreeCacheNode(subtree, stamp) {
+  this.subtree = subtree;
+  this.stamp = stamp;
+}
+
+export default ImplicitSubtreeCache;

package/Source/Scene/ImplicitSubtreeMetadata.js

@@ -54,7 +54,7 @@ Object.defineProperties(ImplicitSubtreeMetadata.prototype, {
   },
 
   /**
-   * Extras in the JSON object.
+   * Extra user-defined properties.
    *
    * @memberof ImplicitSubtreeMetadata.prototype
    * @type {Object}
@@ -68,7 +68,7 @@ Object.defineProperties(ImplicitSubtreeMetadata.prototype, {
   },
 
   /**
-   * Extensions in the JSON object.
+   * An object containing extensions.
    *
    * @memberof ImplicitSubtreeMetadata.prototype
    * @type {Object}

package/Source/Scene/ImplicitTileset.js

@@ -64,10 +64,11 @@ function ImplicitTileset(baseResource, tileJson, metadataSchema) {
   if (
     !defined(boundingVolume.box) &&
     !defined(boundingVolume.region) &&
-    !hasExtension(boundingVolume, "3DTILES_bounding_volume_S2")
+    !hasExtension(boundingVolume, "3DTILES_bounding_volume_S2") &&
+    !hasExtension(boundingVolume, "3DTILES_bounding_volume_cylinder")
   ) {
     throw new RuntimeError(
-      "Only box, region and 3DTILES_bounding_volume_S2 are supported for implicit tiling"
+      "Only box, region, 3DTILES_bounding_volume_S2, and 3DTILES_bounding_volume_cylinder are supported for implicit tiling"
     );
   }