@loaders.gl/tiles 3.1.0-alpha.2 → 3.1.0-beta.1

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

@@ -1,6 +1,9 @@
-export function get3dTilesOptions(tileset) {
-  return {
-    assetGltfUpAxis: tileset.asset && tileset.asset.gltfUpAxis || 'Y'
-  };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get3dTilesOptions = void 0;
+function get3dTilesOptions(tileset) {
+    return {
+        assetGltfUpAxis: (tileset.asset && tileset.asset.gltfUpAxis) || 'Y'
+    };
 }
-//# sourceMappingURL=3d-tiles-options.js.map
+exports.get3dTilesOptions = get3dTilesOptions;

package/dist/tileset/helpers/bounding-volume.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Create a bounding volume from the tile's bounding volume header.
+ * @param {Object} boundingVolumeHeader The tile's bounding volume header.
+ * @param {Matrix4} transform The transform to apply to the bounding volume.
+ * @param [result] The object onto which to store the result.
+ * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.
+ */
+export declare function createBoundingVolume(boundingVolumeHeader: any, transform: any, result: any): any;
+//# sourceMappingURL=bounding-volume.d.ts.map

package/dist/tileset/helpers/bounding-volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounding-volume.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/bounding-volume.ts"],"names":[],"mappings":"AAuBA;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,oBAAoB,KAAA,EAAE,SAAS,KAAA,EAAE,MAAM,KAAA,OAsC3E"}

package/dist/tileset/helpers/bounding-volume.js

@@ -1,88 +1,177 @@
-import { Quaternion, Vector3, Matrix3, Matrix4, degrees } from '@math.gl/core';
-import { BoundingSphere, OrientedBoundingBox } from '@math.gl/culling';
-import { Ellipsoid } from '@math.gl/geospatial';
-import { assert } from '@loaders.gl/loader-utils';
-
+"use strict";
+// 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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBoundingVolume = void 0;
+/* eslint-disable */
+const core_1 = require("@math.gl/core");
+const culling_1 = require("@math.gl/culling");
+const geospatial_1 = require("@math.gl/geospatial");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+// const scratchProjectedBoundingSphere = new BoundingSphere();
 function defined(x) {
-  return x !== undefined && x !== null;
+    return x !== undefined && x !== null;
 }
-
-const scratchScale = new Vector3();
-const scratchNorthWest = new Vector3();
-const scratchSouthEast = new Vector3();
-export function createBoundingVolume(boundingVolumeHeader, transform, result) {
-  assert(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');
-
-  if (boundingVolumeHeader.box) {
-    return createBox(boundingVolumeHeader.box, transform, result);
-  }
-
-  if (boundingVolumeHeader.region) {
-    const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
-    const northWest = Ellipsoid.WGS84.cartographicToCartesian([degrees(west), degrees(north), minHeight], scratchNorthWest);
-    const southEast = Ellipsoid.WGS84.cartographicToCartesian([degrees(east), degrees(south), maxHeight], scratchSouthEast);
-    const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyScalar(0.5);
-    const radius = new Vector3().subVectors(northWest, southEast).len() / 2.0;
-    return createSphere([centerInCartesian[0], centerInCartesian[1], centerInCartesian[2], radius], new Matrix4());
-  }
-
-  if (boundingVolumeHeader.sphere) {
-    return createSphere(boundingVolumeHeader.sphere, transform, result);
-  }
-
-  throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');
+// const scratchMatrix = new Matrix3();
+const scratchScale = new core_1.Vector3();
+const scratchNorthWest = new core_1.Vector3();
+const scratchSouthEast = new core_1.Vector3();
+// const scratchRectangle = new Rectangle();
+// const scratchOrientedBoundingBox = new OrientedBoundingBox();
+// const scratchTransform = new Matrix4();
+/**
+ * Create a bounding volume from the tile's bounding volume header.
+ * @param {Object} boundingVolumeHeader The tile's bounding volume header.
+ * @param {Matrix4} transform The transform to apply to the bounding volume.
+ * @param [result] The object onto which to store the result.
+ * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.
+ */
+function createBoundingVolume(boundingVolumeHeader, transform, result) {
+    (0, loader_utils_1.assert)(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');
+    // boundingVolume schema:
+    // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
+    if (boundingVolumeHeader.box) {
+        return createBox(boundingVolumeHeader.box, transform, result);
+    }
+    if (boundingVolumeHeader.region) {
+        // [west, south, east, north, minimum height, maximum height]
+        // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.
+        // Heights are in meters above (or below) the WGS 84 ellipsoid.
+        const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
+        const northWest = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian([(0, core_1.degrees)(west), (0, core_1.degrees)(north), minHeight], scratchNorthWest);
+        const southEast = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian([(0, core_1.degrees)(east), (0, core_1.degrees)(south), maxHeight], scratchSouthEast);
+        const centerInCartesian = new core_1.Vector3().addVectors(northWest, southEast).multiplyScalar(0.5);
+        const radius = new core_1.Vector3().subVectors(northWest, southEast).len() / 2.0;
+        // TODO improve region boundingVolume
+        // for now, create a sphere as the boundingVolume instead of box
+        return createSphere([centerInCartesian[0], centerInCartesian[1], centerInCartesian[2], radius], new core_1.Matrix4());
+    }
+    if (boundingVolumeHeader.sphere) {
+        return createSphere(boundingVolumeHeader.sphere, transform, result);
+    }
+    throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');
 }
-
+exports.createBoundingVolume = createBoundingVolume;
 function createBox(box, transform, result) {
-  const center = new Vector3(box[0], box[1], box[2]);
-  transform.transform(center, center);
-  let origin = [];
+    // https://math.gl/modules/culling/docs/api-reference/oriented-bounding-box
+    // 1. A half-axes based representation.
+    // box: An array of 12 numbers that define an oriented bounding box.
+    // The first three elements define the x, y, and z values for the center of the box.
+    // The next three elements (with indices 3, 4, and 5) define the x axis direction and half-length.
+    // The next three elements (indices 6, 7, and 8) define the y axis direction and half-length.
+    // The last three elements (indices 9, 10, and 11) define the z axis direction and half-length.
+    // 2. A half-size-quaternion based representation.
+    // box: An array of 10 numbers that define an oriented bounding box.
+    // The first three elements define the x, y, and z values for the center of the box in a right-handed 3-axis (x, y, z) Cartesian coordinate system where the z-axis is up.
+    // The next three elements (with indices 3, 4, and 5) define the halfSize.
+    // The last four elements (indices 6, 7, 8 and 10) define the quaternion.
+    const center = new core_1.Vector3(box[0], box[1], box[2]);
+    transform.transform(center, center);
+    let origin = [];
+    if (box.length === 10) {
+        const halfSize = box.slice(3, 6);
+        const quaternion = new core_1.Quaternion();
+        quaternion.fromArray(box, 6);
+        const x = new core_1.Vector3([1, 0, 0]);
+        const y = new core_1.Vector3([0, 1, 0]);
+        const z = new core_1.Vector3([0, 0, 1]);
+        x.transformByQuaternion(quaternion);
+        x.scale(halfSize[0]);
+        y.transformByQuaternion(quaternion);
+        y.scale(halfSize[1]);
+        z.transformByQuaternion(quaternion);
+        z.scale(halfSize[2]);
+        origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];
+    }
+    else {
+        origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];
+    }
+    const xAxis = transform.transformAsVector(origin.slice(0, 3));
+    const yAxis = transform.transformAsVector(origin.slice(3, 6));
+    const zAxis = transform.transformAsVector(origin.slice(6, 9));
+    const halfAxes = new core_1.Matrix3([
+        xAxis[0],
+        xAxis[1],
+        xAxis[2],
+        yAxis[0],
+        yAxis[1],
+        yAxis[2],
+        zAxis[0],
+        zAxis[1],
+        zAxis[2]
+    ]);
+    if (defined(result)) {
+        result.center = center;
+        result.halfAxes = halfAxes;
+        return result;
+    }
+    return new culling_1.OrientedBoundingBox(center, halfAxes);
+}
+/*
+function createBoxFromTransformedRegion(region, transform, initialTransform, result) {
+  const rectangle = Rectangle.unpack(region, 0, scratchRectangle);
+  const minimumHeight = region[4];
+  const maximumHeight = region[5];
 
-  if (box.length === 10) {
-    const halfSize = box.slice(3, 6);
-    const quaternion = new Quaternion();
-    quaternion.fromArray(box, 6);
-    const x = new Vector3([1, 0, 0]);
-    const y = new Vector3([0, 1, 0]);
-    const z = new Vector3([0, 0, 1]);
-    x.transformByQuaternion(quaternion);
-    x.scale(halfSize[0]);
-    y.transformByQuaternion(quaternion);
-    y.scale(halfSize[1]);
-    z.transformByQuaternion(quaternion);
-    z.scale(halfSize[2]);
-    origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];
-  } else {
-    origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];
-  }
+  const orientedBoundingBox = OrientedBoundingBox.fromRectangle(
+    rectangle,
+    minimumHeight,
+    maximumHeight,
+    Ellipsoid.WGS84,
+    scratchOrientedBoundingBox
+  );
+  const center = orientedBoundingBox.center;
+  const halfAxes = orientedBoundingBox.halfAxes;
 
-  const xAxis = transform.transformAsVector(origin.slice(0, 3));
-  const yAxis = transform.transformAsVector(origin.slice(3, 6));
-  const zAxis = transform.transformAsVector(origin.slice(6, 9));
-  const halfAxes = new Matrix3([xAxis[0], xAxis[1], xAxis[2], yAxis[0], yAxis[1], yAxis[2], zAxis[0], zAxis[1], zAxis[2]]);
+  // A region bounding volume is not transformed by the transform in the tileset JSON,
+  // but may be transformed by additional transforms applied in Cesium.
+  // This is why the transform is calculated as the difference between the initial transform and the current transform.
+  transform = Matrix4.multiplyTransformation(
+    transform,
+    Matrix4.inverseTransformation(initialTransform, scratchTransform),
+    scratchTransform
+  );
+  center = Matrix4.multiplyByPoint(transform, center, center);
+  const rotationScale = Matrix4.getRotation(transform, scratchMatrix);
+  halfAxes = Matrix3.multiply(rotationScale, halfAxes, halfAxes);
 
-  if (defined(result)) {
-    result.center = center;
-    result.halfAxes = halfAxes;
+  if (defined(result) && result instanceof TileOrientedBoundingBox) {
+    result.update(center, halfAxes);
     return result;
   }
 
-  return new OrientedBoundingBox(center, halfAxes);
+  return new TileOrientedBoundingBox(center, halfAxes);
 }
 
-function createSphere(sphere, transform, result) {
-  const center = new Vector3(sphere[0], sphere[1], sphere[2]);
-  transform.transform(center, center);
-  const scale = transform.getScale(scratchScale);
-  const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);
-  const radius = sphere[3] * uniformScale;
+function createRegion(region, transform, initialTransform, result) {
+  if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {
+    return createBoxFromTransformedRegion(region, transform, initialTransform, result);
+  }
 
   if (defined(result)) {
-    result.center = center;
-    result.radius = radius;
     return result;
   }
 
-  return new BoundingSphere(center, radius);
+  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);
+
+  return new TileBoundingRegion({
+    rectangle: rectangleRegion,
+    minimumHeight: region[4],
+    maximumHeight: region[5]
+  });
+}
+*/
+function createSphere(sphere, transform, result) {
+    // Find the transformed center
+    const center = new core_1.Vector3(sphere[0], sphere[1], sphere[2]);
+    transform.transform(center, center);
+    const scale = transform.getScale(scratchScale);
+    const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);
+    const radius = sphere[3] * uniformScale;
+    if (defined(result)) {
+        result.center = center;
+        result.radius = radius;
+        return result;
+    }
+    return new culling_1.BoundingSphere(center, radius);
 }
-//# sourceMappingURL=bounding-volume.js.map

package/dist/tileset/helpers/frame-state.d.ts

@@ -0,0 +1,17 @@
+import { CullingVolume } from '@math.gl/culling';
+export declare type FrameState = {
+    camera: {
+        position: number[];
+        direction: number[];
+        up: number[];
+    };
+    viewport: {
+        [key: string]: any;
+    };
+    height: number;
+    cullingVolume: CullingVolume;
+    frameNumber: number;
+    sseDenominator: number;
+};
+export declare function getFrameState(viewport: any, frameNumber: number): FrameState;
+//# sourceMappingURL=frame-state.d.ts.map

package/dist/tileset/helpers/frame-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-state.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/frame-state.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,aAAa,EAAQ,MAAM,kBAAkB,CAAC;AAGtD,oBAAY,UAAU,GAAG;IACvB,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,EAAE,EAAE,MAAM,EAAE,CAAC;KACd,CAAC;IACF,QAAQ,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAeF,wBAAgB,aAAa,CAAC,QAAQ,KAAA,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CA6CvE"}

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

@@ -1,51 +1,70 @@
-import { Vector3 } from '@math.gl/core';
-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()]);
-export function getFrameState(viewport, frameNumber) {
-  const {
-    cameraDirection,
-    cameraUp,
-    height
-  } = viewport;
-  const {
-    metersPerUnit
-  } = viewport.distanceScales;
-  const viewportCenterCartographic = [viewport.longitude, viewport.latitude, 0];
-  const viewportCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(viewportCenterCartographic, new Vector3());
-  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, viewportCenterCartesian);
-  return {
-    camera: {
-      position: cameraPositionCartesian,
-      direction: cameraDirectionCartesian,
-      up: cameraUpCartesian
-    },
-    viewport,
-    height,
-    cullingVolume,
-    frameNumber,
-    sseDenominator: 1.15
-  };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFrameState = void 0;
+const core_1 = require("@math.gl/core");
+const culling_1 = require("@math.gl/culling");
+const geospatial_1 = require("@math.gl/geospatial");
+const scratchVector = new core_1.Vector3();
+const scratchPosition = new core_1.Vector3();
+const cullingVolume = new culling_1.CullingVolume([
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.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
+function getFrameState(viewport, frameNumber) {
+    // Traverse and and request. Update _selectedTiles so that we know what to render.
+    const { cameraDirection, cameraUp, height } = viewport;
+    const { metersPerUnit } = viewport.distanceScales;
+    const viewportCenterCartographic = [viewport.longitude, viewport.latitude, 0];
+    // TODO - Ellipsoid.eastNorthUpToFixedFrame() breaks on raw array, create a Vector.
+    // TODO - Ellipsoid.eastNorthUpToFixedFrame() takes a cartesian, is that intuitive?
+    const viewportCenterCartesian = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(viewportCenterCartographic, new core_1.Vector3());
+    const enuToFixedTransform = geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
+    const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
+    const cameraPositionCartesian = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new core_1.Vector3());
+    // These should still be normalized as the transform has scale 1 (goes from meters to meters)
+    const cameraDirectionCartesian = new core_1.Vector3(
+    // @ts-ignore
+    enuToFixedTransform.transformAsVector(new core_1.Vector3(cameraDirection).scale(metersPerUnit))).normalize();
+    const cameraUpCartesian = new core_1.Vector3(
+    // @ts-ignore
+    enuToFixedTransform.transformAsVector(new core_1.Vector3(cameraUp).scale(metersPerUnit))).normalize();
+    commonSpacePlanesToWGS84(viewport, viewportCenterCartesian);
+    // 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,
+        height,
+        cullingVolume,
+        frameNumber,
+        sseDenominator: 1.15 // Assumes fovy = 60 degrees
+    };
 }
