@loaders.gl/3d-tiles 4.3.0-alpha.6 → 4.3.0-alpha.8

package/dist/index.cjs

@@ -48,7 +48,7 @@ var import_loader_utils8 = require("@loaders.gl/loader-utils");
 var import_tiles2 = require("@loaders.gl/tiles");
 
 // dist/lib/utils/version.js
-var VERSION = true ? "4.3.0-alpha.5" : "latest";
+var VERSION = true ? "4.3.0-alpha.7" : "latest";
 
 // dist/lib/constants.js
 var TILE3D_TYPE = {
@@ -1810,95 +1810,89 @@ function getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme) {
   return void 0;
 }
 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 = {
+  const { subtree, subtreeData = {
     level: 0,
-    mortonIndex: 0,
     x: 0,
     y: 0,
     z: 0
-  } } = params;
+  }, parentData = {
+    mortonIndex: 0,
+    localLevel: -1,
+    localX: 0,
+    localY: 0,
+    localZ: 0
+  }, childIndex = 0, implicitOptions, loaderOptions, s2VolumeBox } = params;
   const { subdivisionScheme, subtreeLevels, maximumLevel, contentUrlTemplate, subtreesUriTemplate, basePath } = implicitOptions;
   const tile = { children: [], lodMetricValue: 0, contentUrl: "" };
   if (!maximumLevel) {
     import_log.default.once(`Missing 'maximumLevel' or 'availableLevels' property. The subtree ${contentUrlTemplate} won't be loaded...`);
     return tile;
   }
-  const lev = level + globalData.level;
-  if (lev > maximumLevel) {
+  const localLevel = parentData.localLevel + 1;
+  const level = subtreeData.level + localLevel;
+  if (level > maximumLevel) {
     return tile;
   }
   const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
   const bitsPerTile = Math.log2(childrenPerTile);
-  const childX = childIndex & 1;
-  const childY = childIndex >> 1 & 1;
-  const childZ = childIndex >> 2 & 1;
-  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);
+  const lastBitX = childIndex & 1;
+  const lastBitY = childIndex >> 1 & 1;
+  const lastBitZ = childIndex >> 2 & 1;
+  const localX = concatBits(parentData.localX, lastBitX, 1);
+  const localY = concatBits(parentData.localY, lastBitY, 1);
+  const localZ = concatBits(parentData.localZ, lastBitZ, 1);
+  const x = concatBits(subtreeData.x, localX, localLevel);
+  const y = concatBits(subtreeData.y, localY, localLevel);
+  const z = concatBits(subtreeData.z, localZ, localLevel);
+  const mortonIndex = concatBits(parentData.mortonIndex, childIndex, bitsPerTile);
+  const isChildSubtreeAvailable = localLevel === subtreeLevels && getAvailabilityResult(subtree.childSubtreeAvailability, mortonIndex);
+  let nextSubtree;
+  let nextSubtreeData;
+  let nextParentData;
+  let tileAvailabilityIndex;
   if (isChildSubtreeAvailable) {
     const subtreePath = `${basePath}/${subtreesUriTemplate}`;
-    const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
+    const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, level, x, y, z);
     const childSubtree = await (0, import_core7.load)(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
-    subtree = childSubtree;
-    globalData = {
-      mortonIndex: childTileMortonIndex,
-      x: childTileX,
-      y: childTileY,
-      z: childTileZ,
-      level
-    };
-    childTileMortonIndex = 0;
+    nextSubtree = childSubtree;
     tileAvailabilityIndex = 0;
-    childTileX = 0;
-    childTileY = 0;
-    childTileZ = 0;
-    level = 0;
+    nextSubtreeData = { level, x, y, z };
+    nextParentData = { mortonIndex: 0, localLevel: 0, localX: 0, localY: 0, localZ: 0 };
+  } else {
+    nextSubtree = subtree;
+    const levelOffset = (childrenPerTile ** localLevel - 1) / (childrenPerTile - 1);
+    tileAvailabilityIndex = levelOffset + mortonIndex;
+    nextSubtreeData = subtreeData;
+    nextParentData = { mortonIndex, localLevel, localX, localY, localZ };
   }
