@loaders.gl/tiles 3.1.0-alpha.4 → 3.1.0-beta.3

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

@@ -0,0 +1,177 @@
+"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;
+}
+// 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) {
+    // 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];
+
+  const orientedBoundingBox = OrientedBoundingBox.fromRectangle(
+    rectangle,
+    minimumHeight,
+    maximumHeight,
+    Ellipsoid.WGS84,
+    scratchOrientedBoundingBox
+  );
+  const center = orientedBoundingBox.center;
+  const halfAxes = orientedBoundingBox.halfAxes;
+
+  // 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 instanceof TileOrientedBoundingBox) {
+    result.update(center, halfAxes);
+    return result;
+  }
+
+  return new TileOrientedBoundingBox(center, halfAxes);
+}
+
+function createRegion(region, transform, initialTransform, result) {
+  if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {
+    return createBoxFromTransformedRegion(region, transform, initialTransform, result);
+  }
+
+  if (defined(result)) {
+    return result;
+  }
+
+  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);
+}

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

@@ -0,0 +1,70 @@
+"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) {
+    // 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));
+    }
+}

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

@@ -0,0 +1,83 @@
+"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';
+}
+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;
+}
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tiles-3d-lod.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/tiles-3d-lod.ts"],"names":[],"mappings":"AAkBA,wBAAgB,gCAAgC,CAAC,IAAI,KAAA,EAAE,EAAC,MAAM,EAAE,aAAa,EAAC;;;CAAA,EAAE,OAAO,KAAK,UAqF3F;AAED,wBAAgB,GAAG,CAAC,gBAAgB,KAAA,EAAE,OAAO,KAAA,UAG5C;AAED,wBAAgB,0BAA0B,CAAC,OAAO,KAAA,EAAE,gBAAgB,KAAA,UAUnE;AAED,wBAAgB,0BAA0B,CAAC,IAAI,KAAA,EAAE,UAAU,KAAA,EAAE,kBAAkB,KAAA,UAsB9E"}

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

@@ -0,0 +1,116 @@
+"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.getTiles3DScreenSpaceError = exports.getDynamicScreenSpaceError = exports.fog = exports.calculateDynamicScreenSpaceError = void 0;
+// TODO - Dynamic screen space error provides an optimization when looking at
+// tilesets from above
+/* eslint-disable */
+// @ts-nocheck
+const core_1 = require("@math.gl/core");
+const scratchPositionNormal = new core_1.Vector3();
+const scratchCartographic = new core_1.Vector3();
+const scratchMatrix = new core_1.Matrix4();
+const scratchCenter = new core_1.Vector3();
+const scratchPosition = new core_1.Vector3();
+const scratchDirection = new core_1.Vector3();
+// eslint-disable-next-line max-statements, complexity
+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;
+    }
+    else {
+        // Transform camera position and direction into the local coordinate system of the tileset
+        const transformLocal = core_1.Matrix4.inverseTransformation(root.computedTransform, scratchMatrix);
+        const ellipsoid = mapProjection.ellipsoid;
+        const boundingVolume = tileBoundingVolume.boundingVolume;
+        const centerLocal = core_1.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 = core_1.Matrix4.multiplyByPoint(transformLocal, camera.positionWC, scratchPosition);
+            up = Cartesian3.UNIT_Z;
+            direction = core_1.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 = (0, core_1.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;
+}
+exports.calculateDynamicScreenSpaceError = calculateDynamicScreenSpaceError;
+function fog(distanceToCamera, density) {
+    const scalar = distanceToCamera * density;
+    return 1.0 - Math.exp(-(scalar * scalar));
+}
+exports.fog = fog;
+function getDynamicScreenSpaceError(tileset, distanceToCamera) {
+    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;
+}
+exports.getDynamicScreenSpaceError = getDynamicScreenSpaceError;
+function getTiles3DScreenSpaceError(tile, frameState, useParentLodMetric) {
+    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;
+}
+exports.getTiles3DScreenSpaceError = getTiles3DScreenSpaceError;

package/dist/tileset/helpers/transform-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function calculateTransformProps(tileHeader: any, tile: any): void;
+//# sourceMappingURL=transform-utils.d.ts.map

package/dist/tileset/helpers/transform-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-utils.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/transform-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,uBAAuB,CAAC,UAAU,KAAA,EAAE,IAAI,KAAA,QA4DvD"}

package/dist/tileset/helpers/transform-utils.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateTransformProps = void 0;
+const geospatial_1 = require("@math.gl/geospatial");
+const core_1 = require("@math.gl/core");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+function calculateTransformProps(tileHeader, tile) {
+    (0, loader_utils_1.assert)(tileHeader);
+    (0, loader_utils_1.assert)(tile);
+    const { rtcCenter, gltfUpAxis } = tile;
+    const { computedTransform, boundingVolume: { center } } = tileHeader;
+    let modelMatrix = new core_1.Matrix4(computedTransform);
+    // Translate if appropriate
+    if (rtcCenter) {
+        modelMatrix.translate(rtcCenter);
+    }
+    // glTF models need to be rotated from Y to Z up
+    // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
+    switch (gltfUpAxis) {
+        case 'Z':
+            break;
+        case 'Y':
+            const rotationY = new core_1.Matrix4().rotateX(Math.PI / 2);
+            modelMatrix = modelMatrix.multiplyRight(rotationY);
+            break;
+        case 'X':
+            const rotationX = new core_1.Matrix4().rotateY(-Math.PI / 2);
+            modelMatrix = modelMatrix.multiplyRight(rotationX);
+            break;
+        default:
+            break;
+    }
+    // Scale/offset positions if normalized integers
+    if (tile.isQuantized) {
+        modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);
+    }
+    // Option 1: Cartesian matrix and origin
+    const cartesianOrigin = new core_1.Vector3(center);
+    tile.cartesianModelMatrix = modelMatrix;
+    tile.cartesianOrigin = cartesianOrigin;
+    // Option 2: Cartographic matrix and origin
+    const cartographicOrigin = geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new core_1.Vector3());
+    const fromFixedFrameMatrix = geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
+    const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
+    tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
+    tile.cartographicOrigin = cartographicOrigin;
+    // Deprecated, drop
+    if (!tile.coordinateSystem) {
+        tile.modelMatrix = tile.cartographicModelMatrix;
+    }
+}
+exports.calculateTransformProps = calculateTransformProps;

