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

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

@@ -1,77 +1,177 @@
-import { LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE } from '@loaders.gl/tiles';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeImplicitTileData = exports.normalizeImplicitTileHeaders = exports.normalizeTileHeaders = exports.normalizeTileData = void 0;
+const tile_3d_subtree_loader_1 = require("../../tile-3d-subtree-loader");
+const core_1 = require("@loaders.gl/core");
+const tiles_1 = require("@loaders.gl/tiles");
+const parse_3d_implicit_tiles_1 = require("./helpers/parse-3d-implicit-tiles");
+const s2_corners_to_obb_1 = require("../utils/obb/s2-corners-to-obb");
 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;
-  }
+    if (!tile.contentUrl) {
+        return tiles_1.TILE_TYPE.EMPTY;
+    }
+    const contentUrl = tile.contentUrl;
+    const fileExtension = contentUrl.split('.').pop();
+    switch (fileExtension) {
+        case 'pnts':
+            return tiles_1.TILE_TYPE.POINTCLOUD;
+        case 'i3dm':
+        case 'b3dm':
+        case 'glb':
+        case 'gltf':
+            return tiles_1.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;
-  }
+    switch (refine) {
+        case 'REPLACE':
+        case 'replace':
+            return tiles_1.TILE_REFINEMENT.REPLACE;
+        case 'ADD':
+        case 'add':
+            return tiles_1.TILE_REFINEMENT.ADD;
+        default:
+            return refine;
+    }
+}
+function resolveUri(uri, basePath) {
+    // url scheme per RFC3986
+    const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
+    if (urlSchemeRegex.test(basePath)) {
+        const url = new URL(uri, `${basePath}/`);
+        return decodeURI(url.toString());
+    }
+    else if (uri.startsWith('/')) {
+        return uri;
+    }
+    return `${basePath}/${uri}`;
+}
+function normalizeTileData(tile, options) {
+    if (!tile) {
+        return null;
+    }
+    if (tile.content) {
+        const contentUri = tile.content.uri || tile.content.url;
+        tile.contentUrl = resolveUri(contentUri, options.basePath);
+    }
+    tile.id = tile.contentUrl;
+    tile.lodMetricType = tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+    tile.lodMetricValue = tile.geometricError;
+    tile.transformMatrix = tile.transform;
+    tile.type = getTileType(tile);
+    tile.refine = getRefine(tile.refine);
+    return tile;
+}
+exports.normalizeTileData = normalizeTileData;
+// normalize tile headers
+async function normalizeTileHeaders(tileset, options) {
+    const basePath = tileset.basePath;
+    let root;
+    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset?.root);
+    if (rootImplicitTilingExtension && tileset.root) {
+        root = await normalizeImplicitTileHeaders(tileset.root, tileset, rootImplicitTilingExtension, options);
+    }
+    else {
+        root = normalizeTileData(tileset.root, tileset);
+    }
+    const stack = [];
+    stack.push(root);
+    while (stack.length > 0) {
+        const tile = stack.pop() || {};
+        const children = tile.children || [];
+        for (let childHeader of children) {
+            const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+            if (childImplicitTilingExtension) {
+                childHeader = await normalizeImplicitTileHeaders(childHeader, tileset, childImplicitTilingExtension, options);
+            }
+            else {
+                normalizeTileData(childHeader, { basePath });
+            }
+            stack.push(childHeader);
+        }
+    }
+    return root;
 }
