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

package/src/lib/parsers/{parse-3d-tile.js → parse-3d-tile.ts}

@@ -8,12 +8,16 @@ import {parsePointCloud3DTile} from './parse-3d-tile-point-cloud';
 import {parseBatchedModel3DTile} from './parse-3d-tile-batched-model';
 import {parseInstancedModel3DTile} from './parse-3d-tile-instanced-model';
 import {parseComposite3DTile} from './parse-3d-tile-composite';
+import {parseGltf3DTile} from './parse-3d-tile-gltf';
 
 // Extracts
 export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = {}) {
+  // @ts-expect-error
   tile.byteOffset = byteOffset;
+  // @ts-expect-error
   tile.type = getMagicString(arrayBuffer, byteOffset);
 
+  // @ts-expect-error
   switch (tile.type) {
     case TILE3D_TYPE.COMPOSITE:
       // Note: We pass this function as argument so that embedded tiles can be parsed recursively
@@ -29,6 +33,9 @@ export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context,
     case TILE3D_TYPE.BATCHED_3D_MODEL:
       return await parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context);
 
+    case TILE3D_TYPE.GLTF:
+      return await parseGltf3DTile(tile, arrayBuffer, options, context);
+
     case TILE3D_TYPE.INSTANCED_3D_MODEL:
       return await parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context);
 
@@ -36,6 +43,7 @@ export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context,
       return await parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, context);
 
     default:
+      // @ts-expect-error
       throw new Error(`3DTileLoader: unknown type ${tile.type}`); // eslint-disable-line
   }
 }

package/src/tile-3d-subtree-loader.ts

@@ -0,0 +1,19 @@
+import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import parse3DTilesSubtree from './lib/parsers/helpers/parse-3d-tile-subtree';
+import {VERSION} from './lib/utils/version';
+
+/**
+ * Loader for 3D Tiles Subtree
+ *
+ */
+export const Tile3DSubtreeLoader: LoaderWithParser = {
+  id: '3d-tiles-subtree',
+  name: '3D Tiles Subtree',
+  module: '3d-tiles',
+  version: VERSION,
+  extensions: ['subtree'],
+  mimeTypes: ['application/octet-stream'],
+  tests: ['subtree'],
+  parse: parse3DTilesSubtree,
+  options: {}
+};

package/src/tiles-3d-loader.ts

@@ -3,7 +3,12 @@ import {path} from '@loaders.gl/loader-utils';
 import {TILESET_TYPE, LOD_METRIC_TYPE} from '@loaders.gl/tiles';
 import {VERSION} from './lib/utils/version';
 import {parse3DTile} from './lib/parsers/parse-3d-tile';
-import {normalizeTileHeaders} from './lib/parsers/parse-3d-tile-header';
+import {
+  normalizeTileHeaders,
+  normalizeImplicitTileHeaders
+} from './lib/parsers/parse-3d-tile-header';
+
+const IMPLICIT_TILING_EXTENSION_NAME = '3DTILES_implicit_tiling';
 
 /**
  * Loader for 3D Tiles
@@ -49,7 +54,10 @@ async function parseTileset(data, options, context) {
   tilesetJson.url = context.url;
   // base path that non-absolute paths in tileset are relative to.
   tilesetJson.basePath = getBaseUri(tilesetJson);
-  tilesetJson.root = normalizeTileHeaders(tilesetJson);
+  tilesetJson.root = hasImplicitTilingExtension(tilesetJson)
+    ? await normalizeImplicitTileHeaders(tilesetJson)
+    : normalizeTileHeaders(tilesetJson);
+
   tilesetJson.type = TILESET_TYPE.TILES3D;
 
   tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
@@ -76,3 +84,10 @@ async function parse(data, options, context) {
 
   return data;
 }
+
+function hasImplicitTilingExtension(tilesetJson) {
+  return (
+    tilesetJson?.extensionsRequired?.includes(IMPLICIT_TILING_EXTENSION_NAME) &&
+    tilesetJson?.extensionsUsed?.includes(IMPLICIT_TILING_EXTENSION_NAME)
+  );
+}

package/src/types.ts

@@ -45,7 +45,46 @@ export type Node3D = {
   };
 };
 
-type BoundingVolume = {
+export type BoundingVolume = {
   box?: number[];
   sphere?: number[];
+  region?: number[];
+};
+
+/**
+ * 3DTILES_implicit_tiling types
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ */
+export type Subtree = {
+  buffers: Buffer[];
+  bufferViews: BufferView[];
+  tileAvailability: Availability;
+  contentAvailability: Availability;
+  childSubtreeAvailability: Availability;
+};
+
+export type Availability = {
+  constant?: 0 | 1;
+  bufferView?: number;
+  // Internal bitstream type
+  explicitBitstream?: ExplicitBitstream;
+};
+
+export type ExplicitBitstream = Uint8Array;
+
+/**
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subdivision-scheme
+ */
+export type SubdivisionScheme = 'QUADTREE' | 'OCTREE';
+
+type Buffer = {
+  name: string;
+  uri?: string;
+  byteLength: number;
+};
+
+type BufferView = {
+  buffer: number;
+  byteOffset: number;
+  byteLength: number;
 };

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

@@ -1,69 +0,0 @@
-import {LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE} from '@loaders.gl/tiles';
-
-function getTileType(tile) {
-  if (!tile.contentUrl) {
-    return TILE_TYPE.EMPTY;
-  }
-
-  const contentUrl = tile.contentUrl;
-  const fileExtension = contentUrl.split('.').pop();
-  switch (fileExtension) {
-    case 'pnts':
-      return TILE_TYPE.POINTCLOUD;
-    case 'i3dm':
-    case 'b3dm':
-      return TILE_TYPE.SCENEGRAPH;
-    default:
-      return fileExtension;
-  }
-}
-
-function getRefine(refine) {
-  switch (refine) {
-    case 'REPLACE':
-    case 'replace':
-      return TILE_REFINEMENT.REPLACE;
-    case 'ADD':
-    case 'add':
-      return TILE_REFINEMENT.ADD;
-    default:
-      return refine;
-  }
-}
-
-export function normalizeTileData(tile, options) {
-  if (!tile) {
-    return null;
-  }
-  if (tile.content) {
-    const contentUri = tile.content.uri || tile.content.url;
-    tile.contentUrl = `${options.basePath}/${contentUri}`;
-  }
-  tile.id = tile.contentUrl;
-  tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-  tile.lodMetricValue = tile.geometricError;
-  tile.transformMatrix = tile.transform;
-  tile.type = getTileType(tile);
-  tile.refine = getRefine(tile.refine);
-  return tile;
-}
-
-// normalize tile headers
-export function normalizeTileHeaders(tileset) {
-  const basePath = tileset.basePath;
-  const root = normalizeTileData(tileset.root, tileset);
-
-  const stack = [];
-  stack.push(root);
-
-  while (stack.length > 0) {
-    const tile = stack.pop() || {};
-    const children = tile.children || [];
-    for (const childHeader of children) {
-      normalizeTileData(childHeader, {basePath});
-      stack.push(childHeader);
-    }
-  }
-
-  return root;
-}