@loaders.gl/3d-tiles 3.1.0-alpha.5 → 3.1.0-beta.1

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/3d-tiles",
-  "version": "3.1.0-alpha.5",
+  "version": "3.1.0-beta.1",
   "description": "3D Tiles, an open standard for streaming massive heterogeneous 3D geospatial datasets.",
   "license": "MIT",
   "publishConfig": {
@@ -31,20 +31,19 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle",
-    "post-build": "tsc",
-    "build-bundle": "webpack --display=minimal --config ../../scripts/webpack/bundle.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js"
   },
   "dependencies": {
-    "@loaders.gl/draco": "3.1.0-alpha.5",
-    "@loaders.gl/gltf": "3.1.0-alpha.5",
-    "@loaders.gl/loader-utils": "3.1.0-alpha.5",
-    "@loaders.gl/math": "3.1.0-alpha.5",
-    "@loaders.gl/tiles": "3.1.0-alpha.5",
+    "@loaders.gl/draco": "3.1.0-beta.1",
+    "@loaders.gl/gltf": "3.1.0-beta.1",
+    "@loaders.gl/loader-utils": "3.1.0-beta.1",
+    "@loaders.gl/math": "3.1.0-beta.1",
+    "@loaders.gl/tiles": "3.1.0-beta.1",
     "@math.gl/core": "^3.5.1",
     "@math.gl/geospatial": "^3.5.1"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "^3.0.0"
+    "@loaders.gl/core": "4.0.0-alpha.4"
   },
-  "gitHead": "352241dd910a8c6307a235dadbe154ca915b885b"
+  "gitHead": "980cdefb4e8ec9ef9c951d20c78cf77777707f49"
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 // LOADERS
 export {Tiles3DLoader} from './tiles-3d-loader';
 export {CesiumIonLoader} from './cesium-ion-loader';
+export {Tile3DSubtreeLoader} from './tile-3d-subtree-loader';
 
 // WRITERS
 export {Tile3DWriter} from './tile-3d-writer';

package/src/lib/classes/{tile-3d-batch-table.js → tile-3d-batch-table.ts}