-
-export function normalizeTileData(tile, options) {
-  if (!tile) {
-    return null;
-  }
-
-  if (tile.content) {
-    const contentUri = tile.content.uri || tile.content.url;
-    tile.contentUrl = "".concat(options.basePath, "/").concat(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;
+exports.normalizeTileHeaders = normalizeTileHeaders;
+/**
+ * Do normalisation of implicit tile headers
+ * TODO Check if Tile3D class can be a return type here.
+ * @param tileset
+ */
+async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtension, options) {
+    const basePath = tileset.basePath;
+    const { subdivisionScheme, maximumLevel, subtreeLevels, subtrees: { uri: subtreesUriTemplate } } = implicitTilingExtension;
+    const replacedUrlTemplate = (0, parse_3d_implicit_tiles_1.replaceContentUrlTemplate)(subtreesUriTemplate, 0, 0, 0, 0);
+    const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
+    const subtree = await (0, core_1.load)(subtreeUrl, tile_3d_subtree_loader_1.Tile3DSubtreeLoader, options);
+    const contentUrlTemplate = resolveUri(tile.content.uri, basePath);
+    const refine = tileset?.root?.refine;
+    // @ts-ignore
+    const rootLodMetricValue = tile.geometricError;
+    // Replace tile.boundingVolume with the the bounding volume specified by the extensions['3DTILES_bounding_volume_S2']
+    const s2VolumeInfo = tile.boundingVolume.extensions?.['3DTILES_bounding_volume_S2'];
+    if (s2VolumeInfo) {
+        const box = (0, s2_corners_to_obb_1.convertS2BoundingVolumetoOBB)(s2VolumeInfo);
+        const s2VolumeBox = { box, s2VolumeInfo };
+        tile.boundingVolume = s2VolumeBox;
+    }
+    const rootBoundingVolume = tile.boundingVolume;
+    const implicitOptions = {
+        contentUrlTemplate,
+        subtreesUriTemplate,
+        subdivisionScheme,
+        subtreeLevels,
+        maximumLevel,
+        refine,
+        basePath,
+        lodMetricType: tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+        rootLodMetricValue,
+        rootBoundingVolume,
+        getTileType,
+        getRefine
+    };
+    return await normalizeImplicitTileData(tile, subtree, implicitOptions);
 }
-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);
+exports.normalizeImplicitTileHeaders = normalizeImplicitTileHeaders;
+/**
+ * Do implicit data normalisation to create hierarchical tile structure
+ * @param tile
+ * @param rootSubtree
+ * @param options
+ * @returns
+ */
+async function normalizeImplicitTileData(tile, rootSubtree, options) {
+    if (!tile) {
+        return null;
     }
-  }
-
-  return root;
+    tile.lodMetricType = tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+    tile.lodMetricValue = tile.geometricError;
+    tile.transformMatrix = tile.transform;
+    const { children, contentUrl } = await (0, parse_3d_implicit_tiles_1.parseImplicitTiles)({
+        subtree: rootSubtree,
+        options,
+        s2VolumeBox: tile
+    });
+    if (contentUrl) {
+        tile.contentUrl = contentUrl;
+        tile.content = { uri: contentUrl.replace(`${options.basePath}/`, '') };
+    }
+    tile.refine = getRefine(tile.refine);
+    tile.type = getTileType(tile);
+    tile.children = children;
+    tile.id = tile.contentUrl;
+    return tile;
+}
+exports.normalizeImplicitTileData = normalizeImplicitTileData;
+/**
+ * Implicit Tiling data can be in 3DTILES_implicit_tiling for 3DTiles v.Next or directly in implicitTiling object for 3DTiles v1.1.
+ * Spec 3DTiles v.Next - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
+ * Spec 3DTiles v.1.1 - https://github.com/CesiumGS/3d-tiles/tree/draft-1.1/specification/ImplicitTiling
+ * @param tile
+ * @returns
+ */
+function getImplicitTilingExtensionData(tile) {
+    return tile?.extensions?.['3DTILES_implicit_tiling'] || tile?.implicitTiling;
 }
-//# sourceMappingURL=parse-3d-tile-header.js.map

package/dist/lib/parsers/parse-3d-tile-instanced-model.d.ts

@@ -0,0 +1,2 @@
+export declare function parseInstancedModel3DTile(tile: any, arrayBuffer: any, byteOffset: any, options: any, context: any): Promise<any>;
+//# sourceMappingURL=parse-3d-tile-instanced-model.d.ts.map

package/dist/lib/parsers/parse-3d-tile-instanced-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-instanced-model.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-instanced-model.ts"],"names":[],"mappings":"AAaA,wBAAsB,yBAAyB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,gBAI9F"}

package/dist/lib/parsers/parse-3d-tile-instanced-model.js

