@loaders.gl/3d-tiles 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/lib/parsers/helpers/parse-3d-implicit-tiles.js

@@ -1,3 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
 import { Tile3DSubtreeLoader } from "../../../tile-3d-subtree-loader.js";
 import { load } from '@loaders.gl/core';
 import { default as log } from '@probe.gl/log';
@@ -6,260 +9,292 @@ import { convertS2BoundingVolumetoOBB } from "../../utils/obb/s2-corners-to-obb.
 const QUADTREE_DIVISION_COUNT = 4;
 const OCTREE_DIVISION_COUNT = 8;
 const SUBDIVISION_COUNT_MAP = {
-  QUADTREE: QUADTREE_DIVISION_COUNT,
-  OCTREE: OCTREE_DIVISION_COUNT
+    QUADTREE: QUADTREE_DIVISION_COUNT,
+    OCTREE: OCTREE_DIVISION_COUNT
 };
 function getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme) {
-  if (s2VolumeBox !== null && s2VolumeBox !== void 0 && s2VolumeBox.box) {
-    const cellId = getS2CellIdFromToken(s2VolumeBox.s2VolumeInfo.token);
-    const childCellId = getS2ChildCellId(cellId, index);
-    const childToken = getS2TokenFromCellId(childCellId);
-    const s2ChildVolumeInfo = {
-      ...s2VolumeBox.s2VolumeInfo
-    };
-    s2ChildVolumeInfo.token = childToken;
-    switch (subdivisionScheme) {
-      case 'OCTREE':
-        const s2VolumeInfo = s2VolumeBox.s2VolumeInfo;
-        const delta = s2VolumeInfo.maximumHeight - s2VolumeInfo.minimumHeight;
-        const sizeZ = delta / 2.0;
-        const midZ = s2VolumeInfo.minimumHeight + delta / 2.0;
-        s2VolumeInfo.minimumHeight = midZ - sizeZ;
-        s2VolumeInfo.maximumHeight = midZ + sizeZ;
-        break;
-      default:
-        break;
+    if (s2VolumeBox?.box) {
+        // Check if the BoundingVolume is of type "box"
+        const cellId = getS2CellIdFromToken(s2VolumeBox.s2VolumeInfo.token);
+        const childCellId = getS2ChildCellId(cellId, index);
+        const childToken = getS2TokenFromCellId(childCellId);
+        // Clone object. Note, s2VolumeInfo is a plain object that doesn't contain any nested object.
+        // So, we can use the Spread Operator to make a shallow copy of the object.
+        const s2ChildVolumeInfo = { ...s2VolumeBox.s2VolumeInfo };
+        s2ChildVolumeInfo.token = childToken; // replace the token with the child's one
+        // In case of QUADTREE the sizeZ should NOT be changed!
+        // https://portal.ogc.org/files/102132
+        // A quadtree divides space only on the x and y dimensions.
+        // It divides each tile into 4 smaller tiles where the x and y dimensions are halved.
+        // The quadtree z minimum and maximum remain unchanged.
+        switch (subdivisionScheme) {
+            case 'OCTREE':
+                const s2VolumeInfo = s2VolumeBox.s2VolumeInfo;
+                const delta = s2VolumeInfo.maximumHeight - s2VolumeInfo.minimumHeight;
+                const sizeZ = delta / 2.0; // It's a next level (a child)
+                const midZ = s2VolumeInfo.minimumHeight + delta / 2.0;
+                s2VolumeInfo.minimumHeight = midZ - sizeZ;
+                s2VolumeInfo.maximumHeight = midZ + sizeZ;
+                break;
+            default:
+                break;
+        }
+        const box = convertS2BoundingVolumetoOBB(s2ChildVolumeInfo);
+        const childS2VolumeBox = {
+            box,
+            s2VolumeInfo: s2ChildVolumeInfo
+        };
+        return childS2VolumeBox;
     }
-    const box = convertS2BoundingVolumetoOBB(s2ChildVolumeInfo);
-    const childS2VolumeBox = {
-      box,
-      s2VolumeInfo: s2ChildVolumeInfo
-    };
-    return childS2VolumeBox;
-  }
-  return undefined;
+    return undefined;
 }
+/**
+ * Recursively parse implicit tiles tree
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
+ * TODO Check out do we able to use Tile3D class as return type here.
+ * @param subtree
+ * @param lodMetricValue
+ * @param options
+ * @param parentData
+ * @param childIndex
+ * @param level
+ * @param globalData
+ */
+// eslint-disable-next-line max-statements
 export async function parseImplicitTiles(params) {
-  const {
-    implicitOptions,
-    parentData = {
-      mortonIndex: 0,
-      x: 0,
-      y: 0,
-      z: 0
-    },
-    childIndex = 0,
-    s2VolumeBox,
-    loaderOptions
-  } = params;
-  let {
-    subtree,
-    level = 0,
-    globalData = {
-      level: 0,
-      mortonIndex: 0,
-      x: 0,
-      y: 0,
-      z: 0
+    const { implicitOptions, parentData = {
+        mortonIndex: 0,
+        x: 0,
+        y: 0,
+        z: 0
+    }, childIndex = 0, s2VolumeBox, loaderOptions } = params;
+    let { subtree, level = 0, globalData = {
+        level: 0,
+        mortonIndex: 0,
+        x: 0,
+        y: 0,
+        z: 0
+    } } = params;
+    const { subdivisionScheme, subtreeLevels, maximumLevel, contentUrlTemplate, subtreesUriTemplate, basePath } = implicitOptions;
+    const tile = { children: [], lodMetricValue: 0, contentUrl: '' };
+    if (!maximumLevel) {
+        // eslint-disable-next-line no-console
+        log.once(`Missing 'maximumLevel' or 'availableLevels' property. The subtree ${contentUrlTemplate} won't be loaded...`);
+        return tile;
     }
-  } = params;
-  const {
-    subdivisionScheme,
-    subtreeLevels,
-    maximumLevel,
-    contentUrlTemplate,
-    subtreesUriTemplate,
-    basePath
-  } = implicitOptions;
-  const tile = {
-    children: [],
-    lodMetricValue: 0,
-    contentUrl: ''
-  };
-  if (!maximumLevel) {
-    log.once(`Missing 'maximumLevel' or 'availableLevels' property. The subtree ${contentUrlTemplate} won't be loaded...`);
-    return tile;
-  }
-  const lev = level + globalData.level;
-  if (lev > maximumLevel) {
-    return tile;
-  }
-  const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
-  const bitsPerTile = Math.log2(childrenPerTile);
-  const childX = childIndex & 0b01;
-  const childY = childIndex >> 1 & 0b01;
-  const childZ = childIndex >> 2 & 0b01;
-  const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
-  let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex, bitsPerTile);
-  let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
-  let childTileX = concatBits(parentData.x, childX, 1);
-  let childTileY = concatBits(parentData.y, childY, 1);
-  let childTileZ = concatBits(parentData.z, childZ, 1);
-  let isChildSubtreeAvailable = false;
-  if (level >= subtreeLevels) {
-    isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
-  }
-  const x = concatBits(globalData.x, childTileX, level);
-  const y = concatBits(globalData.y, childTileY, level);
-  const z = concatBits(globalData.z, childTileZ, level);
-  if (isChildSubtreeAvailable) {
-    const subtreePath = `${basePath}/${subtreesUriTemplate}`;
-    const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
-    const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
-    subtree = childSubtree;
-    globalData = {
-      mortonIndex: childTileMortonIndex,
-      x: childTileX,
-      y: childTileY,
-      z: childTileZ,
-      level
-    };
-    childTileMortonIndex = 0;
-    tileAvailabilityIndex = 0;
-    childTileX = 0;
-    childTileY = 0;
-    childTileZ = 0;
-    level = 0;
-  }
-  const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
-  if (!isTileAvailable) {
-    return tile;
-  }
-  const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
-  if (isContentAvailable) {
-    tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
-  }
-  const childTileLevel = level + 1;
-  const pData = {
-    mortonIndex: childTileMortonIndex,
-    x: childTileX,
-    y: childTileY,
-    z: childTileZ
-  };
-  for (let index = 0; index < childrenPerTile; index++) {
-    const childS2VolumeBox = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
-    const childTileParsed = await parseImplicitTiles({
-      subtree,
-      implicitOptions,
-      loaderOptions,
-      parentData: pData,
-      childIndex: index,
-      level: childTileLevel,
-      globalData: {
-        ...globalData
-      },
-      s2VolumeBox: childS2VolumeBox
-    });
-    if (childTileParsed.contentUrl || childTileParsed.children.length) {
-      const globalLevel = lev + 1;
-      const childCoordinates = {
-        childTileX,
-        childTileY,
-        childTileZ
-      };
-      const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, implicitOptions, s2VolumeBox);
-      tile.children.push(formattedTile);
+    const lev = level + globalData.level;
+    if (lev > maximumLevel) {
+        return tile;
+    }
+    const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
+    const bitsPerTile = Math.log2(childrenPerTile);
+    // childIndex is in range [0,4] for quadtrees and [0, 7] for octrees
+    const childX = childIndex & 0b01; // Get first bit for X
+    const childY = (childIndex >> 1) & 0b01; // Get second bit for Y
+    const childZ = (childIndex >> 2) & 0b01; // Get third bit for Z
+    const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
+    let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex, bitsPerTile);
+    let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
+    // Local tile coordinates
+    let childTileX = concatBits(parentData.x, childX, 1);
+    let childTileY = concatBits(parentData.y, childY, 1);
+    let childTileZ = concatBits(parentData.z, childZ, 1);
+    let isChildSubtreeAvailable = false;
+    if (level >= subtreeLevels) {
+        isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
+    }
+    const x = concatBits(globalData.x, childTileX, level);
+    const y = concatBits(globalData.y, childTileY, level);
+    const z = concatBits(globalData.z, childTileZ, level);
+    if (isChildSubtreeAvailable) {
+        const subtreePath = `${basePath}/${subtreesUriTemplate}`;
+        const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
+        const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
+        subtree = childSubtree;
+        globalData = {
+            mortonIndex: childTileMortonIndex,
+            x: childTileX,
+            y: childTileY,
+            z: childTileZ,
+            level
+        };
+        childTileMortonIndex = 0;
+        tileAvailabilityIndex = 0;
+        childTileX = 0;
+        childTileY = 0;
+        childTileZ = 0;
+        level = 0;
+    }
+    const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
+    if (!isTileAvailable) {
+        return tile;
+    }
+    const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
+    if (isContentAvailable) {
+        tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
+    }
+    const childTileLevel = level + 1;
+    const pData = { mortonIndex: childTileMortonIndex, x: childTileX, y: childTileY, z: childTileZ };
+    for (let index = 0; index < childrenPerTile; index++) {
+        const childS2VolumeBox = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
+        // Recursive calling...
+        const childTileParsed = await parseImplicitTiles({
+            subtree,
+            implicitOptions,
+            loaderOptions,
+            parentData: pData,
+            childIndex: index,
+            level: childTileLevel,
+            globalData: { ...globalData },
+            s2VolumeBox: childS2VolumeBox
+        });
+        if (childTileParsed.contentUrl || childTileParsed.children.length) {
+            const globalLevel = lev + 1;
+            const childCoordinates = { childTileX, childTileY, childTileZ };
+            const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, implicitOptions, s2VolumeBox);
+            // @ts-ignore
+            tile.children.push(formattedTile);
+        }
     }
-  }
-  return tile;
+    return tile;
 }
