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

package/dist/lib/parsers/parse-3d-tile-composite.js

@@ -1,24 +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.parseComposite3DTile = void 0;
-const parse_3d_tile_header_1 = require("./helpers/parse-3d-tile-header");
-// eslint-disable-next-line max-params
-async function parseComposite3DTile(tile, arrayBuffer, byteOffset, options, context, parse3DTile) {
-    byteOffset = (0, parse_3d_tile_header_1.parse3DTileHeaderSync)(tile, arrayBuffer, byteOffset);
-    const view = new DataView(arrayBuffer);
-    // Extract number of tiles
-    tile.tilesLength = view.getUint32(byteOffset, true);
-    byteOffset += 4;
-    // extract each tile from the byte stream
-    tile.tiles = [];
-    while (tile.tiles.length < tile.tilesLength && (tile.byteLength || 0) - byteOffset > 12) {
-        const subtile = { shape: 'tile3d' };
-        tile.tiles.push(subtile);
-        byteOffset = await parse3DTile(arrayBuffer, byteOffset, options, context, subtile);
-        // TODO - do we need to add any padding in between tiles?
-    }
-    return byteOffset;
-}
-exports.parseComposite3DTile = parseComposite3DTile;

package/dist/lib/parsers/parse-3d-tile-gltf.js

@@ -1,29 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGltf3DTile = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const gltf_1 = require("@loaders.gl/gltf");
-async function parseGltf3DTile(tile, arrayBuffer, options, context) {
-    // Set flags
-    // 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
-    tile.rotateYtoZ = true;
-    // Save gltf up axis
-    tile.gltfUpAxis = options?.['3d-tiles']?.assetGltfUpAxis
-        ? options['3d-tiles'].assetGltfUpAxis
-        : 'Y';
-    if (options?.['3d-tiles']?.loadGLTF) {
-        if (!context) {
-            return arrayBuffer.byteLength;
-        }
-        const gltfWithBuffers = await (0, loader_utils_1.parseFromContext)(arrayBuffer, gltf_1.GLTFLoader, options, context);
-        tile.gltf = (0, gltf_1.postProcessGLTF)(gltfWithBuffers);
-        tile.gpuMemoryUsageInBytes = (0, gltf_1._getMemoryUsageGLTF)(tile.gltf);
-    }
-    else {
-        tile.gltfArrayBuffer = arrayBuffer;
-    }
-    return arrayBuffer.byteLength;
-}
-exports.parseGltf3DTile = parseGltf3DTile;

package/dist/lib/parsers/parse-3d-tile-header.js

