@cesium/engine 6.1.1 → 7.0.0

package/Source/Scene/Megatexture.js

@@ -366,7 +366,7 @@ Megatexture.getApproximateTextureMemoryByteLength = function (
   const voxelCountTotal =
     tileCount * dimensions.x * dimensions.y * dimensions.z;
 
-  const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.z));
+  const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.x));
   const sliceCountPerRegionY = Math.ceil(dimensions.z / sliceCountPerRegionX);
   const voxelCountPerRegionX = sliceCountPerRegionX * dimensions.x;
   const voxelCountPerRegionY = sliceCountPerRegionY * dimensions.y;

package/Source/Scene/Model/AtmospherePipelineStage.js

@@ -0,0 +1,59 @@
+import Cartesian3 from "../../Core/Cartesian3.js";
+import CesiumMath from "../../Core/Math.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+import AtmosphereStageFS from "../../Shaders/Model/AtmosphereStageFS.js";
+import AtmosphereStageVS from "../../Shaders/Model/AtmosphereStageVS.js";
+
+/**
+ * The atmosphere pipeline stage applies all earth atmosphere effects that apply
+ * to models, including fog.
+ *
+ * @namespace AtmospherePipelineStage
+ *
+ * @private
+ */
+const AtmospherePipelineStage = {
+  name: "AtmospherePipelineStage", // Helps with debugging
+};
+
+AtmospherePipelineStage.process = function (
+  renderResources,
+  model,
+  frameState
+) {
+  const shaderBuilder = renderResources.shaderBuilder;
+
+  shaderBuilder.addDefine("HAS_ATMOSPHERE", undefined, ShaderDestination.BOTH);
+  shaderBuilder.addDefine(
+    "COMPUTE_POSITION_WC_ATMOSPHERE",
+    undefined,
+    ShaderDestination.BOTH
+  );
+
+  shaderBuilder.addVarying("vec3", "v_atmosphereRayleighColor");
+  shaderBuilder.addVarying("vec3", "v_atmosphereMieColor");
+  shaderBuilder.addVarying("float", "v_atmosphereOpacity");
+
+  shaderBuilder.addVertexLines([AtmosphereStageVS]);
+  shaderBuilder.addFragmentLines([AtmosphereStageFS]);
+
+  // Add a uniform so fog is only calculated when the efcfect would
+  // be non-negligible For example when the camera is in space, fog density decreases
+  // to 0 so fog shouldn't be rendered. Since this state may change rapidly if
+  // the camera is moving, this is implemented as a uniform, not a define.
+  shaderBuilder.addUniform("bool", "u_isInFog", ShaderDestination.FRAGMENT);
+  renderResources.uniformMap.u_isInFog = function () {
+    // We only need a rough measure of distance to the model, so measure
+    // from the camera to the bounding sphere center.
+    const distance = Cartesian3.distance(
+      frameState.camera.positionWC,
+      model.boundingSphere.center
+    );
+
+    return (
+      CesiumMath.fog(distance, frameState.fog.density) > CesiumMath.EPSILON3
+    );
+  };
+};
+
+export default AtmospherePipelineStage;

package/Source/Scene/Model/B3dmLoader.js

@@ -50,6 +50,7 @@ const FeatureIdAttribute = ModelComponents.FeatureIdAttribute;
  * @param {Axis} [options.forwardAxis=Axis.X] The forward-axis of the glTF model.
  * @param {boolean} [options.loadAttributesAsTypedArray=false] If <code>true</code>, load all attributes as typed arrays instead of GPU buffers. If the attributes are interleaved in the glTF they will be de-interleaved in the typed array.
  * @param {boolean} [options.loadAttributesFor2D=false] If <code>true</code>, load the positions buffer and any instanced attribute buffers as typed arrays for accurately projecting models to 2D.
+ * @param {boolean} [options.enablePick=false]  If <code>true</code>, load the positions buffer, any instanced attribute buffers, and index buffer as typed arrays for CPU-enabled picking in WebGL1.
  * @param {boolean} [options.loadIndicesForWireframe=false] If <code>true</code>, load the index buffer as a typed array. This is useful for creating wireframe indices in WebGL1.
  * @param {boolean} [options.loadPrimitiveOutline=true] If <code>true</code>, load outlines from the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set false to avoid post-processing geometry at load time.
  * @param {boolean} [options.loadForClassification=false] If <code>true</code> and if the model has feature IDs, load the feature IDs and indices as typed arrays. This is useful for batching features for classification.
