@loaders.gl/tiles 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/tileset/helpers/frame-state.js

@@ -3,107 +3,126 @@ import { CullingVolume, Plane } from '@math.gl/culling';
 import { Ellipsoid } from '@math.gl/geospatial';
 const scratchVector = new Vector3();
 const scratchPosition = new Vector3();
-const cullingVolume = new CullingVolume([new Plane(), new Plane(), new Plane(), new Plane(), new Plane(), new Plane()]);
+const cullingVolume = new CullingVolume([
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane()
+]);
+// Extracts a frame state appropriate for tile culling from a deck.gl viewport
+// TODO - this could likely be generalized and merged back into deck.gl for other culling scenarios
 export function getFrameState(viewport, frameNumber) {
-  const {
-    cameraDirection,
-    cameraUp,
-    height
-  } = viewport;
-  const {
-    metersPerUnit
-  } = viewport.distanceScales;
-  const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
-  const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
-  const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-  const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new Vector3());
-  const cameraDirectionCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))).normalize();
-  const cameraUpCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))).normalize();
-  commonSpacePlanesToWGS84(viewport);
-  const ViewportClass = viewport.constructor;
-  const {
-    longitude,
-    latitude,
-    width,
-    bearing,
-    zoom
-  } = viewport;
-  const topDownViewport = new ViewportClass({
-    longitude,
-    latitude,
-    height,
-    width,
-    bearing,
-    zoom,
-    pitch: 0
-  });
-  return {
-    camera: {
-      position: cameraPositionCartesian,
-      direction: cameraDirectionCartesian,
-      up: cameraUpCartesian
-    },
-    viewport,
-    topDownViewport,
-    height,
-    cullingVolume,
-    frameNumber,
-    sseDenominator: 1.15
-  };
+    // Traverse and and request. Update _selectedTiles so that we know what to render.
+    // Traverse and and request. Update _selectedTiles so that we know what to render.
+    const { cameraDirection, cameraUp, height } = viewport;
+    const { metersPerUnit } = viewport.distanceScales;
+    // TODO - Ellipsoid.eastNorthUpToFixedFrame() breaks on raw array, create a Vector.
+    // TODO - Ellipsoid.eastNorthUpToFixedFrame() takes a cartesian, is that intuitive?
+    const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
+    const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
+    const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
+    const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new Vector3());
+    // These should still be normalized as the transform has scale 1 (goes from meters to meters)
+    const cameraDirectionCartesian = new Vector3(
+    // @ts-ignore
+    enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))).normalize();
+    const cameraUpCartesian = new Vector3(
+    // @ts-ignore
+    enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))).normalize();
+    commonSpacePlanesToWGS84(viewport);
+    const ViewportClass = viewport.constructor;
+    const { longitude, latitude, width, bearing, zoom } = viewport;
+    // @ts-ignore
+    const topDownViewport = new ViewportClass({
+        longitude,
+        latitude,
+        height,
+        width,
+        bearing,
+        zoom,
+        pitch: 0
+    });
+    // TODO: make a file/class for frameState and document what needs to be attached to this so that traversal can function
+    return {
+        camera: {
+            position: cameraPositionCartesian,
+            direction: cameraDirectionCartesian,
+            up: cameraUpCartesian
+        },
+        viewport,
+        topDownViewport,
+        height,
+        cullingVolume,
+        frameNumber, // TODO: This can be the same between updates, what number is unique for between updates?
+        sseDenominator: 1.15 // Assumes fovy = 60 degrees
+    };
 }
+/**
+ * Limit `tiles` array length with `maximumTilesSelected` number.
+ * The criteria for this filtering is distance of a tile center
+ * to the `frameState.viewport`'s longitude and latitude
+ * @param tiles - tiles array to filter
+ * @param frameState - frameState to calculate distances
+ * @param maximumTilesSelected - maximal amount of tiles in the output array
+ * @returns new tiles array
+ */
 export function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
