@loaders.gl/gltf 4.2.0-alpha.4 → 4.2.0-alpha.5

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

@@ -1,214 +1,331 @@
+/**
+ * loaders.gl, MIT license
+ *
+ * Shared code for 3DTiles extensions:
+ * * EXT_feature_metadata
+ * * EXT_mesh_features
+ * * EXT_structural_metadata
+ */
 import { getComponentTypeFromArray } from "../../gltf-utils/gltf-utils.js";
 import { getImageData } from '@loaders.gl/images';
 function emod(n) {
-  return (n % 1 + 1) % 1;
+    return ((n % 1) + 1) % 1;
 }
 const ATTRIBUTE_TYPE_TO_COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16,
-  BOOLEAN: 1,
-  STRING: 1,
-  ENUM: 1
+    SCALAR: 1,
+    VEC2: 2,
+    VEC3: 3,
+    VEC4: 4,
+    MAT2: 4,
+    MAT3: 9,
+    MAT4: 16,
+    BOOLEAN: 1,
+    STRING: 1,
+    ENUM: 1
 };
 const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-  INT8: Int8Array,
-  UINT8: Uint8Array,
-  INT16: Int16Array,
-  UINT16: Uint16Array,
-  INT32: Int32Array,
-  UINT32: Uint32Array,
-  INT64: BigInt64Array,
-  UINT64: BigUint64Array,
-  FLOAT32: Float32Array,
-  FLOAT64: Float64Array
+    INT8: Int8Array,
+    UINT8: Uint8Array,
+    INT16: Int16Array,
+    UINT16: Uint16Array,
+    INT32: Int32Array,
+    UINT32: Uint32Array,
+    INT64: BigInt64Array,
+    UINT64: BigUint64Array,
+    FLOAT32: Float32Array,
+    FLOAT64: Float64Array
 };
 const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
-  INT8: 1,
-  UINT8: 1,
-  INT16: 2,
-  UINT16: 2,
-  INT32: 4,
-  UINT32: 4,
-  INT64: 8,
-  UINT64: 8,
-  FLOAT32: 4,
-  FLOAT64: 8
+    INT8: 1,
+    UINT8: 1,
+    INT16: 2,
+    UINT16: 2,
+    INT32: 4,
+    UINT32: 4,
+    INT64: 8,
+    UINT64: 8,
+    FLOAT32: 4,
+    FLOAT64: 8
 };
 export function getArrayElementByteSize(attributeType, componentType) {
-  return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
+    return (ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] *
+        ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType]);
 }
+/**
+ * Gets offset array from `arrayOffsets` or `stringOffsets`.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param bufferViewIndex - Buffer view index
+ * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.
+ * @param numberOfElements - The number of elements in each property array.
+ * @returns Array of values offsets. The number of offsets in the array is equal to `numberOfElements` plus one.
+ */
 export function getOffsetsForProperty(scenegraph, bufferViewIndex, offsetType, numberOfElements) {
-  if (offsetType !== 'UINT8' && offsetType !== 'UINT16' && offsetType !== 'UINT32' && offsetType !== 'UINT64') {
-    return null;
-  }
-  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
-  const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, 'SCALAR', offsetType, numberOfElements + 1);
-  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
-    return null;
-  }
-  return arrayOffsets;
+    if (offsetType !== 'UINT8' &&
+        offsetType !== 'UINT16' &&
+        offsetType !== 'UINT32' &&
+        offsetType !== 'UINT64') {
+        return null;
+    }
+    const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);
+    const arrayOffsets = convertRawBufferToMetadataArray(arrayOffsetsBytes, 'SCALAR', // offsets consist of ONE component
+    offsetType, numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.
+    );
+    // We don't support BigInt offsets at the moment. It requires additional logic and potential issues in Safari
+    if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+        return null;
+    }
+    return arrayOffsets;
 }