@@ -1,177 +1,186 @@
-import { Vector3, Matrix3, Matrix4, Quaternion } from '@math.gl/core';
-import { Ellipsoid } from '@math.gl/geospatial';
-import { GL } from '@loaders.gl/math';
-import Tile3DFeatureTable from '../classes/tile-3d-feature-table';
-import Tile3DBatchTable from '../classes/tile-3d-batch-table';
-import { parse3DTileHeaderSync } from './helpers/parse-3d-tile-header';
-import { parse3DTileTablesHeaderSync, parse3DTileTablesSync } from './helpers/parse-3d-tile-tables';
-import { parse3DTileGLTFViewSync, extractGLTF } from './helpers/parse-3d-tile-gltf-view';
-export async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
-  byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
-  await extractGLTF(tile, tile.gltfFormat, options, context);
-  return byteOffset;
+"use strict";
+// This file is derived from the Cesium code base under Apache 2 license
+// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInstancedModel3DTile = void 0;
+const core_1 = require("@math.gl/core");
+const geospatial_1 = require("@math.gl/geospatial");
+const math_1 = require("@loaders.gl/math"); // 'math.gl/geometry';
+const tile_3d_feature_table_1 = __importDefault(require("../classes/tile-3d-feature-table"));
+const tile_3d_batch_table_1 = __importDefault(require("../classes/tile-3d-batch-table"));
+const parse_3d_tile_header_1 = require("./helpers/parse-3d-tile-header");
+const parse_3d_tile_tables_1 = require("./helpers/parse-3d-tile-tables");
+const parse_3d_tile_gltf_view_1 = require("./helpers/parse-3d-tile-gltf-view");
+async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
+    byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
+    await (0, parse_3d_tile_gltf_view_1.extractGLTF)(tile, tile.gltfFormat, options, context);
+    return byteOffset;
 }
-
+exports.parseInstancedModel3DTile = parseInstancedModel3DTile;
 function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