+/**
+ * Check tile availability in the bitstream array
+ * @param availabilityData - tileAvailability / contentAvailability / childSubtreeAvailability object
+ * @param index - index in the bitstream array
+ * @returns
+ */
 function getAvailabilityResult(availabilityData, index) {
-  let availabilityObject;
-  if (Array.isArray(availabilityData)) {
-    availabilityObject = availabilityData[0];
-    if (availabilityData.length > 1) {
-      log.once('Not supported extension "3DTILES_multiple_contents" has been detected');
+    let availabilityObject;
+    if (Array.isArray(availabilityData)) {
+        /** TODO: we don't support `3DTILES_multiple_contents` extension at the moment.
+         * https://github.com/CesiumGS/3d-tiles/blob/main/extensions/3DTILES_implicit_tiling/README.md#multiple-contents
+         * Take first item in the array
+         */
+        availabilityObject = availabilityData[0];
+        if (availabilityData.length > 1) {
+            // eslint-disable-next-line no-console
+            log.once('Not supported extension "3DTILES_multiple_contents" has been detected');
+        }
+    }
+    else {
+        availabilityObject = availabilityData;
+    }
+    if ('constant' in availabilityObject) {
+        return Boolean(availabilityObject.constant);
     }
-  } else {
-    availabilityObject = availabilityData;
-  }
-  if ('constant' in availabilityObject) {
-    return Boolean(availabilityObject.constant);
-  }
-  if (availabilityObject.explicitBitstream) {
-    return getBooleanValueFromBitstream(index, availabilityObject.explicitBitstream);
-  }
-  return false;
+    if (availabilityObject.explicitBitstream) {
+        return getBooleanValueFromBitstream(index, availabilityObject.explicitBitstream);
+    }
+    return false;
 }
+/**
+ * Do formatting of implicit tile data.
+ * TODO Check out do we able to use Tile3D class as type here.
+ * @param tile
+ * @param lodMetricValue
+ * @param options
+ * @returns
+ */
 function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
-  const {
-    basePath,
-    refine,
-    getRefine,
-    lodMetricType,
-    getTileType,
-    rootLodMetricValue,
-    rootBoundingVolume
-  } = options;
-  const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, '');
-  const lodMetricValue = rootLodMetricValue / 2 ** level;
-  const boundingVolume = s2VolumeBox !== null && s2VolumeBox !== void 0 && s2VolumeBox.box ? {
-    box: s2VolumeBox.box
-  } : rootBoundingVolume;
-  const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(level, boundingVolume, childCoordinates);
-  return {
-    children: tile.children,
-    contentUrl: tile.contentUrl,
-    content: {
-      uri
-    },
-    id: tile.contentUrl,
-    refine: getRefine(refine),
-    type: getTileType(tile),
-    lodMetricType,
-    lodMetricValue,
-    geometricError: lodMetricValue,
-    transform: tile.transform,
-    boundingVolume: boundingVolumeForChildTile
-  };
-}
-function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates) {
-  if (rootBoundingVolume.region) {
-    const {
-      childTileX,
-      childTileY,
-      childTileZ
-    } = childCoordinates;
-    const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
-    const boundingVolumesCount = 2 ** level;
-    const sizeX = (east - west) / boundingVolumesCount;
-    const sizeY = (north - south) / boundingVolumesCount;
-    const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
-    const [childWest, childEast] = [west + sizeX * childTileX, west + sizeX * (childTileX + 1)];
-    const [childSouth, childNorth] = [south + sizeY * childTileY, south + sizeY * (childTileY + 1)];
-    const [childMinimumHeight, childMaximumHeight] = [minimumHeight + sizeZ * childTileZ, minimumHeight + sizeZ * (childTileZ + 1)];
+    const { basePath, refine, getRefine, lodMetricType, getTileType, rootLodMetricValue, rootBoundingVolume } = options;
+    const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, '');
+    const lodMetricValue = rootLodMetricValue / 2 ** level;
+    const boundingVolume = s2VolumeBox?.box
+        ? { box: s2VolumeBox.box }
+        : rootBoundingVolume;
+    const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(level, boundingVolume, childCoordinates);
     return {
-      region: [childWest, childSouth, childEast, childNorth, childMinimumHeight, childMaximumHeight]
+        children: tile.children,
+        contentUrl: tile.contentUrl,
+        content: { uri },
+        id: tile.contentUrl,
+        refine: getRefine(refine),
+        type: getTileType(tile),
+        lodMetricType,
+        lodMetricValue,
+        geometricError: lodMetricValue,
+        transform: tile.transform,
+        boundingVolume: boundingVolumeForChildTile
     };
-  }
-  if (rootBoundingVolume.box) {
-    return rootBoundingVolume;
-  }
-  throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
 }
