@loaders.gl/gltf 4.0.0-alpha.9 → 4.0.0-beta.2

package/dist/esm/lib/extensions/utils/3d-tiles-utils.js

@@ -0,0 +1,215 @@
+import { getComponentTypeFromArray, getFloat32ArrayForAccessor } from '../../gltf-utils/gltf-utils';
+import { getImageData } from '@loaders.gl/images';
+import { emod } from '@loaders.gl/math';
+const ATTRIBUTE_TYPE_TO_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16,
+  BOOLEAN: 1,
+  STRING: 1,
+  ENUM: 1
+};
+const 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
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+  INT8: 1,
+  UINT8: 1,
+  INT16: 2,
+  UINT16: 2,
+  INT32: 4,
+  UINT32: 4,
+  INT64: 8,
+  UINT64: 8,
+  FLOAT32: 4,
+  FLOAT64: 8
+};
+export function getArrayElementByteSize(attributeType, componentType) {
+  return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
+}
+export function getOffsetsForProperty(scenegraph, bufferViewIndex, offsetType, numberOfElements) {
+  if (offsetType !== 'UINT8' && offsetType !== 'UINT16' && offsetType !== 'UINT32' && offsetType !== 'UINT64') {
+    return null;
+  }
+  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+  const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, 'SCALAR', offsetType, numberOfElements + 1);
+  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+    return null;
+  }
+  return arrayOffsets;
+}
+export function convertRawBufferToMetadataArray(data, attributeType, componentType) {
+  let elementCount = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
+  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];
+  const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];
+  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);
+}
+export function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
+  var _json$textures, _json$textures$textur;
+  const json = scenegraph.gltf.json;
+  const texCoordAccessorKey = "TEXCOORD_".concat(textureInfo.texCoord || 0);
+  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+  const textureCoordinates = getFloat32ArrayForAccessor(scenegraph.gltf, texCoordAccessorIndex);
+  if (!textureCoordinates) {
+    return null;
+  }
+  const textureIndex = textureInfo.index;
+  const imageIndex = (_json$textures = json.textures) === null || _json$textures === void 0 ? void 0 : (_json$textures$textur = _json$textures[textureIndex]) === null || _json$textures$textur === void 0 ? void 0 : _json$textures$textur.source;
+  if (typeof imageIndex !== 'undefined') {
+    var _json$images, _json$images$imageInd, _scenegraph$gltf$imag;
+    const mimeType = (_json$images = json.images) === null || _json$images === void 0 ? void 0 : (_json$images$imageInd = _json$images[imageIndex]) === null || _json$images$imageInd === void 0 ? void 0 : _json$images$imageInd.mimeType;
+    const parsedImage = (_scenegraph$gltf$imag = scenegraph.gltf.images) === null || _scenegraph$gltf$imag === void 0 ? void 0 : _scenegraph$gltf$imag[imageIndex];
+    if (parsedImage && typeof parsedImage.width !== 'undefined') {
+      const textureData = [];
+      for (let index = 0; index < textureCoordinates.length; index += 2) {
+        const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
+        textureData.push(value);
+      }
+      return textureData;
+    }
+  }
+  return null;
+}
+export function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
+  if (!(propertyData !== null && propertyData !== void 0 && propertyData.length)) {
+    return;
+  }
+  const featureIndices = [];
+  for (const texelData of propertyData) {
+    let index = featureTable.findIndex(item => item === texelData);
+    if (index === -1) {
+      index = featureTable.push(texelData) - 1;
+    }
+    featureIndices.push(index);
+  }
+  const typedArray = new Uint32Array(featureIndices);
+  const bufferIndex = scenegraph.gltf.buffers.push({
+    arrayBuffer: typedArray.buffer,
+    byteOffset: typedArray.byteOffset,
+    byteLength: typedArray.byteLength
+  }) - 1;
+  const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+  const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+    size: 1,
+    componentType: getComponentTypeFromArray(typedArray),
+    count: typedArray.length
+  });
+  primitive.attributes[attributeName] = accessorIndex;
+}
+function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index) {
+  let channels = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [0];
+  const CHANNELS_MAP = {
+    r: {
+      offset: 0,
+      shift: 0
+    },
+    g: {
+      offset: 1,
+      shift: 8
+    },
+    b: {
+      offset: 2,
+      shift: 16
+    },
+    a: {
+      offset: 3,
+      shift: 24
+    }
+  };
+  const u = textureCoordinates[index];
+  const v = textureCoordinates[index + 1];
+  let components = 1;
+  if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1)) components = 4;
+  const offset = coordinatesToOffset(u, v, parsedImage, components);
+  let value = 0;
+  for (const c of channels) {
+    const map = typeof c === 'number' ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
+    const imageOffset = offset + map.offset;
+    const imageData = getImageData(parsedImage);
+    if (imageData.data.length <= imageOffset) {
+      throw new Error("".concat(imageData.data.length, " <= ").concat(imageOffset));
+    }
+    const imageValue = imageData.data[imageOffset];
+    value |= imageValue << map.shift;
+  }
+  return value;
+}
+function coordinatesToOffset(u, v, parsedImage) {
+  let componentsCount = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  const w = parsedImage.width;
+  const iX = emod(u) * (w - 1);
+  const indX = Math.round(iX);
+  const h = parsedImage.height;
+  const iY = emod(v) * (h - 1);
+  const indY = Math.round(iY);
+  const components = parsedImage.components ? parsedImage.components : componentsCount;
+  const offset = (indY * w + indX) * components;
+  return offset;
+}
+export function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, valueSize) {
+  const attributeValueArray = [];
+  for (let index = 0; index < numberOfElements; index++) {
+    const arrayOffset = arrayOffsets[index];
+    const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
+    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+      break;
+    }
+    const typedArrayOffset = arrayOffset / valueSize;
+    const elementCount = arrayByteSize / valueSize;
+    attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
+  }
+  return attributeValueArray;
+}
+export function parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
+  const attributeValueArray = [];
+  for (let index = 0; index < numberOfElements; index++) {
+    const elementOffset = index * arrayCount;
+    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
+  }
+  return attributeValueArray;
+}
+export function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets) {
+  if (arrayOffsets) {
+    throw new Error('Not implemented - arrayOffsets for strings is specified');
+  }
+  if (stringOffsets) {
+    const stringsArray = [];
+    const textDecoder = new TextDecoder('utf8');
+    let stringOffset = 0;
+    for (let index = 0; index < numberOfElements; index++) {
+      const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];
+      if (stringByteSize + stringOffset <= valuesDataBytes.length) {
+        const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);
+        const stringAttribute = textDecoder.decode(stringData);
+        stringsArray.push(stringAttribute);
+        stringOffset += stringByteSize;
+      }
+    }
+    return stringsArray;
+  }
+  return [];
+}
+//# sourceMappingURL=3d-tiles-utils.js.map