@@ -1,194 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeImplicitTileData = exports.normalizeImplicitTileHeaders = exports.normalizeTileHeaders = exports.normalizeTileData = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const tile_3d_subtree_loader_1 = require("../../tile-3d-subtree-loader");
-const core_1 = require("@loaders.gl/core");
-const tiles_1 = require("@loaders.gl/tiles");
-const parse_3d_implicit_tiles_1 = require("./helpers/parse-3d-implicit-tiles");
-const s2_corners_to_obb_1 = require("../utils/obb/s2-corners-to-obb");
-function getTileType(tile, tileContentUrl = '') {
-    if (!tileContentUrl) {
-        return tiles_1.TILE_TYPE.EMPTY;
-    }
-    const contentUrl = tileContentUrl.split('?')[0]; // Discard query string
-    const fileExtension = contentUrl.split('.').pop();
-    switch (fileExtension) {
-        case 'pnts':
-            return tiles_1.TILE_TYPE.POINTCLOUD;
-        case 'i3dm':
-        case 'b3dm':
-        case 'glb':
-        case 'gltf':
-            return tiles_1.TILE_TYPE.SCENEGRAPH;
-        default:
-            return fileExtension || tiles_1.TILE_TYPE.EMPTY;
-    }
-}
-function getRefine(refine) {
-    switch (refine) {
-        case 'REPLACE':
-        case 'replace':
-            return tiles_1.TILE_REFINEMENT.REPLACE;
-        case 'ADD':
-        case 'add':
-            return tiles_1.TILE_REFINEMENT.ADD;
-        default:
-            return refine;
-    }
-}
-function resolveUri(uri = '', basePath) {
-    // url scheme per RFC3986
-    const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
-    if (urlSchemeRegex.test(basePath)) {
-        const url = new URL(uri, `${basePath}/`);
-        return decodeURI(url.toString());
-    }
-    else if (uri.startsWith('/')) {
-        return uri;
-    }
-    return loader_utils_1.path.resolve(basePath, uri);
-}
-function normalizeTileData(tile, basePath) {
-    if (!tile) {
-        return null;
-    }
-    let tileContentUrl;
-    if (tile.content) {
-        const contentUri = tile.content.uri || tile.content?.url;
-        tileContentUrl = resolveUri(contentUri, basePath);
-    }
-    const tilePostprocessed = {
-        ...tile,
-        id: tileContentUrl,
-        contentUrl: tileContentUrl,
-        lodMetricType: tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR,
-        lodMetricValue: tile.geometricError,
-        transformMatrix: tile.transform,
-        type: getTileType(tile, tileContentUrl),
-        refine: getRefine(tile.refine)
-    };
-    return tilePostprocessed;
-}
-exports.normalizeTileData = normalizeTileData;
-// normalize tile headers
-async function normalizeTileHeaders(tileset, basePath, options) {
-    let root = null;
-    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset.root);
-    if (rootImplicitTilingExtension && tileset.root) {
-        root = await normalizeImplicitTileHeaders(tileset.root, tileset, basePath, rootImplicitTilingExtension, options);
-    }
-    else {
-        root = normalizeTileData(tileset.root, basePath);
-    }
-    const stack = [];
-    stack.push(root);
-    while (stack.length > 0) {
-        const tile = stack.pop() || {};
-        const children = tile.children || [];
-        const childrenPostprocessed = [];
-        for (const childHeader of children) {
-            const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
-            let childHeaderPostprocessed;
-            if (childImplicitTilingExtension) {
-                childHeaderPostprocessed = await normalizeImplicitTileHeaders(childHeader, tileset, basePath, childImplicitTilingExtension, options);
-            }
-            else {
-                childHeaderPostprocessed = normalizeTileData(childHeader, basePath);
-            }
-            if (childHeaderPostprocessed) {
-                childrenPostprocessed.push(childHeaderPostprocessed);
-                stack.push(childHeaderPostprocessed);
-            }
-        }
-        tile.children = childrenPostprocessed;
-    }
-    return root;
-}
-exports.normalizeTileHeaders = normalizeTileHeaders;
-/**
- * Do normalisation of implicit tile headers
- * TODO Check if Tile3D class can be a return type here.
- * @param tileset
- */
-async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTilingExtension, options) {
-    const { subdivisionScheme, maximumLevel, availableLevels, subtreeLevels, subtrees: { uri: subtreesUriTemplate } } = implicitTilingExtension;
-    const replacedUrlTemplate = (0, parse_3d_implicit_tiles_1.replaceContentUrlTemplate)(subtreesUriTemplate, 0, 0, 0, 0);
-    const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
-    const subtree = await (0, core_1.load)(subtreeUrl, tile_3d_subtree_loader_1.Tile3DSubtreeLoader, options);
-    const contentUrlTemplate = resolveUri(tile.content?.uri, basePath);
-    const refine = tileset?.root?.refine;
-    // @ts-ignore
-    const rootLodMetricValue = tile.geometricError;
-    // Replace tile.boundingVolume with the the bounding volume specified by the extensions['3DTILES_bounding_volume_S2']
-    const s2VolumeInfo = tile.boundingVolume.extensions?.['3DTILES_bounding_volume_S2'];
-    if (s2VolumeInfo) {
-        const box = (0, s2_corners_to_obb_1.convertS2BoundingVolumetoOBB)(s2VolumeInfo);
-        const s2VolumeBox = { box, s2VolumeInfo };
-        tile.boundingVolume = s2VolumeBox;
-    }
-    const rootBoundingVolume = tile.boundingVolume;
-    const implicitOptions = {
-        contentUrlTemplate,
-        subtreesUriTemplate,
-        subdivisionScheme,
-        subtreeLevels,
-        maximumLevel: Number.isFinite(availableLevels) ? availableLevels - 1 : maximumLevel,
-        refine,
-        basePath,
-        lodMetricType: tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR,
-        rootLodMetricValue,
-        rootBoundingVolume,
-        getTileType,
-        getRefine
-    };
-    return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions, options);
-}
-exports.normalizeImplicitTileHeaders = normalizeImplicitTileHeaders;
-/**
- * Do implicit data normalisation to create hierarchical tile structure
- * @param tile
- * @param rootSubtree
- * @param options
- * @returns
- */
-async function normalizeImplicitTileData(tile, basePath, rootSubtree, implicitOptions, loaderOptions) {
-    if (!tile) {
-        return null;
-    }
-    const { children, contentUrl } = await (0, parse_3d_implicit_tiles_1.parseImplicitTiles)({
-        subtree: rootSubtree,
-        implicitOptions,
-        loaderOptions
-    });
-    let tileContentUrl;
-    let tileContent = null;
-    if (contentUrl) {
-        tileContentUrl = contentUrl;
-        tileContent = { uri: contentUrl.replace(`${basePath}/`, '') };
-    }
-    const tilePostprocessed = {
-        ...tile,
-        id: tileContentUrl,
-        contentUrl: tileContentUrl,
-        lodMetricType: tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR,
-        lodMetricValue: tile.geometricError,
-        transformMatrix: tile.transform,
-        type: getTileType(tile, tileContentUrl),
-        refine: getRefine(tile.refine),
-        content: tileContent || tile.content,
-        children
-    };
-    return tilePostprocessed;
-}
-exports.normalizeImplicitTileData = normalizeImplicitTileData;
-/**
- * Implicit Tiling data can be in 3DTILES_implicit_tiling for 3DTiles v.Next or directly in implicitTiling object for 3DTiles v1.1.
- * Spec 3DTiles v.Next - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
- * Spec 3DTiles v.1.1 - https://github.com/CesiumGS/3d-tiles/tree/draft-1.1/specification/ImplicitTiling
- * @param tile
- * @returns
- */
-function getImplicitTilingExtensionData(tile) {
-    return tile?.extensions?.['3DTILES_implicit_tiling'] || tile?.implicitTiling;
-}

