@loaders.gl/gltf 4.0.0-alpha.23 → 4.0.0-alpha.24

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

@@ -9,12 +9,14 @@ import type {
   GLTF_EXT_feature_metadata_GLTF,
   GLTF_EXT_feature_metadata_TextureAccessor
 } from '../../types/gltf-json-schema';
+import type {BigTypedArray, TypedArray} from '@loaders.gl/schema';
 import {GLTFScenegraph} from '../../api/gltf-scenegraph';
 import {getImageData} from '@loaders.gl/images';
 import {GLTFMeshPrimitive} from '../../types/gltf-json-schema';
 import {getComponentTypeFromArray} from '../../gltf-utils/gltf-utils';
 import {GLTFLoaderOptions} from '../../../gltf-loader';
 import {emod} from '@loaders.gl/math';
+import {convertRawBufferToMetadataArray, getOffsetsForProperty} from '../utils/3d-tiles-utils';
 
 /** Extension name */
 const EXT_FEATURE_METADATA_NAME = 'EXT_feature_metadata';
@@ -125,24 +127,134 @@ function getPropertyDataFromBinarySource(
   schemaProperty: GLTF_EXT_feature_metadata_ClassProperty,
   numberOfFeatures: number,
   featureTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty
-): Uint8Array | string[] {
+): BigTypedArray | string[] {
   const bufferView = featureTableProperty.bufferView;
-  // TODO think maybe we shouldn't get data only in Uint8Array format.
   const dataArray: Uint8Array = scenegraph.getTypedArrayForBufferView(bufferView);
 
-  switch (schemaProperty.type) {
-    case 'STRING': {
-      // stringOffsetBufferView should be available for string type.
-      const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView!;
-      const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-      return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  if (schemaProperty.type === 'STRING') {
+    const offsetsData = getStringOffsets(scenegraph, featureTableProperty, numberOfFeatures);
+    if (!offsetsData) {
+      return [];
     }
-    default:
+    return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
+  } else if (isNumericProperty(schemaProperty.type)) {
+    return getNumericAttributes(
+      dataArray,
+      schemaProperty.type as
+        | 'INT8'
+        | 'UINT8'
+        | 'INT16'
+        | 'UINT16'
+        | 'INT32'
+        | 'UINT32'
+        | 'INT64'
+        | 'UINT64'
+        | 'FLOAT32'
+        | 'FLOAT64',
+      numberOfFeatures
+    );
   }
 
   return dataArray;
 }
 
+/**
+ * Check if the feature table property is of numeric type
+ * @param schemaPropertyType - feature table property
+ * @returns true if property is numeric, else - false
+ */
+function isNumericProperty(
+  schemaPropertyType:
+    | 'INT8'
+    | 'UINT8'
+    | 'INT16'
+    | 'UINT16'
+    | 'INT32'
+    | 'UINT32'
+    | 'INT64'
+    | 'UINT64'
+    | 'FLOAT32'
+    | 'FLOAT64'
+    | 'BOOLEAN'
+    | 'STRING'
+    | 'ENUM'
+    | 'ARRAY'
+    | string
+): boolean {
+  return [
+    'UINT8',
+    'INT16',
+    'UINT16',
+    'INT32',
+    'UINT32',
+    'INT64',
+    'UINT64',
+    'FLOAT32',
+    'FLOAT64'
+  ].includes(schemaPropertyType);
+}
+
+/**
+ * Parse featureTable.property.stringOffsetBufferView.
+ * String offsets is an array of offsets of strings in the united array of charactersz
+ * @param scenegraph - Instance of the class for structured access to GLTF data
+ * @param propertyTableProperty - propertyTable's property metadata
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table
+ * @returns typed array with offset values
+ * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureTable.property.schema.json#L50C10-L50C32
+ */
+function getStringOffsets(
+  scenegraph: GLTFScenegraph,
+  featureTableProperty: GLTF_EXT_feature_metadata_FeatureTableProperty,
+  numberOfElements: number
+): TypedArray | null {
+  if (typeof featureTableProperty.stringOffsetBufferView !== 'undefined') {
+    // Data are in a FIXED-length array
+    return getOffsetsForProperty(
+      scenegraph,
+      featureTableProperty.stringOffsetBufferView,
+      featureTableProperty.offsetType || 'UINT32', // UINT32 is the default by the spec
+      numberOfElements
+    );
+  }
+  return null;
+}
+
+/**
+ * Parse numeric property values
+ * @param valuesDataBytes - values data array
+ * @param propertyType - type of the property
+ * @param elementCount - number of rows in the featureTable
+ * @returns Number data in a typed array
+ */
+function getNumericAttributes(
+  valuesDataBytes: Uint8Array,
+  propertyType:
+    | 'INT8'
+    | 'UINT8'
+    | 'INT16'
+    | 'UINT16'
+    | 'INT32'
+    | 'UINT32'
+    | 'INT64'
+    | 'UINT64'
+    | 'FLOAT32'
+    | 'FLOAT64',
+  elementCount: number
+): BigTypedArray {
+  let valuesData = convertRawBufferToMetadataArray(
+    valuesDataBytes,
+    'SCALAR',
+    // The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types.
+    propertyType,
+    elementCount
+  );
+  if (!valuesData) {
+    valuesData = valuesDataBytes;
+  }
+  return valuesData;
+}
+
 /**
  * Get properties from texture associated with all mesh primitives.
  * @param scenegraph
@@ -371,24 +483,16 @@ function findFeatureTextureByName(
  */
 function getStringAttributes(
   data: Uint8Array,
-  offsetsData: Uint8Array,
+  offsetsData: TypedArray,
   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 stringData = data.slice(offsetsData[index], offsetsData[index + 1]);
     const stringAttribute = textDecoder.decode(stringData);
-
     stringsArray.push(stringAttribute);
-    stringOffset += stringByteSize;
   }
 
   return stringsArray;

package/src/lib/extensions/{data-processing.ts → utils/3d-tiles-utils.ts}

@@ -1,12 +1,33 @@
-import type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../types/gltf-json-schema';
-import type {TypedArray} from '@loaders.gl/schema';
+/**
+ * loaders.gl, MIT license
+ *
+ * Shared code for 3DTiles extensions:
+ * * EXT_feature_metadata
+ * * EXT_mesh_features
+ * * EXT_structural_metadata
+ */
+
+import type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../../types/gltf-json-schema';
+import type {BigTypedArray, TypedArray} from '@loaders.gl/schema';
 import type {ImageType} from '@loaders.gl/images';
 
-import {GLTFScenegraph} from '../api/gltf-scenegraph';
-import {getComponentTypeFromArray} from '../gltf-utils/gltf-utils';
+import {GLTFScenegraph} from '../../api/gltf-scenegraph';
+import {getComponentTypeFromArray} from '../../gltf-utils/gltf-utils';
 import {getImageData} from '@loaders.gl/images';
 import {emod} from '@loaders.gl/math';
 
+export type NumericComponentType =
+  | 'INT8'
+  | 'UINT8'
+  | 'INT16'
+  | 'UINT16'
+  | 'INT32'
+  | 'UINT32'
+  | 'INT64'
+  | 'UINT64'
+  | 'FLOAT32'
+  | 'FLOAT64';
+
 const ATTRIBUTE_TYPE_TO_COMPONENTS = {
   SCALAR: 1,
   VEC2: 2,
@@ -53,39 +74,79 @@ export function getArrayElementByteSize(attributeType, componentType): number {
   );
 }
 
+/**
+ * Gets offset array from `arrayOffsets` or `stringOffsets`.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param bufferViewIndex - Buffer view index
+ * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.
+ * @param numberOfElements - The number of elements in each property array.
+ * @returns array with values offsets
+ */
+export function getOffsetsForProperty(
+  scenegraph: GLTFScenegraph,
+  bufferViewIndex: number,
+  offsetType: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string,
+  numberOfElements: number
+): TypedArray | null {
+  if (
+    offsetType !== 'UINT8' &&
+    offsetType !== 'UINT16' &&
+    offsetType !== 'UINT32' &&
+    offsetType !== 'UINT64'
+  ) {
+    return null;
+  }
+  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+  const arrayOffsets = convertRawBufferToMetadataArray(
+    arrayOffsetsBytes,
+    'SCALAR', // offsets consist of ONE component
+    offsetType,
+    numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.
+  );
+
+  // We don't support BigInt offsets at the moment. It requires additional logic and potential issues in Safari
+  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+    return null;
+  }
+  return arrayOffsets;
+}
+
 /**
  * Converts raw bytes that are in the buffer to an array of the type defined by the schema.
- * @param {Uint8Array} typedArray - raw bytes in the buffer
- * @param {string} attributeType - SCALAR, VECN, MATN
- * @param {string} componentType - type of the component in elements, e.g. 'UINT8' or 'FLOAT32'
- * @param {number} elementCount - number of elements in the array. Default value is 1.
- * @returns {TypedArray} Data array
+ * @param data - raw bytes in the buffer
+ * @param attributeType - SCALAR, VECN, MATN
+ * @param componentType - type of the component in elements, e.g. 'UINT8' or 'FLOAT32'
+ * @param elementCount - number of elements in the array. Default value is 1.
+ * @returns Data array
  */
 export function convertRawBufferToMetadataArray(
-  typedArray: Uint8Array,
+  data: Uint8Array,
   attributeType: string,
-  componentType: string,
+  componentType: NumericComponentType,
   elementCount: number = 1
-): TypedArray {
+): BigTypedArray | null {
   const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
   const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];
-  const length = elementCount * numberOfComponents;
   const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];