package/dist/esm/lib/extensions/utils/3d-tiles-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"3d-tiles-utils.js","names":["getComponentTypeFromArray","getFloat32ArrayForAccessor","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","getOffsetsForProperty","scenegraph","bufferViewIndex","offsetType","numberOfElements","arrayOffsetsBytes","getTypedArrayForBufferView","arrayOffsets","convertRawBufferToMetadataArray","data","elementCount","arguments","length","undefined","numberOfComponents","ArrayType","size","byteLength","buffer","offset","byteOffset","bufferArray","slice","getPrimitiveTextureData","textureInfo","primitive","_json$textures","_json$textures$textur","json","gltf","texCoordAccessorKey","concat","texCoord","texCoordAccessorIndex","attributes","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","typedArray","bufferIndex","buffers","arrayBuffer","addBufferView","accessorIndex","addAccessor","count","CHANNELS_MAP","r","shift","g","b","a","u","v","components","indexOf","coordinatesToOffset","c","map","Object","values","imageOffset","imageData","Error","imageValue","componentsCount","w","iX","indX","Math","round","h","height","iY","indY","parseVariableLengthArrayNumeric","valuesData","valuesDataBytesLength","valueSize","attributeValueArray","arrayOffset","arrayByteSize","typedArrayOffset","parseFixedLengthArrayNumeric","arrayCount","elementOffset","getPropertyDataString","valuesDataBytes","stringOffsets","stringsArray","textDecoder","TextDecoder","stringOffset","stringByteSize","stringData","subarray","stringAttribute","decode"],"sources":["../../../../../src/lib/extensions/utils/3d-tiles-utils.ts"],"sourcesContent":["/**\n * loaders.gl, MIT license\n *\n * Shared code for 3DTiles extensions:\n * * EXT_feature_metadata\n * * EXT_mesh_features\n * * EXT_structural_metadata\n */\n\nimport type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../../types/gltf-json-schema';\nimport type {BigTypedArray, TypedArray} from '@loaders.gl/schema';\nimport type {ImageType} from '@loaders.gl/images';\n\nimport {GLTFScenegraph} from '../../api/gltf-scenegraph';\nimport {getComponentTypeFromArray, getFloat32ArrayForAccessor} from '../../gltf-utils/gltf-utils';\nimport {getImageData} from '@loaders.gl/images';\nimport {emod} from '@loaders.gl/math';\n\nexport type NumericComponentType =\n  | 'INT8'\n  | 'UINT8'\n  | 'INT16'\n  | 'UINT16'\n  | 'INT32'\n  | 'UINT32'\n  | 'INT64'\n  | 'UINT64'\n  | 'FLOAT32'\n  | 'FLOAT64';\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 * Gets offset array from `arrayOffsets` or `stringOffsets`.\n * @param scenegraph - Instance of the class for structured access to GLTF data.\n * @param bufferViewIndex - Buffer view index\n * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.\n * @param numberOfElements - The number of elements in each property array.\n * @returns Array of values offsets. The number of offsets in the array is equal to `numberOfElements` plus one.\n */\nexport function getOffsetsForProperty(\n  scenegraph: GLTFScenegraph,\n  bufferViewIndex: number,\n  offsetType: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string,\n  numberOfElements: number\n): TypedArray | null {\n  if (\n    offsetType !== 'UINT8' &&\n    offsetType !== 'UINT16' &&\n    offsetType !== 'UINT32' &&\n    offsetType !== 'UINT64'\n  ) {\n    return null;\n  }\n  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);\n  const arrayOffsets = convertRawBufferToMetadataArray(\n    arrayOffsetsBytes,\n    'SCALAR', // offsets consist of ONE component\n    offsetType,\n    numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.\n  );\n\n  // We don't support BigInt offsets at the moment. It requires additional logic and potential issues in Safari\n  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {\n    return null;\n  }\n  return arrayOffsets;\n}\n\n/**\n * Converts raw bytes that are in the buffer to an array of the type defined by the schema.\n * @param data - Raw bytes in the buffer.\n * @param attributeType - SCALAR, VECN, MATN.\n * @param componentType - Type of the component in elements, e.g. 'UINT8' or 'FLOAT32'.\n * @param elementCount - Number of elements in the array. Default value is 1.\n * @returns Data array\n */\nexport function convertRawBufferToMetadataArray(\n  data: Uint8Array,\n  attributeType: string,\n  componentType: NumericComponentType,\n  elementCount: number = 1\n): BigTypedArray {\n  const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];\n  const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];\n  const length = elementCount * numberOfComponents;\n  const byteLength = length * size;\n  let buffer = data.buffer;\n  let offset = data.byteOffset;\n  if (offset % size !== 0) {\n    const bufferArray = new Uint8Array(buffer);\n    buffer = bufferArray.slice(offset, offset + byteLength).buffer;\n    offset = 0;\n  }\n  return new ArrayType(buffer, offset, length);\n}\n\n/**\n * Processes data encoded in the texture associated with the primitive.\n * @param scenegraph - Instance of the class for structured access to GLTF data.\n * @param textureInfo - Reference to the texture where extension data are stored.\n * @param primitive - Primitive object in the mesh.\n * @returns 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\n  const textureCoordinates: Float32Array | null = getFloat32ArrayForAccessor(\n    scenegraph.gltf,\n    texCoordAccessorIndex\n  );\n  if (!textureCoordinates) {\n    return null;\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 scenegraph - Scenegraph object.\n * @param attributeName - Name of the attribute.\n * @param propertyData - Property data to store.\n * @param featureTable - Array where unique data from the property data are being stored.\n * @param 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  // No reason to create an empty buffer if there is no property data to store.\n  if (!propertyData?.length) {\n    return;\n  }\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 parsedImage - Image where the data are stored.\n * @param mimeType - MIME type.\n * @param textureCoordinates - uv coordinates to access data in the image.\n * @param index - Index of uv coordinates in the array textureCoordinates.\n * @param channels - Image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.\n * @returns Value taken from the image.\n */\nfunction getImageValueByCoordinates(\n  parsedImage: ImageType,\n  mimeType: string | undefined,\n  textureCoordinates: Float32Array,\n  index: number,\n  channels: number[] | string = [0]\n) {\n  const CHANNELS_MAP = {\n    r: {offset: 0, shift: 0},\n    g: {offset: 1, shift: 8},\n    b: {offset: 2, shift: 16},\n    a: {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    /*\n    According to the EXT_feature_metadata extension specification:\n      Channels are labeled by rgba and are swizzled with a string of 1-4 characters.\n    According to the EXT_mesh_features extension specification:\n      The channels array contains non-negative integer values corresponding to channels of the source texture that the feature ID consists of.\n      Channels of an RGBA texture are numbered 0–3 respectively.\n    Function getImageValueByCoordinates is used to process both extensions. \n    So, there should be possible to get the element of CHANNELS_MAP by either index (0, 1, 2, 3) or key (r, g, b, a).\n    */\n    const map = typeof c === 'number' ? Object.values(CHANNELS_MAP)[c] : 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\n/**\n * Parses variable-length array data.\n * In this case every value of the property in the table will be an array\n * of arbitrary length.\n * @param valuesData - Values in a flat typed array.\n * @param numberOfElements - Number of rows in the property table.\n * @param arrayOffsets - Offsets of nested arrays in the flat values array.\n * @param valuesDataBytesLength - Data byte length.\n * @param valueSize - Value size in bytes.\n * @returns Array of typed arrays.\n */\nexport function parseVariableLengthArrayNumeric(\n  valuesData: BigTypedArray,\n  numberOfElements: number,\n  arrayOffsets: TypedArray,\n  valuesDataBytesLength: number,\n  valueSize: number\n): BigTypedArray[] {\n  const attributeValueArray: BigTypedArray[] = [];\n  for (let index = 0; index < numberOfElements; index++) {\n    const arrayOffset = arrayOffsets[index];\n    const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];\n    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {\n      break;\n    }\n    const typedArrayOffset = arrayOffset / valueSize;\n    const elementCount = arrayByteSize / valueSize;\n    attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));\n  }\n  return attributeValueArray;\n}\n\n/**\n * Parses fixed-length array data.\n * In this case every value of the property in the table will be an array\n * of constant length equal to `arrayCount`.\n * @param valuesData - Values in a flat typed array.\n * @param numberOfElements - Number of rows in the property table.\n * @param arrayCount - Nested arrays length.\n * @returns Array of typed arrays.\n */\nexport function parseFixedLengthArrayNumeric(\n  valuesData: BigTypedArray,\n  numberOfElements: number,\n  arrayCount: number\n): BigTypedArray[] {\n  const attributeValueArray: BigTypedArray[] = [];\n  for (let index = 0; index < numberOfElements; index++) {\n    const elementOffset = index * arrayCount;\n    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));\n  }\n  return attributeValueArray;\n}\n\n/**\n * Decodes properties of string type from binary source.\n * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.\n * @param valuesDataBytes - Data taken from values property of the property table property.\n * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.\n * @param stringOffsets - Index of the buffer view containing offsets for strings. It should be available for string type.\n * @returns String property values\n */\nexport function getPropertyDataString(\n  numberOfElements: number,\n  valuesDataBytes: Uint8Array,\n  arrayOffsets: TypedArray | null,\n  stringOffsets: TypedArray | null\n): string[] | string[][] {\n  if (arrayOffsets) {\n    // TODO: implement it as soon as we have the corresponding tileset\n    throw new Error('Not implemented - arrayOffsets for strings is specified');\n  }\n\n  if (stringOffsets) {\n    const stringsArray: string[] = [];\n    const textDecoder = new TextDecoder('utf8');\n\n    let stringOffset = 0;\n    for (let index = 0; index < numberOfElements; index++) {\n      const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];\n\n      if (stringByteSize + stringOffset <= valuesDataBytes.length) {\n        const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);\n        const stringAttribute = textDecoder.decode(stringData);\n\n        stringsArray.push(stringAttribute);\n        stringOffset += stringByteSize;\n      }\n    }\n\n    return stringsArray;\n  }\n  return [];\n}\n"],"mappings":"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"}

package/dist/esm/lib/gltf-utils/gltf-utils.js

@@ -1,4 +1,5 @@
 import { assert } from '../utils/assert';
+import { BYTES, COMPONENTS } from '../gltf-utils/gltf-constants';
 const MIPMAP_FACTOR = 1.33;
 const TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
 const ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [[Int8Array, 5120], [Uint8Array, 5121], [Int16Array, 5122], [Uint16Array, 5123], [Uint32Array, 5125], [Float32Array, 5126], [Float64Array, 5130]];
@@ -52,6 +53,35 @@ export function getAccessorArrayTypeAndLength(accessor, bufferView) {
     byteLength
   };
 }