-export function convertRawBufferToMetadataArray(data, attributeType, componentType) {
-  let elementCount = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-  const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
-  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];
-  const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];
-  const length = elementCount * numberOfComponents;
-  const byteLength = length * size;
-  let buffer = data.buffer;
-  let offset = data.byteOffset;
-  if (offset % size !== 0) {
-    const bufferArray = new Uint8Array(buffer);
-    buffer = bufferArray.slice(offset, offset + byteLength).buffer;
-    offset = 0;
-  }
-  return new ArrayType(buffer, offset, length);
+/**
+ * Converts raw bytes that are in the buffer to an array of the type defined by the schema.
+ * @param data - Raw bytes in the buffer.
+ * @param attributeType - SCALAR, VECN, MATN.
+ * @param componentType - Type of the component in elements, e.g. 'UINT8' or 'FLOAT32'.
+ * @param elementCount - Number of elements in the array. Default value is 1.
+ * @returns Data array
+ */
+export function convertRawBufferToMetadataArray(data, attributeType, componentType, elementCount = 1) {
+    const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];
+    const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];
+    const length = elementCount * numberOfComponents;
+    const byteLength = length * size;
+    let buffer = data.buffer;
+    let offset = data.byteOffset;
+    if (offset % size !== 0) {
+        const bufferArray = new Uint8Array(buffer);
+        buffer = bufferArray.slice(offset, offset + byteLength).buffer;
+        offset = 0;
+    }
+    return new ArrayType(buffer, offset, length);
 }
+/**
+ * Processes data encoded in the texture associated with the primitive.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param textureInfo - Reference to the texture where extension data are stored.
+ * @param primitive - Primitive object in the mesh.
+ * @returns Array of data taken. Null if data can't be taken from the texture.
+ */
 export function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
-  var _json$textures, _json$textures$textur;
-  const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
-  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
-  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') {
-    var _json$images, _json$images$imageInd, _scenegraph$gltf$imag;
-    const mimeType = (_json$images = json.images) === null || _json$images === void 0 ? void 0 : (_json$images$imageInd = _json$images[imageIndex]) === null || _json$images$imageInd === void 0 ? void 0 : _json$images$imageInd.mimeType;
-    const parsedImage = (_scenegraph$gltf$imag = scenegraph.gltf.images) === null || _scenegraph$gltf$imag === void 0 ? void 0 : _scenegraph$gltf$imag[imageIndex];
-    if (parsedImage && typeof parsedImage.width !== 'undefined') {
-      const textureData = [];
-      for (let index = 0; index < textureCoordinates.length; index += 2) {
-        const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
-        textureData.push(value);
+    /*
+      texture.index is an index for the "textures" array.
+      The texture object referenced by this index looks like this:
+      {
+      "sampler": 0,
+      "source": 0
       }
-      return textureData;
+      "sampler" is an index for the "samplers" array
+      "source" is an index for the "images" array that contains data stored in rgba channels of the image.
+  
+      texture.texCoord is a number-suffix (like 1) for an attribute like "TEXCOORD_1" in meshes.primitives
+      The value of "TEXCOORD_1" is an accessor that is used to get coordinates.
+      These coordinates are being used to get data from the image.
+      
+      Default for texture.texCoord is 0
+      @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/specification/2.0/schema/textureInfo.schema.json
+    */
+    const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const textureCoordinates = scenegraph.getTypedArrayForAccessor(texCoordAccessorIndex);
+    const json = scenegraph.gltf.json;
+    const textureIndex = textureInfo.index;
+    const imageIndex = json.textures?.[textureIndex]?.source;
+    if (typeof imageIndex !== 'undefined') {
+        const mimeType = json.images?.[imageIndex]?.mimeType;
+        const parsedImage = scenegraph.gltf.images?.[imageIndex];
+        // Checking for width is to prevent handling Un-processed images (e.g. [analyze] stage, where loadImages option is set to false)
+        if (parsedImage && typeof parsedImage.width !== 'undefined') {
+            const textureData = [];
+            for (let index = 0; index < textureCoordinates.length; index += 2) {
+                const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, textureInfo.channels);
+                textureData.push(value);
+            }
+            return textureData;
+        }
     }
-  }
-  return [];
+    return [];
 }
+/**
+ * Puts property data to attributes.
+ * It creates corresponding buffer, bufferView and accessor
+ * so the data can be accessed like regular data stored in buffers.
+ * @param scenegraph - Scenegraph object.
+ * @param attributeName - Name of the attribute.
+ * @param propertyData - Property data to store.
+ * @param featureTable - Array where unique data from the property data are being stored.
+ * @param primitive - Primitive object.
+ */
 export function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
