diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 376bc86d12b8..c39601d15129 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -14,7 +14,7 @@ jobs:
steps:
- name: message result in slack
id: slack
- uses: slackapi/slack-github-action@v1.27.0
+ uses: slackapi/slack-github-action@v2.0.0
env:
SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
with:
diff --git a/.vscode/cesiumjs.code-snippets b/.vscode/cesiumjs.code-snippets
new file mode 100644
index 000000000000..154d4b1ba084
--- /dev/null
+++ b/.vscode/cesiumjs.code-snippets
@@ -0,0 +1,44 @@
+{
+ // Place your workspace snippets here. Each snippet is defined under a snippet name and has a scope, prefix, body and
+ // description. Add comma separated ids of the languages where the snippet is applicable in the scope field. If scope
+ // is left empty or omitted, the snippet gets applied to all languages. The prefix is what is
+ // used to trigger the snippet and the body will be expanded and inserted. Possible variables are:
+ // $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders.
+ // Placeholders with the same ids are connected.
+ // Example:
+ // "Print to console": {
+ // "scope": "javascript,typescript",
+ // "prefix": "log",
+ // "body": [
+ // "console.log('$1');",
+ // "$2"
+ // ],
+ // "description": "Log output to console"
+ // }
+ "Debug Pragma": {
+ "scope": "javascript",
+ "prefix": "pragdebug",
+ "description": "Insert or wrap selection with debug pragma comments",
+ "body": [
+ "//>>includeStart('debug', pragmas.debug);",
+ "${TM_SELECTED_TEXT}$0",
+ "//>>includeEnd('debug')"
+ ]
+ },
+ "Check type": {
+ "prefix": "check",
+ "body": [
+ "Check.typeOf.${2:string}(\"${1:value}\", ${1:value});"
+ ],
+ "description": "Check Type of a variable"
+ },
+ "Check type if defined": {
+ "prefix": "checkifdef",
+ "body": [
+ "if (defined(${1:value})) {",
+ " Check.typeOf.${2:string}(\"${1:value}\", ${1:value});",
+ "}"
+ ],
+ "description": "Check type of a variable if it's defined"
+ }
+}
diff --git a/Apps/SampleData/tracking.czml b/Apps/SampleData/tracking.czml
new file mode 100644
index 000000000000..11fff8a3f146
--- /dev/null
+++ b/Apps/SampleData/tracking.czml
@@ -0,0 +1,4010 @@
+
+[
+ {
+ "id":"document",
+ "name":"tracking",
+ "version":"1.0",
+ "clock":{
+ "interval":"2012-03-15T10:00:00Z/2012-03-16T10:00:00Z",
+ "currentTime":"2012-03-15T10:00:00Z",
+ "range":"LOOP_STOP"
+ }
+ },
+ {
+ "id":"Satellite/ISS",
+ "name":"ISS",
+ "availability":"2012-03-15T10:00:00Z/2012-03-16T10:00:00Z",
+ "description":"\r\n
The International Space Station (ISS) is a space station, or a habitable artificial satellite in low Earth orbit. It is a modular structure whose first component was launched in 1998. Now the largest artificial body in orbit, it can often be seen at the appropriate time with the naked eye from Earth. The ISS consists of pressurised modules, external trusses, solar arrays and other components. ISS components have been launched by American Space Shuttles as well as Russian Proton and Soyuz rockets. In 1984 the ESA was invited to participate in Space Station Freedom. In 1993, after the USSR ended, the United States and Russia merged Mir-2 and Freedom together.\r\nThe ISS serves as a microgravity and space environment research laboratory in which crew members conduct experiments in biology, human biology, physics, astronomy, meteorology and other fields. The station is suited for the testing of spacecraft systems and equipment required for missions to the Moon and Mars.
\r\n\r\n
Since the arrival of Expedition 1 on 2 November 2000, the station has been continuously occupied for 13 years and 86 days, the longest continuous human presence in space. (In 2010, the station surpassed the previous record of almost 10 years (or 3,634 days) held by Mir.) The station is serviced by a variety of visiting spacecraft: Soyuz, Progress, the Automated Transfer Vehicle, the H-II Transfer Vehicle, Dragon, and Cygnus. It has been visited by astronauts and cosmonauts from 15 different nations.
\r\n\r\n
After the U.S. Space Shuttle program ended in 2011, Soyuz rockets became the only provider of transport for astronauts at the International Space Station.\r\nThe ISS programme is a joint project among five participating space agencies: NASA, Roskosmos, JAXA, ESA, and CSA. The ownership and use of the space station is established by intergovernmental treaties and agreements. The station is divided into two sections, the Russian Orbital Segment (ROS) and the United States Orbital Segment (USOS), which is shared by many nations. The ISS maintains an orbit with an altitude of between 330 km (205 mi) and 435 km (270 mi) by means of reboost manoeuvres using the engines of the Zvezda module or visiting spacecraft. It completes 15.410 orbits per day. The ISS is funded until 2024, and may operate until 2028. The Russian Federal Space Agency, Roskosmos (RKA) has proposed using the ISS to commission modules for a new space station, called OPSEK, before the remainder of the ISS is deorbited. ISS is the ninth space station to be inhabited by crews, following the Soviet and later Russian Salyut, Almaz, and Mir stations, and Skylab from the US.
+
+ Uncertainty information is stored as GPM metadata in the tiles.
+
+ The anchor points provide information about the low-frequency
+ error.
+ This error is visualized as ellipsoids.
+
+ The high-frequency error is represented as
+ Per-Point Error textures.
+ This error can be visualized with custom shaders. The 'uncertainty'
+ shaders visualize the horizontal or vertical uncertainty with a color
+ scale. The 'threshold' shaders highlight areas where the selected
+ error threshold is exceeded. Picking a point on the tileset will show
+ a label with the actual error values.
+
+
+
+
+
+
+
+
diff --git a/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.jpg b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.jpg
new file mode 100644
index 000000000000..5b2daea52ce0
Binary files /dev/null and b/Apps/Sandcastle/gallery/3D Tiles NGA GPM Visualization.jpg differ
diff --git a/Apps/Sandcastle/gallery/3D Tiles Vertical Exaggeration.html b/Apps/Sandcastle/gallery/3D Tiles Vertical Exaggeration.html
index 4e636b2f001c..41f67a60a1b6 100644
--- a/Apps/Sandcastle/gallery/3D Tiles Vertical Exaggeration.html
+++ b/Apps/Sandcastle/gallery/3D Tiles Vertical Exaggeration.html
@@ -78,6 +78,7 @@
Loading...
animation: false,
sceneModePicker: false,
baseLayerPicker: false,
+ geocoder: Cesium.IonGeocodeProviderType.GOOGLE,
// The globe does not need to be displayed,
// since the Photorealistic 3D Tiles include terrain
globe: false,
@@ -104,7 +105,10 @@
Loading...
// Add Photorealistic 3D Tiles
try {
- const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+ const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ // Only the Google Geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of the viewer constructor options to IonGeocodeProviderType.GOOGLE.
+ onlyUsingWithGoogleGeocoder: true,
+ });
scene.primitives.add(tileset);
} catch (error) {
console.log(`Error loading Photorealistic 3D Tiles tileset.
diff --git a/Apps/Sandcastle/gallery/AEC Architectural Design.html b/Apps/Sandcastle/gallery/AEC Architectural Design.html
new file mode 100644
index 000000000000..a1aff825bb57
--- /dev/null
+++ b/Apps/Sandcastle/gallery/AEC Architectural Design.html
@@ -0,0 +1,250 @@
+
+
+
+
+
+
+
+
+
+ Cesium Demo
+
+
+
+
+
+
+
+
Loading...
+
+
+
+
diff --git a/Apps/Sandcastle/gallery/AEC Architectural Design.jpg b/Apps/Sandcastle/gallery/AEC Architectural Design.jpg
new file mode 100644
index 000000000000..e6753bb4f5c9
Binary files /dev/null and b/Apps/Sandcastle/gallery/AEC Architectural Design.jpg differ
diff --git a/Apps/Sandcastle/gallery/AEC Clipping.html b/Apps/Sandcastle/gallery/AEC Clipping.html
index 0fa60bf14964..d373bd2a589a 100644
--- a/Apps/Sandcastle/gallery/AEC Clipping.html
+++ b/Apps/Sandcastle/gallery/AEC Clipping.html
@@ -32,6 +32,7 @@
animation: false,
sceneModePicker: false,
baseLayerPicker: false,
+ geocoder: Cesium.IonGeocodeProviderType.GOOGLE,
// The globe does not need to be displayed,
// since the Photorealistic 3D Tiles include terrain
globe: false,
@@ -48,7 +49,10 @@
// Add Photorealistic 3D Tiles
let googleTileset;
try {
- googleTileset = await Cesium.createGooglePhotorealistic3DTileset();
+ googleTileset = await Cesium.createGooglePhotorealistic3DTileset({
+ // Only the Google Geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of the viewer constructor options to IonGeocodeProviderType.GOOGLE.
+ onlyUsingWithGoogleGeocoder: true,
+ });
viewer.scene.primitives.add(googleTileset);
} catch (error) {
console.log(`Error loading Photorealistic 3D Tiles tileset.
diff --git a/Apps/Sandcastle/gallery/AEC Isolate by Category.html b/Apps/Sandcastle/gallery/AEC Isolate by Category.html
new file mode 100644
index 000000000000..70170c1c7fc6
--- /dev/null
+++ b/Apps/Sandcastle/gallery/AEC Isolate by Category.html
@@ -0,0 +1,165 @@
+
+
+
+
+
+
+
+
+
+ Cesium Demo
+
+
+
+
+
+
+
+
Loading...
+
+
+
+
diff --git a/Apps/Sandcastle/gallery/AEC Isolate by Category.jpg b/Apps/Sandcastle/gallery/AEC Isolate by Category.jpg
new file mode 100644
index 000000000000..81f2db7cedf7
Binary files /dev/null and b/Apps/Sandcastle/gallery/AEC Isolate by Category.jpg differ
diff --git a/Apps/Sandcastle/gallery/AEC Metadata Styling.html b/Apps/Sandcastle/gallery/AEC Metadata Styling.html
new file mode 100644
index 000000000000..ff8dd8fe0cc6
--- /dev/null
+++ b/Apps/Sandcastle/gallery/AEC Metadata Styling.html
@@ -0,0 +1,205 @@
+
+
+
+
+
+
+
+
+
+ Cesium Demo
+
+
+
+
+
+
+
+
@@ -106,7 +106,11 @@
//Sandcastle_Begin
const viewer = new Cesium.Viewer("cesiumContainer");
- viewer.clock.currentTime = Cesium.JulianDate.fromIso8601("2022-08-01T00:00:00Z");
+ const { canvas, camera, clock, scene } = viewer;
+ camera.frustum.near = 1.0;
+ scene.debugShowFramesPerSecond = true;
+
+ clock.currentTime = Cesium.JulianDate.fromIso8601("2022-08-01T00:00:00Z");
if (!Cesium.PostProcessStageLibrary.isAmbientOcclusionSupported(viewer.scene)) {
window.alert(
@@ -119,9 +123,9 @@
ambientOcclusionOnly: false,
intensity: 3.0,
bias: 0.1,
- lengthCap: 0.03,
- stepSize: 1.0,
- blurStepSize: 0.86,
+ lengthCap: 0.26,
+ directionCount: 8,
+ stepCount: 32,
};
Cesium.knockout.track(viewModel);
@@ -134,7 +138,7 @@
}
function updatePostProcess() {
- const ambientOcclusion = viewer.scene.postProcessStages.ambientOcclusion;
+ const ambientOcclusion = scene.postProcessStages.ambientOcclusion;
ambientOcclusion.enabled =
Boolean(viewModel.show) || Boolean(viewModel.ambientOcclusionOnly);
ambientOcclusion.uniforms.ambientOcclusionOnly = Boolean(
@@ -143,12 +147,11 @@
ambientOcclusion.uniforms.intensity = Number(viewModel.intensity);
ambientOcclusion.uniforms.bias = Number(viewModel.bias);
ambientOcclusion.uniforms.lengthCap = Number(viewModel.lengthCap);
- ambientOcclusion.uniforms.stepSize = Number(viewModel.stepSize);
- ambientOcclusion.uniforms.blurStepSize = Number(viewModel.blurStepSize);
+ ambientOcclusion.uniforms.directionCount = Number(viewModel.directionCount);
+ ambientOcclusion.uniforms.stepCount = Number(viewModel.stepCount);
}
updatePostProcess();
- const camera = viewer.scene.camera;
camera.position = new Cesium.Cartesian3(
1234127.2294710164,
-5086011.666443127,
@@ -173,7 +176,7 @@
try {
// Power Plant design model provided by Bentley Systems
const tileset = await Cesium.Cesium3DTileset.fromIonAssetId(2464651);
- viewer.scene.primitives.add(tileset);
+ scene.primitives.add(tileset);
} catch (error) {
console.log(`Error loading tileset: ${error}`);
} //Sandcastle_End
diff --git a/Apps/Sandcastle/gallery/Bing Maps Labels Only.html b/Apps/Sandcastle/gallery/Bing Maps Labels Only.html
index f4c12739f24f..7f92188196ba 100644
--- a/Apps/Sandcastle/gallery/Bing Maps Labels Only.html
+++ b/Apps/Sandcastle/gallery/Bing Maps Labels Only.html
@@ -67,6 +67,7 @@
baseLayer: false,
baseLayerPicker: false,
infoBox: false,
+ geocoder: Cesium.IonGeocodeProviderType.BING,
});
const layers = viewer.imageryLayers;
diff --git a/Apps/Sandcastle/gallery/Callback Position Property.html b/Apps/Sandcastle/gallery/Callback Position Property.html
index 272509b8b934..4786dfd84822 100644
--- a/Apps/Sandcastle/gallery/Callback Position Property.html
+++ b/Apps/Sandcastle/gallery/Callback Position Property.html
@@ -134,7 +134,7 @@
}
// Create the entity and bind its position to the callback position property
- viewer.entities.add({
+ const entity = viewer.entities.add({
availability: new Cesium.TimeIntervalCollection([
new Cesium.TimeInterval({
start: start,
@@ -158,35 +158,11 @@
leadTime: 1,
trailTime: 0.1,
},
+ trackingReferenceFrame: Cesium.TrackingReferenceFrame.INERTIAL,
+ viewFrom: new Cesium.Cartesian3(-100, 0, 10),
});
- const camera = viewer.camera;
- const scene = viewer.scene;
-
- const scratchPosition = new Cesium.Cartesian3();
- const scratchOrientation = new Cesium.Quaternion();
- const scratchTransform = new Cesium.Matrix4();
- const offset = new Cesium.Cartesian3(-100, 0, 10);
-
- // Update camera to follow entity's position and orientation
- viewer.clock.onTick.addEventListener(function (clock) {
- if (scene.mode === Cesium.Scene.MORPHING) {
- return;
- }
- const time = clock.currentTime;
- const entityPosition = position.getValue(time, scratchPosition);
- const entityOrientation = orientation.getValue(time, scratchOrientation);
- if (entityPosition === undefined || entityOrientation === undefined) {
- return;
- }
- const transform = Cesium.Matrix4.fromTranslationQuaternionRotationScale(
- entityPosition,
- entityOrientation,
- Cesium.Cartesian3.ONE,
- scratchTransform,
- );
- camera.lookAtTransform(transform, offset);
- });
+ viewer.trackedEntity = entity;
//Sandcastle_End
};
if (typeof Cesium !== "undefined") {
diff --git a/Apps/Sandcastle/gallery/Clamp Entities to Ground.html b/Apps/Sandcastle/gallery/Clamp Entities to Ground.html
index 0a048fbe0d93..e38e8709c464 100644
--- a/Apps/Sandcastle/gallery/Clamp Entities to Ground.html
+++ b/Apps/Sandcastle/gallery/Clamp Entities to Ground.html
@@ -41,6 +41,7 @@
timeline: false,
animation: false,
baseLayerPicker: false,
+ geocoder: Cesium.IonGeocodeProviderType.GOOGLE,
});
const scene = viewer.scene;
scene.globe.depthTestAgainstTerrain = true;
@@ -56,7 +57,10 @@
let worldTileset;
try {
- worldTileset = await Cesium.createGooglePhotorealistic3DTileset();
+ worldTileset = await Cesium.createGooglePhotorealistic3DTileset({
+ // Only the Google Geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of the viewer constructor options to IonGeocodeProviderType.GOOGLE.
+ onlyUsingWithGoogleGeocoder: true,
+ });
viewer.scene.primitives.add(worldTileset);
} catch (error) {
console.log(`Error loading Photorealistic 3D Tiles tileset.
diff --git a/Apps/Sandcastle/gallery/Clipping Regions.html b/Apps/Sandcastle/gallery/Clipping Regions.html
index 97dba26b3ce9..f56a5c886b27 100644
--- a/Apps/Sandcastle/gallery/Clipping Regions.html
+++ b/Apps/Sandcastle/gallery/Clipping Regions.html
@@ -43,6 +43,7 @@
animation: false,
sceneModePicker: false,
baseLayerPicker: false,
+ geocoder: Cesium.IonGeocodeProviderType.GOOGLE,
});
const scene = viewer.scene;
@@ -60,7 +61,10 @@
let worldTileset;
try {
- worldTileset = await Cesium.createGooglePhotorealistic3DTileset();
+ worldTileset = await Cesium.createGooglePhotorealistic3DTileset({
+ // Only the Google Geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of the viewer constructor options to IonGeocodeProviderType.GOOGLE.
+ onlyUsingWithGoogleGeocoder: true,
+ });
scene.primitives.add(worldTileset);
} catch (error) {
console.log(`Error loading Photorealistic 3D Tiles tileset.
diff --git a/Apps/Sandcastle/gallery/Entity tracking.html b/Apps/Sandcastle/gallery/Entity tracking.html
new file mode 100644
index 000000000000..6e894c642e9d
--- /dev/null
+++ b/Apps/Sandcastle/gallery/Entity tracking.html
@@ -0,0 +1,117 @@
+
+
+
+
+
+
+
+
+ Cesium Demo
+
+
+
+
+
+
+
+
Loading...
+
+
+
+
diff --git a/Apps/Sandcastle/gallery/Entity tracking.jpg b/Apps/Sandcastle/gallery/Entity tracking.jpg
new file mode 100644
index 000000000000..4fe477db6de5
Binary files /dev/null and b/Apps/Sandcastle/gallery/Entity tracking.jpg differ
diff --git a/Apps/Sandcastle/gallery/Globe Interior.html b/Apps/Sandcastle/gallery/Globe Interior.html
index 0deb07a51e34..9a4ff467d784 100644
--- a/Apps/Sandcastle/gallery/Globe Interior.html
+++ b/Apps/Sandcastle/gallery/Globe Interior.html
@@ -34,6 +34,7 @@
//Sandcastle_Begin
const viewer = new Cesium.Viewer("cesiumContainer", {
orderIndependentTranslucency: false,
+ geocoder: Cesium.IonGeocodeProviderType.BING,
});
const scene = viewer.scene;
diff --git a/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles with Building Insert.html b/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles with Building Insert.html
index 6437a2fb7c19..a75c993a8afa 100644
--- a/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles with Building Insert.html
+++ b/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles with Building Insert.html
@@ -32,6 +32,7 @@
animation: false,
sceneModePicker: false,
baseLayerPicker: false,
+ geocoder: Cesium.IonGeocodeProviderType.GOOGLE,
// The globe does not need to be displayed,
// since the Photorealistic 3D Tiles include terrain
globe: false,
@@ -42,7 +43,10 @@
// Add Photorealistic 3D Tiles
try {
- const googleTileset = await Cesium.createGooglePhotorealistic3DTileset();
+ const googleTileset = await Cesium.createGooglePhotorealistic3DTileset({
+ // Only the Google Geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of the viewer constructor options to IonGeocodeProviderType.GOOGLE.
+ onlyUsingWithGoogleGeocoder: true,
+ });
viewer.scene.primitives.add(googleTileset);
} catch (error) {
console.log(`Error loading Photorealistic 3D Tiles tileset.
diff --git a/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles.html b/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles.html
index d4d68c1c97d6..2f9da653dc9c 100644
--- a/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles.html
+++ b/Apps/Sandcastle/gallery/Google Photorealistic 3D Tiles.html
@@ -32,6 +32,7 @@
animation: false,
sceneModePicker: false,
baseLayerPicker: false,
+ geocoder: Cesium.IonGeocodeProviderType.GOOGLE,
// The globe does not need to be displayed,
// since the Photorealistic 3D Tiles include terrain
globe: false,
@@ -42,7 +43,10 @@
// Add Photorealistic 3D Tiles
try {
- const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+ const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ // Only the Google Geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of the viewer constructor options to IonGeocodeProviderType.GOOGLE.
+ onlyUsingWithGoogleGeocoder: true,
+ });
viewer.scene.primitives.add(tileset);
} catch (error) {
console.log(`Error loading Photorealistic 3D Tiles tileset.
diff --git a/Apps/Sandcastle/gallery/Imagery Color To Alpha.html b/Apps/Sandcastle/gallery/Imagery Color To Alpha.html
index 8fa3ed032883..c28533a3c4a9 100644
--- a/Apps/Sandcastle/gallery/Imagery Color To Alpha.html
+++ b/Apps/Sandcastle/gallery/Imagery Color To Alpha.html
@@ -51,7 +51,9 @@
window.startup = async function (Cesium) {
"use strict";
//Sandcastle_Begin
- const viewer = new Cesium.Viewer("cesiumContainer");
+ const viewer = new Cesium.Viewer("cesiumContainer", {
+ geocoder: Cesium.IonGeocodeProviderType.BING,
+ });
const layers = viewer.scene.imageryLayers;
diff --git a/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html b/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html
index 4e309a339dd7..9b1f026cdbab 100644
--- a/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html
+++ b/Apps/Sandcastle/gallery/Imagery Layers Manipulation.html
@@ -106,6 +106,7 @@
//Sandcastle_Begin
const viewer = new Cesium.Viewer("cesiumContainer", {
baseLayerPicker: false,
+ geocoder: false,
});
const imageryLayers = viewer.imageryLayers;
diff --git a/Apps/Sandcastle/gallery/Imagery Layers Split.html b/Apps/Sandcastle/gallery/Imagery Layers Split.html
index 37927116fc29..15375661bb5f 100644
--- a/Apps/Sandcastle/gallery/Imagery Layers Split.html
+++ b/Apps/Sandcastle/gallery/Imagery Layers Split.html
@@ -58,6 +58,7 @@
),
baseLayerPicker: false,
infoBox: false,
+ geocoder: false,
});
const layers = viewer.imageryLayers;
diff --git a/Apps/Sandcastle/gallery/Interpolation.html b/Apps/Sandcastle/gallery/Interpolation.html
index d0559b27d7a8..f21a5dd259c3 100644
--- a/Apps/Sandcastle/gallery/Interpolation.html
+++ b/Apps/Sandcastle/gallery/Interpolation.html
@@ -154,6 +154,21 @@
viewer.trackedEntity = entity;
});
+ Sandcastle.addToolbarMenu([
+ {
+ text: "Tracking reference frame: East-North-Up",
+ onselect: function () {
+ entity.trackingReferenceFrame = Cesium.TrackingReferenceFrame.ENU;
+ },
+ },
+ {
+ text: "Tracking reference frame: Inertial",
+ onselect: function () {
+ entity.trackingReferenceFrame = Cesium.TrackingReferenceFrame.INERTIAL;
+ },
+ },
+ ]);
+
//Add a combo box for selecting each interpolation mode.
Sandcastle.addToolbarMenu(
[
diff --git a/Apps/Sandcastle/gallery/development/3D Tiles Picking.html b/Apps/Sandcastle/gallery/development/3D Tiles Picking.html
index 10c3b2367a66..ce77a1cc5f35 100644
--- a/Apps/Sandcastle/gallery/development/3D Tiles Picking.html
+++ b/Apps/Sandcastle/gallery/development/3D Tiles Picking.html
@@ -34,6 +34,7 @@
animation: false,
baseLayerPicker: false,
globe: false,
+ geocoder: false,
});
const scene = viewer.scene;
@@ -44,7 +45,10 @@
onselect: async () => {
scene.primitives.remove(tileset);
try {
- tileset = await Cesium.createGooglePhotorealistic3DTileset();
+ tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ // Only the Google Geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of the viewer constructor options to IonGeocodeProviderType.GOOGLE.
+ onlyUsingWithGoogleGeocoder: true,
+ });
scene.primitives.add(tileset);
} catch (error) {
console.log(error);
diff --git a/Apps/Sandcastle/gallery/iModel Mesh Export Service.html b/Apps/Sandcastle/gallery/iModel Mesh Export Service.html
new file mode 100644
index 000000000000..b445ff763ad7
--- /dev/null
+++ b/Apps/Sandcastle/gallery/iModel Mesh Export Service.html
@@ -0,0 +1,322 @@
+
+
+
+
+
+
+
+
+ iModel Mesh Export Service
+
+
+
+
+
+
+
Loading...
+
+
+
+
+
+
+
+
diff --git a/Apps/Sandcastle/gallery/iModel Mesh Export Service.jpg b/Apps/Sandcastle/gallery/iModel Mesh Export Service.jpg
new file mode 100644
index 000000000000..ec74f8279e2b
Binary files /dev/null and b/Apps/Sandcastle/gallery/iModel Mesh Export Service.jpg differ
diff --git a/CHANGES.md b/CHANGES.md
index 0cdd0ec2e29c..c2fad0a5d1c1 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,56 @@
# Change Log
+### 1.124 - 2024-12-02
+
+#### @cesium/engine
+
+##### Additions :tada:
+
+- Added an integration with the [iTwin Platform](https://developer.bentley.com/) to load iModels as 3D Tiles. Use `ITwinPlatform.defaultAccessToken` to set the access token. Use `ITwinData.createTilesetFromIModelId(iModelId)` to load the iModel as a `Cesium3DTileset`. [#12289](https://github.com/CesiumGS/cesium/pull/12289)
+- Added `getSample` to `SampledProperty` to get the time of samples. [#12253](https://github.com/CesiumGS/cesium/pull/12253)
+- Added `Entity.trackingReferenceFrame` property to allow tracking entities in various reference frames. [#12194](https://github.com/CesiumGS/cesium/pull/12194), [#12314](https://github.com/CesiumGS/cesium/pull/12314)
+ - `TrackingReferenceFrame.AUTODETECT` (default): uses either VVLH or ENU depending on entity's dynamic. Use `TrackingReferenceFrame.ENU` if your camera orientation flips abruptly from time to time.
+ - `TrackingReferenceFrame.ENU`: uses the entity's local East-North-Up reference frame.
+ - `TrackingReferenceFrame.INERTIAL`: uses the entity's inertial reference frame.
+ - `TrackingReferenceFrame.VELOCITY`: uses entity's `VelocityOrientationProperty` as orientation.
+- Added `GoogleGeocoderService` for standalone usage of Google geocoder. [#12299](https://github.com/CesiumGS/cesium/pull/12299)
+
+##### Breaking Changes :mega:
+
+- `PostProcessStageCollection.ambientOcclusion` has been updated with a new algorithm to provide better results at all scales, with tunable performance cost. To approximate the appearance and performance of the old algorithm, set the following values for `scene.postProcessStages.ambientOcclusion.uniforms`: `{ lengthCap: 0.02, directionCount: 6, stepCount: 8 }`. For best results at long distances, consider setting `Viewer.camera.frustum.near` to `1.0` or more, to improve precision in the depth buffer. [#12316](https://github.com/CesiumGS/cesium/pull/12316)
+- `Rectangle.validate` has been removed.
+
+##### Fixes :wrench:
+
+- Fixed bug where shared external textures from glTF files were not accounted for in resource statistics. [#12331](https://github.com/CesiumGS/cesium/pull/12331)
+- Fixed lag or crashes when loading many models in the same frame. [#12320](https://github.com/CesiumGS/cesium/pull/12320)
+- Fix point cloud filtering performance on certain hardware [#12317](https://github.com/CesiumGS/cesium/pull/12317)
+- Fix label rendering bug in WebGL1 contexts. [#12301](https://github.com/CesiumGS/cesium/pull/12301)
+- Updated WMS example URL in UrlTemplateImageryProvider documentation to use an active service. [#12323](https://github.com/CesiumGS/cesium/pull/12323)
+
+##### Deprecated :hourglass_flowing_sand:
+
+- `createGooglePhotorealistic3DTileset(key)` has been deprecated. Use `createGooglePhotorealistic3DTileset({key})` instead. It will be removed in 1.126.
+
+#### @cesium/widgets
+
+##### Additions :tada:
+
+- Added the ability to choose between Bing and Google geocoders. Updated `Viewer` constructor to also accept `IonGeocoderProvider` [#12299](https://github.com/CesiumGS/cesium/pull/12299)
+
+##### Fixes :wrench:
+
+- Added a `DeveloperError` when `globe` is set to `false` and a `baseLayer` is provided in `Viewer` options. This prevents errors caused by attempting to use a `baseLayer` without a globe. [#12274](https://github.com/CesiumGS/cesium/pull/12274)
+
+### 1.123.1 - 2024-11-07
+
+#### @cesium/engine
+
+##### Additions :tada:
+
+- Added fallback diffuse lighting, `DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS`, that is used when `DynamicEnvironmentMapManager` is disabled or unsupported. [#12292](https://github.com/CesiumGS/cesium/pull/12292)
+- Added `DynamicEnvironmentMapManager.isDynamicUpdateSupported` to check if dynamic environment map updates are supported. [#12292](https://github.com/CesiumGS/cesium/pull/12292)
+
### 1.123 - 2024-11-01
#### @cesium/engine
@@ -37,9 +88,12 @@
- Fix flickering issue caused by bounding sphere retrieval being blocked by the bounding sphere of another entity. [#12230](https://github.com/CesiumGS/cesium/pull/12230)
- Fixed `ImageBasedLighting.imageBasedLightingFactor` not affecting lighting. [#12129](https://github.com/CesiumGS/cesium/pull/12129)
-
- Fix error with normalization of corner points for lines and corridors with collinear points. [#12255](https://github.com/CesiumGS/cesium/pull/12255)
+##### Fixes :wrench:
+
+- Properly handle `offset` and `scale` properties when picking metadata from property textures. [#12237](https://github.com/CesiumGS/cesium/pull/12237)
+
### 1.122 - 2024-10-01
#### @cesium/engine
diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 5bd6a8a5cdaf..bc8598aeda78 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -168,6 +168,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
- [Siddhesh Ranade](https://github.com/siddheshranade)
- [Adam Morris](https://github.com/weegeekps)
- [Luke McKinstry](https://github.com/lukemckinstry)
+ - [Ryan Veenstra](https://github.com/r-veenstra)
- [Northrop Grumman](http://www.northropgrumman.com)
- [Joseph Stein](https://github.com/nahgrin)
- [EOX IT Services GmbH](https://eox.at)
@@ -414,4 +415,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to Cesiu
- [Adam Wirth](https://github.com/adamwirth)
- [Javier Sanchez](https://github.com/jvrjsanchez)
- [Jérôme Fayot](https://github.com/jfayot)
+- [Michael Nusair](https://github.com/mnpcmw6444)
- [Kirn Kim](https://github.com/squrki)
+- [Emanuele Mastaglia](https://github.com/Masty88)
+- [Connor Manning](https://github.com/connormanning)
diff --git a/Documentation/Contributors/VSCodeGuide/README.md b/Documentation/Contributors/VSCodeGuide/README.md
index c759beb8da91..51d4931c6c3c 100644
--- a/Documentation/Contributors/VSCodeGuide/README.md
+++ b/Documentation/Contributors/VSCodeGuide/README.md
@@ -46,6 +46,10 @@ restart VSCode after you are done installing extensions.
- **[Shader languages support for VS Code](https://marketplace.visualstudio.com/items?itemName=slevesque.shader)** by slevesque - This extension provides syntax highlighting for CesiumJS's shader code.
- **[glTF Extension for VS Code](https://marketplace.visualstudio.com/items?itemName=cesium.gltf-vscode)** by CesiumJS.org - This extension adds features for previewing and editing 3D models in glTF files.
+## Snippets
+
+We have a small (but growing) collection of snippets to make it easier to write code in CesiumJS. For example, `pragdebug` which will expand to the debug pragma we use to strip out code in production builds. These are stored in `.vscode/cesiumjs.code-snippets`. Refer to that file for the full list available and feel free to add to it for common code constructs you find yourself writing.
+
## VSCode Tasks and Files
You can launch any of CesiumJS's npm tasks from within VSCode by pressing
diff --git a/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-0.glb b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-0.glb
new file mode 100644
index 000000000000..084e4ffb427b
Binary files /dev/null and b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-0.glb differ
diff --git a/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-1.glb b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-1.glb
new file mode 100644
index 000000000000..e322a254caeb
Binary files /dev/null and b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-1.glb differ
diff --git a/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-2.glb b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-2.glb
new file mode 100644
index 000000000000..9463bfd11fbf
Binary files /dev/null and b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-2.glb differ
diff --git a/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-3.glb b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-3.glb
new file mode 100644
index 000000000000..05df860076b5
Binary files /dev/null and b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/plane-3.glb differ
diff --git a/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/texture0.png b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/texture0.png
new file mode 100644
index 000000000000..6c7e5ee581b0
Binary files /dev/null and b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/texture0.png differ
diff --git a/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/texture1.png b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/texture1.png
new file mode 100644
index 000000000000..97288521cd3c
Binary files /dev/null and b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/texture1.png differ
diff --git a/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/tileset.json b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/tileset.json
new file mode 100644
index 000000000000..280e75b7b61d
--- /dev/null
+++ b/Specs/Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/tileset.json
@@ -0,0 +1,116 @@
+{
+ "asset": {
+ "version": "1.1"
+ },
+ "geometricError": 4096,
+ "root": {
+ "boundingVolume": {
+ "box": [
+ 3.5,
+ 0,
+ 0.5,
+ 3.5,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.5
+ ]
+ },
+ "geometricError": 1024,
+ "children": [
+ {
+ "boundingVolume": {
+ "box": [
+ 0.5,
+ 0,
+ 0.5,
+ 0.5,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.5
+ ]
+ },
+ "geometricError": 512,
+ "content": {
+ "uri": "plane-0.glb"
+ }
+ },
+ {
+ "boundingVolume": {
+ "box": [
+ 2.5,
+ 0,
+ 0.5,
+ 0.5,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.5
+ ]
+ },
+ "geometricError": 512,
+ "content": {
+ "uri": "plane-1.glb"
+ }
+ },
+ {
+ "boundingVolume": {
+ "box": [
+ 4.5,
+ 0,
+ 0.5,
+ 0.5,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.5
+ ]
+ },
+ "geometricError": 512,
+ "content": {
+ "uri": "plane-2.glb"
+ }
+ },
+ {
+ "boundingVolume": {
+ "box": [
+ 6.5,
+ 0,
+ 0.5,
+ 0.5,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0.5
+ ]
+ },
+ "geometricError": 512,
+ "content": {
+ "uri": "plane-3.glb"
+ }
+ }
+ ],
+ "refine": "ADD"
+ }
+}
\ No newline at end of file
diff --git a/ThirdParty.json b/ThirdParty.json
index 99be04b43dfc..ed72a070a4c1 100644
--- a/ThirdParty.json
+++ b/ThirdParty.json
@@ -44,7 +44,7 @@
"license": [
"Apache-2.0"
],
- "version": "3.1.7",
+ "version": "3.2.2",
"url": "https://www.npmjs.com/package/dompurify",
"notes": "dompurify is available as both MPL-2.0 OR Apache-2.0"
},
@@ -77,7 +77,7 @@
"license": [
"MIT"
],
- "version": "1.3.9",
+ "version": "1.4.0",
"url": "https://www.npmjs.com/package/jsep"
},
{
diff --git a/package.json b/package.json
index 9ed3be76bceb..5f1ed19eb0bd 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "cesium",
- "version": "1.123.0",
+ "version": "1.124.0",
"description": "CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
"homepage": "http://cesium.com/cesiumjs/",
"license": "Apache-2.0",
@@ -51,8 +51,8 @@
"./Specs/**/*"
],
"dependencies": {
- "@cesium/engine": "^12.0.0",
- "@cesium/widgets": "^9.0.0"
+ "@cesium/engine": "^13.0.0",
+ "@cesium/widgets": "^10.0.0"
},
"devDependencies": {
"@playwright/test": "^1.41.1",
@@ -90,7 +90,7 @@
"karma-safari-launcher": "^1.0.0",
"karma-sourcemap-loader": "^0.4.0",
"karma-spec-reporter": "^0.0.36",
- "markdownlint-cli": "^0.42.0",
+ "markdownlint-cli": "^0.43.0",
"merge-stream": "^2.0.0",
"mkdirp": "^3.0.1",
"node-fetch": "^3.2.10",
@@ -159,4 +159,4 @@
"packages/engine",
"packages/widgets"
]
-}
\ No newline at end of file
+}
diff --git a/packages/engine/Source/Core/BingMapsGeocoderService.js b/packages/engine/Source/Core/BingMapsGeocoderService.js
index 647658fcd2d3..bd299d874026 100644
--- a/packages/engine/Source/Core/BingMapsGeocoderService.js
+++ b/packages/engine/Source/Core/BingMapsGeocoderService.js
@@ -10,6 +10,8 @@ const url = "https://dev.virtualearth.net/REST/v1/Locations";
/**
* Provides geocoding through Bing Maps.
+ *
+ * @see {@link https://www.microsoft.com/en-us/maps/bing-maps/product|Microsoft Bing Maps Platform APIs Terms Of Use}
* @alias BingMapsGeocoderService
* @constructor
*
diff --git a/packages/engine/Source/Core/GoogleGeocoderService.js b/packages/engine/Source/Core/GoogleGeocoderService.js
new file mode 100644
index 000000000000..67326e496e1c
--- /dev/null
+++ b/packages/engine/Source/Core/GoogleGeocoderService.js
@@ -0,0 +1,110 @@
+import Check from "./Check.js";
+import Credit from "./Credit.js";
+import defaultValue from "./defaultValue.js";
+import Rectangle from "./Rectangle.js";
+import Resource from "./Resource.js";
+import defined from "./defined.js";
+import DeveloperError from "./DeveloperError.js";
+import RuntimeError from "./RuntimeError.js";
+
+const API_URL = "https://maps.googleapis.com/maps/api/geocode/json";
+const CREDIT_HTML = ``;
+
+/**
+ * Provides geocoding through Google.
+ *
+ * @see {@link https://developers.google.com/maps/documentation/geocoding/policies|Google Geocoding Policies}
+ * @alias GoogleGeocoderService
+ * @constructor
+ *
+ * @param {object} options Object with the following properties:
+ * @param {string} options.key An API key to use with the Google geocoding service
+ */
+function GoogleGeocoderService(options) {
+ options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+ const key = options.key;
+ //>>includeStart('debug', pragmas.debug);
+ if (!defined(key)) {
+ throw new DeveloperError("options.key is required.");
+ }
+ //>>includeEnd('debug');
+
+ this._resource = new Resource({
+ url: API_URL,
+ queryParameters: { key },
+ });
+
+ this._credit = new Credit(CREDIT_HTML, true);
+}
+
+Object.defineProperties(GoogleGeocoderService.prototype, {
+ /**
+ * Gets the credit to display after a geocode is performed. Typically this is used to credit
+ * the geocoder service.
+ * @memberof GoogleGeocoderService.prototype
+ * @type {Credit|undefined}
+ * @readonly
+ */
+ credit: {
+ get: function () {
+ return this._credit;
+ },
+ },
+});
+
+/**
+ * Get a list of possible locations that match a search string.
+ *
+ * @function
+ *
+ * @param {string} query The query to be sent to the geocoder service
+ * @returns {Promise}
+ * @throws {RuntimeError} If the services returns a status other than OK or ZERO_RESULTS
+ */
+GoogleGeocoderService.prototype.geocode = async function (query) {
+ // See API documentation at https://developers.google.com/maps/documentation/geocoding/requests-geocoding
+
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.string("query", query);
+ //>>includeEnd('debug');
+
+ const resource = this._resource.getDerivedResource({
+ queryParameters: {
+ address: query,
+ },
+ });
+
+ const response = await resource.fetchJson();
+
+ if (response.status === "ZERO_RESULTS") {
+ return [];
+ }
+
+ if (response.status !== "OK") {
+ throw new RuntimeError(
+ `GoogleGeocoderService got a bad response ${response.status}: ${response.error_message}`,
+ );
+ }
+
+ const results = response.results.map((result) => {
+ const southWest = result.geometry.viewport.southwest;
+ const northEast = result.geometry.viewport.northeast;
+ return {
+ displayName: result.formatted_address,
+ destination: Rectangle.fromDegrees(
+ southWest.lng,
+ southWest.lat,
+ northEast.lng,
+ northEast.lat,
+ ),
+ attribution: {
+ html: CREDIT_HTML,
+ collapsible: false,
+ },
+ };
+ });
+
+ return results;
+};
+
+export default GoogleGeocoderService;
diff --git a/packages/engine/Source/Core/ITwinPlatform.js b/packages/engine/Source/Core/ITwinPlatform.js
new file mode 100644
index 000000000000..c6e9e44ba4a5
--- /dev/null
+++ b/packages/engine/Source/Core/ITwinPlatform.js
@@ -0,0 +1,359 @@
+import Check from "./Check.js";
+import defined from "./defined.js";
+import DeveloperError from "./DeveloperError.js";
+import Resource from "./Resource.js";
+import RuntimeError from "./RuntimeError.js";
+
+/**
+ * Default settings for accessing the iTwin platform.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @see ITwinData
+ * @namespace ITwinPlatform
+ */
+const ITwinPlatform = {};
+
+/**
+ * Status states for a mesh-export export.
+ * Valid values are: NotStarted, InProgress, Complete, Invalid
+ * @enum {string}
+ */
+ITwinPlatform.ExportStatus = Object.freeze({
+ NotStarted: "NotStarted",
+ InProgress: "InProgress",
+ Complete: "Complete",
+ Invalid: "Invalid",
+});
+
+/**
+ * Types of mesh-export exports. CesiumJS only supports loading 3DTILES type exports.
+ * Valid values are: IMODEL, CESIUM, 3DTILES
+ * @enum {string}
+ */
+ITwinPlatform.ExportType = Object.freeze({
+ IMODEL: "IMODEL",
+ CESIUM: "CESIUM",
+ "3DTILES": "3DTILES",
+});
+
+/**
+ * Types of Reality data
+ * @see https://developer.bentley.com/apis/reality-management/rm-rd-details/#types
+ * @enum {string}
+ */
+ITwinPlatform.RealityDataType = Object.freeze({
+ Cesium3DTiles: "Cesium3DTiles",
+ PNTS: "PNTS",
+ OPC: "OPC",
+ RealityMesh3DTiles: "RealityMesh3DTiles",
+ Terrain3DTiles: "Terrain3DTiles",
+ "3MX": "3MX",
+ "3SM": "3SM",
+ CCCloudProject: "CCCloudProject",
+ CCImageCollection: "CCImageCollection",
+ CCOrientations: "CCOrientations",
+ ContextCaptureInputs: "ContextCaptureInputs",
+ ContextDetector: "ContextDetector",
+ ContextScene: "ContextScene",
+ DAE: "DAE",
+ DGN: "DGN",
+ DSM: "DSM",
+ FBX: "FBX",
+ GLB: "GLB",
+ GLTF: "GLTF",
+ KML: "KML",
+ LAS: "LAS",
+ LAZ: "LAZ",
+ LOD: "LOD",
+ LodTree: "LodTree",
+ OBJ: "OBJ",
+ OMI: "OMI",
+ OMR: "OMR",
+ Orthophoto: "Orthophoto",
+ OrthophotoDSM: "OrthophotoDSM",
+ OSGB: "OSGB",
+ OVF: "OVF",
+ OBT: "OBT",
+ PLY: "PLY",
+ PointCloud: "PointCloud",
+ S3C: "S3C",
+ ScanCollection: "ScanCollection",
+ SHP: "SHP",
+ SLPK: "SLPK",
+ SpaceEyes3D: "SpaceEyes3D",
+ STL: "STL",
+ TSM: "TSM",
+ Unstructured: "Unstructured",
+ Other: "Other",
+});
+
+/**
+ * Gets or sets the default iTwin access token. This token should have the itwin-platform scope.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @type {string|undefined}
+ */
+ITwinPlatform.defaultAccessToken = undefined;
+
+/**
+ * Gets or sets the default iTwin API endpoint.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @type {string|Resource}
+ * @default "https://api.bentley.com"
+ */
+ITwinPlatform.apiEndpoint = new Resource({
+ url: "https://api.bentley.com",
+});
+
+/**
+ * @typedef {Object} ExportRequest
+ * @private
+ * @property {string} iModelId
+ * @property {string} changesetId
+ * @property {ITwinPlatform.ExportType} exportType Type of the export. CesiumJS only supports the 3DTILES type
+ */
+
+/**
+ * @typedef {Object} Link
+ * @private
+ * @property {string} href
+ */
+
+/**
+ * @typedef {Object} ExportRepresentation
+ * The export objects from get-exports when using return=representation
+ * @private
+ * @property {string} id Export id
+ * @property {string} displayName Name of the iModel
+ * @property {ITwinPlatform.ExportStatus} status Status of this export
+ * @property {string} lastModified
+ * @property {ExportRequest} request Object containing info about the export itself
+ * @property {{mesh: Link}} _links Object containing relevant links. For Exports this includes the access url for the mesh itself
+ */
+
+/**
+ * @typedef {Object} GetExportsResponse
+ * @private
+ * @property {ExportRepresentation[]} exports The list of exports for the current page
+ * @property {{self: Link, next: Link | undefined, prev: Link | undefined}} _links Pagination links
+ */
+
+/**
+ * Get the list of exports for the specified iModel at it's most current version.
+ * This will only return the top 5 exports with {@link ITwinPlatform.ExportType} of 3DTILES.
+ *
+ * @private
+ *
+ * @param {string} iModelId iModel id
+ * @returns {Promise}
+ *
+ * @throws {RuntimeError} If the iTwin API request is not successful
+ */
+ITwinPlatform.getExports = async function (iModelId) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.string("iModelId", iModelId);
+ if (!defined(ITwinPlatform.defaultAccessToken)) {
+ throw new DeveloperError("Must set ITwinPlatform.defaultAccessToken first");
+ }
+ //>>includeEnd('debug')
+
+ const resource = new Resource({
+ url: `${ITwinPlatform.apiEndpoint}mesh-export`,
+ headers: {
+ Authorization: `Bearer ${ITwinPlatform.defaultAccessToken}`,
+ Accept: "application/vnd.bentley.itwin-platform.v1+json",
+ Prefer: "return=representation",
+ },
+ queryParameters: {
+ iModelId: iModelId,
+ exportType: ITwinPlatform.ExportType["3DTILES"],
+ // With the export auto-generation it will auto-delete the 6th export so
+ // there should never be more than 5 results. Just request them all and parse
+ // for ones that are COMPLETE
+ $top: "5",
+ client: "CesiumJS",
+ },
+ });
+ /* global CESIUM_VERSION */
+ if (typeof CESIUM_VERSION !== "undefined") {
+ resource.appendQueryParameters({ clientVersion: CESIUM_VERSION });
+ }
+
+ try {
+ const response = await resource.fetchJson();
+ return response;
+ } catch (error) {
+ const result = JSON.parse(error.response);
+ if (error.statusCode === 401) {
+ throw new RuntimeError(
+ `Unauthorized, bad token, wrong scopes or headers bad. ${result.error.details[0].code}`,
+ );
+ } else if (error.statusCode === 403) {
+ console.error(result.error.code, result.error.message);
+ throw new RuntimeError("Not allowed, forbidden");
+ } else if (error.statusCode === 422) {
+ throw new RuntimeError(
+ `Unprocessable Entity:${result.error.code} ${result.error.message}`,
+ );
+ } else if (error.statusCode === 429) {
+ throw new RuntimeError("Too many requests");
+ }
+ throw new RuntimeError(`Unknown request failure ${error.statusCode}`);
+ }
+};
+
+/**
+ * @typedef {Object} RealityDataExtent
+ * @private
+ * @property {{latitude: number, longitude: number}} southWest
+ * @property {{latitude: number, longitude: number}} northEast
+ */
+
+/**
+ * @typedef {Object} RealityDataRepresentation
+ * @private
+ * @property {string} id "95d8dccd-d89e-4287-bb5f-3219acbc71ae",
+ * @property {string} displayName "Name of reality data",
+ * @property {string} dataset "Dataset",
+ * @property {string} group "73d09423-28c3-4fdb-ab4a-03a47a5b04f8",
+ * @property {string} description "Description of reality data",
+ * @property {string} rootDocument "Directory/SubDirectory/realityData.3mx",
+ * @property {number} size 6521212,
+ * @property {string} classification "Model",
+ * @property {ITwinPlatform.RealityDataType} type "3MX",
+ * @property {{startDateTime: string, endDateTime: string, acquirer: string}} acquisition
+ * @property {RealityDataExtent} extent
+ * @property {boolean} authoring false,
+ * @property {string} dataCenterLocation "North Europe",
+ * @property {string} modifiedDateTime "2021-04-09T19:03:12Z",
+ * @property {string} lastAccessedDateTime "2021-04-09T00:00:00Z",
+ * @property {string} createdDateTime "2021-02-22T20:03:40Z",
+ * @property {string} ownerId "f1d49cc7-f9b3-494f-9c67-563ea5597063",
+ */
+
+/**
+ * Load the full metadata for the given iTwin id and reality data id.
+ *
+ * @private
+ *
+ * @param {string} iTwinId The id of the iTwin to load data from
+ * @param {string} realityDataId The id of the reality data to load
+ * @returns {Promise}
+ */
+ITwinPlatform.getRealityDataMetadata = async function (iTwinId, realityDataId) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.string("iTwinId", iTwinId);
+ Check.typeOf.string("realityDataId", realityDataId);
+ if (!defined(ITwinPlatform.defaultAccessToken)) {
+ throw new DeveloperError("Must set ITwinPlatform.defaultAccessToken first");
+ }
+ //>>includeEnd('debug')
+
+ const resource = new Resource({
+ url: `${ITwinPlatform.apiEndpoint}reality-management/reality-data/${realityDataId}`,
+ headers: {
+ Authorization: `Bearer ${ITwinPlatform.defaultAccessToken}`,
+ Accept: "application/vnd.bentley.itwin-platform.v1+json",
+ },
+ queryParameters: { iTwinId: iTwinId },
+ });
+
+ try {
+ const response = await resource.fetchJson();
+ return response.realityData;
+ } catch (error) {
+ const result = JSON.parse(error.response);
+ if (error.statusCode === 401) {
+ throw new RuntimeError(
+ `Unauthorized, bad token, wrong scopes or headers bad. ${result.error.details[0].code}`,
+ );
+ } else if (error.statusCode === 403) {
+ console.error(result.error.code, result.error.message);
+ throw new RuntimeError("Not allowed, forbidden");
+ } else if (error.statusCode === 404) {
+ throw new RuntimeError(
+ `Reality data not found: ${iTwinId}, ${realityDataId}`,
+ );
+ } else if (error.statusCode === 422) {
+ throw new RuntimeError(
+ `Unprocessable Entity:${result.error.code} ${result.error.message}`,
+ );
+ } else if (error.statusCode === 429) {
+ throw new RuntimeError("Too many requests");
+ }
+ throw new RuntimeError(`Unknown request failure ${error.statusCode}`);
+ }
+};
+
+/**
+ * Request the access url for the given iTwin id, reality data id and root document.
+ * The root document can be requested from the list using return=representation
+ * or the metadata route from {@link ITwinPlatform.getRealityDataMetadata}
+ *
+ * @private
+ *
+ * @param {string} iTwinId The id of the iTwin to load data from
+ * @param {string} realityDataId The id of the reality data to load
+ * @param {string} rootDocument The path of the root document for this reality data
+ * @returns {Promise}
+ */
+ITwinPlatform.getRealityDataURL = async function (
+ iTwinId,
+ realityDataId,
+ rootDocument,
+) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.string("iTwinId", iTwinId);
+ Check.typeOf.string("realityDataId", realityDataId);
+ Check.typeOf.string("rootDocument", rootDocument);
+ if (!defined(ITwinPlatform.defaultAccessToken)) {
+ throw new DeveloperError("Must set ITwinPlatform.defaultAccessToken first");
+ }
+ //>>includeEnd('debug')
+
+ const resource = new Resource({
+ url: `${ITwinPlatform.apiEndpoint}reality-management/reality-data/${realityDataId}/readaccess`,
+ headers: {
+ Authorization: `Bearer ${ITwinPlatform.defaultAccessToken}`,
+ Accept: "application/vnd.bentley.itwin-platform.v1+json",
+ },
+ queryParameters: { iTwinId: iTwinId },
+ });
+
+ try {
+ const result = await resource.fetchJson();
+
+ const containerUrl = result._links.containerUrl.href;
+ const tilesetUrl = new URL(containerUrl);
+ tilesetUrl.pathname = `${tilesetUrl.pathname}/${rootDocument}`;
+
+ return tilesetUrl.toString();
+ } catch (error) {
+ const result = JSON.parse(error.response);
+ if (error.statusCode === 401) {
+ throw new RuntimeError(
+ `Unauthorized, bad token, wrong scopes or headers bad. ${result.error.details[0].code}`,
+ );
+ } else if (error.statusCode === 403) {
+ console.error(result.error.code, result.error.message);
+ throw new RuntimeError("Not allowed, forbidden");
+ } else if (error.statusCode === 404) {
+ throw new RuntimeError(
+ `Reality data not found: ${iTwinId}, ${realityDataId}`,
+ );
+ } else if (error.statusCode === 422) {
+ throw new RuntimeError(
+ `Unprocessable Entity:${result.error.code} ${result.error.message}`,
+ );
+ } else if (error.statusCode === 429) {
+ throw new RuntimeError("Too many requests");
+ }
+ throw new RuntimeError(`Unknown request failure ${error.statusCode}`);
+ }
+};
+
+export default ITwinPlatform;
diff --git a/packages/engine/Source/Core/Ion.js b/packages/engine/Source/Core/Ion.js
index 064a7d82f729..78da25b95607 100644
--- a/packages/engine/Source/Core/Ion.js
+++ b/packages/engine/Source/Core/Ion.js
@@ -8,7 +8,7 @@ let defaultTokenCredit;
const cesiumWebsiteToken =
"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI3ODZkMDQzOS03ZGJjLTQzZWUtYjlmYy04ZmM5Y2UwNzNhMmYiLCJpZCI6MjU5LCJpYXQiOjE2MzgyMDYwMDB9.cK1hsaFBgz0l2dG9Ry5vBFHWp-HF2lwjLC0tcK8Z8tY";
const defaultAccessToken =
- "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJiZjBmMDE4Ny05M2JlLTRlMzgtYjIxYi05YmJjM2QwMzJkYWMiLCJpZCI6MjU5LCJpYXQiOjE3MzA0NjY3MDl9.t-7gCGPUe-oGCyCoeXPtYmlMVdgqUQD9mn-Da23yUoI";
+ "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiI0ZDdmNWJiNy0wMmNlLTQ1MWUtODM2YS02NGM1MTBlOGMwMWQiLCJpZCI6MjU5LCJpYXQiOjE3MzMxNTc4OTV9.B3URHf0VdHDtGckb-hv7uqATdn8KfvkiuoAFZUq8tAo";
/**
* Default settings for accessing the Cesium ion API.
*
diff --git a/packages/engine/Source/Core/IonGeocodeProviderType.js b/packages/engine/Source/Core/IonGeocodeProviderType.js
new file mode 100644
index 000000000000..2dc9bf35d775
--- /dev/null
+++ b/packages/engine/Source/Core/IonGeocodeProviderType.js
@@ -0,0 +1,33 @@
+/**
+ * Underlying geocoding services that can be used via Cesium ion.
+ *
+ * @enum {string}
+ */
+const IonGeocodeProviderType = {
+ /**
+ * Google geocoder, for use with Google data.
+ *
+ * @type {string}
+ * @constant
+ */
+ GOOGLE: "GOOGLE",
+
+ /**
+ * Bing geocoder, for use with Bing data.
+ *
+ * @type {string}
+ * @constant
+ */
+ BING: "BING",
+
+ /**
+ * Use the default geocoder as set on the server. Used when neither Bing or
+ * Google data is used.
+ *
+ * @type {string}
+ * @constant
+ */
+ DEFAULT: "DEFAULT",
+};
+
+export default Object.freeze(IonGeocodeProviderType);
diff --git a/packages/engine/Source/Core/IonGeocoderService.js b/packages/engine/Source/Core/IonGeocoderService.js
index 81da96b7dbba..f473d80005b3 100644
--- a/packages/engine/Source/Core/IonGeocoderService.js
+++ b/packages/engine/Source/Core/IonGeocoderService.js
@@ -2,10 +2,45 @@ import Check from "./Check.js";
import Credit from "./Credit.js";
import defaultValue from "./defaultValue.js";
import defined from "./defined.js";
+import DeveloperError from "./DeveloperError.js";
import Ion from "./Ion.js";
+import IonGeocodeProviderType from "./IonGeocodeProviderType.js";
import PeliasGeocoderService from "./PeliasGeocoderService.js";
import Resource from "./Resource.js";
+/**
+ * @param {*} geocodeProviderType
+ * @throws {DeveloperError}
+ * @private
+ */
+function validateIonGeocodeProviderType(geocodeProviderType) {
+ if (
+ !Object.values(IonGeocodeProviderType).some(
+ (value) => value === geocodeProviderType,
+ )
+ ) {
+ throw new DeveloperError(
+ `Invalid geocodeProviderType: "${geocodeProviderType}"`,
+ );
+ }
+}
+
+const providerToParameterMap = Object.freeze({
+ [IonGeocodeProviderType.GOOGLE]: "google",
+ [IonGeocodeProviderType.BING]: "bing",
+ [IonGeocodeProviderType.DEFAULT]: undefined,
+});
+
+function providerToQueryParameter(provider) {
+ return providerToParameterMap[provider];
+}
+
+function queryParameterToProvider(parameter) {
+ return Object.entries(providerToParameterMap).find(
+ (entry) => entry[1] === parameter,
+ )[0];
+}
+
/**
* Provides geocoding through Cesium ion.
* @alias IonGeocoderService
@@ -15,6 +50,7 @@ import Resource from "./Resource.js";
* @param {Scene} options.scene The scene
* @param {string} [options.accessToken=Ion.defaultAccessToken] The access token to use.
* @param {string|Resource} [options.server=Ion.defaultServer] The resource to the Cesium ion API server.
+ * @param {IonGeocodeProviderType} [options.geocodeProviderType=IonGeocodeProviderType.DEFAULT] The geocoder the Cesium ion API server should use to fulfill this request.
*
* @see Ion
*/
@@ -25,6 +61,14 @@ function IonGeocoderService(options) {
Check.typeOf.object("options.scene", options.scene);
//>>includeEnd('debug');
+ const geocodeProviderType = defaultValue(
+ options.geocodeProviderType,
+ IonGeocodeProviderType.DEFAULT,
+ );
+ //>>includeStart('debug', pragmas.debug);
+ validateIonGeocodeProviderType(geocodeProviderType);
+ //>>includeEnd('debug');
+
const accessToken = defaultValue(options.accessToken, Ion.defaultAccessToken);
const server = Resource.createIfNeeded(
defaultValue(options.server, Ion.defaultServer),
@@ -49,6 +93,9 @@ function IonGeocoderService(options) {
this._accessToken = accessToken;
this._server = server;
this._pelias = new PeliasGeocoderService(searchEndpoint);
+ // geocoderProviderType isn't stored here directly but instead relies on the
+ // query parameters of this._pelias.url. Use the setter logic to update value.
+ this.geocodeProviderType = geocodeProviderType;
}
Object.defineProperties(IonGeocoderService.prototype, {
@@ -64,6 +111,31 @@ Object.defineProperties(IonGeocoderService.prototype, {
return undefined;
},
},
+ /**
+ * The geocoding service that Cesium ion API server should use to fulfill geocding requests.
+ * @memberof IonGeocoderService.prototype
+ * @type {IonGeocodeProviderType}
+ * @default IonGeocodeProviderType.DEFAULT
+ */
+ geocodeProviderType: {
+ get: function () {
+ return queryParameterToProvider(
+ this._pelias.url.queryParameters["geocoder"],
+ );
+ },
+ set: function (geocodeProviderType) {
+ validateIonGeocodeProviderType(geocodeProviderType);
+ const query = {
+ ...this._pelias.url.queryParameters,
+ geocoder: providerToQueryParameter(geocodeProviderType),
+ };
+ // Delete the geocoder parameter to prevent sending &geocoder=undefined in the query
+ if (!defined(query.geocoder)) {
+ delete query.geocoder;
+ }
+ this._pelias.url.setQueryParameters(query);
+ },
+ },
});
/**
diff --git a/packages/engine/Source/Core/Rectangle.js b/packages/engine/Source/Core/Rectangle.js
index 915a5289f909..70cd68fafaa6 100644
--- a/packages/engine/Source/Core/Rectangle.js
+++ b/packages/engine/Source/Core/Rectangle.js
@@ -7,7 +7,6 @@ import Ellipsoid from "./Ellipsoid.js";
import CesiumMath from "./Math.js";
import Transforms from "./Transforms.js";
import Matrix4 from "./Matrix4.js";
-import deprecationWarning from "./deprecationWarning.js";
/**
* A two dimensional region specified as longitude and latitude coordinates.
@@ -533,25 +532,6 @@ Rectangle.prototype.equalsEpsilon = function (other, epsilon) {
return Rectangle.equalsEpsilon(this, other, epsilon);
};
-/**
- * Checks a Rectangle's properties and throws if they are not in valid ranges.
- *
- * @param {Rectangle} rectangle The rectangle to validate
- *
- * @exception {DeveloperError} north must be in the interval [-Pi/2, Pi/2].
- * @exception {DeveloperError} south must be in the interval [-Pi/2, Pi/2].
- * @exception {DeveloperError} east must be in the interval [-Pi, Pi].
- * @exception {DeveloperError} west must be in the interval [-Pi, Pi].
- * @deprecated This function is deprecated and will be removed in Cesium 1.124. See Issue 4921
- */
-Rectangle.validate = function (rectangle) {
- deprecationWarning(
- "Rectangle.validate",
- "Rectangle.validate is a no-op and has been deprecated. It will be removed in Cesium 1.124.",
- );
- return Rectangle._validate(rectangle);
-};
-
/**
* Checks a Rectangle's properties and throws if they are not in valid ranges.
*
diff --git a/packages/engine/Source/Core/TrackingReferenceFrame.js b/packages/engine/Source/Core/TrackingReferenceFrame.js
new file mode 100644
index 000000000000..d16be08b853b
--- /dev/null
+++ b/packages/engine/Source/Core/TrackingReferenceFrame.js
@@ -0,0 +1,45 @@
+/**
+ * Constants for identifying well-known tracking reference frames.
+ *
+ * @enum {number}
+ */
+const TrackingReferenceFrame = {
+ /**
+ * Auto-detect algorithm. The reference frame used to track the Entity will
+ * be automatically selected based on its trajectory: near-surface slow moving
+ * objects will be tracked in the entity's local east-north-up reference
+ * frame, while faster objects like satellites will use VVLH (Vehicle Velocity,
+ * Local Horizontal).
+ *
+ * @type {number}
+ * @constant
+ */
+ AUTODETECT: 0,
+
+ /**
+ * The entity's local East-North-Up reference frame.
+ *
+ * @type {number}
+ * @constant
+ */
+ ENU: 1,
+
+ /**
+ * The entity's inertial reference frame. If entity has no defined orientation
+ * property, it falls back to auto-detect algorithm.
+ *
+ * @type {number}
+ * @constant
+ */
+ INERTIAL: 2,
+
+ /**
+ * The entity's inertial reference frame with orientation fixed to its
+ * {@link VelocityOrientationProperty}, ignoring its own orientation.
+ *
+ * @type {number}
+ * @constant
+ */
+ VELOCITY: 3,
+};
+export default Object.freeze(TrackingReferenceFrame);
diff --git a/packages/engine/Source/DataSources/Entity.js b/packages/engine/Source/DataSources/Entity.js
index b2b7433e29ba..d8c9fab17f9e 100644
--- a/packages/engine/Source/DataSources/Entity.js
+++ b/packages/engine/Source/DataSources/Entity.js
@@ -10,6 +10,7 @@ import CesiumMath from "../Core/Math.js";
import Matrix3 from "../Core/Matrix3.js";
import Matrix4 from "../Core/Matrix4.js";
import Quaternion from "../Core/Quaternion.js";
+import TrackingReferenceFrame from "../Core/TrackingReferenceFrame.js";
import Transforms from "../Core/Transforms.js";
import GroundPolylinePrimitive from "../Scene/GroundPolylinePrimitive.js";
import GroundPrimitive from "../Scene/GroundPrimitive.js";
@@ -73,8 +74,9 @@ function createPropertyTypeDescriptor(name, Type) {
* @property {string} [name] A human readable name to display to users. It does not have to be unique.
* @property {TimeIntervalCollection} [availability] The availability, if any, associated with this object.
* @property {boolean} [show] A boolean value indicating if the entity and its children are displayed.
+ * @property {TrackingReferenceFrame} [trackingReferenceFrame=TrackingReferenceFrame.AUTODETECT] The reference frame used when this entity is being tracked. If undefined, reference frame is determined based on entity velocity: near-surface slow moving entities are tracked using the local east-north-up reference frame, whereas fast moving entities such as satellites are tracked using VVLH (Vehicle Velocity, Local Horizontal).
* @property {Property | string} [description] A string Property specifying an HTML description for this entity.
- * @property {PositionProperty | Cartesian3 | CallbackProperty} [position] A Property specifying the entity position.
+ * @property {PositionProperty | Cartesian3 | CallbackPositionProperty} [position] A Property specifying the entity position.
* @property {Property | Quaternion} [orientation=Transforms.eastNorthUpToFixedFrame(position)] A Property specifying the entity orientation in respect to Earth-fixed-Earth-centered (ECEF). If undefined, east-north-up at entity position is used.
* @property {Property | Cartesian3} [viewFrom] A suggested initial offset for viewing this object.
* @property {Entity} [parent] A parent entity to associate with this entity.
@@ -122,6 +124,10 @@ function Entity(options) {
this._definitionChanged = new Event();
this._name = options.name;
this._show = defaultValue(options.show, true);
+ this._trackingReferenceFrame = defaultValue(
+ options.trackingReferenceFrame,
+ TrackingReferenceFrame.AUTODETECT,
+ );
this._parent = undefined;
this._propertyNames = [
"billboard",
@@ -296,6 +302,14 @@ Object.defineProperties(Entity.prototype, {
this._definitionChanged.raiseEvent(this, "show", value, !value);
},
},
+ /**
+ * Gets or sets the entity's tracking reference frame.
+ * @demo {@link https://sandcastle.cesium.com/index.html?src=Entity tracking.html|Cesium Sandcastle Entity tracking Demo}
+ *
+ * @memberof Entity.prototype
+ * @type {TrackingReferenceFrame}
+ */
+ trackingReferenceFrame: createRawPropertyDescriptor("trackingReferenceFrame"),
/**
* Gets whether this entity is being displayed, taking into account
* the visibility of any ancestor entities.
diff --git a/packages/engine/Source/DataSources/EntityView.js b/packages/engine/Source/DataSources/EntityView.js
index eb4fd4c5c207..9e7ae33234b5 100644
--- a/packages/engine/Source/DataSources/EntityView.js
+++ b/packages/engine/Source/DataSources/EntityView.js
@@ -8,8 +8,11 @@ import JulianDate from "../Core/JulianDate.js";
import CesiumMath from "../Core/Math.js";
import Matrix3 from "../Core/Matrix3.js";
import Matrix4 from "../Core/Matrix4.js";
+import Quaternion from "../Core/Quaternion.js";
+import TrackingReferenceFrame from "../Core/TrackingReferenceFrame.js";
import Transforms from "../Core/Transforms.js";
import SceneMode from "../Scene/SceneMode.js";
+import VelocityVectorProperty from "./VelocityVectorProperty.js";
const updateTransformMatrix3Scratch1 = new Matrix3();
const updateTransformMatrix3Scratch2 = new Matrix3();
@@ -21,6 +24,9 @@ const updateTransformCartesian3Scratch3 = new Cartesian3();
const updateTransformCartesian3Scratch4 = new Cartesian3();
const updateTransformCartesian3Scratch5 = new Cartesian3();
const updateTransformCartesian3Scratch6 = new Cartesian3();
+const updateTransformOrientationScratch = new Quaternion();
+const velocityScratch = new Cartesian3();
+const rotationScratch = new Matrix3();
const deltaTime = new JulianDate();
const northUpAxisFactor = 1.25; // times ellipsoid's maximum radius
@@ -30,6 +36,9 @@ function updateTransform(
updateLookAt,
saveCamera,
positionProperty,
+ velocityProperty,
+ orientationProperty,
+ trackingReferenceFrame,
time,
ellipsoid,
) {
@@ -228,7 +237,44 @@ function updateTransform(
}
const transform = updateTransformMatrix4Scratch;
- if (hasBasis) {
+
+ let orientation;
+ if (defined(orientationProperty)) {
+ orientation = orientationProperty.getValue(
+ time,
+ updateTransformOrientationScratch,
+ );
+ }
+
+ const velocity = velocityProperty.getValue(time, velocityScratch);
+
+ if (
+ trackingReferenceFrame === TrackingReferenceFrame.INERTIAL &&
+ defined(orientation)
+ ) {
+ Matrix4.fromTranslationQuaternionRotationScale(
+ cartesian,
+ orientation,
+ Cartesian3.ONE,
+ transform,
+ );
+ } else if (
+ trackingReferenceFrame === TrackingReferenceFrame.VELOCITY &&
+ defined(velocity)
+ ) {
+ const rotation = Transforms.rotationMatrixFromPositionVelocity(
+ cartesian,
+ velocity,
+ ellipsoid,
+ rotationScratch,
+ );
+ Matrix4.fromRotationTranslation(rotation, cartesian, transform);
+ } else if (
+ trackingReferenceFrame === TrackingReferenceFrame.ENU ||
+ !hasBasis
+ ) {
+ Transforms.eastNorthUpToFixedFrame(cartesian, ellipsoid, transform);
+ } else {
transform[0] = xBasis.x;
transform[1] = xBasis.y;
transform[2] = xBasis.z;
@@ -245,9 +291,6 @@ function updateTransform(
transform[13] = cartesian.y;
transform[14] = cartesian.z;
transform[15] = 0.0;
- } else {
- // Stationary or slow-moving, low-altitude objects use East-North-Up.
- Transforms.eastNorthUpToFixedFrame(cartesian, ellipsoid, transform);
}
camera._setTransform(transform);
@@ -316,6 +359,8 @@ function EntityView(entity, scene, ellipsoid) {
this._lastCartesian = new Cartesian3();
this._defaultOffset3D = undefined;
+ this._velocityProperty = new VelocityVectorProperty(entity.position, true);
+
this._offset3D = new Cartesian3();
}
@@ -362,10 +407,13 @@ EntityView.prototype.update = function (time, boundingSphere) {
}
const entity = this.entity;
+ const trackingReferenceFrame = entity.trackingReferenceFrame;
const positionProperty = entity.position;
if (!defined(positionProperty)) {
return;
}
+ const velocityProperty = this._velocityProperty;
+ const orientationProperty = entity.orientation;
const objectChanged = entity !== this._lastEntity;
const sceneModeChanged = sceneMode !== this._mode;
@@ -419,6 +467,9 @@ EntityView.prototype.update = function (time, boundingSphere) {
updateLookAt,
saveCamera,
positionProperty,
+ velocityProperty,
+ orientationProperty,
+ trackingReferenceFrame,
time,
ellipsoid,
);
diff --git a/packages/engine/Source/DataSources/SampledProperty.js b/packages/engine/Source/DataSources/SampledProperty.js
index 803555188725..dde0676d987e 100644
--- a/packages/engine/Source/DataSources/SampledProperty.js
+++ b/packages/engine/Source/DataSources/SampledProperty.js
@@ -674,6 +674,30 @@ SampledProperty.prototype.addSamples = function (
this._definitionChanged.raiseEvent(this);
};
+/**
+ * Retrieves the time of the provided sample associated with the index. A negative index accesses the list of samples in reverse order.
+ *
+ * @param {number} index The index of samples list.
+ * @returns {JulianDate | undefined} The JulianDate time of the sample, or undefined if failed.
+ */
+SampledProperty.prototype.getSample = function (index) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.number("index", index);
+ //>>includeEnd('debug');
+
+ const times = this._times;
+ const len = times.length;
+ if (!defined(len)) {
+ return undefined;
+ }
+
+ if (index < 0) {
+ index += len;
+ }
+
+ return times[index];
+};
+
/**
* Adds samples as a single packed array where each new sample is represented as a date,
* followed by the packed representation of the corresponding value and derivatives.
diff --git a/packages/engine/Source/Renderer/ContextLimits.js b/packages/engine/Source/Renderer/ContextLimits.js
index b6c5e5731f13..c435971762ac 100644
--- a/packages/engine/Source/Renderer/ContextLimits.js
+++ b/packages/engine/Source/Renderer/ContextLimits.js
@@ -44,7 +44,7 @@ Object.defineProperties(ContextLimits, {
},
/**
- * The approximate maximum cube mape width and height supported by this WebGL implementation.
+ * The approximate maximum cube map width and height supported by this WebGL implementation.
* The minimum is 16, but most desktop and laptop implementations will support much larger sizes like 8,192.
* @memberof ContextLimits
* @type {number}
diff --git a/packages/engine/Source/Renderer/Texture.js b/packages/engine/Source/Renderer/Texture.js
index b4b1259d5001..1e5eed6dd71d 100644
--- a/packages/engine/Source/Renderer/Texture.js
+++ b/packages/engine/Source/Renderer/Texture.js
@@ -27,6 +27,7 @@ import TextureMinificationFilter from "./TextureMinificationFilter.js";
* @property {number} [width] The pixel width of the texture. If not supplied, must be available from the source.
* @property {number} [height] The pixel height of the texture. If not supplied, must be available from the source.
* @property {boolean} [preMultiplyAlpha] If true, the alpha channel will be multiplied into the other channels.
+ * @property {string} [id] A unique identifier for the texture. If this is not given, then a GUID will be created.
*
* @private
*/
@@ -216,7 +217,7 @@ function Texture(options) {
? PixelFormat.compressedTextureSizeInBytes(pixelFormat, width, height)
: PixelFormat.textureSizeInBytes(pixelFormat, pixelDatatype, width, height);
- this._id = createGuid();
+ this._id = options.id ?? createGuid();
this._context = context;
this._textureFilterAnisotropic = context._textureFilterAnisotropic;
this._textureTarget = gl.TEXTURE_2D;
@@ -343,7 +344,7 @@ function loadBufferSource(texture, source) {
gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
- let arrayBufferView = source.arrayBufferView;
+ let { arrayBufferView } = source;
if (flipY) {
arrayBufferView = PixelFormat.flipY(
arrayBufferView,
@@ -386,6 +387,62 @@ function loadBufferSource(texture, source) {
}
}
+/**
+ * Load texel data from a buffer into part of a texture
+ *
+ * @param {Texture} texture The texture to which texel values will be loaded.
+ * @param {TypedArray} arrayBufferView The texel values to be loaded into the texture.
+ * @param {number} xOffset The texel x coordinate of the lower left corner of the subregion of the texture to be updated.
+ * @param {number} yOffset The texel y coordinate of the lower left corner of the subregion of the texture to be updated.
+ * @param {number} width The width of the source data, in pixels.
+ * @param {number} width The height of the source data, in pixels.
+ *
+ * @private
+ */
+function loadPartialBufferSource(
+ texture,
+ arrayBufferView,
+ xOffset,
+ yOffset,
+ width,
+ height,
+) {
+ const context = texture._context;
+ const gl = context._gl;
+
+ const { pixelFormat, pixelDatatype } = texture;
+
+ const unpackAlignment = PixelFormat.alignmentInBytes(
+ pixelFormat,
+ pixelDatatype,
+ width,
+ );
+ gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
+ gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+ gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+
+ if (texture.flipY) {
+ arrayBufferView = PixelFormat.flipY(
+ arrayBufferView,
+ pixelFormat,
+ pixelDatatype,
+ width,
+ height,
+ );
+ }
+ gl.texSubImage2D(
+ texture._textureTarget,
+ 0,
+ xOffset,
+ yOffset,
+ width,
+ height,
+ pixelFormat,
+ PixelDatatype.toWebGLConstant(pixelDatatype, context),
+ arrayBufferView,
+ );
+}
+
/**
* Load texel data from a framebuffer into a texture.
*
@@ -448,6 +505,35 @@ function loadImageSource(texture, source) {
);
}
+/**
+ * Load texel data from an Image into part of a texture
+ *
+ * @param {Texture} texture The texture to which texel values will be loaded.
+ * @param {ImageData|HTMLImageElement|HTMLCanvasElement|HTMLVideoElement} source The source for texel values to be loaded into the texture.
+ * @param {number} xOffset The texel x coordinate of the lower left corner of the subregion of the texture to be updated.
+ * @param {number} yOffset The texel y coordinate of the lower left corner of the subregion of the texture to be updated.
+ *
+ * @private
+ */
+function loadPartialImageSource(texture, source, xOffset, yOffset) {
+ const context = texture._context;
+ const gl = context._gl;
+
+ gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
+ gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.preMultiplyAlpha);
+ gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, texture.flipY);
+
+ gl.texSubImage2D(
+ texture._textureTarget,
+ 0,
+ xOffset,
+ yOffset,
+ texture.pixelFormat,
+ PixelDatatype.toWebGLConstant(texture.pixelDatatype, context),
+ source,
+ );
+}
+
/**
* Compute a dimension of the image for the next mip level.
*
@@ -812,7 +898,6 @@ Texture.prototype.copyFrom = function (options) {
gl.bindTexture(target, this._texture);
let { width, height } = source;
- const arrayBufferView = source.arrayBufferView;
// Make sure we are using the element's intrinsic width and height where available
if (defined(source.videoWidth) && defined(source.videoHeight)) {
@@ -823,25 +908,6 @@ Texture.prototype.copyFrom = function (options) {
height = source.naturalHeight;
}
- const textureWidth = this._width;
- const textureHeight = this._height;
- const internalFormat = this._internalFormat;
- const pixelFormat = this._pixelFormat;
- const pixelDatatype = this._pixelDatatype;
-
- const preMultiplyAlpha = this._preMultiplyAlpha;
- const flipY = this._flipY;
-
- let unpackAlignment = 4;
- if (defined(arrayBufferView)) {
- unpackAlignment = PixelFormat.alignmentInBytes(
- pixelFormat,
- pixelDatatype,
- width,
- );
- }
- gl.pixelStorei(gl.UNPACK_ALIGNMENT, unpackAlignment);
-
if (skipColorSpaceConversion) {
gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
} else {
@@ -853,94 +919,40 @@ Texture.prototype.copyFrom = function (options) {
let uploaded = false;
if (!this._initialized) {
- let pixels;
if (
xOffset === 0 &&
yOffset === 0 &&
- width === textureWidth &&
- height === textureHeight
+ width === this._width &&
+ height === this._height
) {
// initialize the entire texture
- if (defined(arrayBufferView)) {
- gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
- gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
- if (flipY) {
- pixels = PixelFormat.flipY(
- arrayBufferView,
- pixelFormat,
- pixelDatatype,
- textureWidth,
- textureHeight,
- );
- } else {
- pixels = arrayBufferView;
- }
+ if (defined(source.arrayBufferView)) {
+ loadBufferSource(this, source);
} else {
- // Only valid for DOM-Element uploads
- gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
- gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
- pixels = source;
+ loadImageSource(this, source);
}
uploaded = true;
} else {
gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
- // initialize the entire texture to zero
- pixels = PixelFormat.createTypedArray(
- pixelFormat,
- pixelDatatype,
- textureWidth,
- textureHeight,
- );
+ loadNull(this);
}
- gl.texImage2D(
- target,
- 0,
- internalFormat,
- textureWidth,
- textureHeight,
- 0,
- pixelFormat,
- PixelDatatype.toWebGLConstant(pixelDatatype, context),
- pixels,
- );
this._initialized = true;
}
if (!uploaded) {
- let pixels;
- if (defined(arrayBufferView)) {
- gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
- gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
-
- if (flipY) {
- pixels = PixelFormat.flipY(
- arrayBufferView,
- pixelFormat,
- pixelDatatype,
- width,
- height,
- );
- } else {
- pixels = arrayBufferView;
- }
+ if (defined(source.arrayBufferView)) {
+ loadPartialBufferSource(
+ this,
+ source.arrayBufferView,
+ xOffset,
+ yOffset,
+ width,
+ height,
+ );
} else {
- // Only valid for DOM-Element uploads
- gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, preMultiplyAlpha);
- gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
- pixels = source;
+ loadPartialImageSource(this, source, xOffset, yOffset);
}
- gl.texSubImage2D(
- target,
- 0,
- xOffset,
- yOffset,
- width,
- height,
- pixelFormat,
- PixelDatatype.toWebGLConstant(pixelDatatype, context),
- pixels,
- );
}
gl.bindTexture(target, null);
diff --git a/packages/engine/Source/Scene/ArcGisMapService.js b/packages/engine/Source/Scene/ArcGisMapService.js
index ce4f8c0a2e75..738ca6952569 100644
--- a/packages/engine/Source/Scene/ArcGisMapService.js
+++ b/packages/engine/Source/Scene/ArcGisMapService.js
@@ -8,7 +8,7 @@ const cesiumWebsiteToken =
let defaultTokenCredit;
const defaultAccessToken =
- "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmQpcUfxe1Yndhf82d5oKkQJ4_7VPaBQGYSISOMaRew7Sy-eTX1JQ4XwaC8v5aCvV72O6LCPs5Ss1pXXH-0uEw6bSRhTeQYHOmikutC2OMyZt6lu0VfT7FA-jVMO_UsunWNTf2cycP2O4IeDN_UV9G-VNmUu2jRvCHioi8o72ua4238s2219cYLEmcoGRJGVJTA.AT1_PjLvyih0";
+ "AAPTxy8BH1VEsoebNVZXo8HurEOF051kAEKlhkOhBEc9BmSrZYLHFXe7j_lQcsSJKc8-7rwh0IFSNWLGZErkzXRnYjMjURTz-hGiKMEeAJIZBG7uiYEn0Mt1rrwlJGIpirZQC4iO428519DlO3QC9DnRBqLXGTBhirgoU7-Z2209sy87s49kw6NOC8_Eew6nCLf-pZ883DRPRyAYH7LC8cvRLInud0EdndtUFa4y83TamrA.AT1_ahjrWDrq";
/**
* Default options for accessing the ArcGIS image tile service.
*
diff --git a/packages/engine/Source/Scene/Cesium3DTilesetStatistics.js b/packages/engine/Source/Scene/Cesium3DTilesetStatistics.js
index ed80f3fc67fd..f7c0d93834b9 100644
--- a/packages/engine/Source/Scene/Cesium3DTilesetStatistics.js
+++ b/packages/engine/Source/Scene/Cesium3DTilesetStatistics.js
@@ -1,4 +1,5 @@
import defined from "../Core/defined.js";
+import Model3DTileContent from "./Model/Model3DTileContent.js";
/**
* @private
@@ -29,6 +30,7 @@ function Cesium3DTilesetStatistics() {
// Memory statistics
this.geometryByteLength = 0;
this.texturesByteLength = 0;
+ this.texturesReferenceCounterById = {};
this.batchTableByteLength = 0; // batch textures and any binary metadata properties not otherwise accounted for
}
@@ -45,61 +47,123 @@ Cesium3DTilesetStatistics.prototype.clear = function () {
this.numberOfTilesCulledWithChildrenUnion = 0;
};
-function updatePointAndFeatureCounts(statistics, content, decrement, load) {
+/**
+ * Increment the counters for the points, triangles, and features
+ * that are currently selected for rendering.
+ *
+ * This will be called recursively for the given content and
+ * all its inner contents
+ *
+ * @param {Cesium3DTileContent} content
+ */
+Cesium3DTilesetStatistics.prototype.incrementSelectionCounts = function (
+ content,
+) {
+ this.numberOfFeaturesSelected += content.featuresLength;
+ this.numberOfPointsSelected += content.pointsLength;
+ this.numberOfTrianglesSelected += content.trianglesLength;
+
+ // Recursive calls on all inner contents
const contents = content.innerContents;
- const pointsLength = content.pointsLength;
- const trianglesLength = content.trianglesLength;
- const featuresLength = content.featuresLength;
- const geometryByteLength = content.geometryByteLength;
- const texturesByteLength = content.texturesByteLength;
- const batchTableByteLength = content.batchTableByteLength;
+ if (defined(contents)) {
+ const length = contents.length;
+ for (let i = 0; i < length; ++i) {
+ this.incrementSelectionCounts(contents[i]);
+ }
+ }
+};
- if (load) {
- statistics.numberOfFeaturesLoaded += decrement
- ? -featuresLength
- : featuresLength;
- statistics.numberOfPointsLoaded += decrement ? -pointsLength : pointsLength;
- statistics.geometryByteLength += decrement
- ? -geometryByteLength
- : geometryByteLength;
- statistics.texturesByteLength += decrement
- ? -texturesByteLength
- : texturesByteLength;
- statistics.batchTableByteLength += decrement
- ? -batchTableByteLength
- : batchTableByteLength;
+/**
+ * Increment the counters for the number of features and points that
+ * are currently loaded, and the lengths (size in bytes) of the
+ * occupied memory.
+ *
+ * This will be called recursively for the given content and
+ * all its inner contents
+ *
+ * @param {Cesium3DTileContent} content
+ */
+Cesium3DTilesetStatistics.prototype.incrementLoadCounts = function (content) {
+ this.numberOfFeaturesLoaded += content.featuresLength;
+ this.numberOfPointsLoaded += content.pointsLength;
+ this.geometryByteLength += content.geometryByteLength;
+ this.batchTableByteLength += content.batchTableByteLength;
+
+ // When the content is not a `Model3DTileContent`, then its
+ // textures byte length is added directly
+ if (!(content instanceof Model3DTileContent)) {
+ this.texturesByteLength += content.texturesByteLength;
} else {
- statistics.numberOfFeaturesSelected += decrement
- ? -featuresLength
- : featuresLength;
- statistics.numberOfPointsSelected += decrement
- ? -pointsLength
- : pointsLength;
- statistics.numberOfTrianglesSelected += decrement
- ? -trianglesLength
- : trianglesLength;
+ // When the content is a `Model3DTileContent`, then increment the
+ // reference counter for all its textures. The byte length of any
+ // newly tracked texture to the total textures byte length
+ const textureIds = content.getTextureIds();
+ for (const textureId of textureIds) {
+ const referenceCounter =
+ this.texturesReferenceCounterById[textureId] ?? 0;
+ if (referenceCounter === 0) {
+ const textureByteLength = content.getTextureByteLengthById(textureId);
+ this.texturesByteLength += textureByteLength;
+ }
+ this.texturesReferenceCounterById[textureId] = referenceCounter + 1;
+ }
}
+ // Recursive calls on all inner contents
+ const contents = content.innerContents;
if (defined(contents)) {
const length = contents.length;
for (let i = 0; i < length; ++i) {
- updatePointAndFeatureCounts(statistics, contents[i], decrement, load);
+ this.incrementLoadCounts(contents[i]);
}
}
-}
-
-Cesium3DTilesetStatistics.prototype.incrementSelectionCounts = function (
- content,
-) {
- updatePointAndFeatureCounts(this, content, false, false);
-};
-
-Cesium3DTilesetStatistics.prototype.incrementLoadCounts = function (content) {
- updatePointAndFeatureCounts(this, content, false, true);
};
+/**
+ * Decrement the counters for the number of features and points that
+ * are currently loaded, and the lengths (size in bytes) of the
+ * occupied memory.
+ *
+ * This will be called recursively for the given content and
+ * all its inner contents
+ *
+ * @param {Cesium3DTileContent} content
+ */
Cesium3DTilesetStatistics.prototype.decrementLoadCounts = function (content) {
- updatePointAndFeatureCounts(this, content, true, true);
+ this.numberOfFeaturesLoaded -= content.featuresLength;
+ this.numberOfPointsLoaded -= content.pointsLength;
+ this.geometryByteLength -= content.geometryByteLength;
+ this.batchTableByteLength -= content.batchTableByteLength;
+
+ // When the content is not a `Model3DTileContent`, then its
+ // textures byte length is subtracted directly
+ if (!(content instanceof Model3DTileContent)) {
+ this.texturesByteLength -= content.texturesByteLength;
+ } else {
+ // When the content is a `Model3DTileContent`, then decrement the
+ // reference counter for all its textures. The byte length of any
+ // texture that is no longer references is subtracted from the
+ // total textures byte length
+ const textureIds = content.getTextureIds();
+ for (const textureId of textureIds) {
+ const referenceCounter = this.texturesReferenceCounterById[textureId];
+ if (referenceCounter === 1) {
+ delete this.texturesReferenceCounterById[textureId];
+ const textureByteLength = content.getTextureByteLengthById(textureId);
+ this.texturesByteLength -= textureByteLength;
+ } else {
+ this.texturesReferenceCounterById[textureId] = referenceCounter - 1;
+ }
+ }
+ }
+ // Recursive calls on all inner contents
+ const contents = content.innerContents;
+ if (defined(contents)) {
+ const length = contents.length;
+ for (let i = 0; i < length; ++i) {
+ this.decrementLoadCounts(contents[i]);
+ }
+ }
};
Cesium3DTilesetStatistics.clone = function (statistics, result) {
@@ -124,6 +188,9 @@ Cesium3DTilesetStatistics.clone = function (statistics, result) {
statistics.numberOfTilesCulledWithChildrenUnion;
result.geometryByteLength = statistics.geometryByteLength;
result.texturesByteLength = statistics.texturesByteLength;
+ result.texturesReferenceCounterById = {
+ ...statistics.texturesReferenceCounterById,
+ };
result.batchTableByteLength = statistics.batchTableByteLength;
};
export default Cesium3DTilesetStatistics;
diff --git a/packages/engine/Source/Scene/DerivedCommand.js b/packages/engine/Source/Scene/DerivedCommand.js
index 8d70e283ac6a..8e3478fc65f3 100644
--- a/packages/engine/Source/Scene/DerivedCommand.js
+++ b/packages/engine/Source/Scene/DerivedCommand.js
@@ -1,3 +1,4 @@
+import { MetadataComponentType } from "@cesium/engine";
import defined from "../Core/defined.js";
import DrawCommand from "../Renderer/DrawCommand.js";
import RenderState from "../Renderer/RenderState.js";
@@ -416,6 +417,98 @@ function getGlslType(classProperty) {
return `ivec${componentCount}`;
}
+/**
+ * Returns a shader statement that applies the inverse of the
+ * value transform to the given value, based on the given offset
+ * and scale.
+ *
+ * @param {string} input The input value
+ * @param {string} offset The offset
+ * @param {string} scale The scale
+ * @returns {string} The statement
+ */
+function unapplyValueTransform(input, offset, scale) {
+ return `((${input} - float(${offset})) / float(${scale}))`;
+}
+
+/**
+ * Returns a shader statement that applies the inverse of the
+ * normalization, based on the given component type
+ *
+ * @param {string} input The input value
+ * @param {string} componentType The component type
+ * @returns {string} The statement
+ */
+function unnormalize(input, componentType) {
+ const max = MetadataComponentType.getMaximum(componentType);
+ return `(${input}) / float(${max})`;
+}
+
+/**
+ * Creates a shader statement that returns the value of the specified
+ * property, normalized to the range [0, 1].
+ *
+ * @param {MetadataClassProperty} classProperty The class property
+ * @param {object} metadataProperty The metadata property, either
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * @returns {string} The string
+ */
+function getSourceValueStringScalar(classProperty, metadataProperty) {
+ let result = `float(value)`;
+
+ // The 'hasValueTransform' indicates whether the property
+ // (or its class property) did define an 'offset' or 'scale'.
+ // Even when they had not been defined in the JSON, they are
+ // defined in the object, with default values.
+ if (metadataProperty.hasValueTransform) {
+ const offset = metadataProperty.offset;
+ const scale = metadataProperty.scale;
+ result = unapplyValueTransform(result, offset, scale);
+ }
+ if (!classProperty.normalized) {
+ result = unnormalize(result, classProperty.componentType);
+ }
+ return result;
+}
+
+/**
+ * Creates a shader statement that returns the value of the specified
+ * component of the given property, normalized to the range [0, 1].
+ *
+ * @param {MetadataClassProperty} classProperty The class property
+ * @param {object} metadataProperty The metadata property, either
+ * a `PropertyTextureProperty` or a `PropertyAttributeProperty`
+ * @param {string} componentName The name, in ["x", "y", "z", "w"]
+ * @returns {string} The string
+ */
+function getSourceValueStringComponent(
+ classProperty,
+ metadataProperty,
+ componentName,
+) {
+ const valueString = `value.${componentName}`;
+ let result = `float(${valueString})`;
+
+ // The 'hasValueTransform' indicates whether the property
+ // (or its class property) did define an 'offset' or 'scale'.
+ // Even when they had not been defined in the JSON, they are
+ // defined in the object, with default values
+ // Note that in the 'PropertyTextureProperty' and the
+ // 'PropertyAttributeProperty', these values are
+ // stored as "object types" (like 'Cartesian2'), whereas
+ // in the 'MetadataClassProperty', they are stored as
+ // "array types", e.g. a `[number, number]`
+ if (metadataProperty.hasValueTransform) {
+ const offset = metadataProperty.offset[componentName];
+ const scale = metadataProperty.scale[componentName];
+ result = unapplyValueTransform(result, offset, scale);
+ }
+ if (!classProperty.normalized) {
+ result = unnormalize(result, classProperty.componentType);
+ }
+ return result;
+}
+
/**
* Creates a new `ShaderProgram` from the given input that renders metadata
* values into the frame buffer, according to the given picked metadata info.
@@ -452,34 +545,34 @@ function getPickMetadataShaderProgram(
return shader;
}
+ const metadataProperty = pickedMetadataInfo.metadataProperty;
const classProperty = pickedMetadataInfo.classProperty;
const glslType = getGlslType(classProperty);
// Define the components that will go into the output `metadataValues`.
+ // This will be the 'color' that is written into the frame buffer,
+ // meaning that the values should be in [0.0, 1.0], and will become
+ // values in [0, 255] in the frame buffer.
// By default, all of them are 0.0.
const sourceValueStrings = ["0.0", "0.0", "0.0", "0.0"];
const componentCount = getComponentCount(classProperty);
if (componentCount === 1) {
- // When the property is a scalar, store its value directly
- // in `metadataValues.x`
- sourceValueStrings[0] = `float(value)`;
+ // When the property is a scalar, store the source value
+ // string directly in `metadataValues.x`
+ sourceValueStrings[0] = getSourceValueStringScalar(
+ classProperty,
+ metadataProperty,
+ );
} else {
// When the property is an array, store the array elements
// in `metadataValues.x/y/z/w`
- const components = ["x", "y", "z", "w"];
- for (let i = 0; i < componentCount; i++) {
- const component = components[i];
- const valueString = `value.${component}`;
- sourceValueStrings[i] = `float(${valueString})`;
- }
- }
-
- // Make sure that the `metadataValues` components are all in
- // the range [0, 1] (which will result in RGBA components
- // in [0, 255] during rendering)
- if (!classProperty.normalized) {
+ const componentNames = ["x", "y", "z", "w"];
for (let i = 0; i < componentCount; i++) {
- sourceValueStrings[i] += " / 255.0";
+ sourceValueStrings[i] = getSourceValueStringComponent(
+ classProperty,
+ metadataProperty,
+ componentNames[i],
+ );
}
}
diff --git a/packages/engine/Source/Scene/DynamicEnvironmentMapManager.js b/packages/engine/Source/Scene/DynamicEnvironmentMapManager.js
index d8d140ce29f9..f3897e2ff0c3 100644
--- a/packages/engine/Source/Scene/DynamicEnvironmentMapManager.js
+++ b/packages/engine/Source/Scene/DynamicEnvironmentMapManager.js
@@ -12,6 +12,7 @@ import PixelFormat from "../Core/PixelFormat.js";
import SceneMode from "./SceneMode.js";
import Transforms from "../Core/Transforms.js";
import ComputeCommand from "../Renderer/ComputeCommand.js";
+import ContextLimits from "../Renderer/ContextLimits.js";
import CubeMap from "../Renderer/CubeMap.js";
import Framebuffer from "../Renderer/Framebuffer.js";
import Texture from "../Renderer/Texture.js";
@@ -79,7 +80,11 @@ function DynamicEnvironmentMapManager(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
- const mipmapLevels = defaultValue(options.mipmapLevels, 10);
+ const mipmapLevels = Math.min(
+ defaultValue(options.mipmapLevels, 10),
+ Math.log2(ContextLimits.maximumCubeMapSize),
+ );
+
this._mipmapLevels = mipmapLevels;
this._radianceMapComputeCommands = new Array(6);
this._convolutionComputeCommands = new Array((mipmapLevels - 1) * 6);
@@ -95,7 +100,8 @@ function DynamicEnvironmentMapManager(options) {
this._radianceCubeMap = undefined;
this._irradianceMapTexture = undefined;
- this._sphericalHarmonicCoefficients = new Array(9);
+ this._sphericalHarmonicCoefficients =
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS.slice();
this._lastTime = new JulianDate();
const width = Math.pow(2, mipmapLevels - 1);
@@ -294,6 +300,63 @@ Object.defineProperties(DynamicEnvironmentMapManager.prototype, {
},
});
+// Internally manage a queue of commands across all instances to prevent too many commands from being added in a single frame and using too much memory at once.
+DynamicEnvironmentMapManager._maximumComputeCommandCount = 8; // This value is updated once a context is created.
+DynamicEnvironmentMapManager._activeComputeCommandCount = 0;
+DynamicEnvironmentMapManager._nextFrameCommandQueue = [];
+/**
+ * Add a command to the queue. If possible, it will be added to the list of commands for the next frame. Otherwise, it will be added to a backlog
+ * and attempted next frame.
+ * @private
+ * @param {ComputeCommand} command The created command
+ * @param {FrameState} frameState The current frame state
+ */
+DynamicEnvironmentMapManager._queueCommand = (command, frameState) => {
+ if (
+ DynamicEnvironmentMapManager._activeComputeCommandCount >=
+ DynamicEnvironmentMapManager._maximumComputeCommandCount
+ ) {
+ // Command will instead be scheduled next frame
+ DynamicEnvironmentMapManager._nextFrameCommandQueue.push(command);
+ return;
+ }
+
+ frameState.commandList.push(command);
+ DynamicEnvironmentMapManager._activeComputeCommandCount++;
+};
+/**
+ * If there are any backlogged commands, queue up as many as possible for the next frame.
+ * @private
+ * @param {FrameState} frameState The current frame state
+ */
+DynamicEnvironmentMapManager._updateCommandQueue = (frameState) => {
+ DynamicEnvironmentMapManager._maximumComputeCommandCount = Math.log2(
+ ContextLimits.maximumCubeMapSize,
+ ); // Scale relative to GPU resources available
+
+ if (
+ DynamicEnvironmentMapManager._nextFrameCommandQueue.length > 0 &&
+ DynamicEnvironmentMapManager._activeComputeCommandCount <
+ DynamicEnvironmentMapManager._maximumComputeCommandCount
+ ) {
+ let command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
+ while (
+ defined(command) &&
+ DynamicEnvironmentMapManager._activeComputeCommandCount <
+ DynamicEnvironmentMapManager._maximumComputeCommandCount
+ ) {
+ if (command.canceled) {
+ command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
+ continue;
+ }
+
+ frameState.commandList.push(command);
+ DynamicEnvironmentMapManager._activeComputeCommandCount++;
+ command = DynamicEnvironmentMapManager._nextFrameCommandQueue.shift();
+ }
+ }
+};
+
/**
* Sets the owner for the input DynamicEnvironmentMapManager if there wasn't another owner.
* Destroys the owner's previous DynamicEnvironmentMapManager if setting is successful.
@@ -333,15 +396,25 @@ DynamicEnvironmentMapManager.setOwner = function (
DynamicEnvironmentMapManager.prototype.reset = function () {
let length = this._radianceMapComputeCommands.length;
for (let i = 0; i < length; ++i) {
+ if (defined(this._radianceMapComputeCommands[i])) {
+ this._radianceMapComputeCommands[i].canceled = true;
+ DynamicEnvironmentMapManager._activeComputeCommandCount--;
+ }
this._radianceMapComputeCommands[i] = undefined;
}
length = this._convolutionComputeCommands.length;
for (let i = 0; i < length; ++i) {
+ if (defined(this._convolutionComputeCommands[i])) {
+ this._convolutionComputeCommands[i].canceled = true;
+ DynamicEnvironmentMapManager._activeComputeCommandCount--;
+ }
this._convolutionComputeCommands[i] = undefined;
}
if (defined(this._irradianceComputeCommand)) {
+ this._irradianceComputeCommand.canceled = true;
+ DynamicEnvironmentMapManager._activeComputeCommandCount--;
this._irradianceComputeCommand = undefined;
}
@@ -519,14 +592,17 @@ function updateRadianceMap(manager, frameState) {
framebuffer._unBind();
framebuffer.destroy();
+ DynamicEnvironmentMapManager._activeComputeCommandCount--;
+
if (!commands.some(defined)) {
manager._convolutionsCommandsDirty = true;
manager._shouldRegenerateShaders = true;
}
},
});
- frameState.commandList.push(command);
+
manager._radianceMapComputeCommands[i] = command;
+ DynamicEnvironmentMapManager._queueCommand(command, frameState);
i++;
}
manager._radianceCommandsDirty = false;
@@ -553,7 +629,7 @@ function updateSpecularMaps(manager, frameState) {
const getPostExecute = (index, texture, face, level) => () => {
// Copy output texture to corresponding face and mipmap level
const commands = manager._convolutionComputeCommands;
- if (!defined(commands[index])) {
+ if (!defined(commands[index]) || commands[index].canceled) {
// This command was cancelled
return;
}
@@ -561,6 +637,7 @@ function updateSpecularMaps(manager, frameState) {
radianceCubeMap.copyFace(frameState, texture, face, level);
facesCopied++;
+ DynamicEnvironmentMapManager._activeComputeCommandCount--;
// All faces and levels have been copied
if (facesCopied === manager._specularMapTextures.length) {
@@ -610,7 +687,7 @@ function updateSpecularMaps(manager, frameState) {
owner: manager,
uniformMap: {
u_roughness: () => level / (mipmapLevels - 1),
- u_radianceTexture: () => radianceCubeMap,
+ u_radianceTexture: () => radianceCubeMap ?? context.defaultTexture,
u_faceDirection: () => {
return CubeMap.getDirection(face, scratchCartesian);
},
@@ -618,7 +695,7 @@ function updateSpecularMaps(manager, frameState) {
postExecute: getPostExecute(index, texture, face, level),
});
manager._convolutionComputeCommands[index] = command;
- frameState.commandList.push(command);
+ DynamicEnvironmentMapManager._queueCommand(command, frameState);
++index;
}
@@ -663,7 +740,7 @@ function updateIrradianceResources(manager, frameState) {
fragmentShaderSource: fs,
outputTexture: texture,
uniformMap: {
- u_radianceMap: () => manager._radianceCubeMap,
+ u_radianceMap: () => manager._radianceCubeMap ?? context.defaultTexture,
},
postExecute: () => {
if (!defined(manager._irradianceComputeCommand)) {
@@ -673,10 +750,12 @@ function updateIrradianceResources(manager, frameState) {
manager._irradianceTextureDirty = false;
manager._irradianceComputeCommand = undefined;
manager._sphericalHarmonicCoefficientsDirty = true;
+
+ DynamicEnvironmentMapManager._activeComputeCommandCount--;
},
});
manager._irradianceComputeCommand = command;
- frameState.commandList.push(command);
+ DynamicEnvironmentMapManager._queueCommand(command, frameState);
manager._irradianceTextureDirty = true;
}
@@ -727,8 +806,13 @@ function updateSphericalHarmonicCoefficients(manager, frameState) {
*/
DynamicEnvironmentMapManager.prototype.update = function (frameState) {
const mode = frameState.mode;
+ const isSupported =
+ // A FrameState type works here because the function only references the context parameter.
+ // @ts-ignore
+ DynamicEnvironmentMapManager.isDynamicUpdateSupported(frameState);
if (
+ !isSupported ||
!this.enabled ||
!this.shouldUpdate ||
!defined(this._position) ||
@@ -738,6 +822,8 @@ DynamicEnvironmentMapManager.prototype.update = function (frameState) {
return;
}
+ DynamicEnvironmentMapManager._updateCommandQueue(frameState);
+
const dynamicLighting = frameState.atmosphere.dynamicLighting;
const regenerateEnvironmentMap =
atmosphereNeedsUpdate(this, frameState) ||
@@ -841,12 +927,48 @@ DynamicEnvironmentMapManager.prototype.destroy = function () {
return destroyObject(this);
};
+/**
+ * Returns true if dynamic updates are supported in the current WebGL rendering context.
+ * Dynamic updates requires the EXT_color_buffer_float or EXT_color_buffer_half_float extension.
+ *
+ * @param {Scene} scene The object containing the rendering context
+ * @returns {boolean} true if supported
+ */
+DynamicEnvironmentMapManager.isDynamicUpdateSupported = function (scene) {
+ const context = scene.context;
+ return context.halfFloatingPointTexture || context.colorBufferFloat;
+};
+
/**
* Average hue of ground color on earth, a warm green-gray.
* @type {Color}
+ * @readonly
*/
DynamicEnvironmentMapManager.AVERAGE_EARTH_GROUND_COLOR = Object.freeze(
Color.fromCssColorString("#717145"),
);
+/**
+ * The default third order spherical harmonic coefficients used for the diffuse color of image-based lighting, a white ambient light with low intensity.
+ *
+ * There are nine Cartesian3 coefficients.
+ * The order of the coefficients is: L0,0, L1,-1, L1,0, L1,1, L2,-2, L2,-1, L2,0, L2,1, L2,2
+ *
+ * @readonly
+ * @type {Cartesian3[]}
+ * @see {@link https://graphics.stanford.edu/papers/envmap/envmap.pdf|An Efficient Representation for Irradiance Environment Maps}
+ */
+DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS =
+ Object.freeze([
+ Object.freeze(new Cartesian3(0.35449, 0.35449, 0.35449)),
+ Cartesian3.ZERO,
+ Cartesian3.ZERO,
+ Cartesian3.ZERO,
+ Cartesian3.ZERO,
+ Cartesian3.ZERO,
+ Cartesian3.ZERO,
+ Cartesian3.ZERO,
+ Cartesian3.ZERO,
+ ]);
+
export default DynamicEnvironmentMapManager;
diff --git a/packages/engine/Source/Scene/GltfTextureLoader.js b/packages/engine/Source/Scene/GltfTextureLoader.js
index 4c07eef67629..afa6dad8f177 100644
--- a/packages/engine/Source/Scene/GltfTextureLoader.js
+++ b/packages/engine/Source/Scene/GltfTextureLoader.js
@@ -170,6 +170,7 @@ GltfTextureLoader.prototype.load = async function () {
function CreateTextureJob() {
this.gltf = undefined;
this.textureInfo = undefined;
+ this.textureId = undefined;
this.image = undefined;
this.context = undefined;
this.texture = undefined;
@@ -178,12 +179,14 @@ function CreateTextureJob() {
CreateTextureJob.prototype.set = function (
gltf,
textureInfo,
+ textureId,
image,
mipLevels,
context,
) {
this.gltf = gltf;
this.textureInfo = textureInfo;
+ this.textureId = textureId;
this.image = image;
this.mipLevels = mipLevels;
this.context = context;
@@ -193,13 +196,21 @@ CreateTextureJob.prototype.execute = function () {
this.texture = createTexture(
this.gltf,
this.textureInfo,
+ this.textureId,
this.image,
this.mipLevels,
this.context,
);
};
-function createTexture(gltf, textureInfo, image, mipLevels, context) {
+function createTexture(
+ gltf,
+ textureInfo,
+ textureId,
+ image,
+ mipLevels,
+ context,
+) {
// internalFormat is only defined for CompressedTextureBuffer
const internalFormat = image.internalFormat;
@@ -261,6 +272,7 @@ function createTexture(gltf, textureInfo, image, mipLevels, context) {
}
texture = Texture.create({
+ id: textureId,
context: context,
source: {
arrayBufferView: image.bufferView, // Only defined for CompressedTextureBuffer
@@ -276,6 +288,7 @@ function createTexture(gltf, textureInfo, image, mipLevels, context) {
image = resizeImageToNextPowerOfTwo(image);
}
texture = Texture.create({
+ id: textureId,
context: context,
source: image,
sampler: sampler,
@@ -332,6 +345,7 @@ GltfTextureLoader.prototype.process = function (frameState) {
textureJob.set(
this._gltf,
this._textureInfo,
+ this._cacheKey,
this._image,
this._mipLevels,
frameState.context,
@@ -346,6 +360,7 @@ GltfTextureLoader.prototype.process = function (frameState) {
texture = createTexture(
this._gltf,
this._textureInfo,
+ this._cacheKey,
this._image,
this._mipLevels,
frameState.context,
diff --git a/packages/engine/Source/Scene/ITwinData.js b/packages/engine/Source/Scene/ITwinData.js
new file mode 100644
index 000000000000..1b53f27e4c9e
--- /dev/null
+++ b/packages/engine/Source/Scene/ITwinData.js
@@ -0,0 +1,138 @@
+import Cesium3DTileset from "./Cesium3DTileset.js";
+import defined from "../Core/defined.js";
+import Resource from "../Core/Resource.js";
+import ITwinPlatform from "../Core/ITwinPlatform.js";
+import RuntimeError from "../Core/RuntimeError.js";
+import Check from "../Core/Check.js";
+
+/**
+ * Methods for loading iTwin platform data into CesiumJS
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @see ITwinPlatform
+ * @namespace ITwinData
+ */
+const ITwinData = {};
+
+/**
+ * Create a {@link Cesium3DTileset} for the given iModel id using iTwin's Mesh Export API.
+ *
+ * If there is not a completed export available for the given iModel id, the returned promise will resolve to undefined.
+ * We recommend waiting 10-20 seconds and trying to load the tileset again.
+ * If all exports are Invalid this will throw an error.
+ *
+ * @example
+ * const tileset = await Cesium.ITwinData.createTilesetFromIModelId(iModelId);
+ * if (Cesium.defined(tileset)) {
+ * viewer.scene.primitives.add(tileset);
+ * }
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @param {string} iModelId The id of the iModel to load
+ * @param {Cesium3DTileset.ConstructorOptions} [options] Object containing options to pass to the internally created {@link Cesium3DTileset}.
+ * @returns {Promise} A promise that will resolve to the created 3D tileset or undefined if there is no completed export for the given iModel id
+ *
+ * @throws {RuntimeError} If all exports for the given iModel are Invalid
+ * @throws {RuntimeError} If the iTwin API request is not successful
+ */
+ITwinData.createTilesetFromIModelId = async function (iModelId, options) {
+ const { exports } = await ITwinPlatform.getExports(iModelId);
+
+ if (
+ exports.length > 0 &&
+ exports.every((exportObj) => {
+ return exportObj.status === ITwinPlatform.ExportStatus.Invalid;
+ })
+ ) {
+ throw new RuntimeError(
+ `All exports for this iModel are Invalid: ${iModelId}`,
+ );
+ }
+
+ const completeExport = exports.find((exportObj) => {
+ return exportObj.status === ITwinPlatform.ExportStatus.Complete;
+ });
+
+ if (!defined(completeExport)) {
+ return;
+ }
+
+ // Convert the link to the tileset url while preserving the search paramaters
+ // This link is only valid 1 hour
+ const baseUrl = new URL(completeExport._links.mesh.href);
+ baseUrl.pathname = `${baseUrl.pathname}/tileset.json`;
+ const tilesetUrl = baseUrl.toString();
+
+ const resource = new Resource({
+ url: tilesetUrl,
+ });
+
+ return Cesium3DTileset.fromUrl(resource, options);
+};
+
+/**
+ * Create a tileset for the specified reality data id. This function only works
+ * with 3D Tiles meshes and point clouds.
+ *
+ * If the type or rootDocument are not provided this function
+ * will first request the full metadata for the specified reality data to fill these values.
+ *
+ * @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
+ *
+ * @param {string} iTwinId The id of the iTwin to load data from
+ * @param {string} realityDataId The id of the reality data to load
+ * @param {ITwinPlatform.RealityDataType} [type] The type of this reality data
+ * @param {string} [rootDocument] The path of the root document for this reality data
+ * @returns {Promise}
+ */
+ITwinData.createTilesetForRealityDataId = async function (
+ iTwinId,
+ realityDataId,
+ type,
+ rootDocument,
+) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.string("iTwinId", iTwinId);
+ Check.typeOf.string("realityDataId", realityDataId);
+ if (defined(type)) {
+ Check.typeOf.string("type", type);
+ }
+ if (defined(rootDocument)) {
+ Check.typeOf.string("rootDocument", rootDocument);
+ }
+ //>>includeEnd('debug')
+
+ if (!defined(type) || !defined(rootDocument)) {
+ const metadata = await ITwinPlatform.getRealityDataMetadata(
+ iTwinId,
+ realityDataId,
+ );
+ rootDocument = metadata.rootDocument;
+ type = metadata.type;
+ }
+
+ const supportedRealityDataTypes = [
+ ITwinPlatform.RealityDataType.Cesium3DTiles,
+ ITwinPlatform.RealityDataType.PNTS,
+ ITwinPlatform.RealityDataType.RealityMesh3DTiles,
+ ITwinPlatform.RealityDataType.Terrain3DTiles,
+ ];
+
+ if (!supportedRealityDataTypes.includes(type)) {
+ throw new RuntimeError(`Reality data type is not a mesh type: ${type}`);
+ }
+
+ const tilesetAccessUrl = await ITwinPlatform.getRealityDataURL(
+ iTwinId,
+ realityDataId,
+ rootDocument,
+ );
+
+ return Cesium3DTileset.fromUrl(tilesetAccessUrl, {
+ maximumScreenSpaceError: 4,
+ });
+};
+
+export default ITwinData;
diff --git a/packages/engine/Source/Scene/Label.js b/packages/engine/Source/Scene/Label.js
index 7196877768a9..61168a5ff2c0 100644
--- a/packages/engine/Source/Scene/Label.js
+++ b/packages/engine/Source/Scene/Label.js
@@ -400,8 +400,7 @@ Object.defineProperties(Label.prototype, {
if (this._text !== value) {
this._text = value;
- // Strip soft-hyphen (auto-wrap) characters from input string
- const renderedValue = value.replace(/\u00ad/g, "");
+ const renderedValue = Label.filterUnsupportedCharacters(value);
this._renderedText = Label.enableRightToLeftDetection
? reverseRtl(renderedValue)
: renderedValue;
@@ -1346,6 +1345,21 @@ Label.getScreenSpaceBoundingBox = function (
return result;
};
+/**
+ * Removes control characters and soft hyphon (auto-wrap) characters, which will cause an error when rendering a glyph. This does not remove tabs, carriage returns, or newlines.
+ * @private
+ * @param {string} text The original label text
+ * @returns {string} The renderable filtered text
+ */
+Label.filterUnsupportedCharacters = function (text) {
+ const problematicCharactersRegex = new RegExp(
+ // eslint-disable-next-line no-control-regex
+ /[\u0000-\u0008\u000E-\u001F\u00ad\u202a-\u206f\u200b-\u200f]/,
+ "g",
+ );
+ return text.replace(problematicCharactersRegex, "");
+};
+
/**
* Determines if this label equals another label. Labels are equal if all their properties
* are equal. Labels in different collections can be equal.
@@ -1502,7 +1516,7 @@ function reverseBrackets(bracket) {
}
}
-//To add another language, simply add its Unicode block range(s) to the below regex.
+// To add another language, add its Unicode block range(s) to the below regex.
const hebrew = "\u05D0-\u05EA";
const arabic = "\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF";
const rtlChars = new RegExp(`[${hebrew}${arabic}]`);
diff --git a/packages/engine/Source/Scene/MetadataClassProperty.js b/packages/engine/Source/Scene/MetadataClassProperty.js
index dec9b1393e3e..b51a79884817 100644
--- a/packages/engine/Source/Scene/MetadataClassProperty.js
+++ b/packages/engine/Source/Scene/MetadataClassProperty.js
@@ -438,6 +438,10 @@ Object.defineProperties(MetadataClassProperty.prototype, {
/**
* The offset to be added to property values as part of the value transform.
*
+ * This is always defined, even when `hasValueTransform` is `false`. If
+ * the class property JSON itself did not define it, then it will be
+ * initialized to the default value.
+ *
* @memberof MetadataClassProperty.prototype
* @type {number|number[]|number[][]}
* @readonly
@@ -451,6 +455,10 @@ Object.defineProperties(MetadataClassProperty.prototype, {
/**
* The scale to be multiplied to property values as part of the value transform.
*
+ * This is always defined, even when `hasValueTransform` is `false`. If
+ * the class property JSON itself did not define it, then it will be
+ * initialized to the default value.
+ *
* @memberof MetadataClassProperty.prototype
* @type {number|number[]|number[][]}
* @readonly
@@ -1139,6 +1147,24 @@ function normalizeInPlace(values, valueType, normalizeFunction) {
}
/**
+ * Applies the value transform that is defined with the given offsets
+ * and scales to the given values.
+ *
+ * If the given values are not an array, then the given transformation
+ * function will be applied directly.
+ *
+ * If the values are an array, then this function will be called recursively
+ * with the array elements, boiling down to a component-wise application
+ * of the transformation function to the innermost array elements.
+ *
+ * @param {number|number[]|number[][]} values The input values
+ * @param {number|number[]|number[][]} offsets The offsets
+ * @param {number|number[]|number[][]} scales The scales
+ * @param {Function} transformationFunction The function with the signature
+ * `(value:number, offset:number, scale:number) : number` that will be
+ * applied to the innermost elements
+ * @returns The input values (or the result of applying the transformation
+ * function to a single value if the values have not been an array).
* @private
*/
MetadataClassProperty.valueTransformInPlace = function (
diff --git a/packages/engine/Source/Scene/MetadataPicking.js b/packages/engine/Source/Scene/MetadataPicking.js
index 87f33a91d7d3..1ecbb639a57a 100644
--- a/packages/engine/Source/Scene/MetadataPicking.js
+++ b/packages/engine/Source/Scene/MetadataPicking.js
@@ -6,6 +6,7 @@ import Matrix2 from "../Core/Matrix2.js";
import Matrix3 from "../Core/Matrix3.js";
import Matrix4 from "../Core/Matrix4.js";
import RuntimeError from "../Core/RuntimeError.js";
+import MetadataClassProperty from "./MetadataClassProperty.js";
import MetadataComponentType from "./MetadataComponentType.js";
import MetadataType from "./MetadataType.js";
@@ -29,6 +30,10 @@ const MetadataPicking = {};
* @param {DataView} dataView The data view
* @param {number} index The index (byte offset)
* @returns {number|bigint|undefined} The value
+ * @throws RuntimeError If the given component type is not a valid
+ * `MetadataComponentType`
+ * @throws RangeError If reading the data from the given data view would
+ * cause an out-of-bounds access
*
* @private
*/
@@ -43,21 +48,21 @@ MetadataPicking.decodeRawMetadataValue = function (
case MetadataComponentType.UINT8:
return dataView.getUint8(index);
case MetadataComponentType.INT16:
- return dataView.getInt16(index);
+ return dataView.getInt16(index, true);
case MetadataComponentType.UINT16:
- return dataView.getUint16(index);
+ return dataView.getUint16(index, true);
case MetadataComponentType.INT32:
- return dataView.getInt32(index);
+ return dataView.getInt32(index, true);
case MetadataComponentType.UINT32:
- return dataView.getUint32(index);
+ return dataView.getUint32(index, true);
case MetadataComponentType.INT64:
- return dataView.getBigInt64(index);
+ return dataView.getBigInt64(index, true);
case MetadataComponentType.UINT64:
- return dataView.getBigUint64(index);
+ return dataView.getBigUint64(index, true);
case MetadataComponentType.FLOAT32:
- return dataView.getFloat32(index);
+ return dataView.getFloat32(index, true);
case MetadataComponentType.FLOAT64:
- return dataView.getFloat64(index);
+ return dataView.getFloat64(index, true);
}
throw new RuntimeError(`Invalid component type: ${componentType}`);
};
@@ -77,6 +82,10 @@ MetadataPicking.decodeRawMetadataValue = function (
* @param {number} dataViewOffset The byte offset within the data view from
* which the component should be read
* @returns {number|bigint|undefined} The metadata value component
+ * @throws RuntimeError If the component of the given property is not
+ * a valid `MetadataComponentType`
+ * @throws RangeError If reading the data from the given data view would
+ * cause an out-of-bounds access
*/
MetadataPicking.decodeRawMetadataValueComponent = function (
classProperty,
@@ -114,6 +123,11 @@ MetadataPicking.decodeRawMetadataValueComponent = function (
* @param {number} elementIndex The index of the element. This is the index
* inside the array for array-typed properties, and 0 for non-array types.
* @returns {number|number[]|bigint|bigint[]|undefined} The decoded metadata value element
+ * @throws RuntimeError If the component of the given property is not
+ * a valid `MetadataComponentType`
+ * @throws RangeError If reading the data from the given data view would
+ * cause an out-of-bounds access
+ *
*/
MetadataPicking.decodeRawMetadataValueElement = function (
classProperty,
@@ -183,6 +197,7 @@ MetadataPicking.decodeRawMetadataValueElement = function (
* @param {MetadataClassProperty} classProperty The `MetadataClassProperty`
* @param {Uint8Array} rawPixelValues The raw values
* @returns {number|bigint|number[]|bigint[]|undefined} The value
+ * @throws RuntimeError If the class property has an invalid component type
*
* @private
*/
@@ -229,7 +244,8 @@ MetadataPicking.decodeRawMetadataValues = function (
*
* @param {string} type The `ClassProperty` type
* @param {number|bigint|number[]|bigint[]|undefined} value The input value
- * @returns {any} The object representation
+ * @returns {undefined|number|bigint|string|boolean|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4} The object representation
+ * @throws RuntimeError If the type is not a valid `MetadataType`
*/
MetadataPicking.convertToObjectType = function (type, value) {
if (!defined(value)) {
@@ -250,7 +266,7 @@ MetadataPicking.convertToObjectType = function (type, value) {
case MetadataType.VEC3:
return Cartesian3.unpack(numbers, 0, new Cartesian3());
case MetadataType.VEC4:
- return Cartesian4.unpack(numbers, 0, new Cartesian3());
+ return Cartesian4.unpack(numbers, 0, new Cartesian4());
case MetadataType.MAT2:
return Matrix2.unpack(numbers, 0, new Matrix2());
case MetadataType.MAT3:
@@ -259,29 +275,104 @@ MetadataPicking.convertToObjectType = function (type, value) {
return Matrix4.unpack(numbers, 0, new Matrix4());
}
// Should never happen:
- return value;
+ throw new RuntimeError(`Invalid metadata object type: ${type}`);
+};
+
+/**
+ * Converts the given type into a raw value or array representation.
+ *
+ * For `VECn/MATn` types, the given value is converted into an array.
+ * For other types, the value is returned directly
+ *
+ * @param {string} type The `ClassProperty` type
+ * @param {undefined|number|bigint|string|boolean|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4} value The input value
+ * @returns {undefined|number|bigint|string|boolean|number[]} The array representation
+ * @throws RuntimeError If the type is not a valid `MetadataType`
+ */
+MetadataPicking.convertFromObjectType = function (type, value) {
+ if (!defined(value)) {
+ return value;
+ }
+ if (
+ type === MetadataType.SCALAR ||
+ type === MetadataType.STRING ||
+ type === MetadataType.BOOLEAN ||
+ type === MetadataType.ENUM
+ ) {
+ return value;
+ }
+ switch (type) {
+ case MetadataType.VEC2:
+ return Cartesian2.pack(value, Array(2));
+ case MetadataType.VEC3:
+ return Cartesian3.pack(value, Array(3));
+ case MetadataType.VEC4:
+ return Cartesian4.pack(value, Array(4));
+ case MetadataType.MAT2:
+ return Matrix2.pack(value, Array(4));
+ case MetadataType.MAT3:
+ return Matrix3.pack(value, Array(9));
+ case MetadataType.MAT4:
+ return Matrix4.pack(value, Array(16));
+ }
+ // Should never happen:
+ throw new RuntimeError(`Invalid metadata object type: ${type}`);
};
/**
* Decode the given raw values into a metadata property value.
*
- * This just converts the result of `decodeRawMetadataValues`
- * from array-based types into object types like `CartesianN`.
+ * This applies the value transform (offset/scale) to the result
+ * of `decodeRawMetadataValues`, and converts this from array-based
+ * types into object types like `CartesianN`.
*
* @param {MetadataClassProperty} classProperty The `MetadataClassProperty`
+ * @param {object} metadataProperty The
+ * `PropertyTextureProperty` or `PropertyAttributeProperty`
* @param {Uint8Array} rawPixelValues The raw values
- * @returns {any} The value
+ * @returns {MetadataValue} The value
+ * @throws RuntimeError If the class property has an invalid type
+ * or component type
+ * @throws RangeError If the given pixel values do not have sufficient
+ * size to contain the expected value type
*
* @private
*/
MetadataPicking.decodeMetadataValues = function (
classProperty,
+ metadataProperty,
rawPixelValues,
) {
- const arrayBasedResult = MetadataPicking.decodeRawMetadataValues(
+ let arrayBasedResult = MetadataPicking.decodeRawMetadataValues(
classProperty,
rawPixelValues,
);
+
+ if (metadataProperty.hasValueTransform) {
+ // In the MetadataClassProperty, these offset/scale are always in
+ // their array-based form (e.g. a number[3] for `VEC3`). But for
+ // the PropertyTextureProperty and PropertyAttributeProperty,
+ // the type of the offset/scale is defined to be
+ // number|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4
+ // So these types are converted into their array-based form here, before
+ // applying them with `MetadataClassProperty.valueTransformInPlace`
+
+ const offset = MetadataPicking.convertFromObjectType(
+ classProperty.type,
+ metadataProperty.offset,
+ );
+ const scale = MetadataPicking.convertFromObjectType(
+ classProperty.type,
+ metadataProperty.scale,
+ );
+ arrayBasedResult = MetadataClassProperty.valueTransformInPlace(
+ arrayBasedResult,
+ offset,
+ scale,
+ MetadataComponentType.applyValueTransform,
+ );
+ }
+
if (classProperty.isArray) {
const arrayLength = classProperty.arrayLength;
const result = Array(arrayLength);
@@ -295,11 +386,11 @@ MetadataPicking.decodeMetadataValues = function (
}
return result;
}
- const result = MetadataPicking.convertToObjectType(
+ const objectResult = MetadataPicking.convertToObjectType(
classProperty.type,
arrayBasedResult,
);
- return result;
+ return objectResult;
};
export default Object.freeze(MetadataPicking);
diff --git a/packages/engine/Source/Scene/MetadataType.js b/packages/engine/Source/Scene/MetadataType.js
index 9bb0a2e8c7d5..c00e91f2cb1e 100644
--- a/packages/engine/Source/Scene/MetadataType.js
+++ b/packages/engine/Source/Scene/MetadataType.js
@@ -7,6 +7,26 @@ import Matrix2 from "../Core/Matrix2.js";
import Matrix3 from "../Core/Matrix3.js";
import Matrix4 from "../Core/Matrix4.js";
+/**
+ * An instance of a metadata value.
+ *
+ * This can be one of the following types:
+ *
+ *
number for type SCALAR and numeric component types except for INT64 or UINT64
+ *
bigint for type SCALAR and component type INT64 or UINT64
+ *
string for type STRING or ENUM
+ *
boolean for type BOOLEAN
+ *
Cartesian2 for type VEC2
+ *
Cartesian3 for type VEC3
+ *
Cartesian4 for type VEC4
+ *
Matrix2 for type MAT2
+ *
Matrix3 for type MAT3
+ *
Matrix4 for type MAT4
+ *
Arrays of these types when the metadata value is an array
+ *
+ * @typedef {(number|bigint|string|boolean|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4|number[]|bigint[]|string[]|boolean[]|Cartesian2[]|Cartesian3[]|Cartesian4[]|Matrix2[]|Matrix3[]|Matrix4[])} MetadataValue
+ */
+
/**
* An enum of metadata types. These metadata types are containers containing
* one or more components of type {@link MetadataComponentType}
diff --git a/packages/engine/Source/Scene/Model/Extensions/Gpm/GltfMeshPrimitiveGpmLoader.js b/packages/engine/Source/Scene/Model/Extensions/Gpm/GltfMeshPrimitiveGpmLoader.js
index 7be022144311..944d99ab23b7 100644
--- a/packages/engine/Source/Scene/Model/Extensions/Gpm/GltfMeshPrimitiveGpmLoader.js
+++ b/packages/engine/Source/Scene/Model/Extensions/Gpm/GltfMeshPrimitiveGpmLoader.js
@@ -234,7 +234,7 @@ GltfMeshPrimitiveGpmLoader.ppeTexturesMetadataSchemaCache = new Map();
* Create the JSON description of a metadata class that treats
* the given PPE texture as a property texture property.
*
- * @param {any} ppeTexture - The PPE texture
+ * @param {PpeTexture} ppeTexture - The PPE texture
* @param {number} index - The index of the texture in the extension
* @returns The class JSON
*/
@@ -268,9 +268,9 @@ GltfMeshPrimitiveGpmLoader._createPpeTextureClassJson = function (
// property values when they are `normalized`, the values will be
// declared as `normalized` here.
// The normalization factor will later have to be cancelled out,
- // when integrating the `scale` into the actual property texture
- // property. In the property texture property, the `scale` has to
- // be multiplied by 255.
+ // with the `scale` being multiplied by 255.
+ const offset = ppeTexture.offset ?? 0.0;
+ const scale = (ppeTexture.scale ?? 1.0) * 255.0;
const classJson = {
name: `PPE texture class ${index}`,
properties: {
@@ -279,6 +279,8 @@ GltfMeshPrimitiveGpmLoader._createPpeTextureClassJson = function (
type: "SCALAR",
componentType: "UINT8",
normalized: true,
+ offset: offset,
+ scale: scale,
min: traits.min,
max: traits.max,
},
@@ -406,19 +408,12 @@ GltfMeshPrimitiveGpmLoader._convertToStructuralMetadata = function (
const ppePropertyName = traits.source;
const metadataClass = ppeTexturesMetadataSchema.classes[classId];
- // The class property has been declared as `normalized`, so
- // that `offset` and `scale` can be applied. The normalization
- // factor has to be cancelled out here, by multiplying the
- // `scale` with 255.
- const scale = (ppeTexture.scale ?? 1.0) * 255.0;
const ppeTextureAsPropertyTexture = {
class: classId,
properties: {
[ppePropertyName]: {
index: ppeTexture.index,
texCoord: ppeTexture.texCoord,
- offset: ppeTexture.offset,
- scale: scale,
},
},
};
diff --git a/packages/engine/Source/Scene/Model/Model3DTileContent.js b/packages/engine/Source/Scene/Model/Model3DTileContent.js
index e4266704bdad..143acbe8cb48 100644
--- a/packages/engine/Source/Scene/Model/Model3DTileContent.js
+++ b/packages/engine/Source/Scene/Model/Model3DTileContent.js
@@ -152,12 +152,34 @@ Object.defineProperties(Model3DTileContent.prototype, {
},
});
+/**
+ * Returns an array containing the `texture.id` values for all textures
+ * that are part of this content.
+ *
+ * @returns {string[]} The texture IDs
+ */
+Model3DTileContent.prototype.getTextureIds = function () {
+ return this._model.statistics.getTextureIds();
+};
+
+/**
+ * Returns the length, in bytes, of the texture data for the texture with
+ * the given ID that is part of this content, or `undefined` if this
+ * content does not contain the texture with the given ID.
+ *
+ * @param {string} textureId The texture ID
+ * @returns {number|undefined} The texture byte length
+ */
+Model3DTileContent.prototype.getTextureByteLengthById = function (textureId) {
+ return this._model.statistics.getTextureByteLengthById(textureId);
+};
+
/**
* Returns the object that was created for the given extension.
*
* The given name may be the name of a glTF extension, like `"EXT_example_extension"`.
* If the specified extension was present in the root of the underlying glTF asset,
- * and a loder for the specified extension has processed the extension data, then
+ * and a loader for the specified extension has processed the extension data, then
* this will return the model representation of the extension.
*
* @param {string} extensionName The name of the extension
diff --git a/packages/engine/Source/Scene/Model/ModelStatistics.js b/packages/engine/Source/Scene/Model/ModelStatistics.js
index 3188895efc5a..b8a60af26df0 100644
--- a/packages/engine/Source/Scene/Model/ModelStatistics.js
+++ b/packages/engine/Source/Scene/Model/ModelStatistics.js
@@ -61,7 +61,15 @@ function ModelStatistics() {
// Sets of buffers and textures that have already been counted.
// This is to prevent double-counting cached assets.
this._bufferIdSet = {};
- this._textureIdSet = {};
+
+ /**
+ * The mapping from `texture.id` strings to the byte length of the
+ * respective texture
+ *
+ * @type {object}
+ * @private
+ */
+ this._textureIdByteLengths = {};
// Associated array of batch textures that have already been counted.
// This allows for quick look-up to check if a texture has been counted,
@@ -111,7 +119,7 @@ ModelStatistics.prototype.clear = function () {
this.propertyTablesByteLength = 0;
this._bufferIdSet = {};
- this._textureIdSet = {};
+ this._textureIdByteLengths = {};
this._batchTextureIdMap.removeAll();
};
@@ -160,12 +168,32 @@ ModelStatistics.prototype.addTexture = function (texture) {
Check.typeOf.object("texture", texture);
//>>includeEnd('debug');
- if (!this._textureIdSet.hasOwnProperty(texture._id)) {
+ if (!this._textureIdByteLengths.hasOwnProperty(texture._id)) {
this.texturesByteLength += texture.sizeInBytes;
+ this._textureIdByteLengths[texture._id] = texture.sizeInBytes;
}
+};
- // Simulate set insertion.
- this._textureIdSet[texture._id] = true;
+/**
+ * Returns an array containing the `texture.id` values for all textures
+ * that are part of the model.
+ *
+ * @returns {string[]} The texture IDs
+ */
+ModelStatistics.prototype.getTextureIds = function () {
+ return Object.keys(this._textureIdByteLengths);
+};
+
+/**
+ * Returns the length, in bytes, of the texture data for the texture with
+ * the given ID that is part of the model, or `undefined` if the model
+ * does not contain the texture with the given ID.
+ *
+ * @param {string} textureId The texture ID
+ * @returns {number|undefined} The texture byte length
+ */
+ModelStatistics.prototype.getTextureByteLengthById = function (textureId) {
+ return this._textureIdByteLengths[textureId];
};
/**
diff --git a/packages/engine/Source/Scene/Model/PointCloudStylingPipelineStage.js b/packages/engine/Source/Scene/Model/PointCloudStylingPipelineStage.js
index 967e07fcfe98..c89786f88f05 100644
--- a/packages/engine/Source/Scene/Model/PointCloudStylingPipelineStage.js
+++ b/packages/engine/Source/Scene/Model/PointCloudStylingPipelineStage.js
@@ -333,9 +333,10 @@ function addShaderFunctionsAndDefines(shaderBuilder, shaderFunctionInfo) {
shaderBuilder.addDefine(
"HAS_POINT_CLOUD_SHOW_STYLE",
undefined,
- ShaderDestination.VERTEX,
+ ShaderDestination.BOTH,
);
shaderBuilder.addVertexLines(showStyleFunction);
+ shaderBuilder.addVarying("float", "v_pointCloudShow");
}
const pointSizeStyleFunction = shaderFunctionInfo.pointSizeStyleFunction;
diff --git a/packages/engine/Source/Scene/PickedMetadataInfo.js b/packages/engine/Source/Scene/PickedMetadataInfo.js
index 1e8de1902b17..d58fa33e0451 100644
--- a/packages/engine/Source/Scene/PickedMetadataInfo.js
+++ b/packages/engine/Source/Scene/PickedMetadataInfo.js
@@ -6,11 +6,17 @@
* the metadata values of an object into the picking frame buffer. The
* raw values are read from that buffer, and are then translated back into
* proper metadata values in `Picking.pickMetadata`, using the structural
- * information about the metadata `classProperty` that is stored here.
+ * information about the metadata that is stored here.
*
* @private
*/
-function PickedMetadataInfo(schemaId, className, propertyName, classProperty) {
+function PickedMetadataInfo(
+ schemaId,
+ className,
+ propertyName,
+ classProperty,
+ metadataProperty,
+) {
/**
* The optional ID of the metadata schema
*
@@ -29,11 +35,23 @@ function PickedMetadataInfo(schemaId, className, propertyName, classProperty) {
* @type {string}
*/
this.propertyName = propertyName;
+
/**
- * The optional ID of the metadata schema
+ * The the `MetadataClassProperty` that is described by this
+ * structure, as obtained from the `MetadataSchema`
*
* @type {MetadataClassProperty}
*/
this.classProperty = classProperty;
+
+ /**
+ * The `PropertyTextureProperty` or `PropertyAttributeProperty` that
+ * is described by this structure, as obtained from the property texture
+ * or property attribute of the `StructuralMetadata` that matches the
+ * class name and property name.
+ *
+ * @type {object}
+ */
+ this.metadataProperty = metadataProperty;
}
export default PickedMetadataInfo;
diff --git a/packages/engine/Source/Scene/Picking.js b/packages/engine/Source/Scene/Picking.js
index fc38a4a90955..c31490f9851c 100644
--- a/packages/engine/Source/Scene/Picking.js
+++ b/packages/engine/Source/Scene/Picking.js
@@ -426,9 +426,14 @@ Picking.prototype.pickVoxelCoordinate = function (
* - For `VEC3`, the return type will be a `Cartesian3`
* - For `VEC4`, the return type will be a `Cartesian4`
*
+ * Future implementations may additionally return `string`- or
+ * `boolean` types, and `MATn` values as `MatrixN` objects,
+ * and arrays of the respective types.
+ *
* @param {Cartesian2} windowPosition Window coordinates to perform picking on.
* @param {PickedMetadataInfo} pickedMetadataInfo Information about the picked metadata.
- * @returns {any} The metadata values
+ * @returns {MetadataValue|undefined} The metadata value, or `undefined`
+ * when no matching metadata value could be picked at the given position
*
* @private
*/
@@ -517,6 +522,7 @@ Picking.prototype.pickMetadata = function (
const metadataValue = MetadataPicking.decodeMetadataValues(
pickedMetadataInfo.classProperty,
+ pickedMetadataInfo.metadataProperty,
rawMetadataPixel,
);
diff --git a/packages/engine/Source/Scene/PostProcessStage.js b/packages/engine/Source/Scene/PostProcessStage.js
index 44012ca77b56..454822ca4e8f 100644
--- a/packages/engine/Source/Scene/PostProcessStage.js
+++ b/packages/engine/Source/Scene/PostProcessStage.js
@@ -94,9 +94,16 @@ import PostProcessStageSampleMode from "./PostProcessStageSampleMode.js";
function PostProcessStage(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
const {
+ name = createGuid(),
fragmentShader,
+ uniforms,
textureScale = 1.0,
+ forcePowerOfTwo = false,
+ sampleMode = PostProcessStageSampleMode.NEAREST,
pixelFormat = PixelFormat.RGBA,
+ pixelDatatype = PixelDatatype.UNSIGNED_BYTE,
+ clearColor = Color.BLACK,
+ scissorRectangle,
} = options;
//>>includeStart('debug', pragmas.debug);
@@ -113,19 +120,13 @@ function PostProcessStage(options) {
//>>includeEnd('debug');
this._fragmentShader = fragmentShader;
- this._uniforms = options.uniforms;
+ this._uniforms = uniforms;
this._textureScale = textureScale;
- this._forcePowerOfTwo = defaultValue(options.forcePowerOfTwo, false);
- this._sampleMode = defaultValue(
- options.sampleMode,
- PostProcessStageSampleMode.NEAREST,
- );
+ this._forcePowerOfTwo = forcePowerOfTwo;
+ this._sampleMode = sampleMode;
this._pixelFormat = pixelFormat;
- this._pixelDatatype = defaultValue(
- options.pixelDatatype,
- PixelDatatype.UNSIGNED_BYTE,
- );
- this._clearColor = defaultValue(options.clearColor, Color.BLACK);
+ this._pixelDatatype = pixelDatatype;
+ this._clearColor = clearColor;
this._uniformMap = undefined;
this._command = undefined;
@@ -143,18 +144,14 @@ function PostProcessStage(options) {
const passState = new PassState();
passState.scissorTest = {
enabled: true,
- rectangle: defined(options.scissorRectangle)
- ? BoundingRectangle.clone(options.scissorRectangle)
+ rectangle: defined(scissorRectangle)
+ ? BoundingRectangle.clone(scissorRectangle)
: new BoundingRectangle(),
};
this._passState = passState;
this._ready = false;
- let name = options.name;
- if (!defined(name)) {
- name = createGuid();
- }
this._name = name;
this._logDepthChanged = undefined;
diff --git a/packages/engine/Source/Scene/PostProcessStageCollection.js b/packages/engine/Source/Scene/PostProcessStageCollection.js
index 59ca0e293923..20019fa840cd 100644
--- a/packages/engine/Source/Scene/PostProcessStageCollection.js
+++ b/packages/engine/Source/Scene/PostProcessStageCollection.js
@@ -155,32 +155,20 @@ Object.defineProperties(PostProcessStageCollection.prototype, {
* surface receives light and regardless of the light's position.
*
*
- * The uniforms have the following properties: intensity, bias, lengthCap,
- * stepSize, frustumLength, ambientOcclusionOnly,
- * delta, sigma, and blurStepSize.
- *
+ * The uniforms have the following properties:
*
*
intensity is a scalar value used to lighten or darken the shadows exponentially. Higher values make the shadows darker. The default value is 3.0.
- *
*
bias is a scalar value representing an angle in radians. If the dot product between the normal of the sample and the vector to the camera is less than this value,
* sampling stops in the current direction. This is used to remove shadows from near planar edges. The default value is 0.1.
- *
*
lengthCap is a scalar value representing a length in meters. If the distance from the current sample to first sample is greater than this value,
* sampling stops in the current direction. The default value is 0.26.
- *
- *
stepSize is a scalar value indicating the distance to the next texel sample in the current direction. The default value is 1.95.
- *
- *
frustumLength is a scalar value in meters. If the current fragment has a distance from the camera greater than this value, ambient occlusion is not computed for the fragment.
- * The default value is 1000.0.
- *
+ *
directionCount is the number of directions along which the ray marching will search for occluders. The default value is 8.
+ *
stepCount is the number of steps the ray marching will take along each direction. The default value is 32.
+ *
randomTexture is a texture where the red channel is a random value in [0.0, 1.0]. The default value is undefined. This texture needs to be set.
*
ambientOcclusionOnly is a boolean value. When true, only the shadows generated are written to the output. When false, the input texture is modulated
* with the ambient occlusion. This is a useful debug option for seeing the effects of changing the uniform values. The default value is false.
*
*
- * delta, sigma, and blurStepSize are the same properties as {@link PostProcessStageLibrary#createBlurStage}.
- * The blur is applied to the shadows generated from the image to make them smoother.
- *
- *
* When enabled, this stage will execute before all others.
*
*
diff --git a/packages/engine/Source/Scene/PostProcessStageLibrary.js b/packages/engine/Source/Scene/PostProcessStageLibrary.js
index f4329daee77f..9168c068da54 100644
--- a/packages/engine/Source/Scene/PostProcessStageLibrary.js
+++ b/packages/engine/Source/Scene/PostProcessStageLibrary.js
@@ -476,27 +476,19 @@ PostProcessStageLibrary.createBloomStage = function () {
* surface receives light and regardless of the light's position.
*
*
- * The uniforms have the following properties: intensity, bias, lengthCap,
- * stepSize, frustumLength, randomTexture, ambientOcclusionOnly,
- * delta, sigma, and blurStepSize.
- *
+ * The uniforms have the following properties:
*
*
intensity is a scalar value used to lighten or darken the shadows exponentially. Higher values make the shadows darker. The default value is 3.0.
*
bias is a scalar value representing an angle in radians. If the dot product between the normal of the sample and the vector to the camera is less than this value,
* sampling stops in the current direction. This is used to remove shadows from near planar edges. The default value is 0.1.
*
lengthCap is a scalar value representing a length in meters. If the distance from the current sample to first sample is greater than this value,
* sampling stops in the current direction. The default value is 0.26.
- *
stepSize is a scalar value indicating the distance to the next texel sample in the current direction. The default value is 1.95.
- *
frustumLength is a scalar value in meters. If the current fragment has a distance from the camera greater than this value, ambient occlusion is not computed for the fragment.
- * The default value is 1000.0.
+ *
directionCount is the number of directions along which the ray marching will search for occluders. The default value is 8.
+ *
stepCount is the number of steps the ray marching will take along each direction. The default value is 32.
*
randomTexture is a texture where the red channel is a random value in [0.0, 1.0]. The default value is undefined. This texture needs to be set.
*
ambientOcclusionOnly is a boolean value. When true, only the shadows generated are written to the output. When false, the input texture is modulated
* with the ambient occlusion. This is a useful debug option for seeing the effects of changing the uniform values. The default value is false.
*
- *
- * delta, sigma, and blurStepSize are the same properties as {@link PostProcessStageLibrary#createBlurStage}.
- * The blur is applied to the shadows generated from the image to make them smoother.
- *
* @return {PostProcessStageComposite} A post-process stage that applies an ambient occlusion effect.
*
* @private
@@ -509,24 +501,18 @@ PostProcessStageLibrary.createAmbientOcclusionStage = function () {
intensity: 3.0,
bias: 0.1,
lengthCap: 0.26,
- stepSize: 1.95,
- frustumLength: 1000.0,
+ directionCount: 8,
+ stepCount: 32,
randomTexture: undefined,
},
});
- const blur = createBlur("czm_ambient_occlusion_blur");
- blur.uniforms.stepSize = 0.86;
- const generateAndBlur = new PostProcessStageComposite({
- name: "czm_ambient_occlusion_generate_blur",
- stages: [generate, blur],
- });
const ambientOcclusionModulate = new PostProcessStage({
name: "czm_ambient_occlusion_composite",
fragmentShader: AmbientOcclusionModulate,
uniforms: {
ambientOcclusionOnly: false,
- ambientOcclusionTexture: generateAndBlur.name,
+ ambientOcclusionTexture: generate.name,
},
});
@@ -556,20 +542,20 @@ PostProcessStageLibrary.createAmbientOcclusionStage = function () {
generate.uniforms.lengthCap = value;
},
},
- stepSize: {
+ directionCount: {
get: function () {
- return generate.uniforms.stepSize;
+ return generate.uniforms.directionCount;
},
set: function (value) {
- generate.uniforms.stepSize = value;
+ generate.uniforms.directionCount = value;
},
},
- frustumLength: {
+ stepCount: {
get: function () {
- return generate.uniforms.frustumLength;
+ return generate.uniforms.stepCount;
},
set: function (value) {
- generate.uniforms.frustumLength = value;
+ generate.uniforms.stepCount = value;
},
},
randomTexture: {
@@ -580,30 +566,6 @@ PostProcessStageLibrary.createAmbientOcclusionStage = function () {
generate.uniforms.randomTexture = value;
},
},
- delta: {
- get: function () {
- return blur.uniforms.delta;
- },
- set: function (value) {
- blur.uniforms.delta = value;
- },
- },
- sigma: {
- get: function () {
- return blur.uniforms.sigma;
- },
- set: function (value) {
- blur.uniforms.sigma = value;
- },
- },
- blurStepSize: {
- get: function () {
- return blur.uniforms.stepSize;
- },
- set: function (value) {
- blur.uniforms.stepSize = value;
- },
- },
ambientOcclusionOnly: {
get: function () {
return ambientOcclusionModulate.uniforms.ambientOcclusionOnly;
@@ -616,7 +578,7 @@ PostProcessStageLibrary.createAmbientOcclusionStage = function () {
return new PostProcessStageComposite({
name: "czm_ambient_occlusion",
- stages: [generateAndBlur, ambientOcclusionModulate],
+ stages: [generate, ambientOcclusionModulate],
inputPreviousStageTexture: false,
uniforms: uniforms,
});
diff --git a/packages/engine/Source/Scene/PropertyAttributeProperty.js b/packages/engine/Source/Scene/PropertyAttributeProperty.js
index 607fb8611470..70c04cfd1ab4 100644
--- a/packages/engine/Source/Scene/PropertyAttributeProperty.js
+++ b/packages/engine/Source/Scene/PropertyAttributeProperty.js
@@ -80,7 +80,7 @@ Object.defineProperties(PropertyAttributeProperty.prototype, {
* True if offset/scale should be applied. If both offset/scale were
* undefined, they default to identity so this property is set false
*
- * @memberof MetadataClassProperty.prototype
+ * @memberof PropertyAttributeProperty.prototype
* @type {boolean}
* @readonly
* @private
@@ -94,7 +94,13 @@ Object.defineProperties(PropertyAttributeProperty.prototype, {
/**
* The offset to be added to property values as part of the value transform.
*
- * @memberof MetadataClassProperty.prototype
+ * This is always defined, even when `hasValueTransform` is `false`. If
+ * the property JSON itself did not define it, then it will inherit the
+ * value from the `MetadataClassProperty`. There, it also is always
+ * defined, and initialized to the default value if it was not contained
+ * in the class property JSON.
+ *
+ * @memberof PropertyAttributeProperty.prototype
* @type {number|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4}
* @readonly
* @private
@@ -108,7 +114,13 @@ Object.defineProperties(PropertyAttributeProperty.prototype, {
/**
* The scale to be multiplied to property values as part of the value transform.
*
- * @memberof MetadataClassProperty.prototype
+ * This is always defined, even when `hasValueTransform` is `false`. If
+ * the property JSON itself did not define it, then it will inherit the
+ * value from the `MetadataClassProperty`. There, it also is always
+ * defined, and initialized to the default value if it was not contained
+ * in the class property JSON.
+ *
+ * @memberof PropertyAttributeProperty.prototype
* @type {number|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4}
* @readonly
* @private
diff --git a/packages/engine/Source/Scene/PropertyTextureProperty.js b/packages/engine/Source/Scene/PropertyTextureProperty.js
index 765c2507313e..cbb7508cc11e 100644
--- a/packages/engine/Source/Scene/PropertyTextureProperty.js
+++ b/packages/engine/Source/Scene/PropertyTextureProperty.js
@@ -111,6 +111,12 @@ Object.defineProperties(PropertyTextureProperty.prototype, {
/**
* The offset to be added to property values as part of the value transform.
*
+ * This is always defined, even when `hasValueTransform` is `false`. If
+ * the property JSON itself did not define it, then it will inherit the
+ * value from the `MetadataClassProperty`. There, it also is always
+ * defined, and initialized to the default value if it was not contained
+ * in the class property JSON.
+ *
* @memberof PropertyTextureProperty.prototype
* @type {number|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4}
* @readonly
@@ -125,6 +131,12 @@ Object.defineProperties(PropertyTextureProperty.prototype, {
/**
* The scale to be multiplied to property values as part of the value transform.
*
+ * This is always defined, even when `hasValueTransform` is `false`. If
+ * the property JSON itself did not define it, then it will inherit the
+ * value from the `MetadataClassProperty`. There, it also is always
+ * defined, and initialized to the default value if it was not contained
+ * in the class property JSON.
+ *
* @memberof PropertyTextureProperty.prototype
* @type {number|Cartesian2|Cartesian3|Cartesian4|Matrix2|Matrix3|Matrix4}
* @readonly
diff --git a/packages/engine/Source/Scene/Scene.js b/packages/engine/Source/Scene/Scene.js
index e751dda94087..e438fdf87e32 100644
--- a/packages/engine/Source/Scene/Scene.js
+++ b/packages/engine/Source/Scene/Scene.js
@@ -79,6 +79,7 @@ import VoxelCell from "./VoxelCell.js";
import VoxelPrimitive from "./VoxelPrimitive.js";
import getMetadataClassProperty from "./getMetadataClassProperty.js";
import PickedMetadataInfo from "./PickedMetadataInfo.js";
+import getMetadataProperty from "./getMetadataProperty.js";
const requestRenderAfterFrame = function (scene) {
return function () {
@@ -4402,7 +4403,8 @@ Scene.prototype.pickVoxel = function (windowPosition, width, height) {
* values from
* @param {string} propertyName The name of the metadata property to pick
* values from
- * @returns The metadata value
+ * @returns {MetadataValue|undefined} The metadata value, or `undefined` when
+ * no matching metadata was found at the given position
*
* @experimental This feature is not final and is subject to change without Cesium's standard deprecation policy.
*/
@@ -4426,7 +4428,11 @@ Scene.prototype.pickMetadata = function (
// Check if the picked object is a model that has structural
// metadata, with a schema that contains the specified
// property.
- const schema = pickedObject.detail?.model?.structuralMetadata?.schema;
+ const structuralMetadata = pickedObject.detail?.model?.structuralMetadata;
+ if (!defined(structuralMetadata)) {
+ return undefined;
+ }
+ const schema = structuralMetadata.schema;
const classProperty = getMetadataClassProperty(
schema,
schemaId,
@@ -4436,12 +4442,21 @@ Scene.prototype.pickMetadata = function (
if (!defined(classProperty)) {
return undefined;
}
+ const metadataProperty = getMetadataProperty(
+ structuralMetadata,
+ className,
+ propertyName,
+ );
+ if (!defined(metadataProperty)) {
+ return undefined;
+ }
const pickedMetadataInfo = new PickedMetadataInfo(
schemaId,
className,
propertyName,
classProperty,
+ metadataProperty,
);
const pickedMetadataValues = this._picking.pickMetadata(
diff --git a/packages/engine/Source/Scene/SkyBox.js b/packages/engine/Source/Scene/SkyBox.js
index aa175b9d405b..39ca3c8b942e 100644
--- a/packages/engine/Source/Scene/SkyBox.js
+++ b/packages/engine/Source/Scene/SkyBox.js
@@ -81,6 +81,8 @@ function SkyBox(options) {
this._attributeLocations = undefined;
this._useHdr = undefined;
+ this._hasError = false;
+ this._error = undefined;
}
/**
@@ -111,6 +113,15 @@ SkyBox.prototype.update = function (frameState, useHdr) {
return undefined;
}
+ // Throw any errors that had previously occurred asynchronously so they aren't
+ // ignored when running. See https://github.com/CesiumGS/cesium/pull/12307
+ if (this._hasError) {
+ const error = this._error;
+ this._hasError = false;
+ this._error = undefined;
+ throw error;
+ }
+
if (this._sources !== this.sources) {
this._sources = this.sources;
const sources = this.sources;
@@ -141,10 +152,18 @@ SkyBox.prototype.update = function (frameState, useHdr) {
if (typeof sources.positiveX === "string") {
// Given urls for cube-map images. Load them.
- loadCubeMap(context, this._sources).then(function (cubeMap) {
- that._cubeMap = that._cubeMap && that._cubeMap.destroy();
- that._cubeMap = cubeMap;
- });
+ loadCubeMap(context, this._sources)
+ .then(function (cubeMap) {
+ that._cubeMap = that._cubeMap && that._cubeMap.destroy();
+ that._cubeMap = cubeMap;
+ })
+ .catch((error) => {
+ // Defer throwing the error until the next call to update to prevent
+ // test from failing in `afterAll` if this is rejected after the test
+ // using the Skybox ends. See https://github.com/CesiumGS/cesium/pull/12307
+ this._hasError = true;
+ this._error = error;
+ });
} else {
this._cubeMap = this._cubeMap && this._cubeMap.destroy();
this._cubeMap = new CubeMap({
diff --git a/packages/engine/Source/Scene/UrlTemplateImageryProvider.js b/packages/engine/Source/Scene/UrlTemplateImageryProvider.js
index 48dcab645f46..e11c00dfa138 100644
--- a/packages/engine/Source/Scene/UrlTemplateImageryProvider.js
+++ b/packages/engine/Source/Scene/UrlTemplateImageryProvider.js
@@ -159,13 +159,13 @@ const pickFeaturesTags = combine(tags, {
* });
* // Access a Web Map Service (WMS) server.
* const wms = new Cesium.UrlTemplateImageryProvider({
- * url : 'https://programs.communications.gov.au/geoserver/ows?tiled=true&' +
- * 'transparent=true&format=image%2Fpng&exceptions=application%2Fvnd.ogc.se_xml&' +
- * 'styles=&service=WMS&version=1.1.1&request=GetMap&' +
- * 'layers=public%3AMyBroadband_Availability&srs=EPSG%3A3857&' +
+ * url : 'https://services.ga.gov.au/gis/services/NM_Hydrology_and_Marine_Points/MapServer/WMSServer?' +
+ * 'tiled=true&transparent=true&format=image%2Fpng&exceptions=application%2Fvnd.ogc.se_xml&' +
+ * 'styles=&service=WMS&version=1.3.0&request=GetMap&' +
+ * 'layers=Bores&crs=EPSG%3A3857&' +
* 'bbox={westProjected}%2C{southProjected}%2C{eastProjected}%2C{northProjected}&' +
* 'width=256&height=256',
- * rectangle : Cesium.Rectangle.fromDegrees(96.799393, -43.598214999057824, 153.63925700000001, -9.2159219997013)
+ * rectangle : Cesium.Rectangle.fromDegrees(95.0, -55.0, 170.0, -1.0) // From GetCapabilities EX_GeographicBoundingBox
* });
* // Using custom tags in your template url.
* const custom = new Cesium.UrlTemplateImageryProvider({
diff --git a/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js b/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
index f762d748dc36..9c7bad99e30d 100644
--- a/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
+++ b/packages/engine/Source/Scene/createGooglePhotorealistic3DTileset.js
@@ -4,23 +4,37 @@ import defined from "../Core/defined.js";
import IonResource from "../Core/IonResource.js";
import GoogleMaps from "../Core/GoogleMaps.js";
import Resource from "../Core/Resource.js";
+import oneTimeWarning from "../Core/oneTimeWarning.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
/**
- * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D Tiles tileset.
+ * Creates a {@link Cesium3DTileset} instance for the Google Photorealistic 3D
+ * Tiles tileset.
+ *
+ * Google Photorealistic 3D Tiles can only be used with the Google geocoder. To
+ * confirm that you are aware of this restriction pass
+ * `usingOnlyWithGoogleGeocoder: true` to the apiOptions. Otherwise a one time
+ * warning will be displayed when this function is called.
*
* @function
*
- * @param {string} [key=GoogleMaps.defaultApiKey] Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
- * @param {Cesium3DTileset.ConstructorOptions} [options] An object describing initialization options.
+ * @param {object} [apiOptions]
+ * @param {string} [apiOptions.key=GoogleMaps.defaultApiKey] Your API key to access Google Photorealistic 3D Tiles. See {@link https://developers.google.com/maps/documentation/javascript/get-api-key} for instructions on how to create your own key.
+ * @param {true} [apiOptions.onlyUsingWithGoogleGeocoder] Confirmation that this tileset will only be used with the Google geocoder.
+ * @param {Cesium3DTileset.ConstructorOptions} [tilesetOptions] An object describing initialization options.
* @returns {Promise}
*
* @see GoogleMaps
*
* @example
- * const viewer = new Cesium.Viewer("cesiumContainer");
+ * const viewer = new Cesium.Viewer("cesiumContainer", {
+ * geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+ * });
*
* try {
- * const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+ * const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ * onlyUsingWithGoogleGeocoder: true,
+ * });
* viewer.scene.primitives.add(tileset));
* } catch (error) {
* console.log(`Error creating tileset: ${error}`);
@@ -30,27 +44,52 @@ import Resource from "../Core/Resource.js";
* // Use your own Google Maps API key
* Cesium.GoogleMaps.defaultApiKey = "your-api-key";
*
- * const viewer = new Cesium.Viewer("cesiumContainer");
+ * const viewer = new Cesium.Viewer("cesiumContainer". {
+ * geocoder: Cesium.IonGeocodeProviderType.GOOGLE
+ * });
*
* try {
- * const tileset = await Cesium.createGooglePhotorealistic3DTileset();
+ * const tileset = await Cesium.createGooglePhotorealistic3DTileset({
+ * onlyUsingWithGoogleGeocoder: true,
+ * });
* viewer.scene.primitives.add(tileset));
* } catch (error) {
* console.log(`Error creating tileset: ${error}`);
* }
*/
-async function createGooglePhotorealistic3DTileset(key, options) {
- options = defaultValue(options, {});
- options.cacheBytes = defaultValue(options.cacheBytes, 1536 * 1024 * 1024);
- options.maximumCacheOverflowBytes = defaultValue(
- options.maximumCacheOverflowBytes,
+async function createGooglePhotorealistic3DTileset(apiOptions, tilesetOptions) {
+ tilesetOptions = defaultValue(tilesetOptions, {});
+ tilesetOptions.cacheBytes = defaultValue(
+ tilesetOptions.cacheBytes,
+ 1536 * 1024 * 1024,
+ );
+ tilesetOptions.maximumCacheOverflowBytes = defaultValue(
+ tilesetOptions.maximumCacheOverflowBytes,
1024 * 1024 * 1024,
);
- options.enableCollision = defaultValue(options.enableCollision, true);
+ tilesetOptions.enableCollision = defaultValue(
+ tilesetOptions.enableCollision,
+ true,
+ );
- key = defaultValue(key, GoogleMaps.defaultApiKey);
+ apiOptions = defaultValue(apiOptions, defaultValue.EMPTY_OBJECT);
+ if (typeof apiOptions === "string") {
+ deprecationWarning(
+ "createGooglePhotorealistic3DTileset(key)",
+ "createGooglePhotorealistic3DTileset(key) has been deprecated. It is replaced by createGooglePhotorealistic3DTileset({key}). It will be removed in Cesium 1.126.",
+ );
+ apiOptions = { key: apiOptions };
+ }
+ if (!apiOptions.onlyUsingWithGoogleGeocoder) {
+ oneTimeWarning(
+ "google-tiles-with-google-geocoder",
+ "Only the Google geocoder can be used with Google Photorealistic 3D Tiles. Set the `geocode` property of Viewer constructor options. You can set additionalOptions.onlyUsingWithGoogleGeocoder to hide this warning once you have configured the geocoder.",
+ );
+ }
+
+ const key = defaultValue(apiOptions.key, GoogleMaps.defaultApiKey);
if (!defined(key)) {
- return requestCachedIonTileset(options);
+ return requestCachedIonTileset(tilesetOptions);
}
let credits;
@@ -67,7 +106,7 @@ async function createGooglePhotorealistic3DTileset(key, options) {
credits: credits,
});
- return Cesium3DTileset.fromUrl(resource, options);
+ return Cesium3DTileset.fromUrl(resource, tilesetOptions);
}
const metadataCache = {};
diff --git a/packages/engine/Source/Scene/getMetadataProperty.js b/packages/engine/Source/Scene/getMetadataProperty.js
new file mode 100644
index 000000000000..291f4f639851
--- /dev/null
+++ b/packages/engine/Source/Scene/getMetadataProperty.js
@@ -0,0 +1,48 @@
+import defined from "../Core/defined.js";
+
+/**
+ * Return the `PropertyTextureProperty` from the given `StructuralMetadata`
+ * that matches the given description.
+ *
+ * If the given structural metadata is `undefined`, then `undefined` is returned.
+ *
+ * Otherwise, this method will check all the property textures in the given
+ * structural metadata.
+ *
+ * If it finds a property texture that has a class with an `_id` that matches
+ * the given name, and that contains a property for the given property name, then
+ * this property is returned.
+ *
+ * Otherwise, `undefined` is returned
+ *
+ * @param {StructuralMetadata} structuralMetadata The structural metadata
+ * @param {string} className The name of the metadata class
+ * @param {string} propertyName The name of the metadata property
+ * @returns {PropertyTextureProperty|undefined}
+ * @private
+ */
+function getMetadataProperty(structuralMetadata, className, propertyName) {
+ if (!defined(structuralMetadata)) {
+ return undefined;
+ }
+ const propertyTextures = structuralMetadata.propertyTextures;
+ for (const propertyTexture of propertyTextures) {
+ const metadataClass = propertyTexture.class;
+ if (metadataClass.id === className) {
+ const properties = propertyTexture.properties;
+ const property = properties[propertyName];
+ if (defined(property)) {
+ return property;
+ }
+ }
+ }
+ // Note: This could check for property attributes in a similar
+ // way. But since picking arbitrary property attributes via the
+ // frame buffer is not supported yet, returning "undefined" here
+ // causes the picking to bail out early and safely when no
+ // property texture was found.
+ // See https://github.com/CesiumGS/cesium/issues/12225
+ return undefined;
+}
+
+export default getMetadataProperty;
diff --git a/packages/engine/Source/Shaders/Builtin/Functions/reverseLogDepth.glsl b/packages/engine/Source/Shaders/Builtin/Functions/reverseLogDepth.glsl
index d28f45494104..41bdfd7a0072 100644
--- a/packages/engine/Source/Shaders/Builtin/Functions/reverseLogDepth.glsl
+++ b/packages/engine/Source/Shaders/Builtin/Functions/reverseLogDepth.glsl
@@ -4,7 +4,7 @@ float czm_reverseLogDepth(float logZ)
float near = czm_currentFrustum.x;
float far = czm_currentFrustum.y;
float log2Depth = logZ * czm_log2FarDepthFromNearPlusOne;
- float depthFromNear = pow(2.0, log2Depth) - 1.0;
+ float depthFromNear = exp2(log2Depth) - 1.0;
return far * (1.0 - near / (depthFromNear + near)) / (far - near);
#endif
return logZ;
diff --git a/packages/engine/Source/Shaders/ConvolveSpecularMapFS.glsl b/packages/engine/Source/Shaders/ConvolveSpecularMapFS.glsl
index 5eb290ecf3e1..5bb664548a11 100644
--- a/packages/engine/Source/Shaders/ConvolveSpecularMapFS.glsl
+++ b/packages/engine/Source/Shaders/ConvolveSpecularMapFS.glsl
@@ -62,7 +62,7 @@ void main() {
float NdotL = max(dot(V, L), 0.0);
if (NdotL > 0.0) {
- color += vec4(texture(u_radianceTexture, L).rgb, 1.0) * NdotL;
+ color += vec4(czm_textureCube(u_radianceTexture, L).rgb, 1.0) * NdotL;
weight += NdotL;
}
}
diff --git a/packages/engine/Source/Shaders/Model/ModelFS.glsl b/packages/engine/Source/Shaders/Model/ModelFS.glsl
index 0500c0b9f1ff..a6cb2827f60f 100644
--- a/packages/engine/Source/Shaders/Model/ModelFS.glsl
+++ b/packages/engine/Source/Shaders/Model/ModelFS.glsl
@@ -28,6 +28,13 @@ SelectedFeature selectedFeature;
void main()
{
+ #ifdef HAS_POINT_CLOUD_SHOW_STYLE
+ if (v_pointCloudShow == 0.0)
+ {
+ discard;
+ }
+ #endif
+
#ifdef HAS_MODEL_SPLITTER
modelSplitterStage();
#endif
diff --git a/packages/engine/Source/Shaders/Model/ModelVS.glsl b/packages/engine/Source/Shaders/Model/ModelVS.glsl
index b95b329f59ff..2164da1024bc 100644
--- a/packages/engine/Source/Shaders/Model/ModelVS.glsl
+++ b/packages/engine/Source/Shaders/Model/ModelVS.glsl
@@ -145,5 +145,13 @@ void main()
gl_PointSize *= show;
#endif
- gl_Position = show * positionClip;
+ // Important NOT to compute gl_Position = show * positionClip or we hit:
+ // https://github.com/CesiumGS/cesium/issues/11270
+ //
+ // We will discard points with v_pointCloudShow == 0 in the fragment shader.
+ gl_Position = positionClip;
+
+ #ifdef HAS_POINT_CLOUD_SHOW_STYLE
+ v_pointCloudShow = show;
+ #endif
}
diff --git a/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl b/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl
index 42535230cbdc..149de02fa560 100644
--- a/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl
+++ b/packages/engine/Source/Shaders/PostProcessStages/AmbientOcclusionGenerate.glsl
@@ -5,16 +5,21 @@ uniform sampler2D depthTexture;
uniform float intensity;
uniform float bias;
uniform float lengthCap;
-uniform float stepSize;
-uniform float frustumLength;
+uniform int stepCount;
+uniform int directionCount;
-vec3 pixelToEye(vec2 screenCoordinate)
+vec4 pixelToEye(vec2 screenCoordinate)
{
vec2 uv = screenCoordinate / czm_viewport.zw;
float depth = czm_readDepth(depthTexture, uv);
vec2 xy = 2.0 * uv - vec2(1.0);
vec4 posEC = czm_inverseProjection * vec4(xy, depth, 1.0);
- return posEC.xyz / posEC.w;
+ posEC = posEC / posEC.w;
+ // Avoid numerical error at far plane
+ if (depth >= 1.0) {
+ posEC.z = czm_currentFrustum.y;
+ }
+ return posEC;
}
// Reconstruct surface normal in eye coordinates, avoiding edges
@@ -22,10 +27,10 @@ vec3 getNormalXEdge(vec3 positionEC)
{
// Find the 3D surface positions at adjacent screen pixels
vec2 centerCoord = gl_FragCoord.xy;
- vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0));
- vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0));
- vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0));
- vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0));
+ vec3 positionLeft = pixelToEye(centerCoord + vec2(-1.0, 0.0)).xyz;
+ vec3 positionRight = pixelToEye(centerCoord + vec2(1.0, 0.0)).xyz;
+ vec3 positionUp = pixelToEye(centerCoord + vec2(0.0, 1.0)).xyz;
+ vec3 positionDown = pixelToEye(centerCoord + vec2(0.0, -1.0)).xyz;
// Compute potential tangent vectors
vec3 dx0 = positionEC - positionLeft;
@@ -40,22 +45,35 @@ vec3 getNormalXEdge(vec3 positionEC)
return normalize(cross(dx, dy));
}
+const float sqrtTwoPi = sqrt(czm_twoPi);
+
+float gaussian(float x, float standardDeviation) {
+ float argument = x / standardDeviation;
+ return exp(-0.5 * argument * argument) / (sqrtTwoPi * standardDeviation);
+}
+
void main(void)
{
- vec3 positionEC = pixelToEye(gl_FragCoord.xy);
+ vec4 positionEC = pixelToEye(gl_FragCoord.xy);
- if (positionEC.z > frustumLength)
+ // Exit if we are too close to the back of the frustum, where the depth value is invalid.
+ float maxValidDepth = czm_currentFrustum.y - lengthCap;
+ if (-positionEC.z > maxValidDepth)
{
out_FragColor = vec4(1.0);
return;
}
- vec3 normalEC = getNormalXEdge(positionEC);
+ vec3 normalEC = getNormalXEdge(positionEC.xyz);
+ float gaussianVariance = lengthCap * sqrt(-positionEC.z);
+ // Choose a step length such that the marching stops just before 3 * variance.
+ float stepLength = 3.0 * gaussianVariance / (float(stepCount) + 1.0);
+ float metersPerPixel = czm_metersPerPixel(positionEC, 1.0);
+ // Minimum step is 1 pixel to avoid double sampling
+ float pixelsPerStep = max(stepLength / metersPerPixel, 1.0);
+ stepLength = pixelsPerStep * metersPerPixel;
- float ao = 0.0;
-
- const int ANGLE_STEPS = 4;
- float angleStepScale = 1.0 / float(ANGLE_STEPS);
+ float angleStepScale = 1.0 / float(directionCount);
float angleStep = angleStepScale * czm_twoPi;
float cosStep = cos(angleStep);
float sinStep = sin(angleStep);
@@ -67,48 +85,59 @@ void main(void)
float randomVal = texture(randomTexture, randomTexCoord).x;
vec2 sampleDirection = vec2(cos(angleStep * randomVal), sin(angleStep * randomVal));
+ float ao = 0.0;
// Loop over sampling directions
- for (int i = 0; i < ANGLE_STEPS; i++)
+#if __VERSION__ == 300
+ for (int i = 0; i < directionCount; i++)
+ {
+#else
+ for (int i = 0; i < 16; i++)
{
+ if (i >= directionCount) {
+ break;
+ }
+#endif
sampleDirection = rotateStep * sampleDirection;
float localAO = 0.0;
- vec2 radialStep = stepSize * sampleDirection;
+ vec2 radialStep = pixelsPerStep * sampleDirection;
- for (int j = 0; j < 6; j++)
+#if __VERSION__ == 300
+ for (int j = 0; j < stepCount; j++)
+ {
+#else
+ for (int j = 0; j < 64; j++)
{
+ if (j >= stepCount) {
+ break;
+ }
+#endif
// Step along sampling direction, away from output pixel
- vec2 newCoords = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
+ vec2 samplePixel = floor(gl_FragCoord.xy + float(j + 1) * radialStep) + vec2(0.5);
// Exit if we stepped off the screen
- if (clamp(newCoords, vec2(0.0), czm_viewport.zw) != newCoords)
- {
+ if (clamp(samplePixel, vec2(0.0), czm_viewport.zw) != samplePixel) {
break;
}
- vec3 stepPositionEC = pixelToEye(newCoords);
- vec3 stepVector = stepPositionEC - positionEC;
- float stepLength = length(stepVector);
-
- if (stepLength > lengthCap)
- {
- break;
- }
+ // Compute step vector from output point to sampled point
+ vec4 samplePositionEC = pixelToEye(samplePixel);
+ vec3 stepVector = samplePositionEC.xyz - positionEC.xyz;
+ // Estimate the angle from the surface normal.
float dotVal = clamp(dot(normalEC, normalize(stepVector)), 0.0, 1.0);
- if (dotVal < bias)
- {
- dotVal = 0.0;
- }
+ dotVal = czm_branchFreeTernary(dotVal > bias, dotVal, 0.0);
+ dotVal = czm_branchFreeTernary(-samplePositionEC.z <= maxValidDepth, dotVal, 0.0);
- float weight = stepLength / lengthCap;
- weight = 1.0 - weight * weight;
- localAO = max(localAO, dotVal * weight);
+ // Weight contribution based on the distance from the output point
+ float sampleDistance = length(stepVector);
+ float weight = gaussian(sampleDistance, gaussianVariance);
+ localAO += weight * dotVal;
}
ao += localAO;
}
- ao *= angleStepScale;
+ ao *= angleStepScale * stepLength;
ao = 1.0 - clamp(ao, 0.0, 1.0);
ao = pow(ao, intensity);
out_FragColor = vec4(vec3(ao), 1.0);
diff --git a/packages/engine/Specs/Core/GoogleGeocoderServicesSpec.js b/packages/engine/Specs/Core/GoogleGeocoderServicesSpec.js
new file mode 100644
index 000000000000..5260dc265742
--- /dev/null
+++ b/packages/engine/Specs/Core/GoogleGeocoderServicesSpec.js
@@ -0,0 +1,84 @@
+import {
+ createGuid,
+ GeocoderService,
+ GoogleGeocoderService,
+ Resource,
+ Rectangle,
+} from "../../index.js";
+
+describe("Core/GoogleGeocoderService", function () {
+ it("conforms to GeocoderService interface", function () {
+ expect(GoogleGeocoderService).toConformToInterface(GeocoderService);
+ });
+
+ it("constructor throws without key", function () {
+ expect(function () {
+ return new GoogleGeocoderService({});
+ }).toThrowDeveloperError();
+ });
+
+ it("constructor sets key on _resource", function () {
+ const key = createGuid();
+ const service = new GoogleGeocoderService({ key });
+ expect(service._resource.toString()).toEqual(
+ `https://maps.googleapis.com/maps/api/geocode/json?key=${key}`,
+ );
+ });
+
+ it("geocode returns results for status=OK", async function () {
+ const key = createGuid();
+ const query = createGuid();
+ const service = new GoogleGeocoderService({ key });
+
+ spyOn(Resource.prototype, "fetchJson").and.resolveTo({
+ results: [
+ {
+ formatted_address:
+ "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
+ geometry: {
+ viewport: {
+ northeast: {
+ lat: 37.4237349802915,
+ lng: -122.083183169709,
+ },
+ southwest: {
+ lat: 37.4210370197085,
+ lng: -122.085881130292,
+ },
+ },
+ },
+ },
+ ],
+ status: "OK",
+ });
+
+ const results = await service.geocode(query);
+
+ expect(results).toEqual([
+ {
+ displayName: "1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA",
+ destination: Rectangle.fromDegrees(
+ -122.085881130292,
+ 37.4210370197085,
+ -122.083183169709,
+ 37.4237349802915,
+ ),
+ attribution: {
+ html: ``,
+ collapsible: false,
+ },
+ },
+ ]);
+ });
+
+ it("returns empty array for status=ZERO_RESULTS", async function () {
+ const service = new GoogleGeocoderService({ key: "key" });
+
+ spyOn(Resource.prototype, "fetchJson").and.resolveTo({
+ status: "ZERO_RESULTS",
+ });
+
+ const results = await service.geocode("test");
+ expect(results).toEqual([]);
+ });
+});
diff --git a/packages/engine/Specs/Core/ITwinPlatformSpec.js b/packages/engine/Specs/Core/ITwinPlatformSpec.js
new file mode 100644
index 000000000000..b43089c3f881
--- /dev/null
+++ b/packages/engine/Specs/Core/ITwinPlatformSpec.js
@@ -0,0 +1,414 @@
+import {
+ ITwinPlatform,
+ RequestErrorEvent,
+ Resource,
+ RuntimeError,
+} from "../../index.js";
+
+describe("ITwinPlatform", () => {
+ let previousAccessToken;
+ beforeEach(() => {
+ previousAccessToken = ITwinPlatform.defaultAccessToken;
+ ITwinPlatform.defaultAccessToken = "default-access-token";
+ });
+
+ afterEach(() => {
+ ITwinPlatform.defaultAccessToken = previousAccessToken;
+ });
+
+ describe("getExports", () => {
+ let requestSpy;
+ beforeEach(() => {
+ requestSpy = spyOn(Resource.prototype, "fetchJson");
+ });
+
+ it("rejects with no iModelId", async () => {
+ await expectAsync(
+ ITwinPlatform.getExports(undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected iModelId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no default access token set", async () => {
+ ITwinPlatform.defaultAccessToken = undefined;
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithDeveloperError(
+ "Must set ITwinPlatform.defaultAccessToken first",
+ );
+ });
+
+ it("rejects for API 401 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 401,
+ JSON.stringify({
+ error: { message: "failed", details: [{ code: "InvalidToken" }] },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unauthorized/);
+ });
+
+ it("rejects for API 403 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 403,
+ JSON.stringify({
+ error: { message: "failed", code: "Forbidden" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /forbidden/);
+ });
+
+ it("rejects for API 422 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 422,
+ JSON.stringify({
+ error: { message: "failed", code: "BadEntity" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unprocessable/);
+ });
+
+ it("rejects for API 429 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 429,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Too many/);
+ });
+
+ it("uses the default access token for the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return { exports: [] };
+ });
+ await ITwinPlatform.getExports("imodel-id-1");
+ expect(resource).toBeDefined();
+ expect(resource.headers["Authorization"]).toEqual(
+ "Bearer default-access-token",
+ );
+ });
+
+ it("uses the imodel id in the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return JSON.stringify({ exports: [] });
+ });
+ await ITwinPlatform.getExports("imodel-id-1");
+ expect(resource).toBeDefined();
+ expect(resource.url).toContain("imodel-id-1");
+ });
+ });
+
+ describe("getRealityDataMetadata", () => {
+ let requestSpy;
+ beforeEach(() => {
+ requestSpy = spyOn(Resource.prototype, "fetchJson");
+ });
+
+ it("rejects with no iTwinId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata(undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected iTwinId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no realityDataId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected realityDataId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no default access token set", async () => {
+ ITwinPlatform.defaultAccessToken = undefined;
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithDeveloperError(
+ "Must set ITwinPlatform.defaultAccessToken first",
+ );
+ });
+
+ it("rejects for API 401 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 401,
+ JSON.stringify({
+ error: { message: "failed", details: [{ code: "InvalidToken" }] },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unauthorized/);
+ });
+
+ it("rejects for API 403 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 403,
+ JSON.stringify({
+ error: { message: "failed", code: "Forbidden" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /forbidden/);
+ });
+
+ it("rejects for API 404 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 404,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /not found/);
+ });
+
+ it("rejects for API 422 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 422,
+ JSON.stringify({
+ error: { message: "failed", code: "BadEntity" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unprocessable/);
+ });
+
+ it("rejects for API 429 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 429,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Too many/);
+ });
+
+ it("uses the default access token for the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return { realityData: {} };
+ });
+ await ITwinPlatform.getRealityDataMetadata(
+ "itwin-id-1",
+ "reality-data-id-1",
+ );
+ expect(resource).toBeDefined();
+ expect(resource.headers["Authorization"]).toEqual(
+ "Bearer default-access-token",
+ );
+ });
+ });
+
+ describe("getRealityDataURL", () => {
+ let requestSpy;
+ beforeEach(() => {
+ requestSpy = spyOn(Resource.prototype, "fetchJson");
+ });
+
+ it("rejects with no iTwinId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected iTwinId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no realityDataId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL("itwin-id-1", undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected realityDataId to be typeof string, actual typeof was undefined",
+ );
+ });
+ it("rejects with no rootDocument", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ undefined,
+ ),
+ ).toBeRejectedWithDeveloperError(
+ "Expected rootDocument to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no default access token set", async () => {
+ ITwinPlatform.defaultAccessToken = undefined;
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithDeveloperError(
+ "Must set ITwinPlatform.defaultAccessToken first",
+ );
+ });
+
+ it("rejects for API 401 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 401,
+ JSON.stringify({
+ error: { message: "failed", details: [{ code: "InvalidToken" }] },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /Unauthorized/);
+ });
+
+ it("rejects for API 403 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 403,
+ JSON.stringify({
+ error: { message: "failed", code: "Forbidden" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /forbidden/);
+ });
+
+ it("rejects for API 404 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 404,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /not found/);
+ });
+
+ it("rejects for API 422 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 422,
+ JSON.stringify({
+ error: { message: "failed", code: "BadEntity" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /Unprocessable/);
+ });
+
+ it("rejects for API 429 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 429,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /Too many/);
+ });
+
+ it("uses the default access token for the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return {
+ _links: {
+ containerUrl: { href: "https://example.com/base/path?auth=token" },
+ },
+ };
+ });
+ await ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ expect(resource).toBeDefined();
+ expect(resource.headers["Authorization"]).toEqual(
+ "Bearer default-access-token",
+ );
+ });
+
+ it("combines the rootDocument with the access url", async () => {
+ requestSpy.and.resolveTo({
+ _links: {
+ containerUrl: { href: "https://example.com/base/path?auth=token" },
+ },
+ });
+ const tilesetUrl = await ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ expect(tilesetUrl).toEqual(
+ "https://example.com/base/path/root/document/path.json?auth=token",
+ );
+ });
+ });
+});
diff --git a/packages/engine/Specs/Core/IonGeocoderServiceSpec.js b/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
index 17951c615c02..719a762daffc 100644
--- a/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
+++ b/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
@@ -1,7 +1,9 @@
import {
+ DeveloperError,
GeocoderService,
GeocodeType,
Ion,
+ IonGeocodeProviderType,
IonGeocoderService,
} from "../../index.js";
@@ -26,20 +28,24 @@ describe("Core/IonGeocoderService", function () {
expect(service._accessToken).toEqual(Ion.defaultAccessToken);
expect(service._server.url).toEqual(Ion.defaultServer.url);
+ expect(service.geocodeProviderType).toEqual(IonGeocodeProviderType.DEFAULT);
});
it("creates with specified parameters", function () {
const accessToken = "123456";
const server = "http://not.ion.invalid/";
+ const geocodeProviderType = IonGeocodeProviderType.GOOGLE;
const service = new IonGeocoderService({
accessToken: accessToken,
server: server,
scene: scene,
+ geocodeProviderType,
});
expect(service._accessToken).toEqual(accessToken);
expect(service._server.url).toEqual(server);
+ expect(service.geocodeProviderType).toEqual(geocodeProviderType);
});
it("calls inner geocoder and returns result", async function () {
@@ -64,4 +70,47 @@ describe("Core/IonGeocoderService", function () {
expect(service.credit).toBeUndefined();
});
+
+ it("setting geocodeProviderType updates _pelias.url for GOOGLE", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.DEFAULT,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.GOOGLE;
+ expect(service._pelias.url.queryParameters["geocoder"]).toEqual("google");
+ });
+
+ it("setting geocodeProviderType updates _pelias.url for BING", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.DEFAULT,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.BING;
+ expect(service._pelias.url.queryParameters["geocoder"]).toEqual("bing");
+ });
+
+ it("setting geocodeProviderType updates _pelias.url for DEFAULT", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.GOOGLE,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.DEFAULT;
+ const queryParameters = service._pelias.url.queryParameters;
+ expect(queryParameters.geocoder).toBeUndefined();
+ // Make sure that it isn't 'geocoder: undefined'
+ expect(queryParameters.hasOwnProperty("geocoder")).toBeFalse();
+ });
+
+ it("throws if setting invalid geocodeProviderType", function () {
+ expect(
+ () => new IonGeocoderService({ scene, geocodeProviderType: "junk" }),
+ ).toThrowError(DeveloperError, /Invalid geocodeProviderType/);
+ expect(() => {
+ const service = new IonGeocoderService({ scene });
+ service.geocodeProviderType = "junk";
+ }).toThrowError(DeveloperError, /Invalid geocodeProviderType/);
+ });
});
diff --git a/packages/engine/Specs/DataSources/EntitySpec.js b/packages/engine/Specs/DataSources/EntitySpec.js
index 4edfdbffc4da..33ce89a6d98e 100644
--- a/packages/engine/Specs/DataSources/EntitySpec.js
+++ b/packages/engine/Specs/DataSources/EntitySpec.js
@@ -4,6 +4,7 @@ import {
Matrix3,
Matrix4,
Quaternion,
+ TrackingReferenceFrame,
TimeInterval,
TimeIntervalCollection,
Transforms,
@@ -54,11 +55,15 @@ describe("DataSources/Entity", function () {
expect(entity.viewFrom).toBeUndefined();
expect(entity.wall).toBeUndefined();
expect(entity.entityCollection).toBeUndefined();
+ expect(entity.trackingReferenceFrame).toBe(
+ TrackingReferenceFrame.AUTODETECT,
+ );
const options = {
id: "someId",
name: "bob",
show: false,
+ trackingReferenceFrame: TrackingReferenceFrame.INERTIAL,
availability: new TimeIntervalCollection(),
parent: new Entity(),
customProperty: {},
@@ -88,6 +93,7 @@ describe("DataSources/Entity", function () {
expect(entity.id).toEqual(options.id);
expect(entity.name).toEqual(options.name);
expect(entity.show).toBe(options.show);
+ expect(entity.trackingReferenceFrame).toBe(options.trackingReferenceFrame);
expect(entity.availability).toBe(options.availability);
expect(entity.parent).toBe(options.parent);
expect(entity.customProperty).toBe(options.customProperty);
@@ -114,6 +120,7 @@ describe("DataSources/Entity", function () {
expect(entity.wall).toBeInstanceOf(WallGraphics);
expect(entity.entityCollection).toBeUndefined();
+ expect(entity.trackingReferenceFrame).toBe(TrackingReferenceFrame.INERTIAL);
});
it("isAvailable is always true if no availability defined.", function () {
diff --git a/packages/engine/Specs/DataSources/EntityViewSpec.js b/packages/engine/Specs/DataSources/EntityViewSpec.js
index 1406cf8207d3..61223cc1dd0b 100644
--- a/packages/engine/Specs/DataSources/EntityViewSpec.js
+++ b/packages/engine/Specs/DataSources/EntityViewSpec.js
@@ -6,6 +6,7 @@ import {
ConstantPositionProperty,
Entity,
EntityView,
+ TrackingReferenceFrame,
} from "../../index.js";
import createScene from "../../../../Specs/createScene.js";
@@ -74,6 +75,18 @@ describe(
const view = new EntityView(entity, scene);
view.update(JulianDate.now());
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.INERTIAL;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("uses entity bounding sphere", function () {
@@ -92,6 +105,27 @@ describe(
new BoundingSphere(new Cartesian3(3, 4, 5), 6),
);
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.INERTIAL;
+ view.update(
+ JulianDate.now(),
+ new BoundingSphere(new Cartesian3(3, 4, 5), 6),
+ );
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
+ view.update(
+ JulianDate.now(),
+ new BoundingSphere(new Cartesian3(3, 4, 5), 6),
+ );
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(
+ JulianDate.now(),
+ new BoundingSphere(new Cartesian3(3, 4, 5), 6),
+ );
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("uses entity viewFrom if available and boundingsphere is supplied", function () {
@@ -109,6 +143,18 @@ describe(
);
view.update(JulianDate.now());
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.INERTIAL;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("update throws without time parameter", function () {
diff --git a/packages/engine/Specs/DataSources/SampledPropertySpec.js b/packages/engine/Specs/DataSources/SampledPropertySpec.js
index 3caa5d99fe6c..e6ee6edc9335 100644
--- a/packages/engine/Specs/DataSources/SampledPropertySpec.js
+++ b/packages/engine/Specs/DataSources/SampledPropertySpec.js
@@ -110,6 +110,28 @@ describe("DataSources/SampledProperty", function () {
expect(property.getValue(new JulianDate(0.5, 0))).toEqual(7.5);
});
+ it("getSample works", function () {
+ const times = [
+ new JulianDate(0, 0),
+ new JulianDate(1, 0),
+ new JulianDate(2, 0),
+ ];
+ const values = [7, 8, 9];
+
+ const property = new SampledProperty(Number);
+ property.addSamples(times, values);
+
+ expect(property.getSample(0)).toEqual(times[0]);
+ expect(property.getSample(1)).toEqual(times[1]);
+ expect(property.getSample(2)).toEqual(times[2]);
+ expect(property.getSample(3)).toBe(undefined);
+
+ expect(property.getSample(-1)).toBe(times[2]);
+ expect(property.getSample(-2)).toBe(times[1]);
+ expect(property.getSample(-3)).toBe(times[0]);
+ expect(property.getSample(-4)).toBe(undefined);
+ });
+
it("can remove a sample at a date", function () {
const times = [
new JulianDate(0, 0),
diff --git a/packages/engine/Specs/Renderer/TextureSpec.js b/packages/engine/Specs/Renderer/TextureSpec.js
index 609a6a95da47..b9cd1b386199 100644
--- a/packages/engine/Specs/Renderer/TextureSpec.js
+++ b/packages/engine/Specs/Renderer/TextureSpec.js
@@ -16,1075 +16,1203 @@ import {
} from "../../index.js";
import createContext from "../../../../Specs/createContext.js";
+import createWebglVersionHelper from "../createWebglVersionHelper.js";
describe(
"Renderer/Texture",
function () {
- let context;
- let greenImage;
- let blueImage;
- let blueAlphaImage;
- let blueOverRedImage;
- let blueOverRedFlippedImage;
- let red16x16Image;
-
- let greenKTX2Image;
- let greenBasisKTX2Image;
-
- const fs =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = texture(u_texture, vec2(0.0)); }";
- const fsLuminanceAlpha =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = vec4(texture(u_texture, vec2(0.0)).ra, 0.0, 1.0); }";
- let texture;
- const uniformMap = {
- u_texture: function () {
- return texture;
- },
- };
-
- beforeAll(function () {
- context = createContext();
- const promises = [];
- promises.push(
- Resource.fetchImage("./Data/Images/Green.png").then(function (image) {
- greenImage = image;
- }),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/Blue.png").then(function (image) {
- blueImage = image;
- }),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/BlueAlpha.png").then(
- function (image) {
- blueAlphaImage = image;
- },
- ),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/BlueOverRed.png").then(
- function (image) {
- blueOverRedImage = image;
- },
- ),
- );
- // Load this image as an ImageBitmap
- promises.push(
- Resource.fetchImage({
- url: "./Data/Images/BlueOverRed.png",
- preferImageBitmap: true,
- }).then(function (image) {
- blueOverRedFlippedImage = image;
- }),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/Red16x16.png").then(
- function (image) {
- red16x16Image = image;
- },
- ),
- );
-
- const resource = Resource.createIfNeeded("./Data/Images/Green4x4.ktx2");
- const loadPromise = resource.fetchArrayBuffer();
- promises.push(
- loadPromise.then(function (buffer) {
- const promise = KTX2Transcoder.transcode(buffer, {});
- return promise.then(function (result) {
- greenKTX2Image = result;
- });
- }),
- );
+ createWebglVersionHelper(createTextureSpecs);
+
+ function createTextureSpecs(contextOptions) {
+ let context;
+ let greenImage;
+ let blueImage;
+ let blueAlphaImage;
+ let blueOverRedImage;
+ let blueOverRedFlippedImage;
+ let red16x16Image;
+
+ let greenKTX2Image;
+ let greenBasisKTX2Image;
+
+ const fs =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = texture(u_texture, vec2(0.0)); }";
+ const fsLuminanceAlpha =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = vec4(texture(u_texture, vec2(0.0)).ra, 0.0, 1.0); }";
+ let texture;
+ const uniformMap = {
+ u_texture: function () {
+ return texture;
+ },
+ };
- if (context.supportsBasis) {
+ beforeAll(function () {
+ context = createContext(contextOptions);
+ const promises = [];
promises.push(
- loadKTX2("./Data/Images/Green4x4_ETC1S.ktx2").then(function (image) {
- greenBasisKTX2Image = image;
+ Resource.fetchImage("./Data/Images/Green.png").then(function (image) {
+ greenImage = image;
}),
);
- }
-
- return Promise.all(promises);
- });
-
- afterAll(function () {
- context.destroyForSpecs();
- });
-
- let blueImageHeight, blueImageWidth;
- beforeEach(function () {
- blueImageHeight = blueImage.height;
- blueImageWidth = blueImage.width;
- });
-
- afterEach(function () {
- blueImage.height = blueImageHeight;
- blueImage.width = blueImageWidth;
- texture = texture && texture.destroy();
- });
-
- it("has expected default values for pixel format and datatype", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(texture.id).toBeDefined();
- expect(texture.pixelFormat).toEqual(PixelFormat.RGBA);
- expect(texture.pixelDatatype).toEqual(PixelDatatype.UNSIGNED_BYTE);
- });
-
- it("can create a texture from the framebuffer", function () {
- const command = new ClearCommand({
- color: Color.RED,
- });
- command.execute(context);
-
- texture = Texture.fromFramebuffer({
- context: context,
- });
-
- const expectedWidth = context.canvas.clientWidth;
- const expectedHeight = context.canvas.clientHeight;
- expect(texture.width).toEqual(expectedWidth);
- expect(texture.height).toEqual(expectedHeight);
- expect(texture.sizeInBytes).toEqual(
- expectedWidth *
- expectedHeight *
- PixelFormat.componentsLength(texture.pixelFormat),
- );
-
- command.color = Color.WHITE;
- command.execute(context);
- expect(context).toReadPixels([255, 255, 255, 255]);
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("can copy from the framebuffer", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGB,
- });
-
- // Render blue
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([0, 0, 255, 255]);
-
- // Clear to red
- const command = new ClearCommand({
- color: Color.RED,
- });
- command.execute(context);
- expect(context).toReadPixels(Color.RED.toBytes());
-
- texture.copyFromFramebuffer();
-
- const expectedWidth = context.canvas.clientWidth;
- const expectedHeight = context.canvas.clientHeight;
- expect(texture.width).toEqual(expectedWidth);
- expect(texture.height).toEqual(expectedHeight);
- expect(texture.sizeInBytes).toEqual(
- expectedWidth *
- expectedHeight *
- PixelFormat.componentsLength(texture.pixelFormat),
- );
-
- // Clear to white
- command.color = Color.WHITE;
- command.execute(context);
- expect(context).toReadPixels(Color.WHITE.toBytes());
-
- // Render red
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("draws the expected texture color", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([0, 0, 255, 255]);
- });
-
- it("cannot flip texture when using ImageBitmap", function () {
- const topColor = new Color(0.0, 0.0, 1.0, 1.0);
- let bottomColor = new Color(1.0, 0.0, 0.0, 1.0);
-
- return Resource.supportsImageBitmapOptions().then(
- function (supportsImageBitmapOptions) {
- if (supportsImageBitmapOptions) {
- // When imageBitmapOptions is supported, flipY on texture upload is ignored.
- bottomColor = topColor;
- }
-
- texture = new Texture({
- context: context,
- source: blueOverRedFlippedImage,
- pixelFormat: PixelFormat.RGBA,
- flipY: false,
- });
+ promises.push(
+ Resource.fetchImage("./Data/Images/Blue.png").then(function (image) {
+ blueImage = image;
+ }),
+ );
+ promises.push(
+ Resource.fetchImage("./Data/Images/BlueAlpha.png").then(
+ function (image) {
+ blueAlphaImage = image;
+ },
+ ),
+ );
+ promises.push(
+ Resource.fetchImage("./Data/Images/BlueOverRed.png").then(
+ function (image) {
+ blueOverRedImage = image;
+ },
+ ),
+ );
+ // Load this image as an ImageBitmap
+ promises.push(
+ Resource.fetchImage({
+ url: "./Data/Images/BlueOverRed.png",
+ preferImageBitmap: true,
+ }).then(function (image) {
+ blueOverRedFlippedImage = image;
+ }),
+ );
+ promises.push(
+ Resource.fetchImage("./Data/Images/Red16x16.png").then(
+ function (image) {
+ red16x16Image = image;
+ },
+ ),
+ );
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(topColor.toBytes());
+ const resource = Resource.createIfNeeded("./Data/Images/Green4x4.ktx2");
+ const loadPromise = resource.fetchArrayBuffer();
+ promises.push(
+ loadPromise.then(function (buffer) {
+ const promise = KTX2Transcoder.transcode(buffer, {});
+ return promise.then(function (result) {
+ greenKTX2Image = result;
+ });
+ }),
+ );
- // Flip the texture.
- texture = new Texture({
- context: context,
- source: blueOverRedFlippedImage,
- pixelFormat: PixelFormat.RGBA,
- flipY: true,
- });
+ if (context.supportsBasis) {
+ promises.push(
+ loadKTX2("./Data/Images/Green4x4_ETC1S.ktx2").then(
+ function (image) {
+ greenBasisKTX2Image = image;
+ },
+ ),
+ );
+ }
+
+ return Promise.all(promises);
+ });
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(bottomColor.toBytes());
- },
- );
- });
+ afterAll(function () {
+ context.destroyForSpecs();
+ });
- it("draws the expected floating-point texture color", function () {
- if (!context.floatingPointTexture) {
- return;
- }
+ let blueImageHeight, blueImageWidth;
+ beforeEach(function () {
+ blueImageHeight = blueImage.height;
+ blueImageWidth = blueImage.width;
+ });
- const color = new Color(0.2, 0.4, 0.6, 1.0);
- const floats = new Float32Array([
- color.red,
- color.green,
- color.blue,
- color.alpha,
- ]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.FLOAT,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: floats,
- },
+ afterEach(function () {
+ blueImage.height = blueImageHeight;
+ blueImage.width = blueImageWidth;
+ texture = texture && texture.destroy();
});
- expect(texture.sizeInBytes).toEqual(16);
+ it("has expected default values for pixel format and datatype", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ });
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ expect(texture.id).toBeDefined();
+ expect(texture.pixelFormat).toEqual(PixelFormat.RGBA);
+ expect(texture.pixelDatatype).toEqual(PixelDatatype.UNSIGNED_BYTE);
+ });
- it("draws the expected floating-point texture color with linear filtering", function () {
- if (!context.floatingPointTexture) {
- return;
- }
+ it("can create a texture from the framebuffer", function () {
+ const command = new ClearCommand({
+ color: Color.RED,
+ });
+ command.execute(context);
- const color0 = new Color(0.2, 0.4, 0.6, 1.0);
- const color1 = new Color(0.1, 0.3, 0.5, 1.0);
- const floats = new Float32Array([
- color0.red,
- color0.green,
- color0.blue,
- color0.alpha,
- color1.red,
- color1.green,
- color1.blue,
- color1.alpha,
- ]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.FLOAT,
- source: {
- width: 2,
- height: 1,
- arrayBufferView: floats,
- },
- sampler: new Sampler({
- wrapS: TextureWrap.CLAMP_TO_EDGE,
- wrapT: TextureWrap.CLAMP_TO_EDGE,
- minificationFilter: TextureMinificationFilter.LINEAR,
- magnificationFilter: TextureMagnificationFilter.LINEAR,
- }),
- });
+ texture = Texture.fromFramebuffer({
+ context: context,
+ });
- expect(texture.sizeInBytes).toEqual(32);
+ const expectedWidth = context.canvas.clientWidth;
+ const expectedHeight = context.canvas.clientHeight;
+ expect(texture.width).toEqual(expectedWidth);
+ expect(texture.height).toEqual(expectedHeight);
+ expect(texture.sizeInBytes).toEqual(
+ expectedWidth *
+ expectedHeight *
+ PixelFormat.componentsLength(texture.pixelFormat),
+ );
- const fs =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
+ command.color = Color.WHITE;
+ command.execute(context);
+ expect(context).toReadPixels([255, 255, 255, 255]);
- if (!context.textureFloatLinear) {
expect({
context: context,
fragmentShader: fs,
uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender(color1.toBytes());
- } else {
- Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
- Color.multiplyByScalar(color1, 0.5, color1);
- Color.add(color0, color1, color1);
+ }).contextToRender([255, 0, 0, 255]);
+ });
+
+ it("can copy from the framebuffer", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGB,
+ });
+
+ // Render blue
expect({
context: context,
fragmentShader: fs,
uniformMap: uniformMap,
- }).contextToRender(color1.toBytes());
- }
- });
+ }).contextToRender([0, 0, 255, 255]);
- it("draws the expected half floating-point texture color", function () {
- if (!context.halfFloatingPointTexture) {
- return;
- }
+ // Clear to red
+ const command = new ClearCommand({
+ color: Color.RED,
+ });
+ command.execute(context);
+ expect(context).toReadPixels(Color.RED.toBytes());
+
+ texture.copyFromFramebuffer();
+
+ const expectedWidth = context.canvas.clientWidth;
+ const expectedHeight = context.canvas.clientHeight;
+ expect(texture.width).toEqual(expectedWidth);
+ expect(texture.height).toEqual(expectedHeight);
+ expect(texture.sizeInBytes).toEqual(
+ expectedWidth *
+ expectedHeight *
+ PixelFormat.componentsLength(texture.pixelFormat),
+ );
- const color = new Color(0.2, 0.4, 0.6, 1.0);
- const floats = new Uint16Array([12902, 13926, 14541, 15360]);
+ // Clear to white
+ command.color = Color.WHITE;
+ command.execute(context);
+ expect(context).toReadPixels(Color.WHITE.toBytes());
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.HALF_FLOAT,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: floats,
- },
- flipY: false,
+ // Render red
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([255, 0, 0, 255]);
});
- expect(texture.sizeInBytes).toEqual(8);
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ it("draws the expected texture color", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
- it("draws the expected half floating-point texture color with linear filtering", function () {
- if (!context.halfFloatingPointTexture) {
- return;
- }
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([0, 0, 255, 255]);
+ });
- const color0 = new Color(0.2, 0.4, 0.6, 1.0);
- const color1 = new Color(0.1, 0.3, 0.5, 1.0);
- const floats = new Uint16Array([
- 12902, 13926, 14541, 15360, 11878, 13517, 14336, 15360,
- ]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.HALF_FLOAT,
- source: {
- width: 2,
- height: 1,
- arrayBufferView: floats,
- },
- flipY: false,
+ it("cannot flip texture when using ImageBitmap", function () {
+ const topColor = new Color(0.0, 0.0, 1.0, 1.0);
+ let bottomColor = new Color(1.0, 0.0, 0.0, 1.0);
+
+ return Resource.supportsImageBitmapOptions().then(
+ function (supportsImageBitmapOptions) {
+ if (supportsImageBitmapOptions) {
+ // When imageBitmapOptions is supported, flipY on texture upload is ignored.
+ bottomColor = topColor;
+ }
+
+ texture = new Texture({
+ context: context,
+ source: blueOverRedFlippedImage,
+ pixelFormat: PixelFormat.RGBA,
+ flipY: false,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(topColor.toBytes());
+
+ // Flip the texture.
+ texture = new Texture({
+ context: context,
+ source: blueOverRedFlippedImage,
+ pixelFormat: PixelFormat.RGBA,
+ flipY: true,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(bottomColor.toBytes());
+ },
+ );
});
- expect(texture.sizeInBytes).toEqual(16);
+ it("draws the expected floating-point texture color", function () {
+ if (!context.floatingPointTexture) {
+ return;
+ }
- const fs =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
+ const color = new Color(0.2, 0.4, 0.6, 1.0);
+ const floats = new Float32Array([
+ color.red,
+ color.green,
+ color.blue,
+ color.alpha,
+ ]);
- if (!context.textureHalfFloatLinear) {
- expect({
+ texture = new Texture({
context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender(color1.toBytes());
- } else {
- Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
- Color.multiplyByScalar(color1, 0.5, color1);
- Color.add(color0, color1, color1);
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.FLOAT,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ });
+
+ expect(texture.sizeInBytes).toEqual(16);
+
expect({
context: context,
fragmentShader: fs,
uniformMap: uniformMap,
- }).contextToRender(color1.toBytes());
- }
- });
+ }).contextToRender(color.toBytes());
+ });
- it("draws the expected Basis compressed texture color", function () {
- if (!context.supportsBasis) {
- return;
- }
+ it("draws the expected floating-point texture color with linear filtering", function () {
+ if (!context.floatingPointTexture) {
+ return;
+ }
+
+ const color0 = new Color(0.2, 0.4, 0.6, 1.0);
+ const color1 = new Color(0.1, 0.3, 0.5, 1.0);
+ const floats = new Float32Array([
+ color0.red,
+ color0.green,
+ color0.blue,
+ color0.alpha,
+ color1.red,
+ color1.green,
+ color1.blue,
+ color1.alpha,
+ ]);
- texture = new Texture({
- context: context,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
- });
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.FLOAT,
+ source: {
+ width: 2,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ sampler: new Sampler({
+ wrapS: TextureWrap.CLAMP_TO_EDGE,
+ wrapT: TextureWrap.CLAMP_TO_EDGE,
+ minificationFilter: TextureMinificationFilter.LINEAR,
+ magnificationFilter: TextureMagnificationFilter.LINEAR,
+ }),
+ });
- expect(texture.sizeInBytes).toBe(8);
+ expect(texture.sizeInBytes).toEqual(32);
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRenderAndCall(function (color) {
- return expect(color).toEqualEpsilon([2, 255, 2, 255], 2);
- });
- });
+ const fs =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
- it("draws the expected KTX2 uncompressed texture color", function () {
- texture = new Texture({
- context: context,
- pixelFormat: greenKTX2Image.internalFormat,
- source: {
- width: greenKTX2Image.width,
- height: greenKTX2Image.height,
- arrayBufferView: greenKTX2Image.bufferView,
- },
+ if (!context.textureFloatLinear) {
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender(color1.toBytes());
+ } else {
+ Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
+ Color.multiplyByScalar(color1, 0.5, color1);
+ Color.add(color0, color1, color1);
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color1.toBytes());
+ }
});
- expect(texture.sizeInBytes).toBe(48);
+ it("draws the expected half floating-point texture color", function () {
+ if (!context.halfFloatingPointTexture) {
+ return;
+ }
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRenderAndCall(function (color) {
- return expect(color).toEqualEpsilon([0, 255, 24, 255], 2);
- });
- });
+ const color = new Color(0.2, 0.4, 0.6, 1.0);
+ const floats = new Uint16Array([12902, 13926, 14541, 15360]);
- it("renders with premultiplied alpha", function () {
- const cxt = createContext({
- webgl: {
- alpha: true,
- },
- });
- const texture = new Texture({
- context: cxt,
- source: blueAlphaImage,
- pixelFormat: PixelFormat.RGBA,
- preMultiplyAlpha: true,
- });
- const uniformMap = {
- u_texture: function () {
- return texture;
- },
- };
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.HALF_FLOAT,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ flipY: false,
+ });
- expect(texture.preMultiplyAlpha).toEqual(true);
- expect({
- context: cxt,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender([0, 0, 127, 127]);
-
- texture.destroy();
- cxt.destroyForSpecs();
- });
-
- it("draws textured blue and red points", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- let fragmentShaderSource = "";
- fragmentShaderSource += "uniform sampler2D u_texture;";
- fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
- fragmentShaderSource +=
- "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
-
- let txCoords;
- const um = {
- u_texture: function () {
- return texture;
- },
- u_txCoords: function () {
- return txCoords;
- },
- };
+ expect(texture.sizeInBytes).toEqual(8);
- // Blue on top
- txCoords = new Cartesian2(0.5, 0.75);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([0, 0, 255, 255]);
-
- // Red on bottom
- txCoords = new Cartesian2(0.5, 0.25);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("draws the expected luminance texture color", function () {
- const color = new Color(0.6, 0.6, 0.6, 1.0);
- const arrayBufferView = new Uint8Array([153]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.LUMINANCE,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: arrayBufferView,
- },
- flipY: false,
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color.toBytes());
});
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ it("draws the expected half floating-point texture color with linear filtering", function () {
+ if (!context.halfFloatingPointTexture) {
+ return;
+ }
- it("draws the expected luminance alpha texture color", function () {
- const color = new Color(0.6, 0.8, 0.0, 1.0);
- const arrayBufferView = new Uint8Array([153, 204]);
+ const color0 = new Color(0.2, 0.4, 0.6, 1.0);
+ const color1 = new Color(0.1, 0.3, 0.5, 1.0);
+ const floats = new Uint16Array([
+ 12902, 13926, 14541, 15360, 11878, 13517, 14336, 15360,
+ ]);
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.LUMINANCE_ALPHA,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: arrayBufferView,
- },
- flipY: false,
- });
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.HALF_FLOAT,
+ source: {
+ width: 2,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ flipY: false,
+ });
- expect({
- context: context,
- fragmentShader: fsLuminanceAlpha,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ expect(texture.sizeInBytes).toEqual(16);
- it("can be created from a typed array", function () {
- const bytes = new Uint8Array([0, 255, 0, 255]);
+ const fs =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: bytes,
- },
+ if (!context.textureHalfFloatLinear) {
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender(color1.toBytes());
+ } else {
+ Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
+ Color.multiplyByScalar(color1, 0.5, color1);
+ Color.add(color0, color1, color1);
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color1.toBytes());
+ }
});
- expect(texture.width).toEqual(1);
- expect(texture.height).toEqual(1);
- expect(texture.sizeInBytes).toEqual(4);
+ it("draws the expected Basis compressed texture color", function () {
+ if (!context.supportsBasis) {
+ return;
+ }
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([0, 255, 0, 255]);
- });
+ texture = new Texture({
+ context: context,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
- it("can copy from a typed array", function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- width: 1,
- height: 1,
- });
+ expect(texture.sizeInBytes).toBe(8);
- const bytes = new Uint8Array(Color.NAVY.toBytes());
- texture.copyFrom({
- source: {
- width: 1,
- height: 1,
- arrayBufferView: bytes,
- },
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRenderAndCall(function (color) {
+ return expect(color).toEqualEpsilon([2, 255, 2, 255], 2);
+ });
});
- expect(texture.width).toEqual(1);
- expect(texture.height).toEqual(1);
- expect(texture.sizeInBytes).toEqual(4);
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(Color.NAVY.toBytes());
- });
+ it("draws the expected KTX2 uncompressed texture color", function () {
+ texture = new Texture({
+ context: context,
+ pixelFormat: greenKTX2Image.internalFormat,
+ source: {
+ width: greenKTX2Image.width,
+ height: greenKTX2Image.height,
+ arrayBufferView: greenKTX2Image.bufferView,
+ },
+ });
- it("can copy from a DOM element", function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGB,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- width: blueImage.width,
- height: blueImage.height,
- });
+ expect(texture.sizeInBytes).toBe(48);
- texture.copyFrom({
- source: blueImage,
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRenderAndCall(function (color) {
+ return expect(color).toEqualEpsilon([0, 255, 24, 255], 2);
+ });
});
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender([0, 0, 255, 255]);
- });
+ it("renders with premultiplied alpha", function () {
+ const alphaContextOptions = Object.assign(
+ {
+ webgl: {
+ alpha: true,
+ },
+ },
+ contextOptions,
+ );
+ const alphaContext = createContext(alphaContextOptions);
+ const texture = new Texture({
+ context: alphaContext,
+ source: blueAlphaImage,
+ pixelFormat: PixelFormat.RGBA,
+ preMultiplyAlpha: true,
+ });
+ const uniformMap = {
+ u_texture: function () {
+ return texture;
+ },
+ };
- it("can copy from a DOM element when display dimensions are 0", function () {
- blueImage.height = 0;
- blueImage.width = 0;
+ expect(texture.preMultiplyAlpha).toEqual(true);
+ expect({
+ context: alphaContext,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender([0, 0, 127, 127]);
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGB,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: blueImage,
+ texture.destroy();
+ alphaContext.destroyForSpecs();
});
- texture.copyFrom({
- source: blueImage,
- });
+ it("draws textured blue and red points", function () {
+ texture = new Texture({
+ context: context,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender([0, 0, 255, 255]);
- });
+ let fragmentShaderSource = "";
+ fragmentShaderSource += "uniform sampler2D u_texture;";
+ fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
+ fragmentShaderSource +=
+ "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
- it("can replace a subset of a texture", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- });
+ let txCoords;
+ const um = {
+ u_texture: function () {
+ return texture;
+ },
+ u_txCoords: function () {
+ return txCoords;
+ },
+ };
- let fragmentShaderSource = "";
- fragmentShaderSource += "uniform sampler2D u_texture;";
- fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
- fragmentShaderSource +=
- "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
+ // Blue on top
+ txCoords = new Cartesian2(0.5, 0.75);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([0, 0, 255, 255]);
- let txCoords;
- const um = {
- u_texture: function () {
- return texture;
- },
- u_txCoords: function () {
- return txCoords;
- },
- };
+ // Red on bottom
+ txCoords = new Cartesian2(0.5, 0.25);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([255, 0, 0, 255]);
+ });
- // Blue on top
- txCoords = new Cartesian2(0.5, 0.75);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([0, 0, 255, 255]);
-
- // Red on bottom
- txCoords = new Cartesian2(0.5, 0.25);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([255, 0, 0, 255]);
-
- // After copy...
- texture.copyFrom({
- source: greenImage,
- xOffset: 0,
- yOffset: 1,
- });
-
- // Now green on top
- txCoords = new Cartesian2(0.5, 0.75);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender(Color.LIME.toBytes());
-
- // Still red on bottom
- txCoords = new Cartesian2(0.5, 0.25);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("can generate mipmaps", function () {
- texture = new Texture({
- context: context,
- source: red16x16Image,
- pixelFormat: PixelFormat.RGBA,
- sampler: new Sampler({
- minificationFilter: TextureMinificationFilter.NEAREST_MIPMAP_LINEAR,
- }),
- });
- texture.generateMipmap();
- expect(texture.sizeInBytes).toEqualEpsilon(
- (16 * 16 + 8 * 8 + 4 * 4 + 2 * 2 + 1) * 4,
- 1,
- );
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("can set a sampler property", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- const sampler = new Sampler({
- wrapS: TextureWrap.REPEAT,
- wrapT: TextureWrap.MIRRORED_REPEAT,
- minificationFilter: TextureMinificationFilter.NEAREST,
- magnificationFilter: TextureMagnificationFilter.NEAREST,
- maximumAnisotropy: 2.0,
- });
- texture.sampler = sampler;
-
- const s = texture.sampler;
- expect(s.wrapS).toEqual(sampler.wrapS);
- expect(s.wrapT).toEqual(sampler.wrapT);
- expect(s.minificationFilter).toEqual(sampler.minificationFilter);
- expect(s.magnificationFilter).toEqual(sampler.magnificationFilter);
- expect(s.maximumAnisotropy).toEqual(2.0);
- });
-
- it("can set sampler at construction", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- sampler: new Sampler({
- wrapS: TextureWrap.REPEAT,
- wrapT: TextureWrap.MIRRORED_REPEAT,
- minificationFilter: TextureMinificationFilter.NEAREST,
- magnificationFilter: TextureMagnificationFilter.NEAREST,
- maximumAnisotropy: 2.0,
- }),
- });
-
- const s = texture.sampler;
- expect(s.wrapS).toEqual(TextureWrap.REPEAT);
- expect(s.wrapT).toEqual(TextureWrap.MIRRORED_REPEAT);
- expect(s.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
- expect(s.magnificationFilter).toEqual(TextureMagnificationFilter.NEAREST);
- expect(s.maximumAnisotropy).toEqual(2.0);
- });
-
- it("can get width and height", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- expect(texture.width).toEqual(1);
- expect(texture.height).toEqual(2);
- });
-
- it("can get whether Y is flipped", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- flipY: true,
- });
-
- expect(texture.flipY).toEqual(true);
- });
-
- it("can get the dimensions of a texture", function () {
- texture = new Texture({
- context: context,
- width: 64,
- height: 16,
- });
-
- expect(texture.dimensions).toEqual(new Cartesian2(64, 16));
- });
-
- function expectTextureByteSize(
- width,
- height,
- pixelFormat,
- pixelDatatype,
- expectedSize,
- ) {
- texture = new Texture({
- context: context,
- width: width,
- height: height,
- pixelFormat: pixelFormat,
- pixelDatatype: pixelDatatype,
- });
- expect(texture.sizeInBytes).toBe(expectedSize);
- texture = texture && texture.destroy();
- }
+ it("draws the expected luminance texture color", function () {
+ const color = new Color(0.6, 0.6, 0.6, 1.0);
+ const arrayBufferView = new Uint8Array([153]);
- it("can get the size in bytes of a texture", function () {
- // Depth textures
- if (context.depthTexture) {
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.DEPTH_COMPONENT,
- PixelDatatype.UNSIGNED_SHORT,
- 256 * 2,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.DEPTH_COMPONENT,
- PixelDatatype.UNSIGNED_INT,
- 256 * 4,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.DEPTH_STENCIL,
- PixelDatatype.UNSIGNED_INT_24_8,
- 256 * 4,
- );
- }
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.LUMINANCE,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: arrayBufferView,
+ },
+ flipY: false,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color.toBytes());
+ });
+
+ it("draws the expected luminance alpha texture color", function () {
+ const color = new Color(0.6, 0.8, 0.0, 1.0);
+ const arrayBufferView = new Uint8Array([153, 204]);
- // Uncompressed formats
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.ALPHA,
- PixelDatatype.UNSIGNED_BYTE,
- 256,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.RGB,
- PixelDatatype.UNSIGNED_BYTE,
- 256 * 3,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.RGBA,
- PixelDatatype.UNSIGNED_BYTE,
- 256 * 4,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.LUMINANCE,
- PixelDatatype.UNSIGNED_BYTE,
- 256,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.LUMINANCE_ALPHA,
- PixelDatatype.UNSIGNED_BYTE,
- 256 * 2,
- );
- });
-
- it("can be destroyed", function () {
- const t = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- expect(t.isDestroyed()).toEqual(false);
- t.destroy();
- expect(t.isDestroyed()).toEqual(true);
- });
-
- it("throws when creating a texture without a options", function () {
- expect(function () {
- texture = new Texture();
- }).toThrowDeveloperError();
- });
-
- it("throws when creating a texture without a source", function () {
- expect(function () {
texture = new Texture({
context: context,
+ pixelFormat: PixelFormat.LUMINANCE_ALPHA,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: arrayBufferView,
+ },
+ flipY: false,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with width and no height", function () {
- expect(function () {
+ expect({
+ context: context,
+ fragmentShader: fsLuminanceAlpha,
+ uniformMap: uniformMap,
+ }).contextToRender(color.toBytes());
+ });
+
+ it("can be created from a typed array", function () {
+ const bytes = new Uint8Array([0, 255, 0, 255]);
+
texture = new Texture({
context: context,
- width: 16,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: bytes,
+ },
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with height and no width", function () {
- expect(function () {
+ expect(texture.width).toEqual(1);
+ expect(texture.height).toEqual(1);
+ expect(texture.sizeInBytes).toEqual(4);
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([0, 255, 0, 255]);
+ });
+
+ it("can copy from a typed array", function () {
texture = new Texture({
context: context,
- height: 16,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ width: 1,
+ height: 1,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with zero width", function () {
- expect(function () {
+ const bytes = new Uint8Array(Color.NAVY.toBytes());
+ texture.copyFrom({
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: bytes,
+ },
+ });
+
+ expect(texture.width).toEqual(1);
+ expect(texture.height).toEqual(1);
+ expect(texture.sizeInBytes).toEqual(4);
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(Color.NAVY.toBytes());
+ });
+
+ it("can copy from a DOM element", function () {
texture = new Texture({
context: context,
- width: 0,
- height: 16,
+ pixelFormat: PixelFormat.RGB,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ width: blueImage.width,
+ height: blueImage.height,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with width larger than the maximum texture size", function () {
- expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender([0, 0, 255, 255]);
+ });
+
+ it("can copy from a DOM element when display dimensions are 0", function () {
+ blueImage.height = 0;
+ blueImage.width = 0;
+
texture = new Texture({
context: context,
- width: ContextLimits.maximumTextureSize + 1,
- height: 16,
+ pixelFormat: PixelFormat.RGB,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: blueImage,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with zero height", function () {
- expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender([0, 0, 255, 255]);
+ });
+
+ it("can replace a subset of a texture", function () {
texture = new Texture({
context: context,
- width: 16,
- height: 0,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with height larger than the maximum texture size", function () {
- expect(function () {
+ let fragmentShaderSource = "";
+ fragmentShaderSource += "uniform sampler2D u_texture;";
+ fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
+ fragmentShaderSource +=
+ "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
+
+ let txCoords;
+ const um = {
+ u_texture: function () {
+ return texture;
+ },
+ u_txCoords: function () {
+ return txCoords;
+ },
+ };
+
+ // Blue on top
+ txCoords = new Cartesian2(0.5, 0.75);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([0, 0, 255, 255]);
+
+ // Red on bottom
+ txCoords = new Cartesian2(0.5, 0.25);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([255, 0, 0, 255]);
+
+ // After copy...
+ texture.copyFrom({
+ source: greenImage,
+ xOffset: 0,
+ yOffset: 1,
+ });
+
+ // Now green on top
+ txCoords = new Cartesian2(0.5, 0.75);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender(Color.LIME.toBytes());
+
+ // Still red on bottom
+ txCoords = new Cartesian2(0.5, 0.25);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([255, 0, 0, 255]);
+ });
+
+ it("can generate mipmaps", function () {
texture = new Texture({
context: context,
- width: 16,
- height: ContextLimits.maximumTextureSize + 1,
+ source: red16x16Image,
+ pixelFormat: PixelFormat.RGBA,
+ sampler: new Sampler({
+ minificationFilter: TextureMinificationFilter.NEAREST_MIPMAP_LINEAR,
+ }),
});
- }).toThrowDeveloperError();
- });
+ texture.generateMipmap();
+ expect(texture.sizeInBytes).toEqualEpsilon(
+ (16 * 16 + 8 * 8 + 4 * 4 + 2 * 2 + 1) * 4,
+ 1,
+ );
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([255, 0, 0, 255]);
+ });
- it("throws when creating a texture with an invalid pixel format", function () {
- expect(function () {
+ it("can set a sampler property", function () {
texture = new Texture({
context: context,
source: blueImage,
- pixelFormat: "invalid PixelFormat",
+ pixelFormat: PixelFormat.RGBA,
+ });
+
+ const sampler = new Sampler({
+ wrapS: TextureWrap.REPEAT,
+ wrapT: TextureWrap.MIRRORED_REPEAT,
+ minificationFilter: TextureMinificationFilter.NEAREST,
+ magnificationFilter: TextureMagnificationFilter.NEAREST,
+ maximumAnisotropy: 2.0,
});
- }).toThrowDeveloperError();
- });
+ texture.sampler = sampler;
+
+ const s = texture.sampler;
+ expect(s.wrapS).toEqual(sampler.wrapS);
+ expect(s.wrapT).toEqual(sampler.wrapT);
+ expect(s.minificationFilter).toEqual(sampler.minificationFilter);
+ expect(s.magnificationFilter).toEqual(sampler.magnificationFilter);
+ expect(s.maximumAnisotropy).toEqual(2.0);
+ });
- it("throws when creating a texture with an invalid pixel datatype", function () {
- expect(function () {
+ it("can set sampler at construction", function () {
texture = new Texture({
context: context,
source: blueImage,
pixelFormat: PixelFormat.RGBA,
- pixelDatatype: "invalid pixelDatatype",
+ sampler: new Sampler({
+ wrapS: TextureWrap.REPEAT,
+ wrapT: TextureWrap.MIRRORED_REPEAT,
+ minificationFilter: TextureMinificationFilter.NEAREST,
+ magnificationFilter: TextureMagnificationFilter.NEAREST,
+ maximumAnisotropy: 2.0,
+ }),
});
- }).toThrowDeveloperError();
- });
- it("throws when creating if pixelFormat is DEPTH_COMPONENT and pixelDatatype is not UNSIGNED_SHORT or UNSIGNED_INT", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- });
- }).toThrowDeveloperError();
- });
+ const s = texture.sampler;
+ expect(s.wrapS).toEqual(TextureWrap.REPEAT);
+ expect(s.wrapT).toEqual(TextureWrap.MIRRORED_REPEAT);
+ expect(s.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
+ expect(s.magnificationFilter).toEqual(
+ TextureMagnificationFilter.NEAREST,
+ );
+ expect(s.maximumAnisotropy).toEqual(2.0);
+ });
+
+ it("can get width and height", function () {
+ texture = new Texture({
+ context: context,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
+
+ expect(texture.width).toEqual(1);
+ expect(texture.height).toEqual(2);
+ });
+
+ it("can get whether Y is flipped", function () {
+ texture = new Texture({
+ context: context,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
+ flipY: true,
+ });
+
+ expect(texture.flipY).toEqual(true);
+ });
+
+ it("can get the dimensions of a texture", function () {
+ texture = new Texture({
+ context: context,
+ width: 64,
+ height: 16,
+ });
+
+ expect(texture.dimensions).toEqual(new Cartesian2(64, 16));
+ });
+
+ function expectTextureByteSize(
+ width,
+ height,
+ pixelFormat,
+ pixelDatatype,
+ expectedSize,
+ ) {
+ texture = new Texture({
+ context: context,
+ width: width,
+ height: height,
+ pixelFormat: pixelFormat,
+ pixelDatatype: pixelDatatype,
+ });
+ expect(texture.sizeInBytes).toBe(expectedSize);
+ texture = texture && texture.destroy();
+ }
+
+ it("can get the size in bytes of a texture", function () {
+ // Depth textures
+ if (context.depthTexture) {
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.DEPTH_COMPONENT,
+ PixelDatatype.UNSIGNED_SHORT,
+ 256 * 2,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.DEPTH_COMPONENT,
+ PixelDatatype.UNSIGNED_INT,
+ 256 * 4,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.DEPTH_STENCIL,
+ PixelDatatype.UNSIGNED_INT_24_8,
+ 256 * 4,
+ );
+ }
+
+ // Uncompressed formats
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.ALPHA,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.RGB,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256 * 3,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.RGBA,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256 * 4,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.LUMINANCE,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.LUMINANCE_ALPHA,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256 * 2,
+ );
+ });
+
+ it("can be destroyed", function () {
+ const t = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
+
+ expect(t.isDestroyed()).toEqual(false);
+ t.destroy();
+ expect(t.isDestroyed()).toEqual(true);
+ });
+
+ it("throws when creating a texture without a options", function () {
+ expect(function () {
+ texture = new Texture();
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture without a source", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with width and no height", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with height and no width", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ height: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with zero width", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 0,
+ height: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with width larger than the maximum texture size", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: ContextLimits.maximumTextureSize + 1,
+ height: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with zero height", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 16,
+ height: 0,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with height larger than the maximum texture size", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 16,
+ height: ContextLimits.maximumTextureSize + 1,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with an invalid pixel format", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: "invalid PixelFormat",
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with an invalid pixel datatype", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: "invalid pixelDatatype",
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_COMPONENT and pixelDatatype is not UNSIGNED_SHORT or UNSIGNED_INT", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_STENCIL and pixelDatatype is not UNSIGNED_INT_24_8", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.DEPTH_STENCIL,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and source is provided", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and WEBGL_depth_texture is not supported", function () {
+ if (!context.depthTexture) {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when creating if pixelDatatype is FLOAT, and OES_texture_float is not supported", function () {
+ if (!context.floatingPointTexture) {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.FLOAT,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when creating if pixelDatatype = HALF_FLOAT, and OES_texture_half_float is not supported", function () {
+ if (!context.halfFloatingPointTexture) {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelDatatype.RGBA,
+ pixelDatatype: PixelDatatype.HALF_FLOAT,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when creating compressed texture and the array buffer source is undefined", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 4,
+ height: 4,
+ pixelFormat: PixelFormat.RGBA_DXT3,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating from the framebuffer with an invalid pixel format", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: "invalid PixelFormat",
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating from the framebuffer if PixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating from the framebuffer with a negative framebufferXOffset", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: -1,
+ });
+ }).toThrowDeveloperError();
+ });
- it("throws when creating if pixelFormat is DEPTH_STENCIL and pixelDatatype is not UNSIGNED_INT_24_8", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.DEPTH_STENCIL,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- });
- }).toThrowDeveloperError();
- });
+ it("throws when creating from the framebuffer with a negative framebufferYOffset", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: 0,
+ framebufferYOffset: -1,
+ });
+ }).toThrowDeveloperError();
+ });
- it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and source is provided", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
- });
- }).toThrowDeveloperError();
- });
+ it("throws when creating from the framebuffer with a width greater than the canvas clientWidth", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: 0,
+ framebufferYOffset: 0,
+ width: context.canvas.clientWidth + 1,
+ });
+ }).toThrowDeveloperError();
+ });
- it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and WEBGL_depth_texture is not supported", function () {
- if (!context.depthTexture) {
+ it("throws when creating from the framebuffer with a height greater than the canvas clientHeight", function () {
expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: 0,
+ framebufferYOffset: 0,
+ width: 1,
+ height: context.canvas.clientHeight + 1,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when copying to a texture from the framebuffer with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
+ if (context.depthTexture) {
texture = new Texture({
context: context,
width: 1,
@@ -1092,13 +1220,33 @@ describe(
pixelFormat: PixelFormat.DEPTH_COMPONENT,
pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
});
- }).toThrowDeveloperError();
- }
- });
- it("throws when creating if pixelDatatype is FLOAT, and OES_texture_float is not supported", function () {
- if (!context.floatingPointTexture) {
- expect(function () {
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when copying to a texture from the framebuffer with a compressed pixel format", function () {
+ if (context.supportsBasis) {
+ texture = new Texture({
+ context: context,
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
+
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when copying to a texture from the framebuffer with a FLOAT pixel data type", function () {
+ if (context.floatingPointTexture) {
texture = new Texture({
context: context,
width: 1,
@@ -1106,454 +1254,313 @@ describe(
pixelFormat: PixelFormat.RGBA,
pixelDatatype: PixelDatatype.FLOAT,
});
- }).toThrowDeveloperError();
- }
- });
- it("throws when creating if pixelDatatype = HALF_FLOAT, and OES_texture_half_float is not supported", function () {
- if (!context.halfFloatingPointTexture) {
- expect(function () {
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when copying to a texture from the framebuffer with a HALF_FLOAT pixel data type", function () {
+ if (context.halfFloatingPointTexture) {
texture = new Texture({
context: context,
width: 1,
height: 1,
- pixelFormat: PixelDatatype.RGBA,
+ pixelFormat: PixelFormat.RGBA,
pixelDatatype: PixelDatatype.HALF_FLOAT,
});
- }).toThrowDeveloperError();
- }
- });
-
- it("throws when creating compressed texture and the array buffer source is undefined", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- width: 4,
- height: 4,
- pixelFormat: PixelFormat.RGBA_DXT3,
- });
- }).toThrowDeveloperError();
- });
-
- it("throws when creating from the framebuffer with an invalid pixel format", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: "invalid PixelFormat",
- });
- }).toThrowDeveloperError();
- });
- it("throws when creating from the framebuffer if PixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- });
- }).toThrowDeveloperError();
- });
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
- it("throws when creating from the framebuffer with a negative framebufferXOffset", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
+ it("throws when copying from the framebuffer with a negative xOffset", function () {
+ texture = new Texture({
context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: -1,
+ source: blueImage,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating from the framebuffer with a negative framebufferYOffset", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: 0,
- framebufferYOffset: -1,
- });
- }).toThrowDeveloperError();
- });
+ expect(function () {
+ texture.copyFromFramebuffer(-1);
+ }).toThrowDeveloperError();
+ });
- it("throws when creating from the framebuffer with a width greater than the canvas clientWidth", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
+ it("throws when copying from the framebuffer with a negative yOffset", function () {
+ texture = new Texture({
context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: 0,
- framebufferYOffset: 0,
- width: context.canvas.clientWidth + 1,
+ source: blueImage,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating from the framebuffer with a height greater than the canvas clientHeight", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: 0,
- framebufferYOffset: 0,
- width: 1,
- height: context.canvas.clientHeight + 1,
- });
- }).toThrowDeveloperError();
- });
+ expect(function () {
+ texture.copyFromFramebuffer(0, -1);
+ }).toThrowDeveloperError();
+ });
- it("throws when copying to a texture from the framebuffer with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
- if (context.depthTexture) {
+ it("throws when copying from the framebuffer with a negative framebufferXOffset", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, -1);
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when copying to a texture from the framebuffer with a compressed pixel format", function () {
- if (context.supportsBasis) {
+ it("throws when copying from the framebuffer with a negative framebufferYOffset", function () {
texture = new Texture({
context: context,
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, 0, -1);
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when copying to a texture from the framebuffer with a FLOAT pixel data type", function () {
- if (context.floatingPointTexture) {
+ it("throws when copying from the framebuffer with a larger width", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.FLOAT,
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, 0, 0, texture.width + 1);
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when copying to a texture from the framebuffer with a HALF_FLOAT pixel data type", function () {
- if (context.halfFloatingPointTexture) {
+ it("throws when copying from the framebuffer with a larger height", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.HALF_FLOAT,
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, 0, 0, 0, texture.height + 1);
}).toThrowDeveloperError();
- }
- });
-
- it("throws when copying from the framebuffer with a negative xOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFromFramebuffer(-1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying from the framebuffer with a negative yOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFromFramebuffer(0, -1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying from the framebuffer with a negative framebufferXOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFromFramebuffer(0, 0, -1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying from the framebuffer with a negative framebufferYOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
});
- expect(function () {
- texture.copyFromFramebuffer(0, 0, 0, -1);
- }).toThrowDeveloperError();
- });
+ it("throws when copying to a texture with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
+ if (context.depthTexture) {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
- it("throws when copying from the framebuffer with a larger width", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom({
+ source: {
+ arrayBufferView: new Uint16Array([0]),
+ width: 1,
+ height: 1,
+ },
+ });
+ }).toThrowDeveloperError();
+ }
});
- expect(function () {
- texture.copyFromFramebuffer(0, 0, 0, 0, texture.width + 1);
- }).toThrowDeveloperError();
- });
+ it("throws when copyFrom is not given any options", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ });
- it("throws when copying from the framebuffer with a larger height", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom();
+ }).toThrowDeveloperError();
});
- expect(function () {
- texture.copyFromFramebuffer(0, 0, 0, 0, 0, texture.height + 1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying to a texture with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
- if (context.depthTexture) {
+ it("throws when copyFrom is not given a source", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ source: blueImage,
});
expect(function () {
texture.copyFrom({
- source: {
- arrayBufferView: new Uint16Array([0]),
- width: 1,
- height: 1,
- },
+ xOffset: 0,
+ yOffset: 2,
});
}).toThrowDeveloperError();
- }
- });
-
- it("throws when copyFrom is not given any options", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFrom();
- }).toThrowDeveloperError();
- });
-
- it("throws when copyFrom is not given a source", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFrom({
- xOffset: 0,
- yOffset: 2,
- });
- }).toThrowDeveloperError();
- });
-
- it("throws when copyFrom is given a negative xOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
});
- expect(function () {
- texture.copyFrom({
+ it("throws when copyFrom is given a negative xOffset", function () {
+ texture = new Texture({
+ context: context,
source: blueImage,
- xOffset: -1,
});
- }).toThrowDeveloperError();
- });
- it("throws when copyFrom is given a negative yOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ xOffset: -1,
+ });
+ }).toThrowDeveloperError();
});
- expect(function () {
- texture.copyFrom({
+ it("throws when copyFrom is given a negative yOffset", function () {
+ texture = new Texture({
+ context: context,
source: blueImage,
- xOffset: 0,
- yOffset: -1,
});
- }).toThrowDeveloperError();
- });
- it("throws when copyFrom is given a source with larger width", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
- const image = new Image();
- image.width = blueImage.width + 1;
-
- expect(function () {
- texture.copyFrom({
- source: image,
- });
- }).toThrowDeveloperError();
- });
-
- it("throws when copyFrom is given a source with larger height", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ xOffset: 0,
+ yOffset: -1,
+ });
+ }).toThrowDeveloperError();
});
- const image = new Image();
- image.height = blueImage.height + 1;
-
- expect(function () {
- texture.copyFrom({
- source: image,
- });
- }).toThrowDeveloperError();
- });
- it("throws when copyFrom is given a source with a compressed pixel format", function () {
- if (context.supportsBasis) {
+ it("throws when copyFrom is given a source with larger width", function () {
texture = new Texture({
context: context,
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
+ source: blueImage,
});
-
const image = new Image();
+ image.width = blueImage.width + 1;
+
expect(function () {
texture.copyFrom({
source: image,
});
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when generating mipmaps with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
- if (context.depthTexture) {
+ it("throws when copyFrom is given a source with larger height", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ source: blueImage,
});
+ const image = new Image();
+ image.height = blueImage.height + 1;
expect(function () {
- texture.generateMipmap();
+ texture.copyFrom({
+ source: image,
+ });
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when generating mipmaps with a compressed pixel format", function () {
- if (context.supportsBasis) {
- texture = new Texture({
- context: context,
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
- });
+ it("throws when copyFrom is given a source with a compressed pixel format", function () {
+ if (context.supportsBasis) {
+ texture = new Texture({
+ context: context,
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
- expect(function () {
- texture.generateMipmap();
- }).toThrowDeveloperError();
- }
- });
+ const image = new Image();
+ expect(function () {
+ texture.copyFrom({
+ source: image,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
- describe("WebGL1", function () {
- let webgl1Context;
+ it("throws when generating mipmaps with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
+ if (context.depthTexture) {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
- beforeAll(() => {
- webgl1Context = createContext({
- requestWebgl1: true,
- });
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
+ }
});
- afterAll(() => {
- webgl1Context.destroyForSpecs();
+ it("throws when generating mipmaps with a compressed pixel format", function () {
+ if (context.supportsBasis) {
+ texture = new Texture({
+ context: context,
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
+
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
+ }
});
- it("throws when generating mipmaps with a non-power of two width", function () {
- texture = new Texture({
- context: webgl1Context,
- width: 3,
- height: 2,
+ describe("WebGL1", function () {
+ it("throws when generating mipmaps with a non-power of two width", function () {
+ if (context.webgl2) {
+ return;
+ }
+ texture = new Texture({
+ context: context,
+ width: 3,
+ height: 2,
+ });
+
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
});
- expect(function () {
- texture.generateMipmap();
- }).toThrowDeveloperError();
+ it("throws when generating mipmaps with a non-power of two height", function () {
+ if (context.webgl2) {
+ return;
+ }
+ texture = new Texture({
+ context: context,
+ width: 2,
+ height: 3,
+ });
+
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
+ });
});
- it("throws when generating mipmaps with a non-power of two height", function () {
+ it("throws when generating mipmaps with an invalid hint", function () {
texture = new Texture({
- context: webgl1Context,
- width: 2,
- height: 3,
+ context: context,
+ source: blueImage,
});
expect(function () {
- texture.generateMipmap();
+ texture.generateMipmap("invalid hint");
}).toThrowDeveloperError();
});
- });
- it("throws when generating mipmaps with an invalid hint", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
+ it("throws when destroy is called after destroying", function () {
+ const t = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
- expect(function () {
- texture.generateMipmap("invalid hint");
- }).toThrowDeveloperError();
- });
+ t.destroy();
- it("throws when destroy is called after destroying", function () {
- const t = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
+ expect(function () {
+ t.destroy();
+ }).toThrowDeveloperError();
});
-
- t.destroy();
-
- expect(function () {
- t.destroy();
- }).toThrowDeveloperError();
- });
+ }
},
"WebGL",
);
diff --git a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
index 1f70a75175c3..a05b1be4dc28 100644
--- a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
+++ b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
@@ -91,6 +91,10 @@ describe(
const tilesetOfTilesetsUrl =
"Data/Cesium3DTiles/Tilesets/TilesetOfTilesets/tileset.json";
+ // A tileset that refers to 4 GLB files which share two (external) textures
+ const tilesetUrlWithSharedTextures =
+ "Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/tileset.json";
+
const withoutBatchTableUrl =
"Data/Cesium3DTiles/Batched/BatchedWithoutBatchTable/tileset.json";
const withBatchTableUrl =
@@ -211,9 +215,6 @@ describe(
options = {
cullRequestsWhileMoving: false,
- environmentMapOptions: {
- enabled: scene.highDynamicRangeSupported,
- },
};
});
@@ -966,6 +967,78 @@ describe(
);
});
+ it("verify memory usage statistics for shared textures", async function () {
+ // One buffer view with 4 positions, 4 normals, and 4 texture coordinates,
+ // using a common byte stride of 12 (resulting in 144 bytes)
+ // and 2*3 unsigned short indices, resulting in a total of 156 bytes
+ const singleGeometryByteLength = 156;
+
+ // One texture with 128x128 * RGBA pixels = 65536 bytes
+ const singleTexturesByteLength = 65536;
+
+ // Basic camera setup
+ const camera = scene.camera;
+
+ // NOTE: This is really, really important. There are some
+ // random calls in "beforeEach" and other parts of these
+ // specs that affect the camera transform. And the camera
+ // transform is NOT maintained to be consistent with the
+ // other properties in any way. So reset it here...
+ camera.lookAtTransform(Matrix4.IDENTITY);
+
+ camera.position = new Cartesian3(0, -1, 0);
+ camera.direction = Cartesian3.clone(Cartesian3.UNIT_Y);
+ camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
+ camera.frustum.near = 0.01;
+ camera.frustum.far = 100.0;
+
+ // Move the camera to see no tiles
+ camera.position = new Cartesian3(100, -1, 100);
+
+ const tileset = await Cesium3DTilesTester.loadTileset(
+ scene,
+ tilesetUrlWithSharedTextures,
+ );
+
+ const statistics = tileset._statistics;
+
+ // No tiles loaded
+ expect(statistics.geometryByteLength).toEqual(0);
+ expect(statistics.texturesByteLength).toEqual(0);
+
+ // Move the camera to stare at the center of the first tile
+ camera.position = new Cartesian3(0.5, -1, 0.5);
+ await Cesium3DTilesTester.waitForTilesLoaded(scene, tileset);
+
+ // A single tile and texture was loaded
+ expect(statistics.geometryByteLength).toEqual(singleGeometryByteLength);
+ expect(statistics.texturesByteLength).toEqual(singleTexturesByteLength);
+
+ // Move the camera back to see all tiles
+ camera.position = new Cartesian3(3.5, -14, 0.5);
+ await Cesium3DTilesTester.waitForTilesLoaded(scene, tileset);
+
+ // All tiles have been loaded: 4 times the geometry, BUT
+ // ONLY 2 times the texture
+ expect(statistics.geometryByteLength).toEqual(
+ singleGeometryByteLength * 4,
+ );
+ expect(statistics.texturesByteLength).toEqual(
+ singleTexturesByteLength * 2,
+ );
+
+ // Move the camera back to stare at the center of the first tile again
+ camera.position = new Cartesian3(0.5, -1, 0.5);
+
+ // Trim any previously loaded tiles
+ tileset.trimLoadedTiles();
+ await Cesium3DTilesTester.waitForTilesLoaded(scene, tileset);
+
+ // Again, only a single tile and texture should be loaded
+ expect(statistics.geometryByteLength).toEqual(singleGeometryByteLength);
+ expect(statistics.texturesByteLength).toEqual(singleTexturesByteLength);
+ });
+
it("verify memory usage statistics for shared resources", function () {
ResourceCache.statistics.clear();
// Six tiles total:
diff --git a/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js b/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js
index 57ea8ee5354f..0783774b7482 100644
--- a/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js
+++ b/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js
@@ -2,6 +2,7 @@ import {
Cartesian3,
Cartographic,
Color,
+ ContextLimits,
CubeMap,
DynamicAtmosphereLightingType,
DynamicEnvironmentMapManager,
@@ -31,21 +32,59 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
expect(manager.groundAlbedo).toBe(0.31);
});
+ it("constructs with options", function () {
+ const manager = new DynamicEnvironmentMapManager({
+ enabled: false,
+ maximumSecondsDifference: 0,
+ maximumPositionEpsilon: 0,
+ atmosphereScatteringIntensity: 0,
+ gamma: 0,
+ brightness: 0,
+ saturation: 0,
+ groundColor: Color.BLUE,
+ groundAlbedo: 0,
+ });
+
+ expect(manager.enabled).toBeFalse();
+ expect(manager.shouldUpdate).toBeTrue();
+ expect(manager.maximumSecondsDifference).toBe(0);
+ expect(manager.maximumPositionEpsilon).toBe(0);
+ expect(manager.atmosphereScatteringIntensity).toBe(0);
+ expect(manager.gamma).toBe(0);
+ expect(manager.brightness).toBe(0);
+ expect(manager.saturation).toBe(0);
+ expect(manager.groundColor).toEqual(Color.BLUE);
+ expect(manager.groundAlbedo).toBe(0);
+ });
+
+ it("uses default spherical harmonic coefficients", () => {
+ const manager = new DynamicEnvironmentMapManager();
+
+ expect(manager.sphericalHarmonicCoefficients.length).toBe(9);
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
describe(
"render tests",
() => {
const time = JulianDate.fromIso8601("2024-08-30T10:45:00Z");
- let scene;
+ let scene, orginalMaximumCubeMapSize;
beforeAll(() => {
scene = createScene({
skyBox: false,
});
+ orginalMaximumCubeMapSize = ContextLimits.maximumCubeMapSize;
+ // To keep tests fast, don't throttle
+ ContextLimits._maximumCubeMapSize = Number.POSITIVE_INFINITY;
});
afterAll(() => {
scene.destroyForSpecs();
+ ContextLimits._maximumCubeMapSize = orginalMaximumCubeMapSize;
});
afterEach(() => {
@@ -53,7 +92,7 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
scene.atmosphere = new Atmosphere();
});
- // Allows the compute commands to be added to the command list at the right point in the pipeline
+ // A pared-down Primitive. Allows the compute commands to be added to the command list at the right point in the pipeline.
function EnvironmentMockPrimitive(manager) {
this.update = function (frameState) {
manager.update(frameState);
@@ -64,8 +103,74 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
};
}
+ it("does not update if position is undefined", async function () {
+ const manager = new DynamicEnvironmentMapManager();
+
+ const primitive = new EnvironmentMockPrimitive(manager);
+ scene.primitives.add(primitive);
+
+ scene.renderForSpecs();
+
+ expect(manager.radianceCubeMap).toBeUndefined();
+
+ scene.renderForSpecs();
+
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
+ it("does not update if enabled is false", async function () {
+ const manager = new DynamicEnvironmentMapManager();
+
+ const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
+ manager.position =
+ Ellipsoid.WGS84.cartographicToCartesian(cartographic);
+ manager.enabled = false;
+
+ const primitive = new EnvironmentMockPrimitive(manager);
+ scene.primitives.add(primitive);
+
+ scene.renderForSpecs();
+
+ expect(manager.radianceCubeMap).toBeUndefined();
+
+ scene.renderForSpecs();
+
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
+ it("does not update if requires extensions are not available", async function () {
+ spyOn(
+ DynamicEnvironmentMapManager,
+ "isDynamicUpdateSupported",
+ ).and.returnValue(false);
+
+ const manager = new DynamicEnvironmentMapManager();
+
+ const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
+ manager.position =
+ Ellipsoid.WGS84.cartographicToCartesian(cartographic);
+
+ const primitive = new EnvironmentMockPrimitive(manager);
+ scene.primitives.add(primitive);
+
+ scene.renderForSpecs();
+
+ expect(manager.radianceCubeMap).toBeUndefined();
+
+ scene.renderForSpecs();
+
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
it("creates environment map and spherical harmonics at surface in Philadelphia with static lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -146,7 +251,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics at altitude in Philadelphia with static lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -231,7 +337,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics above Earth's atmosphere with static lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -317,7 +424,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics at surface in Philadelphia with dynamic lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -401,7 +509,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics at surface in Sydney with dynamic lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -485,7 +594,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses atmosphere properties", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -572,10 +682,10 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses atmosphereScatteringIntensity value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
-
const manager = new DynamicEnvironmentMapManager();
manager.atmosphereScatteringIntensity = 1.0;
@@ -654,7 +764,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses gamma value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -736,7 +847,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses brightness value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -818,7 +930,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses saturation value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -900,7 +1013,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses ground color value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -982,7 +1096,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses ground albedo value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -1064,18 +1179,6 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("destroys", function () {
- if (!scene.highDynamicRangeSupported) {
- const manager = new DynamicEnvironmentMapManager();
- const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
- manager.position =
- Ellipsoid.WGS84.cartographicToCartesian(cartographic);
-
- manager.destroy();
-
- expect(manager.isDestroyed()).toBe(true);
- return;
- }
-
const manager = new DynamicEnvironmentMapManager();
const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
manager.position =
diff --git a/packages/engine/Specs/Scene/ITwinDataSpec.js b/packages/engine/Specs/Scene/ITwinDataSpec.js
new file mode 100644
index 000000000000..8eb4322c5778
--- /dev/null
+++ b/packages/engine/Specs/Scene/ITwinDataSpec.js
@@ -0,0 +1,224 @@
+import {
+ ITwinPlatform,
+ RuntimeError,
+ Cesium3DTileset,
+ ITwinData,
+} from "../../index.js";
+
+function createMockExport(
+ id,
+ status,
+ exportType = ITwinPlatform.ExportType["3DTILES"],
+) {
+ return {
+ id: `${id}`,
+ displayName: `export ${id}`,
+ status: status,
+ lastModified: "2024-11-04T12:00Z",
+ request: {
+ iModelId: "imodel-id-1",
+ changesetId: "changeset-id",
+ exportType,
+ },
+ _links: {
+ mesh: {
+ // The API returns some important query params for auth that we
+ // need to make sure are preserved when the path is modified
+ href: `https://example.com/link/to/mesh/${id}?query=param`,
+ },
+ },
+ };
+}
+
+describe("ITwinData", () => {
+ let previousAccessToken;
+ beforeEach(() => {
+ previousAccessToken = ITwinPlatform.defaultAccessToken;
+ ITwinPlatform.defaultAccessToken = "default-access-token";
+ });
+
+ afterEach(() => {
+ ITwinPlatform.defaultAccessToken = previousAccessToken;
+ });
+
+ describe("createTilesetFromIModelId", () => {
+ it("rejects when all exports are invalid", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(2, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(3, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(4, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(5, ITwinPlatform.ExportStatus.Invalid),
+ ],
+ });
+ await expectAsync(
+ ITwinData.createTilesetFromIModelId("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /All exports for this iModel/);
+ });
+
+ it("returns undefined when no exports returned", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [],
+ });
+ const tileset = await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tileset).toBeUndefined();
+ });
+
+ it("returns undefined when no exports are complete", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.InProgress),
+ createMockExport(2, ITwinPlatform.ExportStatus.NotStarted),
+ ],
+ });
+ const tileset = await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tileset).toBeUndefined();
+ });
+
+ it("returns undefined when no exports are complete", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.InProgress),
+ createMockExport(2, ITwinPlatform.ExportStatus.NotStarted),
+ ],
+ });
+ const tileset = await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tileset).toBeUndefined();
+ });
+
+ it("creates a tileset for the first complete export", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(2, ITwinPlatform.ExportStatus.Complete),
+ ],
+ });
+ const tilesetSpy = spyOn(Cesium3DTileset, "fromUrl");
+ await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tilesetSpy).toHaveBeenCalledTimes(1);
+ // Check that the resource url created is for the second export because
+ // the first is invalid
+ expect(tilesetSpy.calls.mostRecent().args[0].toString()).toEqual(
+ "https://example.com/link/to/mesh/2/tileset.json?query=param",
+ );
+ expect(tilesetSpy.calls.mostRecent().args[1]).toBeUndefined();
+ });
+
+ it("passes tileset options through to the tileset constructor", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [createMockExport(1, ITwinPlatform.ExportStatus.Complete)],
+ });
+ const tilesetSpy = spyOn(Cesium3DTileset, "fromUrl");
+ const tilesetOptions = { show: false };
+ await ITwinData.createTilesetFromIModelId("imodel-id-1", tilesetOptions);
+ expect(tilesetSpy).toHaveBeenCalledTimes(1);
+ expect(tilesetSpy.calls.mostRecent().args[1]).toEqual(tilesetOptions);
+ });
+ });
+
+ describe("createTilesetForRealityDataId", () => {
+ let getMetadataSpy;
+ let getUrlSpy;
+ let tilesetSpy;
+ beforeEach(() => {
+ getMetadataSpy = spyOn(ITwinPlatform, "getRealityDataMetadata");
+ getUrlSpy = spyOn(ITwinPlatform, "getRealityDataURL");
+ tilesetSpy = spyOn(Cesium3DTileset, "fromUrl");
+ });
+
+ it("rejects if the type is not supported", async () => {
+ await expectAsync(
+ ITwinData.createTilesetForRealityDataId(
+ "imodel-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.DGN,
+ "root/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /type is not/);
+ });
+
+ it("does not fetch metadata if type and rootDocument are defined", async () => {
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.Cesium3DTiles,
+ "root/document/path.json",
+ );
+
+ expect(getMetadataSpy).not.toHaveBeenCalled();
+ expect(getUrlSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ });
+
+ it("fetches metadata if type is undefined", async () => {
+ getMetadataSpy.and.resolveTo({
+ iModelId: "itwin-id-1",
+ id: "reality-data-id-1",
+ type: ITwinPlatform.RealityDataType.Cesium3DTiles,
+ rootDocument: "root/document/path.json",
+ });
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ undefined,
+ "root/document/path.json",
+ );
+
+ expect(getMetadataSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ );
+ expect(getUrlSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ });
+
+ it("fetches metadata if rootDocument is undefined", async () => {
+ getMetadataSpy.and.resolveTo({
+ iModelId: "itwin-id-1",
+ id: "reality-data-id-1",
+ type: ITwinPlatform.RealityDataType.Cesium3DTiles,
+ rootDocument: "root/document/path.json",
+ });
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.Cesium3DTiles,
+ undefined,
+ );
+
+ expect(getMetadataSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ );
+ expect(getUrlSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ });
+
+ it("creates a tileset from the constructed blob url", async () => {
+ const tilesetUrl =
+ "https://example.com/root/document/path.json?auth=token";
+ getUrlSpy.and.resolveTo(tilesetUrl);
+
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.Cesium3DTiles,
+ "root/document/path.json",
+ );
+
+ expect(tilesetSpy).toHaveBeenCalledOnceWith(tilesetUrl, {
+ maximumScreenSpaceError: 4,
+ });
+ });
+ });
+});
diff --git a/packages/engine/Specs/Scene/LabelCollectionSpec.js b/packages/engine/Specs/Scene/LabelCollectionSpec.js
index 3f163690e81e..68c7d7dbf6dd 100644
--- a/packages/engine/Specs/Scene/LabelCollectionSpec.js
+++ b/packages/engine/Specs/Scene/LabelCollectionSpec.js
@@ -2560,6 +2560,84 @@ describe(
});
});
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "a😀b";
+ const expectedText = "a😀b";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "awe2!$34f❤️b";
+ const expectedText = "awe2!$34f❤️b";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "lakneklf\u200fsldknfklf";
+ const expectedText = "lakneklfsldknfklf";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u200f - with Right-to-Left Mark (RLM)";
+ const expectedText = "test - with Right-to-Left Mark (RLM)";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u200b - with Zero-Width Space";
+ const expectedText = "test - with Zero-Width Space";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u202a - with Left-to-Right Embedding";
+ const expectedText = "test - with Left-to-Right Embedding";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test 😀 - Emoji";
+ const expectedText = "test 😀 - Emoji";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test ❤️ - Emoji";
+ const expectedText = "test ❤️ - Emoji";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test 🌍 - Emoji";
+ const expectedText = "test 🌍 - Emoji";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u2060 - with Word Joiner";
+ const expectedText = "test - with Word Joiner";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u0000 - with Null Character";
+ const expectedText = "test - with Null Character";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u000E - with Shift Out (SO)";
+ const expectedText = "test - with Shift Out (SO)";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u001F - with Unit Separator (US)";
+ const expectedText = "test - with Unit Separator (US)";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
describe("height referenced labels", function () {
beforeEach(function () {
scene.globe = new Globe();
diff --git a/packages/engine/Specs/Scene/MetadataPickingSpec.js b/packages/engine/Specs/Scene/MetadataPickingSpec.js
new file mode 100644
index 000000000000..5f1cb8bd5a72
--- /dev/null
+++ b/packages/engine/Specs/Scene/MetadataPickingSpec.js
@@ -0,0 +1,1492 @@
+import {
+ Cartesian2,
+ Cartesian3,
+ Cartesian4,
+ Matrix2,
+ Matrix3,
+ Matrix4,
+ MetadataComponentType,
+ MetadataPicking,
+ MetadataType,
+} from "../../index.js";
+
+// The precision for Jasmine `toBeCloseTo` calls. Note that this
+// is not an "epsilon", but described as "The number of decimal
+// points to check" ...
+const precision = 3;
+
+describe("Scene/MetadataPicking", function () {
+ describe("decodeRawMetadataValue", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const componentType = "NOT_A_COMPONENT_TYPE";
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 0;
+ MetadataPicking.decodeRawMetadataValue(componentType, dataView, index);
+ }).toThrowError();
+ });
+
+ it("throws for invalid index", function () {
+ expect(function () {
+ const componentType = MetadataComponentType.INT8;
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 1234;
+ MetadataPicking.decodeRawMetadataValue(componentType, dataView, index);
+ }).toThrowError();
+ });
+
+ it("decodes raw value with component type INT8", function () {
+ const array = new Int8Array([12, 23]);
+ const componentType = MetadataComponentType.INT8;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 1;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes raw value with component type UINT8", function () {
+ const array = new Uint8Array([12, 23]);
+ const componentType = MetadataComponentType.UINT8;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 1;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes raw value with component type INT16", function () {
+ const array = new Int16Array([1234, 2345]);
+ const componentType = MetadataComponentType.INT16;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 2;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes raw value with component type UINT16", function () {
+ const array = new Uint16Array([1234, 2345]);
+ const componentType = MetadataComponentType.UINT16;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 2;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes raw value with component type INT32", function () {
+ const array = new Int32Array([123456, 234567]);
+ const componentType = MetadataComponentType.INT32;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 4;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes raw value with component type UINT32", function () {
+ const array = new Uint32Array([123456, 234567]);
+ const componentType = MetadataComponentType.UINT32;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 4;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes raw value with component type INT64", function () {
+ const array = new BigInt64Array([12345678900n, 23456789000n]);
+ const componentType = MetadataComponentType.INT64;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 8;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes raw value with component type UINT64", function () {
+ const array = new BigUint64Array([12345678900n, 23456789000n]);
+ const componentType = MetadataComponentType.UINT64;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 8;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes raw value with component type FLOAT32", function () {
+ const array = new Float32Array([1.23, 2.34]);
+ const componentType = MetadataComponentType.FLOAT32;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 4;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+
+ it("decodes raw value with component type FLOAT64", function () {
+ const array = new Float64Array([1.23, 2.34]);
+ const componentType = MetadataComponentType.FLOAT64;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 8;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+ });
+
+ describe("decodeRawMetadataValueComponent", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const classProperty = {
+ componentType: "NOT_A_COMPONENT_TYPE",
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 0;
+ MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ }).toThrowError();
+ });
+
+ it("throws for invalid offset", function () {
+ expect(function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1234;
+ MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ }).toThrowError();
+ });
+
+ it("decodes component with componentType INT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes component with componentType normalized INT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT8,
+ normalized: true,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(23 / 127.0, precision);
+ });
+
+ it("decodes component with componentType UINT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT8,
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes component with componentType normalized UINT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT8,
+ normalized: true,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(23 / 255.0, precision);
+ });
+
+ it("decodes component with componentType INT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT16,
+ normalized: false,
+ };
+ const array = new Int16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes component with componentType normalized INT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT16,
+ normalized: true,
+ };
+ const array = new Int16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2345 / 32767.0, precision);
+ });
+
+ it("decodes component with componentType UINT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT16,
+ normalized: false,
+ };
+ const array = new Uint16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes component with componentType normalized UINT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT16,
+ normalized: true,
+ };
+ const array = new Uint16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2345 / 65535.0, precision);
+ });
+
+ it("decodes component with componentType INT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT32,
+ normalized: false,
+ };
+ const array = new Int32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes component with componentType normalized INT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT32,
+ normalized: true,
+ };
+ const array = new Int32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(234567 / 2147483647.0, precision);
+ });
+
+ it("decodes component with componentType UINT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT32,
+ normalized: false,
+ };
+ const array = new Uint32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes component with componentType normalized UINT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT32,
+ normalized: true,
+ };
+ const array = new Uint32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(234567 / 4294967295.0, precision);
+ });
+
+ it("decodes component with componentType INT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT64,
+ normalized: false,
+ };
+ const array = new BigInt64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes component with componentType normalized INT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT64,
+ normalized: true,
+ };
+ const array = new BigInt64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(Number(value)).toBeCloseTo(
+ Number(23456789000n / 9223372036854775807n),
+ precision,
+ );
+ });
+
+ it("decodes component with componentType UINT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT64,
+ normalized: false,
+ };
+ const array = new BigUint64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes component with componentType normalized UINT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT64,
+ normalized: true,
+ };
+ const array = new BigUint64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(Number(value)).toBeCloseTo(
+ Number(23456789000n / 18446744073709551615n),
+ precision,
+ );
+ });
+
+ it("decodes component with componentType FLOAT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([1.23, 2.34]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+
+ it("decodes component with componentType FLOAT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.FLOAT64,
+ normalized: false,
+ };
+ const array = new Float64Array([1.23, 2.34]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+ });
+
+ describe("decodeRawMetadataValueElement", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const classProperty = {
+ type: "SCALAR",
+ componentType: "NOT_A_COMPONENT_TYPE",
+ normalized: false,
+ };
+ const array = new Int8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 0;
+ MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ }).toThrowError();
+ });
+
+ it("throws for invalid element index", function () {
+ expect(function () {
+ const classProperty = {
+ type: "SCALAR",
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1234;
+ MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ }).toThrowError();
+ });
+
+ it("decodes element with type SCALAR and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toBe(1);
+ });
+
+ it("decodes element with type VEC2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([2, 3]);
+ });
+
+ it("decodes element with type VEC3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3, 4, 5]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([3, 4, 5]);
+ });
+
+ it("decodes element with type VEC4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.MAT2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.MAT3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([9, 10, 11, 12, 13, 14, 15, 16, 17]);
+ });
+
+ it("decodes element with type MAT4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.MAT4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ });
+
+ it("decodes element with type SCALAR and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toBe(1);
+ });
+
+ it("decodes element with type VEC2 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([2, 3]);
+ });
+
+ it("decodes element with type VEC3 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3, 4, 5]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([3, 4, 5]);
+ });
+
+ it("decodes element with type VEC4 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT2 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.MAT2,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT3 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.MAT3,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([9, 10, 11, 12, 13, 14, 15, 16, 17]);
+ });
+
+ it("decodes element with type MAT4 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.MAT4,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ });
+ });
+
+ describe("decodeRawMetadataValues", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const classProperty = {
+ type: "SCALAR",
+ componentType: "NOT_A_COMPONENT_TYPE",
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ MetadataPicking.decodeRawMetadataValues(classProperty, rawPixelValues);
+ }).toThrowError();
+ });
+
+ it("throws for invalid input length", function () {
+ expect(function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.UINT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0]);
+ MetadataPicking.decodeRawMetadataValues(classProperty, rawPixelValues);
+ }).toThrowError();
+ });
+
+ it("decodes raw values with type SCALAR and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(12);
+ });
+
+ it("decodes raw values with type VEC2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual([0, 1]);
+ });
+
+ it("decodes raw values with type VEC3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual([0, 1, 2]);
+ });
+
+ it("decodes raw values with type VEC4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual([0, 1, 2, 3]);
+ });
+ });
+
+ describe("convertToObjectType", function () {
+ it("throws for invalid type", function () {
+ expect(function () {
+ const type = "NOT_A_TYPE";
+ const value = 0;
+ MetadataPicking.convertToObjectType(type, value);
+ }).toThrowError();
+ });
+
+ it("returns SCALAR, STRING, BOOLEAN, and ENUM types (and arrays thereof) unmodified", function () {
+ const value0 = MetadataPicking.convertToObjectType(
+ MetadataType.SCALAR,
+ 123,
+ );
+ const value1 = MetadataPicking.convertToObjectType(
+ MetadataType.STRING,
+ "Value",
+ );
+ const value2 = MetadataPicking.convertToObjectType(
+ MetadataType.SCALAR,
+ true,
+ );
+ const value3 = MetadataPicking.convertToObjectType(
+ MetadataType.ENUM,
+ "VALUE",
+ );
+
+ expect(value0).toEqual(123);
+ expect(value1).toEqual("Value");
+ expect(value2).toEqual(true);
+ expect(value3).toEqual("VALUE");
+
+ const value0a = MetadataPicking.convertToObjectType(
+ MetadataType.SCALAR,
+ [123, 234],
+ );
+ const value1a = MetadataPicking.convertToObjectType(MetadataType.STRING, [
+ "Value0",
+ "Value1",
+ ]);
+ const value2a = MetadataPicking.convertToObjectType(MetadataType.SCALAR, [
+ true,
+ false,
+ ]);
+ const value3a = MetadataPicking.convertToObjectType(MetadataType.ENUM, [
+ "VALUE_A",
+ "VALUE_B",
+ ]);
+
+ expect(value0a).toEqual([123, 234]);
+ expect(value1a).toEqual(["Value0", "Value1"]);
+ expect(value2a).toEqual([true, false]);
+ expect(value3a).toEqual(["VALUE_A", "VALUE_B"]);
+ });
+
+ it("converts array-based VEC2 input into a Cartesian2", function () {
+ const array = [0, 1];
+ const expected = Cartesian2.unpack(array, 0, new Cartesian2());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.VEC2,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based VEC3 input into a Cartesian3", function () {
+ const array = [0, 1, 2];
+ const expected = Cartesian3.unpack(array, 0, new Cartesian3());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.VEC3,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based VEC4 input into a Cartesian4", function () {
+ const array = [0, 1, 2, 3];
+ const expected = Cartesian4.unpack(array, 0, new Cartesian4());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.VEC4,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based MAT2 input into a Matrix2", function () {
+ const array = [0, 1, 2, 3];
+ const expected = Matrix2.unpack(array, 0, new Matrix2());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.MAT2,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based MAT3 input into a Matrix3", function () {
+ const array = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+ const expected = Matrix3.unpack(array, 0, new Matrix3());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.MAT3,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based MAT4 input into a Matrix4", function () {
+ const array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+ const expected = Matrix4.unpack(array, 0, new Matrix4());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.MAT4,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+ });
+
+ describe("convertFromObjectType", function () {
+ it("throws for invalid type", function () {
+ expect(function () {
+ const type = "NOT_A_TYPE";
+ const value = new Cartesian2();
+ MetadataPicking.convertFromObjectType(type, value);
+ }).toThrowError();
+ });
+
+ it("returns SCALAR, STRING, BOOLEAN, and ENUM types (and arrays thereof) unmodified", function () {
+ const value0 = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ 123,
+ );
+ const value1 = MetadataPicking.convertFromObjectType(
+ MetadataType.STRING,
+ "Value",
+ );
+ const value2 = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ true,
+ );
+ const value3 = MetadataPicking.convertFromObjectType(
+ MetadataType.ENUM,
+ "VALUE",
+ );
+
+ expect(value0).toEqual(123);
+ expect(value1).toEqual("Value");
+ expect(value2).toEqual(true);
+ expect(value3).toEqual("VALUE");
+
+ const value0a = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ [123, 234],
+ );
+ const value1a = MetadataPicking.convertFromObjectType(
+ MetadataType.STRING,
+ ["Value0", "Value1"],
+ );
+ const value2a = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ [true, false],
+ );
+ const value3a = MetadataPicking.convertFromObjectType(MetadataType.ENUM, [
+ "VALUE_A",
+ "VALUE_B",
+ ]);
+
+ expect(value0a).toEqual([123, 234]);
+ expect(value1a).toEqual(["Value0", "Value1"]);
+ expect(value2a).toEqual([true, false]);
+ expect(value3a).toEqual(["VALUE_A", "VALUE_B"]);
+ });
+
+ it("converts Cartesian2 into array-based VEC2", function () {
+ const expected = [0, 1];
+ const value = Cartesian2.unpack(expected, 0, new Cartesian2());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.VEC2,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Cartesian3 into array-based VEC3", function () {
+ const expected = [0, 1, 2];
+ const value = Cartesian3.unpack(expected, 0, new Cartesian3());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.VEC3,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Cartesian4 into array-based VEC4", function () {
+ const expected = [0, 1, 2, 3];
+ const value = Cartesian4.unpack(expected, 0, new Cartesian4());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.VEC4,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Matrix2 into array-based MAT2", function () {
+ const expected = [0, 1, 2, 3];
+ const value = Matrix2.unpack(expected, 0, new Matrix2());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.MAT2,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Matrix3 into array-based MAT3", function () {
+ const expected = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+ const value = Matrix3.unpack(expected, 0, new Matrix3());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.MAT3,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Matrix4 into array-based MAT4", function () {
+ const expected = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+ const value = Matrix4.unpack(expected, 0, new Matrix4());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.MAT4,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+ });
+
+ describe("decodeMetadataValues", function () {
+ it("throws for invalid type", function () {
+ expect(function () {
+ const classProperty = {
+ type: "NOT_A_TYPE",
+ componentType: MetadataComponentType.UINT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ }).toThrowError();
+ });
+
+ it("decodes values with type SCALAR and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(12);
+ });
+
+ it("decodes values with type VEC2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(new Cartesian2(12, 23));
+ });
+
+ it("decodes values with type VEC3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(new Cartesian3(12, 23, 34));
+ });
+
+ it("decodes values with type VEC4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(new Cartesian4(12, 23, 34, 45));
+ });
+
+ it("decodes values with type SCALAR and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = 100;
+ const scale = 2;
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(offset + 12 * scale);
+ });
+
+ it("decodes values with type VEC2 and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = new Cartesian2(100, 200);
+ const scale = new Cartesian2(2, 3);
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ const expected = new Cartesian2(
+ offset.x + 12 * scale.x,
+ offset.y + 23 * scale.y,
+ );
+ expect(value).toEqual(expected);
+ });
+
+ it("decodes values with type VEC3 and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = new Cartesian3(100, 200, 300);
+ const scale = new Cartesian3(2, 3, 4);
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ const expected = new Cartesian3(
+ offset.x + 12 * scale.x,
+ offset.y + 23 * scale.y,
+ offset.z + 34 * scale.z,
+ );
+ expect(value).toEqual(expected);
+ });
+
+ it("decodes values with type VEC4 and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = new Cartesian4(100, 200, 300, 400);
+ const scale = new Cartesian4(2, 3, 4, 5);
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ const expected = new Cartesian4(
+ offset.x + 12 * scale.x,
+ offset.y + 23 * scale.y,
+ offset.z + 34 * scale.z,
+ offset.w + 45 * scale.w,
+ );
+ expect(value).toEqual(expected);
+ });
+ });
+});
diff --git a/packages/engine/Specs/Scene/Model/ModelSpec.js b/packages/engine/Specs/Scene/Model/ModelSpec.js
index 2f31aa01b5fa..7af9758fdad9 100644
--- a/packages/engine/Specs/Scene/Model/ModelSpec.js
+++ b/packages/engine/Specs/Scene/Model/ModelSpec.js
@@ -3113,10 +3113,13 @@ describe(
{
gltf: boxTexturedGltfUrl,
lightColor: Cartesian3.ZERO,
- imageBasedLighting: undefined,
},
scene,
);
+
+ // ignore any image-based lighting– Test directional light only
+ model.imageBasedLighting.imageBasedLightingFactor = Cartesian2.ZERO;
+
verifyRender(model, false);
});
@@ -3125,6 +3128,10 @@ describe(
{ gltf: boxTexturedGltfUrl, imageBasedLighting: undefined },
scene,
);
+
+ // ignore any image-based lighting– Test directional light only
+ model.imageBasedLighting.imageBasedLightingFactor = Cartesian2.ZERO;
+
model.lightColor = Cartesian3.ZERO;
verifyRender(model, false);
@@ -3193,7 +3200,7 @@ describe(
it("changing imageBasedLighting works", async function () {
const imageBasedLighting = new ImageBasedLighting({
sphericalHarmonicCoefficients: [
- new Cartesian3(0.35449, 0.35449, 0.35449),
+ new Cartesian3(1.0, 0.0, 0.0),
Cartesian3.ZERO,
Cartesian3.ZERO,
Cartesian3.ZERO,
diff --git a/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js b/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js
index d471effc9773..c83454747c6d 100644
--- a/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js
+++ b/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js
@@ -15,7 +15,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -27,7 +27,7 @@ describe("Scene/Model/ModelStatistics", function () {
statistics.texturesByteLength = 10;
statistics.propertyTablesByteLength = 10;
statistics._bufferIdSet = { uuid1: true, uuid2: true };
- statistics._textureIdSet = { uuid3: true };
+ statistics._textureIdByteLengths = { uuid3: 1234 };
const map = new AssociativeArray();
map.set("uuid", {});
@@ -41,7 +41,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -78,7 +78,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({ uuid: true });
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -99,7 +99,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({ uuid: true });
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -129,7 +129,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({ uuid1: true, uuid2: true });
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -158,7 +158,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({ uuid: true });
+ expect(statistics._textureIdByteLengths).toEqual({ uuid: 10 });
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -188,7 +188,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({ uuid1: true, uuid2: true });
+ expect(statistics._textureIdByteLengths).toEqual({ uuid1: 2, uuid2: 3 });
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -219,7 +219,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(expectedMap);
// Simulate creating a batch texture
@@ -265,7 +265,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(expectedMap);
// Simulate creating first batch texture
diff --git a/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js b/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js
index 11cf22014bd7..ae7deeead20b 100644
--- a/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js
+++ b/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js
@@ -314,7 +314,9 @@ describe(
"HAS_POINT_CLOUD_SHOW_STYLE",
"COMPUTE_POSITION_WC_STYLE",
]);
- ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, []);
+ ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
+ "HAS_POINT_CLOUD_SHOW_STYLE",
+ ]);
ShaderBuilderTester.expectHasVertexUniforms(shaderBuilder, [
"uniform vec4 model_pointCloudParameters;",
diff --git a/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js b/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js
index e50ab6a8cf5c..514f53df64f5 100644
--- a/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js
+++ b/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js
@@ -1,28 +1,12 @@
-import { Model, ImageBasedLighting, Cartesian3 } from "../../../index.js";
+import { Model } from "../../../index.js";
import pollToPromise from "../../../../../Specs/pollToPromise.js";
-// A white ambient light with low intensity
-const defaultIbl = new ImageBasedLighting({
- sphericalHarmonicCoefficients: [
- new Cartesian3(0.35449, 0.35449, 0.35449),
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- ],
-});
-
async function loadAndZoomToModelAsync(options, scene) {
options = {
environmentMapOptions: {
enabled: false, // disable other diffuse lighting by default
...options.environmentMapOptions,
},
- imageBasedLighting: defaultIbl,
...options,
};
diff --git a/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js b/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js
index 3350a5a2eb54..5b6f4d040389 100644
--- a/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js
+++ b/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js
@@ -392,32 +392,23 @@ describe(
expect(ao.uniforms.intensity).toEqual(3.0);
expect(ao.uniforms.bias).toEqual(0.1);
expect(ao.uniforms.lengthCap).toEqual(0.26);
- expect(ao.uniforms.stepSize).toEqual(1.95);
- expect(ao.uniforms.frustumLength).toEqual(1000.0);
+ expect(ao.uniforms.directionCount).toEqual(8);
+ expect(ao.uniforms.stepCount).toEqual(32);
expect(ao.uniforms.randomTexture).not.toBeDefined();
- expect(ao.uniforms.delta).toEqual(1.0);
- expect(ao.uniforms.sigma).toEqual(2.0);
- expect(ao.uniforms.blurStepSize).toEqual(0.86);
ao.uniforms.ambientOcclusionOnly = true;
ao.uniforms.intensity = 4.0;
ao.uniforms.bias = 0.2;
ao.uniforms.lengthCap = 0.3;
- ao.uniforms.stepSize = 2.0;
- ao.uniforms.frustumLength = 1001.0;
- ao.uniforms.delta = 2.0;
- ao.uniforms.sigma = 3.0;
- ao.uniforms.blurStepSize = 2.0;
+ ao.uniforms.directionCount = 9;
+ ao.uniforms.stepCount = 33;
expect(ao.uniforms.ambientOcclusionOnly).toEqual(true);
expect(ao.uniforms.intensity).toEqual(4.0);
expect(ao.uniforms.bias).toEqual(0.2);
expect(ao.uniforms.lengthCap).toEqual(0.3);
- expect(ao.uniforms.stepSize).toEqual(2.0);
- expect(ao.uniforms.frustumLength).toEqual(1001.0);
- expect(ao.uniforms.delta).toEqual(2.0);
- expect(ao.uniforms.sigma).toEqual(3.0);
- expect(ao.uniforms.blurStepSize).toEqual(2.0);
+ expect(ao.uniforms.directionCount).toEqual(9);
+ expect(ao.uniforms.stepCount).toEqual(33);
});
it("bloom", function () {
diff --git a/packages/engine/Specs/Scene/SceneSpec.js b/packages/engine/Specs/Scene/SceneSpec.js
index 3fc9c31602aa..7f2d30742baa 100644
--- a/packages/engine/Specs/Scene/SceneSpec.js
+++ b/packages/engine/Specs/Scene/SceneSpec.js
@@ -271,26 +271,64 @@ function createPropertyTextureGltfScalar() {
type: "SCALAR",
componentType: "UINT8",
},
+ },
+ },
+ },
+ };
+ const properties = {
+ example_UINT8_SCALAR: {
+ index: 0,
+ texCoord: 0,
+ channels: [0],
+ },
+ };
+ return createPropertyTextureGltf(schema, properties);
+}
+
+/**
+ * Creates the glTF for the normalized 'scalar' test case
+ *
+ * @param {number|undefined} classPropertyOffset The optional offset
+ * that will be defined in the class property definition
+ * @param {number|undefined} classPropertyScale The optional scale
+ * that will be defined in the class property definition
+ * @param {number|undefined} metadataPropertyOffset The optional offset
+ * that will be defined in the property texture property definition
+ * @param {number|undefined} metadataPropertyScale The optional scale
+ * that will be defined in the property texture property definition
+ * @returns The glTF
+ */
+function createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+) {
+ const schema = {
+ id: "ExampleSchema",
+ classes: {
+ exampleClass: {
+ name: "Example class",
+ properties: {
example_normalized_UINT8_SCALAR: {
name: "Example SCALAR property with normalized UINT8 components",
type: "SCALAR",
componentType: "UINT8",
normalized: true,
+ offset: classPropertyOffset,
+ scale: classPropertyScale,
},
},
},
},
};
const properties = {
- example_UINT8_SCALAR: {
- index: 0,
- texCoord: 0,
- channels: [0],
- },
example_normalized_UINT8_SCALAR: {
index: 0,
texCoord: 0,
- channels: [1],
+ channels: [0],
+ offset: metadataPropertyOffset,
+ scale: metadataPropertyScale,
},
};
return createPropertyTextureGltf(schema, properties);
@@ -329,6 +367,57 @@ function createPropertyTextureGltfScalarArray() {
return createPropertyTextureGltf(schema, properties);
}
+/**
+ * Creates the glTF for the 'normalized scalar array' test case
+ *
+ * @param {number[]|undefined} classPropertyOffset The optional offset
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} classPropertyScale The optional scale
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} metadataPropertyOffset The optional offset
+ * that will be defined in the property texture property definition
+ * @param {number[]|undefined} metadataPropertyScale The optional scale
+ * that will be defined in the property texture property definition
+ * @returns The glTF
+ */
+function createPropertyTextureGltfNormalizedScalarArray(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+) {
+ const schema = {
+ id: "ExampleSchema",
+ classes: {
+ exampleClass: {
+ name: "Example class",
+ properties: {
+ example_fixed_length_normalized_UINT8_SCALAR_array: {
+ name: "Example fixed-length SCALAR array property with normalized INT8 components",
+ type: "SCALAR",
+ componentType: "UINT8",
+ array: true,
+ count: 3,
+ normalized: true,
+ offset: classPropertyOffset,
+ scale: classPropertyScale,
+ },
+ },
+ },
+ },
+ };
+ const properties = {
+ example_fixed_length_normalized_UINT8_SCALAR_array: {
+ index: 0,
+ texCoord: 0,
+ channels: [0, 1, 2],
+ offset: metadataPropertyOffset,
+ scale: metadataPropertyScale,
+ },
+ };
+ return createPropertyTextureGltf(schema, properties);
+}
+
/**
* Creates the glTF for the 'vec2' test case
*
@@ -363,9 +452,22 @@ function createPropertyTextureGltfVec2() {
/**
* Creates the glTF for the normalized 'vec2' test case
*
+ * @param {number[]|undefined} classPropertyOffset The optional offset
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} classPropertyScale The optional scale
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} metadataPropertyOffset The optional offset
+ * that will be defined in the property texture property definition
+ * @param {number[]|undefined} metadataPropertyScale The optional scale
+ * that will be defined in the property texture property definition
* @returns The glTF
*/
-function createPropertyTextureGltfNormalizedVec2() {
+function createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+) {
const schema = {
id: "ExampleSchema",
classes: {
@@ -377,6 +479,8 @@ function createPropertyTextureGltfNormalizedVec2() {
type: "VEC2",
componentType: "UINT8",
normalized: true,
+ offset: classPropertyOffset,
+ scale: classPropertyScale,
},
},
},
@@ -387,6 +491,8 @@ function createPropertyTextureGltfNormalizedVec2() {
index: 0,
texCoord: 0,
channels: [0, 1],
+ offset: metadataPropertyOffset,
+ scale: metadataPropertyScale,
},
};
return createPropertyTextureGltf(schema, properties);
@@ -3115,7 +3221,16 @@ describe(
const schemaId = undefined;
const className = "exampleClass";
const propertyName = "example_normalized_UINT8_SCALAR";
- const gltf = createPropertyTextureGltfScalar();
+ const classPropertyOffset = undefined;
+ const classPropertyScale = undefined;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
const canvasSizeX = textureSizeX * canvasScaling;
const canvasSizeY = textureSizeY * canvasScaling;
@@ -3145,16 +3260,16 @@ describe(
schemaId,
className,
propertyName,
- 3,
0,
+ 1,
);
const actualMetadataValue2 = pickMetadataAt(
scene,
schemaId,
className,
propertyName,
- 6,
0,
+ 2,
);
const expectedMetadataValue0 = 0.0;
const expectedMetadataValue1 = 0.5;
@@ -3175,6 +3290,165 @@ describe(
scene.destroyForSpecs();
});
+ it("picks normalized UINT8 SCALAR from a property texture with offset and scale in class property", async function () {
+ if (webglStub) {
+ return;
+ }
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_SCALAR";
+ const classPropertyOffset = 100.0;
+ const classPropertyScale = 2.0;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 2,
+ );
+ const expectedMetadataValue0 =
+ classPropertyOffset + classPropertyScale * 0.0;
+ const expectedMetadataValue1 =
+ classPropertyOffset + classPropertyScale * 0.5;
+ const expectedMetadataValue2 =
+ classPropertyOffset + classPropertyScale * 1.0;
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
+ it("picks normalized UINT8 SCALAR from a property texture with offset and scale in property texture property", async function () {
+ if (webglStub) {
+ return;
+ }
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_SCALAR";
+ const classPropertyOffset = 100.0;
+ const classPropertyScale = 200.0;
+ // These should override the values from the class property:
+ const metadataPropertyOffset = 200.0;
+ const metadataPropertyScale = 3.0;
+ const gltf = createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 2,
+ );
+ const expectedMetadataValue0 =
+ metadataPropertyOffset + metadataPropertyScale * 0.0;
+ const expectedMetadataValue1 =
+ metadataPropertyOffset + metadataPropertyScale * 0.5;
+ const expectedMetadataValue2 =
+ metadataPropertyOffset + metadataPropertyScale * 1.0;
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
it("picks fixed length UINT8 SCALAR array from a property texture", async function () {
if (webglStub) {
return;
@@ -3242,6 +3516,82 @@ describe(
scene.destroyForSpecs();
});
+ it("picks fixed length normalized UINT8 SCALAR array from a property texture", async function () {
+ if (webglStub) {
+ return;
+ }
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_fixed_length_normalized_UINT8_SCALAR_array";
+ const classPropertyOffset = undefined;
+ const classPropertyScale = undefined;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedScalarArray(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 1,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 2,
+ 2,
+ );
+ const expectedMetadataValue0 = [0, 0, 0];
+ const expectedMetadataValue1 = [0.5, 0, 0.5];
+ const expectedMetadataValue2 = [1.0, 0, 1.0];
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
it("picks UINT8 VEC2 from a property texture", async function () {
if (webglStub) {
return;
@@ -3318,7 +3668,16 @@ describe(
const schemaId = undefined;
const className = "exampleClass";
const propertyName = "example_normalized_UINT8_VEC2";
- const gltf = createPropertyTextureGltfNormalizedVec2();
+ const classPropertyOffset = undefined;
+ const classPropertyScale = undefined;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
const canvasSizeX = textureSizeX * canvasScaling;
const canvasSizeY = textureSizeY * canvasScaling;
@@ -3379,6 +3738,181 @@ describe(
scene.destroyForSpecs();
});
+ it("picks normalized UINT8 VEC2 from a property texture with offset and scale in class property", async function () {
+ if (webglStub) {
+ return;
+ }
+
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_VEC2";
+ const classPropertyOffset = [100.0, 200.0];
+ const classPropertyScale = [2.0, 3.0];
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 1,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 2,
+ 2,
+ );
+
+ const expectedMetadataValue0 = new Cartesian2(
+ classPropertyOffset[0] + classPropertyScale[0] * 0.0,
+ classPropertyOffset[1] + classPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue1 = new Cartesian2(
+ classPropertyOffset[0] + classPropertyScale[0] * 0.5,
+ classPropertyOffset[1] + classPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue2 = new Cartesian2(
+ classPropertyOffset[0] + classPropertyScale[0] * 1.0,
+ classPropertyOffset[1] + classPropertyScale[1] * 0.0,
+ );
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
+ it("picks normalized UINT8 VEC2 from a property texture with offset and scale in property texture property", async function () {
+ if (webglStub) {
+ return;
+ }
+
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_VEC2";
+ const classPropertyOffset = [100.0, 200.0];
+ const classPropertyScale = [2.0, 3.0];
+ // These should override the values from the class property:
+ const metadataPropertyOffset = [300.0, 400.0];
+ const metadataPropertyScale = [4.0, 5.0];
+ const gltf = createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 1,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 2,
+ 2,
+ );
+
+ const expectedMetadataValue0 = new Cartesian2(
+ metadataPropertyOffset[0] + metadataPropertyScale[0] * 0.0,
+ metadataPropertyOffset[1] + metadataPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue1 = new Cartesian2(
+ metadataPropertyOffset[0] + metadataPropertyScale[0] * 0.5,
+ metadataPropertyOffset[1] + metadataPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue2 = new Cartesian2(
+ metadataPropertyOffset[0] + metadataPropertyScale[0] * 1.0,
+ metadataPropertyOffset[1] + metadataPropertyScale[1] * 0.0,
+ );
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
it("picks UINT8 VEC3 from a property texture", async function () {
if (webglStub) {
return;
diff --git a/packages/engine/Specs/Scene/ShadowMapSpec.js b/packages/engine/Specs/Scene/ShadowMapSpec.js
index 2a66f528b10d..1b142d13152b 100644
--- a/packages/engine/Specs/Scene/ShadowMapSpec.js
+++ b/packages/engine/Specs/Scene/ShadowMapSpec.js
@@ -11,7 +11,6 @@ import {
HeadingPitchRange,
HeadingPitchRoll,
HeightmapTerrainData,
- ImageBasedLighting,
JulianDate,
Math as CesiumMath,
Matrix4,
@@ -282,26 +281,11 @@ describe(
}
async function loadModel(options) {
- // A white ambient light with low intensity
- const defaultIbl = new ImageBasedLighting({
- sphericalHarmonicCoefficients: [
- new Cartesian3(0.35449, 0.35449, 0.35449),
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- ],
- });
const model = scene.primitives.add(
await Model.fromGltfAsync({
environmentMapOptions: {
enabled: false,
},
- imageBasedLighting: defaultIbl,
...options,
}),
);
diff --git a/packages/engine/Specs/Scene/SkyBoxSpec.js b/packages/engine/Specs/Scene/SkyBoxSpec.js
index 4db7c8702d18..9691fb035594 100644
--- a/packages/engine/Specs/Scene/SkyBoxSpec.js
+++ b/packages/engine/Specs/Scene/SkyBoxSpec.js
@@ -1,6 +1,7 @@
-import { Resource, SceneMode, SkyBox } from "../../index.js";
+import { defined, Resource, SceneMode, SkyBox } from "../../index.js";
import createScene from "../../../../Specs/createScene.js";
+import pollToPromise from "../../../../Specs/pollToPromise.js";
describe(
"Scene/SkyBox",
@@ -10,8 +11,6 @@ describe(
let loadedImage;
beforeAll(function () {
- scene = createScene();
-
return Resource.fetchImage("./Data/Images/Blue.png").then(
function (image) {
loadedImage = image;
@@ -19,17 +18,15 @@ describe(
);
});
- afterAll(function () {
- scene.destroyForSpecs();
- });
-
beforeEach(function () {
+ scene = createScene();
scene.mode = SceneMode.SCENE3D;
});
afterEach(function () {
skyBox = skyBox && skyBox.destroy();
scene.skyBox = undefined;
+ scene.destroyForSpecs();
});
it("draws a sky box from Images", function () {
@@ -355,6 +352,32 @@ describe(
return scene.render();
}).toThrowDeveloperError();
});
+
+ it("defers throwing error when Resources fail to load until next call to update", async () => {
+ const error = new Error("intentional error for test");
+ spyOn(Resource.prototype, "fetchImage").and.rejectWith(error);
+
+ skyBox = new SkyBox({
+ sources: {
+ positiveX: "./Data/Images/Blue.png",
+ negativeX: "./Data/Images/Blue.png",
+ positiveY: "./Data/Images/Blue.png",
+ negativeY: "./Data/Images/Blue.png",
+ positiveZ: "./Data/Images/Blue.png",
+ negativeZ: "./Data/Images/Blue.png",
+ },
+ });
+
+ scene.frameState.passes.render = true;
+ scene.skyBox = skyBox;
+ skyBox.update(scene.frameState);
+
+ await pollToPromise(() => defined(skyBox._cubeMap) || skyBox._hasError);
+
+ expect(skyBox._hasError).toBeTrue();
+ expect(skyBox._error).toEqual(error);
+ expect(() => skyBox.update(scene.frameState)).toThrow(error);
+ });
},
"WebGL",
);
diff --git a/packages/engine/package.json b/packages/engine/package.json
index acc1c285479d..f95090f5176f 100644
--- a/packages/engine/package.json
+++ b/packages/engine/package.json
@@ -1,6 +1,6 @@
{
"name": "@cesium/engine",
- "version": "12.0.0",
+ "version": "13.0.0",
"description": "CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
"keywords": [
"3D",
diff --git a/packages/widgets/Source/Viewer/Viewer.js b/packages/widgets/Source/Viewer/Viewer.js
index 4574ef6aadc7..b00646389215 100644
--- a/packages/widgets/Source/Viewer/Viewer.js
+++ b/packages/widgets/Source/Viewer/Viewer.js
@@ -18,6 +18,7 @@ import {
Math as CesiumMath,
Property,
ScreenSpaceEventType,
+ IonGeocoderService,
} from "@cesium/engine";
import Animation from "../Animation/Animation.js";
import AnimationViewModel from "../Animation/AnimationViewModel.js";
@@ -280,7 +281,7 @@ function enableVRUI(viewer, enabled) {
* @property {boolean} [baseLayerPicker=true] If set to false, the BaseLayerPicker widget will not be created.
* @property {boolean} [fullscreenButton=true] If set to false, the FullscreenButton widget will not be created.
* @property {boolean} [vrButton=false] If set to true, the VRButton widget will be created.
- * @property {boolean|GeocoderService[]} [geocoder=true] If set to false, the Geocoder widget will not be created.
+ * @property {boolean|IonGeocodeProviderType|GeocoderService[]} [geocoder=IonGeocodeProviderType.DEFAULT] The geocoding service or services to use when searching with the Geocoder widget. If set to false, the Geocoder widget will not be created.
* @property {boolean} [homeButton=true] If set to false, the HomeButton widget will not be created.
* @property {boolean} [infoBox=true] If set to false, the InfoBox widget will not be created.
* @property {boolean} [sceneModePicker=true] If set to false, the SceneModePicker widget will not be created.
@@ -295,7 +296,7 @@ function enableVRUI(viewer, enabled) {
* @property {ProviderViewModel[]} [imageryProviderViewModels=createDefaultImageryProviderViewModels()] The array of ProviderViewModels to be selectable from the BaseLayerPicker. This value is only valid if `baseLayerPicker` is set to true.
* @property {ProviderViewModel} [selectedTerrainProviderViewModel] The view model for the current base terrain layer, if not supplied the first available base layer is used. This value is only valid if `baseLayerPicker` is set to true.
* @property {ProviderViewModel[]} [terrainProviderViewModels=createDefaultTerrainProviderViewModels()] The array of ProviderViewModels to be selectable from the BaseLayerPicker. This value is only valid if `baseLayerPicker` is set to true.
- * @property {ImageryLayer|false} [baseLayer=ImageryLayer.fromWorldImagery()] The bottommost imagery layer applied to the globe. If set to false, no imagery provider will be added. This value is only valid if `baseLayerPicker` is set to false.
+ * @property {ImageryLayer|false} [baseLayer=ImageryLayer.fromWorldImagery()] The bottommost imagery layer applied to the globe. If set to false, no imagery provider will be added. This value is only valid if `baseLayerPicker` is set to false. Cannot be used when `globe` is set to false.
* @property {Ellipsoid} [ellipsoid = Ellipsoid.default] The default ellipsoid.
* @property {TerrainProvider} [terrainProvider=new EllipsoidTerrainProvider()] The terrain provider to use
* @property {Terrain} [terrain] A terrain object which handles asynchronous terrain provider. Can only specify if options.terrainProvider is undefined.
@@ -402,6 +403,16 @@ function Viewer(container, options) {
container = getElement(container);
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+ //>>includeStart('debug', pragmas.debug);
+ if (
+ options.globe === false &&
+ defined(options.baseLayer) &&
+ options.baseLayer !== false
+ ) {
+ throw new DeveloperError("Cannot use baseLayer when globe is disabled.");
+ }
+ //>>includeEnd('debug')
+
const createBaseLayerPicker =
(!defined(options.globe) || options.globe !== false) &&
(!defined(options.baseLayerPicker) || options.baseLayerPicker !== false);
@@ -557,7 +568,17 @@ Either specify options.terrainProvider instead or set options.baseLayerPicker to
geocoderContainer.className = "cesium-viewer-geocoderContainer";
toolbar.appendChild(geocoderContainer);
let geocoderService;
- if (defined(options.geocoder) && typeof options.geocoder !== "boolean") {
+ if (typeof options.geocoder === "string") {
+ geocoderService = [
+ new IonGeocoderService({
+ scene,
+ geocodeProviderType: options.geocoder,
+ }),
+ ];
+ } else if (
+ defined(options.geocoder) &&
+ typeof options.geocoder !== "boolean"
+ ) {
geocoderService = Array.isArray(options.geocoder)
? options.geocoder
: [options.geocoder];
diff --git a/packages/widgets/Specs/Viewer/ViewerSpec.js b/packages/widgets/Specs/Viewer/ViewerSpec.js
index 49df43f46eb2..822df41c034b 100644
--- a/packages/widgets/Specs/Viewer/ViewerSpec.js
+++ b/packages/widgets/Specs/Viewer/ViewerSpec.js
@@ -18,6 +18,8 @@ import {
ImageryLayerCollection,
SceneMode,
ShadowMode,
+ IonGeocodeProviderType,
+ IonGeocoderService,
} from "@cesium/engine";
import {
@@ -354,6 +356,19 @@ describe(
expect(viewer.geocoder.viewModel._geocoderServices.length).toBe(1);
});
+ it("constructs geocoder with IonGeocodeProviderType", function () {
+ viewer = createViewer(container, {
+ geocoder: IonGeocodeProviderType.GOOGLE,
+ });
+ expect(viewer.geocoder).toBeDefined();
+ expect(viewer.geocoder.viewModel._geocoderServices.length).toBe(1);
+ const geocoderService = viewer.geocoder.viewModel._geocoderServices[0];
+ expect(geocoderService).toBeInstanceOf(IonGeocoderService);
+ expect(geocoderService.geocodeProviderType).toEqual(
+ IonGeocodeProviderType.GOOGLE,
+ );
+ });
+
it("constructs geocoder with geocoder service option", function () {
const service = new CartographicGeocoderService();
viewer = createViewer(container, {
@@ -542,6 +557,23 @@ describe(
);
});
+ it("throws when baseLayer is provided with globe: false", function () {
+ expect(function () {
+ viewer = createViewer(container, {
+ globe: false,
+ baseLayer: new ImageryLayer(testProvider),
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("does not throw when globe is false and baseLayer is not provided", function () {
+ expect(function () {
+ viewer = createViewer(container, {
+ globe: false,
+ });
+ }).not.toThrowDeveloperError();
+ });
+
it("can set baseLayer to false when BaseLayerPicker is disabled", function () {
viewer = createViewer(container, {
baseLayerPicker: false,
diff --git a/packages/widgets/package.json b/packages/widgets/package.json
index 42736b0c563a..eecf87e2728d 100644
--- a/packages/widgets/package.json
+++ b/packages/widgets/package.json
@@ -1,6 +1,6 @@
{
"name": "@cesium/widgets",
- "version": "9.0.0",
+ "version": "10.0.0",
"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": "^12.0.0",
+ "@cesium/engine": "^13.0.0",
"nosleep.js": "^0.12.0"
},
"type": "module",
`,
+ collapsible: false,
+ },
+ },
+ ]);
+ });
+
+ it("returns empty array for status=ZERO_RESULTS", async function () {
+ const service = new GoogleGeocoderService({ key: "key" });
+
+ spyOn(Resource.prototype, "fetchJson").and.resolveTo({
+ status: "ZERO_RESULTS",
+ });
+
+ const results = await service.geocode("test");
+ expect(results).toEqual([]);
+ });
+});
diff --git a/packages/engine/Specs/Core/ITwinPlatformSpec.js b/packages/engine/Specs/Core/ITwinPlatformSpec.js
new file mode 100644
index 000000000000..b43089c3f881
--- /dev/null
+++ b/packages/engine/Specs/Core/ITwinPlatformSpec.js
@@ -0,0 +1,414 @@
+import {
+ ITwinPlatform,
+ RequestErrorEvent,
+ Resource,
+ RuntimeError,
+} from "../../index.js";
+
+describe("ITwinPlatform", () => {
+ let previousAccessToken;
+ beforeEach(() => {
+ previousAccessToken = ITwinPlatform.defaultAccessToken;
+ ITwinPlatform.defaultAccessToken = "default-access-token";
+ });
+
+ afterEach(() => {
+ ITwinPlatform.defaultAccessToken = previousAccessToken;
+ });
+
+ describe("getExports", () => {
+ let requestSpy;
+ beforeEach(() => {
+ requestSpy = spyOn(Resource.prototype, "fetchJson");
+ });
+
+ it("rejects with no iModelId", async () => {
+ await expectAsync(
+ ITwinPlatform.getExports(undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected iModelId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no default access token set", async () => {
+ ITwinPlatform.defaultAccessToken = undefined;
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithDeveloperError(
+ "Must set ITwinPlatform.defaultAccessToken first",
+ );
+ });
+
+ it("rejects for API 401 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 401,
+ JSON.stringify({
+ error: { message: "failed", details: [{ code: "InvalidToken" }] },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unauthorized/);
+ });
+
+ it("rejects for API 403 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 403,
+ JSON.stringify({
+ error: { message: "failed", code: "Forbidden" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /forbidden/);
+ });
+
+ it("rejects for API 422 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 422,
+ JSON.stringify({
+ error: { message: "failed", code: "BadEntity" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unprocessable/);
+ });
+
+ it("rejects for API 429 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 429,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getExports("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Too many/);
+ });
+
+ it("uses the default access token for the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return { exports: [] };
+ });
+ await ITwinPlatform.getExports("imodel-id-1");
+ expect(resource).toBeDefined();
+ expect(resource.headers["Authorization"]).toEqual(
+ "Bearer default-access-token",
+ );
+ });
+
+ it("uses the imodel id in the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return JSON.stringify({ exports: [] });
+ });
+ await ITwinPlatform.getExports("imodel-id-1");
+ expect(resource).toBeDefined();
+ expect(resource.url).toContain("imodel-id-1");
+ });
+ });
+
+ describe("getRealityDataMetadata", () => {
+ let requestSpy;
+ beforeEach(() => {
+ requestSpy = spyOn(Resource.prototype, "fetchJson");
+ });
+
+ it("rejects with no iTwinId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata(undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected iTwinId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no realityDataId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected realityDataId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no default access token set", async () => {
+ ITwinPlatform.defaultAccessToken = undefined;
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithDeveloperError(
+ "Must set ITwinPlatform.defaultAccessToken first",
+ );
+ });
+
+ it("rejects for API 401 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 401,
+ JSON.stringify({
+ error: { message: "failed", details: [{ code: "InvalidToken" }] },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unauthorized/);
+ });
+
+ it("rejects for API 403 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 403,
+ JSON.stringify({
+ error: { message: "failed", code: "Forbidden" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /forbidden/);
+ });
+
+ it("rejects for API 404 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 404,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /not found/);
+ });
+
+ it("rejects for API 422 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 422,
+ JSON.stringify({
+ error: { message: "failed", code: "BadEntity" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Unprocessable/);
+ });
+
+ it("rejects for API 429 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 429,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataMetadata("itwin-id-1", "reality-data-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /Too many/);
+ });
+
+ it("uses the default access token for the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return { realityData: {} };
+ });
+ await ITwinPlatform.getRealityDataMetadata(
+ "itwin-id-1",
+ "reality-data-id-1",
+ );
+ expect(resource).toBeDefined();
+ expect(resource.headers["Authorization"]).toEqual(
+ "Bearer default-access-token",
+ );
+ });
+ });
+
+ describe("getRealityDataURL", () => {
+ let requestSpy;
+ beforeEach(() => {
+ requestSpy = spyOn(Resource.prototype, "fetchJson");
+ });
+
+ it("rejects with no iTwinId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected iTwinId to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no realityDataId", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL("itwin-id-1", undefined),
+ ).toBeRejectedWithDeveloperError(
+ "Expected realityDataId to be typeof string, actual typeof was undefined",
+ );
+ });
+ it("rejects with no rootDocument", async () => {
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ undefined,
+ ),
+ ).toBeRejectedWithDeveloperError(
+ "Expected rootDocument to be typeof string, actual typeof was undefined",
+ );
+ });
+
+ it("rejects with no default access token set", async () => {
+ ITwinPlatform.defaultAccessToken = undefined;
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithDeveloperError(
+ "Must set ITwinPlatform.defaultAccessToken first",
+ );
+ });
+
+ it("rejects for API 401 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 401,
+ JSON.stringify({
+ error: { message: "failed", details: [{ code: "InvalidToken" }] },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /Unauthorized/);
+ });
+
+ it("rejects for API 403 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 403,
+ JSON.stringify({
+ error: { message: "failed", code: "Forbidden" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /forbidden/);
+ });
+
+ it("rejects for API 404 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 404,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /not found/);
+ });
+
+ it("rejects for API 422 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 422,
+ JSON.stringify({
+ error: { message: "failed", code: "BadEntity" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /Unprocessable/);
+ });
+
+ it("rejects for API 429 errors", async () => {
+ requestSpy.and.rejectWith(
+ new RequestErrorEvent(
+ 429,
+ JSON.stringify({
+ error: { message: "" },
+ }),
+ ),
+ );
+ await expectAsync(
+ ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /Too many/);
+ });
+
+ it("uses the default access token for the API request", async () => {
+ let resource;
+ requestSpy.and.callFake(function () {
+ resource = this;
+ return {
+ _links: {
+ containerUrl: { href: "https://example.com/base/path?auth=token" },
+ },
+ };
+ });
+ await ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ expect(resource).toBeDefined();
+ expect(resource.headers["Authorization"]).toEqual(
+ "Bearer default-access-token",
+ );
+ });
+
+ it("combines the rootDocument with the access url", async () => {
+ requestSpy.and.resolveTo({
+ _links: {
+ containerUrl: { href: "https://example.com/base/path?auth=token" },
+ },
+ });
+ const tilesetUrl = await ITwinPlatform.getRealityDataURL(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ expect(tilesetUrl).toEqual(
+ "https://example.com/base/path/root/document/path.json?auth=token",
+ );
+ });
+ });
+});
diff --git a/packages/engine/Specs/Core/IonGeocoderServiceSpec.js b/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
index 17951c615c02..719a762daffc 100644
--- a/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
+++ b/packages/engine/Specs/Core/IonGeocoderServiceSpec.js
@@ -1,7 +1,9 @@
import {
+ DeveloperError,
GeocoderService,
GeocodeType,
Ion,
+ IonGeocodeProviderType,
IonGeocoderService,
} from "../../index.js";
@@ -26,20 +28,24 @@ describe("Core/IonGeocoderService", function () {
expect(service._accessToken).toEqual(Ion.defaultAccessToken);
expect(service._server.url).toEqual(Ion.defaultServer.url);
+ expect(service.geocodeProviderType).toEqual(IonGeocodeProviderType.DEFAULT);
});
it("creates with specified parameters", function () {
const accessToken = "123456";
const server = "http://not.ion.invalid/";
+ const geocodeProviderType = IonGeocodeProviderType.GOOGLE;
const service = new IonGeocoderService({
accessToken: accessToken,
server: server,
scene: scene,
+ geocodeProviderType,
});
expect(service._accessToken).toEqual(accessToken);
expect(service._server.url).toEqual(server);
+ expect(service.geocodeProviderType).toEqual(geocodeProviderType);
});
it("calls inner geocoder and returns result", async function () {
@@ -64,4 +70,47 @@ describe("Core/IonGeocoderService", function () {
expect(service.credit).toBeUndefined();
});
+
+ it("setting geocodeProviderType updates _pelias.url for GOOGLE", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.DEFAULT,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.GOOGLE;
+ expect(service._pelias.url.queryParameters["geocoder"]).toEqual("google");
+ });
+
+ it("setting geocodeProviderType updates _pelias.url for BING", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.DEFAULT,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.BING;
+ expect(service._pelias.url.queryParameters["geocoder"]).toEqual("bing");
+ });
+
+ it("setting geocodeProviderType updates _pelias.url for DEFAULT", function () {
+ const service = new IonGeocoderService({
+ scene,
+ geocoder: IonGeocodeProviderType.GOOGLE,
+ });
+
+ service.geocodeProviderType = IonGeocodeProviderType.DEFAULT;
+ const queryParameters = service._pelias.url.queryParameters;
+ expect(queryParameters.geocoder).toBeUndefined();
+ // Make sure that it isn't 'geocoder: undefined'
+ expect(queryParameters.hasOwnProperty("geocoder")).toBeFalse();
+ });
+
+ it("throws if setting invalid geocodeProviderType", function () {
+ expect(
+ () => new IonGeocoderService({ scene, geocodeProviderType: "junk" }),
+ ).toThrowError(DeveloperError, /Invalid geocodeProviderType/);
+ expect(() => {
+ const service = new IonGeocoderService({ scene });
+ service.geocodeProviderType = "junk";
+ }).toThrowError(DeveloperError, /Invalid geocodeProviderType/);
+ });
});
diff --git a/packages/engine/Specs/DataSources/EntitySpec.js b/packages/engine/Specs/DataSources/EntitySpec.js
index 4edfdbffc4da..33ce89a6d98e 100644
--- a/packages/engine/Specs/DataSources/EntitySpec.js
+++ b/packages/engine/Specs/DataSources/EntitySpec.js
@@ -4,6 +4,7 @@ import {
Matrix3,
Matrix4,
Quaternion,
+ TrackingReferenceFrame,
TimeInterval,
TimeIntervalCollection,
Transforms,
@@ -54,11 +55,15 @@ describe("DataSources/Entity", function () {
expect(entity.viewFrom).toBeUndefined();
expect(entity.wall).toBeUndefined();
expect(entity.entityCollection).toBeUndefined();
+ expect(entity.trackingReferenceFrame).toBe(
+ TrackingReferenceFrame.AUTODETECT,
+ );
const options = {
id: "someId",
name: "bob",
show: false,
+ trackingReferenceFrame: TrackingReferenceFrame.INERTIAL,
availability: new TimeIntervalCollection(),
parent: new Entity(),
customProperty: {},
@@ -88,6 +93,7 @@ describe("DataSources/Entity", function () {
expect(entity.id).toEqual(options.id);
expect(entity.name).toEqual(options.name);
expect(entity.show).toBe(options.show);
+ expect(entity.trackingReferenceFrame).toBe(options.trackingReferenceFrame);
expect(entity.availability).toBe(options.availability);
expect(entity.parent).toBe(options.parent);
expect(entity.customProperty).toBe(options.customProperty);
@@ -114,6 +120,7 @@ describe("DataSources/Entity", function () {
expect(entity.wall).toBeInstanceOf(WallGraphics);
expect(entity.entityCollection).toBeUndefined();
+ expect(entity.trackingReferenceFrame).toBe(TrackingReferenceFrame.INERTIAL);
});
it("isAvailable is always true if no availability defined.", function () {
diff --git a/packages/engine/Specs/DataSources/EntityViewSpec.js b/packages/engine/Specs/DataSources/EntityViewSpec.js
index 1406cf8207d3..61223cc1dd0b 100644
--- a/packages/engine/Specs/DataSources/EntityViewSpec.js
+++ b/packages/engine/Specs/DataSources/EntityViewSpec.js
@@ -6,6 +6,7 @@ import {
ConstantPositionProperty,
Entity,
EntityView,
+ TrackingReferenceFrame,
} from "../../index.js";
import createScene from "../../../../Specs/createScene.js";
@@ -74,6 +75,18 @@ describe(
const view = new EntityView(entity, scene);
view.update(JulianDate.now());
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.INERTIAL;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("uses entity bounding sphere", function () {
@@ -92,6 +105,27 @@ describe(
new BoundingSphere(new Cartesian3(3, 4, 5), 6),
);
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.INERTIAL;
+ view.update(
+ JulianDate.now(),
+ new BoundingSphere(new Cartesian3(3, 4, 5), 6),
+ );
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
+ view.update(
+ JulianDate.now(),
+ new BoundingSphere(new Cartesian3(3, 4, 5), 6),
+ );
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(
+ JulianDate.now(),
+ new BoundingSphere(new Cartesian3(3, 4, 5), 6),
+ );
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("uses entity viewFrom if available and boundingsphere is supplied", function () {
@@ -109,6 +143,18 @@ describe(
);
view.update(JulianDate.now());
expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.INERTIAL;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.VELOCITY;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
+
+ entity.trackingReferenceFrame = TrackingReferenceFrame.ENU;
+ view.update(JulianDate.now());
+ expect(view.scene.camera.position).toEqualEpsilon(sampleOffset, 1e-10);
});
it("update throws without time parameter", function () {
diff --git a/packages/engine/Specs/DataSources/SampledPropertySpec.js b/packages/engine/Specs/DataSources/SampledPropertySpec.js
index 3caa5d99fe6c..e6ee6edc9335 100644
--- a/packages/engine/Specs/DataSources/SampledPropertySpec.js
+++ b/packages/engine/Specs/DataSources/SampledPropertySpec.js
@@ -110,6 +110,28 @@ describe("DataSources/SampledProperty", function () {
expect(property.getValue(new JulianDate(0.5, 0))).toEqual(7.5);
});
+ it("getSample works", function () {
+ const times = [
+ new JulianDate(0, 0),
+ new JulianDate(1, 0),
+ new JulianDate(2, 0),
+ ];
+ const values = [7, 8, 9];
+
+ const property = new SampledProperty(Number);
+ property.addSamples(times, values);
+
+ expect(property.getSample(0)).toEqual(times[0]);
+ expect(property.getSample(1)).toEqual(times[1]);
+ expect(property.getSample(2)).toEqual(times[2]);
+ expect(property.getSample(3)).toBe(undefined);
+
+ expect(property.getSample(-1)).toBe(times[2]);
+ expect(property.getSample(-2)).toBe(times[1]);
+ expect(property.getSample(-3)).toBe(times[0]);
+ expect(property.getSample(-4)).toBe(undefined);
+ });
+
it("can remove a sample at a date", function () {
const times = [
new JulianDate(0, 0),
diff --git a/packages/engine/Specs/Renderer/TextureSpec.js b/packages/engine/Specs/Renderer/TextureSpec.js
index 609a6a95da47..b9cd1b386199 100644
--- a/packages/engine/Specs/Renderer/TextureSpec.js
+++ b/packages/engine/Specs/Renderer/TextureSpec.js
@@ -16,1075 +16,1203 @@ import {
} from "../../index.js";
import createContext from "../../../../Specs/createContext.js";
+import createWebglVersionHelper from "../createWebglVersionHelper.js";
describe(
"Renderer/Texture",
function () {
- let context;
- let greenImage;
- let blueImage;
- let blueAlphaImage;
- let blueOverRedImage;
- let blueOverRedFlippedImage;
- let red16x16Image;
-
- let greenKTX2Image;
- let greenBasisKTX2Image;
-
- const fs =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = texture(u_texture, vec2(0.0)); }";
- const fsLuminanceAlpha =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = vec4(texture(u_texture, vec2(0.0)).ra, 0.0, 1.0); }";
- let texture;
- const uniformMap = {
- u_texture: function () {
- return texture;
- },
- };
-
- beforeAll(function () {
- context = createContext();
- const promises = [];
- promises.push(
- Resource.fetchImage("./Data/Images/Green.png").then(function (image) {
- greenImage = image;
- }),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/Blue.png").then(function (image) {
- blueImage = image;
- }),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/BlueAlpha.png").then(
- function (image) {
- blueAlphaImage = image;
- },
- ),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/BlueOverRed.png").then(
- function (image) {
- blueOverRedImage = image;
- },
- ),
- );
- // Load this image as an ImageBitmap
- promises.push(
- Resource.fetchImage({
- url: "./Data/Images/BlueOverRed.png",
- preferImageBitmap: true,
- }).then(function (image) {
- blueOverRedFlippedImage = image;
- }),
- );
- promises.push(
- Resource.fetchImage("./Data/Images/Red16x16.png").then(
- function (image) {
- red16x16Image = image;
- },
- ),
- );
-
- const resource = Resource.createIfNeeded("./Data/Images/Green4x4.ktx2");
- const loadPromise = resource.fetchArrayBuffer();
- promises.push(
- loadPromise.then(function (buffer) {
- const promise = KTX2Transcoder.transcode(buffer, {});
- return promise.then(function (result) {
- greenKTX2Image = result;
- });
- }),
- );
+ createWebglVersionHelper(createTextureSpecs);
+
+ function createTextureSpecs(contextOptions) {
+ let context;
+ let greenImage;
+ let blueImage;
+ let blueAlphaImage;
+ let blueOverRedImage;
+ let blueOverRedFlippedImage;
+ let red16x16Image;
+
+ let greenKTX2Image;
+ let greenBasisKTX2Image;
+
+ const fs =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = texture(u_texture, vec2(0.0)); }";
+ const fsLuminanceAlpha =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = vec4(texture(u_texture, vec2(0.0)).ra, 0.0, 1.0); }";
+ let texture;
+ const uniformMap = {
+ u_texture: function () {
+ return texture;
+ },
+ };
- if (context.supportsBasis) {
+ beforeAll(function () {
+ context = createContext(contextOptions);
+ const promises = [];
promises.push(
- loadKTX2("./Data/Images/Green4x4_ETC1S.ktx2").then(function (image) {
- greenBasisKTX2Image = image;
+ Resource.fetchImage("./Data/Images/Green.png").then(function (image) {
+ greenImage = image;
}),
);
- }
-
- return Promise.all(promises);
- });
-
- afterAll(function () {
- context.destroyForSpecs();
- });
-
- let blueImageHeight, blueImageWidth;
- beforeEach(function () {
- blueImageHeight = blueImage.height;
- blueImageWidth = blueImage.width;
- });
-
- afterEach(function () {
- blueImage.height = blueImageHeight;
- blueImage.width = blueImageWidth;
- texture = texture && texture.destroy();
- });
-
- it("has expected default values for pixel format and datatype", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(texture.id).toBeDefined();
- expect(texture.pixelFormat).toEqual(PixelFormat.RGBA);
- expect(texture.pixelDatatype).toEqual(PixelDatatype.UNSIGNED_BYTE);
- });
-
- it("can create a texture from the framebuffer", function () {
- const command = new ClearCommand({
- color: Color.RED,
- });
- command.execute(context);
-
- texture = Texture.fromFramebuffer({
- context: context,
- });
-
- const expectedWidth = context.canvas.clientWidth;
- const expectedHeight = context.canvas.clientHeight;
- expect(texture.width).toEqual(expectedWidth);
- expect(texture.height).toEqual(expectedHeight);
- expect(texture.sizeInBytes).toEqual(
- expectedWidth *
- expectedHeight *
- PixelFormat.componentsLength(texture.pixelFormat),
- );
-
- command.color = Color.WHITE;
- command.execute(context);
- expect(context).toReadPixels([255, 255, 255, 255]);
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("can copy from the framebuffer", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGB,
- });
-
- // Render blue
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([0, 0, 255, 255]);
-
- // Clear to red
- const command = new ClearCommand({
- color: Color.RED,
- });
- command.execute(context);
- expect(context).toReadPixels(Color.RED.toBytes());
-
- texture.copyFromFramebuffer();
-
- const expectedWidth = context.canvas.clientWidth;
- const expectedHeight = context.canvas.clientHeight;
- expect(texture.width).toEqual(expectedWidth);
- expect(texture.height).toEqual(expectedHeight);
- expect(texture.sizeInBytes).toEqual(
- expectedWidth *
- expectedHeight *
- PixelFormat.componentsLength(texture.pixelFormat),
- );
-
- // Clear to white
- command.color = Color.WHITE;
- command.execute(context);
- expect(context).toReadPixels(Color.WHITE.toBytes());
-
- // Render red
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("draws the expected texture color", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([0, 0, 255, 255]);
- });
-
- it("cannot flip texture when using ImageBitmap", function () {
- const topColor = new Color(0.0, 0.0, 1.0, 1.0);
- let bottomColor = new Color(1.0, 0.0, 0.0, 1.0);
-
- return Resource.supportsImageBitmapOptions().then(
- function (supportsImageBitmapOptions) {
- if (supportsImageBitmapOptions) {
- // When imageBitmapOptions is supported, flipY on texture upload is ignored.
- bottomColor = topColor;
- }
-
- texture = new Texture({
- context: context,
- source: blueOverRedFlippedImage,
- pixelFormat: PixelFormat.RGBA,
- flipY: false,
- });
+ promises.push(
+ Resource.fetchImage("./Data/Images/Blue.png").then(function (image) {
+ blueImage = image;
+ }),
+ );
+ promises.push(
+ Resource.fetchImage("./Data/Images/BlueAlpha.png").then(
+ function (image) {
+ blueAlphaImage = image;
+ },
+ ),
+ );
+ promises.push(
+ Resource.fetchImage("./Data/Images/BlueOverRed.png").then(
+ function (image) {
+ blueOverRedImage = image;
+ },
+ ),
+ );
+ // Load this image as an ImageBitmap
+ promises.push(
+ Resource.fetchImage({
+ url: "./Data/Images/BlueOverRed.png",
+ preferImageBitmap: true,
+ }).then(function (image) {
+ blueOverRedFlippedImage = image;
+ }),
+ );
+ promises.push(
+ Resource.fetchImage("./Data/Images/Red16x16.png").then(
+ function (image) {
+ red16x16Image = image;
+ },
+ ),
+ );
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(topColor.toBytes());
+ const resource = Resource.createIfNeeded("./Data/Images/Green4x4.ktx2");
+ const loadPromise = resource.fetchArrayBuffer();
+ promises.push(
+ loadPromise.then(function (buffer) {
+ const promise = KTX2Transcoder.transcode(buffer, {});
+ return promise.then(function (result) {
+ greenKTX2Image = result;
+ });
+ }),
+ );
- // Flip the texture.
- texture = new Texture({
- context: context,
- source: blueOverRedFlippedImage,
- pixelFormat: PixelFormat.RGBA,
- flipY: true,
- });
+ if (context.supportsBasis) {
+ promises.push(
+ loadKTX2("./Data/Images/Green4x4_ETC1S.ktx2").then(
+ function (image) {
+ greenBasisKTX2Image = image;
+ },
+ ),
+ );
+ }
+
+ return Promise.all(promises);
+ });
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(bottomColor.toBytes());
- },
- );
- });
+ afterAll(function () {
+ context.destroyForSpecs();
+ });
- it("draws the expected floating-point texture color", function () {
- if (!context.floatingPointTexture) {
- return;
- }
+ let blueImageHeight, blueImageWidth;
+ beforeEach(function () {
+ blueImageHeight = blueImage.height;
+ blueImageWidth = blueImage.width;
+ });
- const color = new Color(0.2, 0.4, 0.6, 1.0);
- const floats = new Float32Array([
- color.red,
- color.green,
- color.blue,
- color.alpha,
- ]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.FLOAT,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: floats,
- },
+ afterEach(function () {
+ blueImage.height = blueImageHeight;
+ blueImage.width = blueImageWidth;
+ texture = texture && texture.destroy();
});
- expect(texture.sizeInBytes).toEqual(16);
+ it("has expected default values for pixel format and datatype", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ });
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ expect(texture.id).toBeDefined();
+ expect(texture.pixelFormat).toEqual(PixelFormat.RGBA);
+ expect(texture.pixelDatatype).toEqual(PixelDatatype.UNSIGNED_BYTE);
+ });
- it("draws the expected floating-point texture color with linear filtering", function () {
- if (!context.floatingPointTexture) {
- return;
- }
+ it("can create a texture from the framebuffer", function () {
+ const command = new ClearCommand({
+ color: Color.RED,
+ });
+ command.execute(context);
- const color0 = new Color(0.2, 0.4, 0.6, 1.0);
- const color1 = new Color(0.1, 0.3, 0.5, 1.0);
- const floats = new Float32Array([
- color0.red,
- color0.green,
- color0.blue,
- color0.alpha,
- color1.red,
- color1.green,
- color1.blue,
- color1.alpha,
- ]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.FLOAT,
- source: {
- width: 2,
- height: 1,
- arrayBufferView: floats,
- },
- sampler: new Sampler({
- wrapS: TextureWrap.CLAMP_TO_EDGE,
- wrapT: TextureWrap.CLAMP_TO_EDGE,
- minificationFilter: TextureMinificationFilter.LINEAR,
- magnificationFilter: TextureMagnificationFilter.LINEAR,
- }),
- });
+ texture = Texture.fromFramebuffer({
+ context: context,
+ });
- expect(texture.sizeInBytes).toEqual(32);
+ const expectedWidth = context.canvas.clientWidth;
+ const expectedHeight = context.canvas.clientHeight;
+ expect(texture.width).toEqual(expectedWidth);
+ expect(texture.height).toEqual(expectedHeight);
+ expect(texture.sizeInBytes).toEqual(
+ expectedWidth *
+ expectedHeight *
+ PixelFormat.componentsLength(texture.pixelFormat),
+ );
- const fs =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
+ command.color = Color.WHITE;
+ command.execute(context);
+ expect(context).toReadPixels([255, 255, 255, 255]);
- if (!context.textureFloatLinear) {
expect({
context: context,
fragmentShader: fs,
uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender(color1.toBytes());
- } else {
- Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
- Color.multiplyByScalar(color1, 0.5, color1);
- Color.add(color0, color1, color1);
+ }).contextToRender([255, 0, 0, 255]);
+ });
+
+ it("can copy from the framebuffer", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGB,
+ });
+
+ // Render blue
expect({
context: context,
fragmentShader: fs,
uniformMap: uniformMap,
- }).contextToRender(color1.toBytes());
- }
- });
+ }).contextToRender([0, 0, 255, 255]);
- it("draws the expected half floating-point texture color", function () {
- if (!context.halfFloatingPointTexture) {
- return;
- }
+ // Clear to red
+ const command = new ClearCommand({
+ color: Color.RED,
+ });
+ command.execute(context);
+ expect(context).toReadPixels(Color.RED.toBytes());
+
+ texture.copyFromFramebuffer();
+
+ const expectedWidth = context.canvas.clientWidth;
+ const expectedHeight = context.canvas.clientHeight;
+ expect(texture.width).toEqual(expectedWidth);
+ expect(texture.height).toEqual(expectedHeight);
+ expect(texture.sizeInBytes).toEqual(
+ expectedWidth *
+ expectedHeight *
+ PixelFormat.componentsLength(texture.pixelFormat),
+ );
- const color = new Color(0.2, 0.4, 0.6, 1.0);
- const floats = new Uint16Array([12902, 13926, 14541, 15360]);
+ // Clear to white
+ command.color = Color.WHITE;
+ command.execute(context);
+ expect(context).toReadPixels(Color.WHITE.toBytes());
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.HALF_FLOAT,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: floats,
- },
- flipY: false,
+ // Render red
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([255, 0, 0, 255]);
});
- expect(texture.sizeInBytes).toEqual(8);
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ it("draws the expected texture color", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
- it("draws the expected half floating-point texture color with linear filtering", function () {
- if (!context.halfFloatingPointTexture) {
- return;
- }
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([0, 0, 255, 255]);
+ });
- const color0 = new Color(0.2, 0.4, 0.6, 1.0);
- const color1 = new Color(0.1, 0.3, 0.5, 1.0);
- const floats = new Uint16Array([
- 12902, 13926, 14541, 15360, 11878, 13517, 14336, 15360,
- ]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.HALF_FLOAT,
- source: {
- width: 2,
- height: 1,
- arrayBufferView: floats,
- },
- flipY: false,
+ it("cannot flip texture when using ImageBitmap", function () {
+ const topColor = new Color(0.0, 0.0, 1.0, 1.0);
+ let bottomColor = new Color(1.0, 0.0, 0.0, 1.0);
+
+ return Resource.supportsImageBitmapOptions().then(
+ function (supportsImageBitmapOptions) {
+ if (supportsImageBitmapOptions) {
+ // When imageBitmapOptions is supported, flipY on texture upload is ignored.
+ bottomColor = topColor;
+ }
+
+ texture = new Texture({
+ context: context,
+ source: blueOverRedFlippedImage,
+ pixelFormat: PixelFormat.RGBA,
+ flipY: false,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(topColor.toBytes());
+
+ // Flip the texture.
+ texture = new Texture({
+ context: context,
+ source: blueOverRedFlippedImage,
+ pixelFormat: PixelFormat.RGBA,
+ flipY: true,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(bottomColor.toBytes());
+ },
+ );
});
- expect(texture.sizeInBytes).toEqual(16);
+ it("draws the expected floating-point texture color", function () {
+ if (!context.floatingPointTexture) {
+ return;
+ }
- const fs =
- "uniform sampler2D u_texture;" +
- "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
+ const color = new Color(0.2, 0.4, 0.6, 1.0);
+ const floats = new Float32Array([
+ color.red,
+ color.green,
+ color.blue,
+ color.alpha,
+ ]);
- if (!context.textureHalfFloatLinear) {
- expect({
+ texture = new Texture({
context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender(color1.toBytes());
- } else {
- Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
- Color.multiplyByScalar(color1, 0.5, color1);
- Color.add(color0, color1, color1);
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.FLOAT,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ });
+
+ expect(texture.sizeInBytes).toEqual(16);
+
expect({
context: context,
fragmentShader: fs,
uniformMap: uniformMap,
- }).contextToRender(color1.toBytes());
- }
- });
+ }).contextToRender(color.toBytes());
+ });
- it("draws the expected Basis compressed texture color", function () {
- if (!context.supportsBasis) {
- return;
- }
+ it("draws the expected floating-point texture color with linear filtering", function () {
+ if (!context.floatingPointTexture) {
+ return;
+ }
+
+ const color0 = new Color(0.2, 0.4, 0.6, 1.0);
+ const color1 = new Color(0.1, 0.3, 0.5, 1.0);
+ const floats = new Float32Array([
+ color0.red,
+ color0.green,
+ color0.blue,
+ color0.alpha,
+ color1.red,
+ color1.green,
+ color1.blue,
+ color1.alpha,
+ ]);
- texture = new Texture({
- context: context,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
- });
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.FLOAT,
+ source: {
+ width: 2,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ sampler: new Sampler({
+ wrapS: TextureWrap.CLAMP_TO_EDGE,
+ wrapT: TextureWrap.CLAMP_TO_EDGE,
+ minificationFilter: TextureMinificationFilter.LINEAR,
+ magnificationFilter: TextureMagnificationFilter.LINEAR,
+ }),
+ });
- expect(texture.sizeInBytes).toBe(8);
+ expect(texture.sizeInBytes).toEqual(32);
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRenderAndCall(function (color) {
- return expect(color).toEqualEpsilon([2, 255, 2, 255], 2);
- });
- });
+ const fs =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
- it("draws the expected KTX2 uncompressed texture color", function () {
- texture = new Texture({
- context: context,
- pixelFormat: greenKTX2Image.internalFormat,
- source: {
- width: greenKTX2Image.width,
- height: greenKTX2Image.height,
- arrayBufferView: greenKTX2Image.bufferView,
- },
+ if (!context.textureFloatLinear) {
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender(color1.toBytes());
+ } else {
+ Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
+ Color.multiplyByScalar(color1, 0.5, color1);
+ Color.add(color0, color1, color1);
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color1.toBytes());
+ }
});
- expect(texture.sizeInBytes).toBe(48);
+ it("draws the expected half floating-point texture color", function () {
+ if (!context.halfFloatingPointTexture) {
+ return;
+ }
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRenderAndCall(function (color) {
- return expect(color).toEqualEpsilon([0, 255, 24, 255], 2);
- });
- });
+ const color = new Color(0.2, 0.4, 0.6, 1.0);
+ const floats = new Uint16Array([12902, 13926, 14541, 15360]);
- it("renders with premultiplied alpha", function () {
- const cxt = createContext({
- webgl: {
- alpha: true,
- },
- });
- const texture = new Texture({
- context: cxt,
- source: blueAlphaImage,
- pixelFormat: PixelFormat.RGBA,
- preMultiplyAlpha: true,
- });
- const uniformMap = {
- u_texture: function () {
- return texture;
- },
- };
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.HALF_FLOAT,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ flipY: false,
+ });
- expect(texture.preMultiplyAlpha).toEqual(true);
- expect({
- context: cxt,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender([0, 0, 127, 127]);
-
- texture.destroy();
- cxt.destroyForSpecs();
- });
-
- it("draws textured blue and red points", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- let fragmentShaderSource = "";
- fragmentShaderSource += "uniform sampler2D u_texture;";
- fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
- fragmentShaderSource +=
- "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
-
- let txCoords;
- const um = {
- u_texture: function () {
- return texture;
- },
- u_txCoords: function () {
- return txCoords;
- },
- };
+ expect(texture.sizeInBytes).toEqual(8);
- // Blue on top
- txCoords = new Cartesian2(0.5, 0.75);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([0, 0, 255, 255]);
-
- // Red on bottom
- txCoords = new Cartesian2(0.5, 0.25);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("draws the expected luminance texture color", function () {
- const color = new Color(0.6, 0.6, 0.6, 1.0);
- const arrayBufferView = new Uint8Array([153]);
-
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.LUMINANCE,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: arrayBufferView,
- },
- flipY: false,
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color.toBytes());
});
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ it("draws the expected half floating-point texture color with linear filtering", function () {
+ if (!context.halfFloatingPointTexture) {
+ return;
+ }
- it("draws the expected luminance alpha texture color", function () {
- const color = new Color(0.6, 0.8, 0.0, 1.0);
- const arrayBufferView = new Uint8Array([153, 204]);
+ const color0 = new Color(0.2, 0.4, 0.6, 1.0);
+ const color1 = new Color(0.1, 0.3, 0.5, 1.0);
+ const floats = new Uint16Array([
+ 12902, 13926, 14541, 15360, 11878, 13517, 14336, 15360,
+ ]);
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.LUMINANCE_ALPHA,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: arrayBufferView,
- },
- flipY: false,
- });
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.HALF_FLOAT,
+ source: {
+ width: 2,
+ height: 1,
+ arrayBufferView: floats,
+ },
+ flipY: false,
+ });
- expect({
- context: context,
- fragmentShader: fsLuminanceAlpha,
- uniformMap: uniformMap,
- }).contextToRender(color.toBytes());
- });
+ expect(texture.sizeInBytes).toEqual(16);
- it("can be created from a typed array", function () {
- const bytes = new Uint8Array([0, 255, 0, 255]);
+ const fs =
+ "uniform sampler2D u_texture;" +
+ "void main() { out_FragColor = texture(u_texture, vec2(0.5, 0.0)); }";
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: {
- width: 1,
- height: 1,
- arrayBufferView: bytes,
- },
+ if (!context.textureHalfFloatLinear) {
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender(color1.toBytes());
+ } else {
+ Color.multiplyByScalar(color0, 1.0 - 0.5, color0);
+ Color.multiplyByScalar(color1, 0.5, color1);
+ Color.add(color0, color1, color1);
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color1.toBytes());
+ }
});
- expect(texture.width).toEqual(1);
- expect(texture.height).toEqual(1);
- expect(texture.sizeInBytes).toEqual(4);
+ it("draws the expected Basis compressed texture color", function () {
+ if (!context.supportsBasis) {
+ return;
+ }
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([0, 255, 0, 255]);
- });
+ texture = new Texture({
+ context: context,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
- it("can copy from a typed array", function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- width: 1,
- height: 1,
- });
+ expect(texture.sizeInBytes).toBe(8);
- const bytes = new Uint8Array(Color.NAVY.toBytes());
- texture.copyFrom({
- source: {
- width: 1,
- height: 1,
- arrayBufferView: bytes,
- },
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRenderAndCall(function (color) {
+ return expect(color).toEqualEpsilon([2, 255, 2, 255], 2);
+ });
});
- expect(texture.width).toEqual(1);
- expect(texture.height).toEqual(1);
- expect(texture.sizeInBytes).toEqual(4);
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender(Color.NAVY.toBytes());
- });
+ it("draws the expected KTX2 uncompressed texture color", function () {
+ texture = new Texture({
+ context: context,
+ pixelFormat: greenKTX2Image.internalFormat,
+ source: {
+ width: greenKTX2Image.width,
+ height: greenKTX2Image.height,
+ arrayBufferView: greenKTX2Image.bufferView,
+ },
+ });
- it("can copy from a DOM element", function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGB,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- width: blueImage.width,
- height: blueImage.height,
- });
+ expect(texture.sizeInBytes).toBe(48);
- texture.copyFrom({
- source: blueImage,
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRenderAndCall(function (color) {
+ return expect(color).toEqualEpsilon([0, 255, 24, 255], 2);
+ });
});
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender([0, 0, 255, 255]);
- });
+ it("renders with premultiplied alpha", function () {
+ const alphaContextOptions = Object.assign(
+ {
+ webgl: {
+ alpha: true,
+ },
+ },
+ contextOptions,
+ );
+ const alphaContext = createContext(alphaContextOptions);
+ const texture = new Texture({
+ context: alphaContext,
+ source: blueAlphaImage,
+ pixelFormat: PixelFormat.RGBA,
+ preMultiplyAlpha: true,
+ });
+ const uniformMap = {
+ u_texture: function () {
+ return texture;
+ },
+ };
- it("can copy from a DOM element when display dimensions are 0", function () {
- blueImage.height = 0;
- blueImage.width = 0;
+ expect(texture.preMultiplyAlpha).toEqual(true);
+ expect({
+ context: alphaContext,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender([0, 0, 127, 127]);
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.RGB,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- source: blueImage,
+ texture.destroy();
+ alphaContext.destroyForSpecs();
});
- texture.copyFrom({
- source: blueImage,
- });
+ it("draws textured blue and red points", function () {
+ texture = new Texture({
+ context: context,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- epsilon: 1,
- }).contextToRender([0, 0, 255, 255]);
- });
+ let fragmentShaderSource = "";
+ fragmentShaderSource += "uniform sampler2D u_texture;";
+ fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
+ fragmentShaderSource +=
+ "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
- it("can replace a subset of a texture", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- });
+ let txCoords;
+ const um = {
+ u_texture: function () {
+ return texture;
+ },
+ u_txCoords: function () {
+ return txCoords;
+ },
+ };
- let fragmentShaderSource = "";
- fragmentShaderSource += "uniform sampler2D u_texture;";
- fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
- fragmentShaderSource +=
- "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
+ // Blue on top
+ txCoords = new Cartesian2(0.5, 0.75);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([0, 0, 255, 255]);
- let txCoords;
- const um = {
- u_texture: function () {
- return texture;
- },
- u_txCoords: function () {
- return txCoords;
- },
- };
+ // Red on bottom
+ txCoords = new Cartesian2(0.5, 0.25);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([255, 0, 0, 255]);
+ });
- // Blue on top
- txCoords = new Cartesian2(0.5, 0.75);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([0, 0, 255, 255]);
-
- // Red on bottom
- txCoords = new Cartesian2(0.5, 0.25);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([255, 0, 0, 255]);
-
- // After copy...
- texture.copyFrom({
- source: greenImage,
- xOffset: 0,
- yOffset: 1,
- });
-
- // Now green on top
- txCoords = new Cartesian2(0.5, 0.75);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender(Color.LIME.toBytes());
-
- // Still red on bottom
- txCoords = new Cartesian2(0.5, 0.25);
- expect({
- context: context,
- fragmentShader: fragmentShaderSource,
- uniformMap: um,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("can generate mipmaps", function () {
- texture = new Texture({
- context: context,
- source: red16x16Image,
- pixelFormat: PixelFormat.RGBA,
- sampler: new Sampler({
- minificationFilter: TextureMinificationFilter.NEAREST_MIPMAP_LINEAR,
- }),
- });
- texture.generateMipmap();
- expect(texture.sizeInBytes).toEqualEpsilon(
- (16 * 16 + 8 * 8 + 4 * 4 + 2 * 2 + 1) * 4,
- 1,
- );
-
- expect({
- context: context,
- fragmentShader: fs,
- uniformMap: uniformMap,
- }).contextToRender([255, 0, 0, 255]);
- });
-
- it("can set a sampler property", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- const sampler = new Sampler({
- wrapS: TextureWrap.REPEAT,
- wrapT: TextureWrap.MIRRORED_REPEAT,
- minificationFilter: TextureMinificationFilter.NEAREST,
- magnificationFilter: TextureMagnificationFilter.NEAREST,
- maximumAnisotropy: 2.0,
- });
- texture.sampler = sampler;
-
- const s = texture.sampler;
- expect(s.wrapS).toEqual(sampler.wrapS);
- expect(s.wrapT).toEqual(sampler.wrapT);
- expect(s.minificationFilter).toEqual(sampler.minificationFilter);
- expect(s.magnificationFilter).toEqual(sampler.magnificationFilter);
- expect(s.maximumAnisotropy).toEqual(2.0);
- });
-
- it("can set sampler at construction", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- sampler: new Sampler({
- wrapS: TextureWrap.REPEAT,
- wrapT: TextureWrap.MIRRORED_REPEAT,
- minificationFilter: TextureMinificationFilter.NEAREST,
- magnificationFilter: TextureMagnificationFilter.NEAREST,
- maximumAnisotropy: 2.0,
- }),
- });
-
- const s = texture.sampler;
- expect(s.wrapS).toEqual(TextureWrap.REPEAT);
- expect(s.wrapT).toEqual(TextureWrap.MIRRORED_REPEAT);
- expect(s.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
- expect(s.magnificationFilter).toEqual(TextureMagnificationFilter.NEAREST);
- expect(s.maximumAnisotropy).toEqual(2.0);
- });
-
- it("can get width and height", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- expect(texture.width).toEqual(1);
- expect(texture.height).toEqual(2);
- });
-
- it("can get whether Y is flipped", function () {
- texture = new Texture({
- context: context,
- source: blueOverRedImage,
- pixelFormat: PixelFormat.RGBA,
- flipY: true,
- });
-
- expect(texture.flipY).toEqual(true);
- });
-
- it("can get the dimensions of a texture", function () {
- texture = new Texture({
- context: context,
- width: 64,
- height: 16,
- });
-
- expect(texture.dimensions).toEqual(new Cartesian2(64, 16));
- });
-
- function expectTextureByteSize(
- width,
- height,
- pixelFormat,
- pixelDatatype,
- expectedSize,
- ) {
- texture = new Texture({
- context: context,
- width: width,
- height: height,
- pixelFormat: pixelFormat,
- pixelDatatype: pixelDatatype,
- });
- expect(texture.sizeInBytes).toBe(expectedSize);
- texture = texture && texture.destroy();
- }
+ it("draws the expected luminance texture color", function () {
+ const color = new Color(0.6, 0.6, 0.6, 1.0);
+ const arrayBufferView = new Uint8Array([153]);
- it("can get the size in bytes of a texture", function () {
- // Depth textures
- if (context.depthTexture) {
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.DEPTH_COMPONENT,
- PixelDatatype.UNSIGNED_SHORT,
- 256 * 2,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.DEPTH_COMPONENT,
- PixelDatatype.UNSIGNED_INT,
- 256 * 4,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.DEPTH_STENCIL,
- PixelDatatype.UNSIGNED_INT_24_8,
- 256 * 4,
- );
- }
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.LUMINANCE,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: arrayBufferView,
+ },
+ flipY: false,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(color.toBytes());
+ });
+
+ it("draws the expected luminance alpha texture color", function () {
+ const color = new Color(0.6, 0.8, 0.0, 1.0);
+ const arrayBufferView = new Uint8Array([153, 204]);
- // Uncompressed formats
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.ALPHA,
- PixelDatatype.UNSIGNED_BYTE,
- 256,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.RGB,
- PixelDatatype.UNSIGNED_BYTE,
- 256 * 3,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.RGBA,
- PixelDatatype.UNSIGNED_BYTE,
- 256 * 4,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.LUMINANCE,
- PixelDatatype.UNSIGNED_BYTE,
- 256,
- );
- expectTextureByteSize(
- 16,
- 16,
- PixelFormat.LUMINANCE_ALPHA,
- PixelDatatype.UNSIGNED_BYTE,
- 256 * 2,
- );
- });
-
- it("can be destroyed", function () {
- const t = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
- });
-
- expect(t.isDestroyed()).toEqual(false);
- t.destroy();
- expect(t.isDestroyed()).toEqual(true);
- });
-
- it("throws when creating a texture without a options", function () {
- expect(function () {
- texture = new Texture();
- }).toThrowDeveloperError();
- });
-
- it("throws when creating a texture without a source", function () {
- expect(function () {
texture = new Texture({
context: context,
+ pixelFormat: PixelFormat.LUMINANCE_ALPHA,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: arrayBufferView,
+ },
+ flipY: false,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with width and no height", function () {
- expect(function () {
+ expect({
+ context: context,
+ fragmentShader: fsLuminanceAlpha,
+ uniformMap: uniformMap,
+ }).contextToRender(color.toBytes());
+ });
+
+ it("can be created from a typed array", function () {
+ const bytes = new Uint8Array([0, 255, 0, 255]);
+
texture = new Texture({
context: context,
- width: 16,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: bytes,
+ },
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with height and no width", function () {
- expect(function () {
+ expect(texture.width).toEqual(1);
+ expect(texture.height).toEqual(1);
+ expect(texture.sizeInBytes).toEqual(4);
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([0, 255, 0, 255]);
+ });
+
+ it("can copy from a typed array", function () {
texture = new Texture({
context: context,
- height: 16,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ width: 1,
+ height: 1,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with zero width", function () {
- expect(function () {
+ const bytes = new Uint8Array(Color.NAVY.toBytes());
+ texture.copyFrom({
+ source: {
+ width: 1,
+ height: 1,
+ arrayBufferView: bytes,
+ },
+ });
+
+ expect(texture.width).toEqual(1);
+ expect(texture.height).toEqual(1);
+ expect(texture.sizeInBytes).toEqual(4);
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender(Color.NAVY.toBytes());
+ });
+
+ it("can copy from a DOM element", function () {
texture = new Texture({
context: context,
- width: 0,
- height: 16,
+ pixelFormat: PixelFormat.RGB,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ width: blueImage.width,
+ height: blueImage.height,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with width larger than the maximum texture size", function () {
- expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender([0, 0, 255, 255]);
+ });
+
+ it("can copy from a DOM element when display dimensions are 0", function () {
+ blueImage.height = 0;
+ blueImage.width = 0;
+
texture = new Texture({
context: context,
- width: ContextLimits.maximumTextureSize + 1,
- height: 16,
+ pixelFormat: PixelFormat.RGB,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ source: blueImage,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with zero height", function () {
- expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ });
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ epsilon: 1,
+ }).contextToRender([0, 0, 255, 255]);
+ });
+
+ it("can replace a subset of a texture", function () {
texture = new Texture({
context: context,
- width: 16,
- height: 0,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating a texture with height larger than the maximum texture size", function () {
- expect(function () {
+ let fragmentShaderSource = "";
+ fragmentShaderSource += "uniform sampler2D u_texture;";
+ fragmentShaderSource += "uniform mediump vec2 u_txCoords;";
+ fragmentShaderSource +=
+ "void main() { out_FragColor = texture(u_texture, u_txCoords); }";
+
+ let txCoords;
+ const um = {
+ u_texture: function () {
+ return texture;
+ },
+ u_txCoords: function () {
+ return txCoords;
+ },
+ };
+
+ // Blue on top
+ txCoords = new Cartesian2(0.5, 0.75);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([0, 0, 255, 255]);
+
+ // Red on bottom
+ txCoords = new Cartesian2(0.5, 0.25);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([255, 0, 0, 255]);
+
+ // After copy...
+ texture.copyFrom({
+ source: greenImage,
+ xOffset: 0,
+ yOffset: 1,
+ });
+
+ // Now green on top
+ txCoords = new Cartesian2(0.5, 0.75);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender(Color.LIME.toBytes());
+
+ // Still red on bottom
+ txCoords = new Cartesian2(0.5, 0.25);
+ expect({
+ context: context,
+ fragmentShader: fragmentShaderSource,
+ uniformMap: um,
+ }).contextToRender([255, 0, 0, 255]);
+ });
+
+ it("can generate mipmaps", function () {
texture = new Texture({
context: context,
- width: 16,
- height: ContextLimits.maximumTextureSize + 1,
+ source: red16x16Image,
+ pixelFormat: PixelFormat.RGBA,
+ sampler: new Sampler({
+ minificationFilter: TextureMinificationFilter.NEAREST_MIPMAP_LINEAR,
+ }),
});
- }).toThrowDeveloperError();
- });
+ texture.generateMipmap();
+ expect(texture.sizeInBytes).toEqualEpsilon(
+ (16 * 16 + 8 * 8 + 4 * 4 + 2 * 2 + 1) * 4,
+ 1,
+ );
+
+ expect({
+ context: context,
+ fragmentShader: fs,
+ uniformMap: uniformMap,
+ }).contextToRender([255, 0, 0, 255]);
+ });
- it("throws when creating a texture with an invalid pixel format", function () {
- expect(function () {
+ it("can set a sampler property", function () {
texture = new Texture({
context: context,
source: blueImage,
- pixelFormat: "invalid PixelFormat",
+ pixelFormat: PixelFormat.RGBA,
+ });
+
+ const sampler = new Sampler({
+ wrapS: TextureWrap.REPEAT,
+ wrapT: TextureWrap.MIRRORED_REPEAT,
+ minificationFilter: TextureMinificationFilter.NEAREST,
+ magnificationFilter: TextureMagnificationFilter.NEAREST,
+ maximumAnisotropy: 2.0,
});
- }).toThrowDeveloperError();
- });
+ texture.sampler = sampler;
+
+ const s = texture.sampler;
+ expect(s.wrapS).toEqual(sampler.wrapS);
+ expect(s.wrapT).toEqual(sampler.wrapT);
+ expect(s.minificationFilter).toEqual(sampler.minificationFilter);
+ expect(s.magnificationFilter).toEqual(sampler.magnificationFilter);
+ expect(s.maximumAnisotropy).toEqual(2.0);
+ });
- it("throws when creating a texture with an invalid pixel datatype", function () {
- expect(function () {
+ it("can set sampler at construction", function () {
texture = new Texture({
context: context,
source: blueImage,
pixelFormat: PixelFormat.RGBA,
- pixelDatatype: "invalid pixelDatatype",
+ sampler: new Sampler({
+ wrapS: TextureWrap.REPEAT,
+ wrapT: TextureWrap.MIRRORED_REPEAT,
+ minificationFilter: TextureMinificationFilter.NEAREST,
+ magnificationFilter: TextureMagnificationFilter.NEAREST,
+ maximumAnisotropy: 2.0,
+ }),
});
- }).toThrowDeveloperError();
- });
- it("throws when creating if pixelFormat is DEPTH_COMPONENT and pixelDatatype is not UNSIGNED_SHORT or UNSIGNED_INT", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- });
- }).toThrowDeveloperError();
- });
+ const s = texture.sampler;
+ expect(s.wrapS).toEqual(TextureWrap.REPEAT);
+ expect(s.wrapT).toEqual(TextureWrap.MIRRORED_REPEAT);
+ expect(s.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
+ expect(s.magnificationFilter).toEqual(
+ TextureMagnificationFilter.NEAREST,
+ );
+ expect(s.maximumAnisotropy).toEqual(2.0);
+ });
+
+ it("can get width and height", function () {
+ texture = new Texture({
+ context: context,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
+
+ expect(texture.width).toEqual(1);
+ expect(texture.height).toEqual(2);
+ });
+
+ it("can get whether Y is flipped", function () {
+ texture = new Texture({
+ context: context,
+ source: blueOverRedImage,
+ pixelFormat: PixelFormat.RGBA,
+ flipY: true,
+ });
+
+ expect(texture.flipY).toEqual(true);
+ });
+
+ it("can get the dimensions of a texture", function () {
+ texture = new Texture({
+ context: context,
+ width: 64,
+ height: 16,
+ });
+
+ expect(texture.dimensions).toEqual(new Cartesian2(64, 16));
+ });
+
+ function expectTextureByteSize(
+ width,
+ height,
+ pixelFormat,
+ pixelDatatype,
+ expectedSize,
+ ) {
+ texture = new Texture({
+ context: context,
+ width: width,
+ height: height,
+ pixelFormat: pixelFormat,
+ pixelDatatype: pixelDatatype,
+ });
+ expect(texture.sizeInBytes).toBe(expectedSize);
+ texture = texture && texture.destroy();
+ }
+
+ it("can get the size in bytes of a texture", function () {
+ // Depth textures
+ if (context.depthTexture) {
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.DEPTH_COMPONENT,
+ PixelDatatype.UNSIGNED_SHORT,
+ 256 * 2,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.DEPTH_COMPONENT,
+ PixelDatatype.UNSIGNED_INT,
+ 256 * 4,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.DEPTH_STENCIL,
+ PixelDatatype.UNSIGNED_INT_24_8,
+ 256 * 4,
+ );
+ }
+
+ // Uncompressed formats
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.ALPHA,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.RGB,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256 * 3,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.RGBA,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256 * 4,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.LUMINANCE,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256,
+ );
+ expectTextureByteSize(
+ 16,
+ 16,
+ PixelFormat.LUMINANCE_ALPHA,
+ PixelDatatype.UNSIGNED_BYTE,
+ 256 * 2,
+ );
+ });
+
+ it("can be destroyed", function () {
+ const t = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
+
+ expect(t.isDestroyed()).toEqual(false);
+ t.destroy();
+ expect(t.isDestroyed()).toEqual(true);
+ });
+
+ it("throws when creating a texture without a options", function () {
+ expect(function () {
+ texture = new Texture();
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture without a source", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with width and no height", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with height and no width", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ height: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with zero width", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 0,
+ height: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with width larger than the maximum texture size", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: ContextLimits.maximumTextureSize + 1,
+ height: 16,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with zero height", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 16,
+ height: 0,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with height larger than the maximum texture size", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 16,
+ height: ContextLimits.maximumTextureSize + 1,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with an invalid pixel format", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: "invalid PixelFormat",
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating a texture with an invalid pixel datatype", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: "invalid pixelDatatype",
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_COMPONENT and pixelDatatype is not UNSIGNED_SHORT or UNSIGNED_INT", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_STENCIL and pixelDatatype is not UNSIGNED_INT_24_8", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ pixelFormat: PixelFormat.DEPTH_STENCIL,
+ pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and source is provided", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and WEBGL_depth_texture is not supported", function () {
+ if (!context.depthTexture) {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when creating if pixelDatatype is FLOAT, and OES_texture_float is not supported", function () {
+ if (!context.floatingPointTexture) {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.RGBA,
+ pixelDatatype: PixelDatatype.FLOAT,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when creating if pixelDatatype = HALF_FLOAT, and OES_texture_half_float is not supported", function () {
+ if (!context.halfFloatingPointTexture) {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelDatatype.RGBA,
+ pixelDatatype: PixelDatatype.HALF_FLOAT,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when creating compressed texture and the array buffer source is undefined", function () {
+ expect(function () {
+ texture = new Texture({
+ context: context,
+ width: 4,
+ height: 4,
+ pixelFormat: PixelFormat.RGBA_DXT3,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating from the framebuffer with an invalid pixel format", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: "invalid PixelFormat",
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating from the framebuffer if PixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when creating from the framebuffer with a negative framebufferXOffset", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: -1,
+ });
+ }).toThrowDeveloperError();
+ });
- it("throws when creating if pixelFormat is DEPTH_STENCIL and pixelDatatype is not UNSIGNED_INT_24_8", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- pixelFormat: PixelFormat.DEPTH_STENCIL,
- pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
- });
- }).toThrowDeveloperError();
- });
+ it("throws when creating from the framebuffer with a negative framebufferYOffset", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: 0,
+ framebufferYOffset: -1,
+ });
+ }).toThrowDeveloperError();
+ });
- it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and source is provided", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
- });
- }).toThrowDeveloperError();
- });
+ it("throws when creating from the framebuffer with a width greater than the canvas clientWidth", function () {
+ expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: 0,
+ framebufferYOffset: 0,
+ width: context.canvas.clientWidth + 1,
+ });
+ }).toThrowDeveloperError();
+ });
- it("throws when creating if pixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL, and WEBGL_depth_texture is not supported", function () {
- if (!context.depthTexture) {
+ it("throws when creating from the framebuffer with a height greater than the canvas clientHeight", function () {
expect(function () {
+ texture = Texture.fromFramebuffer({
+ context: context,
+ pixelFormat: PixelFormat.RGB,
+ framebufferXOffset: 0,
+ framebufferYOffset: 0,
+ width: 1,
+ height: context.canvas.clientHeight + 1,
+ });
+ }).toThrowDeveloperError();
+ });
+
+ it("throws when copying to a texture from the framebuffer with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
+ if (context.depthTexture) {
texture = new Texture({
context: context,
width: 1,
@@ -1092,13 +1220,33 @@ describe(
pixelFormat: PixelFormat.DEPTH_COMPONENT,
pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
});
- }).toThrowDeveloperError();
- }
- });
- it("throws when creating if pixelDatatype is FLOAT, and OES_texture_float is not supported", function () {
- if (!context.floatingPointTexture) {
- expect(function () {
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when copying to a texture from the framebuffer with a compressed pixel format", function () {
+ if (context.supportsBasis) {
+ texture = new Texture({
+ context: context,
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
+
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when copying to a texture from the framebuffer with a FLOAT pixel data type", function () {
+ if (context.floatingPointTexture) {
texture = new Texture({
context: context,
width: 1,
@@ -1106,454 +1254,313 @@ describe(
pixelFormat: PixelFormat.RGBA,
pixelDatatype: PixelDatatype.FLOAT,
});
- }).toThrowDeveloperError();
- }
- });
- it("throws when creating if pixelDatatype = HALF_FLOAT, and OES_texture_half_float is not supported", function () {
- if (!context.halfFloatingPointTexture) {
- expect(function () {
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
+
+ it("throws when copying to a texture from the framebuffer with a HALF_FLOAT pixel data type", function () {
+ if (context.halfFloatingPointTexture) {
texture = new Texture({
context: context,
width: 1,
height: 1,
- pixelFormat: PixelDatatype.RGBA,
+ pixelFormat: PixelFormat.RGBA,
pixelDatatype: PixelDatatype.HALF_FLOAT,
});
- }).toThrowDeveloperError();
- }
- });
-
- it("throws when creating compressed texture and the array buffer source is undefined", function () {
- expect(function () {
- texture = new Texture({
- context: context,
- width: 4,
- height: 4,
- pixelFormat: PixelFormat.RGBA_DXT3,
- });
- }).toThrowDeveloperError();
- });
-
- it("throws when creating from the framebuffer with an invalid pixel format", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: "invalid PixelFormat",
- });
- }).toThrowDeveloperError();
- });
- it("throws when creating from the framebuffer if PixelFormat is DEPTH_COMPONENT or DEPTH_STENCIL", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- });
- }).toThrowDeveloperError();
- });
+ expect(function () {
+ texture.copyFromFramebuffer();
+ }).toThrowDeveloperError();
+ }
+ });
- it("throws when creating from the framebuffer with a negative framebufferXOffset", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
+ it("throws when copying from the framebuffer with a negative xOffset", function () {
+ texture = new Texture({
context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: -1,
+ source: blueImage,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating from the framebuffer with a negative framebufferYOffset", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: 0,
- framebufferYOffset: -1,
- });
- }).toThrowDeveloperError();
- });
+ expect(function () {
+ texture.copyFromFramebuffer(-1);
+ }).toThrowDeveloperError();
+ });
- it("throws when creating from the framebuffer with a width greater than the canvas clientWidth", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
+ it("throws when copying from the framebuffer with a negative yOffset", function () {
+ texture = new Texture({
context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: 0,
- framebufferYOffset: 0,
- width: context.canvas.clientWidth + 1,
+ source: blueImage,
});
- }).toThrowDeveloperError();
- });
- it("throws when creating from the framebuffer with a height greater than the canvas clientHeight", function () {
- expect(function () {
- texture = Texture.fromFramebuffer({
- context: context,
- pixelFormat: PixelFormat.RGB,
- framebufferXOffset: 0,
- framebufferYOffset: 0,
- width: 1,
- height: context.canvas.clientHeight + 1,
- });
- }).toThrowDeveloperError();
- });
+ expect(function () {
+ texture.copyFromFramebuffer(0, -1);
+ }).toThrowDeveloperError();
+ });
- it("throws when copying to a texture from the framebuffer with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
- if (context.depthTexture) {
+ it("throws when copying from the framebuffer with a negative framebufferXOffset", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, -1);
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when copying to a texture from the framebuffer with a compressed pixel format", function () {
- if (context.supportsBasis) {
+ it("throws when copying from the framebuffer with a negative framebufferYOffset", function () {
texture = new Texture({
context: context,
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, 0, -1);
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when copying to a texture from the framebuffer with a FLOAT pixel data type", function () {
- if (context.floatingPointTexture) {
+ it("throws when copying from the framebuffer with a larger width", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.FLOAT,
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, 0, 0, texture.width + 1);
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when copying to a texture from the framebuffer with a HALF_FLOAT pixel data type", function () {
- if (context.halfFloatingPointTexture) {
+ it("throws when copying from the framebuffer with a larger height", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.RGBA,
- pixelDatatype: PixelDatatype.HALF_FLOAT,
+ source: blueImage,
});
expect(function () {
- texture.copyFromFramebuffer();
+ texture.copyFromFramebuffer(0, 0, 0, 0, 0, texture.height + 1);
}).toThrowDeveloperError();
- }
- });
-
- it("throws when copying from the framebuffer with a negative xOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFromFramebuffer(-1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying from the framebuffer with a negative yOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFromFramebuffer(0, -1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying from the framebuffer with a negative framebufferXOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFromFramebuffer(0, 0, -1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying from the framebuffer with a negative framebufferYOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
});
- expect(function () {
- texture.copyFromFramebuffer(0, 0, 0, -1);
- }).toThrowDeveloperError();
- });
+ it("throws when copying to a texture with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
+ if (context.depthTexture) {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
- it("throws when copying from the framebuffer with a larger width", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom({
+ source: {
+ arrayBufferView: new Uint16Array([0]),
+ width: 1,
+ height: 1,
+ },
+ });
+ }).toThrowDeveloperError();
+ }
});
- expect(function () {
- texture.copyFromFramebuffer(0, 0, 0, 0, texture.width + 1);
- }).toThrowDeveloperError();
- });
+ it("throws when copyFrom is not given any options", function () {
+ texture = new Texture({
+ context: context,
+ source: blueImage,
+ });
- it("throws when copying from the framebuffer with a larger height", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom();
+ }).toThrowDeveloperError();
});
- expect(function () {
- texture.copyFromFramebuffer(0, 0, 0, 0, 0, texture.height + 1);
- }).toThrowDeveloperError();
- });
-
- it("throws when copying to a texture with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
- if (context.depthTexture) {
+ it("throws when copyFrom is not given a source", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ source: blueImage,
});
expect(function () {
texture.copyFrom({
- source: {
- arrayBufferView: new Uint16Array([0]),
- width: 1,
- height: 1,
- },
+ xOffset: 0,
+ yOffset: 2,
});
}).toThrowDeveloperError();
- }
- });
-
- it("throws when copyFrom is not given any options", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFrom();
- }).toThrowDeveloperError();
- });
-
- it("throws when copyFrom is not given a source", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
-
- expect(function () {
- texture.copyFrom({
- xOffset: 0,
- yOffset: 2,
- });
- }).toThrowDeveloperError();
- });
-
- it("throws when copyFrom is given a negative xOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
});
- expect(function () {
- texture.copyFrom({
+ it("throws when copyFrom is given a negative xOffset", function () {
+ texture = new Texture({
+ context: context,
source: blueImage,
- xOffset: -1,
});
- }).toThrowDeveloperError();
- });
- it("throws when copyFrom is given a negative yOffset", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ xOffset: -1,
+ });
+ }).toThrowDeveloperError();
});
- expect(function () {
- texture.copyFrom({
+ it("throws when copyFrom is given a negative yOffset", function () {
+ texture = new Texture({
+ context: context,
source: blueImage,
- xOffset: 0,
- yOffset: -1,
});
- }).toThrowDeveloperError();
- });
- it("throws when copyFrom is given a source with larger width", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
- const image = new Image();
- image.width = blueImage.width + 1;
-
- expect(function () {
- texture.copyFrom({
- source: image,
- });
- }).toThrowDeveloperError();
- });
-
- it("throws when copyFrom is given a source with larger height", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
+ expect(function () {
+ texture.copyFrom({
+ source: blueImage,
+ xOffset: 0,
+ yOffset: -1,
+ });
+ }).toThrowDeveloperError();
});
- const image = new Image();
- image.height = blueImage.height + 1;
-
- expect(function () {
- texture.copyFrom({
- source: image,
- });
- }).toThrowDeveloperError();
- });
- it("throws when copyFrom is given a source with a compressed pixel format", function () {
- if (context.supportsBasis) {
+ it("throws when copyFrom is given a source with larger width", function () {
texture = new Texture({
context: context,
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
+ source: blueImage,
});
-
const image = new Image();
+ image.width = blueImage.width + 1;
+
expect(function () {
texture.copyFrom({
source: image,
});
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when generating mipmaps with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
- if (context.depthTexture) {
+ it("throws when copyFrom is given a source with larger height", function () {
texture = new Texture({
context: context,
- width: 1,
- height: 1,
- pixelFormat: PixelFormat.DEPTH_COMPONENT,
- pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ source: blueImage,
});
+ const image = new Image();
+ image.height = blueImage.height + 1;
expect(function () {
- texture.generateMipmap();
+ texture.copyFrom({
+ source: image,
+ });
}).toThrowDeveloperError();
- }
- });
+ });
- it("throws when generating mipmaps with a compressed pixel format", function () {
- if (context.supportsBasis) {
- texture = new Texture({
- context: context,
- width: greenBasisKTX2Image.width,
- height: greenBasisKTX2Image.height,
- pixelFormat: greenBasisKTX2Image.internalFormat,
- source: {
- arrayBufferView: greenBasisKTX2Image.bufferView,
- },
- });
+ it("throws when copyFrom is given a source with a compressed pixel format", function () {
+ if (context.supportsBasis) {
+ texture = new Texture({
+ context: context,
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
- expect(function () {
- texture.generateMipmap();
- }).toThrowDeveloperError();
- }
- });
+ const image = new Image();
+ expect(function () {
+ texture.copyFrom({
+ source: image,
+ });
+ }).toThrowDeveloperError();
+ }
+ });
- describe("WebGL1", function () {
- let webgl1Context;
+ it("throws when generating mipmaps with a DEPTH_COMPONENT or DEPTH_STENCIL pixel format", function () {
+ if (context.depthTexture) {
+ texture = new Texture({
+ context: context,
+ width: 1,
+ height: 1,
+ pixelFormat: PixelFormat.DEPTH_COMPONENT,
+ pixelDatatype: PixelDatatype.UNSIGNED_SHORT,
+ });
- beforeAll(() => {
- webgl1Context = createContext({
- requestWebgl1: true,
- });
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
+ }
});
- afterAll(() => {
- webgl1Context.destroyForSpecs();
+ it("throws when generating mipmaps with a compressed pixel format", function () {
+ if (context.supportsBasis) {
+ texture = new Texture({
+ context: context,
+ width: greenBasisKTX2Image.width,
+ height: greenBasisKTX2Image.height,
+ pixelFormat: greenBasisKTX2Image.internalFormat,
+ source: {
+ arrayBufferView: greenBasisKTX2Image.bufferView,
+ },
+ });
+
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
+ }
});
- it("throws when generating mipmaps with a non-power of two width", function () {
- texture = new Texture({
- context: webgl1Context,
- width: 3,
- height: 2,
+ describe("WebGL1", function () {
+ it("throws when generating mipmaps with a non-power of two width", function () {
+ if (context.webgl2) {
+ return;
+ }
+ texture = new Texture({
+ context: context,
+ width: 3,
+ height: 2,
+ });
+
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
});
- expect(function () {
- texture.generateMipmap();
- }).toThrowDeveloperError();
+ it("throws when generating mipmaps with a non-power of two height", function () {
+ if (context.webgl2) {
+ return;
+ }
+ texture = new Texture({
+ context: context,
+ width: 2,
+ height: 3,
+ });
+
+ expect(function () {
+ texture.generateMipmap();
+ }).toThrowDeveloperError();
+ });
});
- it("throws when generating mipmaps with a non-power of two height", function () {
+ it("throws when generating mipmaps with an invalid hint", function () {
texture = new Texture({
- context: webgl1Context,
- width: 2,
- height: 3,
+ context: context,
+ source: blueImage,
});
expect(function () {
- texture.generateMipmap();
+ texture.generateMipmap("invalid hint");
}).toThrowDeveloperError();
});
- });
- it("throws when generating mipmaps with an invalid hint", function () {
- texture = new Texture({
- context: context,
- source: blueImage,
- });
+ it("throws when destroy is called after destroying", function () {
+ const t = new Texture({
+ context: context,
+ source: blueImage,
+ pixelFormat: PixelFormat.RGBA,
+ });
- expect(function () {
- texture.generateMipmap("invalid hint");
- }).toThrowDeveloperError();
- });
+ t.destroy();
- it("throws when destroy is called after destroying", function () {
- const t = new Texture({
- context: context,
- source: blueImage,
- pixelFormat: PixelFormat.RGBA,
+ expect(function () {
+ t.destroy();
+ }).toThrowDeveloperError();
});
-
- t.destroy();
-
- expect(function () {
- t.destroy();
- }).toThrowDeveloperError();
- });
+ }
},
"WebGL",
);
diff --git a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
index 1f70a75175c3..a05b1be4dc28 100644
--- a/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
+++ b/packages/engine/Specs/Scene/Cesium3DTilesetSpec.js
@@ -91,6 +91,10 @@ describe(
const tilesetOfTilesetsUrl =
"Data/Cesium3DTiles/Tilesets/TilesetOfTilesets/tileset.json";
+ // A tileset that refers to 4 GLB files which share two (external) textures
+ const tilesetUrlWithSharedTextures =
+ "Data/Cesium3DTiles/Tilesets/TilesetWithSharedTextures/tileset.json";
+
const withoutBatchTableUrl =
"Data/Cesium3DTiles/Batched/BatchedWithoutBatchTable/tileset.json";
const withBatchTableUrl =
@@ -211,9 +215,6 @@ describe(
options = {
cullRequestsWhileMoving: false,
- environmentMapOptions: {
- enabled: scene.highDynamicRangeSupported,
- },
};
});
@@ -966,6 +967,78 @@ describe(
);
});
+ it("verify memory usage statistics for shared textures", async function () {
+ // One buffer view with 4 positions, 4 normals, and 4 texture coordinates,
+ // using a common byte stride of 12 (resulting in 144 bytes)
+ // and 2*3 unsigned short indices, resulting in a total of 156 bytes
+ const singleGeometryByteLength = 156;
+
+ // One texture with 128x128 * RGBA pixels = 65536 bytes
+ const singleTexturesByteLength = 65536;
+
+ // Basic camera setup
+ const camera = scene.camera;
+
+ // NOTE: This is really, really important. There are some
+ // random calls in "beforeEach" and other parts of these
+ // specs that affect the camera transform. And the camera
+ // transform is NOT maintained to be consistent with the
+ // other properties in any way. So reset it here...
+ camera.lookAtTransform(Matrix4.IDENTITY);
+
+ camera.position = new Cartesian3(0, -1, 0);
+ camera.direction = Cartesian3.clone(Cartesian3.UNIT_Y);
+ camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
+ camera.frustum.near = 0.01;
+ camera.frustum.far = 100.0;
+
+ // Move the camera to see no tiles
+ camera.position = new Cartesian3(100, -1, 100);
+
+ const tileset = await Cesium3DTilesTester.loadTileset(
+ scene,
+ tilesetUrlWithSharedTextures,
+ );
+
+ const statistics = tileset._statistics;
+
+ // No tiles loaded
+ expect(statistics.geometryByteLength).toEqual(0);
+ expect(statistics.texturesByteLength).toEqual(0);
+
+ // Move the camera to stare at the center of the first tile
+ camera.position = new Cartesian3(0.5, -1, 0.5);
+ await Cesium3DTilesTester.waitForTilesLoaded(scene, tileset);
+
+ // A single tile and texture was loaded
+ expect(statistics.geometryByteLength).toEqual(singleGeometryByteLength);
+ expect(statistics.texturesByteLength).toEqual(singleTexturesByteLength);
+
+ // Move the camera back to see all tiles
+ camera.position = new Cartesian3(3.5, -14, 0.5);
+ await Cesium3DTilesTester.waitForTilesLoaded(scene, tileset);
+
+ // All tiles have been loaded: 4 times the geometry, BUT
+ // ONLY 2 times the texture
+ expect(statistics.geometryByteLength).toEqual(
+ singleGeometryByteLength * 4,
+ );
+ expect(statistics.texturesByteLength).toEqual(
+ singleTexturesByteLength * 2,
+ );
+
+ // Move the camera back to stare at the center of the first tile again
+ camera.position = new Cartesian3(0.5, -1, 0.5);
+
+ // Trim any previously loaded tiles
+ tileset.trimLoadedTiles();
+ await Cesium3DTilesTester.waitForTilesLoaded(scene, tileset);
+
+ // Again, only a single tile and texture should be loaded
+ expect(statistics.geometryByteLength).toEqual(singleGeometryByteLength);
+ expect(statistics.texturesByteLength).toEqual(singleTexturesByteLength);
+ });
+
it("verify memory usage statistics for shared resources", function () {
ResourceCache.statistics.clear();
// Six tiles total:
diff --git a/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js b/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js
index 57ea8ee5354f..0783774b7482 100644
--- a/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js
+++ b/packages/engine/Specs/Scene/DynamicEnvironmentMapManagerSpec.js
@@ -2,6 +2,7 @@ import {
Cartesian3,
Cartographic,
Color,
+ ContextLimits,
CubeMap,
DynamicAtmosphereLightingType,
DynamicEnvironmentMapManager,
@@ -31,21 +32,59 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
expect(manager.groundAlbedo).toBe(0.31);
});
+ it("constructs with options", function () {
+ const manager = new DynamicEnvironmentMapManager({
+ enabled: false,
+ maximumSecondsDifference: 0,
+ maximumPositionEpsilon: 0,
+ atmosphereScatteringIntensity: 0,
+ gamma: 0,
+ brightness: 0,
+ saturation: 0,
+ groundColor: Color.BLUE,
+ groundAlbedo: 0,
+ });
+
+ expect(manager.enabled).toBeFalse();
+ expect(manager.shouldUpdate).toBeTrue();
+ expect(manager.maximumSecondsDifference).toBe(0);
+ expect(manager.maximumPositionEpsilon).toBe(0);
+ expect(manager.atmosphereScatteringIntensity).toBe(0);
+ expect(manager.gamma).toBe(0);
+ expect(manager.brightness).toBe(0);
+ expect(manager.saturation).toBe(0);
+ expect(manager.groundColor).toEqual(Color.BLUE);
+ expect(manager.groundAlbedo).toBe(0);
+ });
+
+ it("uses default spherical harmonic coefficients", () => {
+ const manager = new DynamicEnvironmentMapManager();
+
+ expect(manager.sphericalHarmonicCoefficients.length).toBe(9);
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
describe(
"render tests",
() => {
const time = JulianDate.fromIso8601("2024-08-30T10:45:00Z");
- let scene;
+ let scene, orginalMaximumCubeMapSize;
beforeAll(() => {
scene = createScene({
skyBox: false,
});
+ orginalMaximumCubeMapSize = ContextLimits.maximumCubeMapSize;
+ // To keep tests fast, don't throttle
+ ContextLimits._maximumCubeMapSize = Number.POSITIVE_INFINITY;
});
afterAll(() => {
scene.destroyForSpecs();
+ ContextLimits._maximumCubeMapSize = orginalMaximumCubeMapSize;
});
afterEach(() => {
@@ -53,7 +92,7 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
scene.atmosphere = new Atmosphere();
});
- // Allows the compute commands to be added to the command list at the right point in the pipeline
+ // A pared-down Primitive. Allows the compute commands to be added to the command list at the right point in the pipeline.
function EnvironmentMockPrimitive(manager) {
this.update = function (frameState) {
manager.update(frameState);
@@ -64,8 +103,74 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
};
}
+ it("does not update if position is undefined", async function () {
+ const manager = new DynamicEnvironmentMapManager();
+
+ const primitive = new EnvironmentMockPrimitive(manager);
+ scene.primitives.add(primitive);
+
+ scene.renderForSpecs();
+
+ expect(manager.radianceCubeMap).toBeUndefined();
+
+ scene.renderForSpecs();
+
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
+ it("does not update if enabled is false", async function () {
+ const manager = new DynamicEnvironmentMapManager();
+
+ const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
+ manager.position =
+ Ellipsoid.WGS84.cartographicToCartesian(cartographic);
+ manager.enabled = false;
+
+ const primitive = new EnvironmentMockPrimitive(manager);
+ scene.primitives.add(primitive);
+
+ scene.renderForSpecs();
+
+ expect(manager.radianceCubeMap).toBeUndefined();
+
+ scene.renderForSpecs();
+
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
+ it("does not update if requires extensions are not available", async function () {
+ spyOn(
+ DynamicEnvironmentMapManager,
+ "isDynamicUpdateSupported",
+ ).and.returnValue(false);
+
+ const manager = new DynamicEnvironmentMapManager();
+
+ const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
+ manager.position =
+ Ellipsoid.WGS84.cartographicToCartesian(cartographic);
+
+ const primitive = new EnvironmentMockPrimitive(manager);
+ scene.primitives.add(primitive);
+
+ scene.renderForSpecs();
+
+ expect(manager.radianceCubeMap).toBeUndefined();
+
+ scene.renderForSpecs();
+
+ expect(manager.sphericalHarmonicCoefficients).toEqual(
+ DynamicEnvironmentMapManager.DEFAULT_SPHERICAL_HARMONIC_COEFFICIENTS,
+ );
+ });
+
it("creates environment map and spherical harmonics at surface in Philadelphia with static lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -146,7 +251,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics at altitude in Philadelphia with static lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -231,7 +337,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics above Earth's atmosphere with static lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -317,7 +424,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics at surface in Philadelphia with dynamic lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -401,7 +509,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("creates environment map and spherical harmonics at surface in Sydney with dynamic lighting", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -485,7 +594,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses atmosphere properties", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -572,10 +682,10 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses atmosphereScatteringIntensity value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
-
const manager = new DynamicEnvironmentMapManager();
manager.atmosphereScatteringIntensity = 1.0;
@@ -654,7 +764,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses gamma value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -736,7 +847,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses brightness value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -818,7 +930,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses saturation value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -900,7 +1013,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses ground color value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -982,7 +1096,8 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("lighting uses ground albedo value", async function () {
- if (!scene.highDynamicRangeSupported) {
+ // Skip if required WebGL extensions are not supported
+ if (!DynamicEnvironmentMapManager.isDynamicUpdateSupported(scene)) {
return;
}
@@ -1064,18 +1179,6 @@ describe("Scene/DynamicEnvironmentMapManager", function () {
});
it("destroys", function () {
- if (!scene.highDynamicRangeSupported) {
- const manager = new DynamicEnvironmentMapManager();
- const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
- manager.position =
- Ellipsoid.WGS84.cartographicToCartesian(cartographic);
-
- manager.destroy();
-
- expect(manager.isDestroyed()).toBe(true);
- return;
- }
-
const manager = new DynamicEnvironmentMapManager();
const cartographic = Cartographic.fromDegrees(-75.165222, 39.952583);
manager.position =
diff --git a/packages/engine/Specs/Scene/ITwinDataSpec.js b/packages/engine/Specs/Scene/ITwinDataSpec.js
new file mode 100644
index 000000000000..8eb4322c5778
--- /dev/null
+++ b/packages/engine/Specs/Scene/ITwinDataSpec.js
@@ -0,0 +1,224 @@
+import {
+ ITwinPlatform,
+ RuntimeError,
+ Cesium3DTileset,
+ ITwinData,
+} from "../../index.js";
+
+function createMockExport(
+ id,
+ status,
+ exportType = ITwinPlatform.ExportType["3DTILES"],
+) {
+ return {
+ id: `${id}`,
+ displayName: `export ${id}`,
+ status: status,
+ lastModified: "2024-11-04T12:00Z",
+ request: {
+ iModelId: "imodel-id-1",
+ changesetId: "changeset-id",
+ exportType,
+ },
+ _links: {
+ mesh: {
+ // The API returns some important query params for auth that we
+ // need to make sure are preserved when the path is modified
+ href: `https://example.com/link/to/mesh/${id}?query=param`,
+ },
+ },
+ };
+}
+
+describe("ITwinData", () => {
+ let previousAccessToken;
+ beforeEach(() => {
+ previousAccessToken = ITwinPlatform.defaultAccessToken;
+ ITwinPlatform.defaultAccessToken = "default-access-token";
+ });
+
+ afterEach(() => {
+ ITwinPlatform.defaultAccessToken = previousAccessToken;
+ });
+
+ describe("createTilesetFromIModelId", () => {
+ it("rejects when all exports are invalid", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(2, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(3, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(4, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(5, ITwinPlatform.ExportStatus.Invalid),
+ ],
+ });
+ await expectAsync(
+ ITwinData.createTilesetFromIModelId("imodel-id-1"),
+ ).toBeRejectedWithError(RuntimeError, /All exports for this iModel/);
+ });
+
+ it("returns undefined when no exports returned", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [],
+ });
+ const tileset = await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tileset).toBeUndefined();
+ });
+
+ it("returns undefined when no exports are complete", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.InProgress),
+ createMockExport(2, ITwinPlatform.ExportStatus.NotStarted),
+ ],
+ });
+ const tileset = await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tileset).toBeUndefined();
+ });
+
+ it("returns undefined when no exports are complete", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.InProgress),
+ createMockExport(2, ITwinPlatform.ExportStatus.NotStarted),
+ ],
+ });
+ const tileset = await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tileset).toBeUndefined();
+ });
+
+ it("creates a tileset for the first complete export", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [
+ createMockExport(1, ITwinPlatform.ExportStatus.Invalid),
+ createMockExport(2, ITwinPlatform.ExportStatus.Complete),
+ ],
+ });
+ const tilesetSpy = spyOn(Cesium3DTileset, "fromUrl");
+ await ITwinData.createTilesetFromIModelId("imodel-id-1");
+ expect(tilesetSpy).toHaveBeenCalledTimes(1);
+ // Check that the resource url created is for the second export because
+ // the first is invalid
+ expect(tilesetSpy.calls.mostRecent().args[0].toString()).toEqual(
+ "https://example.com/link/to/mesh/2/tileset.json?query=param",
+ );
+ expect(tilesetSpy.calls.mostRecent().args[1]).toBeUndefined();
+ });
+
+ it("passes tileset options through to the tileset constructor", async () => {
+ spyOn(ITwinPlatform, "getExports").and.resolveTo({
+ exports: [createMockExport(1, ITwinPlatform.ExportStatus.Complete)],
+ });
+ const tilesetSpy = spyOn(Cesium3DTileset, "fromUrl");
+ const tilesetOptions = { show: false };
+ await ITwinData.createTilesetFromIModelId("imodel-id-1", tilesetOptions);
+ expect(tilesetSpy).toHaveBeenCalledTimes(1);
+ expect(tilesetSpy.calls.mostRecent().args[1]).toEqual(tilesetOptions);
+ });
+ });
+
+ describe("createTilesetForRealityDataId", () => {
+ let getMetadataSpy;
+ let getUrlSpy;
+ let tilesetSpy;
+ beforeEach(() => {
+ getMetadataSpy = spyOn(ITwinPlatform, "getRealityDataMetadata");
+ getUrlSpy = spyOn(ITwinPlatform, "getRealityDataURL");
+ tilesetSpy = spyOn(Cesium3DTileset, "fromUrl");
+ });
+
+ it("rejects if the type is not supported", async () => {
+ await expectAsync(
+ ITwinData.createTilesetForRealityDataId(
+ "imodel-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.DGN,
+ "root/path.json",
+ ),
+ ).toBeRejectedWithError(RuntimeError, /type is not/);
+ });
+
+ it("does not fetch metadata if type and rootDocument are defined", async () => {
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.Cesium3DTiles,
+ "root/document/path.json",
+ );
+
+ expect(getMetadataSpy).not.toHaveBeenCalled();
+ expect(getUrlSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ });
+
+ it("fetches metadata if type is undefined", async () => {
+ getMetadataSpy.and.resolveTo({
+ iModelId: "itwin-id-1",
+ id: "reality-data-id-1",
+ type: ITwinPlatform.RealityDataType.Cesium3DTiles,
+ rootDocument: "root/document/path.json",
+ });
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ undefined,
+ "root/document/path.json",
+ );
+
+ expect(getMetadataSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ );
+ expect(getUrlSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ });
+
+ it("fetches metadata if rootDocument is undefined", async () => {
+ getMetadataSpy.and.resolveTo({
+ iModelId: "itwin-id-1",
+ id: "reality-data-id-1",
+ type: ITwinPlatform.RealityDataType.Cesium3DTiles,
+ rootDocument: "root/document/path.json",
+ });
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.Cesium3DTiles,
+ undefined,
+ );
+
+ expect(getMetadataSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ );
+ expect(getUrlSpy).toHaveBeenCalledOnceWith(
+ "itwin-id-1",
+ "reality-data-id-1",
+ "root/document/path.json",
+ );
+ });
+
+ it("creates a tileset from the constructed blob url", async () => {
+ const tilesetUrl =
+ "https://example.com/root/document/path.json?auth=token";
+ getUrlSpy.and.resolveTo(tilesetUrl);
+
+ await ITwinData.createTilesetForRealityDataId(
+ "itwin-id-1",
+ "reality-data-id-1",
+ ITwinPlatform.RealityDataType.Cesium3DTiles,
+ "root/document/path.json",
+ );
+
+ expect(tilesetSpy).toHaveBeenCalledOnceWith(tilesetUrl, {
+ maximumScreenSpaceError: 4,
+ });
+ });
+ });
+});
diff --git a/packages/engine/Specs/Scene/LabelCollectionSpec.js b/packages/engine/Specs/Scene/LabelCollectionSpec.js
index 3f163690e81e..68c7d7dbf6dd 100644
--- a/packages/engine/Specs/Scene/LabelCollectionSpec.js
+++ b/packages/engine/Specs/Scene/LabelCollectionSpec.js
@@ -2560,6 +2560,84 @@ describe(
});
});
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "a😀b";
+ const expectedText = "a😀b";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "awe2!$34f❤️b";
+ const expectedText = "awe2!$34f❤️b";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "lakneklf\u200fsldknfklf";
+ const expectedText = "lakneklfsldknfklf";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u200f - with Right-to-Left Mark (RLM)";
+ const expectedText = "test - with Right-to-Left Mark (RLM)";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u200b - with Zero-Width Space";
+ const expectedText = "test - with Zero-Width Space";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u202a - with Left-to-Right Embedding";
+ const expectedText = "test - with Left-to-Right Embedding";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test 😀 - Emoji";
+ const expectedText = "test 😀 - Emoji";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test ❤️ - Emoji";
+ const expectedText = "test ❤️ - Emoji";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test 🌍 - Emoji";
+ const expectedText = "test 🌍 - Emoji";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u2060 - with Word Joiner";
+ const expectedText = "test - with Word Joiner";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u0000 - with Null Character";
+ const expectedText = "test - with Null Character";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u000E - with Shift Out (SO)";
+ const expectedText = "test - with Shift Out (SO)";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
+ it("filterUnsupportedCharacters removes unicode characters from text only if they cause render issues", function () {
+ const text = "test \u001F - with Unit Separator (US)";
+ const expectedText = "test - with Unit Separator (US)";
+ expect(Label.filterUnsupportedCharacters(text)).toEqual(expectedText);
+ });
+
describe("height referenced labels", function () {
beforeEach(function () {
scene.globe = new Globe();
diff --git a/packages/engine/Specs/Scene/MetadataPickingSpec.js b/packages/engine/Specs/Scene/MetadataPickingSpec.js
new file mode 100644
index 000000000000..5f1cb8bd5a72
--- /dev/null
+++ b/packages/engine/Specs/Scene/MetadataPickingSpec.js
@@ -0,0 +1,1492 @@
+import {
+ Cartesian2,
+ Cartesian3,
+ Cartesian4,
+ Matrix2,
+ Matrix3,
+ Matrix4,
+ MetadataComponentType,
+ MetadataPicking,
+ MetadataType,
+} from "../../index.js";
+
+// The precision for Jasmine `toBeCloseTo` calls. Note that this
+// is not an "epsilon", but described as "The number of decimal
+// points to check" ...
+const precision = 3;
+
+describe("Scene/MetadataPicking", function () {
+ describe("decodeRawMetadataValue", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const componentType = "NOT_A_COMPONENT_TYPE";
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 0;
+ MetadataPicking.decodeRawMetadataValue(componentType, dataView, index);
+ }).toThrowError();
+ });
+
+ it("throws for invalid index", function () {
+ expect(function () {
+ const componentType = MetadataComponentType.INT8;
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 1234;
+ MetadataPicking.decodeRawMetadataValue(componentType, dataView, index);
+ }).toThrowError();
+ });
+
+ it("decodes raw value with component type INT8", function () {
+ const array = new Int8Array([12, 23]);
+ const componentType = MetadataComponentType.INT8;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 1;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes raw value with component type UINT8", function () {
+ const array = new Uint8Array([12, 23]);
+ const componentType = MetadataComponentType.UINT8;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 1;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes raw value with component type INT16", function () {
+ const array = new Int16Array([1234, 2345]);
+ const componentType = MetadataComponentType.INT16;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 2;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes raw value with component type UINT16", function () {
+ const array = new Uint16Array([1234, 2345]);
+ const componentType = MetadataComponentType.UINT16;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 2;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes raw value with component type INT32", function () {
+ const array = new Int32Array([123456, 234567]);
+ const componentType = MetadataComponentType.INT32;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 4;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes raw value with component type UINT32", function () {
+ const array = new Uint32Array([123456, 234567]);
+ const componentType = MetadataComponentType.UINT32;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 4;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes raw value with component type INT64", function () {
+ const array = new BigInt64Array([12345678900n, 23456789000n]);
+ const componentType = MetadataComponentType.INT64;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 8;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes raw value with component type UINT64", function () {
+ const array = new BigUint64Array([12345678900n, 23456789000n]);
+ const componentType = MetadataComponentType.UINT64;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 8;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes raw value with component type FLOAT32", function () {
+ const array = new Float32Array([1.23, 2.34]);
+ const componentType = MetadataComponentType.FLOAT32;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 4;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+
+ it("decodes raw value with component type FLOAT64", function () {
+ const array = new Float64Array([1.23, 2.34]);
+ const componentType = MetadataComponentType.FLOAT64;
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const index = 8;
+ const value = MetadataPicking.decodeRawMetadataValue(
+ componentType,
+ dataView,
+ index,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+ });
+
+ describe("decodeRawMetadataValueComponent", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const classProperty = {
+ componentType: "NOT_A_COMPONENT_TYPE",
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 0;
+ MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ }).toThrowError();
+ });
+
+ it("throws for invalid offset", function () {
+ expect(function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1234;
+ MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ }).toThrowError();
+ });
+
+ it("decodes component with componentType INT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes component with componentType normalized INT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT8,
+ normalized: true,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(23 / 127.0, precision);
+ });
+
+ it("decodes component with componentType UINT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT8,
+ normalized: false,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23);
+ });
+
+ it("decodes component with componentType normalized UINT8", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT8,
+ normalized: true,
+ };
+ const array = new Uint8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 1;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(23 / 255.0, precision);
+ });
+
+ it("decodes component with componentType INT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT16,
+ normalized: false,
+ };
+ const array = new Int16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes component with componentType normalized INT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT16,
+ normalized: true,
+ };
+ const array = new Int16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2345 / 32767.0, precision);
+ });
+
+ it("decodes component with componentType UINT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT16,
+ normalized: false,
+ };
+ const array = new Uint16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(2345);
+ });
+
+ it("decodes component with componentType normalized UINT16", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT16,
+ normalized: true,
+ };
+ const array = new Uint16Array([1234, 2345]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 2;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2345 / 65535.0, precision);
+ });
+
+ it("decodes component with componentType INT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT32,
+ normalized: false,
+ };
+ const array = new Int32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes component with componentType normalized INT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT32,
+ normalized: true,
+ };
+ const array = new Int32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(234567 / 2147483647.0, precision);
+ });
+
+ it("decodes component with componentType UINT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT32,
+ normalized: false,
+ };
+ const array = new Uint32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(234567);
+ });
+
+ it("decodes component with componentType normalized UINT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT32,
+ normalized: true,
+ };
+ const array = new Uint32Array([123456, 234567]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(234567 / 4294967295.0, precision);
+ });
+
+ it("decodes component with componentType INT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT64,
+ normalized: false,
+ };
+ const array = new BigInt64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes component with componentType normalized INT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.INT64,
+ normalized: true,
+ };
+ const array = new BigInt64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(Number(value)).toBeCloseTo(
+ Number(23456789000n / 9223372036854775807n),
+ precision,
+ );
+ });
+
+ it("decodes component with componentType UINT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT64,
+ normalized: false,
+ };
+ const array = new BigUint64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBe(23456789000n);
+ });
+
+ it("decodes component with componentType normalized UINT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.UINT64,
+ normalized: true,
+ };
+ const array = new BigUint64Array([12345678900n, 23456789000n]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(Number(value)).toBeCloseTo(
+ Number(23456789000n / 18446744073709551615n),
+ precision,
+ );
+ });
+
+ it("decodes component with componentType FLOAT32", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([1.23, 2.34]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 4;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+
+ it("decodes component with componentType FLOAT64", function () {
+ const classProperty = {
+ componentType: MetadataComponentType.FLOAT64,
+ normalized: false,
+ };
+ const array = new Float64Array([1.23, 2.34]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const dataViewOffset = 8;
+ const value = MetadataPicking.decodeRawMetadataValueComponent(
+ classProperty,
+ dataView,
+ dataViewOffset,
+ );
+ expect(value).toBeCloseTo(2.34, precision);
+ });
+ });
+
+ describe("decodeRawMetadataValueElement", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const classProperty = {
+ type: "SCALAR",
+ componentType: "NOT_A_COMPONENT_TYPE",
+ normalized: false,
+ };
+ const array = new Int8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 0;
+ MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ }).toThrowError();
+ });
+
+ it("throws for invalid element index", function () {
+ expect(function () {
+ const classProperty = {
+ type: "SCALAR",
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([12, 23]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1234;
+ MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ }).toThrowError();
+ });
+
+ it("decodes element with type SCALAR and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toBe(1);
+ });
+
+ it("decodes element with type VEC2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([2, 3]);
+ });
+
+ it("decodes element with type VEC3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3, 4, 5]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([3, 4, 5]);
+ });
+
+ it("decodes element with type VEC4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.MAT2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.MAT3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([9, 10, 11, 12, 13, 14, 15, 16, 17]);
+ });
+
+ it("decodes element with type MAT4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.MAT4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const array = new Int8Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ });
+
+ it("decodes element with type SCALAR and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toBe(1);
+ });
+
+ it("decodes element with type VEC2 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([2, 3]);
+ });
+
+ it("decodes element with type VEC3 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3, 4, 5]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([3, 4, 5]);
+ });
+
+ it("decodes element with type VEC4 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT2 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.MAT2,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([0, 1, 2, 3, 4, 5, 6, 7]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([4, 5, 6, 7]);
+ });
+
+ it("decodes element with type MAT3 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.MAT3,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([9, 10, 11, 12, 13, 14, 15, 16, 17]);
+ });
+
+ it("decodes element with type MAT4 and component type FLOAT32", function () {
+ const classProperty = {
+ type: MetadataType.MAT4,
+ componentType: MetadataComponentType.FLOAT32,
+ normalized: false,
+ };
+ const array = new Float32Array([
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ const dataView = new DataView(
+ array.buffer,
+ array.byteOffset,
+ array.byteLength,
+ );
+ const elementIndex = 1;
+ const value = MetadataPicking.decodeRawMetadataValueElement(
+ classProperty,
+ dataView,
+ elementIndex,
+ );
+ expect(value).toEqual([
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+ ]);
+ });
+ });
+
+ describe("decodeRawMetadataValues", function () {
+ it("throws for invalid component type", function () {
+ expect(function () {
+ const classProperty = {
+ type: "SCALAR",
+ componentType: "NOT_A_COMPONENT_TYPE",
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ MetadataPicking.decodeRawMetadataValues(classProperty, rawPixelValues);
+ }).toThrowError();
+ });
+
+ it("throws for invalid input length", function () {
+ expect(function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.UINT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0]);
+ MetadataPicking.decodeRawMetadataValues(classProperty, rawPixelValues);
+ }).toThrowError();
+ });
+
+ it("decodes raw values with type SCALAR and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(12);
+ });
+
+ it("decodes raw values with type VEC2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual([0, 1]);
+ });
+
+ it("decodes raw values with type VEC3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual([0, 1, 2]);
+ });
+
+ it("decodes raw values with type VEC4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ const value = MetadataPicking.decodeRawMetadataValues(
+ classProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual([0, 1, 2, 3]);
+ });
+ });
+
+ describe("convertToObjectType", function () {
+ it("throws for invalid type", function () {
+ expect(function () {
+ const type = "NOT_A_TYPE";
+ const value = 0;
+ MetadataPicking.convertToObjectType(type, value);
+ }).toThrowError();
+ });
+
+ it("returns SCALAR, STRING, BOOLEAN, and ENUM types (and arrays thereof) unmodified", function () {
+ const value0 = MetadataPicking.convertToObjectType(
+ MetadataType.SCALAR,
+ 123,
+ );
+ const value1 = MetadataPicking.convertToObjectType(
+ MetadataType.STRING,
+ "Value",
+ );
+ const value2 = MetadataPicking.convertToObjectType(
+ MetadataType.SCALAR,
+ true,
+ );
+ const value3 = MetadataPicking.convertToObjectType(
+ MetadataType.ENUM,
+ "VALUE",
+ );
+
+ expect(value0).toEqual(123);
+ expect(value1).toEqual("Value");
+ expect(value2).toEqual(true);
+ expect(value3).toEqual("VALUE");
+
+ const value0a = MetadataPicking.convertToObjectType(
+ MetadataType.SCALAR,
+ [123, 234],
+ );
+ const value1a = MetadataPicking.convertToObjectType(MetadataType.STRING, [
+ "Value0",
+ "Value1",
+ ]);
+ const value2a = MetadataPicking.convertToObjectType(MetadataType.SCALAR, [
+ true,
+ false,
+ ]);
+ const value3a = MetadataPicking.convertToObjectType(MetadataType.ENUM, [
+ "VALUE_A",
+ "VALUE_B",
+ ]);
+
+ expect(value0a).toEqual([123, 234]);
+ expect(value1a).toEqual(["Value0", "Value1"]);
+ expect(value2a).toEqual([true, false]);
+ expect(value3a).toEqual(["VALUE_A", "VALUE_B"]);
+ });
+
+ it("converts array-based VEC2 input into a Cartesian2", function () {
+ const array = [0, 1];
+ const expected = Cartesian2.unpack(array, 0, new Cartesian2());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.VEC2,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based VEC3 input into a Cartesian3", function () {
+ const array = [0, 1, 2];
+ const expected = Cartesian3.unpack(array, 0, new Cartesian3());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.VEC3,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based VEC4 input into a Cartesian4", function () {
+ const array = [0, 1, 2, 3];
+ const expected = Cartesian4.unpack(array, 0, new Cartesian4());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.VEC4,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based MAT2 input into a Matrix2", function () {
+ const array = [0, 1, 2, 3];
+ const expected = Matrix2.unpack(array, 0, new Matrix2());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.MAT2,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based MAT3 input into a Matrix3", function () {
+ const array = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+ const expected = Matrix3.unpack(array, 0, new Matrix3());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.MAT3,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts array-based MAT4 input into a Matrix4", function () {
+ const array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+ const expected = Matrix4.unpack(array, 0, new Matrix4());
+ const actual = MetadataPicking.convertToObjectType(
+ MetadataType.MAT4,
+ array,
+ );
+ expect(actual).toEqual(expected);
+ });
+ });
+
+ describe("convertFromObjectType", function () {
+ it("throws for invalid type", function () {
+ expect(function () {
+ const type = "NOT_A_TYPE";
+ const value = new Cartesian2();
+ MetadataPicking.convertFromObjectType(type, value);
+ }).toThrowError();
+ });
+
+ it("returns SCALAR, STRING, BOOLEAN, and ENUM types (and arrays thereof) unmodified", function () {
+ const value0 = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ 123,
+ );
+ const value1 = MetadataPicking.convertFromObjectType(
+ MetadataType.STRING,
+ "Value",
+ );
+ const value2 = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ true,
+ );
+ const value3 = MetadataPicking.convertFromObjectType(
+ MetadataType.ENUM,
+ "VALUE",
+ );
+
+ expect(value0).toEqual(123);
+ expect(value1).toEqual("Value");
+ expect(value2).toEqual(true);
+ expect(value3).toEqual("VALUE");
+
+ const value0a = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ [123, 234],
+ );
+ const value1a = MetadataPicking.convertFromObjectType(
+ MetadataType.STRING,
+ ["Value0", "Value1"],
+ );
+ const value2a = MetadataPicking.convertFromObjectType(
+ MetadataType.SCALAR,
+ [true, false],
+ );
+ const value3a = MetadataPicking.convertFromObjectType(MetadataType.ENUM, [
+ "VALUE_A",
+ "VALUE_B",
+ ]);
+
+ expect(value0a).toEqual([123, 234]);
+ expect(value1a).toEqual(["Value0", "Value1"]);
+ expect(value2a).toEqual([true, false]);
+ expect(value3a).toEqual(["VALUE_A", "VALUE_B"]);
+ });
+
+ it("converts Cartesian2 into array-based VEC2", function () {
+ const expected = [0, 1];
+ const value = Cartesian2.unpack(expected, 0, new Cartesian2());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.VEC2,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Cartesian3 into array-based VEC3", function () {
+ const expected = [0, 1, 2];
+ const value = Cartesian3.unpack(expected, 0, new Cartesian3());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.VEC3,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Cartesian4 into array-based VEC4", function () {
+ const expected = [0, 1, 2, 3];
+ const value = Cartesian4.unpack(expected, 0, new Cartesian4());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.VEC4,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Matrix2 into array-based MAT2", function () {
+ const expected = [0, 1, 2, 3];
+ const value = Matrix2.unpack(expected, 0, new Matrix2());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.MAT2,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Matrix3 into array-based MAT3", function () {
+ const expected = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+ const value = Matrix3.unpack(expected, 0, new Matrix3());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.MAT3,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+
+ it("converts Matrix4 into array-based MAT4", function () {
+ const expected = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+ const value = Matrix4.unpack(expected, 0, new Matrix4());
+ const actual = MetadataPicking.convertFromObjectType(
+ MetadataType.MAT4,
+ value,
+ );
+ expect(actual).toEqual(expected);
+ });
+ });
+
+ describe("decodeMetadataValues", function () {
+ it("throws for invalid type", function () {
+ expect(function () {
+ const classProperty = {
+ type: "NOT_A_TYPE",
+ componentType: MetadataComponentType.UINT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([0, 1, 2, 3]);
+ MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ }).toThrowError();
+ });
+
+ it("decodes values with type SCALAR and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(12);
+ });
+
+ it("decodes values with type VEC2 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(new Cartesian2(12, 23));
+ });
+
+ it("decodes values with type VEC3 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(new Cartesian3(12, 23, 34));
+ });
+
+ it("decodes values with type VEC4 and component type INT8", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const metadataProperty = {
+ hasValueTransform: false,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(new Cartesian4(12, 23, 34, 45));
+ });
+
+ it("decodes values with type SCALAR and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.SCALAR,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = 100;
+ const scale = 2;
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ expect(value).toEqual(offset + 12 * scale);
+ });
+
+ it("decodes values with type VEC2 and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.VEC2,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = new Cartesian2(100, 200);
+ const scale = new Cartesian2(2, 3);
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ const expected = new Cartesian2(
+ offset.x + 12 * scale.x,
+ offset.y + 23 * scale.y,
+ );
+ expect(value).toEqual(expected);
+ });
+
+ it("decodes values with type VEC3 and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.VEC3,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = new Cartesian3(100, 200, 300);
+ const scale = new Cartesian3(2, 3, 4);
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ const expected = new Cartesian3(
+ offset.x + 12 * scale.x,
+ offset.y + 23 * scale.y,
+ offset.z + 34 * scale.z,
+ );
+ expect(value).toEqual(expected);
+ });
+
+ it("decodes values with type VEC4 and component type INT8 and offset and scale", function () {
+ const classProperty = {
+ type: MetadataType.VEC4,
+ componentType: MetadataComponentType.INT8,
+ normalized: false,
+ };
+ const offset = new Cartesian4(100, 200, 300, 400);
+ const scale = new Cartesian4(2, 3, 4, 5);
+ const metadataProperty = {
+ hasValueTransform: true,
+ offset: offset,
+ scale: scale,
+ };
+ const rawPixelValues = new Uint8Array([12, 23, 34, 45]);
+ const value = MetadataPicking.decodeMetadataValues(
+ classProperty,
+ metadataProperty,
+ rawPixelValues,
+ );
+ const expected = new Cartesian4(
+ offset.x + 12 * scale.x,
+ offset.y + 23 * scale.y,
+ offset.z + 34 * scale.z,
+ offset.w + 45 * scale.w,
+ );
+ expect(value).toEqual(expected);
+ });
+ });
+});
diff --git a/packages/engine/Specs/Scene/Model/ModelSpec.js b/packages/engine/Specs/Scene/Model/ModelSpec.js
index 2f31aa01b5fa..7af9758fdad9 100644
--- a/packages/engine/Specs/Scene/Model/ModelSpec.js
+++ b/packages/engine/Specs/Scene/Model/ModelSpec.js
@@ -3113,10 +3113,13 @@ describe(
{
gltf: boxTexturedGltfUrl,
lightColor: Cartesian3.ZERO,
- imageBasedLighting: undefined,
},
scene,
);
+
+ // ignore any image-based lighting– Test directional light only
+ model.imageBasedLighting.imageBasedLightingFactor = Cartesian2.ZERO;
+
verifyRender(model, false);
});
@@ -3125,6 +3128,10 @@ describe(
{ gltf: boxTexturedGltfUrl, imageBasedLighting: undefined },
scene,
);
+
+ // ignore any image-based lighting– Test directional light only
+ model.imageBasedLighting.imageBasedLightingFactor = Cartesian2.ZERO;
+
model.lightColor = Cartesian3.ZERO;
verifyRender(model, false);
@@ -3193,7 +3200,7 @@ describe(
it("changing imageBasedLighting works", async function () {
const imageBasedLighting = new ImageBasedLighting({
sphericalHarmonicCoefficients: [
- new Cartesian3(0.35449, 0.35449, 0.35449),
+ new Cartesian3(1.0, 0.0, 0.0),
Cartesian3.ZERO,
Cartesian3.ZERO,
Cartesian3.ZERO,
diff --git a/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js b/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js
index d471effc9773..c83454747c6d 100644
--- a/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js
+++ b/packages/engine/Specs/Scene/Model/ModelStatisticsSpec.js
@@ -15,7 +15,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -27,7 +27,7 @@ describe("Scene/Model/ModelStatistics", function () {
statistics.texturesByteLength = 10;
statistics.propertyTablesByteLength = 10;
statistics._bufferIdSet = { uuid1: true, uuid2: true };
- statistics._textureIdSet = { uuid3: true };
+ statistics._textureIdByteLengths = { uuid3: 1234 };
const map = new AssociativeArray();
map.set("uuid", {});
@@ -41,7 +41,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -78,7 +78,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({ uuid: true });
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -99,7 +99,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({ uuid: true });
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -129,7 +129,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({ uuid1: true, uuid2: true });
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -158,7 +158,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({ uuid: true });
+ expect(statistics._textureIdByteLengths).toEqual({ uuid: 10 });
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -188,7 +188,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({ uuid1: true, uuid2: true });
+ expect(statistics._textureIdByteLengths).toEqual({ uuid1: 2, uuid2: 3 });
expect(statistics._batchTextureIdMap).toEqual(emptyMap);
});
@@ -219,7 +219,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(expectedMap);
// Simulate creating a batch texture
@@ -265,7 +265,7 @@ describe("Scene/Model/ModelStatistics", function () {
expect(statistics.propertyTablesByteLength).toBe(0);
expect(statistics.batchTexturesByteLength).toBe(0);
expect(statistics._bufferIdSet).toEqual({});
- expect(statistics._textureIdSet).toEqual({});
+ expect(statistics._textureIdByteLengths).toEqual({});
expect(statistics._batchTextureIdMap).toEqual(expectedMap);
// Simulate creating first batch texture
diff --git a/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js b/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js
index 11cf22014bd7..ae7deeead20b 100644
--- a/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js
+++ b/packages/engine/Specs/Scene/Model/PointCloudStylingPipelineStageSpec.js
@@ -314,7 +314,9 @@ describe(
"HAS_POINT_CLOUD_SHOW_STYLE",
"COMPUTE_POSITION_WC_STYLE",
]);
- ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, []);
+ ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, [
+ "HAS_POINT_CLOUD_SHOW_STYLE",
+ ]);
ShaderBuilderTester.expectHasVertexUniforms(shaderBuilder, [
"uniform vec4 model_pointCloudParameters;",
diff --git a/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js b/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js
index e50ab6a8cf5c..514f53df64f5 100644
--- a/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js
+++ b/packages/engine/Specs/Scene/Model/loadAndZoomToModelAsync.js
@@ -1,28 +1,12 @@
-import { Model, ImageBasedLighting, Cartesian3 } from "../../../index.js";
+import { Model } from "../../../index.js";
import pollToPromise from "../../../../../Specs/pollToPromise.js";
-// A white ambient light with low intensity
-const defaultIbl = new ImageBasedLighting({
- sphericalHarmonicCoefficients: [
- new Cartesian3(0.35449, 0.35449, 0.35449),
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- ],
-});
-
async function loadAndZoomToModelAsync(options, scene) {
options = {
environmentMapOptions: {
enabled: false, // disable other diffuse lighting by default
...options.environmentMapOptions,
},
- imageBasedLighting: defaultIbl,
...options,
};
diff --git a/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js b/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js
index 3350a5a2eb54..5b6f4d040389 100644
--- a/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js
+++ b/packages/engine/Specs/Scene/PostProcessStageLibrarySpec.js
@@ -392,32 +392,23 @@ describe(
expect(ao.uniforms.intensity).toEqual(3.0);
expect(ao.uniforms.bias).toEqual(0.1);
expect(ao.uniforms.lengthCap).toEqual(0.26);
- expect(ao.uniforms.stepSize).toEqual(1.95);
- expect(ao.uniforms.frustumLength).toEqual(1000.0);
+ expect(ao.uniforms.directionCount).toEqual(8);
+ expect(ao.uniforms.stepCount).toEqual(32);
expect(ao.uniforms.randomTexture).not.toBeDefined();
- expect(ao.uniforms.delta).toEqual(1.0);
- expect(ao.uniforms.sigma).toEqual(2.0);
- expect(ao.uniforms.blurStepSize).toEqual(0.86);
ao.uniforms.ambientOcclusionOnly = true;
ao.uniforms.intensity = 4.0;
ao.uniforms.bias = 0.2;
ao.uniforms.lengthCap = 0.3;
- ao.uniforms.stepSize = 2.0;
- ao.uniforms.frustumLength = 1001.0;
- ao.uniforms.delta = 2.0;
- ao.uniforms.sigma = 3.0;
- ao.uniforms.blurStepSize = 2.0;
+ ao.uniforms.directionCount = 9;
+ ao.uniforms.stepCount = 33;
expect(ao.uniforms.ambientOcclusionOnly).toEqual(true);
expect(ao.uniforms.intensity).toEqual(4.0);
expect(ao.uniforms.bias).toEqual(0.2);
expect(ao.uniforms.lengthCap).toEqual(0.3);
- expect(ao.uniforms.stepSize).toEqual(2.0);
- expect(ao.uniforms.frustumLength).toEqual(1001.0);
- expect(ao.uniforms.delta).toEqual(2.0);
- expect(ao.uniforms.sigma).toEqual(3.0);
- expect(ao.uniforms.blurStepSize).toEqual(2.0);
+ expect(ao.uniforms.directionCount).toEqual(9);
+ expect(ao.uniforms.stepCount).toEqual(33);
});
it("bloom", function () {
diff --git a/packages/engine/Specs/Scene/SceneSpec.js b/packages/engine/Specs/Scene/SceneSpec.js
index 3fc9c31602aa..7f2d30742baa 100644
--- a/packages/engine/Specs/Scene/SceneSpec.js
+++ b/packages/engine/Specs/Scene/SceneSpec.js
@@ -271,26 +271,64 @@ function createPropertyTextureGltfScalar() {
type: "SCALAR",
componentType: "UINT8",
},
+ },
+ },
+ },
+ };
+ const properties = {
+ example_UINT8_SCALAR: {
+ index: 0,
+ texCoord: 0,
+ channels: [0],
+ },
+ };
+ return createPropertyTextureGltf(schema, properties);
+}
+
+/**
+ * Creates the glTF for the normalized 'scalar' test case
+ *
+ * @param {number|undefined} classPropertyOffset The optional offset
+ * that will be defined in the class property definition
+ * @param {number|undefined} classPropertyScale The optional scale
+ * that will be defined in the class property definition
+ * @param {number|undefined} metadataPropertyOffset The optional offset
+ * that will be defined in the property texture property definition
+ * @param {number|undefined} metadataPropertyScale The optional scale
+ * that will be defined in the property texture property definition
+ * @returns The glTF
+ */
+function createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+) {
+ const schema = {
+ id: "ExampleSchema",
+ classes: {
+ exampleClass: {
+ name: "Example class",
+ properties: {
example_normalized_UINT8_SCALAR: {
name: "Example SCALAR property with normalized UINT8 components",
type: "SCALAR",
componentType: "UINT8",
normalized: true,
+ offset: classPropertyOffset,
+ scale: classPropertyScale,
},
},
},
},
};
const properties = {
- example_UINT8_SCALAR: {
- index: 0,
- texCoord: 0,
- channels: [0],
- },
example_normalized_UINT8_SCALAR: {
index: 0,
texCoord: 0,
- channels: [1],
+ channels: [0],
+ offset: metadataPropertyOffset,
+ scale: metadataPropertyScale,
},
};
return createPropertyTextureGltf(schema, properties);
@@ -329,6 +367,57 @@ function createPropertyTextureGltfScalarArray() {
return createPropertyTextureGltf(schema, properties);
}
+/**
+ * Creates the glTF for the 'normalized scalar array' test case
+ *
+ * @param {number[]|undefined} classPropertyOffset The optional offset
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} classPropertyScale The optional scale
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} metadataPropertyOffset The optional offset
+ * that will be defined in the property texture property definition
+ * @param {number[]|undefined} metadataPropertyScale The optional scale
+ * that will be defined in the property texture property definition
+ * @returns The glTF
+ */
+function createPropertyTextureGltfNormalizedScalarArray(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+) {
+ const schema = {
+ id: "ExampleSchema",
+ classes: {
+ exampleClass: {
+ name: "Example class",
+ properties: {
+ example_fixed_length_normalized_UINT8_SCALAR_array: {
+ name: "Example fixed-length SCALAR array property with normalized INT8 components",
+ type: "SCALAR",
+ componentType: "UINT8",
+ array: true,
+ count: 3,
+ normalized: true,
+ offset: classPropertyOffset,
+ scale: classPropertyScale,
+ },
+ },
+ },
+ },
+ };
+ const properties = {
+ example_fixed_length_normalized_UINT8_SCALAR_array: {
+ index: 0,
+ texCoord: 0,
+ channels: [0, 1, 2],
+ offset: metadataPropertyOffset,
+ scale: metadataPropertyScale,
+ },
+ };
+ return createPropertyTextureGltf(schema, properties);
+}
+
/**
* Creates the glTF for the 'vec2' test case
*
@@ -363,9 +452,22 @@ function createPropertyTextureGltfVec2() {
/**
* Creates the glTF for the normalized 'vec2' test case
*
+ * @param {number[]|undefined} classPropertyOffset The optional offset
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} classPropertyScale The optional scale
+ * that will be defined in the class property definition
+ * @param {number[]|undefined} metadataPropertyOffset The optional offset
+ * that will be defined in the property texture property definition
+ * @param {number[]|undefined} metadataPropertyScale The optional scale
+ * that will be defined in the property texture property definition
* @returns The glTF
*/
-function createPropertyTextureGltfNormalizedVec2() {
+function createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+) {
const schema = {
id: "ExampleSchema",
classes: {
@@ -377,6 +479,8 @@ function createPropertyTextureGltfNormalizedVec2() {
type: "VEC2",
componentType: "UINT8",
normalized: true,
+ offset: classPropertyOffset,
+ scale: classPropertyScale,
},
},
},
@@ -387,6 +491,8 @@ function createPropertyTextureGltfNormalizedVec2() {
index: 0,
texCoord: 0,
channels: [0, 1],
+ offset: metadataPropertyOffset,
+ scale: metadataPropertyScale,
},
};
return createPropertyTextureGltf(schema, properties);
@@ -3115,7 +3221,16 @@ describe(
const schemaId = undefined;
const className = "exampleClass";
const propertyName = "example_normalized_UINT8_SCALAR";
- const gltf = createPropertyTextureGltfScalar();
+ const classPropertyOffset = undefined;
+ const classPropertyScale = undefined;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
const canvasSizeX = textureSizeX * canvasScaling;
const canvasSizeY = textureSizeY * canvasScaling;
@@ -3145,16 +3260,16 @@ describe(
schemaId,
className,
propertyName,
- 3,
0,
+ 1,
);
const actualMetadataValue2 = pickMetadataAt(
scene,
schemaId,
className,
propertyName,
- 6,
0,
+ 2,
);
const expectedMetadataValue0 = 0.0;
const expectedMetadataValue1 = 0.5;
@@ -3175,6 +3290,165 @@ describe(
scene.destroyForSpecs();
});
+ it("picks normalized UINT8 SCALAR from a property texture with offset and scale in class property", async function () {
+ if (webglStub) {
+ return;
+ }
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_SCALAR";
+ const classPropertyOffset = 100.0;
+ const classPropertyScale = 2.0;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 2,
+ );
+ const expectedMetadataValue0 =
+ classPropertyOffset + classPropertyScale * 0.0;
+ const expectedMetadataValue1 =
+ classPropertyOffset + classPropertyScale * 0.5;
+ const expectedMetadataValue2 =
+ classPropertyOffset + classPropertyScale * 1.0;
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
+ it("picks normalized UINT8 SCALAR from a property texture with offset and scale in property texture property", async function () {
+ if (webglStub) {
+ return;
+ }
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_SCALAR";
+ const classPropertyOffset = 100.0;
+ const classPropertyScale = 200.0;
+ // These should override the values from the class property:
+ const metadataPropertyOffset = 200.0;
+ const metadataPropertyScale = 3.0;
+ const gltf = createPropertyTextureGltfNormalizedScalar(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 2,
+ );
+ const expectedMetadataValue0 =
+ metadataPropertyOffset + metadataPropertyScale * 0.0;
+ const expectedMetadataValue1 =
+ metadataPropertyOffset + metadataPropertyScale * 0.5;
+ const expectedMetadataValue2 =
+ metadataPropertyOffset + metadataPropertyScale * 1.0;
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
it("picks fixed length UINT8 SCALAR array from a property texture", async function () {
if (webglStub) {
return;
@@ -3242,6 +3516,82 @@ describe(
scene.destroyForSpecs();
});
+ it("picks fixed length normalized UINT8 SCALAR array from a property texture", async function () {
+ if (webglStub) {
+ return;
+ }
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_fixed_length_normalized_UINT8_SCALAR_array";
+ const classPropertyOffset = undefined;
+ const classPropertyScale = undefined;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedScalarArray(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 1,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 2,
+ 2,
+ );
+ const expectedMetadataValue0 = [0, 0, 0];
+ const expectedMetadataValue1 = [0.5, 0, 0.5];
+ const expectedMetadataValue2 = [1.0, 0, 1.0];
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
it("picks UINT8 VEC2 from a property texture", async function () {
if (webglStub) {
return;
@@ -3318,7 +3668,16 @@ describe(
const schemaId = undefined;
const className = "exampleClass";
const propertyName = "example_normalized_UINT8_VEC2";
- const gltf = createPropertyTextureGltfNormalizedVec2();
+ const classPropertyOffset = undefined;
+ const classPropertyScale = undefined;
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
const canvasSizeX = textureSizeX * canvasScaling;
const canvasSizeY = textureSizeY * canvasScaling;
@@ -3379,6 +3738,181 @@ describe(
scene.destroyForSpecs();
});
+ it("picks normalized UINT8 VEC2 from a property texture with offset and scale in class property", async function () {
+ if (webglStub) {
+ return;
+ }
+
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_VEC2";
+ const classPropertyOffset = [100.0, 200.0];
+ const classPropertyScale = [2.0, 3.0];
+ const metadataPropertyOffset = undefined;
+ const metadataPropertyScale = undefined;
+ const gltf = createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 1,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 2,
+ 2,
+ );
+
+ const expectedMetadataValue0 = new Cartesian2(
+ classPropertyOffset[0] + classPropertyScale[0] * 0.0,
+ classPropertyOffset[1] + classPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue1 = new Cartesian2(
+ classPropertyOffset[0] + classPropertyScale[0] * 0.5,
+ classPropertyOffset[1] + classPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue2 = new Cartesian2(
+ classPropertyOffset[0] + classPropertyScale[0] * 1.0,
+ classPropertyOffset[1] + classPropertyScale[1] * 0.0,
+ );
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
+ it("picks normalized UINT8 VEC2 from a property texture with offset and scale in property texture property", async function () {
+ if (webglStub) {
+ return;
+ }
+
+ const schemaId = undefined;
+ const className = "exampleClass";
+ const propertyName = "example_normalized_UINT8_VEC2";
+ const classPropertyOffset = [100.0, 200.0];
+ const classPropertyScale = [2.0, 3.0];
+ // These should override the values from the class property:
+ const metadataPropertyOffset = [300.0, 400.0];
+ const metadataPropertyScale = [4.0, 5.0];
+ const gltf = createPropertyTextureGltfNormalizedVec2(
+ classPropertyOffset,
+ classPropertyScale,
+ metadataPropertyOffset,
+ metadataPropertyScale,
+ );
+
+ const canvasSizeX = textureSizeX * canvasScaling;
+ const canvasSizeY = textureSizeY * canvasScaling;
+ const scene = createScene({
+ canvas: createCanvas(canvasSizeX, canvasSizeY),
+ contextOptions: {
+ requestWebgl1: true,
+ },
+ });
+
+ await loadAsModel(scene, gltf);
+ fitCameraToUnitSquare(scene.camera);
+
+ scene.initializeFrame();
+ scene.render(defaultDate);
+
+ const actualMetadataValue0 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 0,
+ 0,
+ );
+ const actualMetadataValue1 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 1,
+ 1,
+ );
+ const actualMetadataValue2 = pickMetadataAt(
+ scene,
+ schemaId,
+ className,
+ propertyName,
+ 2,
+ 2,
+ );
+
+ const expectedMetadataValue0 = new Cartesian2(
+ metadataPropertyOffset[0] + metadataPropertyScale[0] * 0.0,
+ metadataPropertyOffset[1] + metadataPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue1 = new Cartesian2(
+ metadataPropertyOffset[0] + metadataPropertyScale[0] * 0.5,
+ metadataPropertyOffset[1] + metadataPropertyScale[1] * 0.0,
+ );
+ const expectedMetadataValue2 = new Cartesian2(
+ metadataPropertyOffset[0] + metadataPropertyScale[0] * 1.0,
+ metadataPropertyOffset[1] + metadataPropertyScale[1] * 0.0,
+ );
+
+ expect(actualMetadataValue0).toEqualEpsilon(
+ expectedMetadataValue0,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue1).toEqualEpsilon(
+ expectedMetadataValue1,
+ propertyValueEpsilon,
+ );
+ expect(actualMetadataValue2).toEqualEpsilon(
+ expectedMetadataValue2,
+ propertyValueEpsilon,
+ );
+ scene.destroyForSpecs();
+ });
+
it("picks UINT8 VEC3 from a property texture", async function () {
if (webglStub) {
return;
diff --git a/packages/engine/Specs/Scene/ShadowMapSpec.js b/packages/engine/Specs/Scene/ShadowMapSpec.js
index 2a66f528b10d..1b142d13152b 100644
--- a/packages/engine/Specs/Scene/ShadowMapSpec.js
+++ b/packages/engine/Specs/Scene/ShadowMapSpec.js
@@ -11,7 +11,6 @@ import {
HeadingPitchRange,
HeadingPitchRoll,
HeightmapTerrainData,
- ImageBasedLighting,
JulianDate,
Math as CesiumMath,
Matrix4,
@@ -282,26 +281,11 @@ describe(
}
async function loadModel(options) {
- // A white ambient light with low intensity
- const defaultIbl = new ImageBasedLighting({
- sphericalHarmonicCoefficients: [
- new Cartesian3(0.35449, 0.35449, 0.35449),
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- Cartesian3.ZERO,
- ],
- });
const model = scene.primitives.add(
await Model.fromGltfAsync({
environmentMapOptions: {
enabled: false,
},
- imageBasedLighting: defaultIbl,
...options,
}),
);
diff --git a/packages/engine/Specs/Scene/SkyBoxSpec.js b/packages/engine/Specs/Scene/SkyBoxSpec.js
index 4db7c8702d18..9691fb035594 100644
--- a/packages/engine/Specs/Scene/SkyBoxSpec.js
+++ b/packages/engine/Specs/Scene/SkyBoxSpec.js
@@ -1,6 +1,7 @@
-import { Resource, SceneMode, SkyBox } from "../../index.js";
+import { defined, Resource, SceneMode, SkyBox } from "../../index.js";
import createScene from "../../../../Specs/createScene.js";
+import pollToPromise from "../../../../Specs/pollToPromise.js";
describe(
"Scene/SkyBox",
@@ -10,8 +11,6 @@ describe(
let loadedImage;
beforeAll(function () {
- scene = createScene();
-
return Resource.fetchImage("./Data/Images/Blue.png").then(
function (image) {
loadedImage = image;
@@ -19,17 +18,15 @@ describe(
);
});
- afterAll(function () {
- scene.destroyForSpecs();
- });
-
beforeEach(function () {
+ scene = createScene();
scene.mode = SceneMode.SCENE3D;
});
afterEach(function () {
skyBox = skyBox && skyBox.destroy();
scene.skyBox = undefined;
+ scene.destroyForSpecs();
});
it("draws a sky box from Images", function () {
@@ -355,6 +352,32 @@ describe(
return scene.render();
}).toThrowDeveloperError();
});
+
+ it("defers throwing error when Resources fail to load until next call to update", async () => {
+ const error = new Error("intentional error for test");
+ spyOn(Resource.prototype, "fetchImage").and.rejectWith(error);
+
+ skyBox = new SkyBox({
+ sources: {
+ positiveX: "./Data/Images/Blue.png",
+ negativeX: "./Data/Images/Blue.png",
+ positiveY: "./Data/Images/Blue.png",
+ negativeY: "./Data/Images/Blue.png",
+ positiveZ: "./Data/Images/Blue.png",
+ negativeZ: "./Data/Images/Blue.png",
+ },
+ });
+
+ scene.frameState.passes.render = true;
+ scene.skyBox = skyBox;
+ skyBox.update(scene.frameState);
+
+ await pollToPromise(() => defined(skyBox._cubeMap) || skyBox._hasError);
+
+ expect(skyBox._hasError).toBeTrue();
+ expect(skyBox._error).toEqual(error);
+ expect(() => skyBox.update(scene.frameState)).toThrow(error);
+ });
},
"WebGL",
);
diff --git a/packages/engine/package.json b/packages/engine/package.json
index acc1c285479d..f95090f5176f 100644
--- a/packages/engine/package.json
+++ b/packages/engine/package.json
@@ -1,6 +1,6 @@
{
"name": "@cesium/engine",
- "version": "12.0.0",
+ "version": "13.0.0",
"description": "CesiumJS is a JavaScript library for creating 3D globes and 2D maps in a web browser without a plugin.",
"keywords": [
"3D",
diff --git a/packages/widgets/Source/Viewer/Viewer.js b/packages/widgets/Source/Viewer/Viewer.js
index 4574ef6aadc7..b00646389215 100644
--- a/packages/widgets/Source/Viewer/Viewer.js
+++ b/packages/widgets/Source/Viewer/Viewer.js
@@ -18,6 +18,7 @@ import {
Math as CesiumMath,
Property,
ScreenSpaceEventType,
+ IonGeocoderService,
} from "@cesium/engine";
import Animation from "../Animation/Animation.js";
import AnimationViewModel from "../Animation/AnimationViewModel.js";
@@ -280,7 +281,7 @@ function enableVRUI(viewer, enabled) {
* @property {boolean} [baseLayerPicker=true] If set to false, the BaseLayerPicker widget will not be created.
* @property {boolean} [fullscreenButton=true] If set to false, the FullscreenButton widget will not be created.
* @property {boolean} [vrButton=false] If set to true, the VRButton widget will be created.
- * @property {boolean|GeocoderService[]} [geocoder=true] If set to false, the Geocoder widget will not be created.
+ * @property {boolean|IonGeocodeProviderType|GeocoderService[]} [geocoder=IonGeocodeProviderType.DEFAULT] The geocoding service or services to use when searching with the Geocoder widget. If set to false, the Geocoder widget will not be created.
* @property {boolean} [homeButton=true] If set to false, the HomeButton widget will not be created.
* @property {boolean} [infoBox=true] If set to false, the InfoBox widget will not be created.
* @property {boolean} [sceneModePicker=true] If set to false, the SceneModePicker widget will not be created.
@@ -295,7 +296,7 @@ function enableVRUI(viewer, enabled) {
* @property {ProviderViewModel[]} [imageryProviderViewModels=createDefaultImageryProviderViewModels()] The array of ProviderViewModels to be selectable from the BaseLayerPicker. This value is only valid if `baseLayerPicker` is set to true.
* @property {ProviderViewModel} [selectedTerrainProviderViewModel] The view model for the current base terrain layer, if not supplied the first available base layer is used. This value is only valid if `baseLayerPicker` is set to true.
* @property {ProviderViewModel[]} [terrainProviderViewModels=createDefaultTerrainProviderViewModels()] The array of ProviderViewModels to be selectable from the BaseLayerPicker. This value is only valid if `baseLayerPicker` is set to true.
- * @property {ImageryLayer|false} [baseLayer=ImageryLayer.fromWorldImagery()] The bottommost imagery layer applied to the globe. If set to