-  if (maximumTilesSelected === 0 || tiles.length <= maximumTilesSelected) {
-    return [tiles, []];
-  }
-  const tuples = [];
-  const {
-    longitude: viewportLongitude,
-    latitude: viewportLatitude
-  } = frameState.viewport;
-  for (const [index, tile] of tiles.entries()) {
-    const [longitude, latitude] = tile.header.mbs;
-    const deltaLon = Math.abs(viewportLongitude - longitude);
-    const deltaLat = Math.abs(viewportLatitude - latitude);
-    const distance = Math.sqrt(deltaLat * deltaLat + deltaLon * deltaLon);
-    tuples.push([index, distance]);
-  }
-  const tuplesSorted = tuples.sort((a, b) => a[1] - b[1]);
-  const selectedTiles = [];
-  for (let i = 0; i < maximumTilesSelected; i++) {
-    selectedTiles.push(tiles[tuplesSorted[i][0]]);
-  }
-  const unselectedTiles = [];
-  for (let i = maximumTilesSelected; i < tuplesSorted.length; i++) {
-    unselectedTiles.push(tiles[tuplesSorted[i][0]]);
-  }
-  return [selectedTiles, unselectedTiles];
+    if (maximumTilesSelected === 0 || tiles.length <= maximumTilesSelected) {
+        return [tiles, []];
+    }
+    // Accumulate distances in couples array: [tileIndex: number, distanceToViewport: number]
+    const tuples = [];
+    const { longitude: viewportLongitude, latitude: viewportLatitude } = frameState.viewport;
+    for (const [index, tile] of tiles.entries()) {
+        const [longitude, latitude] = tile.header.mbs;
+        const deltaLon = Math.abs(viewportLongitude - longitude);
+        const deltaLat = Math.abs(viewportLatitude - latitude);
+        const distance = Math.sqrt(deltaLat * deltaLat + deltaLon * deltaLon);
+        tuples.push([index, distance]);
+    }
+    const tuplesSorted = tuples.sort((a, b) => a[1] - b[1]);
+    const selectedTiles = [];
+    for (let i = 0; i < maximumTilesSelected; i++) {
+        selectedTiles.push(tiles[tuplesSorted[i][0]]);
+    }
+    const unselectedTiles = [];
+    for (let i = maximumTilesSelected; i < tuplesSorted.length; i++) {
+        unselectedTiles.push(tiles[tuplesSorted[i][0]]);
+    }
+    return [selectedTiles, unselectedTiles];
 }
 function commonSpacePlanesToWGS84(viewport) {
-  const frustumPlanes = viewport.getFrustumPlanes();
-  const nearCenterCommon = closestPointOnPlane(frustumPlanes.near, viewport.cameraPosition);
-  const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
-  const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition);
-  let i = 0;
-  cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian));
-  for (const dir in frustumPlanes) {
-    if (dir === 'near') {
-      continue;
+    // Extract frustum planes based on current view.
+    const frustumPlanes = viewport.getFrustumPlanes();
+    // Get the near/far plane centers
+    const nearCenterCommon = closestPointOnPlane(frustumPlanes.near, viewport.cameraPosition);
+    const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+    const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition);
+    let i = 0;
+    cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian));
+    for (const dir in frustumPlanes) {
+        if (dir === 'near') {
+            continue; // eslint-disable-line no-continue
+        }
+        const plane = frustumPlanes[dir];
+        const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition);
+        const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition);
+        cullingVolume.planes[i++].fromPointNormal(cartesianPos, 
+        // Want the normal to point into the frustum since that's what culling expects
+        scratchVector.copy(nearCenterCartesian).subtract(cartesianPos));
     }
-    const plane = frustumPlanes[dir];
-    const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition);
-    const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition);
-    cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector.copy(nearCenterCartesian).subtract(cartesianPos));
-  }
 }