-  if (!(propertyData !== null && propertyData !== void 0 && propertyData.length)) {
-    return;
-  }
-  const featureIndices = [];
-  for (const texelData of propertyData) {
-    let index = featureTable.findIndex(item => item === texelData);
-    if (index === -1) {
-      index = featureTable.push(texelData) - 1;
+    // No reason to create an empty buffer if there is no property data to store.
+    if (!propertyData?.length) {
+        return;
     }
-    featureIndices.push(index);
-  }
-  const typedArray = new Uint32Array(featureIndices);
-  const bufferIndex = scenegraph.gltf.buffers.push({
-    arrayBuffer: typedArray.buffer,
-    byteOffset: typedArray.byteOffset,
-    byteLength: typedArray.byteLength
-  }) - 1;
-  const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
-  const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
-    size: 1,
-    componentType: getComponentTypeFromArray(typedArray),
-    count: typedArray.length
-  });
-  primitive.attributes[attributeName] = accessorIndex;
-}
-function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index) {
-  let channels = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : [0];
-  const CHANNELS_MAP = {
-    r: {
-      offset: 0,
-      shift: 0
-    },
-    g: {
-      offset: 1,
-      shift: 8
-    },
-    b: {
-      offset: 2,
-      shift: 16
-    },
-    a: {
-      offset: 3,
-      shift: 24
+    /*
+      featureTable will contain unique values, e.g.
+      propertyData = [24, 35, 28, 24]
+      featureTable = [24, 35, 28]
+      featureIndices will contain indices that refer featureTextureTable, e.g.
+      featureIndices = [0, 1, 2, 0]
+    */
+    const featureIndices = [];
+    for (const texelData of propertyData) {
+        let index = featureTable.findIndex((item) => item === texelData);
+        if (index === -1) {
+            index = featureTable.push(texelData) - 1;
+        }
+        featureIndices.push(index);
     }
-  };
-  const u = textureCoordinates[index];
-  const v = textureCoordinates[index + 1];
-  let components = 1;
-  if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1)) components = 4;
-  const offset = coordinatesToOffset(u, v, parsedImage, components);
-  let value = 0;
-  for (const c of channels) {
-    const map = typeof c === 'number' ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
-    const imageOffset = offset + map.offset;
-    const imageData = getImageData(parsedImage);
-    if (imageData.data.length <= imageOffset) {
-      throw new Error(`${imageData.data.length} <= ${imageOffset}`);
+    const typedArray = new Uint32Array(featureIndices);
+    const bufferIndex = scenegraph.gltf.buffers.push({
+        arrayBuffer: typedArray.buffer,
+        byteOffset: typedArray.byteOffset,
+        byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+        size: 1,
+        componentType: getComponentTypeFromArray(typedArray),
+        count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+}
+/**
+ * Gets the value from the texture by coordinates provided.
+ * @param parsedImage - Image where the data are stored.
+ * @param mimeType - MIME type.
+ * @param textureCoordinates - uv coordinates to access data in the image.
+ * @param index - Index of uv coordinates in the array textureCoordinates.
+ * @param channels - Image channels where data are stored.
+ *  Channels of an RGBA texture are numbered 0..3 respectively.
+ *  For Ext_mesh_features and EXT_strucural_metadata the channels default is [0]
+ *  @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features/schema/featureIdTexture.schema.json
+ *  @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_structural_metadata/schema/propertyTexture.property.schema.json
+ * @returns Value taken from the image.
+ */
+function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
+    const CHANNELS_MAP = {
+        r: { offset: 0, shift: 0 },
+        g: { offset: 1, shift: 8 },
+        b: { offset: 2, shift: 16 },
+        a: { offset: 3, shift: 24 }
+    };
+    const u = textureCoordinates[index];
+    const v = textureCoordinates[index + 1];
+    let components = 1;
+    if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1))
+        components = 4;
+    const offset = coordinatesToOffset(u, v, parsedImage, components);
+    let value = 0;
+    for (const c of channels) {
+        /*
+        According to the EXT_feature_metadata extension specification:
+          Channels are labeled by rgba and are swizzled with a string of 1-4 characters.
+        According to the EXT_mesh_features extension specification:
+          The channels array contains non-negative integer values corresponding to channels of the source texture that the feature ID consists of.
+          Channels of an RGBA texture are numbered 0–3 respectively.
+        Function getImageValueByCoordinates is used to process both extensions.
+        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).
+        */
+        const map = typeof c === 'number' ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
+        const imageOffset = offset + map.offset;
+        const imageData = getImageData(parsedImage);
+        if (imageData.data.length <= imageOffset) {
+            throw new Error(`${imageData.data.length} <= ${imageOffset}`);
+        }
+        const imageValue = imageData.data[imageOffset];
+        value |= imageValue << map.shift;
     }
-    const imageValue = imageData.data[imageOffset];
-    value |= imageValue << map.shift;
-  }
-  return value;
+    return value;
 }