-
+exports.getFrameState = getFrameState;
 function commonSpacePlanesToWGS84(viewport, viewportCenterCartesian) {
-  const frustumPlanes = viewport.getFrustumPlanes();
-  let i = 0;
-
-  for (const dir in frustumPlanes) {
-    const plane = frustumPlanes[dir];
-    const distanceToCenter = plane.normal.dot(viewport.center);
-    scratchPosition.copy(plane.normal).scale(plane.distance - distanceToCenter).add(viewport.center);
-    const cartographicPos = viewport.unprojectPosition(scratchPosition);
-    const cartesianPos = Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new Vector3());
-    cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector.copy(viewportCenterCartesian).subtract(cartesianPos));
-  }
+    // Extract frustum planes based on current view.
+    const frustumPlanes = viewport.getFrustumPlanes();
+    let i = 0;
+    for (const dir in frustumPlanes) {
+        const plane = frustumPlanes[dir];
+        const distanceToCenter = plane.normal.dot(viewport.center);
+        scratchPosition
+            .copy(plane.normal)
+            .scale(plane.distance - distanceToCenter)
+            .add(viewport.center);
+        const cartographicPos = viewport.unprojectPosition(scratchPosition);
+        const cartesianPos = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new core_1.Vector3());
+        cullingVolume.planes[i++].fromPointNormal(cartesianPos, 
+        // Want the normal to point into the frustum since that's what culling expects
+        scratchVector.copy(viewportCenterCartesian).subtract(cartesianPos));
+    }
 }