-  byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
-
-  if (tile.version !== 1) {
-    throw new Error("Instanced 3D Model version ".concat(tile.version, " is not supported"));
-  }
-
-  byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);
-  const view = new DataView(arrayBuffer);
-  tile.gltfFormat = view.getUint32(byteOffset, true);
-  byteOffset += 4;
-  byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);
-  byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);
-
-  if (tile.featureTableJsonByteLength === 0) {
-    throw new Error('i3dm parser: featureTableJsonByteLength is zero.');
-  }
-
-  const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);
-  const instancesLength = featureTable.getGlobalProperty('INSTANCES_LENGTH');
-  featureTable.featuresLength = instancesLength;
-
-  if (!Number.isFinite(instancesLength)) {
-    throw new Error('i3dm parser: INSTANCES_LENGTH must be defined');
-  }
-
-  tile.eastNorthUp = featureTable.getGlobalProperty('EAST_NORTH_UP');
-  tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', GL.FLOAT, 3);
-  const batchTable = new Tile3DBatchTable(tile.batchTableJson, tile.batchTableBinary, instancesLength);
-  extractInstancedAttributes(tile, featureTable, batchTable, instancesLength);
-  return byteOffset;
-}
-
-function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
-  const collectionOptions = {
-    instances: new Array(instancesLength),
-    batchTable: tile._batchTable,
-    cull: false,
-    url: undefined,
-    gltf: undefined,
-    basePath: undefined,
-    incrementallyLoadTextures: false,
-    forwardAxis: [1, 0, 0]
-  };
-  const instances = collectionOptions.instances;
-  const instancePosition = new Vector3();
-  const instanceNormalRight = new Vector3();
-  const instanceNormalUp = new Vector3();
-  const instanceNormalForward = new Vector3();
-  const instanceRotation = new Matrix3();
-  const instanceQuaternion = new Quaternion();
-  const instanceScale = new Vector3();
-  const instanceTranslationRotationScale = {};
-  const instanceTransform = new Matrix4();
-  const scratch1 = [];
-  const scratch2 = [];
-  const scratchVector1 = new Vector3();
-  const scratchVector2 = new Vector3();
-
-  for (let i = 0; i < instancesLength; i++) {
-    let position;
-
-    if (featureTable.hasProperty('POSITION')) {
-      position = featureTable.getProperty('POSITION', GL.FLOAT, 3, i, instancePosition);
-    } else if (featureTable.hasProperty('POSITION_QUANTIZED')) {
-      position = featureTable.getProperty('POSITION_QUANTIZED', GL.UNSIGNED_SHORT, 3, i, instancePosition);
-      const quantizedVolumeOffset = featureTable.getGlobalProperty('QUANTIZED_VOLUME_OFFSET', GL.FLOAT, 3, scratchVector1);
-
-      if (!quantizedVolumeOffset) {
-        throw new Error('i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.');
-      }
-
-      const quantizedVolumeScale = featureTable.getGlobalProperty('QUANTIZED_VOLUME_SCALE', GL.FLOAT, 3, scratchVector2);
-
-      if (!quantizedVolumeScale) {
-        throw new Error('i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.');
-      }
-
-      const MAX_UNSIGNED_SHORT = 65535.0;
-
-      for (let j = 0; j < 3; j++) {
-        position[j] = position[j] / MAX_UNSIGNED_SHORT * quantizedVolumeScale[j] + quantizedVolumeOffset[j];
-      }
-    }
-
-    if (!position) {
-      throw new Error('i3dm: POSITION or POSITION_QUANTIZED must be defined for each instance.');
-    }
-
-    instancePosition.copy(position);
-    instanceTranslationRotationScale.translation = instancePosition;
-    tile.normalUp = featureTable.getProperty('NORMAL_UP', GL.FLOAT, 3, i, scratch1);
-    tile.normalRight = featureTable.getProperty('NORMAL_RIGHT', GL.FLOAT, 3, i, scratch2);
-    const hasCustomOrientation = false;
-
-    if (tile.normalUp) {
-      if (!tile.normalRight) {
-        throw new Error('i3dm: Custom orientation requires both NORMAL_UP and NORMAL_RIGHT.');
-      }
-
-      tile.hasCustomOrientation = true;
-    } else {
-      tile.octNormalUp = featureTable.getProperty('NORMAL_UP_OCT32P', GL.UNSIGNED_SHORT, 2, scratch1);
-      tile.octNormalRight = featureTable.getProperty('NORMAL_RIGHT_OCT32P', GL.UNSIGNED_SHORT, 2, scratch2);
-
-      if (tile.octNormalUp) {
-        if (!tile.octNormalRight) {
-          throw new Error('i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P');
-        }
-
-        throw new Error('i3dm: oct-encoded orientation not implemented');
-      } else if (tile.eastNorthUp) {
-        Ellipsoid.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
-        instanceTransform.getRotationMatrix3(instanceRotation);
-      } else {
-        instanceRotation.identity();
-      }
+    byteOffset = (0, parse_3d_tile_header_1.parse3DTileHeaderSync)(tile, arrayBuffer, byteOffset);
+    if (tile.version !== 1) {
+        throw new Error(`Instanced 3D Model version ${tile.version} is not supported`);
     }
-
-    if (hasCustomOrientation) {
-      instanceNormalForward.copy(instanceNormalRight).cross(instanceNormalUp).normalize();
-      instanceRotation.setColumn(0, instanceNormalRight);
-      instanceRotation.setColumn(1, instanceNormalUp);
-      instanceRotation.setColumn(2, instanceNormalForward);
+    byteOffset = (0, parse_3d_tile_tables_1.parse3DTileTablesHeaderSync)(tile, arrayBuffer, byteOffset);
+    const view = new DataView(arrayBuffer);
+    tile.gltfFormat = view.getUint32(byteOffset, true);
+    byteOffset += 4;
+    // PARSE FEATURE TABLE
+    byteOffset = (0, parse_3d_tile_tables_1.parse3DTileTablesSync)(tile, arrayBuffer, byteOffset, options);
+    byteOffset = (0, parse_3d_tile_gltf_view_1.parse3DTileGLTFViewSync)(tile, arrayBuffer, byteOffset, options);
+    // TODO - Is the feature table sometimes optional or can check be moved into table header parser?
+    if (tile.featureTableJsonByteLength === 0) {
+        throw new Error('i3dm parser: featureTableJsonByteLength is zero.');
     }
-
-    instanceQuaternion.fromMatrix3(instanceRotation);
-    instanceTranslationRotationScale.rotation = instanceQuaternion;
-    instanceScale.set(1.0, 1.0, 1.0);
-    const scale = featureTable.getProperty('SCALE', GL.FLOAT, 1, i);
-
-    if (Number.isFinite(scale)) {
-      instanceScale.multiplyByScalar(scale);
+    const featureTable = new tile_3d_feature_table_1.default(tile.featureTableJson, tile.featureTableBinary);
+    const instancesLength = featureTable.getGlobalProperty('INSTANCES_LENGTH');
+    featureTable.featuresLength = instancesLength;
+    if (!Number.isFinite(instancesLength)) {
+        throw new Error('i3dm parser: INSTANCES_LENGTH must be defined');
     }
-
-    const nonUniformScale = featureTable.getProperty('SCALE_NON_UNIFORM', GL.FLOAT, 3, i, scratch1);
-
-    if (nonUniformScale) {
-      instanceScale.scale(nonUniformScale);
-    }
-
-    instanceTranslationRotationScale.scale = instanceScale;
-    let batchId = featureTable.getProperty('BATCH_ID', GL.UNSIGNED_SHORT, 1, i);
-
-    if (batchId === undefined) {
-      batchId = i;
-    }
-
-    const rotationMatrix = new Matrix4().fromQuaternion(instanceTranslationRotationScale.rotation);
-    instanceTransform.identity();
-    instanceTransform.translate(instanceTranslationRotationScale.translation);
-    instanceTransform.multiplyRight(rotationMatrix);
-    instanceTransform.scale(instanceTranslationRotationScale.scale);
-    const modelMatrix = instanceTransform.clone();
-    instances[i] = {
-      modelMatrix,
-      batchId
+    tile.eastNorthUp = featureTable.getGlobalProperty('EAST_NORTH_UP');
+    tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', math_1.GL.FLOAT, 3);
+    const batchTable = new tile_3d_batch_table_1.default(tile.batchTableJson, tile.batchTableBinary, instancesLength);
+    extractInstancedAttributes(tile, featureTable, batchTable, instancesLength);
+    return byteOffset;
+}
+// eslint-disable-next-line max-statements, complexity
+function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
+    // Create model instance collection
+    const collectionOptions = {
+        instances: new Array(instancesLength),
+        batchTable: tile._batchTable,
+        cull: false,
+        url: undefined,
+        // requestType: RequestType.TILES3D,
+        gltf: undefined,
+        basePath: undefined,
+        incrementallyLoadTextures: false,
+        // TODO - tileset is not available at this stage, tile is parsed independently
+        // upAxis: (tileset && tileset._gltfUpAxis) || [0, 1, 0],
+        forwardAxis: [1, 0, 0]
     };
-  }
-
-  tile.instances = instances;
+    const instances = collectionOptions.instances;
+    const instancePosition = new core_1.Vector3();
+    const instanceNormalRight = new core_1.Vector3();
+    const instanceNormalUp = new core_1.Vector3();
+    const instanceNormalForward = new core_1.Vector3();
+    const instanceRotation = new core_1.Matrix3();
+    const instanceQuaternion = new core_1.Quaternion();
+    const instanceScale = new core_1.Vector3();
+    const instanceTranslationRotationScale = {};
+    const instanceTransform = new core_1.Matrix4();
+    const scratch1 = [];
+    const scratch2 = [];
+    const scratchVector1 = new core_1.Vector3();
+    const scratchVector2 = new core_1.Vector3();
+    for (let i = 0; i < instancesLength; i++) {
+        let position;
+        // Get the instance position
+        if (featureTable.hasProperty('POSITION')) {
+            position = featureTable.getProperty('POSITION', math_1.GL.FLOAT, 3, i, instancePosition);
+        }
+        else if (featureTable.hasProperty('POSITION_QUANTIZED')) {
+            position = featureTable.getProperty('POSITION_QUANTIZED', math_1.GL.UNSIGNED_SHORT, 3, i, instancePosition);
+            const quantizedVolumeOffset = featureTable.getGlobalProperty('QUANTIZED_VOLUME_OFFSET', math_1.GL.FLOAT, 3, scratchVector1);
+            if (!quantizedVolumeOffset) {
+                throw new Error('i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.');
+            }
+            const quantizedVolumeScale = featureTable.getGlobalProperty('QUANTIZED_VOLUME_SCALE', math_1.GL.FLOAT, 3, scratchVector2);
+            if (!quantizedVolumeScale) {
+                throw new Error('i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.');
+            }
+            const MAX_UNSIGNED_SHORT = 65535.0;
+            for (let j = 0; j < 3; j++) {
+                position[j] =
+                    (position[j] / MAX_UNSIGNED_SHORT) * quantizedVolumeScale[j] + quantizedVolumeOffset[j];
+            }
+        }
+        if (!position) {
+            throw new Error('i3dm: POSITION or POSITION_QUANTIZED must be defined for each instance.');
+        }
+        instancePosition.copy(position);
+        // @ts-expect-error
+        instanceTranslationRotationScale.translation = instancePosition;
+        // Get the instance rotation
+        tile.normalUp = featureTable.getProperty('NORMAL_UP', math_1.GL.FLOAT, 3, i, scratch1);
+        tile.normalRight = featureTable.getProperty('NORMAL_RIGHT', math_1.GL.FLOAT, 3, i, scratch2);
+        const hasCustomOrientation = false;
+        if (tile.normalUp) {
+            if (!tile.normalRight) {
+                throw new Error('i3dm: Custom orientation requires both NORMAL_UP and NORMAL_RIGHT.');
+            }
+            // Vector3.unpack(normalUp, 0, instanceNormalUp);
+            // Vector3.unpack(normalRight, 0, instanceNormalRight);
+            tile.hasCustomOrientation = true;
+        }
+        else {
+            tile.octNormalUp = featureTable.getProperty('NORMAL_UP_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, scratch1);
+            tile.octNormalRight = featureTable.getProperty('NORMAL_RIGHT_OCT32P', math_1.GL.UNSIGNED_SHORT, 2, scratch2);
+            if (tile.octNormalUp) {
+                if (!tile.octNormalRight) {
+                    throw new Error('i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P');
+                }
+                throw new Error('i3dm: oct-encoded orientation not implemented');
+                /*
+                AttributeCompression.octDecodeInRange(octNormalUp[0], octNormalUp[1], 65535, instanceNormalUp);
+                AttributeCompression.octDecodeInRange(octNormalRight[0], octNormalRight[1], 65535, instanceNormalRight);
+                hasCustomOrientation = true;
+                */
+            }
+            else if (tile.eastNorthUp) {
+                geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(instancePosition, instanceTransform);
+                instanceTransform.getRotationMatrix3(instanceRotation);
+            }
+            else {
+                instanceRotation.identity();
+            }
+        }
+        if (hasCustomOrientation) {
+            instanceNormalForward.copy(instanceNormalRight).cross(instanceNormalUp).normalize();
+            instanceRotation.setColumn(0, instanceNormalRight);
+            instanceRotation.setColumn(1, instanceNormalUp);
+            instanceRotation.setColumn(2, instanceNormalForward);
+        }
+        instanceQuaternion.fromMatrix3(instanceRotation);
+        // @ts-expect-error
+        instanceTranslationRotationScale.rotation = instanceQuaternion;
+        // Get the instance scale
+        instanceScale.set(1.0, 1.0, 1.0);
+        const scale = featureTable.getProperty('SCALE', math_1.GL.FLOAT, 1, i);
+        if (Number.isFinite(scale)) {
+            instanceScale.multiplyByScalar(scale);
+        }
+        const nonUniformScale = featureTable.getProperty('SCALE_NON_UNIFORM', math_1.GL.FLOAT, 3, i, scratch1);
+        if (nonUniformScale) {
+            instanceScale.scale(nonUniformScale);
+        }
+        // @ts-expect-error
+        instanceTranslationRotationScale.scale = instanceScale;
+        // Get the batchId
+        let batchId = featureTable.getProperty('BATCH_ID', math_1.GL.UNSIGNED_SHORT, 1, i);
+        if (batchId === undefined) {
+            // If BATCH_ID semantic is undefined, batchId is just the instance number
+            batchId = i;
+        }
+        // @ts-expect-error
+        const rotationMatrix = new core_1.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();
+        instances[i] = {
+            modelMatrix,
+            batchId
+        };
+    }
+    tile.instances = instances;
 }
-//# sourceMappingURL=parse-3d-tile-instanced-model.js.map

package/dist/lib/parsers/parse-3d-tile-point-cloud.d.ts

@@ -0,0 +1,3 @@
+export declare function parsePointCloud3DTile(tile: any, arrayBuffer: any, byteOffset: any, options: any, context: any): Promise<any>;
+export declare function loadDraco(tile: any, dracoData: any, options: any, context: any): Promise<void>;
+//# sourceMappingURL=parse-3d-tile-point-cloud.d.ts.map

package/dist/lib/parsers/parse-3d-tile-point-cloud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-3d-tile-point-cloud.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-3d-tile-point-cloud.ts"],"names":[],"mappings":"AAeA,wBAAsB,qBAAqB,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA,EAAE,UAAU,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,gBAe1F;AA8KD,wBAAsB,SAAS,CAAC,IAAI,KAAA,EAAE,SAAS,KAAA,EAAE,OAAO,KAAA,EAAE,OAAO,KAAA,iBAqDhE"}