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

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;
+};

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/cesium-ion-loader.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/cesium-ion-loader.ts"],"names":["Tiles3DLoader","getIonTilesetMetadata","preload","url","options","accessToken","assetId","Number","isFinite","matched","match","CesiumIonLoader","id","name","parse","data","context","loader"],"mappings":"AACA,SAAQA,aAAR,QAA4B,mBAA5B;AACA,SAAQC,qBAAR,QAAoC,eAApC;;AAEA,eAAeC,OAAf,CAAuBC,GAAvB,EAA4BC,OAAO,GAAG,EAAtC,EAA0C;AACxCA,EAAAA,OAAO,GAAGA,OAAO,CAAC,YAAD,CAAP,IAAyB,EAAnC;AAEA,QAAM;AAACC,IAAAA;AAAD,MAAgBD,OAAtB;AAEA,MAAIE,OAAO,GAAGF,OAAO,CAACE,OAAtB;;AACA,MAAI,CAACC,MAAM,CAACC,QAAP,CAAgBF,OAAhB,CAAL,EAA+B;AAC7B,UAAMG,OAAO,GAAGN,GAAG,CAACO,KAAJ,CAAU,0BAAV,CAAhB;AACAJ,IAAAA,OAAO,GAAGG,OAAO,IAAIA,OAAO,CAAC,CAAD,CAA5B;AACD;;AACD,SAAOR,qBAAqB,CAACI,WAAD,EAAcC,OAAd,CAA5B;AACD;;AAKD,OAAO,MAAMK,eAAiC,GAAG,EAC/C,GAAGX,aAD4C;AAE/CY,EAAAA,EAAE,EAAE,YAF2C;AAG/CC,EAAAA,IAAI,EAAE,YAHyC;AAK/CX,EAAAA,OAL+C;AAM/CY,EAAAA,KAAK,EAAE,OAAOC,IAAP,EAAaX,OAAb,EAAuBY,OAAvB,KAAoC;AACzCZ,IAAAA,OAAO,GAAG,EAAC,GAAGA;AAAJ,KAAV;AACAA,IAAAA,OAAO,CAAC,UAAD,CAAP,GAAsBA,OAAO,CAAC,YAAD,CAA7B;AAEAA,IAAAA,OAAO,CAACa,MAAR,GAAiBN,eAAjB;AACA,WAAOX,aAAa,CAACc,KAAd,CAAoBC,IAApB,EAA0BX,OAA1B,EAAmCY,OAAnC,CAAP;AACD,GAZ8C;AAa/CZ,EAAAA,OAAO,EAAE;AACP,kBAAc,EACZ,GAAGJ,aAAa,CAACI,OAAd,CAAsB,UAAtB,CADS;AAEZC,MAAAA,WAAW,EAAE;AAFD;AADP;AAbsC,CAA1C","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {Tiles3DLoader} from './tiles-3d-loader';\nimport {getIonTilesetMetadata} from './lib/ion/ion';\n\nasync function preload(url, options = {}) {\n  options = options['cesium-ion'] || {};\n  // @ts-ignore\n  const {accessToken} = options;\n  // @ts-ignore\n  let assetId = options.assetId;\n  if (!Number.isFinite(assetId)) {\n    const matched = url.match(/\\/([0-9]+)\\/tileset.json/);\n    assetId = matched && matched[1];\n  }\n  return getIonTilesetMetadata(accessToken, assetId);\n}\n\n/**\n * Loader for 3D tiles from Cesium ION\n */\nexport const CesiumIonLoader: LoaderWithParser = {\n  ...Tiles3DLoader,\n  id: 'cesium-ion',\n  name: 'Cesium Ion',\n  // @ts-ignore\n  preload,\n  parse: async (data, options?, context?) => {\n    options = {...options};\n    options['3d-tiles'] = options['cesium-ion'];\n    // @ts-ignore\n    options.loader = CesiumIonLoader;\n    return Tiles3DLoader.parse(data, options, context); // , loader);\n  },\n  options: {\n    'cesium-ion': {\n      ...Tiles3DLoader.options['3d-tiles'],\n      accessToken: null\n    }\n  }\n};\n"],"file":"cesium-ion-loader.js"}