@loaders.gl/i3s 3.2.6 → 3.3.0-alpha.2

package/src/lib/parsers/parse-i3s-tile-content.ts

@@ -8,15 +8,16 @@ import {DracoLoader, DracoMesh} from '@loaders.gl/draco';
 import {BasisLoader, CompressedTextureLoader} from '@loaders.gl/textures';
 
 import {
-  I3STilesetHeader,
-  I3STileHeader,
   FeatureAttribute,
   VertexAttribute,
   I3SMeshAttributes,
   I3SMeshAttribute,
   TileContentTexture,
   HeaderAttributeProperty,
-  I3SMaterialDefinition
+  I3SMaterialDefinition,
+  I3STileContent,
+  I3STileOptions,
+  I3STilesetOptions
 } from '../../types';
 import {getUrlWithToken} from '../utils/url-utils';
 
@@ -40,43 +41,51 @@ function getLoaderForTextureFormat(textureFormat?: 'jpg' | 'png' | 'ktx-etc2' |
 
 const I3S_ATTRIBUTE_TYPE = 'i3s-attribute-type';
 
+const defaultContent: I3STileContent = {
+  attributes: {},
+  indices: null,
+  featureIds: [],
+  vertexCount: 0,
+  modelMatrix: new Matrix4(),
+  coordinateSystem: 0,
+  byteLength: 0,
+  texture: null
+};
+
 export async function parseI3STileContent(
   arrayBuffer: ArrayBuffer,
-  tile: I3STileHeader,
-  tileset: I3STilesetHeader,
+  tileOptions: I3STileOptions,
+  tilesetOptions: I3STilesetOptions,
   options?: LoaderOptions,
   context?: LoaderContext
-) {
-  tile.content = tile.content || {};
-  tile.content.featureIds = tile.content.featureIds || null;
-
-  tile.content.attributes = {};
+): Promise<I3STileContent> {
+  const content: I3STileContent = defaultContent;
 
-  if (tile.textureUrl) {
-    const url = getUrlWithToken(tile.textureUrl, options?.i3s?.token);
-    const loader = getLoaderForTextureFormat(tile.textureFormat);
+  if (tileOptions.textureUrl) {
+    const url = getUrlWithToken(tileOptions.textureUrl, options?.i3s?.token);
+    const loader = getLoaderForTextureFormat(tileOptions.textureFormat);
     const response = await fetch(url, options?.fetch as RequestInit);
     const arrayBuffer = await response.arrayBuffer();
 
     if (options?.i3s.decodeTextures) {
       if (loader === ImageLoader) {
-        const options = {...tile.textureLoaderOptions, image: {type: 'data'}};
+        const options = {...tileOptions.textureLoaderOptions, image: {type: 'data'}};
         try {
           // @ts-ignore context must be defined
           // Image constructor is not supported in worker thread.
           // Do parsing image data on the main thread by using context to avoid worker issues.
-          tile.content.texture = await context.parse(arrayBuffer, options);
+          content.texture = await context.parse(arrayBuffer, options);
         } catch (e) {
           // context object is different between worker and node.js conversion script.
           // To prevent error we parse data in ordinary way if it is not parsed by using context.
-          tile.content.texture = await parse(arrayBuffer, loader, options);
+          content.texture = await parse(arrayBuffer, loader, options);
         }
       } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
-        let texture = await load(arrayBuffer, loader, tile.textureLoaderOptions);
+        let texture = await load(arrayBuffer, loader, tileOptions.textureLoaderOptions);
         if (loader === BasisLoader) {
           texture = texture[0];
         }
-        tile.content.texture = {
+        content.texture = {
           compressed: true,
           mipmaps: false,
           width: texture[0].width,
@@ -85,30 +94,26 @@ export async function parseI3STileContent(
         };
       }
     } else {
-      tile.content.texture = arrayBuffer;
+      content.texture = arrayBuffer;
     }
   }
 
-  tile.content.material = makePbrMaterial(tile.materialDefinition, tile.content.texture);
-  if (tile.content.material) {
-    tile.content.texture = null;
+  content.material = makePbrMaterial(tileOptions.materialDefinition, content.texture);
+  if (content.material) {
+    content.texture = null;
   }
 
-  return await parseI3SNodeGeometry(arrayBuffer, tile, tileset, options);
+  return await parseI3SNodeGeometry(arrayBuffer, content, tileOptions, tilesetOptions, options);
 }
 
 /* eslint-disable max-statements */
 async function parseI3SNodeGeometry(
   arrayBuffer: ArrayBuffer,
-  tile: I3STileHeader,
-  tileset: I3STilesetHeader,
+  content: I3STileContent,
+  tileOptions: I3STileOptions,
+  tilesetOptions: I3STilesetOptions,
   options?: LoaderOptions
-) {
-  if (!tile.content) {
-    return tile;
-  }
-
-  const content = tile.content;
+): Promise<I3STileContent> {
   const contentByteLength = arrayBuffer.byteLength;
   let attributes: I3SMeshAttributes;
   let vertexCount: number;
@@ -116,7 +121,7 @@ async function parseI3SNodeGeometry(
   let featureCount: number = 0;
   let indices: TypedArray | undefined;
 
-  if (tile.isDracoGeometry) {
+  if (tileOptions.isDracoGeometry) {
     const decompressedGeometry: DracoMesh = await parse(arrayBuffer, DracoLoader, {
       draco: {
         attributeNameEntry: I3S_ATTRIBUTE_TYPE
@@ -156,9 +161,9 @@ async function parseI3SNodeGeometry(
       ordering: attributesOrder,
       featureAttributes,
       featureAttributeOrder
-    } = tileset.store.defaultGeometrySchema;
+    } = tilesetOptions.store.defaultGeometrySchema;
     // First 8 bytes reserved for header (vertexCount and featureCount)
-    const headers = parseHeaders(tileset, arrayBuffer);
+    const headers = parseHeaders(arrayBuffer, tilesetOptions);
     byteOffset = headers.byteOffset;
     vertexCount = headers.vertexCount;
     featureCount = headers.featureCount;
@@ -188,7 +193,7 @@ async function parseI3SNodeGeometry(
     !options?.i3s?.coordinateSystem ||
     options.i3s.coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS
   ) {
-    const enuMatrix = parsePositions(attributes.position, tile);
+    const enuMatrix = parsePositions(attributes.position, tileOptions);
     content.modelMatrix = enuMatrix.invert();
     content.coordinateSystem = COORDINATE_SYSTEM.METER_OFFSETS;
   } else {
@@ -206,7 +211,7 @@ async function parseI3SNodeGeometry(
   content.indices = indices || null;
 
   if (attributes.id && attributes.id.value) {
-    tile.content.featureIds = attributes.id.value;
+    content.featureIds = attributes.id.value;
   }
 
   // Remove undefined attributes
@@ -219,7 +224,7 @@ async function parseI3SNodeGeometry(
   content.vertexCount = vertexCount;
   content.byteLength = contentByteLength;
 
-  return tile;
+  return content;
 }
 
 /**
@@ -274,12 +279,12 @@ function normalizeAttribute(attribute: I3SMeshAttribute): I3SMeshAttribute {
   return attribute;
 }
 
-function parseHeaders(tileset: I3STilesetHeader, arrayBuffer: ArrayBuffer) {
+function parseHeaders(arrayBuffer: ArrayBuffer, options: I3STilesetOptions) {
   let byteOffset = 0;
   // First 8 bytes reserved for header (vertexCount and featurecount)
   let vertexCount = 0;
   let featureCount = 0;
-  for (const {property, type} of tileset.store.defaultGeometrySchema.header) {
+  for (const {property, type} of options.store.defaultGeometrySchema.header) {
     const TypedArrayTypeHeader = getConstructorForDataFormat(type);
     switch (property) {
       case HeaderAttributeProperty.vertexCount:
@@ -394,8 +399,8 @@ function parseUint64Values(
   return new Uint32Array(values);
 }
 
-function parsePositions(attribute: I3SMeshAttribute, tile: I3STileHeader): Matrix4 {
-  const mbs = tile.mbs;
+function parsePositions(attribute: I3SMeshAttribute, options: I3STileOptions): Matrix4 {
+  const mbs = options.mbs;
   const value = attribute.value;
   const metadata = attribute.metadata;
   const enuMatrix = new Matrix4();

package/src/lib/parsers/parse-i3s.ts

@@ -13,7 +13,7 @@ import {
 } from '../../types';
 import type {LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';
 
-export function normalizeTileData(tile : Node3DIndexDocument, options : LoaderOptions, context: LoaderContext): I3STileHeader {
+export function normalizeTileData(tile : Node3DIndexDocument, context: LoaderContext): I3STileHeader {
   const url: string = context.url || '';
   let contentUrl: string | undefined;
   if (tile.geometryData) {

package/src/types.ts

@@ -1,5 +1,6 @@
 import type {Matrix4, Quaternion, Vector3} from '@math.gl/core';
 import type {TypedArray, MeshAttribute, TextureLevel} from '@loaders.gl/schema';
+import {Tile3D, Tileset3D} from '@loaders.gl/tiles';
 
 export enum DATA_TYPE {
   UInt8 = 'UInt8',
@@ -80,6 +81,50 @@ export type I3STileHeader = {
   lodSelection?: LodSelection[];
   [key: string]: any;
 };
+
+export type I3SParseOptions = {
+  /** ArcGIS access token */
+  token?: string;
+  /** Is 3DSceneLayer json expected in response */
+  isTileset?: string;
+  /** Is 3DNodeIndexDocument json expected in response */
+  isTileHeader?: string;
+  /** Tile3D instance. This property used only to load tile content */
+  /** @deprecated */
+  tile?: Tile3D | I3STileOptions;
+  /** Tileset3D instance. This property used only to load tile content */
+  /** @deprecated */
+  tileset?: Tileset3D | I3STilesetOptions;
+  /** Tile-specific options */
+  _tileOptions?: I3STileOptions;
+  /** Tileset-specific options */
+  _tilesetOptions?: I3STilesetOptions;
+  /** Load Draco Compressed geometry if available */
+  useDracoGeometry?: boolean;
+  /** Load compressed textures if available */
+  useCompressedTextures?: boolean;
+  /** Set false if don't need to parse textures */
+  decodeTextures?: boolean;
+  /** deck.gl compatible coordinate system.
+   * https://github.com/visgl/deck.gl/blob/master/docs/developer-guide/coordinate-systems.md
+   * Supported coordinate systems: METER_OFFSETS, LNGLAT_OFFSETS
+   */
+  coordinateSystem?: number;
+};
+
+export type I3STileOptions = {
+  isDracoGeometry: boolean;
+  textureUrl?: string;
+  textureFormat?: I3STextureFormat;
+  textureLoaderOptions?: any;
+  materialDefinition?: I3SMaterialDefinition;
+  mbs: Mbs;
+};
+
+export type I3STilesetOptions = {
+  store: Store;
+};
+
 // TODO Replace "[key: string]: any" with actual defenition
 export type I3STileContent = {
   attributes: I3SMeshAttributes;