+export function getFloat32ArrayForAccessor(gltfData, texCoordAccessor) {
+  var _gltfData$json$access;
+  const accessor = (_gltfData$json$access = gltfData.json.accessors) === null || _gltfData$json$access === void 0 ? void 0 : _gltfData$json$access[texCoordAccessor];
+  if (accessor && typeof accessor.bufferView !== 'undefined') {
+    var _gltfData$json$buffer;
+    const bufferView = (_gltfData$json$buffer = gltfData.json.bufferViews) === null || _gltfData$json$buffer === void 0 ? void 0 : _gltfData$json$buffer[accessor.bufferView];
+    if (bufferView) {
+      const {
+        arrayBuffer,
+        byteOffset: bufferByteOffset
+      } = gltfData.buffers[bufferView.buffer];
+      const byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+      const {
+        ArrayType,
+        length
+      } = getAccessorArrayTypeAndLength(accessor, bufferView);
+      const bytes = BYTES[accessor.componentType];
+      const components = COMPONENTS[accessor.type];
+      const elementAddressScale = bufferView.byteStride || bytes * components;
+      const result = new Float32Array(length);
+      for (let i = 0; i < accessor.count; i++) {
+        const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);
+        result.set(uv, i * components);
+      }
+      return result;
+    }
+  }
+  return null;
+}
 export function getMemoryUsageGLTF(gltf) {
   let {
     images,

package/dist/esm/lib/gltf-utils/gltf-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-utils.js","names":["assert","MIPMAP_FACTOR","TYPES","ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT","Int8Array","Uint8Array","Int16Array","Uint16Array","Uint32Array","Float32Array","Float64Array","ARRAY_TO_COMPONENT_TYPE","Map","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","getAccessorTypeFromSize","size","type","getComponentTypeFromArray","typedArray","componentType","get","constructor","Error","getAccessorArrayTypeAndLength","accessor","bufferView","ArrayType","components","bytesPerComponent","length","count","byteLength","getMemoryUsageGLTF","gltf","images","bufferViews","imageBufferViews","map","i","filter","view","includes","bufferMemory","reduce","acc","pixelCount","image","width","height","Math","ceil"],"sources":["../../../../src/lib/gltf-utils/gltf-utils.ts"],"sourcesContent":["import {assert} from '../utils/assert';\nimport type {GLTFPostprocessed} from '../types/gltf-postprocessed-schema';\n\n/**\n * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...\n * Minimum 1.33, but due to GPU layout may be 1.5\n */\nconst MIPMAP_FACTOR = 1.33;\n\nconst TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];\n\ntype TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nconst ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [\n  [Int8Array, 5120],\n  [Uint8Array, 5121],\n  [Int16Array, 5122],\n  [Uint16Array, 5123],\n  [Uint32Array, 5125],\n  [Float32Array, 5126],\n  [Float64Array, 5130]\n];\nconst ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(\n  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT\n);\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};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  5120: 1,\n  5121: 1,\n  5122: 2,\n  5123: 2,\n  5125: 4,\n  5126: 4\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  5120: Int8Array,\n  5121: Uint8Array,\n  5122: Int16Array,\n  5123: Uint16Array,\n  5125: Uint32Array,\n  5126: Float32Array\n};\n\nexport function getAccessorTypeFromSize(size) {\n  const type = TYPES[size - 1];\n  return type || TYPES[0];\n}\n\nexport function getComponentTypeFromArray(typedArray) {\n  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);\n  if (!componentType) {\n    throw new Error('Illegal typed array');\n  }\n  return componentType;\n}\n\nexport function getAccessorArrayTypeAndLength(accessor, bufferView) {\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];\n  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];\n  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];\n  const length = accessor.count * components;\n  const byteLength = accessor.count * components * bytesPerComponent;\n  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);\n  return {ArrayType, length, byteLength};\n}\n\n/**\n * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory\n * @param gltf - the gltf content of a GLTF tile\n * @returns - total memory usage in bytes\n */\nexport function getMemoryUsageGLTF(gltf: GLTFPostprocessed): number {\n  let {images, bufferViews} = gltf;\n  images = images || [];\n  bufferViews = bufferViews || [];\n  const imageBufferViews = images.map((i) => i.bufferView);\n  bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view as any));\n\n  const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);\n\n  // Assume each pixel of the texture is 4 channel with mimmaps (which add 33%)\n  // TODO correctly handle compressed textures\n  const pixelCount = images.reduce((acc, image) => {\n    // @ts-ignore\n    const {width, height} = (image as any).image;\n    return acc + width * height;\n  }, 0);\n  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);\n}\n"],"mappings":"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"}
+{"version":3,"file":"gltf-utils.js","names":["assert","BYTES","COMPONENTS","MIPMAP_FACTOR","TYPES","ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT","Int8Array","Uint8Array","Int16Array","Uint16Array","Uint32Array","Float32Array","Float64Array","ARRAY_TO_COMPONENT_TYPE","Map","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","getAccessorTypeFromSize","size","type","getComponentTypeFromArray","typedArray","componentType","get","constructor","Error","getAccessorArrayTypeAndLength","accessor","bufferView","ArrayType","components","bytesPerComponent","length","count","byteLength","getFloat32ArrayForAccessor","gltfData","texCoordAccessor","_gltfData$json$access","json","accessors","_gltfData$json$buffer","bufferViews","arrayBuffer","byteOffset","bufferByteOffset","buffers","buffer","bytes","elementAddressScale","byteStride","result","i","uv","set","getMemoryUsageGLTF","gltf","images","imageBufferViews","map","filter","view","includes","bufferMemory","reduce","acc","pixelCount","image","width","height","Math","ceil"],"sources":["../../../../src/lib/gltf-utils/gltf-utils.ts"],"sourcesContent":["import {assert} from '../utils/assert';\n\nimport type {GLTFWithBuffers} from '../types/gltf-types';\nimport type {GLTFPostprocessed} from '../types/gltf-postprocessed-schema';\nimport {BYTES, COMPONENTS} from '../gltf-utils/gltf-constants';\n\n/**\n * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...\n * Minimum 1.33, but due to GPU layout may be 1.5\n */\nconst MIPMAP_FACTOR = 1.33;\n\nconst TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];\n\ntype TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nconst ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [\n  [Int8Array, 5120],\n  [Uint8Array, 5121],\n  [Int16Array, 5122],\n  [Uint16Array, 5123],\n  [Uint32Array, 5125],\n  [Float32Array, 5126],\n  [Float64Array, 5130]\n];\nconst ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(\n  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT\n);\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};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  5120: 1,\n  5121: 1,\n  5122: 2,\n  5123: 2,\n  5125: 4,\n  5126: 4\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  5120: Int8Array,\n  5121: Uint8Array,\n  5122: Int16Array,\n  5123: Uint16Array,\n  5125: Uint32Array,\n  5126: Float32Array\n};\n\nexport function getAccessorTypeFromSize(size) {\n  const type = TYPES[size - 1];\n  return type || TYPES[0];\n}\n\nexport function getComponentTypeFromArray(typedArray) {\n  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);\n  if (!componentType) {\n    throw new Error('Illegal typed array');\n  }\n  return componentType;\n}\n\nexport function getAccessorArrayTypeAndLength(accessor, bufferView) {\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];\n  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];\n  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];\n  const length = accessor.count * components;\n  const byteLength = accessor.count * components * bytesPerComponent;\n  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);\n  return {ArrayType, length, byteLength};\n}\n\nexport function getFloat32ArrayForAccessor(\n  gltfData: GLTFWithBuffers,\n  texCoordAccessor: number\n): Float32Array | null {\n  const accessor = gltfData.json.accessors?.[texCoordAccessor];\n  if (accessor && typeof accessor.bufferView !== 'undefined') {\n    // Get `bufferView` of the `accessor`\n    const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];\n    if (bufferView) {\n      // Get `arrayBuffer` the `bufferView` look at\n      const {arrayBuffer, byteOffset: bufferByteOffset} = gltfData.buffers[bufferView.buffer];\n      // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets\n      const byteOffset =\n        (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);\n      // Deduce TypedArray type and its length from `accessor` and `bufferView` data\n      const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n      // Number of bytes each component occupies\n      const bytes = BYTES[accessor.componentType];\n      // Number of components. For the `TEXCOORD_0` with `VEC2` type, it must return 2\n      const components = COMPONENTS[accessor.type];\n      // Multiplier to calculate the address of the `TEXCOORD_0` element in the arrayBuffer\n      const elementAddressScale = bufferView.byteStride || bytes * components;\n      // Data transform to Float32Array\n      const result = new Float32Array(length);\n      for (let i = 0; i < accessor.count; i++) {\n        // Take [u, v] couple from the arrayBuffer\n        const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);\n        result.set(uv, i * components);\n      }\n      return result;\n    }\n  }\n  return null;\n}\n\n/**\n * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory\n * @param gltf - the gltf content of a GLTF tile\n * @returns - total memory usage in bytes\n */\nexport function getMemoryUsageGLTF(gltf: GLTFPostprocessed): number {\n  let {images, bufferViews} = gltf;\n  images = images || [];\n  bufferViews = bufferViews || [];\n  const imageBufferViews = images.map((i) => i.bufferView);\n  bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view as any));\n\n  const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);\n\n  // Assume each pixel of the texture is 4 channel with mimmaps (which add 33%)\n  // TODO correctly handle compressed textures\n  const pixelCount = images.reduce((acc, image) => {\n    // @ts-ignore\n    const {width, height} = (image as any).image;\n    return acc + width * height;\n  }, 0);\n  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);\n}\n"],"mappings":"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"}

package/dist/esm/lib/parsers/parse-gltf.js

@@ -1,4 +1,4 @@
-import { parseJSON, sliceArrayBuffer } from '@loaders.gl/loader-utils';
+import { parseJSON, sliceArrayBuffer, parseFromContext } from '@loaders.gl/loader-utils';
 import { ImageLoader } from '@loaders.gl/images';
 import { BasisLoader, selectSupportedBasisFormat } from '@loaders.gl/textures';
 import { assert } from '../utils/assert';
