@loaders.gl/scene 5.0.0-alpha.9 → 5.0.0-beta.2

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

@@ -0,0 +1,358 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { GLTFIterator } from "../../api/gltf-iterator.js";
+import { getComponentTypeFromArray } from "../../gltf-utils/gltf-utils.js";
+import { getImageData } from '@loaders.gl/images';
+import { ensureArrayBuffer } from '@loaders.gl/core/loader-utils';
+function emod(n) {
+    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
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
+    INT8: Int8Array,
+    UINT8: Uint8Array,
+    INT16: Int16Array,
+    UINT16: Uint16Array,
+    INT32: Int32Array,
+    UINT32: Uint32Array,
+    INT64: BigInt64Array,
+    UINT64: BigUint64Array,
+    FLOAT32: Float32Array,
+    FLOAT64: Float64Array
+};
+const ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
+    INT8: 1,
+    UINT8: 1,
+    INT16: 2,
+    UINT16: 2,
+    INT32: 4,
+    UINT32: 4,
+    INT64: 8,
+    UINT64: 8,
+    FLOAT32: 4,
+    FLOAT64: 8
+};
+export function getArrayElementByteSize(attributeType, componentType) {
+    return (ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] *
+        ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType]);
+}
+/**
+ * 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', // offsets consist of ONE component
+    offsetType, numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.
+    );
+    if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {
+        const numericOffsets = new Float64Array(arrayOffsets.length);
+        const maximumSafeOffset = BigInt(Number.MAX_SAFE_INTEGER);
+        for (let index = 0; index < arrayOffsets.length; index++) {
+            const offset = arrayOffsets[index];
+            if (offset < 0n || offset > maximumSafeOffset) {
+                throw new Error('EXT_structural_metadata: UINT64 offset exceeds the safe integer range');
+            }
+            numericOffsets[index] = Number(offset);
+        }
+        return numericOffsets;
+    }
+    return arrayOffsets;
+}
+/**
+ * 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(ensureArrayBuffer(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) {
+    /*
+      texture.index is an index for the "textures" array.
+      The texture object referenced by this index looks like this:
+      {
+      "sampler": 0,
+      "source": 0
+      }
+      "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 [];
+}
+/**
+ * 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) {
+    // No reason to create an empty buffer if there is no property data to store.
+    if (!propertyData?.length) {
+        return;
+    }
+    /*
+      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 typedArray = new Uint32Array(featureIndices);
+    const iterator = scenegraph instanceof GLTFIterator ? scenegraph : new GLTFIterator(scenegraph.gltf);
+    const bufferIndex = iterator.addBuffer(typedArray);
+    const bufferViewIndex = iterator.addBufferView(bufferIndex, typedArray.byteLength);
+    const accessorIndex = iterator.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;
+    }
+    return value;
+}
+/**
+ * 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 componentCount - Number of scalar components in each value.
+ * @returns Array of typed arrays.
+ */
+export function parseVariableLengthArrayNumeric(valuesData, numberOfElements, arrayOffsets, componentCount = 1) {
+    const attributeValueArray = [];
+    for (let index = 0; index < numberOfElements; index++) {
+        const arrayOffset = Number(arrayOffsets[index]);
+        const arrayLength = Number(arrayOffsets[index + 1]) - arrayOffset;
+        if (!Number.isInteger(arrayOffset) ||
+            !Number.isInteger(arrayLength) ||
+            arrayOffset < 0 ||
+            arrayLength < 0 ||
+            (arrayOffset + arrayLength) * componentCount > valuesData.length) {
+            break;
+        }
+        const componentOffset = arrayOffset * componentCount;
+        const componentLength = arrayLength * componentCount;
+        attributeValueArray.push(valuesData.slice(componentOffset, componentOffset + componentLength));
+    }
+    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.
+ * @param componentCount - Number of scalar components in each array element.
+ * @returns Array of typed arrays.
+ */
+export function parseFixedLengthArrayNumeric(valuesData, numberOfElements, arrayCount, componentCount = 1) {
+    const attributeValueArray = [];
+    const rowComponentCount = arrayCount * componentCount;
+    for (let index = 0; index < numberOfElements; index++) {
+        const elementOffset = index * rowComponentCount;
+        attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + rowComponentCount));
+    }
+    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.
+ * @param fixedArrayCount - Number of strings in each fixed-length array row.
+ * @returns String property values
+ */
+export function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets, fixedArrayCount) {
+    const textDecoder = new TextDecoder('utf8');
+    // Variable-length string array (arrayOffsets + stringOffsets)
+    // See: https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings
+    if (arrayOffsets) {
+        if (!stringOffsets) {
+            throw new Error('stringOffsets is required for variable-length string arrays');
+        }
+        const result = [];
+        for (let featureId = 0; featureId < numberOfElements; featureId++) {
+            const startStringIndex = arrayOffsets[featureId];
+            const endStringIndex = arrayOffsets[featureId + 1];
+            const strings = [];
+            for (let stringIndex = startStringIndex; stringIndex < endStringIndex; stringIndex++) {
+                const startByte = stringOffsets[stringIndex];
+                const endByte = stringOffsets[stringIndex + 1];
+                const stringData = valuesDataBytes.subarray(startByte, endByte);
+                strings.push(textDecoder.decode(stringData));
+            }
+            result.push(strings);
+        }
+        return result;
+    }
+    // Simple strings (stringOffsets only)
+    if (stringOffsets) {
+        const stringsArray = [];
+        const stringCount = numberOfElements * (fixedArrayCount || 1);
+        for (let index = 0; index < stringCount; index++) {
+            const startByte = Number(stringOffsets[index]);
+            const endByte = Number(stringOffsets[index + 1]);
+            if (startByte >= 0 && endByte >= startByte && endByte <= valuesDataBytes.length) {
+                stringsArray.push(textDecoder.decode(valuesDataBytes.subarray(startByte, endByte)));
+            }
+        }
+        return fixedArrayCount
+            ? Array.from({ length: numberOfElements }, (_unused, rowIndex) => stringsArray.slice(rowIndex * fixedArrayCount, (rowIndex + 1) * fixedArrayCount))
+            : stringsArray;
+    }
+    return [];
+}
+//# sourceMappingURL=3d-tiles-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"3d-tiles-utils.js","sourceRoot":"","sources":["../../../../../src/gltf/lib/extensions/utils/3d-tiles-utils.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,189 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/gltf/lib/gltf-utils/get-typed-array.ts
+var get_typed_array_exports = {};
+__export(get_typed_array_exports, {
+  getTypedArrayForAccessor: () => getTypedArrayForAccessor,
+  getTypedArrayForBufferView: () => getTypedArrayForBufferView,
+  getTypedArrayForImageData: () => getTypedArrayForImageData
+});
+module.exports = __toCommonJS(get_typed_array_exports);
+var import_assert = require("../utils/assert.cjs");
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+var import_gltf_utils = require("./gltf-utils.cjs");
+function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
+  const bufferView = typeof bufferViewIndex === "number" ? json.bufferViews[bufferViewIndex] : bufferViewIndex;
+  (0, import_assert.assert)(bufferView);
+  const bufferIndex = bufferView.buffer;
+  const binChunk = buffers[bufferIndex];
+  (0, import_assert.assert)(binChunk);
+  (0, import_assert.assert)((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
+  (0, import_assert.assert)((bufferView.byteOffset || 0) + bufferView.byteLength <= binChunk.byteLength);
+  (0, import_assert.assert)(
+    binChunk.byteOffset >= 0 && binChunk.byteOffset + binChunk.byteLength <= binChunk.arrayBuffer.byteLength
+  );
+  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
+}
+function getTypedArrayForImageData(json, buffers, imageIndex) {
+  const image = json.images[imageIndex];
+  return getTypedArrayForBufferView(json, buffers, image.bufferView);
+}
+function getTypedArrayForAccessor(json, buffers, accessor) {
+  const gltfAccessor = typeof accessor === "number" ? json.accessors?.[accessor] : accessor;
+  if (!gltfAccessor) {
+    throw new Error(`No gltf accessor ${JSON.stringify(accessor)}`);
+  }
+  (0, import_assert.assert)(Number.isSafeInteger(gltfAccessor.count) && gltfAccessor.count >= 0);
+  const { ArrayType, length, numberOfComponentsInElement } = (0, import_gltf_utils.getAccessorArrayTypeAndLength)(
+    gltfAccessor,
+    { byteLength: Infinity }
+  );
+  const decodedValue = gltfAccessor.value;
+  let result;
+  if (ArrayBuffer.isView(decodedValue)) {
+    (0, import_assert.assert)(decodedValue.length === length);
+    result = decodedValue;
+  } else if (gltfAccessor.bufferView === void 0) {
+    result = new ArrayType(length);
+  } else {
+    result = readAccessorValues(json, buffers, gltfAccessor);
+  }
+  const sparse = gltfAccessor.sparse;
+  if (!sparse) return result;
+  const copiedValue = new ArrayType(length);
+  new Uint8Array(copiedValue.buffer).set(
+    new Uint8Array(result.buffer, result.byteOffset, result.byteLength)
+  );
+  (0, import_assert.assert)(sparse.count >= 0 && sparse.count <= gltfAccessor.count);
+  (0, import_assert.assert)([5121, 5123, 5125].includes(sparse.indices.componentType));
+  const indices = readAccessorValues(json, buffers, {
+    bufferView: sparse.indices.bufferView,
+    byteOffset: sparse.indices.byteOffset,
+    componentType: sparse.indices.componentType,
+    count: sparse.count,
+    type: "SCALAR"
+  });
+  const values = readAccessorValues(json, buffers, {
+    bufferView: sparse.values.bufferView,
+    byteOffset: sparse.values.byteOffset,
+    componentType: gltfAccessor.componentType,
+    count: sparse.count,
+    type: gltfAccessor.type
+  });
+  let previousIndex = -1;
+  const copiedBytes = new Uint8Array(copiedValue.buffer);
+  const elementByteLength = numberOfComponentsInElement * ArrayType.BYTES_PER_ELEMENT;
+  const valueBytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+  for (let sparseIndex = 0; sparseIndex < sparse.count; sparseIndex++) {
+    const index = Number(indices[sparseIndex]);
+    (0, import_assert.assert)(index > previousIndex && index < gltfAccessor.count);
+    copiedBytes.set(
+      valueBytes.subarray(sparseIndex * elementByteLength, (sparseIndex + 1) * elementByteLength),
+      index * elementByteLength
+    );
+    previousIndex = index;
+  }
+  return copiedValue;
+}
+function readAccessorValues(json, buffers, gltfAccessor) {
+  const bufferView = json.bufferViews?.[gltfAccessor.bufferView];
+  if (!bufferView) {
+    throw new Error(`No gltf buffer view for accessor ${bufferView}`);
+  }
+  const externalBuffer = buffers[bufferView.buffer];
+  (0, import_assert.assert)(externalBuffer);
+  const { arrayBuffer, byteOffset: bufferByteOffset } = externalBuffer;
+  (0, import_assert.assert)((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);
+  (0, import_assert.assert)((bufferView.byteOffset || 0) + bufferView.byteLength <= externalBuffer.byteLength);
+  (0, import_assert.assert)(
+    bufferByteOffset >= 0 && bufferByteOffset + externalBuffer.byteLength <= arrayBuffer.byteLength
+  );
+  (0, import_assert.assert)((gltfAccessor.byteOffset || 0) >= 0);
+  const byteOffset = (bufferByteOffset || 0) + (gltfAccessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+  const { ArrayType, length, componentByteSize, numberOfComponentsInElement } = (0, import_gltf_utils.getAccessorArrayTypeAndLength)(gltfAccessor, bufferView);
+  const elementByteSize = componentByteSize * numberOfComponentsInElement;
+  const matrixColumns = gltfAccessor.type.startsWith("MAT") ? Number(gltfAccessor.type.slice(3)) : 1;
+  const matrixColumnByteSize = (0, import_loader_utils.padToNBytes)(matrixColumns * componentByteSize, 4);
+  const packedElementByteSize = matrixColumns > 1 ? matrixColumns * matrixColumnByteSize : elementByteSize;
+  const elementStride = bufferView.byteStride ?? packedElementByteSize;
+  const lastElementByteSize = matrixColumns > 1 ? (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize : elementByteSize;
+  (0, import_assert.assert)(elementStride >= packedElementByteSize);
+  (0, import_assert.assert)(
+    (gltfAccessor.byteOffset || 0) + (gltfAccessor.count === 0 ? 0 : (gltfAccessor.count - 1) * elementStride + lastElementByteSize) <= bufferView.byteLength
+  );
+  if (gltfAccessor.count === 0) return new ArrayType(0);
+  if (matrixColumns > 1 && matrixColumnByteSize !== matrixColumns * componentByteSize) {
+    const elementStride2 = bufferView.byteStride ?? matrixColumns * matrixColumnByteSize;
+    const lastElementSize = (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize;
+    (0, import_assert.assert)(
+      (gltfAccessor.byteOffset || 0) + (gltfAccessor.count - 1) * elementStride2 + lastElementSize <= bufferView.byteLength
+    );
+    const result2 = new ArrayType(length);
+    const outputBytes = new Uint8Array(result2.buffer, result2.byteOffset, result2.byteLength);
+    for (let elementIndex = 0; elementIndex < gltfAccessor.count; elementIndex++) {
+      for (let columnIndex = 0; columnIndex < matrixColumns; columnIndex++) {
+        const columnBytes = new Uint8Array(
+          arrayBuffer,
+          byteOffset + elementIndex * elementStride2 + columnIndex * matrixColumnByteSize,
+          matrixColumns * componentByteSize
+        );
+        outputBytes.set(
+          columnBytes,
+          elementIndex * elementByteSize + columnIndex * matrixColumns * componentByteSize
+        );
+      }
+    }
+    return result2;
+  }
+  const elementAddressScale = bufferView.byteStride || elementByteSize;
+  if (typeof bufferView.byteStride === "undefined" || bufferView.byteStride === elementByteSize) {
+    if (byteOffset % componentByteSize !== 0) {
+      const bytes = new Uint8Array(arrayBuffer, byteOffset, length * componentByteSize);
+      const alignedBytes = new Uint8Array(bytes.byteLength);
+      alignedBytes.set(bytes);
+      return new ArrayType(alignedBytes.buffer, 0, length);
+    }
+    const result2 = new ArrayType(arrayBuffer, byteOffset, length);
+    return result2;
+  }
+  const result = new ArrayType(length);
+  for (let i = 0; i < gltfAccessor.count; i++) {
+    const elementByteOffset = byteOffset + i * elementAddressScale;
+    let values;
+    if (elementByteOffset % componentByteSize !== 0) {
+      const bytes = new Uint8Array(arrayBuffer, elementByteOffset, elementByteSize);
+      const alignedBytes = new Uint8Array(elementByteSize);
+      alignedBytes.set(bytes);
+      values = new ArrayType(alignedBytes.buffer, 0, numberOfComponentsInElement);
+    } else {
+      values = new ArrayType(arrayBuffer, elementByteOffset, numberOfComponentsInElement);
+    }
+    result.set(values, i * numberOfComponentsInElement);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTypedArrayForAccessor,
+  getTypedArrayForBufferView,
+  getTypedArrayForImageData
+});
+//# sourceMappingURL=get-typed-array.cjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/gltf/lib/gltf-utils/get-typed-array.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// TODO - GLTFScenegraph should use these\nimport {assert} from '../utils/assert';\nimport {padToNBytes} from '@loaders.gl/core/loader-utils';\nimport type {BigTypedArray} from '@loaders.gl/core/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 =\n    typeof bufferViewIndex === 'number' ? json.bufferViews[bufferViewIndex] : 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  assert((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);\n  assert((bufferView.byteOffset || 0) + bufferView.byteLength <= binChunk.byteLength);\n  assert(\n    binChunk.byteOffset >= 0 &&\n      binChunk.byteOffset + binChunk.byteLength <= binChunk.arrayBuffer.byteLength\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  return getTypedArrayForBufferView(json, buffers, image.bufferView);\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 Typed array with type matching the accessor component type.\n */\n// eslint-disable-next-line complexity\nexport function getTypedArrayForAccessor(\n  json: GLTF,\n  buffers: GLTFExternalBuffer[],\n  accessor: GLTFAccessor | number\n): BigTypedArray {\n  const gltfAccessor = typeof accessor === 'number' ? json.accessors?.[accessor] : accessor;\n  if (!gltfAccessor) {\n    throw new Error(`No gltf accessor ${JSON.stringify(accessor)}`);\n  }\n  assert(Number.isSafeInteger(gltfAccessor.count) && gltfAccessor.count >= 0);\n  const {ArrayType, length, numberOfComponentsInElement} = getAccessorArrayTypeAndLength(\n    gltfAccessor,\n    {byteLength: Infinity}\n  );\n  const decodedValue = (gltfAccessor as GLTFAccessor & {value?: BigTypedArray}).value;\n  let result: BigTypedArray;\n  if (ArrayBuffer.isView(decodedValue)) {\n    assert(decodedValue.length === length);\n    result = decodedValue;\n  } else if (gltfAccessor.bufferView === undefined) {\n    result = new ArrayType(length);\n  } else {\n    result = readAccessorValues(json, buffers, gltfAccessor);\n  }\n  const sparse = gltfAccessor.sparse;\n  if (!sparse) return result;\n  // Sparse substitutions must never mutate borrowed buffers or decoder-owned arrays.\n  const copiedValue: BigTypedArray = new ArrayType(length);\n  new Uint8Array(copiedValue.buffer).set(\n    new Uint8Array(result.buffer, result.byteOffset, result.byteLength)\n  );\n  assert(sparse.count >= 0 && sparse.count <= gltfAccessor.count);\n  assert([5121, 5123, 5125].includes(sparse.indices.componentType));\n  const indices = readAccessorValues(json, buffers, {\n    bufferView: sparse.indices.bufferView,\n    byteOffset: sparse.indices.byteOffset,\n    componentType: sparse.indices.componentType,\n    count: sparse.count,\n    type: 'SCALAR'\n  });\n  const values = readAccessorValues(json, buffers, {\n    bufferView: sparse.values.bufferView,\n    byteOffset: sparse.values.byteOffset,\n    componentType: gltfAccessor.componentType,\n    count: sparse.count,\n    type: gltfAccessor.type\n  });\n  let previousIndex = -1;\n  const copiedBytes = new Uint8Array(copiedValue.buffer);\n  const elementByteLength = numberOfComponentsInElement * ArrayType.BYTES_PER_ELEMENT;\n  const valueBytes = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);\n  for (let sparseIndex = 0; sparseIndex < sparse.count; sparseIndex++) {\n    const index = Number(indices[sparseIndex]);\n    assert(index > previousIndex && index < gltfAccessor.count);\n    copiedBytes.set(\n      valueBytes.subarray(sparseIndex * elementByteLength, (sparseIndex + 1) * elementByteLength),\n      index * elementByteLength\n    );\n    previousIndex = index;\n  }\n  return copiedValue;\n}\n\n/** Read dense values, respecting buffer-view ranges, interleaving and matrix column padding. */\nfunction readAccessorValues(\n  json: GLTF,\n  buffers: GLTFExternalBuffer[],\n  gltfAccessor: GLTFAccessor\n): BigTypedArray {\n  const bufferView = json.bufferViews?.[gltfAccessor.bufferView!];\n  if (!bufferView) {\n    throw new Error(`No gltf buffer view for accessor ${bufferView}`);\n  }\n  // Get `arrayBuffer` the `bufferView` looks at\n  const externalBuffer = buffers[bufferView.buffer];\n  assert(externalBuffer);\n  const {arrayBuffer, byteOffset: bufferByteOffset} = externalBuffer;\n  assert((bufferView.byteOffset || 0) >= 0 && bufferView.byteLength >= 0);\n  assert((bufferView.byteOffset || 0) + bufferView.byteLength <= externalBuffer.byteLength);\n  assert(\n    bufferByteOffset >= 0 && bufferByteOffset + externalBuffer.byteLength <= arrayBuffer.byteLength\n  );\n  assert((gltfAccessor.byteOffset || 0) >= 0);\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 matrixColumns = gltfAccessor.type.startsWith('MAT')\n    ? Number(gltfAccessor.type.slice(3))\n    : 1;\n  const matrixColumnByteSize = padToNBytes(matrixColumns * componentByteSize, 4);\n  const packedElementByteSize =\n    matrixColumns > 1 ? matrixColumns * matrixColumnByteSize : elementByteSize;\n  const elementStride = bufferView.byteStride ?? packedElementByteSize;\n  const lastElementByteSize =\n    matrixColumns > 1\n      ? (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize\n      : elementByteSize;\n  assert(elementStride >= packedElementByteSize);\n  assert(\n    (gltfAccessor.byteOffset || 0) +\n      (gltfAccessor.count === 0\n        ? 0\n        : (gltfAccessor.count - 1) * elementStride + lastElementByteSize) <=\n      bufferView.byteLength\n  );\n  if (gltfAccessor.count === 0) return new ArrayType(0);\n  if (matrixColumns > 1 && matrixColumnByteSize !== matrixColumns * componentByteSize) {\n    const elementStride = bufferView.byteStride ?? matrixColumns * matrixColumnByteSize;\n    const lastElementSize =\n      (matrixColumns - 1) * matrixColumnByteSize + matrixColumns * componentByteSize;\n    assert(\n      (gltfAccessor.byteOffset || 0) + (gltfAccessor.count - 1) * elementStride + lastElementSize <=\n        bufferView.byteLength\n    );\n    const result: BigTypedArray = new ArrayType(length);\n    const outputBytes = new Uint8Array(result.buffer, result.byteOffset, result.byteLength);\n    for (let elementIndex = 0; elementIndex < gltfAccessor.count; elementIndex++) {\n      for (let columnIndex = 0; columnIndex < matrixColumns; columnIndex++) {\n        const columnBytes = new Uint8Array(\n          arrayBuffer,\n          byteOffset + elementIndex * elementStride + columnIndex * matrixColumnByteSize,\n          matrixColumns * componentByteSize\n        );\n        outputBytes.set(\n          columnBytes,\n          elementIndex * elementByteSize + columnIndex * matrixColumns * componentByteSize\n        );\n      }\n    }\n    return result;\n  }\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    if (byteOffset % componentByteSize !== 0) {\n      const bytes = new Uint8Array(arrayBuffer, byteOffset, length * componentByteSize);\n      const alignedBytes = new Uint8Array(bytes.byteLength);\n      alignedBytes.set(bytes);\n      return new ArrayType(alignedBytes.buffer, 0, length);\n    }\n    const result: BigTypedArray = new ArrayType(arrayBuffer, byteOffset, length);\n    return result;\n  }\n  // Iterleaving\n  const result: BigTypedArray = new ArrayType(length);\n  for (let i = 0; i < gltfAccessor.count; i++) {\n    const elementByteOffset = byteOffset + i * elementAddressScale;\n    let values: any;\n    if (elementByteOffset % componentByteSize !== 0) {\n      const bytes = new Uint8Array(arrayBuffer, elementByteOffset, elementByteSize);\n      const alignedBytes = new Uint8Array(elementByteSize);\n      alignedBytes.set(bytes);\n      values = new ArrayType(alignedBytes.buffer, 0, numberOfComponentsInElement);\n    } else {\n      values = new ArrayType(arrayBuffer, elementByteOffset, numberOfComponentsInElement);\n    }\n    result.set(values, i * numberOfComponentsInElement);\n  }\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": ["elementStride", "result"]
+}

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

@@ -0,0 +1,13 @@
+import type { BigTypedArray } from '@loaders.gl/core/schema';
+import type { GLTF, GLTFExternalBuffer, GLTFAccessor } from "../types/gltf-types.js";
+export declare function getTypedArrayForBufferView(json: any, buffers: any, bufferViewIndex: any): Uint8Array<any>;
+export declare function getTypedArrayForImageData(json: any, buffers: any, imageIndex: any): Uint8Array<any>;
+/**
+ * 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 Typed array with type matching the accessor component type.
+ */
+export declare function getTypedArrayForAccessor(json: GLTF, buffers: GLTFExternalBuffer[], accessor: GLTFAccessor | number): BigTypedArray;
+//# sourceMappingURL=get-typed-array.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-typed-array.d.ts","sourceRoot":"","sources":["../../../../src/gltf/lib/gltf-utils/get-typed-array.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAC,IAAI,EAAE,kBAAkB,EAAE,YAAY,EAAC,+BAA4B;AAKhF,wBAAgB,0BAA0B,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,eAAe,KAAA,mBAkBxE;AAID,wBAAgB,yBAAyB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,EAAE,UAAU,KAAA,mBAGlE;AAED;;;;;;GAMG;AAEH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,kBAAkB,EAAE,EAC7B,QAAQ,EAAE,YAAY,GAAG,MAAM,GAC9B,aAAa,CAyDf"}