@loaders.gl/gltf 3.3.0-alpha.1 → 3.3.0-alpha.10

package/src/index.ts

@@ -15,15 +15,20 @@ export type {
   GLTFTexture,
   GLTFImage,
   GLTFPostprocessed,
+  GLTFAccessorPostprocessed,
   GLTFNodePostprocessed,
   GLTFMaterialPostprocessed,
+  GLTFMeshPostprocessed,
+  GLTFMeshPrimitivePostprocessed,
   GLTFImagePostprocessed,
+  GLTFTexturePostprocessed,
   // The following extensions are handled by the GLTFLoader and removed from the parsed glTF (disable via options.gltf.excludeExtensions)
   GLTF_KHR_binary_glTF,
   GLTF_KHR_draco_mesh_compression,
   GLTF_KHR_texture_basisu,
   GLTF_EXT_meshopt_compression,
-  GLTF_EXT_texture_webp
+  GLTF_EXT_texture_webp,
+  GLTF_EXT_feature_metadata
 } from './lib/types/gltf-types';
 
 // glTF loader/writer definition objects
@@ -39,3 +44,4 @@ export {default as GLTFScenegraph} from './lib/api/gltf-scenegraph';
 export {postProcessGLTF} from './lib/api/post-process-gltf';
 export type {Mesh} from './lib/types/gltf-json-schema';
 export type {GLTFObject} from './lib/types/gltf-types';
+export type {Node, Accessor, Image} from './lib/types/gltf-postprocessed-schema';

package/src/lib/api/gltf-extensions.ts

@@ -16,6 +16,7 @@ import * as KHR_texture_transform from '../extensions/KHR_texture_transform';
 import * as KHR_lights_punctual from '../extensions/deprecated/KHR_lights_punctual';
 import * as KHR_materials_unlit from '../extensions/deprecated/KHR_materials_unlit';
 import * as KHR_techniques_webgl from '../extensions/deprecated/KHR_techniques_webgl';
+import * as EXT_feature_metadata from '../extensions/deprecated/EXT_feature_metadata';
 
 // Vendor extensions
 
@@ -52,7 +53,8 @@ export const EXTENSIONS: GLTFExtensionPlugin[] = [
   KHR_lights_punctual,
   KHR_materials_unlit,
   KHR_techniques_webgl,
-  KHR_texture_transform
+  KHR_texture_transform,
+  EXT_feature_metadata
 ];
 
 /** Call before any resource loading starts */

package/src/lib/api/gltf-scenegraph.ts

@@ -10,7 +10,8 @@ import type {
   GLTFTexture,
   GLTFImage,
   GLTFBuffer,
-  GLTFBufferView
+  GLTFBufferView,
+  GLTFWithBuffers
 } from '../types/gltf-types';
 
 import {getBinaryImageMetadata} from '@loaders.gl/images';
@@ -22,12 +23,6 @@ import {
   getComponentTypeFromArray
 } from '../gltf-utils/gltf-utils';
 