+/**
+ * Calculate child bounding volume.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subdivision-rules
+ * @param level
+ * @param rootBoundingVolume
+ * @param childCoordinates
+ */
+function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates) {
+    if (rootBoundingVolume.region) {
+        const { childTileX, childTileY, childTileZ } = childCoordinates;
+        const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
+        const boundingVolumesCount = 2 ** level;
+        const sizeX = (east - west) / boundingVolumesCount;
+        const sizeY = (north - south) / boundingVolumesCount;
+        // TODO : Why is the subdivisionScheme not being checked here?
+        // In case of QUADTREE the sizeZ should NOT be changed!
+        // https://portal.ogc.org/files/102132
+        // A quadtree divides space only on the x and y dimensions. It divides each tile into 4 smaller tiles where the x and y dimensions are halved. The quadtree z minimum and maximum remain unchanged.
+        const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
+        const [childWest, childEast] = [west + sizeX * childTileX, west + sizeX * (childTileX + 1)];
+        const [childSouth, childNorth] = [south + sizeY * childTileY, south + sizeY * (childTileY + 1)];
+        const [childMinimumHeight, childMaximumHeight] = [
+            minimumHeight + sizeZ * childTileZ,
+            minimumHeight + sizeZ * (childTileZ + 1)
+        ];
+        return {
+            region: [childWest, childSouth, childEast, childNorth, childMinimumHeight, childMaximumHeight]
+        };
+    }
+    if (rootBoundingVolume.box) {
+        return rootBoundingVolume;
+    }
+    throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
+}
+/**
+ * Do binary concatenation
+ * @param higher - number to put to higher part of result
+ * @param lower - number to put to lower part of result
+ * @param shift - number of bits to shift lower number
+ */
 function concatBits(higher, lower, shift) {
-  return (higher << shift) + lower;
+    return (higher << shift) + lower;
 }
