@loaders.gl/tiles 4.0.0-alpha.23 → 4.0.0-alpha.25

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

@@ -1,293 +0,0 @@
-"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.getCartographicBounds = 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 scratchPoint = new core_1.Vector3();
-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;
-/**
- * Calculate the cartographic bounding box the tile's bounding volume.
- * @param {Object} boundingVolumeHeader The tile's bounding volume header.
- * @param {BoundingVolume} boundingVolume The bounding volume.
- * @returns {CartographicBounds}
- */
-function getCartographicBounds(boundingVolumeHeader, boundingVolume) {
-    // boundingVolume schema:
-    // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
-    if (boundingVolumeHeader.box) {
-        return orientedBoundingBoxToCartographicBounds(boundingVolume);
-    }
-    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;
-        return [
-            [(0, core_1.degrees)(west), (0, core_1.degrees)(south), minHeight],
-            [(0, core_1.degrees)(east), (0, core_1.degrees)(north), maxHeight]
-        ];
-    }
-    if (boundingVolumeHeader.sphere) {
-        return boundingSphereToCartographicBounds(boundingVolume);
-    }
-    throw new Error('Unkown boundingVolume type');
-}
-exports.getCartographicBounds = getCartographicBounds;
-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);
-}
-/**
- * Convert a bounding volume defined by OrientedBoundingBox to cartographic bounds
- * @returns {CartographicBounds}
- */
-function orientedBoundingBoxToCartographicBounds(boundingVolume) {
-    const result = emptyCartographicBounds();
-    const { halfAxes } = boundingVolume;
-    const xAxis = new core_1.Vector3(halfAxes.getColumn(0));
-    const yAxis = new core_1.Vector3(halfAxes.getColumn(1));
-    const zAxis = new core_1.Vector3(halfAxes.getColumn(2));
-    // Test all 8 corners of the box
-    for (let x = 0; x < 2; x++) {
-        for (let y = 0; y < 2; y++) {
-            for (let z = 0; z < 2; z++) {
-                scratchPoint.copy(boundingVolume.center);
-                scratchPoint.add(xAxis);
-                scratchPoint.add(yAxis);
-                scratchPoint.add(zAxis);
-                addToCartographicBounds(result, scratchPoint);
-                zAxis.negate();
-            }
-            yAxis.negate();
-        }
-        xAxis.negate();
-    }
-    return result;
-}
-/**
- * Convert a bounding volume defined by BoundingSphere to cartographic bounds
- * @returns {CartographicBounds}
- */
-function boundingSphereToCartographicBounds(boundingVolume) {
-    const result = emptyCartographicBounds();
-    const { center, radius } = boundingVolume;
-    const point = geospatial_1.Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
-    let zAxis;
-    if (point) {
-        zAxis = geospatial_1.Ellipsoid.WGS84.geodeticSurfaceNormal(point);
-    }
-    else {
-        zAxis = new core_1.Vector3(0, 0, 1);
-    }
-    let xAxis = new core_1.Vector3(zAxis[2], -zAxis[1], 0);
-    if (xAxis.len() > 0) {
-        xAxis.normalize();
-    }
-    else {
-        xAxis = new core_1.Vector3(0, 1, 0);
-    }
-    const yAxis = xAxis.clone().cross(zAxis);
-    // Test 6 end points of the 3 axes
-    for (const axis of [xAxis, yAxis, zAxis]) {
-        scratchScale.copy(axis).scale(radius);
-        for (let dir = 0; dir < 2; dir++) {
-            scratchPoint.copy(center);
-            scratchPoint.add(scratchScale);
-            addToCartographicBounds(result, scratchPoint);
-            // Flip the axis
-            scratchScale.negate();
-        }
-    }
-    return result;
-}
-/**
- * Create a new cartographic bounds that contains no points
- * @returns {CartographicBounds}
- */
-function emptyCartographicBounds() {
-    return [
-        [Infinity, Infinity, Infinity],
-        [-Infinity, -Infinity, -Infinity]
-    ];
-}
-/**
- * Add a point to the target cartographic bounds
- * @param {CartographicBounds} target
- * @param {Vector3} cartesian coordinates of the point to add
- */
-function addToCartographicBounds(target, cartesian) {
-    geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
-    target[0][0] = Math.min(target[0][0], scratchPoint[0]);
-    target[0][1] = Math.min(target[0][1], scratchPoint[1]);
-    target[0][2] = Math.min(target[0][2], scratchPoint[2]);
-    target[1][0] = Math.max(target[1][0], scratchPoint[0]);
-    target[1][1] = Math.max(target[1][1], scratchPoint[1]);
-    target[1][2] = Math.max(target[1][2], scratchPoint[2]);
-}

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

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.limitSelectedTiles = 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.
-    // 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 = 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);
-    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,
-        sseDenominator: 1.15 // Assumes fovy = 60 degrees
-    };
-}
-exports.getFrameState = getFrameState;
-/**
- * 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
- */
-function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
-    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];
-}
-exports.limitSelectedTiles = limitSelectedTiles;
-function commonSpacePlanesToWGS84(viewport) {
-    // 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));
-    }
-}
-function closestPointOnPlane(plane, refPoint, out = new core_1.Vector3()) {
-    const distanceToRef = plane.normal.dot(refPoint);
-    out
-        .copy(plane.normal)
-        .scale(plane.distance - distanceToRef)
-        .add(refPoint);
-    return out;
-}
-function worldToCartesian(viewport, point, out = new core_1.Vector3()) {
-    const cartographicPos = viewport.unprojectPosition(point);
-    return geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
-}

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

@@ -1,85 +0,0 @@
-"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';
-}
-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;
-}
-exports.getProjectedRadius = getProjectedRadius;

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

@@ -1,117 +0,0 @@
-"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;
-    }
-    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.js

@@ -1,53 +0,0 @@
-"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;
-    }
-}
-exports.calculateTransformProps = calculateTransformProps;