@loaders.gl/tiles 3.4.10 → 3.4.12

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;

package/dist/tileset/helpers/zoom.js

@@ -1,89 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getZoomFromExtent = exports.getZoomFromFullExtent = exports.getZoomFromBoundingVolume = void 0;
-const core_1 = require("@math.gl/core");
-const culling_1 = require("@math.gl/culling");
-const geospatial_1 = require("@math.gl/geospatial");
-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 boundingVolume - the instance of bounding volume
- * @param cartorgraphicCenter - cartographic center of the bounding volume
- * @returns {number} - zoom value
- */
-function getZoomFromBoundingVolume(boundingVolume, cartorgraphicCenter) {
-    if (boundingVolume instanceof culling_1.OrientedBoundingBox) {
-        // OrientedBoundingBox
-        const { halfAxes } = boundingVolume;
-        const obbSize = getObbSize(halfAxes);
-        // Use WGS84_RADIUS_Z to allign with BoundingSphere algorithm
-        // Add the tile elevation value for correct zooming to elevated tiles
-        return Math.log2(WGS84_RADIUS_Z / (obbSize + cartorgraphicCenter[2]));
-    }
-    else if (boundingVolume instanceof culling_1.BoundingSphere) {
-        // BoundingSphere
-        const { radius } = boundingVolume;
-        // Add the tile elevation value for correct zooming to elevated tiles
-        return Math.log2(WGS84_RADIUS_Z / (radius + cartorgraphicCenter[2]));
-    }
-    else if (boundingVolume.width && boundingVolume.height) {
-        // BoundingRectangle
-        const { width, height } = boundingVolume;
-        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;
-/**
- * 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
- */
-function getZoomFromFullExtent(fullExtent, cartorgraphicCenter, cartesianCenter) {
-    const extentVertex = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian([fullExtent.xmax, fullExtent.ymax, fullExtent.zmax], new core_1.Vector3());
-    const extentSize = Math.sqrt(Math.pow(extentVertex[0] - cartesianCenter[0], 2) +
-        Math.pow(extentVertex[1] - cartesianCenter[1], 2) +
-        Math.pow(extentVertex[2] - cartesianCenter[2], 2));
-    return Math.log2(WGS84_RADIUS_Z / (extentSize + cartorgraphicCenter[2]));
-}
-exports.getZoomFromFullExtent = getZoomFromFullExtent;
-/**
- * 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
- */
-function getZoomFromExtent(extent, cartorgraphicCenter, cartesianCenter) {
-    const [xmin, ymin, xmax, ymax] = extent;
-    return getZoomFromFullExtent({ xmin, xmax, ymin, ymax, zmin: 0, zmax: 0 }, cartorgraphicCenter, cartesianCenter);
-}
-exports.getZoomFromExtent = getZoomFromExtent;
-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;
-}