+/**
+ * Replace implicit tile content url with real coordinates.
+ * @param templateUrl
+ * @param level
+ * @param x
+ * @param y
+ * @param z
+ */
 export function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
-  const mapUrl = generateMapUrl({
-    level,
-    x,
-    y,
-    z
-  });
-  return templateUrl.replace(/{level}|{x}|{y}|{z}/gi, matched => mapUrl[matched]);
+    const mapUrl = generateMapUrl({ level, x, y, z });
+    return templateUrl.replace(/{level}|{x}|{y}|{z}/gi, (matched) => mapUrl[matched]);
 }
+/**
+ * Get Map object for content url generation
+ * @param items
+ */
 function generateMapUrl(items) {
-  const mapUrl = {};
-  for (const key in items) {
-    mapUrl[`{${key}}`] = items[key];
-  }
-  return mapUrl;
+    const mapUrl = {};
+    for (const key in items) {
+        mapUrl[`{${key}}`] = items[key];
+    }
+    return mapUrl;
 }
+/**
+ * Get boolean value from bistream by index
+ * A boolean value is encoded as a single bit, either 0 (false) or 1 (true).
+ * Multiple boolean values are packed tightly in the same buffer.
+ * These buffers of tightly-packed bits are sometimes referred to as bitstreams.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/implicit-revisions/specification/Metadata#booleans
+ * @param availabilitiIndex
+ */
 function getBooleanValueFromBitstream(availabilityIndex, availabilityBuffer) {
-  const byteIndex = Math.floor(availabilityIndex / 8);
-  const bitIndex = availabilityIndex % 8;
-  const bitValue = availabilityBuffer[byteIndex] >> bitIndex & 1;
-  return bitValue === 1;
+    const byteIndex = Math.floor(availabilityIndex / 8);
+    const bitIndex = availabilityIndex % 8;
+    const bitValue = (availabilityBuffer[byteIndex] >> bitIndex) & 1;
+    return bitValue === 1;
 }