-function coordinatesToOffset(u, v, parsedImage) {
-  let componentsCount = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
-  const w = parsedImage.width;
-  const iX = emod(u) * (w - 1);
-  const indX = Math.round(iX);
-  const h = parsedImage.height;
-  const iY = emod(v) * (h - 1);
-  const indY = Math.round(iY);
-  const components = parsedImage.components ? parsedImage.components : componentsCount;
-  const offset = (indY * w + indX) * components;
-  return offset;
+/**
+ * Retrieves the offset in the image where the data are stored.
+ * @param u - u-coordinate.
+ * @param v - v-coordinate.
+ * @param parsedImage - Image where the data are stored.
+ * @param componentsCount - Number of components the data consists of.
+ * @returns Offset in the image where the data are stored.
+ */
+function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
+    const w = parsedImage.width;
+    const iX = emod(u) * (w - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = emod(v) * (h - 1);
+    const indY = Math.round(iY);
+    const components = parsedImage.components ? parsedImage.components : componentsCount;
+    // components is a number of channels in the image
+    const offset = (indY * w + indX) * components;
+    return offset;
 }
+/**
+ * Parses variable-length array data.
+ * In this case every value of the property in the table will be an array
+ * of arbitrary length.
+ * @param valuesData - Values in a flat typed array.
+ * @param numberOfElements - Number of rows in the property table.
+ * @param arrayOffsets - Offsets of nested arrays in the flat values array.
+ * @param valuesDataBytesLength - Data byte length.
+ * @param valueSize - Value size in bytes.
+ * @returns Array of typed arrays.
+ */
 export function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, valuesDataBytesLength, valueSize) {
-  const attributeValueArray = [];
-  for (let index = 0; index < numberOfElements; index++) {
-    const arrayOffset = arrayOffsets[index];
-    const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
-    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
-      break;
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const arrayOffset = arrayOffsets[index];
+        const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];
+        if (arrayByteSize + arrayOffset > valuesDataBytesLength) {
+            break;
+        }
+        const typedArrayOffset = arrayOffset / valueSize;
+        const elementCount = arrayByteSize / valueSize;
+        attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
     }
-    const typedArrayOffset = arrayOffset / valueSize;
-    const elementCount = arrayByteSize / valueSize;
-    attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));
-  }
-  return attributeValueArray;
+    return attributeValueArray;
 }
+/**
+ * Parses fixed-length array data.
+ * In this case every value of the property in the table will be an array
+ * of constant length equal to `arrayCount`.
+ * @param valuesData - Values in a flat typed array.
+ * @param numberOfElements - Number of rows in the property table.
+ * @param arrayCount - Nested arrays length.
+ * @returns Array of typed arrays.
+ */
 export function parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount) {
-  const attributeValueArray = [];
-  for (let index = 0; index < numberOfElements; index++) {
-    const elementOffset = index * arrayCount;
-    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
-  }
-  return attributeValueArray;
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const elementOffset = index * arrayCount;
+        attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));
+    }
+    return attributeValueArray;
 }
+/**
+ * Decodes properties of string type from binary source.
+ * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.
+ * @param valuesDataBytes - Data taken from values property of the property table property.
+ * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.
+ * @param stringOffsets - Index of the buffer view containing offsets for strings. It should be available for string type.
+ * @returns String property values
+ */
 export function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets) {
-  if (arrayOffsets) {
-    throw new Error('Not implemented - arrayOffsets for strings is specified');
-  }
-  if (stringOffsets) {
-    const stringsArray = [];
-    const textDecoder = new TextDecoder('utf8');
-    let stringOffset = 0;
-    for (let index = 0; index < numberOfElements; index++) {
-      const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];
-      if (stringByteSize + stringOffset <= valuesDataBytes.length) {
-        const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);
-        const stringAttribute = textDecoder.decode(stringData);
-        stringsArray.push(stringAttribute);
-        stringOffset += stringByteSize;
-      }
+    if (arrayOffsets) {
+        // TODO: implement it as soon as we have the corresponding tileset
+        throw new Error('Not implemented - arrayOffsets for strings is specified');
+    }
+    if (stringOffsets) {
+        const stringsArray = [];
+        const textDecoder = new TextDecoder('utf8');
+        let stringOffset = 0;
+        for (let index = 0; index < numberOfElements; index++) {
+            const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];
+            if (stringByteSize + stringOffset <= valuesDataBytes.length) {
+                const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);
+                const stringAttribute = textDecoder.decode(stringData);
+                stringsArray.push(stringAttribute);
+                stringOffset += stringByteSize;
+            }
+        }
+        return stringsArray;
     }
