@loaders.gl/scene 5.0.0-alpha.8 → 5.0.0-beta.1

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

@@ -0,0 +1,280 @@
+"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/extensions/utils/3d-tiles-utils.ts
+var d_tiles_utils_exports = {};
+__export(d_tiles_utils_exports, {
+  convertRawBufferToMetadataArray: () => convertRawBufferToMetadataArray,
+  getArrayElementByteSize: () => getArrayElementByteSize,
+  getOffsetsForProperty: () => getOffsetsForProperty,
+  getPrimitiveTextureData: () => getPrimitiveTextureData,
+  getPropertyDataString: () => getPropertyDataString,
+  parseFixedLengthArrayNumeric: () => parseFixedLengthArrayNumeric,
+  parseVariableLengthArrayNumeric: () => parseVariableLengthArrayNumeric,
+  primitivePropertyDataToAttributes: () => primitivePropertyDataToAttributes
+});
+module.exports = __toCommonJS(d_tiles_utils_exports);
+var import_gltf_iterator = require("../../api/gltf-iterator.cjs");
+var import_gltf_utils = require("../../gltf-utils/gltf-utils.cjs");
+var import_images = require("@loaders.gl/images");
+var import_loader_utils = require("@loaders.gl/core/loader-utils");
+function emod(n) {
+  return (n % 1 + 1) % 1;
+}
+var ATTRIBUTE_TYPE_TO_COMPONENTS = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16,
+  BOOLEAN: 1,
+  STRING: 1,
+  ENUM: 1
+};
+var 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
+};
+var 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
+};
+function getArrayElementByteSize(attributeType, componentType) {
+  return ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] * ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
+}
+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;
+}
+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((0, import_loader_utils.ensureArrayBuffer)(buffer), offset, length);
+}
+function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
+  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];
+    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 [];
+}
+function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
+  if (!propertyData?.length) {
+    return;
+  }
+  const featureIndices = [];
+  for (const texelData of propertyData) {
+    let index = featureTable.findIndex((item) => item === texelData);
+    if (index === -1) {
+      index = featureTable.push(texelData) - 1;
+    }
+    featureIndices.push(index);
+  }
+  const typedArray = new Uint32Array(featureIndices);
+  const iterator = scenegraph instanceof import_gltf_iterator.GLTFIterator ? scenegraph : new import_gltf_iterator.GLTFIterator(scenegraph.gltf);
+  const bufferIndex = iterator.addBuffer(typedArray);
+  const bufferViewIndex = iterator.addBufferView(bufferIndex, typedArray.byteLength);
+  const accessorIndex = iterator.addAccessor(bufferViewIndex, {
+    size: 1,
+    componentType: (0, import_gltf_utils.getComponentTypeFromArray)(typedArray),
+    count: typedArray.length
+  });
+  primitive.attributes[attributeName] = accessorIndex;
+}
+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) {
+    const map = typeof c === "number" ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];
+    const imageOffset = offset + map.offset;
+    const imageData = (0, import_images.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;
+}
+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;
+  const offset = (indY * w + indX) * components;
+  return offset;
+}
+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;
+}
+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;
+}
+function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets, stringOffsets, fixedArrayCount) {
+  const textDecoder = new TextDecoder("utf8");
+  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;
+  }
+  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 [];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertRawBufferToMetadataArray,
+  getArrayElementByteSize,
+  getOffsetsForProperty,
+  getPrimitiveTextureData,
+  getPropertyDataString,
+  parseFixedLengthArrayNumeric,
+  parseVariableLengthArrayNumeric,
+  primitivePropertyDataToAttributes
+});
+//# sourceMappingURL=3d-tiles-utils.cjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/gltf/lib/extensions/utils/3d-tiles-utils.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n/**\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/core/schema';\nimport type {ImageType} from '@loaders.gl/images';\n\nimport {GLTFScenegraph} from '../../api/gltf-scenegraph';\nimport {GLTFIterator} from '../../api/gltf-iterator';\nimport {getComponentTypeFromArray} from '../../gltf-utils/gltf-utils';\nimport {getImageData} from '@loaders.gl/images';\nimport {ensureArrayBuffer} from '@loaders.gl/core/loader-utils';\n\nfunction emod(n: number): number {\n  return ((n % 1) + 1) % 1;\n}\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 | GLTFIterator,\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  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {\n    const numericOffsets = new Float64Array(arrayOffsets.length);\n    const maximumSafeOffset = BigInt(Number.MAX_SAFE_INTEGER);\n    for (let index = 0; index < arrayOffsets.length; index++) {\n      const offset = arrayOffsets[index];\n      if (offset < 0n || offset > maximumSafeOffset) {\n        throw new Error('EXT_structural_metadata: UINT64 offset exceeds the safe integer range');\n      }\n      numericOffsets[index] = Number(offset);\n    }\n    return numericOffsets;\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(ensureArrayBuffer(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 | GLTFIterator,\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 | GLTFIterator,\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 iterator =\n    scenegraph instanceof GLTFIterator ? scenegraph : new GLTFIterator(scenegraph.gltf);\n  const bufferIndex = iterator.addBuffer(typedArray);\n  const bufferViewIndex = iterator.addBufferView(bufferIndex, typedArray.byteLength);\n  const accessorIndex = iterator.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\u20133 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 componentCount - Number of scalar components in each value.\n * @returns Array of typed arrays.\n */\nexport function parseVariableLengthArrayNumeric(\n  valuesData: BigTypedArray,\n  numberOfElements: number,\n  arrayOffsets: TypedArray,\n  componentCount = 1\n): BigTypedArray[] {\n  const attributeValueArray: BigTypedArray[] = [];\n  for (let index = 0; index < numberOfElements; index++) {\n    const arrayOffset = Number(arrayOffsets[index]);\n    const arrayLength = Number(arrayOffsets[index + 1]) - arrayOffset;\n    if (\n      !Number.isInteger(arrayOffset) ||\n      !Number.isInteger(arrayLength) ||\n      arrayOffset < 0 ||\n      arrayLength < 0 ||\n      (arrayOffset + arrayLength) * componentCount > valuesData.length\n    ) {\n      break;\n    }\n    const componentOffset = arrayOffset * componentCount;\n    const componentLength = arrayLength * componentCount;\n    attributeValueArray.push(valuesData.slice(componentOffset, componentOffset + componentLength));\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 * @param componentCount - Number of scalar components in each array element.\n * @returns Array of typed arrays.\n */\nexport function parseFixedLengthArrayNumeric(\n  valuesData: BigTypedArray,\n  numberOfElements: number,\n  arrayCount: number,\n  componentCount = 1\n): BigTypedArray[] {\n  const attributeValueArray: BigTypedArray[] = [];\n  const rowComponentCount = arrayCount * componentCount;\n  for (let index = 0; index < numberOfElements; index++) {\n    const elementOffset = index * rowComponentCount;\n    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + rowComponentCount));\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 * @param fixedArrayCount - Number of strings in each fixed-length array row.\n * @returns String property values\n */\nexport function getPropertyDataString(\n  numberOfElements: number,\n  valuesDataBytes: Uint8Array,\n  arrayOffsets: TypedArray | null,\n  stringOffsets: TypedArray | null,\n  fixedArrayCount?: number\n): string[] | string[][] {\n  const textDecoder = new TextDecoder('utf8');\n\n  // Variable-length string array (arrayOffsets + stringOffsets)\n  // See: https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings\n  if (arrayOffsets) {\n    if (!stringOffsets) {\n      throw new Error('stringOffsets is required for variable-length string arrays');\n    }\n\n    const result: string[][] = [];\n    for (let featureId = 0; featureId < numberOfElements; featureId++) {\n      const startStringIndex = arrayOffsets[featureId];\n      const endStringIndex = arrayOffsets[featureId + 1];\n      const strings: string[] = [];\n\n      for (let stringIndex = startStringIndex; stringIndex < endStringIndex; stringIndex++) {\n        const startByte = stringOffsets[stringIndex];\n        const endByte = stringOffsets[stringIndex + 1];\n        const stringData = valuesDataBytes.subarray(startByte, endByte);\n        strings.push(textDecoder.decode(stringData));\n      }\n\n      result.push(strings);\n    }\n    return result;\n  }\n\n  // Simple strings (stringOffsets only)\n  if (stringOffsets) {\n    const stringsArray: string[] = [];\n    const stringCount = numberOfElements * (fixedArrayCount || 1);\n    for (let index = 0; index < stringCount; index++) {\n      const startByte = Number(stringOffsets[index]);\n      const endByte = Number(stringOffsets[index + 1]);\n      if (startByte >= 0 && endByte >= startByte && endByte <= valuesDataBytes.length) {\n        stringsArray.push(textDecoder.decode(valuesDataBytes.subarray(startByte, endByte)));\n      }\n    }\n    return fixedArrayCount\n      ? Array.from({length: numberOfElements}, (_unused, rowIndex) =>\n          stringsArray.slice(rowIndex * fixedArrayCount, (rowIndex + 1) * fixedArrayCount)\n        )\n      : stringsArray;\n  }\n  return [];\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,84 @@
+/**
+ * loaders.gl, MIT license
+ *
+ * Shared code for 3DTiles extensions:
+ * * EXT_feature_metadata
+ * * EXT_mesh_features
+ * * EXT_structural_metadata
+ */
+import type { GLTFTextureInfoMetadata, GLTFMeshPrimitive } from "../../types/gltf-json-schema.js";
+import type { BigTypedArray, TypedArray } from '@loaders.gl/core/schema';
+import { GLTFScenegraph } from "../../api/gltf-scenegraph.js";
+import { GLTFIterator } from "../../api/gltf-iterator.js";
+export type NumericComponentType = 'INT8' | 'UINT8' | 'INT16' | 'UINT16' | 'INT32' | 'UINT32' | 'INT64' | 'UINT64' | 'FLOAT32' | 'FLOAT64';
+export declare function getArrayElementByteSize(attributeType: any, componentType: any): number;
+/**
+ * Gets offset array from `arrayOffsets` or `stringOffsets`.
+ * @param scenegraph - Instance of the class for structured access to GLTF data.
+ * @param bufferViewIndex - Buffer view index
+ * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.
+ * @param numberOfElements - The number of elements in each property array.
+ * @returns Array of values offsets. The number of offsets in the array is equal to `numberOfElements` plus one.
+ */
+export declare function getOffsetsForProperty(scenegraph: GLTFScenegraph | GLTFIterator, bufferViewIndex: number, offsetType: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string, numberOfElements: number): TypedArray | null;
+/**
+ * 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 declare function convertRawBufferToMetadataArray(data: Uint8Array, attributeType: string, componentType: NumericComponentType, elementCount?: number): BigTypedArray;
+/**
+ * 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 declare function getPrimitiveTextureData(scenegraph: GLTFScenegraph | GLTFIterator, textureInfo: GLTFTextureInfoMetadata, primitive: GLTFMeshPrimitive): number[];
+/**
+ * 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 declare function primitivePropertyDataToAttributes(scenegraph: GLTFScenegraph | GLTFIterator, attributeName: string, propertyData: number[], featureTable: number[], primitive: GLTFMeshPrimitive): void;
+/**
+ * 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 declare function parseVariableLengthArrayNumeric(valuesData: BigTypedArray, numberOfElements: number, arrayOffsets: TypedArray, componentCount?: number): BigTypedArray[];
+/**
+ * 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 declare function parseFixedLengthArrayNumeric(valuesData: BigTypedArray, numberOfElements: number, arrayCount: number, componentCount?: number): BigTypedArray[];
+/**
+ * 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 declare function getPropertyDataString(numberOfElements: number, valuesDataBytes: Uint8Array, arrayOffsets: TypedArray | null, stringOffsets: TypedArray | null, fixedArrayCount?: number): string[] | string[][];
+//# sourceMappingURL=3d-tiles-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"3d-tiles-utils.d.ts","sourceRoot":"","sources":["../../../../../src/gltf/lib/extensions/utils/3d-tiles-utils.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAC,uBAAuB,EAAE,iBAAiB,EAAC,wCAAqC;AAC7F,OAAO,KAAK,EAAC,aAAa,EAAE,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAGvE,OAAO,EAAC,cAAc,EAAC,qCAAkC;AACzD,OAAO,EAAC,YAAY,EAAC,mCAAgC;AASrD,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,GAAG,YAAY,EACzC,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,EAC7D,gBAAgB,EAAE,MAAM,GACvB,UAAU,GAAG,IAAI,CA8BnB;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,GAAG,YAAY,EACzC,WAAW,EAAE,uBAAuB,EACpC,SAAS,EAAE,iBAAiB,GAC3B,MAAM,EAAE,CA6CV;AAED;;;;;;;;;GASG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,cAAc,GAAG,YAAY,EACzC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EAAE,EACtB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,iBAAiB,GAC3B,IAAI,CA+BN;AAsFD;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,aAAa,EACzB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,UAAU,EACxB,cAAc,SAAI,GACjB,aAAa,EAAE,CAmBjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,aAAa,EACzB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,cAAc,SAAI,GACjB,aAAa,EAAE,CAQjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,gBAAgB,EAAE,MAAM,EACxB,eAAe,EAAE,UAAU,EAC3B,YAAY,EAAE,UAAU,GAAG,IAAI,EAC/B,aAAa,EAAE,UAAU,GAAG,IAAI,EAChC,eAAe,CAAC,EAAE,MAAM,GACvB,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CA8CvB"}