@loaders.gl/tiles 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -1,108 +1,85 @@
-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";
+// loaders.gl, MIT license
+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");
+const cameraPositionCartesian = new core_1.Vector3();
+const toEye = new core_1.Vector3();
+const cameraPositionEnu = new core_1.Vector3();
+const extraVertexEnu = new core_1.Vector3();
+const projectedOriginVector = new core_1.Vector3();
+const enuToCartesianMatrix = new core_1.Matrix4();
+const cartesianToEnuMatrix = new core_1.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
+ */
+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 { 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);
+    geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
+    // ---------------------------
+    // Calculate mbs border vertex
+    // ---------------------------
+    toEye.copy(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
+    // Add extra vector to form plane
+    geospatial_1.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 = 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 = projectedOriginVector
+        .copy(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

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":"AAoBA,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

@@ -1,105 +1,117 @@
-import { Matrix4, Vector3, clamp } from '@math.gl/core';
-const scratchPositionNormal = new Vector3();
-const scratchCartographic = new Vector3();
-const scratchMatrix = new Matrix4();
-const scratchCenter = new Vector3();
-const scratchPosition = new Vector3();
-const scratchDirection = new Vector3();
-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;
-  } 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;
-      }
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTiles3DScreenSpaceError = exports.getDynamicScreenSpaceError = exports.fog = exports.calculateDynamicScreenSpaceError = void 0;
+// 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
+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;
     }
-  }
-
-  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 = 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;
 }
-export function fog(distanceToCamera, density) {
-  const scalar = distanceToCamera * density;
-  return 1.0 - Math.exp(-(scalar * scalar));
+exports.calculateDynamicScreenSpaceError = calculateDynamicScreenSpaceError;
+function fog(distanceToCamera, density) {
+    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;
+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;
 }
-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;
+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;
 }
-//# sourceMappingURL=tiles-3d-lod.js.map
+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":"AAMA,wBAAgB,uBAAuB,CAAC,UAAU,KAAA,EAAE,IAAI,KAAA,QA4DvD"}

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

@@ -1,58 +1,53 @@
-import { Ellipsoid } from '@math.gl/geospatial';
-import { Matrix4, Vector3 } from '@math.gl/core';
-import { assert } from '@loaders.gl/loader-utils';
-export function calculateTransformProps(tileHeader, tile) {
-  assert(tileHeader);
-  assert(tile);
-  const {
-    rtcCenter,
-    gltfUpAxis
-  } = tile;
-  const {
-    computedTransform,
-    boundingVolume: {
-      center
+"use strict";
+// loaders.gl, MIT license
+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;
     }
-  } = tileHeader;
-  let modelMatrix = new Matrix4(computedTransform);
-
-  if (rtcCenter) {
-    modelMatrix.translate(rtcCenter);
-  }
-
-  switch (gltfUpAxis) {
-    case 'Z':
-      break;
-
-    case 'Y':
-      const rotationY = new Matrix4().rotateX(Math.PI / 2);
-      modelMatrix = modelMatrix.multiplyRight(rotationY);
-      break;
-
-    case 'X':
-      const rotationX = new Matrix4().rotateY(-Math.PI / 2);
-      modelMatrix = modelMatrix.multiplyRight(rotationX);
-      break;
-
-    default:
-      break;
-  }
-
-  if (tile.isQuantized) {
-    modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);
-  }
-
-  const cartesianOrigin = new Vector3(center);
-  tile.cartesianModelMatrix = modelMatrix;
-  tile.cartesianOrigin = cartesianOrigin;
-  const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new Vector3());
-  const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
-  const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
-  tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
-  tile.cartographicOrigin = cartographicOrigin;
-
-  if (!tile.coordinateSystem) {
-    tile.modelMatrix = tile.cartographicModelMatrix;
-  }
 }
-//# sourceMappingURL=transform-utils.js.map
+exports.calculateTransformProps = calculateTransformProps;

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

@@ -0,0 +1,46 @@
+import { Vector3 } from '@math.gl/core';
+import { BoundingSphere, OrientedBoundingBox } from '@math.gl/culling';
+import { BoundingRectangle } from '../../types';
+/**
+ * Calculate appropriate zoom value for a particular boundingVolume
+ * @param boundingVolume - the instance of bounding volume
+ * @param cartorgraphicCenter - cartographic center of the bounding volume
+ * @returns {number} - zoom value
+ */
+export declare function getZoomFromBoundingVolume(boundingVolume: BoundingSphere | OrientedBoundingBox | BoundingRectangle, cartorgraphicCenter: Vector3): number;
+/**
+ * Calculate initial zoom for the tileset from 3D `fullExtent` defined in
+ * the tileset metadata
+ * @param fullExtent - 3D extent of the tileset
+ * @param fullExtent.xmin - minimal longitude in decimal degrees
+ * @param fullExtent.xmax - maximal longitude in decimal degrees
+ * @param fullExtent.ymin - minimal latitude in decimal degrees
+ * @param fullExtent.ymax - maximal latitude in decimal degrees
+ * @param fullExtent.zmin - minimal elevation in meters
+ * @param fullExtent.zmax - maximal elevation in meters
+ * @param cartorgraphicCenter - tileset center in cartographic coordinate system
+ * @param cartesianCenter - tileset center in cartesian coordinate system
+ * @returns - initial zoom for the tileset
+ */
+export declare function getZoomFromFullExtent(fullExtent: {
+    xmin: number;
+    xmax: number;
+    ymin: number;
+    ymax: number;
+    zmin: number;
+    zmax: number;
+}, cartorgraphicCenter: Vector3, cartesianCenter: Vector3): number;
+/**
+ * Calculate initial zoom for the tileset from 2D `extent` defined in
+ * the tileset metadata
+ * @param extent - 2D extent of the tileset. It is array of 4 elements [xmin, ymin, xmax, ymax]
+ * @param extent[0] - minimal longitude in decimal degrees
+ * @param extent[1] - minimal latitude in decimal degrees
+ * @param extent[2] - maximal longitude in decimal degrees
+ * @param extent[3] - maximal latitude in decimal degrees
+ * @param cartorgraphicCenter - tileset center in cartographic coordinate system
+ * @param cartesianCenter - tileset center in cartesian coordinate system
+ * @returns - initial zoom for the tileset
+ */
+export declare function getZoomFromExtent(extent: [number, number, number, number], cartorgraphicCenter: Vector3, cartesianCenter: Vector3): 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":"AAEA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AAErE,OAAO,EAAC,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAQ9C;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,GAAG,mBAAmB,GAAG,iBAAiB,EACxE,mBAAmB,EAAE,OAAO,UAwB7B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE;IACV,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,EACD,mBAAmB,EAAE,OAAO,EAC5B,eAAe,EAAE,OAAO,UAYzB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,mBAAmB,EAAE,OAAO,EAC5B,eAAe,EAAE,OAAO,UAQzB"}