@loaders.gl/tile-converter 3.1.3 → 3.1.4

package/src/i3s-converter/helpers/geometry-converter.js

@@ -243,6 +243,36 @@ function convertNodes(
   }
 }
 
+/**
+ * Generate transformation matrix for node
+ * Aapply all gltf transformations to initial transformation matrix.
+ * @param node
+ * @param matrix
+ */
+function getCompositeTransformationMatrix(node, matrix) {
+  let transformationMatrix = matrix;
+
+  const {matrix: nodeMatrix, rotation, scale, translation} = node;
+
+  if (nodeMatrix) {
+    transformationMatrix = matrix.multiplyRight(nodeMatrix);
+  }
+
+  if (rotation) {
+    transformationMatrix = transformationMatrix.rotateXYZ(rotation);
+  }
+
+  if (scale) {
+    transformationMatrix = transformationMatrix.scale(scale);
+  }
+
+  if (translation) {
+    transformationMatrix = transformationMatrix.translate(translation);
+  }
+
+  return transformationMatrix;
+}
+
 /**
  * Convert all primitives of node and all children nodes
  * @param {Object} node - gltf node
@@ -259,15 +289,20 @@ function convertNode(
   useCartesianPositions,
   matrix = new Matrix4([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1])
 ) {
-  const nodeMatrix = node.matrix;
-  const compositeMatrix = nodeMatrix ? matrix.multiplyRight(nodeMatrix) : matrix;
+  const transformationMatrix = getCompositeTransformationMatrix(node, matrix);
 
   const mesh = node.mesh;
   if (mesh) {
-    convertMesh(mesh, tileContent, attributesMap, useCartesianPositions, compositeMatrix);
+    convertMesh(mesh, tileContent, attributesMap, useCartesianPositions, transformationMatrix);
   }
 
-  convertNodes(node.children, tileContent, attributesMap, useCartesianPositions, compositeMatrix);
+  convertNodes(
+    node.children,
+    tileContent,
+    attributesMap,
+    useCartesianPositions,
+    transformationMatrix
+  );
 }
 
 /**

package/src/i3s-converter/helpers/node-debug.ts

@@ -1,14 +1,23 @@
+import type {Mbs, Node3DIndexDocument, Obb} from '@loaders.gl/i3s';
+
 import {OrientedBoundingBox, BoundingSphere} from '@math.gl/culling';
 import {CubeGeometry} from '@luma.gl/engine';
 import {Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 
 // TODO Unite Tile validation logic in i3s-17-and-debug with this code.
-export function validateNodeBoundingVolumes(node) {
-  if (!node.parentNode.obb || !node.parentNode.mbs) {
+
+/**
+ * Do validation of bounding volumes for particular node.
+ * Generates special warnings if there are some issues.
+ * @param node
+ */
+export function validateNodeBoundingVolumes(node: Node3DIndexDocument): string[] {
+  if (!node?.parentNode?.obb || !node?.parentNode?.mbs) {
     return [];
   }
-  const tileWarnings = [];
+
+  const tileWarnings: string[] = [];
 
   validateObb(tileWarnings, node);
   validateMbs(tileWarnings, node);
@@ -16,7 +25,13 @@ export function validateNodeBoundingVolumes(node) {
   return tileWarnings;
 }
 
-function validateObb(tileWarnings, node) {
+/**
+ * Check if child Obb fit into parent Obb.
+ * @param tileWarnings
+ * @param node
+ */
+function validateObb(tileWarnings: string[], node: Node3DIndexDocument): void {
+  // @ts-expect-error
   const parentObb = createBoundingBoxFromTileObb(node.parentNode.obb);
   const tileVertices = getTileObbVertices(node);
   const isTileObbInsideParentObb = isAllVerticesInsideBoundingVolume(parentObb, tileVertices);
@@ -25,36 +40,58 @@ function validateObb(tileWarnings, node) {
     return;
   }
 
-  const title = `OBB of Tile (${node.id}) doesn't fit into Parent (${node.parentNode.id}) tile OBB`;
+  const title = `OBB of Tile (${node.id}) doesn't fit into Parent (${node.parentNode?.id}) tile OBB`;
   tileWarnings.push(title);
 }
 
-function validateMbs(tileWarnings, node) {
+/**
+ * Check if child Mbs fit into parent Mbs.
+ * @param tileWarnings
+ * @param node
+ */
+function validateMbs(tileWarnings: string[], node: Node3DIndexDocument): void {
+  // @ts-expect-error
   const tileMbs = createBoundingSphereFromTileMbs(node.mbs);
+  // @ts-expect-error
   const parentMbs = createBoundingSphereFromTileMbs(node.parentNode.mbs);
   const distanceBetweenCenters = tileMbs.center.distanceTo(parentMbs.center);
 
   if (distanceBetweenCenters + tileMbs.radius > parentMbs.radius) {
-    const title = `MBS of Tile (${node.id}) doesn't fit into Parent (${node.parentNode.id}) tile MBS`;
+    const title = `MBS of Tile (${node.id}) doesn't fit into Parent (${node.parentNode?.id}) tile MBS`;
     tileWarnings.push(title);
   }
 }
 
-function createBoundingSphereFromTileMbs(mbs) {
+/**
+ * Generates bounding sphere from mbs
+ * @param mbs
+ */
+function createBoundingSphereFromTileMbs(mbs: Mbs): BoundingSphere {
   return new BoundingSphere([mbs[0], mbs[1], mbs[2]], mbs[3]);
 }
 
-function createBoundingBoxFromTileObb(obb) {
+/**
+ * Generates oriented bounding box from tile obb
+ * @param obb
+ * @returns
+ */
+function createBoundingBoxFromTileObb(obb: Obb): OrientedBoundingBox {
   const {center, halfSize, quaternion} = obb;
   return new OrientedBoundingBox().fromCenterHalfSizeQuaternion(center, halfSize, quaternion);
 }
 
-// TODO check if Obb generates properly
-function getTileObbVertices(node) {
+/**
+ * Get vertices fromnode obb
+ * TODO check if Obb generates properly
+ * @param node
+ */
+function getTileObbVertices(node: Node3DIndexDocument): number[] {
   const geometry = new CubeGeometry();
+  // @ts-expect-error
   const halfSize = node.obb.halfSize;
   const attributes = geometry.getAttributes();
   const positions = new Float32Array(attributes.POSITION.value);
+  // @ts-expect-error
   const obbCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(node.obb.center);
 
   let vertices = [];
@@ -66,6 +103,7 @@ function getTileObbVertices(node) {
       (positions[i + 2] *= halfSize[2])
     );
     const rotatedPositions = positionsVector
+      // @ts-expect-error
       .transformByQuaternion(node.obb.quaternion)
       .add(obbCenterCartesian);
     // @ts-expect-error
@@ -75,7 +113,15 @@ function getTileObbVertices(node) {
   return vertices;
 }
 
-function isAllVerticesInsideBoundingVolume(boundingVolume, positions) {
+/**
+ * Check if all vertices inside bounding volume
+ * @param boundingVolume
+ * @param positions
+ */
+function isAllVerticesInsideBoundingVolume(
+  boundingVolume: OrientedBoundingBox,
+  positions: number[]
+): boolean {
   let isVerticesInsideObb = true;
 
   for (let index = 0; index < positions.length / 3; index += 3) {

package/src/i3s-converter/i3s-converter.ts

@@ -227,7 +227,7 @@ export default class I3SConverter {
 
     this.layers0!.materialDefinitions = this.materialDefinitions;
     await this._writeLayers0();
-    createSceneServerPath(tilesetName, this.layers0, tilesetPath);
+    createSceneServerPath(tilesetName, this.layers0!, tilesetPath);
     await this._writeNodeIndexDocument(root0, 'root', join(this.layers0Path, 'nodes', 'root'));
     await this.nodePages.save(this.layers0Path, this.fileMap, isCreateSlpk);
     await this._createSlpk(tilesetPath);

package/src/i3s-converter/types.ts

@@ -12,3 +12,31 @@ export type I3SConvertedResources = {
   geometryBuffer?: ArrayBuffer;
   boundingVolumes: BoundingVolumes | null;
 };
+
+export type AttributesData = {
+  positions: Float32Array;
+  normals: Float32Array;
+  texCoords: Float32Array;
+  colors: Uint8Array;
+  featureIndices: number[];
+  triangleCount: number;
+  boundingVolumes?: BoundingVolumes | null;
+};
+
+export type GeometryAttributes = {
+  positions: Float32Array;
+  normals: Float32Array;
+  texCoords: Float32Array;
+  colors: Uint8Array;
+  faceRange: Uint32Array;
+  featureIds: number[];
+  featureCount: number;
+};
+
+export type GroupedByFeatureIdAttributes = {
+  featureId: number;
+  positions: Float32Array;
+  normals: Float32Array;
+  colors: Uint8Array;
+  texCoords: Float32Array;
+};