-function closestPointOnPlane(plane, refPoint) {
-  let out = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Vector3();
-  const distanceToRef = plane.normal.dot(refPoint);
-  out.copy(plane.normal).scale(plane.distance - distanceToRef).add(refPoint);
-  return out;
+function closestPointOnPlane(plane, refPoint, out = new Vector3()) {
+    const distanceToRef = plane.normal.dot(refPoint);
+    out
+        .copy(plane.normal)
+        .scale(plane.distance - distanceToRef)
+        .add(refPoint);
+    return out;
 }
-function worldToCartesian(viewport, point) {
-  let out = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Vector3();
-  const cartographicPos = viewport.unprojectPosition(point);
-  return Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
+function worldToCartesian(viewport, point, out = new Vector3()) {
+    const cartographicPos = viewport.unprojectPosition(point);
+    return Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
 }
-//# sourceMappingURL=frame-state.js.map

package/dist/tileset/helpers/i3s-lod.d.ts

@@ -1,5 +1,5 @@
-import { Tile3D } from '../tile-3d';
-import { FrameState } from './frame-state';
+import { Tile3D } from "../tile-3d.js";
+import { FrameState } from "./frame-state.js";
 /**
  * For the maxScreenThreshold error metric, maxError means that you should replace the node with it's children
    as soon as the nodes bounding sphere has a screen radius larger than maxError pixels.

package/dist/tileset/helpers/i3s-lod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i3s-lod.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/i3s-lod.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,MAAM,EAAC,MAAM,YAAY,CAAC;AAClC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAUzC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAczF;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CA6C/E"}
+{"version":3,"file":"i3s-lod.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/i3s-lod.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,MAAM,EAAC,sBAAmB;AAClC,OAAO,EAAC,UAAU,EAAC,yBAAsB;AAUzC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAczF;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CA6C/E"}

package/dist/tileset/helpers/i3s-lod.js

@@ -1,3 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { Matrix4, Vector3 } from '@math.gl/core';
 import { Ellipsoid } from '@math.gl/geospatial';
 const cameraPositionCartesian = new Vector3();
@@ -7,47 +10,73 @@ const extraVertexEnu = new Vector3();
 const projectedOriginVector = new Vector3();
 const enuToCartesianMatrix = new Matrix4();
 const cartesianToEnuMatrix = new Matrix4();
+/**
+ * For the maxScreenThreshold error metric, maxError means that you should replace the node with it's children
+   as soon as the nodes bounding sphere has a screen radius larger than maxError pixels.
+   In this sense a value of 0 means you should always load it's children,
+   or if it's a leaf node, you should always display it.
+ * @param tile
+ * @param frameState
+ * @returns
+ */
 export function getLodStatus(tile, frameState) {
-  if (tile.lodMetricValue === 0 || isNaN(tile.lodMetricValue)) {
-    return 'DIG';
-  }
-  const screenSize = 2 * getProjectedRadius(tile, frameState);
-  if (screenSize < 2) {
+    if (tile.lodMetricValue === 0 || isNaN(tile.lodMetricValue)) {
+        return 'DIG';
+    }
+    const screenSize = 2 * getProjectedRadius(tile, frameState);
+    if (screenSize < 2) {
+        return 'OUT';
+    }
+    if (!tile.header.children || screenSize <= tile.lodMetricValue) {
+        return 'DRAW';
+    }
+    else if (tile.header.children) {
+        return 'DIG';
+    }
     return 'OUT';
-  }
-  if (!tile.header.children || screenSize <= tile.lodMetricValue) {
-    return 'DRAW';
-  } else if (tile.header.children) {
-    return 'DIG';
-  }
-  return 'OUT';
 }
+/**
+ * Calculate size of MBS radius projected on the screen plane
+ * @param tile
+ * @param frameState
+ * @returns
+ */
+// eslint-disable-next-line max-statements
 export function getProjectedRadius(tile, frameState) {
-  const {
-    topDownViewport: viewport
-  } = frameState;
-  const mbsLat = tile.header.mbs[1];
-  const mbsLon = tile.header.mbs[0];
-  const mbsZ = tile.header.mbs[2];
-  const mbsR = tile.header.mbs[3];
-  const mbsCenterCartesian = [...tile.boundingVolume.center];
-  const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-  Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
-  toEye.copy(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
-  Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);
-  cartesianToEnuMatrix.copy(enuToCartesianMatrix).invert();
-  cameraPositionEnu.copy(cameraPositionCartesian).transform(cartesianToEnuMatrix);
-  const projection = Math.sqrt(cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]);
-  const extraZ = projection * projection / cameraPositionEnu[2];
-  extraVertexEnu.copy([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);
-  const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);
-  const extraVectorCartesian = extraVertexCartesian.subtract(mbsCenterCartesian).normalize();
-  const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);
-  const sphereMbsBorderVertexCartesian = radiusVector.add(mbsCenterCartesian);
-  const sphereMbsBorderVertexCartographic = Ellipsoid.WGS84.cartesianToCartographic(sphereMbsBorderVertexCartesian);
-  const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);
-  const projectedMbsBorderVertex = viewport.project(sphereMbsBorderVertexCartographic);
-  const projectedRadius = projectedOriginVector.copy(projectedOrigin).subtract(projectedMbsBorderVertex).magnitude();
-  return projectedRadius;
+    const { topDownViewport: viewport } = frameState;
+    const mbsLat = tile.header.mbs[1];
+    const mbsLon = tile.header.mbs[0];
+    const mbsZ = tile.header.mbs[2];
+    const mbsR = tile.header.mbs[3];
+    const mbsCenterCartesian = [...tile.boundingVolume.center];
+    const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
+    Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
+    // ---------------------------
+    // Calculate mbs border vertex
+    // ---------------------------
+    toEye.copy(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
+    // Add extra vector to form plane
+    Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);
+    cartesianToEnuMatrix.copy(enuToCartesianMatrix).invert();
+    cameraPositionEnu.copy(cameraPositionCartesian).transform(cartesianToEnuMatrix);
+    // Mean Proportionals in Right Triangles - Altitude rule
+    // https://mathbitsnotebook.com/Geometry/RightTriangles/RTmeanRight.html
+    const projection = Math.sqrt(cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]);
+    const extraZ = (projection * projection) / cameraPositionEnu[2];
+    extraVertexEnu.copy([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);
+    const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);
+    const extraVectorCartesian = extraVertexCartesian.subtract(mbsCenterCartesian).normalize();
+    // We need radius vector orthogonal to toEye vector
+    const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);
+    const sphereMbsBorderVertexCartesian = radiusVector.add(mbsCenterCartesian);
+    const sphereMbsBorderVertexCartographic = Ellipsoid.WGS84.cartesianToCartographic(sphereMbsBorderVertexCartesian);
+    // ---------------------------
+    // Project center vertex and border vertex and calculate projected radius of MBS
+    const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);
+    const projectedMbsBorderVertex = viewport.project(sphereMbsBorderVertexCartographic);
+    const projectedRadius = projectedOriginVector
+        .copy(projectedOrigin)
+        .subtract(projectedMbsBorderVertex)
+        .magnitude();
+    return projectedRadius;
 }