-type GLTFWithBuffers = {
-  json: GLTF;
-  buffers: any[];
-  binary?: ArrayBuffer;
-};
-
 const DEFAULT_GLTF_JSON: GLTF = {
   asset: {
     version: '2.0',
@@ -68,13 +63,13 @@ export default class GLTFScenegraph {
     return this.gltf.json;
   }
 
-  getApplicationData(key: string): {[key: string]: any} {
+  getApplicationData(key: string): unknown {
     // TODO - Data is already unpacked by GLBParser
     const data = this.json[key];
     return data;
   }
 
-  getExtraData(key: string): {[key: string]: any} {
+  getExtraData(key: string): {[key: string]: unknown} {
     // TODO - Data is already unpacked by GLBParser
     const extras = this.json.extras || {};
     return extras[key];
@@ -99,6 +94,10 @@ export default class GLTFScenegraph {
     return this.json.extensionsUsed || [];
   }
 
+  getRemovedExtensions(): string[] {
+    return (this.json.extensionsRemoved || []) as string[];
+  }
+
   getObjectExtension<T = Extension>(object: {[key: string]: any}, extensionName: string): T | null {
     const extensions = object.extensions || {};
     return extensions[extensionName];
@@ -157,7 +156,7 @@ export default class GLTFScenegraph {
     if (typeof index === 'object') {
       return index;
     }
-    const object = this.json[array] && this.json[array][index];
+    const object = this.json[array] && (this.json[array] as {}[])[index];
     if (!object) {
       throw new Error(`glTF file error: Could not find ${array}[${index}]`); // eslint-disable-line
     }
@@ -234,7 +233,7 @@ export default class GLTFScenegraph {
    */
   addExtraData(key: string, data: object): GLTFScenegraph {
     this.json.extras = this.json.extras || {};
-    this.json.extras[key] = data;
+    (this.json.extras as Record<string, unknown>)[key] = data;
     return this;
   }
 
@@ -269,7 +268,7 @@ export default class GLTFScenegraph {
   addExtension(extensionName: string, extensionData: object = {}): object {
     assert(extensionData);
     this.json.extensions = this.json.extensions || {};
-    this.json.extensions[extensionName] = extensionData;
+    (this.json.extensions as Record<string, unknown>)[extensionName] = extensionData;
     this.registerUsedExtension(extensionName);
     return extensionData;
   }
@@ -309,6 +308,9 @@ export default class GLTFScenegraph {
    * Removes an extension from the top-level list
    */
   removeExtension(extensionName: string): void {
+    if (!this.getExtension(extensionName)) {
+      return;
+    }
     if (this.json.extensionsRequired) {
       this._removeStringFromArray(this.json.extensionsRequired, extensionName);
     }
@@ -318,6 +320,13 @@ export default class GLTFScenegraph {
     if (this.json.extensions) {
       delete this.json.extensions[extensionName];
     }
+    if (!Array.isArray(this.json.extensionsRemoved)) {
+      this.json.extensionsRemoved = [];
+    }
+    const extensionsRemoved = this.json.extensionsRemoved as string[];
+    if (!extensionsRemoved.includes(extensionName)) {
+      extensionsRemoved.push(extensionName);
+    }
   }
 
   /**

package/src/lib/api/normalize-gltf-v1.ts

@@ -298,7 +298,8 @@ class GLTFV1Normalizer {
         roughnessFactor: 1
       };
 
-      const textureId = material.values?.tex || material.values?.texture2d_0;
+      const textureId =
+        material.values?.tex || material.values?.texture2d_0 || material.values?.diffuseTex;
       const textureIndex = json.textures.findIndex((texture) => texture.id === textureId);
       if (textureIndex !== -1) {
         material.pbrMetallicRoughness.baseColorTexture = {index: textureIndex};

package/src/lib/extensions/EXT_meshopt_compression.ts

@@ -31,7 +31,7 @@ export async function decode(gltfData: {json: GLTF}, options: GLTFLoaderOptions)
   // Decompress meshes in parallel
   await Promise.all(promises);
 
-  // We have now decompressed all primitives, so remove the top-level extensions
+  // We have now decompressed all primitives, so remove the top-level extension
   scenegraph.removeExtension(EXT_MESHOPT_COMPRESSION);
 }
 

package/src/lib/extensions/EXT_texture_webp.ts

@@ -35,6 +35,7 @@ export function preprocess(gltfData: {json: GLTF}, options: GLTFLoaderOptions):
       EXT_TEXTURE_WEBP
     );
     if (extension) {
+      // TODO - if multiple texture extensions are present which one wins?
       texture.source = extension.source;
     }
     scenegraph.removeObjectExtension(texture, EXT_TEXTURE_WEBP);

package/src/lib/extensions/KHR_binary_gltf.ts

@@ -40,7 +40,7 @@ export function preprocess(gltfData: {json: GLTF}): void {
     delete json.buffers[0].uri;
   }
 
-  // Remove the top-level extension as it has now been removed from all nodes
+  // Remove the top-level extension as it has now been processed
   gltfScenegraph.removeExtension(KHR_BINARY_GLTF);
 }
 

package/src/lib/extensions/KHR_draco_mesh_compression.ts

@@ -56,7 +56,7 @@ export async function decode(
   // Decompress meshes in parallel
   await Promise.all(promises);
 
-  // We have now decompressed all primitives, so remove the top-level extensions
+  // We have now decompressed all primitives, so remove the top-level extension
   scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
 }
 

package/src/lib/extensions/KHR_texture_basisu.ts

@@ -26,6 +26,7 @@ export function preprocess(gltfData: {json: GLTF}, options: GLTFLoaderOptions):
       KHR_TEXTURE_BASISU
     );
     if (extension) {
+      // TODO - if multiple texture extensions are present which one wins?
       texture.source = extension.source;
     }
     scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);

package/src/lib/extensions/deprecated/EXT_feature_metadata.ts

@@ -0,0 +1,163 @@
+/* eslint-disable camelcase */
+import type {GLTF} from '../../types/gltf-types';
+
+import GLTFScenegraph from '../../api/gltf-scenegraph';
+import {
+  ClassProperty,
+  EXT_feature_metadata_class_object,
+  EXT_feature_metadata_feature_table,
+  FeatureTableProperty,
+  GLTF_EXT_feature_metadata
+} from '../../types/gltf-json-schema';
+
+/** Extension name */
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+
+export const name = EXT_FEATURE_METADATA;
+
+export async function decode(gltfData: {json: GLTF}): Promise<void> {
+  const scenegraph = new GLTFScenegraph(gltfData);
+  decodeExtFeatureMetadata(scenegraph);
+}
+
+/**
+ * Decodes feature metadata from extension
+ * @param scenegraph
+ */
+function decodeExtFeatureMetadata(scenegraph: GLTFScenegraph): void {
+  const extension: GLTF_EXT_feature_metadata | null = scenegraph.getExtension(EXT_FEATURE_METADATA);
+  const schemaClasses = extension?.schema?.classes;
+  const featureTables = extension?.featureTables;
+  const featureTextures = extension?.featureTextures;
+
+  if (featureTextures) {
+    /*
+     * TODO add support for featureTextures
+     * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-textures
+     */
+    // eslint-disable-next-line no-console
+    console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
+  }
+
+  if (schemaClasses && featureTables) {
+    for (const schemaName in schemaClasses) {
+      const schemaClass = schemaClasses[schemaName];
+      const featureTable = findFeatureTableByName(featureTables, schemaName);
+
+      if (featureTable) {
+        handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+      }
+    }
+  }
+}
+
+/**
+ * Navigate throw all properies in feature table and gets properties data.
+ * @param scenegraph
+ * @param featureTable
+ * @param schemaClass
+ */
+function handleFeatureTableProperties(
+  scenegraph: GLTFScenegraph,
+  featureTable: EXT_feature_metadata_feature_table,
+  schemaClass: EXT_feature_metadata_class_object
+): void {
+  for (const propertyName in schemaClass.properties) {
+    const schemaProperty = schemaClass.properties[propertyName];
+    const featureTableProperty = featureTable?.properties?.[propertyName];
+    const numberOfFeatures = featureTable.count;
+
+    if (featureTableProperty) {
+      const data = getPropertyDataFromBinarySource(
+        scenegraph,
+        schemaProperty,
+        numberOfFeatures,
+        featureTableProperty
+      );
+      featureTableProperty.data = data;
+    }
+  }
+}
+
+/**
+ * Decode properties from binary sourse based on property type.
+ * @param scenegraph
+ * @param schemaProperty
+ * @param numberOfFeatures
+ * @param featureTableProperty
+ */
+function getPropertyDataFromBinarySource(
+  scenegraph: GLTFScenegraph,
+  schemaProperty: ClassProperty,
+  numberOfFeatures: number,
+  featureTableProperty: FeatureTableProperty
+): Uint8Array | string[] {
+  const bufferView = featureTableProperty.bufferView;
+  // TODO think maybe we shouldn't get data only in Uint8Array format.
+  let data: Uint8Array | string[] = scenegraph.getTypedArrayForBufferView(bufferView);
+
+  switch (schemaProperty.type) {
+    case 'STRING': {
+      // stringOffsetBufferView should be available for string type.
+      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView!;
+      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+      data = getStringAttributes(data, offsetsData, numberOfFeatures);
+      break;
+    }
+    default:
+  }
+
+  return data;
+}
+
+/**
+ * Find the feature table by class name.
+ * @param featureTables
+ * @param schemaClassName
+ */
+function findFeatureTableByName(
+  featureTables: {[key: string]: EXT_feature_metadata_feature_table},
+  schemaClassName: string
+): EXT_feature_metadata_feature_table | null {
+  for (const featureTableName in featureTables) {
+    const featureTable = featureTables[featureTableName];
+
+    if (featureTable.class === schemaClassName) {
+      return featureTable;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Getting string attributes from binary data.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings
+ * @param data
+ * @param offsetsData
+ * @param stringsCount
+ */
+function getStringAttributes(
+  data: Uint8Array,
+  offsetsData: Uint8Array,
+  stringsCount: number
+): string[] {
+  const stringsArray: string[] = [];
+  const textDecoder = new TextDecoder('utf8');
+
+  let stringOffset = 0;
+  const bytesPerStringSize = 4;
+
+  for (let index = 0; index < stringsCount; index++) {
+    // TODO check if it is multiplication on bytesPerStringSize is valid operation?
+    const stringByteSize =
+      offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+    const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+    const stringAttribute = textDecoder.decode(stringData);
+
+    stringsArray.push(stringAttribute);
+    stringOffset += stringByteSize;
+  }
+
+  return stringsArray;
+}

package/src/lib/extensions/deprecated/KHR_materials_unlit.ts

@@ -13,9 +13,6 @@ export async function decode(gltfData: {json: GLTF}): Promise<void> {
   const gltfScenegraph = new GLTFScenegraph(gltfData);
   const {json} = gltfScenegraph;
 
-  // Remove the top-level extension
-  gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
-
   // Any nodes that have the extension, add lights field pointing to light object
   // and remove the extension
   for (const material of json.materials || []) {
@@ -26,6 +23,9 @@ export async function decode(gltfData: {json: GLTF}): Promise<void> {
     }
     gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);
   }
+
+  // Remove the top-level extension
+  gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
 }
 
 export function encode(gltfData) {

package/src/lib/extensions/deprecated/KHR_techniques_webgl.ts

@@ -33,6 +33,7 @@ export async function decode(gltfData: {json: GLTF}): Promise<void> {
       gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
     }
 
+    // Remove the top-level extension
     gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
   }
 }

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

@@ -201,10 +201,13 @@ async function loadImage(
 
   let arrayBuffer;
 
-  if (image.uri) {
+  if (image.uri && !image.hasOwnProperty('bufferView')) {
     const uri = resolveUrl(image.uri, options);
     const response = await fetch(uri);
     arrayBuffer = await response.arrayBuffer();
+    image.bufferView = {
+      data: arrayBuffer
+    };
   }
 
   if (Number.isFinite(image.bufferView)) {