-//# sourceMappingURL=parse-3d-implicit-tiles.js.map

package/dist/lib/parsers/helpers/parse-3d-tile-gltf-view.d.ts

@@ -1,6 +1,6 @@
 import { LoaderContext } from '@loaders.gl/loader-utils';
-import { Tiles3DTileContent } from '../../../types';
-import { Tiles3DLoaderOptions } from '../../../tiles-3d-loader';
+import { Tiles3DTileContent } from "../../../types.js";
+import { Tiles3DLoaderOptions } from "../../../tiles-3d-loader.js";
 export declare const GLTF_FORMAT: {
     URI: number;
     EMBEDDED: number;

package/dist/lib/parsers/helpers/parse-3d-tile-gltf-view.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-3d-tile-gltf-view.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts"],"names":[],"mappings":"AAcA,OAAO,EAAC,aAAa,EAAqC,MAAM,0BAA0B,CAAC;AAC3F,OAAO,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAE9D,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,GAAG,SAAS,UAqC1C;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,kBAAkB,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CA8Bf"}
+{"version":3,"file":"parse-3d-tile-gltf-view.d.ts","sourceRoot":"","sources":["../../../../src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts"],"names":[],"mappings":"AAcA,OAAO,EAAC,aAAa,EAAqC,MAAM,0BAA0B,CAAC;AAC3F,OAAO,EAAC,kBAAkB,EAAC,0BAAuB;AAClD,OAAO,EAAC,oBAAoB,EAAC,oCAAiC;AAE9D,eAAO,MAAM,WAAW;;;CAGvB,CAAC;AAEF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,kBAAkB,EACxB,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,GAAG,SAAS,UAqC1C;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,kBAAkB,EACxB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CA8Bf"}