package/dist/tileset/helpers/zoom.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Calculate appropriate zoom value for a particular boundingVolume
+ * @param {BoundingSphere, OrientedBoundingBox} boundingVolume - the instance of bounding volume
+ * @returns {number} - zoom value
+ */
+export declare function getZoomFromBoundingVolume(boundingVolume: any): number;
+//# sourceMappingURL=zoom.d.ts.map

package/dist/tileset/helpers/zoom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoom.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/zoom.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,cAAc,KAAA,UAoBvD"}

package/dist/tileset/helpers/zoom.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZoomFromBoundingVolume = void 0;
+const core_1 = require("@math.gl/core");
+const WGS84_RADIUS_X = 6378137.0;
+const WGS84_RADIUS_Y = 6378137.0;
+const WGS84_RADIUS_Z = 6356752.3142451793;
+const scratchVector = new core_1.Vector3();
+/**
+ * Calculate appropriate zoom value for a particular boundingVolume
+ * @param {BoundingSphere, OrientedBoundingBox} boundingVolume - the instance of bounding volume
+ * @returns {number} - zoom value
+ */
+function getZoomFromBoundingVolume(boundingVolume) {
+    const { halfAxes, radius, width, height } = boundingVolume;
+    if (halfAxes) {
+        // OrientedBoundingBox
+        const obbSize = getObbSize(halfAxes);
+        // Use WGS84_RADIUS_Z to allign with BoundingSphere algorithm
+        return Math.log2(WGS84_RADIUS_Z / obbSize);
+    }
+    else if (radius) {
+        // BoundingSphere
+        return Math.log2(WGS84_RADIUS_Z / radius);
+    }
+    else if (height && width) {
+        // BoundingRectangle
+        const zoomX = Math.log2(WGS84_RADIUS_X / width);
+        const zoomY = Math.log2(WGS84_RADIUS_Y / height);
+        return (zoomX + zoomY) / 2;
+    }
+    return 1;
+}
+exports.getZoomFromBoundingVolume = getZoomFromBoundingVolume;
+function getObbSize(halfAxes) {
+    halfAxes.getColumn(0, scratchVector);
+    const axeY = halfAxes.getColumn(1);
+    const axeZ = halfAxes.getColumn(2);
+    const farthestVertex = scratchVector.add(axeY).add(axeZ);
+    const size = farthestVertex.len();
+    return size;
+}