@@ -112,13 +112,12 @@ function getReferencesImageIndices(gltf) {
   return Array.from(imageIndices).sort();
 }
 async function loadImage(gltf, image, index, options, context) {
-  const {
-    fetch,
-    parse
-  } = context;
   let arrayBuffer;
   if (image.uri && !image.hasOwnProperty('bufferView')) {
     const uri = resolveUrl(image.uri, options);
+    const {
+      fetch
+    } = context;
     const response = await fetch(uri);
     arrayBuffer = await response.arrayBuffer();
     image.bufferView = {
@@ -130,7 +129,8 @@ async function loadImage(gltf, image, index, options, context) {
     arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
   }
   assert(arrayBuffer, 'glTF image has no data');
-  let parsedImage = await parse(arrayBuffer, [ImageLoader, BasisLoader], {
+  let parsedImage = await parseFromContext(arrayBuffer, [ImageLoader, BasisLoader], {
+    ...options,
     mimeType: image.mimeType,
     basis: options.basis || {
       format: selectSupportedBasisFormat()

package/dist/esm/lib/parsers/parse-gltf.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse-gltf.js","names":["parseJSON","sliceArrayBuffer","ImageLoader","BasisLoader","selectSupportedBasisFormat","assert","isGLB","parseGLBSync","resolveUrl","getTypedArrayForBufferView","preprocessExtensions","decodeExtensions","normalizeGLTFV1","isGLTF","arrayBuffer","options","byteOffset","parseGLTF","gltf","arrayBufferOrString","_options$gltf","_options$gltf2","_options$gltf3","arguments","length","undefined","context","parseGLTFContainerSync","normalize","loadBuffers","json","buffers","loadImages","data","uri","baseUri","ArrayBuffer","textDecoder","TextDecoder","decode","glb","type","concat","_glb","Array","fill","header","hasBinChunk","binChunks","byteLength","images","i","buffer","_context$fetch","_response$arrayBuffer","fetch","response","call","imageIndices","getReferencesImageIndices","promises","imageIndex","push","loadImage","Promise","all","Set","textures","texture","source","add","from","sort","image","index","parse","hasOwnProperty","bufferView","Number","isFinite","array","parsedImage","mimeType","basis","format","compressed","mipmaps","width","height"],"sources":["../../../../src/lib/parsers/parse-gltf.ts"],"sourcesContent":["/* eslint-disable camelcase, max-statements, no-restricted-globals */\nimport type {LoaderContext} from '@loaders.gl/loader-utils';\nimport type {GLTFLoaderOptions} from '../../gltf-loader';\nimport type {GLTFWithBuffers} from '../types/gltf-types';\nimport type {GLB} from '../types/glb-types';\nimport type {ParseGLBOptions} from './parse-glb';\n\nimport {parseJSON, sliceArrayBuffer} from '@loaders.gl/loader-utils';\nimport {ImageLoader} from '@loaders.gl/images';\nimport {BasisLoader, selectSupportedBasisFormat} from '@loaders.gl/textures';\n\nimport {assert} from '../utils/assert';\nimport {isGLB, parseGLBSync} from './parse-glb';\nimport {resolveUrl} from '../gltf-utils/resolve-url';\nimport {getTypedArrayForBufferView} from '../gltf-utils/get-typed-array';\nimport {preprocessExtensions, decodeExtensions} from '../api/gltf-extensions';\nimport {normalizeGLTFV1} from '../api/normalize-gltf-v1';\n\n/**  */\nexport type ParseGLTFOptions = ParseGLBOptions & {\n  normalize?: boolean;\n  loadImages?: boolean;\n  loadBuffers?: boolean;\n  decompressMeshes?: boolean;\n  excludeExtensions?: string[];\n\n  /** @deprecated not supported in v4. `postProcessGLTF()` must be called by the application */\n  postProcess?: false;\n};\n\n/** Check if an array buffer appears to contain GLTF data */\nexport function isGLTF(arrayBuffer: ArrayBuffer, options?: ParseGLTFOptions): boolean {\n  const byteOffset = 0;\n  return isGLB(arrayBuffer, byteOffset, options);\n}\n\nexport async function parseGLTF(\n  gltf: GLTFWithBuffers,\n  arrayBufferOrString,\n  byteOffset = 0,\n  options: GLTFLoaderOptions,\n  context: LoaderContext\n): Promise<GLTFWithBuffers> {\n  parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);\n\n  normalizeGLTFV1(gltf, {normalize: options?.gltf?.normalize});\n\n  preprocessExtensions(gltf, options, context);\n\n  // Load linked buffers asynchronously and decodes base64 buffers in parallel\n  if (options?.gltf?.loadBuffers && gltf.json.buffers) {\n    await loadBuffers(gltf, options, context);\n  }\n\n  // loadImages and decodeExtensions should not be running in parallel, because\n  // decodeExtensions uses data from images taken during the loadImages call.\n  if (options?.gltf?.loadImages) {\n    await loadImages(gltf, options, context);\n  }\n\n  await decodeExtensions(gltf, options, context);\n\n  return gltf;\n}\n\n/**\n *\n * @param gltf\n * @param data - can be ArrayBuffer (GLB), ArrayBuffer (Binary JSON), String (JSON), or Object (parsed JSON)\n * @param byteOffset\n * @param options\n */\nfunction parseGLTFContainerSync(gltf, data, byteOffset, options) {\n  // Initialize gltf container\n  if (options.uri) {\n    gltf.baseUri = options.uri;\n  }\n\n  // If data is binary and starting with magic bytes, assume binary JSON text, convert to string\n  if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {\n    const textDecoder = new TextDecoder();\n    data = textDecoder.decode(data);\n  }\n\n  if (typeof data === 'string') {\n    // If string, try to parse as JSON\n    gltf.json = parseJSON(data);\n  } else if (data instanceof ArrayBuffer) {\n    // If still ArrayBuffer, parse as GLB container\n    const glb: GLB = {} as GLB;\n    byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);\n\n    assert(glb.type === 'glTF', `Invalid GLB magic string ${glb.type}`);\n\n    gltf._glb = glb;\n    gltf.json = glb.json;\n  } else {\n    assert(false, 'GLTF: must be ArrayBuffer or string');\n  }\n\n  // Populate buffers\n  // Create an external buffers array to hold binary data\n  const buffers = gltf.json.buffers || [];\n  gltf.buffers = new Array(buffers.length).fill(null);\n\n  // Populates JSON and some bin chunk info\n  if (gltf._glb && gltf._glb.header.hasBinChunk) {\n    const {binChunks} = gltf._glb;\n    gltf.buffers[0] = {\n      arrayBuffer: binChunks[0].arrayBuffer,\n      byteOffset: binChunks[0].byteOffset,\n      byteLength: binChunks[0].byteLength\n    };\n\n    // TODO - this modifies JSON and is a post processing thing\n    // gltf.json.buffers[0].data = gltf.buffers[0].arrayBuffer;\n    // gltf.json.buffers[0].byteOffset = gltf.buffers[0].byteOffset;\n  }\n\n  // Populate images\n  const images = gltf.json.images || [];\n  gltf.images = new Array(images.length).fill({});\n}\n\n/** Asynchronously fetch and parse buffers, store in buffers array outside of json\n * TODO - traverse gltf and determine which buffers are actually needed\n */\nasync function loadBuffers(gltf: GLTFWithBuffers, options, context: LoaderContext) {\n  // TODO\n  const buffers = gltf.json.buffers || [];\n  for (let i = 0; i < buffers.length; ++i) {\n    const buffer = buffers[i];\n    if (buffer.uri) {\n      const {fetch} = context;\n      assert(fetch);\n\n      const uri = resolveUrl(buffer.uri, options);\n      const response = await context?.fetch?.(uri);\n      const arrayBuffer = await response?.arrayBuffer?.();\n\n      gltf.buffers[i] = {\n        arrayBuffer,\n        byteOffset: 0,\n        byteLength: arrayBuffer.byteLength\n      };\n\n      delete buffer.uri;\n    } else if (gltf.buffers[i] === null) {\n      gltf.buffers[i] = {\n        arrayBuffer: new ArrayBuffer(buffer.byteLength),\n        byteOffset: 0,\n        byteLength: buffer.byteLength\n      };\n    }\n  }\n}\n\n/**\n * Loads all images\n * TODO - traverse gltf and determine which images are actually needed\n * @param gltf\n * @param options\n * @param context\n * @returns\n */\nasync function loadImages(gltf: GLTFWithBuffers, options, context: LoaderContext) {\n  const imageIndices = getReferencesImageIndices(gltf);\n\n  const images = gltf.json.images || [];\n\n  const promises: Promise<any>[] = [];\n  for (const imageIndex of imageIndices) {\n    promises.push(loadImage(gltf, images[imageIndex], imageIndex, options, context));\n  }\n\n  return await Promise.all(promises);\n}\n\n/** Make sure we only load images that are actually referenced by textures */\nfunction getReferencesImageIndices(gltf: GLTFWithBuffers): number[] {\n  const imageIndices = new Set<number>();\n\n  const textures = gltf.json.textures || [];\n  for (const texture of textures) {\n    if (texture.source !== undefined) {\n      imageIndices.add(texture.source);\n    }\n  }\n\n  return Array.from(imageIndices).sort();\n}\n\n/** Asynchronously fetches and parses one image, store in images array outside of json */\nasync function loadImage(\n  gltf: GLTFWithBuffers,\n  image,\n  index: number,\n  options,\n  context: LoaderContext\n) {\n  const {fetch, parse} = context;\n\n  let arrayBuffer;\n\n  if (image.uri && !image.hasOwnProperty('bufferView')) {\n    const uri = resolveUrl(image.uri, options);\n    const response = await fetch(uri);\n    arrayBuffer = await response.arrayBuffer();\n    image.bufferView = {\n      data: arrayBuffer\n    };\n  }\n\n  if (Number.isFinite(image.bufferView)) {\n    const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);\n    arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);\n  }\n\n  assert(arrayBuffer, 'glTF image has no data');\n\n  // Call `parse`\n  let parsedImage = await parse(\n    arrayBuffer,\n    [ImageLoader, BasisLoader],\n    {mimeType: image.mimeType, basis: options.basis || {format: selectSupportedBasisFormat()}},\n    context\n  );\n\n  if (parsedImage && parsedImage[0]) {\n    parsedImage = {\n      compressed: true,\n      mipmaps: false,\n      width: parsedImage[0].width,\n      height: parsedImage[0].height,\n      data: parsedImage[0]\n    };\n  }\n  // TODO making sure ImageLoader is overridable by using array of loaders\n  // const parsedImage = await parse(arrayBuffer, [ImageLoader]);\n\n  // Store the loaded image\n  gltf.images = gltf.images || [];\n  gltf.images[index] = parsedImage;\n}\n"],"mappings":"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"}
+{"version":3,"file":"parse-gltf.js","names":["parseJSON","sliceArrayBuffer","parseFromContext","ImageLoader","BasisLoader","selectSupportedBasisFormat","assert","isGLB","parseGLBSync","resolveUrl","getTypedArrayForBufferView","preprocessExtensions","decodeExtensions","normalizeGLTFV1","isGLTF","arrayBuffer","options","byteOffset","parseGLTF","gltf","arrayBufferOrString","_options$gltf","_options$gltf2","_options$gltf3","arguments","length","undefined","context","parseGLTFContainerSync","normalize","loadBuffers","json","buffers","loadImages","data","uri","baseUri","ArrayBuffer","textDecoder","TextDecoder","decode","glb","type","concat","_glb","Array","fill","header","hasBinChunk","binChunks","byteLength","images","i","buffer","_context$fetch","_response$arrayBuffer","fetch","response","call","imageIndices","getReferencesImageIndices","promises","imageIndex","push","loadImage","Promise","all","Set","textures","texture","source","add","from","sort","image","index","hasOwnProperty","bufferView","Number","isFinite","array","parsedImage","mimeType","basis","format","compressed","mipmaps","width","height"],"sources":["../../../../src/lib/parsers/parse-gltf.ts"],"sourcesContent":["/* eslint-disable camelcase, max-statements, no-restricted-globals */\nimport type {LoaderContext} from '@loaders.gl/loader-utils';\nimport type {GLTFLoaderOptions} from '../../gltf-loader';\nimport type {GLTFWithBuffers} from '../types/gltf-types';\nimport type {GLB} from '../types/glb-types';\nimport type {ParseGLBOptions} from './parse-glb';\n\nimport type {ImageType, TextureLevel} from '@loaders.gl/schema';\nimport {parseJSON, sliceArrayBuffer, parseFromContext} from '@loaders.gl/loader-utils';\nimport {ImageLoader} from '@loaders.gl/images';\nimport {BasisLoader, selectSupportedBasisFormat} from '@loaders.gl/textures';\n\nimport {assert} from '../utils/assert';\nimport {isGLB, parseGLBSync} from './parse-glb';\nimport {resolveUrl} from '../gltf-utils/resolve-url';\nimport {getTypedArrayForBufferView} from '../gltf-utils/get-typed-array';\nimport {preprocessExtensions, decodeExtensions} from '../api/gltf-extensions';\nimport {normalizeGLTFV1} from '../api/normalize-gltf-v1';\n\n/**  */\nexport type ParseGLTFOptions = ParseGLBOptions & {\n  normalize?: boolean;\n  loadImages?: boolean;\n  loadBuffers?: boolean;\n  decompressMeshes?: boolean;\n  excludeExtensions?: string[];\n\n  /** @deprecated not supported in v4. `postProcessGLTF()` must be called by the application */\n  postProcess?: false;\n};\n\n/** Check if an array buffer appears to contain GLTF data */\nexport function isGLTF(arrayBuffer: ArrayBuffer, options?: ParseGLTFOptions): boolean {\n  const byteOffset = 0;\n  return isGLB(arrayBuffer, byteOffset, options);\n}\n\nexport async function parseGLTF(\n  gltf: GLTFWithBuffers,\n  arrayBufferOrString,\n  byteOffset = 0,\n  options: GLTFLoaderOptions,\n  context: LoaderContext\n): Promise<GLTFWithBuffers> {\n  parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);\n\n  normalizeGLTFV1(gltf, {normalize: options?.gltf?.normalize});\n\n  preprocessExtensions(gltf, options, context);\n\n  // Load linked buffers asynchronously and decodes base64 buffers in parallel\n  if (options?.gltf?.loadBuffers && gltf.json.buffers) {\n    await loadBuffers(gltf, options, context);\n  }\n\n  // loadImages and decodeExtensions should not be running in parallel, because\n  // decodeExtensions uses data from images taken during the loadImages call.\n  if (options?.gltf?.loadImages) {\n    await loadImages(gltf, options, context);\n  }\n\n  await decodeExtensions(gltf, options, context);\n\n  return gltf;\n}\n\n/**\n *\n * @param gltf\n * @param data - can be ArrayBuffer (GLB), ArrayBuffer (Binary JSON), String (JSON), or Object (parsed JSON)\n * @param byteOffset\n * @param options\n */\nfunction parseGLTFContainerSync(gltf, data, byteOffset, options) {\n  // Initialize gltf container\n  if (options.uri) {\n    gltf.baseUri = options.uri;\n  }\n\n  // If data is binary and starting with magic bytes, assume binary JSON text, convert to string\n  if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {\n    const textDecoder = new TextDecoder();\n    data = textDecoder.decode(data);\n  }\n\n  if (typeof data === 'string') {\n    // If string, try to parse as JSON\n    gltf.json = parseJSON(data);\n  } else if (data instanceof ArrayBuffer) {\n    // If still ArrayBuffer, parse as GLB container\n    const glb: GLB = {} as GLB;\n    byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);\n\n    assert(glb.type === 'glTF', `Invalid GLB magic string ${glb.type}`);\n\n    gltf._glb = glb;\n    gltf.json = glb.json;\n  } else {\n    assert(false, 'GLTF: must be ArrayBuffer or string');\n  }\n\n  // Populate buffers\n  // Create an external buffers array to hold binary data\n  const buffers = gltf.json.buffers || [];\n  gltf.buffers = new Array(buffers.length).fill(null);\n\n  // Populates JSON and some bin chunk info\n  if (gltf._glb && gltf._glb.header.hasBinChunk) {\n    const {binChunks} = gltf._glb;\n    gltf.buffers[0] = {\n      arrayBuffer: binChunks[0].arrayBuffer,\n      byteOffset: binChunks[0].byteOffset,\n      byteLength: binChunks[0].byteLength\n    };\n\n    // TODO - this modifies JSON and is a post processing thing\n    // gltf.json.buffers[0].data = gltf.buffers[0].arrayBuffer;\n    // gltf.json.buffers[0].byteOffset = gltf.buffers[0].byteOffset;\n  }\n\n  // Populate images\n  const images = gltf.json.images || [];\n  gltf.images = new Array(images.length).fill({});\n}\n\n/** Asynchronously fetch and parse buffers, store in buffers array outside of json\n * TODO - traverse gltf and determine which buffers are actually needed\n */\nasync function loadBuffers(gltf: GLTFWithBuffers, options, context: LoaderContext) {\n  // TODO\n  const buffers = gltf.json.buffers || [];\n  for (let i = 0; i < buffers.length; ++i) {\n    const buffer = buffers[i];\n    if (buffer.uri) {\n      const {fetch} = context;\n      assert(fetch);\n\n      const uri = resolveUrl(buffer.uri, options);\n      const response = await context?.fetch?.(uri);\n      const arrayBuffer = await response?.arrayBuffer?.();\n\n      gltf.buffers[i] = {\n        arrayBuffer,\n        byteOffset: 0,\n        byteLength: arrayBuffer.byteLength\n      };\n\n      delete buffer.uri;\n    } else if (gltf.buffers[i] === null) {\n      gltf.buffers[i] = {\n        arrayBuffer: new ArrayBuffer(buffer.byteLength),\n        byteOffset: 0,\n        byteLength: buffer.byteLength\n      };\n    }\n  }\n}\n\n/**\n * Loads all images\n * TODO - traverse gltf and determine which images are actually needed\n * @param gltf\n * @param options\n * @param context\n * @returns\n */\nasync function loadImages(gltf: GLTFWithBuffers, options, context: LoaderContext) {\n  const imageIndices = getReferencesImageIndices(gltf);\n\n  const images = gltf.json.images || [];\n\n  const promises: Promise<any>[] = [];\n  for (const imageIndex of imageIndices) {\n    promises.push(loadImage(gltf, images[imageIndex], imageIndex, options, context));\n  }\n\n  return await Promise.all(promises);\n}\n\n/** Make sure we only load images that are actually referenced by textures */\nfunction getReferencesImageIndices(gltf: GLTFWithBuffers): number[] {\n  const imageIndices = new Set<number>();\n\n  const textures = gltf.json.textures || [];\n  for (const texture of textures) {\n    if (texture.source !== undefined) {\n      imageIndices.add(texture.source);\n    }\n  }\n\n  return Array.from(imageIndices).sort();\n}\n\n/** Asynchronously fetches and parses one image, store in images array outside of json */\nasync function loadImage(\n  gltf: GLTFWithBuffers,\n  image,\n  index: number,\n  options,\n  context: LoaderContext\n) {\n  let arrayBuffer;\n\n  if (image.uri && !image.hasOwnProperty('bufferView')) {\n    const uri = resolveUrl(image.uri, options);\n\n    const {fetch} = context;\n    const response = await fetch(uri);\n\n    arrayBuffer = await response.arrayBuffer();\n    image.bufferView = {\n      data: arrayBuffer\n    };\n  }\n\n  if (Number.isFinite(image.bufferView)) {\n    const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);\n    arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);\n  }\n\n  assert(arrayBuffer, 'glTF image has no data');\n\n  // Call `parse`\n  let parsedImage = (await parseFromContext(\n    arrayBuffer,\n    [ImageLoader, BasisLoader],\n    {\n      ...options,\n      mimeType: image.mimeType,\n      basis: options.basis || {format: selectSupportedBasisFormat()}\n    },\n    context\n  )) as ImageType | TextureLevel[][];\n\n  if (parsedImage && parsedImage[0]) {\n    parsedImage = {\n      compressed: true,\n      // @ts-expect-error\n      mipmaps: false,\n      width: parsedImage[0].width,\n      height: parsedImage[0].height,\n      data: parsedImage[0]\n    };\n  }\n  // TODO making sure ImageLoader is overridable by using array of loaders\n  // const parsedImage = await parse(arrayBuffer, [ImageLoader]);\n\n  // Store the loaded image\n  gltf.images = gltf.images || [];\n  // @ts-expect-error TODO - sort out image typing asap\n  gltf.images[index] = parsedImage;\n}\n"],"mappings":"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"}

package/dist/esm/lib/types/gltf-ext-feature-metadata-schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gltf-ext-feature-metadata-schema.js.map

package/dist/esm/lib/types/gltf-ext-feature-metadata-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-feature-metadata-schema.js","names":[],"sources":["../../../../src/lib/types/gltf-ext-feature-metadata-schema.ts"],"sourcesContent":["import {GLTFTextureInfo} from './gltf-json-schema';\n\n/* eslint-disable camelcase */\n\n/**\n * EXT_feature_metadata extension types\n * This extension has glTF-level metadata and primitive-level feature indexing and segmentation metadata\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata\n *\n * glTF-level metadata\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#gltf-extension-1\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata/schema/glTF.EXT_feature_metadata.schema.json\n */\nexport type GLTF_EXT_feature_metadata_GLTF = {\n  /** An object defining classes and enums. */\n  schema?: GLTF_EXT_feature_metadata_Schema;\n  /** A uri to an external schema file. */\n  schemaUri?: string;\n  /** An object containing statistics about features. */\n  statistics?: GLTF_EXT_feature_metadata_Statistics;\n  /** A dictionary, where each key is a feature table ID and each value is an object defining the feature table. */\n  featureTables?: {\n    [key: string]: GLTF_EXT_feature_metadata_FeatureTable;\n  };\n  /** A dictionary, where each key is a feature texture ID and each value is an object defining the feature texture. */\n  featureTextures?: {\n    [key: string]: GLTF_EXT_feature_metadata_FeatureTexture;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * An object defining classes and enums.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#schema\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/schema.schema.json\n */\nexport type GLTF_EXT_feature_metadata_Schema = {\n  /** The name of the schema. */\n  name?: string;\n  /** The description of the schema. */\n  description?: string;\n  /** Application-specific version of the schema. */\n  version?: string;\n  /** A dictionary, where each key is a class ID and each value is an object defining the class. */\n  classes?: {\n    [key: string]: GLTF_EXT_feature_metadata_Class;\n  };\n  /** A dictionary, where each key is an enum ID and each value is an object defining the values for the enum. */\n  enums?: {\n    [key: string]: GLTF_EXT_feature_metadata_Enum;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * A class containing a set of properties.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#class\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/class.schema.json\n */\nexport type GLTF_EXT_feature_metadata_Class = {\n  /** The name of the class, e.g. for display purposes. */\n  name?: string;\n  /** The description of the class. */\n  description?: string;\n  /** A dictionary, where each key is a property ID and each value is an object defining the property. */\n  properties: {\n    [key: string]: GLTF_EXT_feature_metadata_ClassProperty;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * A class property.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#class-property\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/class.property.schema.json\n */\nexport type GLTF_EXT_feature_metadata_ClassProperty = {\n  /** The name of the property, e.g. for display purposes. */\n  name?: string;\n  /** The description of the property. */\n  description?: string;\n  /**\n   * The property type. If ENUM is used, then enumType must also be specified.\n   * If ARRAY is used, then componentType must also be specified.\n   * ARRAY is a fixed-length array when componentCount is defined, and variable-length otherwise.\n   */\n  type:\n    | 'INT8'\n    | 'UINT8'\n    | 'INT16'\n    | 'UINT16'\n    | 'INT32'\n    | 'UINT32'\n    | 'INT64'\n    | 'UINT64'\n    | 'FLOAT32'\n    | 'FLOAT64'\n    | 'BOOLEAN'\n    | 'STRING'\n    | 'ENUM'\n    | 'ARRAY'\n    | string;\n  /**\n   * An enum ID as declared in the enums dictionary.\n   * This value must be specified when type or componentType is ENUM.\n   */\n  enumType?: string;\n  /**\n   * When type is ARRAY this indicates the type of each component of the array.\n   * If ENUM is used, then enumType must also be specified.\n   */\n  componentType?:\n    | 'INT8'\n    | 'UINT8'\n    | 'INT16'\n    | 'UINT16'\n    | 'INT32'\n    | 'UINT32'\n    | 'INT64'\n    | 'UINT64'\n    | 'FLOAT32'\n    | 'FLOAT64'\n    | 'BOOLEAN'\n    | 'STRING'\n    | 'ENUM'\n    | string;\n  /** The number of components per element for ARRAY elements. */\n  componentCount?: number;\n  /**\n   * Specifies whether integer values are normalized.\n   * This applies both when type is an integer type, or when type is ARRAY with a componentType that is an integer type.\n   * For unsigned integer types, values are normalized between [0.0, 1.0].\n   * For signed integer types, values are normalized between [-1.0, 1.0].\n   * For all other types, this property is ignored.\n   */\n  normalized: boolean;\n  /**\n   * Maximum allowed values for property values.\n   * Only applicable for numeric types and fixed-length arrays of numeric types.\n   * For numeric types this is a single number.\n   * For fixed-length arrays this is an array with componentCount number of elements.\n   * The normalized property has no effect on these values: they always correspond to the integer values.\n   */\n  max?: number | number[];\n  /**\n   * Minimum allowed values for property values.\n   * Only applicable for numeric types and fixed-length arrays of numeric types.\n   * For numeric types this is a single number.\n   * For fixed-length arrays this is an array with componentCount number of elements.\n   * The normalized property has no effect on these values: they always correspond to the integer values.\n   */\n  min?: number | number[];\n  /**\n   * A default value to use when the property value is not defined.\n   * If used, optional must be set to true.\n   * The type of the default value must match the property definition: For BOOLEAN use true or false.\n   * For STRING use a JSON string. For a numeric type use a JSON number.\n   * For ENUM use the enum name, not the integer value.\n   * For ARRAY use a JSON array containing values matching the componentType.\n   */\n  default?: boolean | number | string | number[];\n  /** If true, this property is optional. */\n  optional?: boolean; // default false;\n  /**\n   * An identifier that describes how this property should be interpreted.\n   * The semantic cannot be used by other properties in the class.\n   */\n  semantic?: string;\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * An object defining the values of an enum.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#enum\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata/schema/enum.schema.json\n */\nexport type GLTF_EXT_feature_metadata_Enum = {\n  /** The name of the enum, e.g. for display purposes. */\n  name?: string;\n  /** The description of the enum. */\n  description?: string;\n  /** The type of the integer enum value. */\n  valueType?: 'INT8' | 'UINT8' | 'INT16' | 'UINT16' | 'INT32' | 'UINT32' | 'INT64' | 'UINT64'; // default: \"UINT16\"\n  /** An array of enum values. Duplicate names or duplicate integer values are not allowed. */\n  values: GLTF_EXT_feature_metadata_EnumValue[];\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n  [key: string]: unknown;\n};\n\n/**\n * An enum value.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#enum-value\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata/schema/enum.value.schema.json\n */\nexport type GLTF_EXT_feature_metadata_EnumValue = {\n  /** The name of the enum value. */\n  name: string;\n  /** The description of the enum value. */\n  description?: string;\n  /** The integer enum value. */\n  value: number; // default: \"UINT16\"\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n  [key: string]: unknown;\n};\n\n/**\n * A feature table defined by a class and property values stored in arrays.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-table\n * JSON Schenma - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureTable.schema.json\n */\nexport type GLTF_EXT_feature_metadata_FeatureTable = {\n  /** The class that property values conform to. The value must be a class ID declared in the classes dictionary. */\n  class?: string;\n  /** The number of features, as well as the number of elements in each property array. */\n  count: number;\n  /**\n   * A dictionary, where each key corresponds to a property ID in the class properties dictionary\n   * and each value is an object describing where property values are stored.\n   * Optional properties may be excluded from this dictionary.\n   */\n  properties?: {\n    [key: string]: GLTF_EXT_feature_metadata_FeatureTableProperty;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * An array of binary property values.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-table-property\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureTable.property.schema.json\n */\nexport type GLTF_EXT_feature_metadata_FeatureTableProperty = {\n  /**\n   * The index of the buffer view containing property values.\n   * The data type of property values is determined by the property definition:\n   * When type is BOOLEAN values are packed into a bitfield.\n   * When type is STRING values are stored as byte sequences and decoded as UTF-8 strings.\n   * When type is a numeric type values are stored as the provided type.\n   * When type is ENUM values are stored as the enum's valueType.\n   * Each enum value in the buffer must match one of the allowed values in the enum definition.\n   * When type is ARRAY elements are packed tightly together and the data type is based on the componentType following the same rules as above.\n   * arrayOffsetBufferView is required for variable-size arrays\n   * and stringOffsetBufferView is required for strings (for variable-length arrays of strings, both are required)\n   * The buffer view byteOffset must be aligned to a multiple of 8 bytes.\n   * If the buffer view's buffer is the GLB-stored BIN chunk the byte offset is measured relative to the beginning of the GLB.\n   * Otherwise it is measured relative to the beginning of the buffer.\n   */\n  bufferView: number;\n\n  /** The type of values in arrayOffsetBufferView and stringOffsetBufferView. */\n  offsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string; // default: \"UINT32\"\n  /**\n   * The index of the buffer view containing offsets for variable-length arrays.\n   * The number of offsets is equal to the feature table count plus one.\n   * The offsets represent the start positions of each array, with the last offset representing the position after the last array.\n   * The array length is computed using the difference between the current offset and the subsequent offset.\n   * If componentType is STRING the offsets index into the string offsets array (stored in stringOffsetBufferView),\n   * otherwise they index into the property array (stored in bufferView).\n   * The data type of these offsets is determined by offsetType.\n   * The buffer view byteOffset must be aligned to a multiple of 8 bytes in the same manner as the main bufferView\n   */\n  arrayOffsetBufferView?: number;\n  /**\n   * The index of the buffer view containing offsets for strings.\n   * The number of offsets is equal to the number of string components plus one.\n   * The offsets represent the byte offsets of each string in the main bufferView,\n   * with the last offset representing the byte offset after the last string.\n   * The string byte length is computed using the difference between the current offset and the subsequent offset.\n   * The data type of these offsets is determined by offsetType.\n   * The buffer view byteOffset must be aligned to a multiple of 8 bytes in the same manner as the main bufferView.\n   */\n  stringOffsetBufferView?: number;\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n  /** This is not part of the spec. GLTFLoader loads feature tables data into this property */\n  data: unknown;\n};\n\n/**\n * Features whose property values are stored directly in texture channels. This is not to be confused with feature ID textures which store feature IDs for use with a feature table.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-texture\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureTexture.schema.json\n */\nexport type GLTF_EXT_feature_metadata_FeatureTexture = {\n  /** The class this feature texture conforms to. The value must be a class ID declared in the classes dictionary. */\n  class: string;\n  /**\n   * A dictionary, where each key corresponds to a property ID in the class properties dictionary\n   * and each value describes the texture channels containing property values.\n   */\n  properties: {\n    [key: string]: GLTF_EXT_feature_metadata_TextureAccessor;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * A description of how to access property values from the color channels of a texture.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#texture-accessor\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/textureAccessor.schema.json\n */\nexport type GLTF_EXT_feature_metadata_TextureAccessor = {\n  /** Texture channels containing property values. Channels are labeled by rgba and are swizzled with a string of 1-4 characters. */\n  channels: string;\n  /** The glTF texture and texture coordinates to use. */\n  texture: GLTFTextureInfo;\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n  /** This is not part of the spec. GLTFLoader loads feature tables data into this property */\n  data: unknown;\n};\n\n/**\n * Statistics about features.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#statistics-1\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/statistics.schema.json\n */\nexport type GLTF_EXT_feature_metadata_Statistics = {\n  /**\n   * A dictionary, where each key is a class ID declared in the classes dictionary\n   * and each value is an object containing statistics about features that conform to the class.\n   */\n  classes?: {\n    [key: string]: GLTF_EXT_feature_metadata_StatisticsClass;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * Statistics about features that conform to the class.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#class-statistics\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/statistics.class.property.schema.json\n */\nexport type GLTF_EXT_feature_metadata_StatisticsClass = {\n  /** The number of features that conform to the class. */\n  count?: number;\n  /**\n   * A dictionary, where each key is a class ID declared in the classes dictionary\n   * and each value is an object containing statistics about property values.\n   */\n  properties?: {\n    [key: string]: GLTF_EXT_feature_metadata_StatisticsClassProperty;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * min, max, mean, median, standardDeviation, variance, sum are\n * only applicable for numeric types and fixed-length arrays of numeric types.\n * For numeric types this is a single number.\n * For fixed-length arrays this is an array with componentCount number of elements.\n * The normalized property has no effect on these values.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#property-statistics\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/statistics.class.property.schema.json\n */\nexport type GLTF_EXT_feature_metadata_StatisticsClassProperty = {\n  /** The minimum property value. */\n  min?: number | number[];\n  /** The maximum property value. */\n  max?: number | number[];\n  /** The arithmetic mean of the property values. */\n  mean?: number | number[];\n  /** The median of the property values. */\n  median?: number | number[];\n  /** The standard deviation of the property values. */\n  standardDeviation?: number | number[];\n  /** The variance of the property values. */\n  variance?: number | number[];\n  /** The sum of the property values. */\n  sum?: number | number[];\n  /**\n   * A dictionary, where each key corresponds to an enum name and each value is the number of occurrences of that enum.\n   * Only applicable when type or componentType is ENUM.\n   * For fixed-length arrays, this is an array with componentCount number of elements.\n   */\n  occurrences: {\n    [key: string]: number | number[];\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * EXT_feature_metadata extension types\n * This extension has glTF-level metadata and primitive-level (feature indexing and segmentation) metadata\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata\n *\n * primitive-level metadata\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#primitive-extension\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/mesh.primitive.EXT_feature_metadata.schema.json\n */\nexport type GLTF_EXT_feature_metadata_Primitive = {\n  /** Feature ids definition in attributes */\n  featureIdAttributes?: GLTF_EXT_feature_metadata_FeatureIdAttribute[];\n  /** Feature ids definition in textures */\n  featureIdTextures?: GLTF_EXT_feature_metadata_FeatureIdTexture[];\n  /** An array of IDs of feature textures from the root EXT_feature_metadata object. */\n  featureTextures?: string[];\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * Attribute which described featureIds definition.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-id-attribute\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureIdAttribute.schema.json\n */\nexport type GLTF_EXT_feature_metadata_FeatureIdAttribute = {\n  /** Name of feature table */\n  featureTable: string;\n  /** Described how feature ids are defined */\n  featureIds: GLTF_EXT_feature_metadata_FeatureIdAttributeFeatureIds;\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * Defining featureIds by attributes or implicitly.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#primitive-extensionfeatureidattributes\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureIdAttribute.featureIds.schema.json\n */\nexport type GLTF_EXT_feature_metadata_FeatureIdAttributeFeatureIds = {\n  /** Name of attribute where featureIds are defined */\n  attribute?: string;\n  /** Sets a constant feature ID for each vertex. The default is 0. */\n  constant?: number;\n  /** Sets the rate at which feature IDs increment.\n   * If divisor is zero then constant is used.\n   * If divisor is greater than zero the feature ID increments once per divisor sets of vertices, starting at constant.\n   * The default is 0\n   */\n  divisor?: number;\n};\n\n/**\n * An object describing a texture used for storing per-texel feature IDs.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-id-texture\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/featureIdTexture.schema.json\n */\nexport type GLTF_EXT_feature_metadata_FeatureIdTexture = {\n  /** The ID of the feature table in the model's root `EXT_feature_metadata.featureTables` dictionary. */\n  featureTable: string;\n  /** A description of the texture and channel to use for feature IDs. The `channels` property must have a single channel. Furthermore,\n   * feature IDs must be whole numbers in the range `[0, count - 1]` (inclusive), where `count` is the total number of features\n   * in the feature table. Texel values must be read as integers. Texture filtering should be disabled when fetching feature IDs.\n   */\n  featureIds: GLTF_EXT_feature_metadata_FeatureIdTextureAccessor;\n};\n\n/**\n * A description of how to access property values from the color channels of a texture.\n * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#featureidtexturefeatureids\n * JSON Schema - https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_feature_metadata/schema/textureAccessor.schema.json\n */\nexport type GLTF_EXT_feature_metadata_FeatureIdTextureAccessor = {\n  /** gLTF textureInfo object - https://github.com/CesiumGS/glTF/blob/3d-tiles-next/specification/2.0/schema/textureInfo.schema.json */\n  texture: GLTFTextureInfo;\n  /** Must be a single channel (\"r\", \"g\", \"b\", or \"a\") */\n  channels: 'r' | 'g' | 'b' | 'a';\n};\n"],"mappings":""}

package/dist/esm/lib/types/gltf-ext-mesh-features-schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gltf-ext-mesh-features-schema.js.map

package/dist/esm/lib/types/gltf-ext-mesh-features-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-mesh-features-schema.js","names":[],"sources":["../../../../src/lib/types/gltf-ext-mesh-features-schema.ts"],"sourcesContent":["import {GLTFTextureInfoMetadata} from './gltf-json-schema';\n/* eslint-disable camelcase */\n\n/**\n * EXT_mesh_features extension types\n * This is a primitive-level extension.\n * An object describing feature IDs for a mesh primitive.\n * @see https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features\n * or https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_mesh_features/schema/mesh.primitive.EXT_mesh_features.schema.json\n */\nexport type GLTF_EXT_mesh_features = {\n  /** An array of feature ID sets. */\n  featureIds: GLTF_EXT_mesh_features_featureId[];\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * Feature IDs stored in an attribute or texture.\n * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_mesh_features/schema/featureId.schema.json\n */\nexport type GLTF_EXT_mesh_features_featureId = {\n  /** The number of unique features in the attribute or texture. */\n  featureCount: number;\n  /** A value that indicates that no feature is associated with this vertex or texel. */\n  nullFeatureId?: number;\n  /** A label assigned to this feature ID set. Labels must be alphanumeric identifiers matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`. */\n  label?: string;\n  /**\n   * An attribute containing feature IDs.\n   * When `attribute` and `texture` are omitted the feature IDs are assigned to vertices by their index.\n   * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features/schema/featureIdAttribute.schema.json\n   * An integer value used to construct a string in the format `_FEATURE_ID_<set index>` which is a reference to a key in `mesh.primitives.attributes`\n   * (e.g. a value of `0` corresponds to `_FEATURE_ID_0`).\n   */\n  attribute?: number;\n  /** A texture containing feature IDs. */\n  texture?: GLTFTextureInfoMetadata;\n  /** The index of the property table containing per-feature property values. Only applicable when using the `EXT_structural_metadata` extension. */\n  propertyTable?: number;\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n\n  /** This is not part of the spec. GLTFLoader loads feature tables data into this property */\n  data?: unknown;\n};\n"],"mappings":""}

package/dist/esm/lib/types/gltf-ext-structural-metadata-schema.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gltf-ext-structural-metadata-schema.js.map

package/dist/esm/lib/types/gltf-ext-structural-metadata-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-structural-metadata-schema.js","names":[],"sources":["../../../../src/lib/types/gltf-ext-structural-metadata-schema.ts"],"sourcesContent":["import {GLTFTextureInfoMetadata} from './gltf-json-schema';\n\n/* eslint-disable camelcase */\n\n/**\n * glTF extension that provides structural metadata about vertices, texels, and features in a glTF asset.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/glTF.EXT_structural_metadata.schema.json\n */\nexport type GLTF_EXT_structural_metadata_GLTF = {\n  /** An object defining classes and enums. */\n  schema?: GLTF_EXT_structural_metadata_Schema;\n  /** A uri to an external schema file. */\n  schemaUri?: string;\n  /** An array of property table definitions, which may be referenced by index. */\n  propertyTables?: GLTF_EXT_structural_metadata_PropertyTable[];\n  /** An array of property texture definitions, which may be referenced by index. */\n  propertyTextures?: GLTF_EXT_structural_metadata_PropertyTexture[];\n  /** \"An array of property attribute definitions, which may be referenced by index. */\n  propertyAttributes?: GLTF_EXT_structural_metadata_PropertyAttribute[];\n  /** This is not part of the spec. GLTFLoader loads names of attributes crated into this property */\n  dataAttributeNames?: string[];\n};\n\n/**\n * An object defining classes and enums.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/schema.schema.json\n */\nexport type GLTF_EXT_structural_metadata_Schema = {\n  /** Unique identifier for the schema. Schema IDs must be alphanumeric identifiers matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`. */\n  id: string;\n  /** The name of the schema. */\n  name?: string;\n  /** The description of the schema. */\n  description?: string;\n  /** Application-specific version of the schema. */\n  version?: string;\n  /** A dictionary, where each key is a class ID and each value is an object defining the class. */\n  classes?: {\n    [key: string]: GLTF_EXT_structural_metadata_Class;\n  };\n  /** A dictionary, where each key is an enum ID and each value is an object defining the values for the enum. */\n  enums?: {\n    [key: string]: GLTF_EXT_structural_metadata_Enum;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * An object defining the values of an enum.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/enum.schema.json\n */\nexport type GLTF_EXT_structural_metadata_Enum = {\n  /** The name of the enum, e.g. for display purposes. */\n  name?: string;\n  /** The description of the enum. */\n  description?: string;\n  /**\n   * The type of the integer enum value.\n   * Default value is 'UINT16'\n   */\n  valueType?: 'INT8' | 'UINT8' | 'INT16' | 'UINT16' | 'INT32' | 'UINT32' | 'INT64' | 'UINT64';\n  /** An array of enum values. Duplicate names or duplicate integer values are not allowed. */\n  values: GLTF_EXT_structural_metadata_EnumValue[];\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * An enum value.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/enum.value.schema.json\n */\nexport type GLTF_EXT_structural_metadata_EnumValue = {\n  /** The name of the enum value. */\n  name: string;\n  /** The description of the enum value. */\n  description?: string;\n  /** The integer enum value. */\n  value: number;\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * A class containing a set of properties.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/class.schema.json\n */\nexport type GLTF_EXT_structural_metadata_Class = {\n  /** The name of the class, e.g. for display purposes. */\n  name?: string;\n  /** The description of the class. */\n  description?: string;\n  /**\n   * A dictionary, where each key is a property ID and each value is an object defining the property.\n   * Property IDs must be alphanumeric identifiers matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`.\n   */\n  properties: {\n    [key: string]: GLTF_EXT_structural_metadata_ClassProperty;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * A class property.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/class.property.schema.json\n */\nexport type GLTF_EXT_structural_metadata_ClassProperty = {\n  /** The name of the property, e.g. for display purposes. */\n  name?: string;\n\n  /** The description of the property. */\n  description?: string;\n\n  /** The element type. */\n  type:\n    | 'SCALAR'\n    | 'VEC2'\n    | 'VEC3'\n    | 'VEC4'\n    | 'MAT2'\n    | 'MAT3'\n    | 'MAT4'\n    | 'BOOLEAN'\n    | 'STRING'\n    | 'ENUM'\n    | string;\n\n  /** The datatype of the element's components. Only applicable to `SCALAR`, `VECN`, and `MATN` types. */\n  componentType?:\n    | 'INT8'\n    | 'UINT8'\n    | 'INT16'\n    | 'UINT16'\n    | 'INT32'\n    | 'UINT32'\n    | 'INT64'\n    | 'UINT64'\n    | 'FLOAT32'\n    | 'FLOAT64'\n    | string;\n\n  /** Enum ID as declared in the `enums` dictionary. Required when `type` is `ENUM`. */\n  enumType?: string;\n\n  /**\n   * Whether the property is an array.\n   * When `count` is defined the property is a fixed-length array. Otherwise the property is a variable-length array.\n   */\n  array?: boolean;\n\n  /** The number of array elements. May only be defined when `array` is true. */\n  count?: number;\n\n  /**\n   * Specifies whether integer values are normalized.\n   * Only applicable to `SCALAR`, `VECN`, and `MATN` types with integer component types.\n   * For unsigned integer component types, values are normalized between `[0.0, 1.0]`.\n   * For signed integer component types, values are normalized between `[-1.0, 1.0]`.\n   * For all other component types, this property must be false.\n   */\n  normalized?: boolean;\n\n  /**\n   * An offset to apply to property values.\n   * Only applicable to `SCALAR`, `VECN`, and `MATN` types when the component type is `FLOAT32` or `FLOAT64`, or when the property is `normalized`.\n   */\n  offset?: number | number[];\n\n  /**\n   * A scale to apply to property values.\n   * Only applicable to `SCALAR`, `VECN`, and `MATN` types when the component type is `FLOAT32` or `FLOAT64`, or when the property is `normalized`.\n   */\n  scale?: number | number[];\n\n  /**\n   * Maximum allowed value for the property.\n   * Only applicable to `SCALAR`, `VECN`, and `MATN` types.\n   * This is the maximum of all property values, after the transforms based on the `normalized`, `offset`, and `scale` properties have been applied.\n   */\n  max?: number | number[];\n\n  /**\n   * Minimum allowed value for the property.\n   * Only applicable to `SCALAR`, `VECN`, and `MATN` types.\n   * This is the minimum of all property values, after the transforms based on the `normalized`, `offset`, and `scale` properties have been applied.\n   */\n  min?: number | number[];\n\n  default?: boolean | number | string | number[];\n  /**\n   * If required, the property must be present in every entity conforming to the class.\n   * If not required, individual entities may include `noData` values, or the entire property may be omitted.\n   * As a result, `noData` has no effect on a required property.\n   * Client implementations may use required properties to make performance optimizations.\n   * Default value is false.\n   */\n  required?: boolean;\n\n  /**\n   * A `noData` value represents missing data — also known as a sentinel value — wherever it appears.\n   * `BOOLEAN` properties may not specify `noData` values.\n   * This is given as the plain property value, without the transforms from the `normalized`, `offset`, and `scale` properties.\n   * Must not be defined if `required` is true.\n   */\n  noData?: number | string | number[] | string[];\n\n  /**\n   * An identifier that describes how this property should be interpreted.\n   * The semantic cannot be used by other properties in the class.\n   */\n  semantic?: string;\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * Properties conforming to a class, organized as property values stored in binary columnar arrays.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTable.schema.json\n */\nexport type GLTF_EXT_structural_metadata_PropertyTable = {\n  /** The name of the property table, e.g. for display purposes. */\n  name?: string;\n  /** The class that property values conform to. The value must be a class ID declared in the `classes` dictionary. */\n  class: string;\n  /** The number of elements in each property array. */\n  count: number;\n  /**\n   * A dictionary, where each key corresponds to a property ID in the class' `properties` dictionary\n   * and each value is an object describing where property values are stored.\n   * Required properties must be included in this dictionary.\n   */\n  properties?: {\n    [key: string]: GLTF_EXT_structural_metadata_PropertyTable_Property;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * An array of binary property values.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTable.property.schema.json\n */\nexport type GLTF_EXT_structural_metadata_PropertyTable_Property = {\n  /**\n   * The index of the buffer view containing property values.\n   * The data type of property values is determined by the property definition:\n   * When `type` is `BOOLEAN` values are packed into a bitstream.\n   * When `type` is `STRING` values are stored as byte sequences and decoded as UTF-8 strings.\n   * When `type` is `SCALAR`, `VECN`, or `MATN` the values are stored as the provided `componentType`\n   * and the buffer view `byteOffset` must be aligned to a multiple of the `componentType` size.\n   * When `type` is `ENUM` values are stored as the enum's `valueType`\n   * and the buffer view `byteOffset` must be aligned to a multiple of the `valueType` size.\n   * Each enum value in the array must match one of the allowed values in the enum definition.\n   * `arrayOffsets` is required for variable-length arrays and `stringOffsets` is required for strings (for variable-length arrays of strings, both are required).\n   */\n  values: number;\n  /**\n   * The index of the buffer view containing offsets for variable-length arrays.\n   * The number of offsets is equal to the property table `count` plus one.\n   * The offsets represent the start positions of each array, with the last offset representing the position after the last array.\n   * The array length is computed using the difference between the subsequent offset and the current offset.\n   * If `type` is `STRING` the offsets index into the string offsets array (stored in `stringOffsets`), otherwise they index into the property array (stored in `values`).\n   * The data type of these offsets is determined by `arrayOffsetType`.\n   * The buffer view `byteOffset` must be aligned to a multiple of the `arrayOffsetType` size.\n   */\n  arrayOffsets?: number;\n  /**\n   * The index of the buffer view containing offsets for strings.\n   * The number of offsets is equal to the number of string elements plus one.\n   * The offsets represent the byte offsets of each string in the property array (stored in `values`), with the last offset representing the byte offset after the last string.\n   * The string byte length is computed using the difference between the subsequent offset and the current offset.\n   * The data type of these offsets is determined by `stringOffsetType`.\n   * The buffer view `byteOffset` must be aligned to a multiple of the `stringOffsetType` size.\n   */\n  stringOffsets?: number;\n  /**\n   * The type of values in `arrayOffsets`.\n   * Default value is 'UINT32'\n   */\n  arrayOffsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string;\n\n  /**\n   * The type of values in `stringOffsets`.\n   * Default value is 'UINT32'\n   */\n  stringOffsetType?: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string;\n  /**\n   * An offset to apply to property values.\n   * Only applicable when the component type is `FLOAT32` or `FLOAT64`, or when the property is `normalized`.\n   * Overrides the class property's `offset` if both are defined.\n   */\n  offset?: number | number[];\n  /**\n   * A scale to apply to property values.\n   * Only applicable when the component type is `FLOAT32` or `FLOAT64`, or when the property is `normalized`.\n   * Overrides the class property's `scale` if both are defined.\n   */\n  scale?: number | number[];\n  /**\n   * Maximum value present in the property values.\n   * Only applicable to `SCALAR`, `VECN`, and `MATN` types.\n   * This is the maximum of all property values, after the transforms based on the `normalized`, `offset`, and `scale` properties have been applied.\n   */\n  max?: number | number[];\n  /**\n   * Minimum value present in the property values.\n   * Only applicable to `SCALAR`, `VECN`, and `MATN` types.\n   * This is the minimum of all property values, after the transforms based on the `normalized`, `offset`, and `scale` properties have been applied.\n   */\n  min?: number | number[];\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n  /** This is not part of the spec. GLTFLoader loads feature tables data into this property */\n  data?: unknown;\n};\n\n/**\n * Properties conforming to a class, organized as property values stored in textures.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTexture.schema.json\n */\nexport type GLTF_EXT_structural_metadata_PropertyTexture = {\n  /** The name of the property texture, e.g. for display purposes. */\n  name?: string;\n  /** The class that property values conform to. The value must be a class ID declared in the `classes` dictionary. */\n  class: string;\n  /**\n   * A dictionary, where each key corresponds to a property ID in the class' `properties` dictionary\n   * and each value is an object describing where property values are stored.\n   * Required properties must be included in this dictionary.\n   *\n   * https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata\n   * Each property that is defined in the propertyTexture object extends the glTF textureInfo object.\n   * The texCoord specifies a texture coordinate set in the referring primitive.\n   * The index is the index of the glTF texture object that stores the actual data. Additionally,\n   * each property specifies an array of channels, which are the indices of the texture channels providing data for the respective property.\n   * Channels of an RGBA texture are numbered 0..3 respectively.\n   */\n  properties?: {\n    [key: string]: GLTFTextureInfoMetadata;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * Properties conforming to a class, organized as property values stored in attributes.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyAttribute.schema.json\n */\nexport type GLTF_EXT_structural_metadata_PropertyAttribute = {\n  /** The name of the property attribute, e.g. for display purposes. */\n  name?: string;\n  /** The class that property values conform to. The value must be a class ID declared in the `classes` dictionary. */\n  class: string;\n  /**\n   * \"A dictionary, where each key corresponds to a property ID in the class' `properties` dictionary\n   * and each value is an object describing where property values are stored.\n   * Required properties must be included in this dictionary.\n   */\n  properties?: {\n    [key: string]: unknown;\n  };\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n\n/**\n * Structural metadata about a glTF primitive.\n * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/mesh.primitive.EXT_structural_metadata.schema.json\n */\nexport type GLTF_EXT_structural_metadata_Primitive = {\n  /** An array of indexes of property textures in the root `EXT_structural_metadata` object. */\n  propertyTextures?: number[];\n  /** An array of indexes of property attributes in the root `EXT_structural_metadata` object. */\n  propertyAttributes?: number[];\n  extensions?: Record<string, unknown>;\n  extras?: unknown;\n};\n"],"mappings":""}