-  const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
+  const isTileAvailable = getAvailabilityResult(nextSubtree.tileAvailability, tileAvailabilityIndex);
   if (!isTileAvailable) {
     return tile;
   }
-  const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
+  const isContentAvailable = getAvailabilityResult(nextSubtree.contentAvailability, tileAvailabilityIndex);
   if (isContentAvailable) {
-    tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, lev, x, y, z);
+    tile.contentUrl = replaceContentUrlTemplate(contentUrlTemplate, level, 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,
+    const childTile = await parseImplicitTiles({
+      subtree: nextSubtree,
+      subtreeData: nextSubtreeData,
+      parentData: nextParentData,
+      childIndex: index,
       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);
+    if (childTile.contentUrl || childTile.children.length) {
+      tile.children.push(childTile);
     }
   }
+  if (tile.contentUrl || tile.children.length) {
+    const coordinates = { level, x, y, z };
+    const formattedTile = formatTileData(tile, coordinates, implicitOptions, s2VolumeBox);
+    return formattedTile;
+  }
   return tile;
 }
 function getAvailabilityResult(availabilityData, index) {
@@ -1919,12 +1913,12 @@ function getAvailabilityResult(availabilityData, index) {
   }
   return false;
 }
-function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
+function formatTileData(tile, coordinates, options, s2VolumeBox) {
   const { basePath, refine, getRefine: getRefine2, lodMetricType, getTileType: getTileType2, rootLodMetricValue, rootBoundingVolume } = options;
   const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, "");
-  const lodMetricValue = rootLodMetricValue / 2 ** level;
+  const lodMetricValue = rootLodMetricValue / 2 ** coordinates.level;
   const boundingVolume = (s2VolumeBox == null ? void 0 : s2VolumeBox.box) ? { box: s2VolumeBox.box } : rootBoundingVolume;
-  const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(level, boundingVolume, childCoordinates);
+  const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(boundingVolume, coordinates, options.subdivisionScheme);
   return {
     children: tile.children,
     contentUrl: tile.contentUrl,
@@ -1939,20 +1933,26 @@ function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
     boundingVolume: boundingVolumeForChildTile
   };
 }
-function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates) {
+function calculateBoundingVolumeForChildTile(rootBoundingVolume, coordinates, subdivisionScheme) {
   if (rootBoundingVolume.region) {
-    const { childTileX, childTileY, childTileZ } = childCoordinates;
+    const { level, x, y, z } = coordinates;
     const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
     const boundingVolumesCount = 2 ** level;
     const sizeX = (east - west) / boundingVolumesCount;
+    const [childWest, childEast] = [west + sizeX * x, west + sizeX * (x + 1)];
     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 [childSouth, childNorth] = [south + sizeY * y, south + sizeY * (y + 1)];
+    let childMinimumHeight;
+    let childMaximumHeight;
+    if (subdivisionScheme === "OCTREE") {
+      const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
+      [childMinimumHeight, childMaximumHeight] = [
+        minimumHeight + sizeZ * z,
+        minimumHeight + sizeZ * (z + 1)
+      ];
+    } else {
+      [childMinimumHeight, childMaximumHeight] = [minimumHeight, maximumHeight];
+    }
     return {
       region: [childWest, childSouth, childEast, childNorth, childMinimumHeight, childMaximumHeight]
     };
@@ -2390,7 +2390,7 @@ var parse3DTilesArchive = async (fileProvider, cb) => {
 };
 
 // dist/3d-tiles-archive-loader.js
-var VERSION2 = true ? "4.3.0-alpha.5" : "latest";
+var VERSION2 = true ? "4.3.0-alpha.7" : "latest";
 var Tiles3DArchiveFileLoader = {
   dataType: null,
   batchType: null,