-//# sourceMappingURL=frame-state.js.map

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

@@ -0,0 +1,20 @@
+import Tile3D from '../tile-3d';
+import { FrameState } from './frame-state';
+/**
+ * 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 declare function getLodStatus(tile: Tile3D, frameState: FrameState): 'DIG' | 'OUT' | 'DRAW';
+/**
+ * Calculate size of MBS radius projected on the screen plane
+ * @param tile
+ * @param frameState
+ * @returns
+ */
+export declare function getProjectedRadius(tile: Tile3D, frameState: FrameState): number;
+//# sourceMappingURL=i3s-lod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-lod.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/i3s-lod.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,YAAY,CAAC;AAChC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAEzC;;;;;;;;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,CAoD/E"}

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

@@ -1,108 +1,83 @@
-import { toRadians } from '@math.gl/core';
-const WGS84_RADIUS_X = 6378137.0;
-const qualityFactor = Math.PI / 2;
-export function lodJudge(tile, frameState) {
-  const viewport = frameState.viewport;
-  const metersPerPixel = viewport.metersPerPixel;
-  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 {
-    height,
-    width,
-    latitude,
-    longitude
-  } = viewport;
-  const viewportCenter = [longitude, latitude];
-  const mbsCenter = [mbsLon, mbsLat, mbsZ];
-  const mbsLatProjected = [longitude, mbsLat];
-  const mbsLonProjected = [mbsLon, latitude];
-  const diagonalInMeters = Math.sqrt(height * height + width * width) * metersPerPixel[0];
-  const distanceInMeters = getDistanceFromLatLon(viewportCenter, mbsCenter);
-  const visibleHeight = height * 0.5 + mbsR / WGS84_RADIUS_X;
-  const visibleWidth = width * 0.5 + mbsR / WGS84_RADIUS_X;
-
-  if (distanceInMeters > diagonalInMeters + mbsR / WGS84_RADIUS_X) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectedRadius = exports.getLodStatus = void 0;
+const core_1 = require("@math.gl/core");
+const geospatial_1 = require("@math.gl/geospatial");
+/**
+ * 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
+ */
+function getLodStatus(tile, frameState) {
+    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 (getDistanceFromLatLon(viewportCenter, mbsLatProjected) > visibleHeight) {
-    return 'OUT';
-  }
-
-  if (getDistanceFromLatLon(viewportCenter, mbsLonProjected) > visibleWidth) {
-    return 'OUT';
-  }
-
-  if (tile.lodMetricValue === 0) {
-    return 'DIG';
-  }
-
-  let screenSize = getI3ScreenSize(tile, frameState);
-  screenSize *= qualityFactor;
-
-  if (screenSize < 0.5) {
-    return 'OUT';
-  }
-
-  if (!tile.header.children || screenSize <= tile.lodMetricValue) {
-    return 'DRAW';
-  } else if (tile.header.children) {
-    return 'DIG';
-  }
-
-  return 'OUT';
-}
-
-function projectVertexToSphere([x, y, z]) {
-  const azim = toRadians(x);
-  const incl = toRadians(y);
-  const radius = 1.0 + z / WGS84_RADIUS_X;
-  const radCosInc = radius * Math.cos(incl);
-  x = radCosInc * Math.cos(azim);
-  y = radCosInc * Math.sin(azim);
-  z = radius * Math.sin(incl);
-  return [x, y, z];
-}
-
-function getDistanceFromLatLon(observer, center) {
-  const [observerLon, observerLat, observerZ = 0.0] = observer;
-  const [centerLon, centerLat, centerZ = 0.0] = center;
-  const projectedCenter = projectVertexToSphere([centerLon, centerLat, centerZ]);
-  const projectedObserver = projectVertexToSphere([observerLon, observerLat, observerZ]);
-  const dx = projectedObserver[0] - projectedCenter[0];
-  const dy = projectedObserver[1] - projectedCenter[1];
-  const dz = projectedObserver[2] - projectedCenter[2];
-  return dx * dx + dy * dy + dz * dz;
-}
-
-export function getI3ScreenSize(tile, frameState) {
-  const viewport = frameState.viewport;
-  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 mbsCenter = [mbsLon, mbsLat, mbsZ];
-  const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-  const dSquared = getDistanceFromLatLon(cameraPositionCartographic, mbsCenter);
-  const mbsRNormalized = mbsR / WGS84_RADIUS_X;
-  const d = dSquared - mbsRNormalized * mbsRNormalized;
-  const fltMax = 3.4028235e38;
-
-  if (d <= 0.0) {
-    return 0.5 * fltMax;
-  }
-
-  const screenSizeFactor = getTanOfHalfVFAngle(frameState) * mbsRNormalized / Math.sqrt(d) * 300;
-  return screenSizeFactor;
 }
-
-function getTanOfHalfVFAngle(frameState) {
-  const {
-    projectionMatrix
-  } = frameState.viewport;
-  const t = projectionMatrix[5];
-  return t;
+exports.getLodStatus = getLodStatus;
+/**
+ * Calculate size of MBS radius projected on the screen plane
+ * @param tile
+ * @param frameState
+ * @returns
+ */
+// eslint-disable-next-line max-statements
+function getProjectedRadius(tile, frameState) {
+    const originalViewport = frameState.viewport;
+    const ViewportClass = originalViewport.constructor;
+    const { longitude, latitude, height, width, bearing, zoom } = originalViewport;
+    // @ts-ignore
+    const viewport = new ViewportClass({ longitude, latitude, height, width, bearing, zoom, pitch: 0 });
+    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);
+    const cameraPositionCartesian = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new core_1.Vector3());
+    // ---------------------------
+    // Calculate mbs border vertex
+    // ---------------------------
+    const toEye = new core_1.Vector3(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
+    // Add extra vector to form plane
+    const enuToCartesianMatrix = new core_1.Matrix4();
+    geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);
+    const cartesianToEnuMatrix = new core_1.Matrix4(enuToCartesianMatrix).invert();
+    const cameraPositionEnu = new core_1.Vector3(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];
+    const extraVertexEnu = new core_1.Vector3([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);
+    const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);
+    const extraVectorCartesian = new core_1.Vector3(extraVertexCartesian)
+        .subtract(mbsCenterCartesian)
+        .normalize();
+    // We need radius vector orthogonal to toEye vector
+    const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);
+    const sphereMbsBorderVertexCartesian = new core_1.Vector3(mbsCenterCartesian).add(radiusVector);
+    const sphereMbsBorderVertexCartographic = geospatial_1.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 = new core_1.Vector3(projectedOrigin)
+        .subtract(projectedMbsBorderVertex)
+        .magnitude();
+    return projectedRadius;
 }
-//# sourceMappingURL=i3s-lod.js.map
+exports.getProjectedRadius = getProjectedRadius;

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

@@ -0,0 +1,8 @@
+export declare function calculateDynamicScreenSpaceError(root: any, { camera, mapProjection }: {
+    camera: any;
+    mapProjection: any;
+}, options?: {}): number;
+export declare function fog(distanceToCamera: any, density: any): number;
+export declare function getDynamicScreenSpaceError(tileset: any, distanceToCamera: any): number;
+export declare function getTiles3DScreenSpaceError(tile: any, frameState: any, useParentLodMetric: any): number;
+//# sourceMappingURL=tiles-3d-lod.d.ts.map