@loaders.gl/gltf 4.0.0-beta.1 → 4.0.0-beta.3

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

@@ -1 +1 @@
-{"version":3,"file":"3d-tiles-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/utils/3d-tiles-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAC,uBAAuB,EAAE,iBAAiB,EAAC,MAAM,8BAA8B,CAAC;AAC7F,OAAO,KAAK,EAAC,aAAa,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAGlE,OAAO,EAAC,cAAc,EAAC,MAAM,2BAA2B,CAAC;AAKzD,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,OAAO,GACP,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,SAAS,GACT,SAAS,CAAC;AAyCd,wBAAgB,uBAAuB,CAAC,aAAa,KAAA,EAAE,aAAa,KAAA,GAAG,MAAM,CAK5E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,cAAc,EAC1B,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,EAC7D,gBAAgB,EAAE,MAAM,GACvB,UAAU,GAAG,IAAI,CAsBnB;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,UAAU,EAChB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,oBAAoB,EACnC,YAAY,GAAE,MAAU,GACvB,aAAa,CAcf;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,cAAc,EAC1B,WAAW,EAAE,uBAAuB,EACpC,SAAS,EAAE,iBAAiB,GAC3B,MAAM,EAAE,GAAG,IAAI,CAiDjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EAAE,EACtB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,iBAAiB,GAC3B,IAAI,CAkCN;AAkFD;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,aAAa,EACzB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,UAAU,EACxB,qBAAqB,EAAE,MAAM,EAC7B,SAAS,EAAE,MAAM,GAChB,aAAa,EAAE,CAajB;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,aAAa,EACzB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,GACjB,aAAa,EAAE,CAOjB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,gBAAgB,EAAE,MAAM,EACxB,eAAe,EAAE,UAAU,EAC3B,YAAY,EAAE,UAAU,GAAG,IAAI,EAC/B,aAAa,EAAE,UAAU,GAAG,IAAI,GAC/B,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CA0BvB"}
+{"version":3,"file":"3d-tiles-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/utils/3d-tiles-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAC,uBAAuB,EAAE,iBAAiB,EAAC,MAAM,8BAA8B,CAAC;AAC7F,OAAO,KAAK,EAAC,aAAa,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAGlE,OAAO,EAAC,cAAc,EAAC,MAAM,2BAA2B,CAAC;AAKzD,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,OAAO,GACP,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,SAAS,GACT,SAAS,CAAC;AAyCd,wBAAgB,uBAAuB,CAAC,aAAa,KAAA,EAAE,aAAa,KAAA,GAAG,MAAM,CAK5E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,cAAc,EAC1B,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,EAC7D,gBAAgB,EAAE,MAAM,GACvB,UAAU,GAAG,IAAI,CAsBnB;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,UAAU,EAChB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,oBAAoB,EACnC,YAAY,GAAE,MAAU,GACvB,aAAa,CAcf;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,cAAc,EAC1B,WAAW,EAAE,uBAAuB,EACpC,SAAS,EAAE,iBAAiB,GAC3B,MAAM,EAAE,CA6CV;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,cAAc,EAC1B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EAAE,EACtB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,iBAAiB,GAC3B,IAAI,CAkCN;AAsFD;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,aAAa,EACzB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,UAAU,EACxB,qBAAqB,EAAE,MAAM,EAC7B,SAAS,EAAE,MAAM,GAChB,aAAa,EAAE,CAajB;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,aAAa,EACzB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,GACjB,aAAa,EAAE,CAOjB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,gBAAgB,EAAE,MAAM,EACxB,eAAe,EAAE,UAAU,EAC3B,YAAY,EAAE,UAAU,GAAG,IAAI,EAC/B,aAAa,EAAE,UAAU,GAAG,IAAI,GAC/B,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CA0BvB"}

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

@@ -1,4 +1,4 @@
-import { getComponentTypeFromArray, getFloat32ArrayForAccessor } from '../../gltf-utils/gltf-utils';
+import { getComponentTypeFromArray } from "../../gltf-utils/gltf-utils.js";
 import { getImageData } from '@loaders.gl/images';
 import { emod } from '@loaders.gl/math';
 const ATTRIBUTE_TYPE_TO_COMPONENTS = {
@@ -69,13 +69,10 @@ export function convertRawBufferToMetadataArray(data, attributeType, componentTy
 }
 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 texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
   const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-  const textureCoordinates = getFloat32ArrayForAccessor(scenegraph.gltf, texCoordAccessorIndex);
-  if (!textureCoordinates) {
-    return null;
-  }
+  const textureCoordinates = scenegraph.getTypedArrayForAccessor(texCoordAccessorIndex);
+  const json = scenegraph.gltf.json;
   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') {
@@ -91,7 +88,7 @@ export function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
       return textureData;
     }
   }