@@ -21,6 +21,16 @@ const IGNORED_PROPERTY_FIELDS = {
 
 // The size of this array equals the maximum instance count among all loaded tiles, which has the potential to be large.
 export default class Tile3DBatchTableParser {
+  json;
+  binary;
+  featureCount;
+  _extensions;
+  // Copy all top-level property fields from the json object, ignoring special fields
+  _properties;
+  _binaryProperties;
+  // TODO: hierarchy support is only partially implemented and not tested
+  _hierarchy;
+
   constructor(json, binary, featureCount, options = {}) {
     assert(featureCount >= 0);
     this.json = json || {};
@@ -49,11 +59,11 @@ export default class Tile3DBatchTableParser {
     return this.json && this.json.extensions && this.json.extensions[extensionName];
   }
 
-  memorySizeInBytes() {
+  memorySizeInBytes(): number {
     return 0;
   }
 
-  isClass(batchId, className) {
+  isClass(batchId, className: string): boolean {
     this._checkBatchId(batchId);
     assert(typeof className === 'string', className);
 
@@ -178,7 +188,7 @@ export default class Tile3DBatchTableParser {
   _checkBatchId(batchId) {
     const valid = batchId >= 0 && batchId < this.featureCount;
     if (!valid) {
-      throw new Error(`batchId not in range [0, featureCount - 1].`);
+      throw new Error('batchId not in range [0, featureCount - 1].');
     }
   }
 
@@ -191,7 +201,7 @@ export default class Tile3DBatchTableParser {
   }
 
   _initializeBinaryProperties() {
-    let binaryProperties = null;
+    let binaryProperties: Record<string, any> | null = null;
     for (const name in this._properties) {
       const property = this._properties[name];
       const binaryProperty = this._initializeBinaryProperty(name, property);

package/src/lib/classes/{tile-3d-feature-table.js → tile-3d-feature-table.ts}

@@ -6,11 +6,14 @@ import {GL, GLType} from '@loaders.gl/math';
 // Reference:
 // https://github.com/AnalyticalGraphicsInc/cesium/blob/1de96d087f0b17575eb1a3f736407b348c765d59/Source/Scene/Cesium3DTileFeatureTable.js
 export default class Tile3DFeatureTable {
+  json;
+  buffer;
+  featuresLength = 0;
+  _cachedTypedArrays = {};
+
   constructor(featureTableJson, featureTableBinary) {
     this.json = featureTableJson;
     this.buffer = featureTableBinary;
-    this.featuresLength = 0;
-    this._cachedTypedArrays = {};
   }
 
   getExtension(extensionName) {

package/src/lib/parsers/helpers/{normalize-3d-tile-colors.js → normalize-3d-tile-colors.ts}

@@ -1,7 +1,7 @@
 import {decodeRGB565, GL} from '@loaders.gl/math';
 
 /* eslint-disable complexity*/
-export function normalize3DTileColorAttribute(tile, colors, batchTable) {
+export function normalize3DTileColorAttribute(tile, colors, batchTable?) {
   // no colors defined
   if (!colors && (!tile || !tile.batchIds || !batchTable)) {
     return null;

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

@@ -90,6 +90,6 @@ function extractGLTFBufferOrURL(tile, gltfFormat, options) {
     case GLTF_FORMAT.EMBEDDED:
       break;
     default:
-      throw new Error(`b3dm: Illegal glTF format field`);
+      throw new Error('b3dm: Illegal glTF format field');
   }
 }

package/src/lib/parsers/helpers/parse-3d-tile-subtree.ts

@@ -0,0 +1,104 @@
+import type {SubtreeAvailability, ExplicitBitstream} from '../../../types';
+import {fetchFile} from '@loaders.gl/core';
+
+const SUBTREE_FILE_MAGIC = 0x74627573;
+const SUBTREE_FILE_VERSION = 1;
+
+/**
+ * Parse subtree file
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ * @param data
+ * @returns
+ */
+export default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<SubtreeAvailability> {
+  const magic = new Uint32Array(data.slice(0, 4));
+
+  if (magic[0] !== SUBTREE_FILE_MAGIC) {
+    throw new Error('Wrong subtree file magic number');
+  }
+
+  const version = new Uint32Array(data.slice(4, 8));
+
+  if (version[0] !== SUBTREE_FILE_VERSION) {
+    throw new Error('Wrong subtree file verson, must be 1');
+  }
+
+  const jsonByteLength = parseUint64Value(data.slice(8, 16));
+  const stringAttribute = new Uint8Array(data, 24, jsonByteLength);
+
+  const textDecoder = new TextDecoder('utf8');
+  const string = textDecoder.decode(stringAttribute);
+  const subtree = JSON.parse(string);
+
+  const binaryByteLength = parseUint64Value(data.slice(16, 24));
+  let internalBinaryBuffer = new ArrayBuffer(0);
+
+  if (binaryByteLength) {
+    internalBinaryBuffer = data.slice(24 + jsonByteLength);
+  }
+
+  if ('bufferView' in subtree.tileAvailability) {
+    subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'tileAvailability',
+      internalBinaryBuffer
+    );
+  }
+
+  if ('bufferView' in subtree.contentAvailability) {
+    subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'contentAvailability',
+      internalBinaryBuffer
+    );
+  }
+
+  if ('bufferView' in subtree.childSubtreeAvailability) {
+    subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'childSubtreeAvailability',
+      internalBinaryBuffer
+    );
+  }
+
+  return subtree;
+}
+
+/**
+ * Get explicit bitstream for subtree availability data.
+ * @param subtree
+ * @param name
+ * @param internalBinaryBuffer
+ */
+async function getExplicitBitstream(
+  subtree: SubtreeAvailability,
+  name: string,
+  internalBinaryBuffer: ArrayBuffer
+): Promise<ExplicitBitstream> {
+  const bufferViewIndex = subtree[name].bufferView;
+  const bufferView = subtree.bufferViews[bufferViewIndex];
+  const buffer = subtree.buffers[bufferView.buffer];
+
+  // External bitstream loading
+  if (buffer.uri) {
+    const response = await fetchFile(buffer.uri);
+    const data = await response.arrayBuffer();
+    // Return view of bitstream.
+    return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+  }
+  // Return view of bitstream.
+  return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+}
+
+/**
+ * Parse buffer to return uint64 value
+ * @param buffer
+ * @returns 64-bit value until precision is lost after Number.MAX_SAFE_INTEGER
+ */
+function parseUint64Value(buffer: ArrayBuffer): number {
+  const dataView = new DataView(buffer);
+  const left = dataView.getUint32(0, true);
+  const right = dataView.getUint32(4, true);
+  // combine the two 32-bit values
+  return left + 2 ** 32 * right;
+}

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

@@ -4,7 +4,7 @@
 import {getStringFromArrayBuffer} from './parse-utils';
 
 const SIZEOF_UINT32 = 4;
-const DEPRECATION_WARNING = `b3dm tile in legacy format.`;
+const DEPRECATION_WARNING = 'b3dm tile in legacy format.';
 
 // eslint-disable-next-line max-statements
 export function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {

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

@@ -53,7 +53,7 @@ export function normalizeTileHeaders(tileset) {
   const basePath = tileset.basePath;
   const root = normalizeTileData(tileset.root, tileset);
 
-  const stack = [];
+  const stack: any[] = [];
   stack.push(root);
 
   while (stack.length > 0) {

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

@@ -146,6 +146,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instancePosition.copy(position);
+    // @ts-expect-error
     instanceTranslationRotationScale.translation = instancePosition;
 
     // Get the instance rotation
@@ -203,6 +204,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instanceQuaternion.fromMatrix3(instanceRotation);
+    // @ts-expect-error
     instanceTranslationRotationScale.rotation = instanceQuaternion;
 
     // Get the instance scale
@@ -216,6 +218,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       instanceScale.scale(nonUniformScale);
     }
 
+    // @ts-expect-error
     instanceTranslationRotationScale.scale = instanceScale;
 
     // Get the batchId
@@ -225,12 +228,15 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       batchId = i;
     }
 
+    // @ts-expect-error
     const rotationMatrix = new 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();

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

@@ -137,7 +137,7 @@ function parseNormals(tile, featureTable) {
 }
 
 function parseBatchIds(tile, featureTable) {
-  let batchTable = null;
+  let batchTable: Tile3DBatchTable | null = null;
   if (!tile.batchIds && featureTable.hasProperty('BATCH_ID')) {
     tile.batchIds = featureTable.getPropertyArray('BATCH_ID', GL.UNSIGNED_SHORT, 1);
 
@@ -250,7 +250,7 @@ export async function loadDraco(tile, dracoData, options, context) {
 
   tile.attributes = {
     positions: decodedPositions,
-    colors: normalize3DTileColorAttribute(tile, decodedColors),
+    colors: normalize3DTileColorAttribute(tile, decodedColors, undefined),
     normals: decodedNormals,
     batchIds: decodedBatchIds,
     ...batchTableAttributes

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

@@ -11,9 +11,12 @@ import {parseComposite3DTile} from './parse-3d-tile-composite';
 
 // 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
@@ -36,6 +39,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/types.ts

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