Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Solve the issue of #11877 #11907

Open
wants to merge 11 commits into
base: main
Choose a base branch
from
Open

Solve the issue of #11877 #11907

Changes from 2 commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
af0a45a
modify the terrain adjust condition
HapDragon Mar 28, 2024
ace2829
Merge branch 'CesiumGS:main' into main
HapDragon Mar 28, 2024
3354f5c
Merge branch 'CesiumGS:main' into main
HapDragon Jul 10, 2024
13cdb2d
Merge branch 'CesiumGS:main' into main
HapDragon Dec 25, 2024
ca2e7c0
change adjustHeightForTerrain function
HapDragon Dec 27, 2024
742f5a7
Update ScreenSpaceCameraController.js
HapDragon Dec 27, 2024
d61f710
Update ScreenSpaceCameraController.js
HapDragon Dec 27, 2024
235c08f
Update ScreenSpaceCameraController.js
HapDragon Dec 27, 2024
c542b28
Update ScreenSpaceCameraController.js
HapDragon Jan 2, 2025
088f005
Update ScreenSpaceCameraControllerSpec.js
HapDragon Jan 2, 2025
31544b9
Update ScreenSpaceCameraController.js
HapDragon Jan 2, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
54 changes: 31 additions & 23 deletions packages/engine/Source/Scene/ScreenSpaceCameraController.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2855,6 +2855,7 @@ function update3D(controller) {

const scratchAdjustHeightTransform = new Matrix4();
const scratchAdjustHeightCartographic = new Cartographic();
const transformOrigin = new Cartesian3();

function adjustHeightForTerrain(controller, cameraChanged) {
controller._adjustedHeightForTerrain = true;
Expand Down Expand Up @@ -2888,31 +2889,38 @@ function adjustHeightForTerrain(controller, cameraChanged) {

let heightUpdated = false;
if (cartographic.height < controller._minimumCollisionTerrainHeight) {
const globeHeight = controller._scene.globeHeight;
if (defined(globeHeight)) {
const height = globeHeight + controller.minimumZoomDistance;
const difference = globeHeight - controller._lastGlobeHeight;
const percentDifference = difference / controller._lastGlobeHeight;

// Unless the camera has been moved by user input, to avoid big jumps during tile loads
// only make height updates when the globe height has been fairly stable across several frames
if (
cartographic.height < height &&
(cameraChanged || Math.abs(percentDifference) <= 0.1)
) {
cartographic.height = height;
if (mode === SceneMode.SCENE3D) {
ellipsoid.cartographicToCartesian(cartographic, camera.position);
} else {
projection.project(cartographic, camera.position);
let transformOriginLen = Infinity;
if (defined(transform)) {
Matrix4.getTranslation(transform, transformOrigin);
transformOriginLen = Cartesian3.magnitude(transformOrigin);
}
if (transformOriginLen > controller._minimumCollisionTerrainHeight) {
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I'm not sure about the use of controller._minimumCollisionTerrainHeight here. That value was design to be the height above the ellipsoid surface, not the absolute value.

Additionally, that put us in this strange "middle ground" where the camera still re-orients strangely, like in this example below:

const viewer = new Cesium.Viewer("cesiumContainer", {
  //globe: false
});

const url = "../../SampleData/models/CesiumAir/Cesium_Air.glb";
const position = new Cesium.Cartesian3(0.0, 100000.0, 0.0);
const orientation = new Cesium.Quaternion(0.0, 0.0, 0.0, 1.0);

const entity = viewer.entities.add({
  name: url,
  position: position,
  orientation: orientation,
  model: {
    uri: url,
  },
});

viewer.camera.lookAt(
  new Cesium.Cartesian3(0.0, 100000.0, 1), 
  new Cesium.Cartesian3(0, 50, 0));

How would you feel about instead using a percentage of the ellipsoid radius? That will ensure we scale to other ellipsoids if needed without having to manually set a value.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Hello ，
At line 2897, the comparision: controller._minimumCollisionTerrainHeight, it seemed should not be such a value. What I thought is to put a threshold to specify the maximum centric length of cartesian3, then let any point in a centric ball with the threshold radius will not do the height adjustment (if there is a transform upon the camera).

Thanks for your advice, I am a little confused about using a percentage of the ellipsoid radius. Does it mean using percentage of ellipsoid radius as the height threshold test?

I modify the adjustHeightForTerrain function again: it will avoid the problem in your example above and issue of #11877 as well：

function adjustHeightForTerrain(controller, cameraChanged) {
  controller._adjustedHeightForTerrain = true;

  const scene = controller._scene;
  const mode = scene.mode;
  const globe = scene.globe;

  if (mode === SceneMode.SCENE2D || mode === SceneMode.MORPHING) {
    return;
  }

  const camera = scene.camera;
  const ellipsoid = defaultValue(globe?.ellipsoid, Ellipsoid.WGS84);
  const projection = scene.mapProjection;


  let transform;
  let mag;
  if (!Matrix4.equals(camera.transform, Matrix4.IDENTITY)) {
    transform = Matrix4.clone(camera.transform, scratchAdjustHeightTransform);
    mag = Cartesian3.magnitude(camera.position);
    camera._setTransform(Matrix4.IDENTITY);
  }

  const cartographic = scratchAdjustHeightCartographic;
  if (mode === SceneMode.SCENE3D) {
    ellipsoid.cartesianToCartographic(camera.position, cartographic);
  } else {
    projection.unproject(camera.position, cartographic);
  }

  let heightUpdated = false; 
  if (cartographic.height < controller._minimumCollisionTerrainHeight) {  
    if((defined(transform)&&cartographic.height>-ellipsoid.maximumRadius*0.3)||!defined(transform)){
      const globeHeight = controller._scene.globeHeight;
      if (defined(globeHeight)) {
        const height = globeHeight + controller.minimumZoomDistance;
        const difference = globeHeight - controller._lastGlobeHeight;
        const percentDifference = difference / controller._lastGlobeHeight;
  
        // Unless the camera has been moved by user input, to avoid big jumps during tile loads
        // only make height updates when the globe height has been fairly stable across several frames
        if (
          cartographic.height < height &&
          (cameraChanged || Math.abs(percentDifference) <= 0.1)
        ) {
          cartographic.height = height;
          if (mode === SceneMode.SCENE3D) {
            ellipsoid.cartographicToCartesian(cartographic, camera.position);
          } else {
            projection.project(cartographic, camera.position);
          }
          heightUpdated = true;
        }
  
        if (cameraChanged || Math.abs(percentDifference) <= 0.1) {
          controller._lastGlobeHeight = globeHeight;
        } else {
          controller._lastGlobeHeight += difference * 0.1;
        }
      }
   }  
  }

  if (defined(transform)) {
    camera._setTransform(transform);
    if (heightUpdated) {
      Cartesian3.normalize(camera.position, camera.position);
      Cartesian3.negate(camera.position, camera.direction);
      Cartesian3.multiplyByScalar(
        camera.position,
        Math.max(mag, controller.minimumZoomDistance),
        camera.position
      );
      Cartesian3.normalize(camera.direction, camera.direction);
      Cartesian3.cross(camera.direction, camera.up, camera.right);
      Cartesian3.cross(camera.right, camera.direction, camera.up);
    }
  }
}

It use this code to filter point in deep underground areas:
(defined(transform)&&cartographic.height>-ellipsoid.maximumRadius*0.3)

const globeHeight = controller._scene.globeHeight;
if (defined(globeHeight)) {
const height = globeHeight + controller.minimumZoomDistance;
const difference = globeHeight - controller._lastGlobeHeight;
const percentDifference = difference / controller._lastGlobeHeight;

// Unless the camera has been moved by user input, to avoid big jumps during tile loads
// only make height updates when the globe height has been fairly stable across several frames
if (
cartographic.height < height &&
(cameraChanged || Math.abs(percentDifference) <= 0.1)
) {
cartographic.height = height;
if (mode === SceneMode.SCENE3D) {
ellipsoid.cartographicToCartesian(cartographic, camera.position);
} else {
projection.project(cartographic, camera.position);
}
heightUpdated = true;
}
heightUpdated = true;
}

if (cameraChanged || Math.abs(percentDifference) <= 0.1) {
controller._lastGlobeHeight = globeHeight;
} else {
controller._lastGlobeHeight += difference * 0.1;
if (cameraChanged || Math.abs(percentDifference) <= 0.1) {
controller._lastGlobeHeight = globeHeight;
} else {
controller._lastGlobeHeight += difference * 0.1;
}
}
}
}
Expand Down
Loading