} A promise which resolves to the created IonImageryProvider.
*
* @example
diff --git a/packages/engine/Source/Scene/MapboxImageryProvider.js b/packages/engine/Source/Scene/MapboxImageryProvider.js
index b8e5d069231d..2c5a943bd52a 100644
--- a/packages/engine/Source/Scene/MapboxImageryProvider.js
+++ b/packages/engine/Source/Scene/MapboxImageryProvider.js
@@ -43,8 +43,8 @@ const defaultCredit = new Credit(
* accessToken: 'thisIsMyAccessToken'
* });
*
- * @see {@link https://www.mapbox.com/developers/api/maps/#tiles}
- * @see {@link https://www.mapbox.com/developers/api/#access-tokens}
+ * @see {@link https://docs.mapbox.com/api/maps/raster-tiles/}
+ * @see {@link https://docs.mapbox.com/api/accounts/tokens/}
*/
function MapboxImageryProvider(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
diff --git a/packages/engine/Source/Scene/Model/B3dmLoader.js b/packages/engine/Source/Scene/Model/B3dmLoader.js
index 7385f18a690d..600221ac4dde 100644
--- a/packages/engine/Source/Scene/Model/B3dmLoader.js
+++ b/packages/engine/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 true, 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 true, load the positions buffer and any instanced attribute buffers as typed arrays for accurately projecting models to 2D.
+ * @param {boolean} [options.enablePick=false] If true, 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 true, load the index buffer as a typed array. This is useful for creating wireframe indices in 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.
* @param {boolean} [options.loadForClassification=false] If true 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,
diff --git a/packages/engine/Source/Scene/Model/I3dmLoader.js b/packages/engine/Source/Scene/Model/I3dmLoader.js
index 2a1aff969bd2..0f9457624419 100644
--- a/packages/engine/Source/Scene/Model/I3dmLoader.js
+++ b/packages/engine/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 true, 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,
};
diff --git a/packages/engine/Source/Scene/Model/InstancingPipelineStage.js b/packages/engine/Source/Scene/Model/InstancingPipelineStage.js
index 850410c2fd2b..809a1dd06d32 100644
--- a/packages/engine/Source/Scene/Model/InstancingPipelineStage.js
+++ b/packages/engine/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;
diff --git a/packages/engine/Source/Scene/Model/Model.js b/packages/engine/Source/Scene/Model/Model.js
index 26be311fc8b9..389c7aa9d8ad 100644
--- a/packages/engine/Source/Scene/Model/Model.js
+++ b/packages/engine/Source/Scene/Model/Model.js
@@ -1,23 +1,17 @@
-import AttributeType from "../AttributeType.js";
-import AttributeCompression from "../../Core/AttributeCompression.js";
import BoundingSphere from "../../Core/BoundingSphere.js";
import Cartesian3 from "../../Core/Cartesian3.js";
import Cartographic from "../../Core/Cartographic.js";
import Check from "../../Core/Check.js";
import Credit from "../../Core/Credit.js";
import Color from "../../Core/Color.js";
-import ComponentDatatype from "../../Core/ComponentDatatype.js";
import defined from "../../Core/defined.js";
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 Event from "../../Core/Event.js";
-import IndexDatatype from "../../Core/IndexDatatype.js";
-import IntersectionTests from "../../Core/IntersectionTests.js";
import Matrix3 from "../../Core/Matrix3.js";
import Matrix4 from "../../Core/Matrix4.js";
-import Ray from "../../Core/Ray.js";
import Resource from "../../Core/Resource.js";
import RuntimeError from "../../Core/RuntimeError.js";
import Pass from "../../Renderer/Pass.js";
@@ -45,8 +39,7 @@ import ModelUtility from "./ModelUtility.js";
import oneTimeWarning from "../../Core/oneTimeWarning.js";
import PntsLoader from "./PntsLoader.js";
import StyleCommandsNeeded from "./StyleCommandsNeeded.js";
-import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
-import Transforms from "../../Core/Transforms.js";
+import pickModel from "./pickModel.js";
/**
*
@@ -160,6 +153,7 @@ import Transforms from "../../Core/Transforms.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 with CPU picking with pick 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 pick 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 pick will always return undefined. 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.
@@ -463,6 +457,7 @@ function Model(options) {
this._sceneMode = undefined;
this._projectTo2D = defaultValue(options.projectTo2D, false);
+ this._enablePick = defaultValue(options.enablePick, false);
this._skipLevelOfDetail = false;
this._ignoreCommands = defaultValue(options.ignoreCommands, false);
@@ -2487,201 +2482,18 @@ Model.prototype.isClippingEnabled = function () {
);
};
-const scratchV0 = new Cartesian3();
-const scratchV1 = new Cartesian3();
-const scratchV2 = new Cartesian3();
-const scratchModelMatrix = new Matrix4();
-const scratchPickCartographic = new Cartographic();
-
/**
* 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 {boolean} [cullBackFaces=true] If false, back faces are not culled and will return an intersection if picked.
* @param {Cartesian3|undefined} [result] The intersection or undefined if none was found.
* @returns {Cartesian3|undefined} The intersection or undefined if none was found.
*
* @private
*/
-Model.prototype.pick = function (ray, frameState, cullBackFaces, result) {
- if (frameState.mode === SceneMode.MORPHING) {
- return;
- }
-
- let minT = Number.MAX_VALUE;
- const modelMatrix = this.sceneGraph.computedModelMatrix;
-
- // Check all the primitive positions
- const nodes = this._sceneGraph._runtimeNodes;
- for (let i = 0; i < nodes.length; i++) {
- const node = nodes[i];
- const instances = node.node.instances;
- if (defined(instances)) {
- // TODO: Instances
- return;
- }
-
- const nodeComputedTransform = node.computedTransform;
- let computedModelMatrix = Matrix4.multiplyTransformation(
- modelMatrix,
- nodeComputedTransform,
- scratchModelMatrix
- );
- if (frameState.mode !== SceneMode.SCENE3D) {
- computedModelMatrix = Transforms.basisTo2D(
- frameState.mapProjection,
- computedModelMatrix,
- computedModelMatrix
- );
- }
-
- for (let j = 0; j < node.node.primitives.length; j++) {
- const primitive = node.node.primitives[j];
- const positionAttribute = ModelUtility.getAttributeBySemantic(
- primitive,
- VertexAttributeSemantic.POSITION
- );
- const vertexCount = positionAttribute.count;
-
- let indices = primitive.indices.typedArray;
- if (!defined(indices)) {
- const indicesBuffer = primitive.indices.buffer;
- const indicesCount = primitive.indices.count;
- if (defined(indicesBuffer) && frameState.context.webgl2) {
- const useUint8Array = indicesBuffer.sizeInBytes === indicesCount;
- indices = useUint8Array
- ? new Uint8Array(indicesCount)
- : IndexDatatype.createTypedArray(vertexCount, indicesCount);
- indicesBuffer.getBufferData(indices, 0, 0, indicesCount);
- }
- primitive.indices.typedArray = indices;
- }
-
- let vertices = positionAttribute.typedArray;
- let componentDatatype = positionAttribute.componentDatatype;
- let attributeType = positionAttribute.type;
-
- const quantization = positionAttribute.quantization;
- if (defined(quantization)) {
- componentDatatype = positionAttribute.quantization.componentDatatype;
- attributeType = positionAttribute.quantization.type;
- }
-
- const numComponents = AttributeType.getNumberOfComponents(attributeType);
- const elementCount = vertexCount * numComponents;
-
- if (!defined(vertices)) {
- const verticesBuffer = positionAttribute.buffer;
-
- if (defined(verticesBuffer) && frameState.context.webgl2) {
- vertices = ComponentDatatype.createTypedArray(
- componentDatatype,
- elementCount
- );
- verticesBuffer.getBufferData(
- vertices,
- positionAttribute.byteOffset,
- 0,
- elementCount
- );
- }
-
- if (quantization && positionAttribute.normalized) {
- vertices = AttributeCompression.dequantize(
- vertices,
- componentDatatype,
- attributeType,
- vertexCount
- );
- }
-
- positionAttribute.typedArray = vertices;
- }
-
- const indicesLength = indices.length;
- for (let i = 0; i < indicesLength; i += 3) {
- const i0 = indices[i];
- const i1 = indices[i + 1];
- const i2 = indices[i + 2];
-
- const getPosition = (vertices, index, numComponents, result) => {
- const i = index * numComponents;
- result.x = vertices[i];
- result.y = vertices[i + 1];
- result.z = vertices[i + 2];
-
- if (defined(quantization)) {
- if (quantization.octEncoded) {
- result = AttributeCompression.octDecodeInRange(
- result,
- quantization.normalizationRange,
- result
- );
-
- if (quantization.octEncodedZXY) {
- const x = result.x;
- result.x = result.z;
- result.z = result.y;
- result.y = x;
- }
- } else {
- result = Cartesian3.multiplyComponents(
- result,
- quantization.quantizedVolumeStepSize,
- result
- );
-
- result = Cartesian3.add(
- result,
- quantization.quantizedVolumeOffset,
- result
- );
- }
- }
-
- result = Matrix4.multiplyByPoint(computedModelMatrix, result, result);
-
- return result;
- };
-
- const v0 = getPosition(vertices, i0, numComponents, scratchV0);
- const v1 = getPosition(vertices, i1, numComponents, scratchV1);
- const v2 = getPosition(vertices, i2, numComponents, scratchV2);
-
- const t = IntersectionTests.rayTriangleParametric(
- ray,
- v0,
- v1,
- v2,
- cullBackFaces
- );
-
- if (defined(t)) {
- if (t < minT && t >= 0.0) {
- minT = t;
- }
- }
- }
- }
- }
-
- if (minT === Number.MAX_VALUE) {
- return undefined;
- }
-
- result = Ray.getPoint(ray, minT, result);
- if (frameState.mode !== SceneMode.SCENE3D) {
- Cartesian3.fromElements(result.y, result.z, result.x, result);
-
- const projection = frameState.mapProjection;
- const ellipsoid = projection.ellipsoid;
-
- const cart = projection.unproject(result, scratchPickCartographic);
- ellipsoid.cartographicToCartesian(cart, result);
- }
-
- return result;
+Model.prototype.pick = function (ray, frameState, result) {
+ return pickModel(this, ray, frameState, result);
};
/**
@@ -2843,6 +2655,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 pick 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 pick 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 pick will always return undefined. 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.
@@ -2937,6 +2750,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),
@@ -3013,6 +2827,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),
@@ -3068,6 +2883,7 @@ Model.fromI3dm = async function (options) {
upAxis: options.upAxis,
forwardAxis: options.forwardAxis,
loadAttributesFor2D: options.projectTo2D,
+ enablePick: options.enablePick,
loadIndicesForWireframe: options.enableDebugWireframe,
loadPrimitiveOutline: options.enableShowOutline,
};
@@ -3201,6 +3017,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,
diff --git a/packages/engine/Source/Scene/Model/Model3DTileContent.js b/packages/engine/Source/Scene/Model/Model3DTileContent.js
index c0e71069a2c4..3273c81146d6 100644
--- a/packages/engine/Source/Scene/Model/Model3DTileContent.js
+++ b/packages/engine/Source/Scene/Model/Model3DTileContent.js
@@ -421,23 +421,17 @@ Model3DTileContent.fromGeoJson = async function (
*
* @param {Ray} ray The ray to test for intersection.
* @param {FrameState} frameState The frame state.
- * @param {boolean} [cullBackFaces=true] If false, back faces are not culled and will return an intersection if picked.
* @param {Cartesian3|undefined} [result] The intersection or undefined if none was found.
* @returns {Cartesian3|undefined} The intersection or undefined if none was found.
*
* @private
*/
-Model3DTileContent.prototype.pick = function (
- ray,
- frameState,
- cullBackFaces,
- result
-) {
+Model3DTileContent.prototype.pick = function (ray, frameState, result) {
if (!defined(this._model) || !this._ready) {
return undefined;
}
- return this._model.pick(ray, frameState, cullBackFaces, result);
+ return this._model.pick(ray, frameState, result);
};
function makeModelOptions(tileset, tile, content, additionalOptions) {
@@ -466,6 +460,7 @@ function makeModelOptions(tileset, tile, content, additionalOptions) {
enableDebugWireframe: tileset._enableDebugWireframe,
debugWireframe: tileset.debugWireframe,
projectTo2D: tileset._projectTo2D,
+ enablePick: tileset._enablePick,
enableShowOutline: tileset._enableShowOutline,
showOutline: tileset.showOutline,
outlineColor: tileset.outlineColor,
diff --git a/packages/engine/Source/Scene/Model/pickModel.js b/packages/engine/Source/Scene/Model/pickModel.js
new file mode 100644
index 000000000000..16a2bb02f94f
--- /dev/null
+++ b/packages/engine/Source/Scene/Model/pickModel.js
@@ -0,0 +1,369 @@
+import AttributeCompression from "../../Core/AttributeCompression.js";
+import BoundingSphere from "../../Core/BoundingSphere.js";
+import Cartesian3 from "../../Core/Cartesian3.js";
+import Cartographic from "../../Core/Cartographic.js";
+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 IndexDatatype from "../../Core/IndexDatatype.js";
+import IntersectionTests from "../../Core/IntersectionTests.js";
+import Ray from "../../Core/Ray.js";
+import Matrix4 from "../../Core/Matrix4.js";
+import Transforms from "../../Core/Transforms.js";
+import AttributeType from "../AttributeType.js";
+import SceneMode from "../SceneMode.js";
+import VertexAttributeSemantic from "../VertexAttributeSemantic.js";
+import ModelUtility from "./ModelUtility.js";
+
+const scratchV0 = new Cartesian3();
+const scratchV1 = new Cartesian3();
+const scratchV2 = new Cartesian3();
+const scratchNodeComputedTransform = new Matrix4();
+const scratchModelMatrix = new Matrix4();
+const scratchcomputedModelMatrix = new Matrix4();
+const scratchPickCartographic = new Cartographic();
+const scratchBoundingSphere = new BoundingSphere();
+
+/**
+ * Find an intersection between a ray and the model surface that was rendered. The ray must be given in world coordinates.
+ *
+ * @param {Model} model The model to pick.
+ * @param {Ray} ray The ray to test for intersection.
+ * @param {FrameState} frameState The frame state.
+ * @param {Cartesian3|undefined} [result] The intersection or undefined if none was found.
+ * @returns {Cartesian3|undefined} The intersection or undefined if none was found.
+ *
+ * @private
+ */
+export default function pickModel(model, ray, frameState, result) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.object("model", model);
+ Check.typeOf.object("ray", ray);
+ Check.typeOf.object("frameState", frameState);
+ //>>includeEnd('debug');
+
+ if (!model._ready || frameState.mode === SceneMode.MORPHING) {
+ return;
+ }
+
+ let minT = Number.MAX_VALUE;
+ const sceneGraph = model.sceneGraph;
+
+ const nodes = sceneGraph._runtimeNodes;
+ for (let i = 0; i < nodes.length; i++) {
+ const runtimeNode = nodes[i];
+ const node = runtimeNode.node;
+
+ let nodeComputedTransform = Matrix4.clone(
+ runtimeNode.computedTransform,
+ scratchNodeComputedTransform
+ );
+ let modelMatrix = Matrix4.clone(
+ sceneGraph.computedModelMatrix,
+ scratchModelMatrix
+ );
+
+ const instances = node.instances;
+ if (defined(instances)) {
+ if (instances.transformInWorldSpace) {
+ // Replicate the multiplication order in LegacyInstancingStageVS.
+ modelMatrix = Matrix4.multiplyTransformation(
+ model.modelMatrix,
+ sceneGraph.components.transform,
+ modelMatrix
+ );
+
+ nodeComputedTransform = Matrix4.multiplyTransformation(
+ sceneGraph.axisCorrectionMatrix,
+ runtimeNode.computedTransform,
+ nodeComputedTransform
+ );
+ }
+ }
+
+ if (frameState.mode !== SceneMode.SCENE3D) {
+ modelMatrix = Transforms.basisTo2D(
+ frameState.mapProjection,
+ modelMatrix,
+ modelMatrix
+ );
+ }
+
+ const computedModelMatrix = Matrix4.multiplyTransformation(
+ modelMatrix,
+ nodeComputedTransform,
+ scratchcomputedModelMatrix
+ );
+
+ const transforms = [];
+ if (defined(instances)) {
+ const transformsCount = instances.attributes[0].count;
+ const instanceComponentDatatype =
+ instances.attributes[0].componentDatatype;
+
+ const transformElements = 12;
+ let transformsTypedArray = runtimeNode.transformsTypedArray;
+ if (!defined(transformsTypedArray)) {
+ const instanceTransformsBuffer = runtimeNode.instancingTransformsBuffer;
+ if (defined(instanceTransformsBuffer) && frameState.context.webgl2) {
+ transformsTypedArray = ComponentDatatype.createTypedArray(
+ instanceComponentDatatype,
+ transformsCount * transformElements
+ );
+ instanceTransformsBuffer.getBufferData(transformsTypedArray);
+ }
+ }
+
+ if (defined(transformsTypedArray)) {
+ for (let i = 0; i < transformsCount; i++) {
+ const index = i * transformElements;
+
+ const transform = new Matrix4(
+ transformsTypedArray[index],
+ transformsTypedArray[index + 1],
+ transformsTypedArray[index + 2],
+ transformsTypedArray[index + 3],
+ transformsTypedArray[index + 4],
+ transformsTypedArray[index + 5],
+ transformsTypedArray[index + 6],
+ transformsTypedArray[index + 7],
+ transformsTypedArray[index + 8],
+ transformsTypedArray[index + 9],
+ transformsTypedArray[index + 10],
+ transformsTypedArray[index + 11],
+ 0,
+ 0,
+ 0,
+ 1
+ );
+
+ if (instances.transformInWorldSpace) {
+ Matrix4.multiplyTransformation(
+ transform,
+ nodeComputedTransform,
+ transform
+ );
+ Matrix4.multiplyTransformation(modelMatrix, transform, transform);
+ } else {
+ Matrix4.multiplyTransformation(
+ transform,
+ computedModelMatrix,
+ transform
+ );
+ }
+ transforms.push(transform);
+ }
+ }
+ }
+
+ if (transforms.length === 0) {
+ transforms.push(computedModelMatrix);
+ }
+
+ const primitivesLength = runtimeNode.runtimePrimitives.length;
+ for (let j = 0; j < primitivesLength; j++) {
+ const runtimePrimitive = runtimeNode.runtimePrimitives[j];
+ const primitive = runtimePrimitive.primitive;
+
+ if (defined(runtimePrimitive.boundingSphere) && !defined(instances)) {
+ const boundingSphere = BoundingSphere.transform(
+ runtimePrimitive.boundingSphere,
+ computedModelMatrix,
+ scratchBoundingSphere
+ );
+ const boundsIntersection = IntersectionTests.raySphere(
+ ray,
+ boundingSphere
+ );
+ if (!defined(boundsIntersection)) {
+ continue;
+ }
+ }
+
+ const positionAttribute = ModelUtility.getAttributeBySemantic(
+ primitive,
+ VertexAttributeSemantic.POSITION
+ );
+ const vertexCount = positionAttribute.count;
+
+ if (!defined(primitive.indices)) {
+ // Point clouds
+ continue;
+ }
+
+ let indices = primitive.indices.typedArray;
+ if (!defined(indices)) {
+ const indicesBuffer = primitive.indices.buffer;
+ const indicesCount = primitive.indices.count;
+ const indexDatatype = primitive.indices.indexDatatype;
+ if (defined(indicesBuffer) && frameState.context.webgl2) {
+ if (indexDatatype === IndexDatatype.UNSIGNED_BYTE) {
+ indices = new Uint8Array(indicesCount);
+ } else if (indexDatatype === IndexDatatype.UNSIGNED_SHORT) {
+ indices = new Uint16Array(indicesCount);
+ } else if (indexDatatype === IndexDatatype.UNSIGNED_INT) {
+ indices = new Uint32Array(indicesCount);
+ }
+
+ indicesBuffer.getBufferData(indices);
+ }
+ }
+
+ let vertices = positionAttribute.typedArray;
+ let componentDatatype = positionAttribute.componentDatatype;
+ let attributeType = positionAttribute.type;
+
+ const quantization = positionAttribute.quantization;
+ if (defined(quantization)) {
+ componentDatatype = positionAttribute.quantization.componentDatatype;
+ attributeType = positionAttribute.quantization.type;
+ }
+
+ const numComponents = AttributeType.getNumberOfComponents(attributeType);
+ const elementCount = vertexCount * numComponents;
+
+ if (!defined(vertices)) {
+ const verticesBuffer = positionAttribute.buffer;
+
+ if (defined(verticesBuffer) && frameState.context.webgl2) {
+ vertices = ComponentDatatype.createTypedArray(
+ componentDatatype,
+ elementCount
+ );
+ verticesBuffer.getBufferData(
+ vertices,
+ positionAttribute.byteOffset,
+ 0,
+ elementCount
+ );
+ }
+
+ if (quantization && positionAttribute.normalized) {
+ vertices = AttributeCompression.dequantize(
+ vertices,
+ componentDatatype,
+ attributeType,
+ vertexCount
+ );
+ }
+ }
+
+ if (!defined(indices) || !defined(vertices)) {
+ return;
+ }
+
+ const indicesLength = indices.length;
+ for (let i = 0; i < indicesLength; i += 3) {
+ const i0 = indices[i];
+ const i1 = indices[i + 1];
+ const i2 = indices[i + 2];
+
+ for (const instanceTransform of transforms) {
+ const v0 = getVertexPosition(
+ vertices,
+ i0,
+ numComponents,
+ quantization,
+ instanceTransform,
+ scratchV0
+ );
+ const v1 = getVertexPosition(
+ vertices,
+ i1,
+ numComponents,
+ quantization,
+ instanceTransform,
+ scratchV1
+ );
+ const v2 = getVertexPosition(
+ vertices,
+ i2,
+ numComponents,
+ quantization,
+ instanceTransform,
+ scratchV2
+ );
+
+ const t = IntersectionTests.rayTriangleParametric(
+ ray,
+ v0,
+ v1,
+ v2,
+ defaultValue(model.backFaceCulling, true)
+ );
+
+ if (defined(t)) {
+ if (t < minT && t >= 0.0) {
+ minT = t;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (minT === Number.MAX_VALUE) {
+ return undefined;
+ }
+
+ result = Ray.getPoint(ray, minT, result);
+ if (frameState.mode !== SceneMode.SCENE3D) {
+ Cartesian3.fromElements(result.y, result.z, result.x, result);
+
+ const projection = frameState.mapProjection;
+ const ellipsoid = projection.ellipsoid;
+
+ const cartographic = projection.unproject(result, scratchPickCartographic);
+ ellipsoid.cartographicToCartesian(cartographic, result);
+ }
+
+ return result;
+}
+
+function getVertexPosition(
+ vertices,
+ index,
+ numComponents,
+ quantization,
+ instanceTransform,
+ result
+) {
+ const i = index * numComponents;
+ result.x = vertices[i];
+ result.y = vertices[i + 1];
+ result.z = vertices[i + 2];
+
+ if (defined(quantization)) {
+ if (quantization.octEncoded) {
+ result = AttributeCompression.octDecodeInRange(
+ result,
+ quantization.normalizationRange,
+ result
+ );
+
+ if (quantization.octEncodedZXY) {
+ const x = result.x;
+ result.x = result.z;
+ result.z = result.y;
+ result.y = x;
+ }
+ } else {
+ result = Cartesian3.multiplyComponents(
+ result,
+ quantization.quantizedVolumeStepSize,
+ result
+ );
+
+ result = Cartesian3.add(
+ result,
+ quantization.quantizedVolumeOffset,
+ result
+ );
+ }
+ }
+
+ result = Matrix4.multiplyByPoint(instanceTransform, result, result);
+
+ return result;
+}
diff --git a/packages/engine/Source/Scene/Multiple3DTileContent.js b/packages/engine/Source/Scene/Multiple3DTileContent.js
index cd62641172b4..42ede698a349 100644
--- a/packages/engine/Source/Scene/Multiple3DTileContent.js
+++ b/packages/engine/Source/Scene/Multiple3DTileContent.js
@@ -1,3 +1,4 @@
+import Cartesian3 from "../Core/Cartesian3.js";
import defined from "../Core/defined.js";
import destroyObject from "../Core/destroyObject.js";
import DeveloperError from "../Core/DeveloperError.js";
@@ -650,6 +651,47 @@ Multiple3DTileContent.prototype.update = function (tileset, frameState) {
}
};
+/**
+ * Find an intersection between a ray and the tile content 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 {Cartesian3|undefined} [result] The intersection or undefined if none was found.
+ * @returns {Cartesian3|undefined} The intersection or undefined if none was found.
+ *
+ * @private
+ */
+Multiple3DTileContent.prototype.pick = function (ray, frameState, result) {
+ if (!this._ready) {
+ return undefined;
+ }
+
+ let intersection;
+ let minDistance = Number.POSITIVE_INFINITY;
+ const contents = this._contents;
+ const length = contents.length;
+
+ for (let i = 0; i < length; ++i) {
+ const candidate = contents[i].pick(ray, frameState, result);
+
+ if (!defined(candidate)) {
+ continue;
+ }
+
+ const distance = Cartesian3.distance(ray.origin, candidate);
+ if (distance < minDistance) {
+ intersection = candidate;
+ minDistance = distance;
+ }
+ }
+
+ if (!defined(intersection)) {
+ return undefined;
+ }
+
+ return result;
+};
+
Multiple3DTileContent.prototype.isDestroyed = function () {
return false;
};
diff --git a/packages/engine/Source/Scene/Scene.js b/packages/engine/Source/Scene/Scene.js
index 59239949c591..40a6e81bea95 100644
--- a/packages/engine/Source/Scene/Scene.js
+++ b/packages/engine/Source/Scene/Scene.js
@@ -163,7 +163,6 @@ function Scene(options) {
this._globeTranslucencyState = new GlobeTranslucencyState();
this._primitives = new PrimitiveCollection();
this._groundPrimitives = new PrimitiveCollection();
- this._terrainTilesets = [];
this._globeHeight = undefined;
this._cameraUnderground = false;
@@ -3568,35 +3567,6 @@ function callAfterRenderFunctions(scene) {
functions.length = 0;
}
-/**
- * Allow camera collisions, if enabled for the camera, on a tileset surface
- * @param {Cesium3DTileset} tileset Tileset fo which to enable collision.
- */
-Scene.prototype.enableCollisionDetectionForTileset = function (tileset) {
- //>>includeStart('debug', pragmas.debug);
- Check.typeOf.object("tileset", tileset);
- //>>includeEnd('debug');
-
- this._terrainTilesets.push(tileset);
-};
-
-/**
- * Disallow camera collisions on a tileset surface
- * @param {Cesium3DTileset} tileset Tileset for which to disable collision.
- */
-Scene.prototype.disableCollisionDetectionForTileset = function (tileset) {
- //>>includeStart('debug', pragmas.debug);
- Check.typeOf.object("tileset", tileset);
- //>>includeEnd('debug');
-
- const i = this._terrainTilesets.indexOf(tileset);
- if (i === -1) {
- return;
- }
-
- this._terrainTilesets.splice(i, 1);
-};
-
function getGlobeHeight(scene) {
const camera = scene.camera;
const cartographic = camera.positionCartographic;
@@ -3623,14 +3593,17 @@ Scene.prototype.getHeight = function (cartographic, heightReference) {
heightReference === HeightReference.RELATIVE_TO_3D_TILE;
let maxHeight = Number.NEGATIVE_INFINITY;
+
if (!ignore3dTiles) {
- for (const tileset of this._terrainTilesets) {
- if (!tileset.show) {
+ const length = this.primitives.length;
+ for (let i = 0; i < length; ++i) {
+ const primitive = this.primitives.get(i);
+ if (!primitive.isCesium3DTileset || !primitive.enableCameraCollision) {
continue;
}
- const result = tileset.getHeight(cartographic, this);
- if (result > maxHeight) {
+ const result = primitive.getHeight(cartographic, this);
+ if (defined(result) && result > maxHeight) {
maxHeight = result;
}
}
diff --git a/packages/engine/Source/Scene/Tileset3DTileContent.js b/packages/engine/Source/Scene/Tileset3DTileContent.js
index 655f0e675ef1..41d1652453c1 100644
--- a/packages/engine/Source/Scene/Tileset3DTileContent.js
+++ b/packages/engine/Source/Scene/Tileset3DTileContent.js
@@ -168,6 +168,10 @@ Tileset3DTileContent.prototype.applyStyle = function (style) {};
Tileset3DTileContent.prototype.update = function (tileset, frameState) {};
+Tileset3DTileContent.prototype.pick = function (ray, frameState, result) {
+ return undefined;
+};
+
Tileset3DTileContent.prototype.isDestroyed = function () {
return false;
};
diff --git a/packages/engine/Source/Scene/Vector3DTileContent.js b/packages/engine/Source/Scene/Vector3DTileContent.js
index e191ede706a9..120a22db5801 100644
--- a/packages/engine/Source/Scene/Vector3DTileContent.js
+++ b/packages/engine/Source/Scene/Vector3DTileContent.js
@@ -727,6 +727,10 @@ Vector3DTileContent.prototype.update = function (tileset, frameState) {
}
};
+Vector3DTileContent.prototype.pick = function (ray, frameState, result) {
+ return undefined;
+};
+
Vector3DTileContent.prototype.getPolylinePositions = function (batchId) {
const polylines = this._polylines;
if (!defined(polylines)) {
diff --git a/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js b/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
index d6c708a9d12d..7877b3ac852b 100644
--- a/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
+++ b/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
@@ -41,12 +41,15 @@ import Resource from "../Core/Resource.js";
*/
async function createGooglePhotorealistic3DTileset(key, options) {
options = defaultValue(options, {});
- options.showCreditsOnScreen = true;
options.cacheBytes = defaultValue(options.cacheBytes, 1536 * 1024 * 1024);
options.maximumCacheOverflowBytes = defaultValue(
options.maximumCacheOverflowBytes,
1024 * 1024 * 1024
);
+ options.enableCameraCollision = defaultValue(
+ options.enableCameraCollision,
+ true
+ );
key = defaultValue(key, GoogleMaps.defaultApiKey);
if (!defined(key)) {
diff --git a/packages/engine/Specs/Core/EllipsoidRhumbLineSpec.js b/packages/engine/Specs/Core/EllipsoidRhumbLineSpec.js
index f56803e3f411..87157adea73d 100644
--- a/packages/engine/Specs/Core/EllipsoidRhumbLineSpec.js
+++ b/packages/engine/Specs/Core/EllipsoidRhumbLineSpec.js
@@ -13,6 +13,7 @@ describe("Core/EllipsoidRhumbLine", function () {
const fifteenDegrees = Math.PI / 12;
const thirtyDegrees = Math.PI / 6;
const fortyfiveDegrees = Math.PI / 4;
+ const threeHundredDegrees = (5 * Math.PI) / 6;
it("throws without start", function () {
expect(function () {
@@ -749,6 +750,46 @@ describe("Core/EllipsoidRhumbLine", function () {
);
});
+ it("interpolates when heading is near 90 degrees", function () {
+ const start = new Cartographic(0.0, 0.0);
+ const end = new Cartographic(Math.PI / 2, 0.0);
+ const expectedMid = new Cartographic(fortyfiveDegrees, 0.0);
+
+ const rhumb = new EllipsoidRhumbLine(start, end);
+ expect(rhumb.heading).toEqualEpsilon(Math.PI / 2, CesiumMath.EPSILON12);
+
+ const midpoint = rhumb.interpolateUsingFraction(0.5);
+
+ expect(expectedMid.longitude).toEqualEpsilon(
+ midpoint.longitude,
+ CesiumMath.EPSILON12
+ );
+ expect(expectedMid.latitude).toEqualEpsilon(
+ midpoint.latitude,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("interpolates when heading is near 0 degrees", function () {
+ const start = new Cartographic(-threeHundredDegrees, fifteenDegrees);
+ const end = new Cartographic(-threeHundredDegrees, fortyfiveDegrees);
+ const expectedMid = new Cartographic(-threeHundredDegrees, thirtyDegrees);
+
+ const rhumb = new EllipsoidRhumbLine(start, end);
+ expect(rhumb.heading).toEqualEpsilon(0, CesiumMath.EPSILON12);
+
+ const midpoint = rhumb.interpolateUsingFraction(0.5);
+
+ expect(expectedMid.longitude).toEqualEpsilon(
+ midpoint.longitude,
+ CesiumMath.EPSILON12
+ );
+ expect(expectedMid.latitude).toEqualEpsilon(
+ midpoint.latitude,
+ CesiumMath.EPSILON3
+ );
+ });
+
it("interpolates midpoint fraction using result parameter", function () {
const start = new Cartographic(fifteenDegrees, 0.0);
const end = new Cartographic(fortyfiveDegrees, 0.0);
diff --git a/packages/engine/Specs/Core/GoogleEarthEnterpriseTerrainProviderSpec.js b/packages/engine/Specs/Core/GoogleEarthEnterpriseTerrainProviderSpec.js
index 7847fe668050..8927fca15e42 100644
--- a/packages/engine/Specs/Core/GoogleEarthEnterpriseTerrainProviderSpec.js
+++ b/packages/engine/Specs/Core/GoogleEarthEnterpriseTerrainProviderSpec.js
@@ -314,7 +314,11 @@ describe("Core/GoogleEarthEnterpriseTerrainProvider", function () {
const promises = [];
return pollToPromise(function () {
let b = true;
- for (let i = 0; i < 10; ++i) {
+ for (
+ let i = 0;
+ i < RequestScheduler.maximumRequestsPerServer + 2;
+ ++i
+ ) {
b = b && terrainProvider.getTileDataAvailable(i, i, i);
}
return b && terrainProvider.getTileDataAvailable(1, 2, 3);
diff --git a/packages/engine/Specs/Core/sampleTerrainMostDetailedSpec.js b/packages/engine/Specs/Core/sampleTerrainMostDetailedSpec.js
index 3a55df6250dc..77635449b0d9 100644
--- a/packages/engine/Specs/Core/sampleTerrainMostDetailedSpec.js
+++ b/packages/engine/Specs/Core/sampleTerrainMostDetailedSpec.js
@@ -28,9 +28,9 @@ describe("Core/sampleTerrainMostDetailed", function () {
expect(positions[1].height).toBeLessThan(10000);
});
- it("should throw querying heights from Small Terrain", async function () {
+ it("should throw querying heights from terrain without availability", async function () {
const terrainProvider = await CesiumTerrainProvider.fromUrl(
- "https://s3.amazonaws.com/cesiumjs/smallTerrain"
+ "Data/CesiumTerrainTileJson/StandardHeightmap.tile.json"
);
const positions = [
diff --git a/packages/engine/Specs/Core/sampleTerrainSpec.js b/packages/engine/Specs/Core/sampleTerrainSpec.js
index 3369481f068d..c88c1a5ddff3 100644
--- a/packages/engine/Specs/Core/sampleTerrainSpec.js
+++ b/packages/engine/Specs/Core/sampleTerrainSpec.js
@@ -15,6 +15,11 @@ describe("Core/sampleTerrain", function () {
worldTerrain = await createWorldTerrainAsync();
});
+ afterEach(function () {
+ Resource._Implementations.loadWithXhr =
+ Resource._DefaultImplementations.loadWithXhr;
+ });
+
it("queries heights", function () {
const positions = [
Cartographic.fromDegrees(86.925145, 27.988257),
@@ -32,9 +37,42 @@ describe("Core/sampleTerrain", function () {
});
});
- it("queries heights from Small Terrain", async function () {
+ it("queries heights from terrain without availability", async function () {
+ // Mock terrain tile loading
+ Resource._Implementations.loadWithXhr = function (
+ url,
+ responseType,
+ method,
+ data,
+ headers,
+ deferred,
+ overrideMimeType
+ ) {
+ if (defined(url.match(/\/\d+\/\d+\/\d+\.terrain/))) {
+ Resource._DefaultImplementations.loadWithXhr(
+ "Data/CesiumTerrainTileJson/11_3027_1342.terrain",
+ responseType,
+ method,
+ data,
+ headers,
+ deferred
+ );
+ return;
+ }
+
+ Resource._DefaultImplementations.loadWithXhr(
+ url,
+ responseType,
+ method,
+ data,
+ headers,
+ deferred,
+ overrideMimeType
+ );
+ };
+
const terrainProvider = await CesiumTerrainProvider.fromUrl(
- "https://s3.amazonaws.com/cesiumjs/smallTerrain"
+ "Data/CesiumTerrainTileJson/StandardHeightmap.tile.json"
);
const positions = [
diff --git a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
index 2e3381f89d49..341c8e365a1d 100644
--- a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
+++ b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
@@ -46,6 +46,7 @@ import Cesium3DTilesTester from "../../../../Specs/Cesium3DTilesTester.js";
import createScene from "../../../../Specs/createScene.js";
import generateJsonBuffer from "../../../../Specs/generateJsonBuffer.js";
import pollToPromise from "../../../../Specs/pollToPromise.js";
+import Ellipsoid from "../../Source/Core/Ellipsoid.js";
describe(
"Scene/Cesium3DTileset",
@@ -2414,6 +2415,183 @@ describe(
});
});
+ it("picks", async function () {
+ const tileset = await Cesium3DTilesTester.loadTileset(scene, tilesetUrl, {
+ enablePick: !scene.frameState.context.webgl2,
+ });
+ viewRootOnly();
+ scene.renderForSpecs();
+
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(
+ 1215026.8094312553,
+ -4736367.339076743,
+ 4081652.238842398
+ );
+ expect(tileset.pick(ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("picks tileset of tilesets", async function () {
+ const tileset = await Cesium3DTilesTester.loadTileset(
+ scene,
+ tilesetOfTilesetsUrl,
+ {
+ enablePick: !scene.frameState.context.webgl2,
+ }
+ );
+ viewRootOnly();
+ scene.renderForSpecs();
+
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(
+ 1215026.8094312553,
+ -4736367.339076743,
+ 4081652.238842398
+ );
+ expect(tileset.pick(ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("picks instanced tileset", async function () {
+ const tileset = await Cesium3DTilesTester.loadTileset(
+ scene,
+ instancedUrl,
+ {
+ enablePick: !scene.frameState.context.webgl2,
+ }
+ );
+ viewInstances();
+ scene.renderForSpecs();
+
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(
+ 1215015.7820120894,
+ -4736324.352446682,
+ 4081615.004915994
+ );
+ expect(tileset.pick(ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("picks translucent tileset", async function () {
+ const tileset = await Cesium3DTilesTester.loadTileset(
+ scene,
+ translucentUrl,
+ {
+ enablePick: !scene.frameState.context.webgl2,
+ }
+ );
+ viewAllTiles();
+ scene.renderForSpecs();
+
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(
+ 1215013.1035421563,
+ -4736313.911345786,
+ 4081605.96109977
+ );
+ expect(tileset.pick(ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("picks tileset with transforms", async function () {
+ const tileset = await Cesium3DTilesTester.loadTileset(
+ scene,
+ tilesetWithTransformsUrl,
+ {
+ enablePick: !scene.frameState.context.webgl2,
+ }
+ );
+ viewAllTiles();
+ scene.renderForSpecs();
+
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(
+ 1215013.8353220497,
+ -4736316.763939952,
+ 4081608.4319443353
+ );
+ expect(tileset.pick(ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("picking point cloud tileset returns undefined", async function () {
+ const tileset = await Cesium3DTilesTester.loadTileset(
+ scene,
+ pointCloudUrl,
+ {
+ enablePick: !scene.frameState.context.webgl2,
+ }
+ );
+ viewAllTiles();
+ scene.renderForSpecs();
+
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ expect(tileset.pick(ray, scene.frameState)).toBeUndefined();
+ });
+
+ it("getHeight samples height at a cartographic position", async function () {
+ const tileset = await Cesium3DTilesTester.loadTileset(scene, tilesetUrl, {
+ enablePick: !scene.frameState.context.webgl2,
+ });
+ viewRootOnly();
+ await Cesium3DTilesTester.waitForTilesLoaded(scene, tileset);
+ scene.renderForSpecs();
+
+ const center = Ellipsoid.WGS84.cartesianToCartographic(
+ tileset.boundingSphere.center
+ );
+ const height = tileset.getHeight(center, scene);
+ expect(height).toEqualEpsilon(78.1558019795064, CesiumMath.EPSILON12);
+ });
+
it("destroys", function () {
return Cesium3DTilesTester.loadTileset(scene, tilesetUrl).then(function (
tileset
diff --git a/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js b/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js
index 129bb57b8cf0..9818f2534b2b 100644
--- a/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js
+++ b/packages/engine/Specs/Scene/GlobeSurfaceTileProviderSpec.js
@@ -12,6 +12,7 @@ import {
GeographicProjection,
HeadingPitchRoll,
Rectangle,
+ Resource,
WebMercatorProjection,
ContextLimits,
RenderState,
@@ -104,6 +105,8 @@ describe(
afterEach(function () {
scene.imageryLayers.removeAll();
scene.primitives.removeAll();
+ Resource._Implementations.loadWithXhr =
+ Resource._DefaultImplementations.loadWithXhr;
});
it("conforms to QuadtreeTileProvider interface", function () {
@@ -902,8 +905,41 @@ describe(
scene.imageryLayers.addImageryProvider(provider);
const terrainCredit = new Credit("terrain credit");
+
+ // Mock terrain tile loading
+ Resource._Implementations.loadWithXhr = function (
+ url,
+ responseType,
+ method,
+ data,
+ headers,
+ deferred,
+ overrideMimeType
+ ) {
+ if (defined(url.match(/\/\d+\/\d+\/\d+\.terrain/))) {
+ Resource._DefaultImplementations.loadWithXhr(
+ "Data/CesiumTerrainTileJson/tile.32bitIndices.terrain",
+ responseType,
+ method,
+ data,
+ headers,
+ deferred
+ );
+ return;
+ }
+
+ Resource._DefaultImplementations.loadWithXhr(
+ url,
+ responseType,
+ method,
+ data,
+ headers,
+ deferred,
+ overrideMimeType
+ );
+ };
scene.terrainProvider = await CesiumTerrainProvider.fromUrl(
- "https://s3.amazonaws.com/cesiumjs/smallTerrain",
+ "Data/CesiumTerrainTileJson/QuantizedMesh.tile.json",
{
credit: terrainCredit,
}
diff --git a/packages/engine/Specs/Scene/Model/ModelSpec.js b/packages/engine/Specs/Scene/Model/ModelSpec.js
index df62257eb949..a93f00370367 100644
--- a/packages/engine/Specs/Scene/Model/ModelSpec.js
+++ b/packages/engine/Specs/Scene/Model/ModelSpec.js
@@ -4392,6 +4392,28 @@ describe(
});
});
+ it("pick returns position of intersection between ray and model surface", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(0.5, 0, 0.5);
+ expect(model.pick(ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
it("destroy works", function () {
spyOn(ShaderProgram.prototype, "destroy").and.callThrough();
return loadAndZoomToModelAsync({ gltf: boxTexturedGlbUrl }, scene).then(
diff --git a/packages/engine/Specs/Scene/Model/pickModelSpec.js b/packages/engine/Specs/Scene/Model/pickModelSpec.js
new file mode 100644
index 000000000000..af89fd06907d
--- /dev/null
+++ b/packages/engine/Specs/Scene/Model/pickModelSpec.js
@@ -0,0 +1,365 @@
+import {
+ pickModel,
+ Cartesian2,
+ Cartesian3,
+ HeadingPitchRange,
+ Math as CesiumMath,
+ Model,
+ Ray,
+ SceneMode,
+} from "../../../index.js";
+
+import loadAndZoomToModelAsync from "./loadAndZoomToModelAsync.js";
+import createScene from "../../../../../Specs/createScene.js";
+
+describe("Scene/Model/pickModel", function () {
+ const boxTexturedGltfUrl =
+ "./Data/Models/glTF-2.0/BoxTextured/glTF/BoxTextured.gltf";
+ const boxInstanced =
+ "./Data/Models/glTF-2.0/BoxInstancedNoNormals/glTF/BoxInstancedNoNormals.gltf";
+ const boxWithOffsetUrl =
+ "./Data/Models/glTF-2.0/BoxWithOffset/glTF/BoxWithOffset.gltf";
+ const pointCloudUrl =
+ "./Data/Models/glTF-2.0/PointCloudWithRGBColors/glTF-Binary/PointCloudWithRGBColors.glb";
+ const boxWithMixedCompression =
+ "./Data/Models/glTF-2.0/BoxMixedCompression/glTF/BoxMixedCompression.gltf";
+ const boxWithQuantizedAttributes =
+ "./Data/Models/glTF-2.0/BoxWeb3dQuantizedAttributes/glTF/BoxWeb3dQuantizedAttributes.gltf";
+ const boxCesiumRtcUrl =
+ "./Data/Models/glTF-2.0/BoxCesiumRtc/glTF/BoxCesiumRtc.gltf";
+ const boxBackFaceCullingUrl =
+ "./Data/Models/glTF-2.0/BoxBackFaceCulling/glTF/BoxBackFaceCulling.gltf";
+
+ let scene;
+ beforeAll(function () {
+ scene = createScene();
+ });
+
+ afterAll(function () {
+ scene.destroyForSpecs();
+ });
+
+ afterEach(function () {
+ scene.frameState.mode = SceneMode.SCENE3D;
+ scene.primitives.removeAll();
+ });
+
+ it("throws without model", function () {
+ expect(() => pickModel()).toThrowDeveloperError();
+ });
+
+ it("throws without ray", async function () {
+ const model = await Model.fromGltfAsync({
+ url: boxTexturedGltfUrl,
+ });
+ expect(() => pickModel(model)).toThrowDeveloperError();
+ });
+
+ it("throws without frameState", async function () {
+ const model = await Model.fromGltfAsync({
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ });
+ const ray = new Ray();
+ expect(() => pickModel(model, ray)).toThrowDeveloperError();
+ });
+
+ it("returns undefined if model is not ready", async function () {
+ const model = await Model.fromGltfAsync({
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ });
+ const ray = new Ray();
+ expect(pickModel(model, ray, scene.frameState)).toBeUndefined();
+ });
+
+ it("returns undefined if ray does not intersect model surface", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = new Ray();
+ expect(pickModel(model, ray, scene.frameState)).toBeUndefined();
+ });
+
+ it("returns position of intersection between ray and model surface", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(0.5, 0, 0.5);
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("returns position of intersection between ray and model surface with enablePick in WebGL 1", async function () {
+ const sceneWithWebgl1 = createScene({
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxTexturedGltfUrl,
+ enablePick: true,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(0.5, 0, 0.5);
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+
+ sceneWithWebgl1.destroyForSpecs();
+ });
+
+ it("returns position of intersection accounting for node transforms", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxWithOffsetUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(0.0, 5.5, -0.5);
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("returns position of intersection with RTC model", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxCesiumRtcUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(6378137.5, 0.0, -0.499999996649);
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON8
+ );
+ });
+
+ it("returns position of intersection with quantzed model", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxWithQuantizedAttributes,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(0.5, 0, 0.5);
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("returns position of intersection with mixed compression model", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxWithMixedCompression,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(1.0, 0, 1.0);
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("returns position of intersection with instanced model", async function () {
+ // None of the 4 instanced cubes are in the center of the model's bounding
+ // sphere, so set up a camera view that focuses in on one of them.
+ const offset = new HeadingPitchRange(
+ CesiumMath.PI_OVER_TWO,
+ -CesiumMath.PI_OVER_FOUR,
+ 1
+ );
+
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxInstanced,
+ enablePick: !scene.frameState.context.webgl2,
+ offset,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const expected = new Cartesian3(0, -0.5, 0.5);
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("returns undefined for point cloud", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: pointCloudUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ expect(pickModel(model, ray, scene.frameState)).toBeUndefined();
+ });
+
+ it("cullsBackFaces by default", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+ ray.origin = model.boundingSphere.center;
+
+ expect(pickModel(model, ray, scene.frameState)).toBeUndefined();
+ });
+
+ it("includes back faces results when model disbales backface culling", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxBackFaceCullingUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ backFaceCulling: false,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ ray.origin = model.boundingSphere.center;
+
+ const expected = new Cartesian3(
+ -0.9999998807907355,
+ 0,
+ -0.9999998807907104
+ );
+ expect(pickModel(model, ray, scene.frameState)).toEqualEpsilon(
+ expected,
+ CesiumMath.EPSILON12
+ );
+ });
+
+ it("uses result parameter if specified", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ const result = new Cartesian3();
+ const expected = new Cartesian3(0.5, 0, 0.5);
+ const returned = pickModel(model, ray, scene.frameState, result);
+ expect(result).toEqualEpsilon(expected, CesiumMath.EPSILON12);
+ expect(returned).toBe(result);
+ });
+
+ it("returns undefined when morphing", async function () {
+ const model = await loadAndZoomToModelAsync(
+ {
+ url: boxTexturedGltfUrl,
+ enablePick: !scene.frameState.context.webgl2,
+ },
+ scene
+ );
+ const ray = scene.camera.getPickRay(
+ new Cartesian2(
+ scene.drawingBufferWidth / 2.0,
+ scene.drawingBufferHeight / 2.0
+ )
+ );
+
+ scene.frameState.mode = SceneMode.MORPHING;
+ expect(pickModel(model, ray, scene.frameState)).toBeUndefined();
+ });
+});
diff --git a/packages/engine/Specs/Scene/OctahedralProjectedCubeMapSpec.js b/packages/engine/Specs/Scene/OctahedralProjectedCubeMapSpec.js
index 4d888da1355d..2d13eba58fb1 100644
--- a/packages/engine/Specs/Scene/OctahedralProjectedCubeMapSpec.js
+++ b/packages/engine/Specs/Scene/OctahedralProjectedCubeMapSpec.js
@@ -208,7 +208,7 @@ describe(
});
});
- it("raises error event when environment map fails to load.", function () {
+ it("raises error event when environment map fails to load.", async function () {
if (!OctahedralProjectedCubeMap.isSupported(context)) {
return;
}
@@ -217,17 +217,22 @@ describe(
const frameState = createFrameState(context);
let error;
- const removeListener = projection.errorEvent.addEventListener((e) => {
- error = e;
- expect(error).toBeDefined();
- expect(projection.ready).toEqual(false);
- removeListener();
+ const promise = new Promise((resolve, reject) => {
+ const removeListener = projection.errorEvent.addEventListener((e) => {
+ error = e;
+ expect(error).toBeDefined();
+ expect(projection.ready).toEqual(false);
+ removeListener();
+ resolve();
+ });
});
- return pollToPromise(function () {
+ await pollToPromise(function () {
projection.update(frameState);
return defined(error);
});
+
+ return promise;
});
},
"WebGL"
diff --git a/packages/engine/Specs/test.mjs b/packages/engine/Specs/test.mjs
index 23f6bbf07cc3..1479b34b2dd2 100644
--- a/packages/engine/Specs/test.mjs
+++ b/packages/engine/Specs/test.mjs
@@ -1,9 +1,9 @@
-import { Cartographic, CesiumTerrainProvider, sampleTerrain } from "@cesium/engine";
+import { Cartographic, createWorldTerrainAsync, sampleTerrain } from "@cesium/engine";
import assert from "node:assert";
// NodeJS smoke screen test
async function test() {
- const provider = await CesiumTerrainProvider.fromUrl("https://s3.amazonaws.com/cesiumjs/smallTerrain");
+ const provider = await createWorldTerrainAsync();
const results = await sampleTerrain(provider, 11, [
Cartographic.fromDegrees(86.925145, 27.988257),
Cartographic.fromDegrees(87.0, 28.0),
diff --git a/packages/engine/package.json b/packages/engine/package.json
index 32a25763dcf6..ee1c7b7a0681 100644
--- a/packages/engine/package.json
+++ b/packages/engine/package.json
@@ -1,6 +1,6 @@
{
"name": "@cesium/engine",
- "version": "6.0.0",
+ "version": "6.1.1",
"description": "CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
"keywords": [
"3D",
@@ -45,7 +45,7 @@
"ktx-parse": "^0.6.0",
"lerc": "^2.0.0",
"mersenne-twister": "^1.1.0",
- "meshoptimizer": "^0.19.0",
+ "meshoptimizer": "^0.20.0",
"pako": "^2.0.4",
"protobufjs": "^7.1.0",
"rbush": "^3.0.1",
diff --git a/packages/widgets/package.json b/packages/widgets/package.json
index 6357fe6992d6..5b121d5c1689 100644
--- a/packages/widgets/package.json
+++ b/packages/widgets/package.json
@@ -1,6 +1,6 @@
{
"name": "@cesium/widgets",
- "version": "4.2.0",
+ "version": "4.3.1",
"description": "A widgets library for use with CesiumJS. CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
"keywords": [
"3D",
@@ -28,7 +28,7 @@
"node": ">=14.0.0"
},
"dependencies": {
- "@cesium/engine": "^6.0.0",
+ "@cesium/engine": "^6.1.1",
"nosleep.js": "^0.12.0"
},
"type": "module",