-  // the buffer view `byteOffset` must be aligned to a multiple of the `componentType` size.
-  const offset =
-    typedArray.byteOffset % size
-      ? Math.ceil(typedArray.byteOffset / size) * size
-      : typedArray.byteOffset;
-  return new ArrayType(typedArray.buffer, offset, length);
+  const length = elementCount * numberOfComponents;
+  const byteLength = length * size;
+  let buffer = data.buffer;
+  let offset = data.byteOffset;
+  if (offset % size !== 0) {
+    const bufferArray = new Uint8Array(buffer);
+    buffer = bufferArray.slice(offset, offset + byteLength).buffer;
+    offset = 0;
+  }
+  return new ArrayType(buffer, offset, length);
 }
 
 /**
  * Processes data encoded in the texture associated with the primitive.
  * If Ext_mesh_featues is combined with the Ext_structural_metadata, propertyTable will also be processed.
- * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
- * @param {GLTFTextureInfoMetadata} textureInfo - reference to the texture where extension data are stored.
- * @param {GLTFMeshPrimitive} primitive - primitive object in the mesh
- * @returns {number[] | null} Array of data taken. Null if data can't be taken from the texture.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param textureInfo - reference to the texture where extension data are stored.
+ * @param primitive - primitive object in the mesh
+ * @returns Array of data taken. Null if data can't be taken from the texture.
  */
 export function getPrimitiveTextureData(
   scenegraph: GLTFScenegraph,
@@ -147,11 +208,11 @@ export function getPrimitiveTextureData(
  * Puts property data to attributes.
  * It creates corresponding buffer, bufferView and accessor
  * so the data can be accessed like regular data stored in buffers.
- * @param {GLTFScenegraph} scenegraph - scenegraph object
- * @param {string} attributeName - name of the attribute
- * @param {number[]} propertyData - property data to store
- * @param {number[]} featureTable - an array where unique data from the property data are being stored
- * @param {GLTFMeshPrimitive} primitive - primitive object
+ * @param scenegraph - scenegraph object
+ * @param attributeName - name of the attribute
+ * @param propertyData - property data to store
+ * @param featureTable - an array where unique data from the property data are being stored
+ * @param primitive - primitive object
  */
 export function primitivePropertyDataToAttributes(
   scenegraph: GLTFScenegraph,
@@ -194,12 +255,12 @@ export function primitivePropertyDataToAttributes(
 
 /**
  * Gets the value from the texture by coordinates provided.
- * @param {ImageType} parsedImage - image where the data are stored.
- * @param {string | undefined} mimeType - MIME type
- * @param {Float32Array} textureCoordinates - uv coordinates to access data in the image.
- * @param {number} index - index of uv coordinates in the array textureCoordinates
- * @param {channels} channels - image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.
- * @returns {number} Value taken from the image.
+ * @param parsedImage - image where the data are stored.
+ * @param mimeType - MIME type
+ * @param textureCoordinates - uv coordinates to access data in the image.
+ * @param index - index of uv coordinates in the array textureCoordinates
+ * @param channels - image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.
+ * @returns Value taken from the image.
  */
 function getImageValueByCoordinates(
   parsedImage: ImageType,

package/src/lib/types/gltf-ext-structural-metadata-schema.ts

@@ -115,7 +115,8 @@ export type GLTF_EXT_structural_metadata_ClassProperty = {
     | 'MAT4'
     | 'BOOLEAN'
     | 'STRING'
-    | 'ENUM';
+    | 'ENUM'
+    | string;
 
   /** The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types. */
   componentType?:
@@ -128,7 +129,8 @@ export type GLTF_EXT_structural_metadata_ClassProperty = {
     | 'INT64'
     | 'UINT64'
     | 'FLOAT32'
-    | 'FLOAT64';
+    | 'FLOAT64'
+    | string;
 
   /** Enum ID as declared in the `enums` dictionary. Required when `type` is `ENUM`. */
   enumType?: string;
@@ -261,12 +263,12 @@ export type GLTF_EXT_structural_metadata_PropertyTable_Property = {
   /**
    * The type of values in `arrayOffsets`.
    */
-  arrayOffsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64';
+  arrayOffsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string;
 
   /**
    * The type of values in `stringOffsets`.
    */
-  stringOffsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64';
+  stringOffsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string;
   /**
    * An offset to apply to property values.
    * Only applicable when the component type is `FLOAT32` or `FLOAT64`, or when the property is `normalized`.

package/src/lib/types/gltf-json-schema.ts

@@ -1057,7 +1057,7 @@ export type GLTF_EXT_feature_metadata_FeatureTableProperty = {
   bufferView: number;
 
   /** The type of values in arrayOffsetBufferView and stringOffsetBufferView. */
-  offsetType?: string; // default: "UINT32"
+  offsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string; // default: "UINT32"
   /**
    * The index of the buffer view containing offsets for variable-length arrays.
    * The number of offsets is equal to the feature table count plus one.

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/es5/lib/extensions/data-processing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-processing.js","names":["_gltfUtils","require","_images","_math","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","i","F","s","n","done","value","e","_e","f","TypeError","normalCompletion","didErr","err","call","step","next","_e2","return","minLen","_arrayLikeToArray","Object","prototype","toString","slice","constructor","name","from","test","arr","len","arr2","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","BOOLEAN","STRING","ENUM","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","INT8","Int8Array","UINT8","Uint8Array","INT16","Int16Array","UINT16","Uint16Array","INT32","Int32Array","UINT32","Uint32Array","INT64","BigInt64Array","UINT64","BigUint64Array","FLOAT32","Float32Array","FLOAT64","Float64Array","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","getArrayElementByteSize","attributeType","componentType","convertRawBufferToMetadataArray","typedArray","elementCount","arguments","undefined","numberOfComponents","ArrayType","size","offset","byteOffset","Math","ceil","buffer","getPrimitiveTextureData","scenegraph","textureInfo","primitive","_json$textures","_json$textures$textur","json","gltf","texCoordAccessorKey","concat","texCoord","texCoordAccessorIndex","attributes","texCoordBufferView","getBufferView","texCoordArray","getTypedArrayForBufferView","textureCoordinates","textureIndex","index","imageIndex","textures","source","_json$images","_json$images$imageInd","_scenegraph$gltf$imag","mimeType","images","parsedImage","width","textureData","getImageValueByCoordinates","channels","push","primitivePropertyDataToAttributes","attributeName","propertyData","featureTable","featureIndices","_iterator","_step","_loop","texelData","findIndex","item","bufferIndex","buffers","arrayBuffer","byteLength","bufferViewIndex","addBufferView","accessorIndex","addAccessor","getComponentTypeFromArray","count","CHANNELS_MAP","shift","u","v","components","indexOf","coordinatesToOffset","_iterator2","_step2","c","map","imageOffset","imageData","getImageData","data","Error","imageValue","componentsCount","w","iX","emod","indX","round","h","height","iY","indY"],"sources":["../../../../src/lib/extensions/data-processing.ts"],"sourcesContent":["import type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../types/gltf-json-schema';\nimport type {TypedArray} from '@loaders.gl/schema';\nimport type {ImageType} from '@loaders.gl/images';\n\nimport {GLTFScenegraph} from '../api/gltf-scenegraph';\nimport {getComponentTypeFromArray} from '../gltf-utils/gltf-utils';\nimport {getImageData} from '@loaders.gl/images';\nimport {emod} from '@loaders.gl/math';\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16,\n  BOOLEAN: 1,\n  STRING: 1,\n  ENUM: 1\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  INT8: Int8Array,\n  UINT8: Uint8Array,\n  INT16: Int16Array,\n  UINT16: Uint16Array,\n  INT32: Int32Array,\n  UINT32: Uint32Array,\n  INT64: BigInt64Array,\n  UINT64: BigUint64Array,\n  FLOAT32: Float32Array,\n  FLOAT64: Float64Array\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  INT8: 1,\n  UINT8: 1,\n  INT16: 2,\n  UINT16: 2,\n  INT32: 4,\n  UINT32: 4,\n  INT64: 8,\n  UINT64: 8,\n  FLOAT32: 4,\n  FLOAT64: 8\n};\n\nexport function getArrayElementByteSize(attributeType, componentType): number {\n  return (\n    ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] *\n    ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType]\n  );\n}\n\n/**\n * Converts raw bytes that are in the buffer to an array of the type defined by the schema.\n * @param {Uint8Array} typedArray - raw bytes in the buffer\n * @param {string} attributeType - SCALAR, VECN, MATN\n * @param {string} componentType - type of the component in elements, e.g. 'UINT8' or 'FLOAT32'\n * @param {number} elementCount - number of elements in the array. Default value is 1.\n * @returns {TypedArray} Data array\n */\nexport function convertRawBufferToMetadataArray(\n  typedArray: Uint8Array,\n  attributeType: string,\n  componentType: string,\n  elementCount: number = 1\n): TypedArray {\n  const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];\n  const length = elementCount * numberOfComponents;\n  const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];\n  // the buffer view `byteOffset` must be aligned to a multiple of the `componentType` size.\n  const offset =\n    typedArray.byteOffset % size\n      ? Math.ceil(typedArray.byteOffset / size) * size\n      : typedArray.byteOffset;\n  return new ArrayType(typedArray.buffer, offset, length);\n}\n\n/**\n * Processes data encoded in the texture associated with the primitive.\n * If Ext_mesh_featues is combined with the Ext_structural_metadata, propertyTable will also be processed.\n * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.\n * @param {GLTFTextureInfoMetadata} textureInfo - reference to the texture where extension data are stored.\n * @param {GLTFMeshPrimitive} primitive - primitive object in the mesh\n * @returns {number[] | null} Array of data taken. Null if data can't be taken from the texture.\n */\nexport function getPrimitiveTextureData(\n  scenegraph: GLTFScenegraph,\n  textureInfo: GLTFTextureInfoMetadata,\n  primitive: GLTFMeshPrimitive\n): number[] | null {\n  /*\n    texture.index is an index for the \"textures\" array.\n    The texture object referenced by this index looks like this:\n    {\n    \"sampler\": 0,\n    \"source\": 0\n    }\n    \"sampler\" is an index for the \"samplers\" array\n    \"source\" is an index for the \"images\" array that contains data. These data are stored in rgba channels of the image.\n\n    texture.texCoord is a number-suffix (like 1) for an attribute like \"TEXCOORD_1\" in meshes.primitives\n    The value of \"TEXCOORD_1\" is an accessor that is used to get coordinates. These coordinates are being used to get data from the image.\n  */\n  const json = scenegraph.gltf.json;\n\n  const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;\n  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];\n  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);\n  const texCoordArray: Uint8Array = scenegraph.getTypedArrayForBufferView(texCoordBufferView);\n\n  // textureCoordinates array contains UV coordinates of the actual data stored in the texture\n  const textureCoordinates: Float32Array = new Float32Array(\n    texCoordArray.buffer,\n    texCoordArray.byteOffset,\n    texCoordArray.length / 4\n  );\n\n  const textureIndex: number = textureInfo.index;\n  const imageIndex = json.textures?.[textureIndex]?.source;\n  if (typeof imageIndex !== 'undefined') {\n    const mimeType = json.images?.[imageIndex]?.mimeType;\n    const parsedImage = scenegraph.gltf.images?.[imageIndex];\n    // Checking for width is to prevent handling Un-processed images (e.g. [analyze] stage, where loadImages option is set to false)\n    if (parsedImage && typeof parsedImage.width !== 'undefined') {\n      const textureData: number[] = [];\n      for (let index = 0; index < textureCoordinates.length; index += 2) {\n        const value = getImageValueByCoordinates(\n          parsedImage,\n          mimeType,\n          textureCoordinates,\n          index,\n          textureInfo.channels\n        );\n        textureData.push(value);\n      }\n      return textureData;\n    }\n  }\n  return null;\n}\n\n/**\n * Puts property data to attributes.\n * It creates corresponding buffer, bufferView and accessor\n * so the data can be accessed like regular data stored in buffers.\n * @param {GLTFScenegraph} scenegraph - scenegraph object\n * @param {string} attributeName - name of the attribute\n * @param {number[]} propertyData - property data to store\n * @param {number[]} featureTable - an array where unique data from the property data are being stored\n * @param {GLTFMeshPrimitive} primitive - primitive object\n */\nexport function primitivePropertyDataToAttributes(\n  scenegraph: GLTFScenegraph,\n  attributeName: string,\n  propertyData: number[],\n  featureTable: number[],\n  primitive: GLTFMeshPrimitive\n): void {\n  if (propertyData === null) return;\n  /*\n    featureTable will contain unique values, e.g.\n    propertyData = [24, 35, 28, 24]\n    featureTable = [24, 35, 28]\n    featureIndices will contain indices that refer featureTextureTable, e.g.\n    featureIndices = [0, 1, 2, 0]\n  */\n  const featureIndices: number[] = [];\n  for (const texelData of propertyData) {\n    let index = featureTable.findIndex((item) => item === texelData);\n    if (index === -1) {\n      index = featureTable.push(texelData) - 1;\n    }\n    featureIndices.push(index);\n  }\n  const typedArray = new Uint32Array(featureIndices);\n  const bufferIndex =\n    scenegraph.gltf.buffers.push({\n      arrayBuffer: typedArray.buffer,\n      byteOffset: typedArray.byteOffset,\n      byteLength: typedArray.byteLength\n    }) - 1;\n  const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);\n  const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {\n    size: 1,\n    componentType: getComponentTypeFromArray(typedArray),\n    count: typedArray.length\n  });\n  primitive.attributes[attributeName] = accessorIndex;\n}\n\n/**\n * Gets the value from the texture by coordinates provided.\n * @param {ImageType} parsedImage - image where the data are stored.\n * @param {string | undefined} mimeType - MIME type\n * @param {Float32Array} textureCoordinates - uv coordinates to access data in the image.\n * @param {number} index - index of uv coordinates in the array textureCoordinates\n * @param {channels} channels - image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.\n * @returns {number} Value taken from the image.\n */\nfunction getImageValueByCoordinates(\n  parsedImage: ImageType,\n  mimeType: string | undefined,\n  textureCoordinates: Float32Array,\n  index: number,\n  channels: number[] = [0]\n) {\n  const CHANNELS_MAP = [\n    {offset: 0, shift: 0},\n    {offset: 1, shift: 8},\n    {offset: 2, shift: 16},\n    {offset: 3, shift: 24}\n  ];\n\n  const u = textureCoordinates[index];\n  const v = textureCoordinates[index + 1];\n\n  let components = 1;\n  if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1))\n    components = 4;\n  const offset = coordinatesToOffset(u, v, parsedImage, components);\n  let value: number = 0;\n  for (const c of channels) {\n    const map = CHANNELS_MAP[c];\n    const imageOffset = offset + map.offset;\n    const imageData = getImageData(parsedImage);\n    if (imageData.data.length <= imageOffset) {\n      throw new Error(`${imageData.data.length} <= ${imageOffset}`);\n    }\n    const imageValue = imageData.data[imageOffset];\n    value |= imageValue << map.shift;\n  }\n  return value;\n}\n\n/**\n * Retrieves the offset in the image where the data are stored\n * @param u - u-coordinate\n * @param v - v-coordinate\n * @param parsedImage - image where the data are stored\n * @param componentsCount - number of components the data consists of.\n * @returns offset in the image where the data are stored\n */\nfunction coordinatesToOffset(\n  u: number,\n  v: number,\n  parsedImage: any,\n  componentsCount: number = 1\n): number {\n  const w = parsedImage.width;\n  const iX = emod(u) * (w - 1);\n  const indX = Math.round(iX);\n\n  const h = parsedImage.height;\n  const iY = emod(v) * (h - 1);\n  const indY = Math.round(iY);\n  const components = parsedImage.components ? parsedImage.components : componentsCount;\n  // components is a number of channels in the image\n  const offset = (indY * w + indX) * components;\n  return offset;\n}\n"],"mappings":"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"}

package/dist/esm/lib/extensions/data-processing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-processing.js","names":["getComponentTypeFromArray","getImageData","emod","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","BOOLEAN","STRING","ENUM","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","INT8","Int8Array","UINT8","Uint8Array","INT16","Int16Array","UINT16","Uint16Array","INT32","Int32Array","UINT32","Uint32Array","INT64","BigInt64Array","UINT64","BigUint64Array","FLOAT32","Float32Array","FLOAT64","Float64Array","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","getArrayElementByteSize","attributeType","componentType","convertRawBufferToMetadataArray","typedArray","elementCount","arguments","length","undefined","numberOfComponents","ArrayType","size","offset","byteOffset","Math","ceil","buffer","getPrimitiveTextureData","scenegraph","textureInfo","primitive","_json$textures","_json$textures$textur","json","gltf","texCoordAccessorKey","concat","texCoord","texCoordAccessorIndex","attributes","texCoordBufferView","getBufferView","texCoordArray","getTypedArrayForBufferView","textureCoordinates","textureIndex","index","imageIndex","textures","source","_json$images","_json$images$imageInd","_scenegraph$gltf$imag","mimeType","images","parsedImage","width","textureData","value","getImageValueByCoordinates","channels","push","primitivePropertyDataToAttributes","attributeName","propertyData","featureTable","featureIndices","texelData","findIndex","item","bufferIndex","buffers","arrayBuffer","byteLength","bufferViewIndex","addBufferView","accessorIndex","addAccessor","count","CHANNELS_MAP","shift","u","v","components","indexOf","coordinatesToOffset","c","map","imageOffset","imageData","data","Error","imageValue","componentsCount","w","iX","indX","round","h","height","iY","indY"],"sources":["../../../../src/lib/extensions/data-processing.ts"],"sourcesContent":["import type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../types/gltf-json-schema';\nimport type {TypedArray} from '@loaders.gl/schema';\nimport type {ImageType} from '@loaders.gl/images';\n\nimport {GLTFScenegraph} from '../api/gltf-scenegraph';\nimport {getComponentTypeFromArray} from '../gltf-utils/gltf-utils';\nimport {getImageData} from '@loaders.gl/images';\nimport {emod} from '@loaders.gl/math';\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16,\n  BOOLEAN: 1,\n  STRING: 1,\n  ENUM: 1\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  INT8: Int8Array,\n  UINT8: Uint8Array,\n  INT16: Int16Array,\n  UINT16: Uint16Array,\n  INT32: Int32Array,\n  UINT32: Uint32Array,\n  INT64: BigInt64Array,\n  UINT64: BigUint64Array,\n  FLOAT32: Float32Array,\n  FLOAT64: Float64Array\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  INT8: 1,\n  UINT8: 1,\n  INT16: 2,\n  UINT16: 2,\n  INT32: 4,\n  UINT32: 4,\n  INT64: 8,\n  UINT64: 8,\n  FLOAT32: 4,\n  FLOAT64: 8\n};\n\nexport function getArrayElementByteSize(attributeType, componentType): number {\n  return (\n    ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] *\n    ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType]\n  );\n}\n\n/**\n * Converts raw bytes that are in the buffer to an array of the type defined by the schema.\n * @param {Uint8Array} typedArray - raw bytes in the buffer\n * @param {string} attributeType - SCALAR, VECN, MATN\n * @param {string} componentType - type of the component in elements, e.g. 'UINT8' or 'FLOAT32'\n * @param {number} elementCount - number of elements in the array. Default value is 1.\n * @returns {TypedArray} Data array\n */\nexport function convertRawBufferToMetadataArray(\n  typedArray: Uint8Array,\n  attributeType: string,\n  componentType: string,\n  elementCount: number = 1\n): TypedArray {\n  const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];\n  const length = elementCount * numberOfComponents;\n  const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];\n  // the buffer view `byteOffset` must be aligned to a multiple of the `componentType` size.\n  const offset =\n    typedArray.byteOffset % size\n      ? Math.ceil(typedArray.byteOffset / size) * size\n      : typedArray.byteOffset;\n  return new ArrayType(typedArray.buffer, offset, length);\n}\n\n/**\n * Processes data encoded in the texture associated with the primitive.\n * If Ext_mesh_featues is combined with the Ext_structural_metadata, propertyTable will also be processed.\n * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.\n * @param {GLTFTextureInfoMetadata} textureInfo - reference to the texture where extension data are stored.\n * @param {GLTFMeshPrimitive} primitive - primitive object in the mesh\n * @returns {number[] | null} Array of data taken. Null if data can't be taken from the texture.\n */\nexport function getPrimitiveTextureData(\n  scenegraph: GLTFScenegraph,\n  textureInfo: GLTFTextureInfoMetadata,\n  primitive: GLTFMeshPrimitive\n): number[] | null {\n  /*\n    texture.index is an index for the \"textures\" array.\n    The texture object referenced by this index looks like this:\n    {\n    \"sampler\": 0,\n    \"source\": 0\n    }\n    \"sampler\" is an index for the \"samplers\" array\n    \"source\" is an index for the \"images\" array that contains data. These data are stored in rgba channels of the image.\n\n    texture.texCoord is a number-suffix (like 1) for an attribute like \"TEXCOORD_1\" in meshes.primitives\n    The value of \"TEXCOORD_1\" is an accessor that is used to get coordinates. These coordinates are being used to get data from the image.\n  */\n  const json = scenegraph.gltf.json;\n\n  const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;\n  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];\n  const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);\n  const texCoordArray: Uint8Array = scenegraph.getTypedArrayForBufferView(texCoordBufferView);\n\n  // textureCoordinates array contains UV coordinates of the actual data stored in the texture\n  const textureCoordinates: Float32Array = new Float32Array(\n    texCoordArray.buffer,\n    texCoordArray.byteOffset,\n    texCoordArray.length / 4\n  );\n\n  const textureIndex: number = textureInfo.index;\n  const imageIndex = json.textures?.[textureIndex]?.source;\n  if (typeof imageIndex !== 'undefined') {\n    const mimeType = json.images?.[imageIndex]?.mimeType;\n    const parsedImage = scenegraph.gltf.images?.[imageIndex];\n    // Checking for width is to prevent handling Un-processed images (e.g. [analyze] stage, where loadImages option is set to false)\n    if (parsedImage && typeof parsedImage.width !== 'undefined') {\n      const textureData: number[] = [];\n      for (let index = 0; index < textureCoordinates.length; index += 2) {\n        const value = getImageValueByCoordinates(\n          parsedImage,\n          mimeType,\n          textureCoordinates,\n          index,\n          textureInfo.channels\n        );\n        textureData.push(value);\n      }\n      return textureData;\n    }\n  }\n  return null;\n}\n\n/**\n * Puts property data to attributes.\n * It creates corresponding buffer, bufferView and accessor\n * so the data can be accessed like regular data stored in buffers.\n * @param {GLTFScenegraph} scenegraph - scenegraph object\n * @param {string} attributeName - name of the attribute\n * @param {number[]} propertyData - property data to store\n * @param {number[]} featureTable - an array where unique data from the property data are being stored\n * @param {GLTFMeshPrimitive} primitive - primitive object\n */\nexport function primitivePropertyDataToAttributes(\n  scenegraph: GLTFScenegraph,\n  attributeName: string,\n  propertyData: number[],\n  featureTable: number[],\n  primitive: GLTFMeshPrimitive\n): void {\n  if (propertyData === null) return;\n  /*\n    featureTable will contain unique values, e.g.\n    propertyData = [24, 35, 28, 24]\n    featureTable = [24, 35, 28]\n    featureIndices will contain indices that refer featureTextureTable, e.g.\n    featureIndices = [0, 1, 2, 0]\n  */\n  const featureIndices: number[] = [];\n  for (const texelData of propertyData) {\n    let index = featureTable.findIndex((item) => item === texelData);\n    if (index === -1) {\n      index = featureTable.push(texelData) - 1;\n    }\n    featureIndices.push(index);\n  }\n  const typedArray = new Uint32Array(featureIndices);\n  const bufferIndex =\n    scenegraph.gltf.buffers.push({\n      arrayBuffer: typedArray.buffer,\n      byteOffset: typedArray.byteOffset,\n      byteLength: typedArray.byteLength\n    }) - 1;\n  const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);\n  const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {\n    size: 1,\n    componentType: getComponentTypeFromArray(typedArray),\n    count: typedArray.length\n  });\n  primitive.attributes[attributeName] = accessorIndex;\n}\n\n/**\n * Gets the value from the texture by coordinates provided.\n * @param {ImageType} parsedImage - image where the data are stored.\n * @param {string | undefined} mimeType - MIME type\n * @param {Float32Array} textureCoordinates - uv coordinates to access data in the image.\n * @param {number} index - index of uv coordinates in the array textureCoordinates\n * @param {channels} channels - image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.\n * @returns {number} Value taken from the image.\n */\nfunction getImageValueByCoordinates(\n  parsedImage: ImageType,\n  mimeType: string | undefined,\n  textureCoordinates: Float32Array,\n  index: number,\n  channels: number[] = [0]\n) {\n  const CHANNELS_MAP = [\n    {offset: 0, shift: 0},\n    {offset: 1, shift: 8},\n    {offset: 2, shift: 16},\n    {offset: 3, shift: 24}\n  ];\n\n  const u = textureCoordinates[index];\n  const v = textureCoordinates[index + 1];\n\n  let components = 1;\n  if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1))\n    components = 4;\n  const offset = coordinatesToOffset(u, v, parsedImage, components);\n  let value: number = 0;\n  for (const c of channels) {\n    const map = CHANNELS_MAP[c];\n    const imageOffset = offset + map.offset;\n    const imageData = getImageData(parsedImage);\n    if (imageData.data.length <= imageOffset) {\n      throw new Error(`${imageData.data.length} <= ${imageOffset}`);\n    }\n    const imageValue = imageData.data[imageOffset];\n    value |= imageValue << map.shift;\n  }\n  return value;\n}\n\n/**\n * Retrieves the offset in the image where the data are stored\n * @param u - u-coordinate\n * @param v - v-coordinate\n * @param parsedImage - image where the data are stored\n * @param componentsCount - number of components the data consists of.\n * @returns offset in the image where the data are stored\n */\nfunction coordinatesToOffset(\n  u: number,\n  v: number,\n  parsedImage: any,\n  componentsCount: number = 1\n): number {\n  const w = parsedImage.width;\n  const iX = emod(u) * (w - 1);\n  const indX = Math.round(iX);\n\n  const h = parsedImage.height;\n  const iY = emod(v) * (h - 1);\n  const indY = Math.round(iY);\n  const components = parsedImage.components ? parsedImage.components : componentsCount;\n  // components is a number of channels in the image\n  const offset = (indY * w + indX) * components;\n  return offset;\n}\n"],"mappings":"AAKA,SAAQA,yBAAyB,QAAO,0BAA0B;AAClE,SAAQC,YAAY,QAAO,oBAAoB;AAC/C,SAAQC,IAAI,QAAO,kBAAkB;AAErC,MAAMC,4BAA4B,GAAG;EACnCC,MAAM,EAAE,CAAC;EACTC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,EAAE;EACRC,OAAO,EAAE,CAAC;EACVC,MAAM,EAAE,CAAC;EACTC,IAAI,EAAE;AACR,CAAC;AAED,MAAMC,iCAAiC,GAAG;EACxCC,IAAI,EAAEC,SAAS;EACfC,KAAK,EAAEC,UAAU;EACjBC,KAAK,EAAEC,UAAU;EACjBC,MAAM,EAAEC,WAAW;EACnBC,KAAK,EAAEC,UAAU;EACjBC,MAAM,EAAEC,WAAW;EACnBC,KAAK,EAAEC,aAAa;EACpBC,MAAM,EAAEC,cAAc;EACtBC,OAAO,EAAEC,YAAY;EACrBC,OAAO,EAAEC;AACX,CAAC;AAED,MAAMC,qCAAqC,GAAG;EAC5CpB,IAAI,EAAE,CAAC;EACPE,KAAK,EAAE,CAAC;EACRE,KAAK,EAAE,CAAC;EACRE,MAAM,EAAE,CAAC;EACTE,KAAK,EAAE,CAAC;EACRE,MAAM,EAAE,CAAC;EACTE,KAAK,EAAE,CAAC;EACRE,MAAM,EAAE,CAAC;EACTE,OAAO,EAAE,CAAC;EACVE,OAAO,EAAE;AACX,CAAC;AAED,OAAO,SAASG,uBAAuBA,CAACC,aAAa,EAAEC,aAAa,EAAU;EAC5E,OACEH,qCAAqC,CAACG,aAAa,CAAC,GACpDnC,4BAA4B,CAACkC,aAAa,CAAC;AAE/C;AAUA,OAAO,SAASE,+BAA+BA,CAC7CC,UAAsB,EACtBH,aAAqB,EACrBC,aAAqB,EAET;EAAA,IADZG,YAAoB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EAExB,MAAMG,kBAAkB,GAAG1C,4BAA4B,CAACkC,aAAa,CAAC;EACtE,MAAMS,SAAS,GAAGhC,iCAAiC,CAACwB,aAAa,CAAC;EAClE,MAAMK,MAAM,GAAGF,YAAY,GAAGI,kBAAkB;EAChD,MAAME,IAAI,GAAGZ,qCAAqC,CAACG,aAAa,CAAC;EAEjE,MAAMU,MAAM,GACVR,UAAU,CAACS,UAAU,GAAGF,IAAI,GACxBG,IAAI,CAACC,IAAI,CAACX,UAAU,CAACS,UAAU,GAAGF,IAAI,CAAC,GAAGA,IAAI,GAC9CP,UAAU,CAACS,UAAU;EAC3B,OAAO,IAAIH,SAAS,CAACN,UAAU,CAACY,MAAM,EAAEJ,MAAM,EAAEL,MAAM,CAAC;AACzD;AAUA,OAAO,SAASU,uBAAuBA,CACrCC,UAA0B,EAC1BC,WAAoC,EACpCC,SAA4B,EACX;EAAA,IAAAC,cAAA,EAAAC,qBAAA;EAcjB,MAAMC,IAAI,GAAGL,UAAU,CAACM,IAAI,CAACD,IAAI;EAEjC,MAAME,mBAAmB,eAAAC,MAAA,CAAeP,WAAW,CAACQ,QAAQ,IAAI,CAAC,CAAE;EACnE,MAAMC,qBAAqB,GAAGR,SAAS,CAACS,UAAU,CAACJ,mBAAmB,CAAC;EACvE,MAAMK,kBAAkB,GAAGZ,UAAU,CAACa,aAAa,CAACH,qBAAqB,CAAC;EAC1E,MAAMI,aAAyB,GAAGd,UAAU,CAACe,0BAA0B,CAACH,kBAAkB,CAAC;EAG3F,MAAMI,kBAAgC,GAAG,IAAItC,YAAY,CACvDoC,aAAa,CAAChB,MAAM,EACpBgB,aAAa,CAACnB,UAAU,EACxBmB,aAAa,CAACzB,MAAM,GAAG,CACzB,CAAC;EAED,MAAM4B,YAAoB,GAAGhB,WAAW,CAACiB,KAAK;EAC9C,MAAMC,UAAU,IAAAhB,cAAA,GAAGE,IAAI,CAACe,QAAQ,cAAAjB,cAAA,wBAAAC,qBAAA,GAAbD,cAAA,CAAgBc,YAAY,CAAC,cAAAb,qBAAA,uBAA7BA,qBAAA,CAA+BiB,MAAM;EACxD,IAAI,OAAOF,UAAU,KAAK,WAAW,EAAE;IAAA,IAAAG,YAAA,EAAAC,qBAAA,EAAAC,qBAAA;IACrC,MAAMC,QAAQ,IAAAH,YAAA,GAAGjB,IAAI,CAACqB,MAAM,cAAAJ,YAAA,wBAAAC,qBAAA,GAAXD,YAAA,CAAcH,UAAU,CAAC,cAAAI,qBAAA,uBAAzBA,qBAAA,CAA2BE,QAAQ;IACpD,MAAME,WAAW,IAAAH,qBAAA,GAAGxB,UAAU,CAACM,IAAI,CAACoB,MAAM,cAAAF,qBAAA,uBAAtBA,qBAAA,CAAyBL,UAAU,CAAC;IAExD,IAAIQ,WAAW,IAAI,OAAOA,WAAW,CAACC,KAAK,KAAK,WAAW,EAAE;MAC3D,MAAMC,WAAqB,GAAG,EAAE;MAChC,KAAK,IAAIX,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGF,kBAAkB,CAAC3B,MAAM,EAAE6B,KAAK,IAAI,CAAC,EAAE;QACjE,MAAMY,KAAK,GAAGC,0BAA0B,CACtCJ,WAAW,EACXF,QAAQ,EACRT,kBAAkB,EAClBE,KAAK,EACLjB,WAAW,CAAC+B,QACd,CAAC;QACDH,WAAW,CAACI,IAAI,CAACH,KAAK,CAAC;MACzB;MACA,OAAOD,WAAW;IACpB;EACF;EACA,OAAO,IAAI;AACb;AAYA,OAAO,SAASK,iCAAiCA,CAC/ClC,UAA0B,EAC1BmC,aAAqB,EACrBC,YAAsB,EACtBC,YAAsB,EACtBnC,SAA4B,EACtB;EACN,IAAIkC,YAAY,KAAK,IAAI,EAAE;EAQ3B,MAAME,cAAwB,GAAG,EAAE;EACnC,KAAK,MAAMC,SAAS,IAAIH,YAAY,EAAE;IACpC,IAAIlB,KAAK,GAAGmB,YAAY,CAACG,SAAS,CAAEC,IAAI,IAAKA,IAAI,KAAKF,SAAS,CAAC;IAChE,IAAIrB,KAAK,KAAK,CAAC,CAAC,EAAE;MAChBA,KAAK,GAAGmB,YAAY,CAACJ,IAAI,CAACM,SAAS,CAAC,GAAG,CAAC;IAC1C;IACAD,cAAc,CAACL,IAAI,CAACf,KAAK,CAAC;EAC5B;EACA,MAAMhC,UAAU,GAAG,IAAId,WAAW,CAACkE,cAAc,CAAC;EAClD,MAAMI,WAAW,GACf1C,UAAU,CAACM,IAAI,CAACqC,OAAO,CAACV,IAAI,CAAC;IAC3BW,WAAW,EAAE1D,UAAU,CAACY,MAAM;IAC9BH,UAAU,EAAET,UAAU,CAACS,UAAU;IACjCkD,UAAU,EAAE3D,UAAU,CAAC2D;EACzB,CAAC,CAAC,GAAG,CAAC;EACR,MAAMC,eAAe,GAAG9C,UAAU,CAAC+C,aAAa,CAAC7D,UAAU,EAAEwD,WAAW,EAAE,CAAC,CAAC;EAC5E,MAAMM,aAAa,GAAGhD,UAAU,CAACiD,WAAW,CAACH,eAAe,EAAE;IAC5DrD,IAAI,EAAE,CAAC;IACPT,aAAa,EAAEtC,yBAAyB,CAACwC,UAAU,CAAC;IACpDgE,KAAK,EAAEhE,UAAU,CAACG;EACpB,CAAC,CAAC;EACFa,SAAS,CAACS,UAAU,CAACwB,aAAa,CAAC,GAAGa,aAAa;AACrD;AAWA,SAASjB,0BAA0BA,CACjCJ,WAAsB,EACtBF,QAA4B,EAC5BT,kBAAgC,EAChCE,KAAa,EAEb;EAAA,IADAc,QAAkB,GAAA5C,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC,CAAC;EAExB,MAAM+D,YAAY,GAAG,CACnB;IAACzD,MAAM,EAAE,CAAC;IAAE0D,KAAK,EAAE;EAAC,CAAC,EACrB;IAAC1D,MAAM,EAAE,CAAC;IAAE0D,KAAK,EAAE;EAAC,CAAC,EACrB;IAAC1D,MAAM,EAAE,CAAC;IAAE0D,KAAK,EAAE;EAAE,CAAC,EACtB;IAAC1D,MAAM,EAAE,CAAC;IAAE0D,KAAK,EAAE;EAAE,CAAC,CACvB;EAED,MAAMC,CAAC,GAAGrC,kBAAkB,CAACE,KAAK,CAAC;EACnC,MAAMoC,CAAC,GAAGtC,kBAAkB,CAACE,KAAK,GAAG,CAAC,CAAC;EAEvC,IAAIqC,UAAU,GAAG,CAAC;EAClB,IAAI9B,QAAQ,KAAKA,QAAQ,CAAC+B,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,IAAI/B,QAAQ,CAAC+B,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAC7FD,UAAU,GAAG,CAAC;EAChB,MAAM7D,MAAM,GAAG+D,mBAAmB,CAACJ,CAAC,EAAEC,CAAC,EAAE3B,WAAW,EAAE4B,UAAU,CAAC;EACjE,IAAIzB,KAAa,GAAG,CAAC;EACrB,KAAK,MAAM4B,CAAC,IAAI1B,QAAQ,EAAE;IACxB,MAAM2B,GAAG,GAAGR,YAAY,CAACO,CAAC,CAAC;IAC3B,MAAME,WAAW,GAAGlE,MAAM,GAAGiE,GAAG,CAACjE,MAAM;IACvC,MAAMmE,SAAS,GAAGlH,YAAY,CAACgF,WAAW,CAAC;IAC3C,IAAIkC,SAAS,CAACC,IAAI,CAACzE,MAAM,IAAIuE,WAAW,EAAE;MACxC,MAAM,IAAIG,KAAK,IAAAvD,MAAA,CAAIqD,SAAS,CAACC,IAAI,CAACzE,MAAM,UAAAmB,MAAA,CAAOoD,WAAW,CAAE,CAAC;IAC/D;IACA,MAAMI,UAAU,GAAGH,SAAS,CAACC,IAAI,CAACF,WAAW,CAAC;IAC9C9B,KAAK,IAAIkC,UAAU,IAAIL,GAAG,CAACP,KAAK;EAClC;EACA,OAAOtB,KAAK;AACd;AAUA,SAAS2B,mBAAmBA,CAC1BJ,CAAS,EACTC,CAAS,EACT3B,WAAgB,EAER;EAAA,IADRsC,eAAuB,GAAA7E,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EAE3B,MAAM8E,CAAC,GAAGvC,WAAW,CAACC,KAAK;EAC3B,MAAMuC,EAAE,GAAGvH,IAAI,CAACyG,CAAC,CAAC,IAAIa,CAAC,GAAG,CAAC,CAAC;EAC5B,MAAME,IAAI,GAAGxE,IAAI,CAACyE,KAAK,CAACF,EAAE,CAAC;EAE3B,MAAMG,CAAC,GAAG3C,WAAW,CAAC4C,MAAM;EAC5B,MAAMC,EAAE,GAAG5H,IAAI,CAAC0G,CAAC,CAAC,IAAIgB,CAAC,GAAG,CAAC,CAAC;EAC5B,MAAMG,IAAI,GAAG7E,IAAI,CAACyE,KAAK,CAACG,EAAE,CAAC;EAC3B,MAAMjB,UAAU,GAAG5B,WAAW,CAAC4B,UAAU,GAAG5B,WAAW,CAAC4B,UAAU,GAAGU,eAAe;EAEpF,MAAMvE,MAAM,GAAG,CAAC+E,IAAI,GAAGP,CAAC,GAAGE,IAAI,IAAIb,UAAU;EAC7C,OAAO7D,MAAM;AACf"}

package/dist/glb-loader.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GLBLoader = void 0;
-const version_1 = require("./lib/utils/version");
-const parse_glb_1 = require("./lib/parsers/parse-glb");
-/**
- * GLB Loader -
- * GLB is the binary container format for GLTF
- */
-exports.GLBLoader = {
-    name: 'GLB',
-    id: 'glb',
-    module: 'gltf',
-    version: version_1.VERSION,
-    extensions: ['glb'],
-    mimeTypes: ['model/gltf-binary'],
-    binary: true,
-    parse,
-    parseSync,
-    options: {
-        glb: {
-            strict: false // Enables deprecated XVIZ support (illegal CHUNK formats)
-        }
-    }
-};
-async function parse(arrayBuffer, options) {
-    return parseSync(arrayBuffer, options);
-}
-function parseSync(arrayBuffer, options) {
-    const { byteOffset = 0 } = options || {};
-    const glb = {};
-    (0, parse_glb_1.parseGLBSync)(glb, arrayBuffer, byteOffset, options?.glb);
-    return glb;
-}

package/dist/glb-writer.js

@@ -1,35 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._TypecheckGLBLoader = exports.GLBWriter = void 0;
-const encode_glb_1 = require("./lib/encoders/encode-glb");
-const version_1 = require("./lib/utils/version");
-/**
- * GLB exporter
- * GLB is the binary container format for GLTF
- */
-exports.GLBWriter = {
-    name: 'GLB',
-    id: 'glb',
-    module: 'gltf',
-    version: version_1.VERSION,
-    extensions: ['glb'],
-    mimeTypes: ['model/gltf-binary'],
-    binary: true,
-    encodeSync,
-    options: {
-        glb: {}
-    }
-};
-function encodeSync(glb, options) {
-    const { byteOffset = 0 } = options;
-    // Calculate length and allocate buffer
-    const byteLength = (0, encode_glb_1.encodeGLBSync)(glb, null, byteOffset, options);
-    const arrayBuffer = new ArrayBuffer(byteLength);
-    // Encode into buffer
-    const dataView = new DataView(arrayBuffer);
-    (0, encode_glb_1.encodeGLBSync)(glb, dataView, byteOffset, options);
-    return arrayBuffer;
-}
-// TYPE TESTS - TODO find a better way than exporting junk
-exports._TypecheckGLBLoader = exports.GLBWriter;

package/dist/gltf-loader.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = exports.GLTFLoader = void 0;
-const version_1 = require("./lib/utils/version");
-const parse_gltf_1 = require("./lib/parsers/parse-gltf");
-/**
- * GLTF loader
- */
-exports.GLTFLoader = {
-    name: 'glTF',
-    id: 'gltf',
-    module: 'gltf',
-    version: version_1.VERSION,
-    extensions: ['gltf', 'glb'],
-    mimeTypes: ['model/gltf+json', 'model/gltf-binary'],
-    text: true,
-    binary: true,
-    tests: ['glTF'],
-    parse,
-    options: {
-        gltf: {
-            normalize: true,
-            loadBuffers: true,
-            loadImages: true,
-            decompressMeshes: true // Decompress Draco encoded meshes
-        },
-        // common?
-        log: console // eslint-disable-line
-    },
-    deprecatedOptions: {
-        fetchImages: 'gltf.loadImages',
-        createImages: 'gltf.loadImages',
-        decompress: 'gltf.decompressMeshes',
-        postProcess: 'gltf.postProcess',
-        gltf: {
-            decompress: 'gltf.decompressMeshes',
-            postProcess: 'removed in v4'
-        }
-    }
-};
-async function parse(arrayBuffer, options = {}, context) {
-    // Apps can call the parse method directly, we so apply default options here
-    options = { ...exports.GLTFLoader.options, ...options };
-    // @ts-ignore
-    options.gltf = { ...exports.GLTFLoader.options.gltf, ...options.gltf };
-    const { byteOffset = 0 } = options;
-    const gltf = {};
-    return await (0, parse_gltf_1.parseGLTF)(gltf, arrayBuffer, byteOffset, options, context);
-}
-exports.parse = parse;

package/dist/gltf-writer.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._TypecheckGLBLoader = exports.GLTFWriter = void 0;
-const version_1 = require("./lib/utils/version");
-const encode_gltf_1 = require("./lib/encoders/encode-gltf");
-/**
- * GLTF exporter
- */
-exports.GLTFWriter = {
-    name: 'glTF',
-    id: 'gltf',
-    module: 'gltf',
-    version: version_1.VERSION,
-    extensions: ['glb'],
-    mimeTypes: ['model/gltf-binary'],
-    binary: true,
-    encodeSync,
-    options: {
-        gltf: {}
-    }
-};
-function encodeSync(gltf, options = {}) {
-    const { byteOffset = 0 } = options;
-    // Calculate length, then create arraybuffer and encode
-    const byteLength = (0, encode_gltf_1.encodeGLTFSync)(gltf, null, byteOffset, options);
-    const arrayBuffer = new ArrayBuffer(byteLength);
-    const dataView = new DataView(arrayBuffer);
-    (0, encode_gltf_1.encodeGLTFSync)(gltf, dataView, byteOffset, options);
-    return arrayBuffer;
-}
-// TYPE TESTS - TODO find a better way than exporting junk
-exports._TypecheckGLBLoader = exports.GLTFWriter;