-//# sourceMappingURL=i3s-lod.js.map

package/dist/tileset/helpers/tiles-3d-lod.js

@@ -1,3 +1,12 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+// TODO - Dynamic screen space error provides an optimization when looking at
+// tilesets from above
+/* eslint-disable */
+// @ts-nocheck
 import { Matrix4, Vector3, clamp } from '@math.gl/core';
 const scratchPositionNormal = new Vector3();
 const scratchCartographic = new Vector3();
@@ -5,96 +14,99 @@ const scratchMatrix = new Matrix4();
 const scratchCenter = new Vector3();
 const scratchPosition = new Vector3();
 const scratchDirection = new Vector3();
-export function calculateDynamicScreenSpaceError(root, _ref) {
-  let {
-    camera,
-    mapProjection
-  } = _ref;
-  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  const {
-    dynamicScreenSpaceErrorHeightFalloff = 0.25,
-    dynamicScreenSpaceErrorDensity = 0.00278
-  } = options;
-  let up;
-  let direction;
-  let height;
-  let minimumHeight;
-  let maximumHeight;
-  const tileBoundingVolume = root.contentBoundingVolume;
-  if (tileBoundingVolume instanceof TileBoundingRegion) {
-    up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
-    direction = camera.directionWC;
-    height = camera.positionCartographic.height;
-    minimumHeight = tileBoundingVolume.minimumHeight;
-    maximumHeight = tileBoundingVolume.maximumHeight;
-  } else {
-    const transformLocal = Matrix4.inverseTransformation(root.computedTransform, scratchMatrix);
-    const ellipsoid = mapProjection.ellipsoid;
-    const boundingVolume = tileBoundingVolume.boundingVolume;
-    const centerLocal = Matrix4.multiplyByPoint(transformLocal, boundingVolume.center, scratchCenter);
-    if (Cartesian3.magnitude(centerLocal) > ellipsoid.minimumRadius) {
-      const centerCartographic = Cartographic.fromCartesian(centerLocal, ellipsoid, scratchCartographic);
-      up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
-      direction = camera.directionWC;
-      height = camera.positionCartographic.height;
-      minimumHeight = 0.0;
-      maximumHeight = centerCartographic.height * 2.0;
-    } else {
-      const positionLocal = Matrix4.multiplyByPoint(transformLocal, camera.positionWC, scratchPosition);
-      up = Cartesian3.UNIT_Z;
-      direction = Matrix4.multiplyByPointAsVector(transformLocal, camera.directionWC, scratchDirection);
-      direction = Cartesian3.normalize(direction, direction);
-      height = positionLocal.z;
-      if (tileBoundingVolume instanceof TileOrientedBoundingBox) {
-        const boxHeight = root._header.boundingVolume.box[11];
-        minimumHeight = centerLocal.z - boxHeight;
-        maximumHeight = centerLocal.z + boxHeight;
-      } else if (tileBoundingVolume instanceof TileBoundingSphere) {
-        const radius = boundingVolume.radius;
-        minimumHeight = centerLocal.z - radius;
-        maximumHeight = centerLocal.z + radius;
-      }
+// eslint-disable-next-line max-statements, complexity
+export function calculateDynamicScreenSpaceError(root, { camera, mapProjection }, options = {}) {
+    const { dynamicScreenSpaceErrorHeightFalloff = 0.25, dynamicScreenSpaceErrorDensity = 0.00278 } = options;
+    let up;
+    let direction;
+    let height;
+    let minimumHeight;
+    let maximumHeight;
+    const tileBoundingVolume = root.contentBoundingVolume;
+    if (tileBoundingVolume instanceof TileBoundingRegion) {
+        up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
+        direction = camera.directionWC;
+        height = camera.positionCartographic.height;
+        minimumHeight = tileBoundingVolume.minimumHeight;
+        maximumHeight = tileBoundingVolume.maximumHeight;
     }
-  }
-  const heightFalloff = dynamicScreenSpaceErrorHeightFalloff;
-  const heightClose = minimumHeight + (maximumHeight - minimumHeight) * heightFalloff;
-  const heightFar = maximumHeight;
-  const t = clamp((height - heightClose) / (heightFar - heightClose), 0.0, 1.0);
-  const dot = Math.abs(Cartesian3.dot(direction, up));
-  let horizonFactor = 1.0 - dot;
-  horizonFactor = horizonFactor * (1.0 - t);
-  return dynamicScreenSpaceErrorDensity * horizonFactor;
+    else {
+        // Transform camera position and direction into the local coordinate system of the tileset
+        const transformLocal = Matrix4.inverseTransformation(root.computedTransform, scratchMatrix);
+        const ellipsoid = mapProjection.ellipsoid;
+        const boundingVolume = tileBoundingVolume.boundingVolume;
+        const centerLocal = Matrix4.multiplyByPoint(transformLocal, boundingVolume.center, scratchCenter);
+        if (Cartesian3.magnitude(centerLocal) > ellipsoid.minimumRadius) {
+            // The tileset is defined in WGS84. Approximate the minimum and maximum height.
+            const centerCartographic = Cartographic.fromCartesian(centerLocal, ellipsoid, scratchCartographic);
+            up = Cartesian3.normalize(camera.positionWC, scratchPositionNormal);
+            direction = camera.directionWC;
+            height = camera.positionCartographic.height;
+            minimumHeight = 0.0;
+            maximumHeight = centerCartographic.height * 2.0;
+        }
+        else {
+            // The tileset is defined in local coordinates (z-up)
+            const positionLocal = Matrix4.multiplyByPoint(transformLocal, camera.positionWC, scratchPosition);
+            up = Cartesian3.UNIT_Z;
+            direction = Matrix4.multiplyByPointAsVector(transformLocal, camera.directionWC, scratchDirection);
+            direction = Cartesian3.normalize(direction, direction);
+            height = positionLocal.z;
+            if (tileBoundingVolume instanceof TileOrientedBoundingBox) {
+                // Assuming z-up, the last component stores the half-height of the box
+                const boxHeight = root._header.boundingVolume.box[11];
+                minimumHeight = centerLocal.z - boxHeight;
+                maximumHeight = centerLocal.z + boxHeight;
+            }
+            else if (tileBoundingVolume instanceof TileBoundingSphere) {
+                const radius = boundingVolume.radius;
+                minimumHeight = centerLocal.z - radius;
+                maximumHeight = centerLocal.z + radius;
+            }
+        }
+    }
+    // The range where the density starts to lessen. Start at the quarter height of the tileset.
+    const heightFalloff = dynamicScreenSpaceErrorHeightFalloff;
+    const heightClose = minimumHeight + (maximumHeight - minimumHeight) * heightFalloff;
+    const heightFar = maximumHeight;
+    const t = clamp((height - heightClose) / (heightFar - heightClose), 0.0, 1.0);
+    // Increase density as the camera tilts towards the horizon
+    const dot = Math.abs(Cartesian3.dot(direction, up));
+    let horizonFactor = 1.0 - dot;
+    // Weaken the horizon factor as the camera height increases, implying the camera is further away from the tileset.
+    // The goal is to increase density for the "street view", not when viewing the tileset from a distance.
+    horizonFactor = horizonFactor * (1.0 - t);
+    return dynamicScreenSpaceErrorDensity * horizonFactor;
 }
 export function fog(distanceToCamera, density) {
-  const scalar = distanceToCamera * density;
-  return 1.0 - Math.exp(-(scalar * scalar));
+    const scalar = distanceToCamera * density;
+    return 1.0 - Math.exp(-(scalar * scalar));
 }
 export function getDynamicScreenSpaceError(tileset, distanceToCamera) {
-  if (tileset.dynamicScreenSpaceError && tileset.dynamicScreenSpaceErrorComputedDensity) {
-    const density = tileset.dynamicScreenSpaceErrorComputedDensity;
-    const factor = tileset.dynamicScreenSpaceErrorFactor;
-    const dynamicError = fog(distanceToCamera, density) * factor;
-    return dynamicError;
-  }
-  return 0;
+    if (tileset.dynamicScreenSpaceError && tileset.dynamicScreenSpaceErrorComputedDensity) {
+        const density = tileset.dynamicScreenSpaceErrorComputedDensity;
+        const factor = tileset.dynamicScreenSpaceErrorFactor;
+        // TODO: Refined screen space error that minimizes tiles in non-first-person
+        const dynamicError = fog(distanceToCamera, density) * factor;
+        return dynamicError;
+    }
+    return 0;
 }
 export function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {
-  const tileset = tile.tileset;
-  const parentLodMetricValue = tile.parent && tile.parent.lodMetricValue || tile.lodMetricValue;
-  const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;
-  if (lodMetricValue === 0.0) {
-    return 0.0;
-  }
-  const distance = Math.max(tile._distanceToCamera, 1e-7);
-  const {
-    height,
-    sseDenominator
-  } = frameState;
-  const {
-    viewDistanceScale
-  } = tileset.options;
-  let error = lodMetricValue * height * (viewDistanceScale || 1.0) / (distance * sseDenominator);
-  error -= getDynamicScreenSpaceError(tileset, distance);
-  return error;
+    const tileset = tile.tileset;
+    const parentLodMetricValue = (tile.parent && tile.parent.lodMetricValue) || tile.lodMetricValue;
+    const lodMetricValue = useParentLodMetric ? parentLodMetricValue : tile.lodMetricValue;
+    // Leaf tiles do not have any error so save the computation
+    if (lodMetricValue === 0.0) {
+        return 0.0;
+    }
+    // TODO: Orthographic Frustum needs special treatment?
+    // this._getOrthograhicScreenSpaceError();
+    // Avoid divide by zero when viewer is inside the tile
+    const distance = Math.max(tile._distanceToCamera, 1e-7);
+    const { height, sseDenominator } = frameState;
+    const { viewDistanceScale } = tileset.options;
+    let error = (lodMetricValue * height * (viewDistanceScale || 1.0)) / (distance * sseDenominator);
+    error -= getDynamicScreenSpaceError(tileset, distance);
+    return error;
 }
-//# sourceMappingURL=tiles-3d-lod.js.map