@@ -74,6 +75,7 @@ function B3dmLoader(options) {
     false
   );
   const loadAttributesFor2D = defaultValue(options.loadAttributesFor2D, false);
+  const enablePick = defaultValue(options.enablePick, false);
   const loadIndicesForWireframe = defaultValue(
     options.loadIndicesForWireframe,
     false
@@ -102,6 +104,7 @@ function B3dmLoader(options) {
   this._forwardAxis = forwardAxis;
   this._loadAttributesAsTypedArray = loadAttributesAsTypedArray;
   this._loadAttributesFor2D = loadAttributesFor2D;
+  this._enablePick = enablePick;
   this._loadIndicesForWireframe = loadIndicesForWireframe;
   this._loadPrimitiveOutline = loadPrimitiveOutline;
   this._loadForClassification = loadForClassification;
@@ -223,6 +226,7 @@ B3dmLoader.prototype.load = function () {
     incrementallyLoadTextures: this._incrementallyLoadTextures,
     loadAttributesAsTypedArray: this._loadAttributesAsTypedArray,
     loadAttributesFor2D: this._loadAttributesFor2D,
+    enablePick: this._enablePick,
     loadIndicesForWireframe: this._loadIndicesForWireframe,
     loadPrimitiveOutline: this._loadPrimitiveOutline,
     loadForClassification: this._loadForClassification,

package/Source/Scene/Model/FeatureIdPipelineStage.js

@@ -9,6 +9,7 @@ import FeatureIdStageVS from "../../Shaders/Model/FeatureIdStageVS.js";
 import ModelComponents from "../ModelComponents.js";
 import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
 import ModelUtility from "./ModelUtility.js";
+import Matrix3 from "../../Core/Matrix3.js";
 
 /**
  * The feature ID pipeline stage is responsible for processing feature IDs
@@ -387,10 +388,32 @@ function processTexture(
     ShaderDestination.FRAGMENT
   );
 
+  // Get a GLSL expression for the texture coordinates
+  const texCoord = textureReader.texCoord;
+  const texCoordVariable = `v_texCoord_${texCoord}`;
+  let texCoordVariableExpression = texCoordVariable;
+
+  // Check if the texture defines a `transform` from a `KHR_texture_transform`
+  const transform = textureReader.transform;
+  if (defined(transform) && !Matrix3.equals(transform, Matrix3.IDENTITY)) {
+    // Add a uniform for the transformation matrix
+    const transformUniformName = `${uniformName}Transform`;
+    shaderBuilder.addUniform(
+      "mat3",
+      transformUniformName,
+      ShaderDestination.FRAGMENT
+    );
+    uniformMap[transformUniformName] = function () {
+      return transform;
+    };
+    // Update the expression for the texture coordinates
+    // with one that transforms the texture coordinates
+    // with the transform matrix first
+    texCoordVariableExpression = `vec2(${transformUniformName} * vec3(${texCoordVariable}, 1.0))`;
+  }
   // Read one or more channels from the texture
   // example: texture(u_featureIdTexture_0, v_texCoord_1).rg
-  const texCoord = `v_texCoord_${textureReader.texCoord}`;
-  const textureRead = `texture(${uniformName}, ${texCoord}).${channels}`;
+  const textureRead = `texture(${uniformName}, ${texCoordVariableExpression}).${channels}`;
 
   // Finally, assign to the struct field. Example:
   // featureIds.featureId_0 = unpacked;

package/Source/Scene/Model/I3dmLoader.js

@@ -64,6 +64,7 @@ const Instances = ModelComponents.Instances;
  * @param {Axis} [options.upAxis=Axis.Y] The up-axis of the glTF model.
  * @param {Axis} [options.forwardAxis=Axis.X] The forward-axis of the glTF model.
  * @param {boolean} [options.loadAttributesAsTypedArray=false] Load all attributes as typed arrays instead of GPU buffers. If the attributes are interleaved in the glTF they will be de-interleaved in the typed array.
+ * @param {boolean} [options.enablePick=false]  If <code>true</code>, load the positions buffer, any instanced attribute buffers, and index buffer as typed arrays for CPU-enabled picking in WebGL1.
  * @param {boolean} [options.loadIndicesForWireframe=false] Load the index buffer as a typed array so wireframe indices can be created for WebGL1.
  * @param {boolean} [options.loadPrimitiveOutline=true] If true, load outlines from the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set false to avoid post-processing geometry at load time.
  */
@@ -91,6 +92,7 @@ function I3dmLoader(options) {
     false
   );
   const loadPrimitiveOutline = defaultValue(options.loadPrimitiveOutline, true);
+  const enablePick = defaultValue(options.enablePick, false);
 
   //>>includeStart('debug', pragmas.debug);
   Check.typeOf.object("options.i3dmResource", i3dmResource);
@@ -111,6 +113,7 @@ function I3dmLoader(options) {
   this._loadAttributesAsTypedArray = loadAttributesAsTypedArray;
   this._loadIndicesForWireframe = loadIndicesForWireframe;
   this._loadPrimitiveOutline = loadPrimitiveOutline;
+  this._enablePick = enablePick;
 
   this._state = I3dmLoaderState.NOT_LOADED;
   this._promise = undefined;
@@ -240,6 +243,7 @@ I3dmLoader.prototype.load = function () {
     releaseGltfJson: this._releaseGltfJson,
     incrementallyLoadTextures: this._incrementallyLoadTextures,
     loadAttributesAsTypedArray: this._loadAttributesAsTypedArray,
+    enablePick: this._enablePick,
     loadIndicesForWireframe: this._loadIndicesForWireframe,
     loadPrimitiveOutline: this._loadPrimitiveOutline,
   };

package/Source/Scene/Model/InstancingPipelineStage.js

@@ -73,6 +73,7 @@ InstancingPipelineStage.process = function (renderResources, node, frameState) {
     frameState.mode !== SceneMode.SCENE3D &&
     !frameState.scene3DOnly &&
     model._projectTo2D;
+  const keepTypedArray = model._enablePick && !frameState.context.webgl2;
 
   const instancingVertexAttributes = [];
 
@@ -81,7 +82,8 @@ InstancingPipelineStage.process = function (renderResources, node, frameState) {
     frameState,
     instances,
     instancingVertexAttributes,
-    use2D
+    use2D,
+    keepTypedArray
   );
 
   processFeatureIdAttributes(
@@ -697,7 +699,8 @@ function processTransformAttributes(
   frameState,
   instances,
   instancingVertexAttributes,
-  use2D
+  use2D,
+  keepTypedArray
 ) {
   const rotationAttribute = ModelUtility.getAttributeBySemantic(
     instances,
@@ -711,7 +714,8 @@ function processTransformAttributes(
       instances,
       instancingVertexAttributes,
       frameState,
-      use2D
+      use2D,
+      keepTypedArray
     );
   } else {
     processTransformVec3Attributes(
@@ -729,7 +733,8 @@ function processTransformMatrixAttributes(
   instances,
   instancingVertexAttributes,
   frameState,
-  use2D
+  use2D,
+  keepTypedArray
 ) {
   const shaderBuilder = renderResources.shaderBuilder;
   const count = instances.attributes[0].count;
@@ -755,6 +760,10 @@ function processTransformMatrixAttributes(
     buffer = createVertexBuffer(transformsTypedArray, frameState);
     model._modelResources.push(buffer);
 
+    if (keepTypedArray) {
+      runtimeNode.transformsTypedArray = transformsTypedArray;
+    }
+
     runtimeNode.instancingTransformsBuffer = buffer;
   }
 
@@ -812,7 +821,8 @@ function processTransformVec3Attributes(
   instances,
   instancingVertexAttributes,
   frameState,
-  use2D
+  use2D,
+  keepTypedArray
 ) {
   const shaderBuilder = renderResources.shaderBuilder;
   const runtimeNode = renderResources.runtimeNode;
@@ -872,7 +882,7 @@ function processTransformVec3Attributes(
     attributeString
   );
 
-  if (!use2D) {
+  if (!use2D && !keepTypedArray) {
     return;
   }
 
@@ -898,6 +908,10 @@ function processTransformVec3Attributes(
     );
     const projectedTypedArray = translationsToTypedArray(projectedTranslations);
 
+    if (keepTypedArray) {
+      runtimeNode.transformsTypedArray = projectedTypedArray;
+    }
+
     // This memory is counted during the statistics stage at the end
     // of the pipeline.
     buffer2D = createVertexBuffer(projectedTypedArray, frameState);
@@ -906,6 +920,10 @@ function processTransformVec3Attributes(
     runtimeNode.instancingTranslationBuffer2D = buffer2D;
   }
 
+  if (!use2D) {
+    return;
+  }
+
   const byteOffset = 0;
   const byteStride = undefined;
 

package/Source/Scene/Model/MetadataPipelineStage.js

@@ -1,3 +1,4 @@
+import Matrix3 from "../../Core/Matrix3.js";
 import defined from "../../Core/defined.js";
 import ShaderDestination from "../../Renderer/ShaderDestination.js";
 import MetadataStageFS from "../../Shaders/Model/MetadataStageFS.js";
@@ -430,7 +431,13 @@ function addPropertyTexturePropertyMetadata(renderResources, propertyInfo) {
   const { shaderBuilder, uniformMap } = renderResources;
   const { metadataVariable, glslType, property } = propertyInfo;
 
-  const { texCoord, channels, index, texture } = property.textureReader;
+  const {
+    texCoord,
+    channels,
+    index,
+    texture,
+    transform,
+  } = property.textureReader;
   const textureUniformName = `u_propertyTexture_${index}`;
 
   // Property texture properties may share the same physical texture, so only
@@ -450,9 +457,30 @@ function addPropertyTexturePropertyMetadata(renderResources, propertyInfo) {
     metadataVariable
   );
 
-  // Get a GLSL expression for the value of the property
+  // Get a GLSL expression for the texture coordinates of the property.
+  // By default, this will be taken directly from the attributes.
   const texCoordVariable = `attributes.texCoord_${texCoord}`;
-  const valueExpression = `texture(${textureUniformName}, ${texCoordVariable}).${channels}`;
+  let texCoordVariableExpression = texCoordVariable;
+
+  // Check if the texture defines a `transform` from a `KHR_texture_transform`
+  if (defined(transform) && !Matrix3.equals(transform, Matrix3.IDENTITY)) {
+    // Add a uniform for the transformation matrix
+    const transformUniformName = `${textureUniformName}Transform`;
+    shaderBuilder.addUniform(
+      "mat3",
+      transformUniformName,
+      ShaderDestination.FRAGMENT
+    );
+    uniformMap[transformUniformName] = function () {
+      return transform;
+    };
+
+    // Update the expression for the texture coordinates
+    // with one that transforms the texture coordinates
+    // with the transform matrix first
+    texCoordVariableExpression = `vec2(${transformUniformName} * vec3(${texCoordVariable}, 1.0))`;
+  }
+  const valueExpression = `texture(${textureUniformName}, ${texCoordVariableExpression}).${channels}`;
 
   // Some types need an unpacking step or two. For example, since texture reads
   // are always normalized, UINT8 (not normalized) properties need to be

package/Source/Scene/Model/Model.js

@@ -9,6 +9,7 @@ import defaultValue from "../../Core/defaultValue.js";
 import DeveloperError from "../../Core/DeveloperError.js";
 import destroyObject from "../../Core/destroyObject.js";
 import DistanceDisplayCondition from "../../Core/DistanceDisplayCondition.js";
+import Ellipsoid from "../../Core/Ellipsoid.js";
 import Event from "../../Core/Event.js";
 import Matrix3 from "../../Core/Matrix3.js";
 import Matrix4 from "../../Core/Matrix4.js";
@@ -18,7 +19,9 @@ import Pass from "../../Renderer/Pass.js";
 import ClippingPlaneCollection from "../ClippingPlaneCollection.js";
 import ColorBlendMode from "../ColorBlendMode.js";
 import GltfLoader from "../GltfLoader.js";
-import HeightReference from "../HeightReference.js";
+import HeightReference, {
+  isHeightReferenceRelative,
+} from "../HeightReference.js";
 import ImageBasedLighting from "../ImageBasedLighting.js";
 import PointCloudShading from "../PointCloudShading.js";
 import SceneMode from "../SceneMode.js";
@@ -37,6 +40,7 @@ import ModelUtility from "./ModelUtility.js";
 import oneTimeWarning from "../../Core/oneTimeWarning.js";
 import PntsLoader from "./PntsLoader.js";
 import StyleCommandsNeeded from "./StyleCommandsNeeded.js";
+import pickModel from "./pickModel.js";
 
 /**
  * <div class="notice">
@@ -112,7 +116,7 @@ import StyleCommandsNeeded from "./StyleCommandsNeeded.js";
  * @internalConstructor
  *
  * @privateParam {ResourceLoader} options.loader The loader used to load resources for this model.
- * @privateParam {ModelType} options.type Type of this model, to distinguish individual glTF files from 3D Tiles internally. 
+ * @privateParam {ModelType} options.type Type of this model, to distinguish individual glTF files from 3D Tiles internally.
  * @privateParam {object} options Object with the following properties:
  * @privateParam {Resource} options.resource The Resource to the 3D model.
  * @privateParam {boolean} [options.show=true] Whether or not to render the model.
@@ -150,11 +154,12 @@ import StyleCommandsNeeded from "./StyleCommandsNeeded.js";
  * @privateParam {boolean} [options.showCreditsOnScreen=false] Whether to display the credits of this model on screen.
  * @privateParam {SplitDirection} [options.splitDirection=SplitDirection.NONE] The {@link SplitDirection} split to apply to this model.
  * @privateParam {boolean} [options.projectTo2D=false] Whether to accurately project the model's positions in 2D. If this is true, the model will be projected accurately to 2D, but it will use more memory to do so. If this is false, the model will use less memory and will still render in 2D / CV mode, but its positions may be inaccurate. This disables minimumPixelSize and prevents future modification to the model matrix. This also cannot be set after the model has loaded.
+ * @privateParam {boolean} [options.enablePick=false] Whether to allow CPU picking with <code>pick</code> when not using WebGL 2 or above. If using WebGL 2 or above, this option will be ignored. If using WebGL 1 and this is true, the <code>pick</code> operation will work correctly, but it will use more memory to do so. If running with WebGL 1 and this is false, the model will use less memory, but <code>pick</code> will always return <code>undefined</code>. This cannot be set after the model has loaded.
  * @privateParam {string|number} [options.featureIdLabel="featureId_0"] Label of the feature ID set to use for picking and styling. For EXT_mesh_features, this is the feature ID's label property, or "featureId_N" (where N is the index in the featureIds array) when not specified. EXT_feature_metadata did not have a label field, so such feature ID sets are always labeled "featureId_N" where N is the index in the list of all feature Ids, where feature ID attributes are listed before feature ID textures. If featureIdLabel is an integer N, it is converted to the string "featureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
  * @privateParam {string|number} [options.instanceFeatureIdLabel="instanceFeatureId_0"] Label of the instance feature ID set used for picking and styling. If instanceFeatureIdLabel is set to an integer N, it is converted to the string "instanceFeatureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
  * @privateParam {object} [options.pointCloudShading] Options for constructing a {@link PointCloudShading} object to control point attenuation based on geometric error and lighting.
  * @privateParam {ClassificationType} [options.classificationType] Determines whether terrain, 3D Tiles or both will be classified by this model. This cannot be set after the model has loaded.
- 
+
  *
  * @see Model.fromGltfAsync
  *
@@ -192,7 +197,7 @@ function Model(options) {
    * When this is the identity matrix, the model is drawn in world coordinates, i.e., Earth's Cartesian WGS84 coordinates.
    * Local reference frames can be used by providing a different transformation matrix, like that returned
    * by {@link Transforms.eastNorthUpToFixedFrame}.
-   * 
+   *
    * @type {Matrix4}
 
    * @default {@link Matrix4.IDENTITY}
@@ -333,15 +338,16 @@ function Model(options) {
   this._heightDirty = this._heightReference !== HeightReference.NONE;
   this._removeUpdateHeightCallback = undefined;
 
+  this._verticalExaggerationOn = false;
+
   this._clampedModelMatrix = undefined; // For use with height reference
 
   const scene = options.scene;
   if (defined(scene) && defined(scene.terrainProviderChanged)) {
     this._terrainProviderChangedCallback = scene.terrainProviderChanged.addEventListener(
-      function () {
+      () => {
         this._heightDirty = true;
-      },
-      this
+      }
     );
   }
   this._scene = scene;
@@ -453,6 +459,9 @@ function Model(options) {
 
   this._sceneMode = undefined;
   this._projectTo2D = defaultValue(options.projectTo2D, false);
+  this._enablePick = defaultValue(options.enablePick, false);
+
+  this._fogRenderable = undefined;
 
   this._skipLevelOfDetail = false;
   this._ignoreCommands = defaultValue(options.ignoreCommands, false);
@@ -1548,11 +1557,15 @@ Object.defineProperties(Model.prototype, {
    *     <li>The glTF cannot contain morph targets, skins, or animations.</li>
    *     <li>The glTF cannot contain the <code>EXT_mesh_gpu_instancing</code> extension.</li>
    *     <li>Only meshes with TRIANGLES can be used to classify other assets.</li>
-   *     <li>The position attribute is required.</li>
+   *     <li>The meshes must be watertight.</li>
+   *     <li>The POSITION attribute is required.</li>
    *     <li>If feature IDs and an index buffer are both present, all indices with the same feature id must occupy contiguous sections of the index buffer.</li>
    *     <li>If feature IDs are present without an index buffer, all positions with the same feature id must occupy contiguous sections of the position buffer.</li>
    * </ul>
    * </p>
+   * <p>
+   * The 3D Tiles or terrain receiving the classification must be opaque.
+   * </p>
    *
    * @memberof Model.prototype
    *
@@ -1789,6 +1802,8 @@ Model.prototype.update = function (frameState) {
   updateSkipLevelOfDetail(this, frameState);
   updateClippingPlanes(this, frameState);
   updateSceneMode(this, frameState);
+  updateFog(this, frameState);
+  updateVerticalExaggeration(this, frameState);
 
   this._defaultTexture = frameState.context.defaultTexture;
 
@@ -1983,6 +1998,22 @@ function updateSceneMode(model, frameState) {
   }
 }
 
+function updateFog(model, frameState) {
+  const fogRenderable = frameState.fog.enabled && frameState.fog.renderable;
+  if (fogRenderable !== model._fogRenderable) {
+    model.resetDrawCommands();
+    model._fogRenderable = fogRenderable;
+  }
+}
+
+function updateVerticalExaggeration(model, frameState) {
+  const verticalExaggerationNeeded = frameState.verticalExaggeration !== 1.0;
+  if (model._verticalExaggerationOn !== verticalExaggerationNeeded) {
+    model.resetDrawCommands();
+    model._verticalExaggerationOn = verticalExaggerationNeeded;
+  }
+}
+
 function buildDrawCommands(model, frameState) {
   if (!model._drawCommandsBuilt) {
     model.destroyPipelineResources();
@@ -2025,15 +2056,11 @@ function updateClamping(model) {
   }
 
   const scene = model._scene;
-  if (
-    !defined(scene) ||
-    !defined(scene.globe) ||
-    model.heightReference === HeightReference.NONE
-  ) {
+  if (!defined(scene) || model.heightReference === HeightReference.NONE) {
     //>>includeStart('debug', pragmas.debug);
     if (model.heightReference !== HeightReference.NONE) {
       throw new DeveloperError(
-        "Height reference is not supported without a scene and globe."
+        "Height reference is not supported without a scene."
       );
     }
     //>>includeEnd('debug');
@@ -2042,7 +2069,7 @@ function updateClamping(model) {
   }
 
   const globe = scene.globe;
-  const ellipsoid = globe.ellipsoid;
+  const ellipsoid = defaultValue(globe?.ellipsoid, Ellipsoid.WGS84);
 
   // Compute cartographic position so we don't recompute every update
   const modelMatrix = model.modelMatrix;
@@ -2056,14 +2083,14 @@ function updateClamping(model) {
   }
 
   // Install callback to handle updating of terrain tiles
-  const surface = globe._surface;
-  model._removeUpdateHeightCallback = surface.updateHeight(
+  model._removeUpdateHeightCallback = scene.updateHeight(
     cartoPosition,
-    getUpdateHeightCallback(model, ellipsoid, cartoPosition)
+    getUpdateHeightCallback(model, ellipsoid, cartoPosition),
+    model.heightReference
   );
 
   // Set the correct height now
-  const height = globe.getHeight(cartoPosition);
+  const height = scene.getHeight(cartoPosition, model.heightReference);
   if (defined(height)) {
     // Get callback with cartoPosition being the non-clamped position
     const callback = getUpdateHeightCallback(model, ellipsoid, cartoPosition);
@@ -2071,8 +2098,7 @@ function updateClamping(model) {
     // Compute the clamped cartesian and call updateHeight callback
     Cartographic.clone(cartoPosition, scratchCartographic);
     scratchCartographic.height = height;
-    ellipsoid.cartographicToCartesian(scratchCartographic, scratchPosition);
-    callback(scratchPosition);
+    callback(scratchCartographic);
   }
 
   model._heightDirty = false;
@@ -2329,24 +2355,25 @@ function scaleInPixels(positionWC, radius, frameState) {
   );
 }
 
-function getUpdateHeightCallback(model, ellipsoid, cartoPosition) {
+const scratchUpdateHeightCartesian = new Cartesian3();
+function getUpdateHeightCallback(model, ellipsoid, originalPostition) {
   return function (clampedPosition) {
-    if (model.heightReference === HeightReference.RELATIVE_TO_GROUND) {
-      const clampedCart = ellipsoid.cartesianToCartographic(
-        clampedPosition,
-        scratchCartographic
-      );
-      clampedCart.height += cartoPosition.height;
-      ellipsoid.cartographicToCartesian(clampedCart, clampedPosition);
+    if (isHeightReferenceRelative(model.heightReference)) {
+      clampedPosition.height += originalPostition.height;
     }
 
+    ellipsoid.cartographicToCartesian(
+      clampedPosition,
+      scratchUpdateHeightCartesian
+    );
+
     const clampedModelMatrix = model._clampedModelMatrix;
 
     // Modify clamped model matrix to use new height
     Matrix4.clone(model.modelMatrix, clampedModelMatrix);
-    clampedModelMatrix[12] = clampedPosition.x;
-    clampedModelMatrix[13] = clampedPosition.y;
-    clampedModelMatrix[14] = clampedPosition.z;
+    clampedModelMatrix[12] = scratchUpdateHeightCartesian.x;
+    clampedModelMatrix[13] = scratchUpdateHeightCartesian.y;
+    clampedModelMatrix[14] = scratchUpdateHeightCartesian.z;
 
     model._heightDirty = true;
   };
@@ -2481,6 +2508,35 @@ Model.prototype.isClippingEnabled = function () {
   );
 };
 
+/**
+ * Find an intersection between a ray and the model surface that was rendered. The ray must be given in world coordinates.
+ *
+ * @param {Ray} ray The ray to test for intersection.
+ * @param {FrameState} frameState The frame state.
+ * @param {number} [verticalExaggeration=1.0] A scalar used to exaggerate the height of a position relative to the ellipsoid. If the value is 1.0 there will be no effect.
+ * @param {number} [relativeHeight=0.0] The height above the ellipsoid relative to which a position is exaggerated. If the value is 0.0 the position will be exaggerated relative to the ellipsoid surface.
+ * @param {Cartesian3|undefined} [result] The intersection or <code>undefined</code> if none was found.
+ * @returns {Cartesian3|undefined} The intersection or <code>undefined</code> if none was found.
+ *
+ * @private
+ */
+Model.prototype.pick = function (
+  ray,
+  frameState,
+  verticalExaggeration,
+  relativeHeight,
+  result
+) {
+  return pickModel(
+    this,
+    ray,
+    frameState,
+    verticalExaggeration,
+    relativeHeight,
+    result
+  );
+};
+
 /**
  * Returns true if this object was destroyed; otherwise, false.
  * <br /><br />
@@ -2640,6 +2696,7 @@ Model.prototype.destroyModelResources = function () {
  * @param {boolean} [options.showCreditsOnScreen=false] Whether to display the credits of this model on screen.
  * @param {SplitDirection} [options.splitDirection=SplitDirection.NONE] The {@link SplitDirection} split to apply to this model.
  * @param {boolean} [options.projectTo2D=false] Whether to accurately project the model's positions in 2D. If this is true, the model will be projected accurately to 2D, but it will use more memory to do so. If this is false, the model will use less memory and will still render in 2D / CV mode, but its positions may be inaccurate. This disables minimumPixelSize and prevents future modification to the model matrix. This also cannot be set after the model has loaded.
+ * @param {boolean} [options.enablePick=false] Whether to allow with CPU picking with <code>pick</code> when not using WebGL 2 or above. If using WebGL 2 or above, this option will be ignored. If using WebGL 1 and this is true, the <code>pick</code> operation will work correctly, but it will use more memory to do so. If running with WebGL 1 and this is false, the model will use less memory, but <code>pick</code> will always return <code>undefined</code>. This cannot be set after the model has loaded.
  * @param {string|number} [options.featureIdLabel="featureId_0"] Label of the feature ID set to use for picking and styling. For EXT_mesh_features, this is the feature ID's label property, or "featureId_N" (where N is the index in the featureIds array) when not specified. EXT_feature_metadata did not have a label field, so such feature ID sets are always labeled "featureId_N" where N is the index in the list of all feature Ids, where feature ID attributes are listed before feature ID textures. If featureIdLabel is an integer N, it is converted to the string "featureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
  * @param {string|number} [options.instanceFeatureIdLabel="instanceFeatureId_0"] Label of the instance feature ID set used for picking and styling. If instanceFeatureIdLabel is set to an integer N, it is converted to the string "instanceFeatureId_N" automatically. If both per-primitive and per-instance feature IDs are present, the instance feature IDs take priority.
  * @param {object} [options.pointCloudShading] Options for constructing a {@link PointCloudShading} object to control point attenuation and lighting.
@@ -2734,6 +2791,7 @@ Model.fromGltfAsync = async function (options) {
     upAxis: options.upAxis,
     forwardAxis: options.forwardAxis,
     loadAttributesFor2D: options.projectTo2D,
+    enablePick: options.enablePick,
     loadIndicesForWireframe: options.enableDebugWireframe,
     loadPrimitiveOutline: options.enableShowOutline,
     loadForClassification: defined(options.classificationType),
@@ -2810,6 +2868,7 @@ Model.fromB3dm = async function (options) {
     upAxis: options.upAxis,
     forwardAxis: options.forwardAxis,
     loadAttributesFor2D: options.projectTo2D,
+    enablePick: options.enablePick,
     loadIndicesForWireframe: options.enableDebugWireframe,
     loadPrimitiveOutline: options.enableShowOutline,
     loadForClassification: defined(options.classificationType),
@@ -2865,6 +2924,7 @@ Model.fromI3dm = async function (options) {
     upAxis: options.upAxis,
     forwardAxis: options.forwardAxis,
     loadAttributesFor2D: options.projectTo2D,
+    enablePick: options.enablePick,
     loadIndicesForWireframe: options.enableDebugWireframe,
     loadPrimitiveOutline: options.enableShowOutline,
   };
@@ -2998,6 +3058,7 @@ function makeModelOptions(loader, modelType, options) {
     showCreditsOnScreen: options.showCreditsOnScreen,
     splitDirection: options.splitDirection,
     projectTo2D: options.projectTo2D,
+    enablePick: options.enablePick,
     featureIdLabel: options.featureIdLabel,
     instanceFeatureIdLabel: options.instanceFeatureIdLabel,
     pointCloudShading: options.pointCloudShading,