-  return null;
+  return [];
 }
 export function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
   if (!(propertyData !== null && propertyData !== void 0 && propertyData.length)) {
@@ -150,7 +147,7 @@ function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, i
     const imageOffset = offset + map.offset;
     const imageData = getImageData(parsedImage);
     if (imageData.data.length <= imageOffset) {
-      throw new Error("".concat(imageData.data.length, " <= ").concat(imageOffset));
+      throw new Error(`${imageData.data.length} <= ${imageOffset}`);
     }
     const imageValue = imageData.data[imageOffset];
     value |= imageValue << map.shift;

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

@@ -0,0 +1 @@
+{"version":3,"file":"3d-tiles-utils.js","names":["getComponentTypeFromArray","getImageData","emod","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","BOOLEAN","STRING","ENUM","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","INT8","Int8Array","UINT8","Uint8Array","INT16","Int16Array","UINT16","Uint16Array","INT32","Int32Array","UINT32","Uint32Array","INT64","BigInt64Array","UINT64","BigUint64Array","FLOAT32","Float32Array","FLOAT64","Float64Array","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","getArrayElementByteSize","attributeType","componentType","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","texCoordAccessorKey","texCoord","texCoordAccessorIndex","attributes","textureCoordinates","getTypedArrayForAccessor","json","gltf","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} 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[] {\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 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.\n    These coordinates are being used to get data from the image.\n    \n    Default for texture.texCoord is 0\n    @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/specification/2.0/schema/textureInfo.schema.json\n  */\n  const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;\n  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];\n  const textureCoordinates: TypedArray = scenegraph.getTypedArrayForAccessor(texCoordAccessorIndex);\n\n  const json = scenegraph.gltf.json;\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 [];\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.\n *  Channels of an RGBA texture are numbered 0..3 respectively.\n *  For Ext_mesh_features and EXT_strucural_metadata the channels default is [0]\n *  @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features/schema/featureIdTexture.schema.json\n *  @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTexture.property.schema.json\n * @returns Value taken from the image.\n */\nfunction getImageValueByCoordinates(\n  parsedImage: ImageType,\n  mimeType: string | undefined,\n  textureCoordinates: TypedArray,\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/lib/gltf-utils/get-typed-array.d.ts

@@ -1,3 +1,13 @@
+import type { TypedArray } from '@loaders.gl/schema';
+import type { GLTF, GLTFExternalBuffer, GLTFAccessor } from '../types/gltf-types';
 export declare function getTypedArrayForBufferView(json: any, buffers: any, bufferViewIndex: any): Uint8Array;
 export declare function getTypedArrayForImageData(json: any, buffers: any, imageIndex: any): Uint8Array;
+/**
+ * Gets data pointed by the accessor.
+ * @param json - json part of gltf content of a GLTF tile.
+ * @param buffers - Array containing buffers of data.
+ * @param accessor - accepts accessor index or accessor object.
+ * @returns {TypedArray} Typed array with type matching the type of data poited by the accessor.
+ */
+export declare function getTypedArrayForAccessor(json: GLTF, buffers: GLTFExternalBuffer[], accessor: GLTFAccessor | number): TypedArray;
 //# sourceMappingURL=get-typed-array.d.ts.map

package/dist/lib/gltf-utils/get-typed-array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-typed-array.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/get-typed-array.ts"],"names":[],"mappings":"AAKA,wBAAgB,0BAA0B,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,eAAe,KAAA,cAWxE;AAID,wBAAgB,yBAAyB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,UAAU,KAAA,cAIlE"}
+{"version":3,"file":"get-typed-array.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/get-typed-array.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAC,IAAI,EAAE,kBAAkB,EAAE,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAKhF,wBAAgB,0BAA0B,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,eAAe,KAAA,cAWxE;AAID,wBAAgB,yBAAyB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,UAAU,KAAA,cAIlE;AAED;;;;;;GAMG;AAEH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,kBAAkB,EAAE,EAC7B,QAAQ,EAAE,YAAY,GAAG,MAAM,GAC9B,UAAU,CAsCZ"}

package/dist/lib/gltf-utils/get-typed-array.js

@@ -0,0 +1,51 @@
+import { assert } from "../utils/assert.js";
+import { getAccessorArrayTypeAndLength } from "./gltf-utils.js";
+export function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
+  const bufferView = json.bufferViews[bufferViewIndex];
+  assert(bufferView);
+  const bufferIndex = bufferView.buffer;
+  const binChunk = buffers[bufferIndex];
+  assert(binChunk);
+  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+}
+export function getTypedArrayForImageData(json, buffers, imageIndex) {
+  const image = json.images[imageIndex];
+  const bufferViewIndex = json.bufferViews[image.bufferView];
+  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
+}
+export function getTypedArrayForAccessor(json, buffers, accessor) {
+  var _json$accessors, _json$bufferViews;
+  const gltfAccessor = typeof accessor === 'number' ? (_json$accessors = json.accessors) === null || _json$accessors === void 0 ? void 0 : _json$accessors[accessor] : accessor;
+  if (!gltfAccessor) {
+    throw new Error(`No gltf accessor ${accessor}`);
+  }
+  const bufferView = (_json$bufferViews = json.bufferViews) === null || _json$bufferViews === void 0 ? void 0 : _json$bufferViews[gltfAccessor.bufferView || 0];
+  if (!bufferView) {
+    throw new Error(`No gltf buffer view for accessor ${bufferView}`);
+  }
+  const {
+    arrayBuffer,
+    byteOffset: bufferByteOffset
+  } = buffers[bufferView.buffer];
+  const byteOffset = (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+  const {
+    ArrayType,
+    length,
+    componentByteSize,
+    numberOfComponentsInElement
+  } = getAccessorArrayTypeAndLength(gltfAccessor, bufferView);
+  const elementByteSize = componentByteSize * numberOfComponentsInElement;
+  const elementAddressScale = bufferView.byteStride || elementByteSize;
+  if (typeof bufferView.byteStride === 'undefined' || bufferView.byteStride === elementByteSize) {
+    const result = new ArrayType(arrayBuffer, byteOffset, length);
+    return result;
+  }
+  const result = new ArrayType(length);
+  for (let i = 0; i < gltfAccessor.count; i++) {
+    const values = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, numberOfComponentsInElement);
+    result.set(values, i * numberOfComponentsInElement);
+  }
+  return result;
+}
+//# sourceMappingURL=get-typed-array.js.map

package/dist/lib/gltf-utils/get-typed-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-typed-array.js","names":["assert","getAccessorArrayTypeAndLength","getTypedArrayForBufferView","json","buffers","bufferViewIndex","bufferView","bufferViews","bufferIndex","buffer","binChunk","byteOffset","Uint8Array","arrayBuffer","byteLength","getTypedArrayForImageData","imageIndex","image","images","getTypedArrayForAccessor","accessor","_json$accessors","_json$bufferViews","gltfAccessor","accessors","Error","bufferByteOffset","ArrayType","length","componentByteSize","numberOfComponentsInElement","elementByteSize","elementAddressScale","byteStride","result","i","count","values","set"],"sources":["../../../src/lib/gltf-utils/get-typed-array.ts"],"sourcesContent":["// TODO - GLTFScenegraph should use these\nimport {assert} from '../utils/assert';\nimport type {TypedArray} from '@loaders.gl/schema';\nimport type {GLTF, GLTFExternalBuffer, GLTFAccessor} from '../types/gltf-types';\nimport {getAccessorArrayTypeAndLength} from './gltf-utils';\n\n// accepts buffer view index or buffer view object\n// returns a `Uint8Array`\nexport function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {\n  const bufferView = json.bufferViews[bufferViewIndex];\n  assert(bufferView);\n\n  // Get hold of the arrayBuffer\n  const bufferIndex = bufferView.buffer;\n  const binChunk = buffers[bufferIndex];\n  assert(binChunk);\n\n  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;\n  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);\n}\n\n// accepts accessor index or accessor object\n// returns a `Uint8Array`\nexport function getTypedArrayForImageData(json, buffers, imageIndex) {\n  const image = json.images[imageIndex];\n  const bufferViewIndex = json.bufferViews[image.bufferView];\n  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);\n}\n\n/**\n * Gets data pointed by the accessor.\n * @param json - json part of gltf content of a GLTF tile.\n * @param buffers - Array containing buffers of data.\n * @param accessor - accepts accessor index or accessor object.\n * @returns {TypedArray} Typed array with type matching the type of data poited by the accessor.\n */\n// eslint-disable-next-line complexity\nexport function getTypedArrayForAccessor(\n  json: GLTF,\n  buffers: GLTFExternalBuffer[],\n  accessor: GLTFAccessor | number\n): TypedArray {\n  const gltfAccessor = typeof accessor === 'number' ? json.accessors?.[accessor] : accessor;\n  if (!gltfAccessor) {\n    throw new Error(`No gltf accessor ${accessor}`);\n  }\n  const bufferView = json.bufferViews?.[gltfAccessor.bufferView || 0];\n  if (!bufferView) {\n    throw new Error(`No gltf buffer view for accessor ${bufferView}`);\n  }\n  // Get `arrayBuffer` the `bufferView` looks at\n  const {arrayBuffer, byteOffset: bufferByteOffset} = buffers[bufferView.buffer];\n  // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets\n  const byteOffset =\n    (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);\n  // Deduce TypedArray type and its length from `accessor` and `bufferView` data\n  const {ArrayType, length, componentByteSize, numberOfComponentsInElement} =\n    getAccessorArrayTypeAndLength(gltfAccessor, bufferView);\n  // 'length' is a whole number of components of all elements in the buffer pointed by the accessor\n  // Multiplier to calculate the address of the element in the arrayBuffer\n  const elementByteSize = componentByteSize * numberOfComponentsInElement;\n  const elementAddressScale = bufferView.byteStride || elementByteSize;\n  // Creare an array of component's type where all components (not just elements) will reside\n  if (typeof bufferView.byteStride === 'undefined' || bufferView.byteStride === elementByteSize) {\n    // No iterleaving\n    const result: TypedArray = new ArrayType(arrayBuffer, byteOffset, length);\n    return result;\n  }\n  // Iterleaving\n  const result: TypedArray = new ArrayType(length);\n  for (let i = 0; i < gltfAccessor.count; i++) {\n    const values = new ArrayType(\n      arrayBuffer,\n      byteOffset + i * elementAddressScale,\n      numberOfComponentsInElement\n    );\n    result.set(values, i * numberOfComponentsInElement);\n  }\n  return result;\n}\n"],"mappings":"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"}

package/dist/{esm/lib → lib}/gltf-utils/gltf-attribute-utils.js

@@ -1,4 +1,4 @@
-import { getAccessorTypeFromSize, getComponentTypeFromArray } from './gltf-utils';
+import { getAccessorTypeFromSize, getComponentTypeFromArray } from "./gltf-utils.js";
 export function getGLTFAccessors(attributes) {
   const accessors = {};
   for (const name in attributes) {

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

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-attribute-utils.js","names":["getAccessorTypeFromSize","getComponentTypeFromArray","getGLTFAccessors","attributes","accessors","name","attribute","glTFAccessor","getGLTFAccessor","buffer","size","count","getAccessorData","value","byteOffset","type","componentType","ArrayBuffer","isView","toTypedArray","Float32Array","length","array","ArrayType","convertTypedArrays","arguments","undefined","Array","isArray"],"sources":["../../../src/lib/gltf-utils/gltf-attribute-utils.ts"],"sourcesContent":["// import type {TypedArray} from '../types/loader-utils';\nimport type {GLTFAccessor} from '../types/gltf-json-schema';\n// TODO - remove\nimport {getAccessorTypeFromSize, getComponentTypeFromArray} from './gltf-utils';\n\n// Returns a fresh attributes object with glTF-standardized attributes names\n// Attributes that cannot be identified will not be included\n// Removes `indices` if present, as it should be stored separately from the attributes\nexport function getGLTFAccessors(attributes): {[key: string]: GLTFAccessor} {\n  const accessors = {};\n  for (const name in attributes) {\n    const attribute = attributes[name];\n    if (name !== 'indices') {\n      const glTFAccessor = getGLTFAccessor(attribute);\n      accessors[name] = glTFAccessor;\n    }\n  }\n  return accessors;\n}\n\n// Fix up a single accessor.\n// Input: typed array or a partial accessor object\n// Return: accessor object\nexport function getGLTFAccessor(attribute) {\n  const {buffer, size, count} = getAccessorData(attribute);\n\n  const glTFAccessor: GLTFAccessor = {\n    // glTF Accessor values\n    // TODO: Instead of a bufferView index we could have an actual buffer (typed array)\n    // bufferView: null,\n    // TODO: Deprecate `value` in favor of bufferView?\n    // @ts-ignore\n    value: buffer,\n    size, // Decoded `type` (e.g. SCALAR)\n\n    byteOffset: 0,\n    count,\n    type: getAccessorTypeFromSize(size),\n    componentType: getComponentTypeFromArray(buffer)\n  };\n\n  return glTFAccessor;\n}\n\n// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {\n//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];\n// }\n\nfunction getAccessorData(attribute) {\n  let buffer = attribute;\n  let size = 1;\n  let count = 0;\n\n  if (attribute && attribute.value) {\n    buffer = attribute.value;\n    size = attribute.size || 1;\n  }\n\n  if (buffer) {\n    if (!ArrayBuffer.isView(buffer)) {\n      buffer = toTypedArray(buffer, Float32Array);\n    }\n    count = buffer.length / size;\n  }\n\n  return {buffer, size, count};\n}\n\n// Convert non-typed arrays to arrays of specified format\nfunction toTypedArray(array, ArrayType, convertTypedArrays = false) {\n  if (!array) {\n    return null;\n  }\n  if (Array.isArray(array)) {\n    return new ArrayType(array);\n  }\n  if (convertTypedArrays && !(array instanceof ArrayType)) {\n    return new ArrayType(array);\n  }\n  return array;\n}\n"],"mappings":"SAGQA,uBAAuB,EAAEC,yBAAyB;AAK1D,OAAO,SAASC,gBAAgBA,CAACC,UAAU,EAAiC;EAC1E,MAAMC,SAAS,GAAG,CAAC,CAAC;EACpB,KAAK,MAAMC,IAAI,IAAIF,UAAU,EAAE;IAC7B,MAAMG,SAAS,GAAGH,UAAU,CAACE,IAAI,CAAC;IAClC,IAAIA,IAAI,KAAK,SAAS,EAAE;MACtB,MAAME,YAAY,GAAGC,eAAe,CAACF,SAAS,CAAC;MAC/CF,SAAS,CAACC,IAAI,CAAC,GAAGE,YAAY;IAChC;EACF;EACA,OAAOH,SAAS;AAClB;AAKA,OAAO,SAASI,eAAeA,CAACF,SAAS,EAAE;EACzC,MAAM;IAACG,MAAM;IAAEC,IAAI;IAAEC;EAAK,CAAC,GAAGC,eAAe,CAACN,SAAS,CAAC;EAExD,MAAMC,YAA0B,GAAG;IAMjCM,KAAK,EAAEJ,MAAM;IACbC,IAAI;IAEJI,UAAU,EAAE,CAAC;IACbH,KAAK;IACLI,IAAI,EAAEf,uBAAuB,CAACU,IAAI,CAAC;IACnCM,aAAa,EAAEf,yBAAyB,CAACQ,MAAM;EACjD,CAAC;EAED,OAAOF,YAAY;AACrB;AAMA,SAASK,eAAeA,CAACN,SAAS,EAAE;EAClC,IAAIG,MAAM,GAAGH,SAAS;EACtB,IAAII,IAAI,GAAG,CAAC;EACZ,IAAIC,KAAK,GAAG,CAAC;EAEb,IAAIL,SAAS,IAAIA,SAAS,CAACO,KAAK,EAAE;IAChCJ,MAAM,GAAGH,SAAS,CAACO,KAAK;IACxBH,IAAI,GAAGJ,SAAS,CAACI,IAAI,IAAI,CAAC;EAC5B;EAEA,IAAID,MAAM,EAAE;IACV,IAAI,CAACQ,WAAW,CAACC,MAAM,CAACT,MAAM,CAAC,EAAE;MAC/BA,MAAM,GAAGU,YAAY,CAACV,MAAM,EAAEW,YAAY,CAAC;IAC7C;IACAT,KAAK,GAAGF,MAAM,CAACY,MAAM,GAAGX,IAAI;EAC9B;EAEA,OAAO;IAACD,MAAM;IAAEC,IAAI;IAAEC;EAAK,CAAC;AAC9B;AAGA,SAASQ,YAAYA,CAACG,KAAK,EAAEC,SAAS,EAA8B;EAAA,IAA5BC,kBAAkB,GAAAC,SAAA,CAAAJ,MAAA,QAAAI,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,KAAK;EAChE,IAAI,CAACH,KAAK,EAAE;IACV,OAAO,IAAI;EACb;EACA,IAAIK,KAAK,CAACC,OAAO,CAACN,KAAK,CAAC,EAAE;IACxB,OAAO,IAAIC,SAAS,CAACD,KAAK,CAAC;EAC7B;EACA,IAAIE,kBAAkB,IAAI,EAAEF,KAAK,YAAYC,SAAS,CAAC,EAAE;IACvD,OAAO,IAAIA,SAAS,CAACD,KAAK,CAAC;EAC7B;EACA,OAAOA,KAAK;AACd"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-constants.js","names":["COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","BYTES","getBytesFromComponentType","componentType","getSizeFromAccessorType","type","getGLEnumFromSamplerParameter","parameter","GL_TEXTURE_MAG_FILTER","GL_TEXTURE_MIN_FILTER","GL_TEXTURE_WRAP_S","GL_TEXTURE_WRAP_T","PARAMETER_MAP","magFilter","minFilter","wrapS","wrapT"],"sources":["../../../src/lib/gltf-utils/gltf-constants.ts"],"sourcesContent":["export const COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nexport const BYTES = {\n  5120: 1, // BYTE\n  5121: 1, // UNSIGNED_BYTE\n  5122: 2, // SHORT\n  5123: 2, // UNSIGNED_SHORT\n  5125: 4, // UNSIGNED_INT\n  5126: 4 // FLOAT\n};\n\n// ENUM LOOKUP\n\nexport function getBytesFromComponentType(componentType) {\n  return BYTES[componentType];\n}\n\nexport function getSizeFromAccessorType(type) {\n  return COMPONENTS[type];\n}\n\nexport function getGLEnumFromSamplerParameter(parameter) {\n  const GL_TEXTURE_MAG_FILTER = 0x2800;\n  const GL_TEXTURE_MIN_FILTER = 0x2801;\n  const GL_TEXTURE_WRAP_S = 0x2802;\n  const GL_TEXTURE_WRAP_T = 0x2803;\n\n  const PARAMETER_MAP = {\n    magFilter: GL_TEXTURE_MAG_FILTER,\n    minFilter: GL_TEXTURE_MIN_FILTER,\n    wrapS: GL_TEXTURE_WRAP_S,\n    wrapT: GL_TEXTURE_WRAP_T\n  };\n\n  return PARAMETER_MAP[parameter];\n}\n"],"mappings":"AAAA,OAAO,MAAMA,UAAU,GAAG;EACxBC,MAAM,EAAE,CAAC;EACTC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE;AACR,CAAC;AAED,OAAO,MAAMC,KAAK,GAAG;EACnB,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE;AACR,CAAC;AAID,OAAO,SAASC,yBAAyBA,CAACC,aAAa,EAAE;EACvD,OAAOF,KAAK,CAACE,aAAa,CAAC;AAC7B;AAEA,OAAO,SAASC,uBAAuBA,CAACC,IAAI,EAAE;EAC5C,OAAOZ,UAAU,CAACY,IAAI,CAAC;AACzB;AAEA,OAAO,SAASC,6BAA6BA,CAACC,SAAS,EAAE;EACvD,MAAMC,qBAAqB,GAAG,MAAM;EACpC,MAAMC,qBAAqB,GAAG,MAAM;EACpC,MAAMC,iBAAiB,GAAG,MAAM;EAChC,MAAMC,iBAAiB,GAAG,MAAM;EAEhC,MAAMC,aAAa,GAAG;IACpBC,SAAS,EAAEL,qBAAqB;IAChCM,SAAS,EAAEL,qBAAqB;IAChCM,KAAK,EAAEL,iBAAiB;IACxBM,KAAK,EAAEL;EACT,CAAC;EAED,OAAOC,aAAa,CAACL,SAAS,CAAC;AACjC"}

package/dist/lib/gltf-utils/gltf-utils.d.ts

@@ -1,4 +1,3 @@
-import type { GLTFWithBuffers } from '../types/gltf-types';
 import type { GLTFPostprocessed } from '../types/gltf-postprocessed-schema';
 export declare function getAccessorTypeFromSize(size: any): string;
 export declare function getComponentTypeFromArray(typedArray: any): number;
@@ -6,8 +5,9 @@ export declare function getAccessorArrayTypeAndLength(accessor: any, bufferView:
     ArrayType: any;
     length: number;
     byteLength: number;
+    componentByteSize: any;
+    numberOfComponentsInElement: any;
 };
-export declare function getFloat32ArrayForAccessor(gltfData: GLTFWithBuffers, texCoordAccessor: number): Float32Array | null;
 /**
  * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory
  * @param gltf - the gltf content of a GLTF tile

package/dist/lib/gltf-utils/gltf-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oCAAoC,CAAC;AAgE1E,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;EAQjE;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,eAAe,EACzB,gBAAgB,EAAE,MAAM,GACvB,YAAY,GAAG,IAAI,CA8BrB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAiBlE"}
+{"version":3,"file":"gltf-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oCAAoC,CAAC;AA8D1E,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,UAG3C;AAED,wBAAgB,yBAAyB,CAAC,UAAU,KAAA,UAMnD;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,KAAA,EAAE,UAAU,KAAA;;;;;;EAUjE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAiBlE"}

package/dist/{esm/lib → lib}/gltf-utils/gltf-utils.js

@@ -1,5 +1,5 @@
-import { assert } from '../utils/assert';
-import { BYTES, COMPONENTS } from '../gltf-utils/gltf-constants';
+import { assert } from "../utils/assert.js";
+import { BYTES, COMPONENTS } from "../gltf-utils/gltf-constants.js";
 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]];
@@ -47,41 +47,16 @@ export function getAccessorArrayTypeAndLength(accessor, bufferView) {
   const length = accessor.count * components;
   const byteLength = accessor.count * components * bytesPerComponent;
   assert(byteLength >= 0 && byteLength <= bufferView.byteLength);
+  const componentByteSize = BYTES[accessor.componentType];
+  const numberOfComponentsInElement = COMPONENTS[accessor.type];
   return {
     ArrayType,
     length,
-    byteLength
+    byteLength,
+    componentByteSize,
+    numberOfComponentsInElement
   };
 }
-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/lib/gltf-utils/gltf-utils.js.map

@@ -0,0 +1 @@
+{"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","componentByteSize","numberOfComponentsInElement","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';\n\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  | 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  const componentByteSize = BYTES[accessor.componentType];\n  const numberOfComponentsInElement = COMPONENTS[accessor.type];\n  return {ArrayType, length, byteLength, componentByteSize, numberOfComponentsInElement};\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 → lib}/gltf-utils/resolve-url.js

@@ -5,7 +5,7 @@ export function resolveUrl(url, options) {
   }
   const baseUrl = options.baseUri || options.uri;
   if (!baseUrl) {
-    throw new Error("'baseUri' must be provided to resolve relative url ".concat(url));
+    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
   }
   return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
 }

package/dist/lib/gltf-utils/resolve-url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-url.js","names":["resolveUrl","url","options","absolute","startsWith","baseUrl","baseUri","uri","Error","substr","lastIndexOf"],"sources":["../../../src/lib/gltf-utils/resolve-url.ts"],"sourcesContent":["// Resolves a relative url against a baseUrl\n// If url is absolute, return it unchanged\nexport function resolveUrl(url, options) {\n  // TODO: Use better logic to handle all protocols plus not delay on data\n  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');\n  if (absolute) {\n    return url;\n  }\n  const baseUrl = options.baseUri || options.uri;\n  if (!baseUrl) {\n    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);\n  }\n  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;\n}\n"],"mappings":"AAEA,OAAO,SAASA,UAAUA,CAACC,GAAG,EAAEC,OAAO,EAAE;EAEvC,MAAMC,QAAQ,GAAGF,GAAG,CAACG,UAAU,CAAC,OAAO,CAAC,IAAIH,GAAG,CAACG,UAAU,CAAC,OAAO,CAAC,IAAIH,GAAG,CAACG,UAAU,CAAC,QAAQ,CAAC;EAC/F,IAAID,QAAQ,EAAE;IACZ,OAAOF,GAAG;EACZ;EACA,MAAMI,OAAO,GAAGH,OAAO,CAACI,OAAO,IAAIJ,OAAO,CAACK,GAAG;EAC9C,IAAI,CAACF,OAAO,EAAE;IACZ,MAAM,IAAIG,KAAK,CAAE,sDAAqDP,GAAI,EAAC,CAAC;EAC9E;EACA,OAAOI,OAAO,CAACI,MAAM,CAAC,CAAC,EAAEJ,OAAO,CAACK,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGT,GAAG;AAC9D"}

package/dist/{esm/lib → lib}/parsers/parse-glb.js

@@ -10,7 +10,11 @@ const GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
 const GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
 function getMagicString(dataView) {
   let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  return "".concat(String.fromCharCode(dataView.getUint8(byteOffset + 0))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 1))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 2))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 3)));
+  return `\
+${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\
+${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
 }
 export function isGLB(arrayBuffer) {
   let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
@@ -47,7 +51,7 @@ export function parseGLBSync(glb, arrayBuffer) {
     case 2:
       return parseGLBV2(glb, dataView, byteOffset, options = {});
     default:
-      throw new Error("Invalid GLB version ".concat(glb.version, ". Only supports version 1 and 2."));
+      throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);
   }
 }
 function parseGLBV1(glb, dataView, byteOffset) {

package/dist/lib/parsers/parse-glb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-glb.js","names":["padToNBytes","assert","LITTLE_ENDIAN","MAGIC_glTF","GLB_FILE_HEADER_SIZE","GLB_CHUNK_HEADER_SIZE","GLB_CHUNK_TYPE_JSON","GLB_CHUNK_TYPE_BIN","GLB_V1_CONTENT_FORMAT_JSON","GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED","GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED","getMagicString","dataView","byteOffset","arguments","length","undefined","String","fromCharCode","getUint8","isGLB","arrayBuffer","options","DataView","magic","magic1","getUint32","parseGLBSync","glb","type","version","byteLength","Object","assign","header","hasBinChunk","json","binChunks","parseGLBV1","parseGLBV2","Error","contentLength","contentFormat","parseJSONChunk","parseBINChunk","parseGLBChunksSync","chunkLength","chunkFormat","strict","jsonChunk","Uint8Array","buffer","textDecoder","TextDecoder","jsonText","decode","JSON","parse","push"],"sources":["../../../src/lib/parsers/parse-glb.ts"],"sourcesContent":["/* eslint-disable camelcase, max-statements */\n// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#glb-file-format-specification\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/1.0/Khronos/KHR_binary_glTF\nimport type {GLB} from '../types/glb-types';\nimport {padToNBytes, assert} from '@loaders.gl/loader-utils';\n\n/** Options for parsing a GLB */\nexport type ParseGLBOptions = {\n  /** @deprecated This option was used by XVIZ protocol to define a non-standard magic number */\n  magic?: number;\n  /** @deprecated This option was used by XVIZ protocol to embed non-standard chunks */\n  strict?: boolean;\n};\n\n/** Binary GLTF is little endian. */\nconst LITTLE_ENDIAN = true;\n\n/** 'glTF' in Big-Endian ASCII */\nconst MAGIC_glTF = 0x676c5446;\nconst GLB_FILE_HEADER_SIZE = 12;\nconst GLB_CHUNK_HEADER_SIZE = 8;\nconst GLB_CHUNK_TYPE_JSON = 0x4e4f534a;\nconst GLB_CHUNK_TYPE_BIN = 0x004e4942;\nconst GLB_V1_CONTENT_FORMAT_JSON = 0x0;\n\n/** @deprecated - Backward compatibility for old xviz files */\nconst GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;\n/** @deprecated - Backward compatibility for old xviz files */\nconst GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;\n\nfunction getMagicString(dataView, byteOffset = 0) {\n  return `\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;\n}\n\n/** Check if the contents of an array buffer contains GLB byte markers */\nexport function isGLB(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number = 0,\n  options: ParseGLBOptions = {}\n): boolean {\n  const dataView = new DataView(arrayBuffer);\n  // Check that GLB Header starts with the magic number\n  const {magic = MAGIC_glTF} = options;\n  const magic1 = dataView.getUint32(byteOffset, false);\n  return magic1 === magic || magic1 === MAGIC_glTF;\n}\n\n/**\n * Synchronously parse a GLB\n * @param glb - Target, Output is stored there\n * @param arrayBuffer - Input data\n * @param byteOffset - Offset into arrayBuffer to start parsing from (for \"embedded\" GLBs, e.g. in 3D tiles)\n * @param options\n * @returns\n */\nexport function parseGLBSync(\n  glb: GLB,\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number = 0,\n  options: ParseGLBOptions = {}\n) {\n  // Check that GLB Header starts with the magic number\n  const dataView = new DataView(arrayBuffer);\n\n  // Compare format with GLBLoader documentation\n  const type = getMagicString(dataView, byteOffset + 0);\n  const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Version 2 of binary glTF container format\n  const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN); // Total byte length of binary file\n\n  Object.assign(glb, {\n    // Put less important stuff in a header, to avoid clutter\n    header: {\n      byteOffset, // Byte offset into the initial arrayBuffer\n      byteLength,\n      hasBinChunk: false\n    },\n\n    type,\n    version,\n\n    json: {},\n    binChunks: []\n  } as GLB);\n\n  byteOffset += GLB_FILE_HEADER_SIZE;\n\n  switch (glb.version) {\n    case 1:\n      return parseGLBV1(glb, dataView, byteOffset);\n    case 2:\n      return parseGLBV2(glb, dataView, byteOffset, (options = {}));\n    default:\n      throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);\n  }\n}\n\n/**\n * Parse a V1 GLB\n * @param glb - target, output is stored in this object\n * @param dataView - Input, memory to be parsed\n * @param byteOffset - Offset of first byte of GLB data in the data view\n * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)\n */\nfunction parseGLBV1(glb: GLB, dataView: DataView, byteOffset: number): number {\n  // Sanity: ensure file is big enough to hold at least the headers\n  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n  // Explanation of GLB structure:\n  // https://cloud.githubusercontent.com/assets/3479527/22600725/36b87122-ea55-11e6-9d40-6fd42819fcab.png\n  const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN); // Byte length of chunk\n  const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Chunk format as uint32\n  byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n  // GLB v1 only supports a single chunk type\n  assert(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);\n\n  parseJSONChunk(glb, dataView, byteOffset, contentLength);\n  // No need to call the function padToBytes() from parseJSONChunk()\n  byteOffset += contentLength;\n  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);\n\n  return byteOffset;\n}\n\n/**\n * Parse a V2 GLB\n * @param glb - target, output is stored in this object\n * @param dataView - Input, memory to be parsed\n * @param byteOffset - Offset of first byte of GLB data in the data view\n * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)\n */\nfunction parseGLBV2(\n  glb: GLB,\n  dataView: DataView,\n  byteOffset: number,\n  options: ParseGLBOptions\n): number {\n  // Sanity: ensure file is big enough to hold at least the first chunk header\n  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n  parseGLBChunksSync(glb, dataView, byteOffset, options);\n\n  return byteOffset + glb.header.byteLength;\n}\n\n/** Iterate over GLB chunks and parse them */\nfunction parseGLBChunksSync(\n  glb: GLB,\n  dataView: DataView,\n  byteOffset: number,\n  options: ParseGLBOptions\n) {\n  // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n  // Iterate as long as there is space left for another chunk header\n  while (byteOffset + 8 <= glb.header.byteLength) {\n    const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN); // Byte length of chunk\n    const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Chunk format as uint32\n    byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n    // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n    switch (chunkFormat) {\n      case GLB_CHUNK_TYPE_JSON:\n        parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n        break;\n      case GLB_CHUNK_TYPE_BIN:\n        parseBINChunk(glb, dataView, byteOffset, chunkLength);\n        break;\n\n      // Backward compatibility for very old xviz files\n      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:\n        if (!options.strict) {\n          parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n        }\n        break;\n      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:\n        if (!options.strict) {\n          parseBINChunk(glb, dataView, byteOffset, chunkLength);\n        }\n        break;\n\n      default:\n        // Ignore, per spec\n        // console.warn(`Unknown GLB chunk type`); // eslint-disable-line\n        break;\n    }\n\n    byteOffset += padToNBytes(chunkLength, 4);\n  }\n\n  return byteOffset;\n}\n\n/* Parse a GLB JSON chunk */\nfunction parseJSONChunk(glb: GLB, dataView: DataView, byteOffset: number, chunkLength: number) {\n  // 1. Create a \"view\" of the binary encoded JSON data inside the GLB\n  const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);\n\n  // 2. Decode the JSON binary array into clear text\n  const textDecoder = new TextDecoder('utf8');\n  const jsonText = textDecoder.decode(jsonChunk);\n\n  // 3. Parse the JSON text into a JavaScript data structure\n  glb.json = JSON.parse(jsonText);\n\n  return padToNBytes(chunkLength, 4);\n}\n\n/** Parse a GLB BIN chunk */\nfunction parseBINChunk(glb: GLB, dataView, byteOffset, chunkLength) {\n  // Note: BIN chunk can be optional\n  glb.header.hasBinChunk = true;\n  glb.binChunks.push({\n    byteOffset,\n    byteLength: chunkLength,\n    arrayBuffer: dataView.buffer\n    // TODO - copy, or create typed array view?\n  });\n\n  return padToNBytes(chunkLength, 4);\n}\n"],"mappings":"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"}

package/dist/{esm/lib → lib}/parsers/parse-gltf.js

@@ -1,12 +1,12 @@
 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';
-import { isGLB, parseGLBSync } from './parse-glb';
-import { resolveUrl } from '../gltf-utils/resolve-url';
-import { getTypedArrayForBufferView } from '../gltf-utils/get-typed-array';
-import { preprocessExtensions, decodeExtensions } from '../api/gltf-extensions';
-import { normalizeGLTFV1 } from '../api/normalize-gltf-v1';
+import { assert } from "../utils/assert.js";
+import { isGLB, parseGLBSync } from "./parse-glb.js";
+import { resolveUrl } from "../gltf-utils/resolve-url.js";
+import { getTypedArrayForBufferView } from "../gltf-utils/get-typed-array.js";
+import { preprocessExtensions, decodeExtensions } from "../api/gltf-extensions.js";
+import { normalizeGLTFV1 } from "../api/normalize-gltf-v1.js";
 export function isGLTF(arrayBuffer, options) {
   const byteOffset = 0;
   return isGLB(arrayBuffer, byteOffset, options);
@@ -43,7 +43,7 @@ function parseGLTFContainerSync(gltf, data, byteOffset, options) {
   } else if (data instanceof ArrayBuffer) {
     const glb = {};
     byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);
-    assert(glb.type === 'glTF', "Invalid GLB magic string ".concat(glb.type));
+    assert(glb.type === 'glTF', `Invalid GLB magic string ${glb.type}`);
     gltf._glb = glb;
     gltf.json = glb.json;
   } else {

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

@@ -0,0 +1 @@
+{"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","_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/lib/types/glb-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glb-types.js","names":[],"sources":["../../../src/lib/types/glb-types.ts"],"sourcesContent":["export type GLBBinChunk = {\n  byteOffset: number;\n  byteLength: number;\n  arrayBuffer: ArrayBuffer;\n};\n\nexport type GLB = {\n  type: string;\n  version: number; // Version 2 of binary glTF container format\n\n  // Put less important stuff in a header, to avoid clutter\n  header: {\n    byteOffset: number; // Byte offset into the initial arrayBuffer\n    byteLength: number;\n    hasBinChunk: boolean;\n  };\n\n  // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n  json: Record<string, any>;\n  binChunks: GLBBinChunk[];\n};\n"],"mappings":""}

package/dist/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/lib/types/gltf-ext-mesh-features-schema.d.ts

@@ -31,7 +31,9 @@ export type GLTF_EXT_mesh_features_featureId = {
      * (e.g. a value of `0` corresponds to `_FEATURE_ID_0`).
      */
     attribute?: number;
-    /** A texture containing feature IDs. */
+    /** A texture containing feature IDs.
+     * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_mesh_features/schema/featureIdTexture.schema.json
+     */
     texture?: GLTFTextureInfoMetadata;
     /** The index of the property table containing per-feature property values. Only applicable when using the `EXT_structural_metadata` extension. */
     propertyTable?: number;

package/dist/lib/types/gltf-ext-mesh-features-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-ext-mesh-features-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/types/gltf-ext-mesh-features-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,oBAAoB,CAAC;AAG3D;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,mCAAmC;IACnC,UAAU,EAAE,gCAAgC,EAAE,CAAC;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gCAAgC,GAAG;IAC7C,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,sFAAsF;IACtF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mJAAmJ;IACnJ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC,kJAAkJ;IAClJ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,4FAA4F;IAC5F,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC"}
+{"version":3,"file":"gltf-ext-mesh-features-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/types/gltf-ext-mesh-features-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,oBAAoB,CAAC;AAG3D;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,mCAAmC;IACnC,UAAU,EAAE,gCAAgC,EAAE,CAAC;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gCAAgC,GAAG;IAC7C,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,sFAAsF;IACtF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mJAAmJ;IACnJ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC,kJAAkJ;IAClJ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,4FAA4F;IAC5F,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC"}

package/dist/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   * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_mesh_features/schema/featureIdTexture.schema.json\n   */\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":""}