package/dist/lib/parsers/parse-3d-tile-instanced-model.js

@@ -1,172 +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
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInstancedModel3DTile = void 0;
-const core_1 = require("@math.gl/core");
-const geospatial_1 = require("@math.gl/geospatial");
-const math_1 = require("@loaders.gl/math"); // 'math.gl/geometry';
-const tile_3d_feature_table_1 = __importDefault(require("../classes/tile-3d-feature-table"));
-const tile_3d_batch_table_1 = __importDefault(require("../classes/tile-3d-batch-table"));
-const parse_3d_tile_header_1 = require("./helpers/parse-3d-tile-header");
-const parse_3d_tile_tables_1 = require("./helpers/parse-3d-tile-tables");
-const parse_3d_tile_gltf_view_1 = require("./helpers/parse-3d-tile-gltf-view");
-async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
-    byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
-    await (0, parse_3d_tile_gltf_view_1.extractGLTF)(tile, tile.gltfFormat || 0, options, context);
-    return byteOffset;
-}
-exports.parseInstancedModel3DTile = parseInstancedModel3DTile;
-function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
-    byteOffset = (0, parse_3d_tile_header_1.parse3DTileHeaderSync)(tile, arrayBuffer, byteOffset);
-    if (tile.version !== 1) {
-        throw new Error(`Instanced 3D Model version ${tile.version} is not supported`);
-    }
-    byteOffset = (0, parse_3d_tile_tables_1.parse3DTileTablesHeaderSync)(tile, arrayBuffer, byteOffset);
-    const view = new DataView(arrayBuffer);
-    tile.gltfFormat = view.getUint32(byteOffset, true);
-    byteOffset += 4;
-    // PARSE FEATURE TABLE
-    byteOffset = (0, parse_3d_tile_tables_1.parse3DTileTablesSync)(tile, arrayBuffer, byteOffset, options);
-    byteOffset = (0, parse_3d_tile_gltf_view_1.parse3DTileGLTFViewSync)(tile, arrayBuffer, byteOffset, options);
-    // TODO - Is the feature table sometimes optional or can check be moved into table header parser?
-    if (!tile?.header?.featureTableJsonByteLength || tile.header.featureTableJsonByteLength === 0) {
-        throw new Error('i3dm parser: featureTableJsonByteLength is zero.');
-    }
-    const featureTable = new tile_3d_feature_table_1.default(tile.featureTableJson, tile.featureTableBinary);
-    const instancesLength = featureTable.getGlobalProperty('INSTANCES_LENGTH');
-    featureTable.featuresLength = instancesLength;
-    if (!Number.isFinite(instancesLength)) {
-        throw new Error('i3dm parser: INSTANCES_LENGTH must be defined');
-    }
-    tile.eastNorthUp = featureTable.getGlobalProperty('EAST_NORTH_UP');
-    tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', math_1.GL.FLOAT, 3);
-    const batchTable = new tile_3d_batch_table_1.default(tile.batchTableJson, tile.batchTableBinary, instancesLength);
-    extractInstancedAttributes(tile, featureTable, batchTable, instancesLength);
-    return byteOffset;
-}
-// eslint-disable-next-line max-statements, complexity
-function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
-    const instances = new Array(instancesLength);
-    const instancePosition = new core_1.Vector3();
-    const instanceNormalRight = new core_1.Vector3();
-    const instanceNormalUp = new core_1.Vector3();
-    const instanceNormalForward = new core_1.Vector3();
-    const instanceRotation = new core_1.Matrix3();
-    const instanceQuaternion = new core_1.Quaternion();
-    const instanceScale = new core_1.Vector3();
-    const instanceTranslationRotationScale = {};
-    const instanceTransform = new core_1.Matrix4();
-    const scratch1 = [];
-    const scratch2 = [];
-    const scratch3 = [];
-    const scratch4 = [];
-    for (let i = 0; i < instancesLength; i++) {
-        let position;
-        // Get the instance position
-        if (featureTable.hasProperty('POSITION')) {
-            position = featureTable.getProperty('POSITION', math_1.GL.FLOAT, 3, i, instancePosition);
-        }
-        else if (featureTable.hasProperty('POSITION_QUANTIZED')) {
-            position = featureTable.getProperty('POSITION_QUANTIZED', math_1.GL.UNSIGNED_SHORT, 3, i, instancePosition);
-            const quantizedVolumeOffset = featureTable.getGlobalProperty('QUANTIZED_VOLUME_OFFSET', math_1.GL.FLOAT, 3);
-            if (!quantizedVolumeOffset) {
-                throw new Error('i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.');
-            }
-            const quantizedVolumeScale = featureTable.getGlobalProperty('QUANTIZED_VOLUME_SCALE', math_1.GL.FLOAT, 3);
-            if (!quantizedVolumeScale) {
-                throw new Error('i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.');
-            }
-            const MAX_UNSIGNED_SHORT = 65535.0;
-            for (let j = 0; j < 3; j++) {
-                position[j] =
-                    (position[j] / MAX_UNSIGNED_SHORT) * quantizedVolumeScale[j] + quantizedVolumeOffset[j];
-            }
-        }
-        if (!position) {
-            throw new Error('i3dm: POSITION or POSITION_QUANTIZED must be defined for each instance.');
-        }
-        instancePosition.copy(position);
-        // @ts-expect-error
-        instanceTranslationRotationScale.translation = instancePosition;
-        // Get the instance rotation
-        tile.normalUp = featureTable.getProperty('NORMAL_UP', math_1.GL.FLOAT, 3, i, scratch1);
-        tile.normalRight = featureTable.getProperty('NORMAL_RIGHT', math_1.GL.FLOAT, 3, i, scratch2);
-        const hasCustomOrientation = false;
-        if (tile.normalUp) {
-            if (!tile.normalRight) {
-                throw new Error('i3dm: Custom orientation requires both NORMAL_UP and NORMAL_RIGHT.');
-            }
-            // Vector3.unpack(normalUp, 0, instanceNormalUp);
-            // Vector3.unpack(normalRight, 0, instanceNormalRight);
-            tile.hasCustomOrientation = true;
-        }
-        else {
-            tile.octNormalUp = featureTable.getProperty('NORMAL_UP_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, i, scratch1);
-            tile.octNormalRight = featureTable.getProperty('NORMAL_RIGHT_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, i, scratch2);
-            if (tile.octNormalUp) {
-                if (!tile.octNormalRight) {
-                    throw new Error('i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P');
-                }
-                throw new Error('i3dm: oct-encoded orientation not implemented');
-                /*
-                AttributeCompression.octDecodeInRange(octNormalUp[0], octNormalUp[1], 65535, instanceNormalUp);
-                AttributeCompression.octDecodeInRange(octNormalRight[0], octNormalRight[1], 65535, instanceNormalRight);
-                hasCustomOrientation = true;
-                */
-            }
-            else if (tile.eastNorthUp) {
-                geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
-                instanceTransform.getRotationMatrix3(instanceRotation);
-            }
-            else {
-                instanceRotation.identity();
-            }
-        }
-        if (hasCustomOrientation) {
-            instanceNormalForward.copy(instanceNormalRight).cross(instanceNormalUp).normalize();
-            instanceRotation.setColumn(0, instanceNormalRight);
-            instanceRotation.setColumn(1, instanceNormalUp);
-            instanceRotation.setColumn(2, instanceNormalForward);
-        }
-        instanceQuaternion.fromMatrix3(instanceRotation);
-        // @ts-expect-error
-        instanceTranslationRotationScale.rotation = instanceQuaternion;
-        // Get the instance scale
-        instanceScale.set(1.0, 1.0, 1.0);
-        const scale = featureTable.getProperty('SCALE', math_1.GL.FLOAT, 1, i, scratch3);
-        if (Number.isFinite(scale)) {
-            instanceScale.multiplyByScalar(scale);
-        }
-        const nonUniformScale = featureTable.getProperty('SCALE_NON_UNIFORM', math_1.GL.FLOAT, 3, i, scratch1);
-        if (nonUniformScale) {
-            instanceScale.scale(nonUniformScale);
-        }
-        // @ts-expect-error
-        instanceTranslationRotationScale.scale = instanceScale;
-        // Get the batchId
-        let batchId = featureTable.getProperty('BATCH_ID', math_1.GL.UNSIGNED_SHORT, 1, i, scratch4);
-        if (batchId === undefined) {
-            // If BATCH_ID semantic is undefined, batchId is just the instance number
-            batchId = i;
-        }
-        // @ts-expect-error
-        const rotationMatrix = new core_1.Matrix4().fromQuaternion(instanceTranslationRotationScale.rotation);
-        // Create the model matrix and the instance
-        instanceTransform.identity();
-        // @ts-expect-error
-        instanceTransform.translate(instanceTranslationRotationScale.translation);
-        instanceTransform.multiplyRight(rotationMatrix);
-        // @ts-expect-error
-        instanceTransform.scale(instanceTranslationRotationScale.scale);
-        const modelMatrix = instanceTransform.clone();
-        instances[i] = {
-            modelMatrix,
-            batchId
-        };
-    }
-    tile.instances = instances;
-}