-    return stringsArray;
-  }
-  return [];
+    return [];
 }
-//# sourceMappingURL=3d-tiles-utils.js.map

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

@@ -1,5 +1,5 @@
 import type { TypedArray } from '@loaders.gl/schema';
-import type { GLTF, GLTFExternalBuffer, GLTFAccessor } from '../types/gltf-types';
+import type { GLTF, GLTFExternalBuffer, GLTFAccessor } from "../types/gltf-types.js";
 export declare function getTypedArrayForBufferView(json: any, buffers: any, bufferViewIndex: any): Uint8Array;
 export declare function getTypedArrayForImageData(json: any, buffers: any, imageIndex: any): Uint8Array;
 /**

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":"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"}
+{"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,+BAA4B;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

@@ -1,51 +1,63 @@
+// TODO - GLTFScenegraph should use these
 import { assert } from "../utils/assert.js";
 import { getAccessorArrayTypeAndLength } from "./gltf-utils.js";
+// accepts buffer view index or buffer view object
+// returns a `Uint8Array`
 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);
+    const bufferView = json.bufferViews[bufferViewIndex];
+    assert(bufferView);
+    // Get hold of the arrayBuffer
+    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);
 }
+// accepts accessor index or accessor object
+// returns a `Uint8Array`
 export function getTypedArrayForImageData(json, buffers, imageIndex) {
-  const image = json.images[imageIndex];
-  const bufferViewIndex = json.bufferViews[image.bufferView];
-  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
+    const image = json.images[imageIndex];
+    const bufferViewIndex = json.bufferViews[image.bufferView];
+    return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
 }
+/**
+ * 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.
+ */
+// eslint-disable-next-line complexity
 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 ${JSON.stringify(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);
+    const gltfAccessor = typeof accessor === 'number' ? json.accessors?.[accessor] : accessor;
+    if (!gltfAccessor) {
+        throw new Error(`No gltf accessor ${JSON.stringify(accessor)}`);
+    }
+    const bufferView = json.bufferViews?.[gltfAccessor.bufferView || 0];
+    if (!bufferView) {
+        throw new Error(`No gltf buffer view for accessor ${bufferView}`);
+    }
+    // Get `arrayBuffer` the `bufferView` looks at
+    const { arrayBuffer, byteOffset: bufferByteOffset } = buffers[bufferView.buffer];
+    // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets
+    const byteOffset = (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+    // Deduce TypedArray type and its length from `accessor` and `bufferView` data
+    const { ArrayType, length, componentByteSize, numberOfComponentsInElement } = getAccessorArrayTypeAndLength(gltfAccessor, bufferView);
+    // 'length' is a whole number of components of all elements in the buffer pointed by the accessor
+    // Multiplier to calculate the address of the element in the arrayBuffer
+    const elementByteSize = componentByteSize * numberOfComponentsInElement;
+    const elementAddressScale = bufferView.byteStride || elementByteSize;
+    // Creare an array of component's type where all components (not just elements) will reside
+    if (typeof bufferView.byteStride === 'undefined' || bufferView.byteStride === elementByteSize) {
+        // No iterleaving
+        const result = new ArrayType(arrayBuffer, byteOffset, length);
+        return result;
+    }
+    // Iterleaving
+    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;
-  }
-  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/gltf-attribute-utils.d.ts

@@ -1,4 +1,4 @@
-import type { GLTFAccessor } from '../types/gltf-json-schema';
+import type { GLTFAccessor } from "../types/gltf-json-schema.js";
 export declare function getGLTFAccessors(attributes: any): {
     [key: string]: GLTFAccessor;
 };