@loaders.gl/gltf 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/lib/extensions/deprecated/EXT_feature_metadata.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.name = void 0;
+const gltf_scenegraph_1 = __importDefault(require("../../api/gltf-scenegraph"));
+/** Extension name */
+const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
+exports.name = EXT_FEATURE_METADATA;
+async function decode(gltfData) {
+    const scenegraph = new gltf_scenegraph_1.default(gltfData);
+    decodeExtFeatureMetadata(scenegraph);
+}
+exports.decode = decode;
+/**
+ * Decodes feature metadata from extension
+ * @param scenegraph
+ */
+function decodeExtFeatureMetadata(scenegraph) {
+    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
+    const schemaClasses = extension?.schema?.classes;
+    const featureTables = extension?.featureTables;
+    const featureTextures = extension?.featureTextures;
+    if (featureTextures) {
+        /*
+         * TODO add support for featureTextures
+         * Spec - https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_feature_metadata#feature-textures
+         */
+        // eslint-disable-next-line no-console
+        console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
+    }
+    if (schemaClasses && featureTables) {
+        for (const schemaName in schemaClasses) {
+            const schemaClass = schemaClasses[schemaName];
+            const featureTable = findFeatureTableByName(featureTables, schemaName);
+            if (featureTable) {
+                handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+            }
+        }
+    }
+}
+/**
+ * Navigate throw all properies in feature table and gets properties data.
+ * @param scenegraph
+ * @param featureTable
+ * @param schemaClass
+ */
+function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
+    for (const propertyName in schemaClass.properties) {
+        const schemaProperty = schemaClass.properties[propertyName];
+        const featureTableProperty = featureTable?.properties?.[propertyName];
+        const numberOfFeatures = featureTable.count;
+        if (featureTableProperty) {
+            const data = getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
+            featureTableProperty.data = data;
+        }
+    }
+}
+/**
+ * Decode properties from binary sourse based on property type.
+ * @param scenegraph
+ * @param schemaProperty
+ * @param numberOfFeatures
+ * @param featureTableProperty
+ */
+function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
+    const bufferView = featureTableProperty.bufferView;
+    // TODO think maybe we shouldn't get data only in Uint8Array format.
+    let data = scenegraph.getTypedArrayForBufferView(bufferView);
+    switch (schemaProperty.type) {
+        case 'STRING': {
+            // stringOffsetBufferView should be available for string type.
+            const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
+            const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+            data = getStringAttributes(data, offsetsData, numberOfFeatures);
+            break;
+        }
+        default:
+    }
+    return data;
+}
+/**
+ * Find the feature table by class name.
+ * @param featureTables
+ * @param schemaClassName
+ */
+function findFeatureTableByName(featureTables, schemaClassName) {
+    for (const featureTableName in featureTables) {
+        const featureTable = featureTables[featureTableName];
+        if (featureTable.class === schemaClassName) {
+            return featureTable;
+        }
+    }
+    return null;
+}
+/**
+ * Getting string attributes from binary data.
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/specification/Metadata#strings
+ * @param data
+ * @param offsetsData
+ * @param stringsCount
+ */
+function getStringAttributes(data, offsetsData, stringsCount) {
+    const stringsArray = [];
+    const textDecoder = new TextDecoder('utf8');
+    let stringOffset = 0;
+    const bytesPerStringSize = 4;
+    for (let index = 0; index < stringsCount; index++) {
+        // TODO check if it is multiplication on bytesPerStringSize is valid operation?
+        const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+        const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+        const stringAttribute = textDecoder.decode(stringData);
+        stringsArray.push(stringAttribute);
+        stringOffset += stringByteSize;
+    }
+    return stringsArray;
+}

package/dist/lib/extensions/deprecated/KHR_lights_punctual.js

@@ -1,49 +1,62 @@
-import { assert } from '../../utils/assert';
-import GLTFScenegraph from '../../api/gltf-scenegraph';
+"use strict";
+// GLTF EXTENSION: KHR_lights_punctual
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.decode = exports.name = void 0;
+const assert_1 = require("../../utils/assert");
+const gltf_scenegraph_1 = __importDefault(require("../../api/gltf-scenegraph"));
 const KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';
-export const name = KHR_LIGHTS_PUNCTUAL;
-export async function decode(gltfData) {
-  const gltfScenegraph = new GLTFScenegraph(gltfData);
-  const {
-    json
-  } = gltfScenegraph;
-  const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);
-
-  if (extension) {
-    gltfScenegraph.json.lights = extension.lights;
-    gltfScenegraph.removeExtension(KHR_LIGHTS_PUNCTUAL);
-  }
-
-  for (const node of json.nodes || []) {
-    const nodeExtension = gltfScenegraph.getObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
-
-    if (nodeExtension) {
-      node.light = nodeExtension.light;
+exports.name = KHR_LIGHTS_PUNCTUAL;
+async function decode(gltfData) {
+    const gltfScenegraph = new gltf_scenegraph_1.default(gltfData);
+    const { json } = gltfScenegraph;
+    // Move the light array out of the extension and remove the extension
+    const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);
+    if (extension) {
+        // @ts-ignore
+        gltfScenegraph.json.lights = extension.lights;
+        gltfScenegraph.removeExtension(KHR_LIGHTS_PUNCTUAL);
+    }
+    // Any nodes that have the extension, add lights field pointing to light object
+    // and remove the extension
+    for (const node of json.nodes || []) {
+        const nodeExtension = gltfScenegraph.getObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
+        if (nodeExtension) {
+            // @ts-ignore
+            node.light = nodeExtension.light;
+        }
+        gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
     }
-
-    gltfScenegraph.removeObjectExtension(node, KHR_LIGHTS_PUNCTUAL);
-  }
 }
-export async function encode(gltfData) {
-  const gltfScenegraph = new GLTFScenegraph(gltfData);
-  const {
-    json
-  } = gltfScenegraph;
-
-  if (json.lights) {
-    const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);
-    assert(!extension.lights);
-    extension.lights = json.lights;
-    delete json.lights;
-  }
-
-  if (gltfScenegraph.json.lights) {
-    for (const light of gltfScenegraph.json.lights) {
-      const node = light.node;
-      gltfScenegraph.addObjectExtension(node, KHR_LIGHTS_PUNCTUAL, light);
+exports.decode = decode;
+// Move the light ar ray out of the extension and remove the extension
+async function encode(gltfData) {
+    const gltfScenegraph = new gltf_scenegraph_1.default(gltfData);
+    const { json } = gltfScenegraph;
+    // @ts-ignore
+    if (json.lights) {
+        const extension = gltfScenegraph.addExtension(KHR_LIGHTS_PUNCTUAL);
+        // @ts-ignore
+        (0, assert_1.assert)(!extension.lights);
+        // @ts-ignore
+        extension.lights = json.lights;
+        // @ts-ignore
+        delete json.lights;
+    }
+    // Any nodes that have lights field pointing to light object
+    // add the extension
+    // @ts-ignore
+    if (gltfScenegraph.json.lights) {
+        // @ts-ignore
+        for (const light of gltfScenegraph.json.lights) {
+            const node = light.node;
+            gltfScenegraph.addObjectExtension(node, KHR_LIGHTS_PUNCTUAL, light);
+        }
+        // @ts-ignore
+        delete gltfScenegraph.json.lights;
     }
-
-    delete gltfScenegraph.json.lights;
-  }
 }
-//# sourceMappingURL=KHR_lights_punctual.js.map
+exports.encode = encode;

package/dist/lib/extensions/deprecated/KHR_materials_unlit.js

@@ -1,37 +1,47 @@
-import GLTFScenegraph from '../../api/gltf-scenegraph';
+"use strict";
+// GLTF EXTENSION: KHR_materials_unlit
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.decode = exports.name = void 0;
+const gltf_scenegraph_1 = __importDefault(require("../../api/gltf-scenegraph"));
 const KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';
-export const name = KHR_MATERIALS_UNLIT;
-export async function decode(gltfData) {
-  const gltfScenegraph = new GLTFScenegraph(gltfData);
-  const {
-    json
-  } = gltfScenegraph;
-  gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
-
-  for (const material of json.materials || []) {
-    const extension = material.extensions && material.extensions.KHR_materials_unlit;
-
-    if (extension) {
-      material.unlit = true;
+exports.name = KHR_MATERIALS_UNLIT;
+async function decode(gltfData) {
+    const gltfScenegraph = new gltf_scenegraph_1.default(gltfData);
+    const { json } = gltfScenegraph;
+    // Any nodes that have the extension, add lights field pointing to light object
+    // and remove the extension
+    for (const material of json.materials || []) {
+        const extension = material.extensions && material.extensions.KHR_materials_unlit;
+        if (extension) {
+            // @ts-ignore TODO
+            material.unlit = true;
+        }
+        gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);
     }
-
-    gltfScenegraph.removeObjectExtension(material, KHR_MATERIALS_UNLIT);
-  }
+    // Remove the top-level extension
+    gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
 }
-export function encode(gltfData) {
-  const gltfScenegraph = new GLTFScenegraph(gltfData);
-  const {
-    json
-  } = gltfScenegraph;
-
-  if (gltfScenegraph.materials) {
-    for (const material of json.materials || []) {
-      if (material.unlit) {
-        delete material.unlit;
-        gltfScenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
-        gltfScenegraph.addExtension(KHR_MATERIALS_UNLIT);
-      }
+exports.decode = decode;
+function encode(gltfData) {
+    const gltfScenegraph = new gltf_scenegraph_1.default(gltfData);
+    const { json } = gltfScenegraph;
+    // Any nodes that have lights field pointing to light object
+    // add the extension
+    // @ts-ignore
+    if (gltfScenegraph.materials) {
+        for (const material of json.materials || []) {
+            // @ts-ignore
+            if (material.unlit) {
+                // @ts-ignore
+                delete material.unlit;
+                gltfScenegraph.addObjectExtension(material, KHR_MATERIALS_UNLIT, {});
+                gltfScenegraph.addExtension(KHR_MATERIALS_UNLIT);
+            }
+        }
     }
-  }
 }
-//# sourceMappingURL=KHR_materials_unlit.js.map
+exports.encode = encode;

package/dist/lib/extensions/deprecated/KHR_techniques_webgl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KHR_techniques_webgl.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/deprecated/KHR_techniques_webgl.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAMjD,eAAO,MAAM,IAAI,yBAAuB,CAAC;AAEzC,wBAAsB,MAAM,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BlE;AAED,wBAAsB,MAAM,CAAC,QAAQ,KAAA,EAAE,OAAO,KAAA,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7D"}
+{"version":3,"file":"KHR_techniques_webgl.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/deprecated/KHR_techniques_webgl.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAMjD,eAAO,MAAM,IAAI,yBAAuB,CAAC;AAEzC,wBAAsB,MAAM,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BlE;AAED,wBAAsB,MAAM,CAAC,QAAQ,KAAA,EAAE,OAAO,KAAA,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7D"}

package/dist/lib/extensions/deprecated/KHR_techniques_webgl.js

@@ -1,68 +1,82 @@
-import GLTFScenegraph from '../../api/gltf-scenegraph';
+"use strict";
+// GLTF EXTENSION: KHR_techniques_webgl
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_techniques_webgl
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.decode = exports.name = void 0;
+const gltf_scenegraph_1 = __importDefault(require("../../api/gltf-scenegraph"));
 const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';
-export const name = KHR_TECHNIQUES_WEBGL;
-export async function decode(gltfData) {
-  const gltfScenegraph = new GLTFScenegraph(gltfData);
-  const {
-    json
-  } = gltfScenegraph;
-  const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
-
-  if (extension) {
-    const techniques = resolveTechniques(extension, gltfScenegraph);
-
-    for (const material of json.materials || []) {
-      const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);
-
-      if (materialExtension) {
-        material.technique = Object.assign({}, materialExtension, techniques[materialExtension.technique]);
-        material.technique.values = resolveValues(material.technique, gltfScenegraph);
-      }
-
-      gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+exports.name = KHR_TECHNIQUES_WEBGL;
+async function decode(gltfData) {
+    const gltfScenegraph = new gltf_scenegraph_1.default(gltfData);
+    const { json } = gltfScenegraph;
+    const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
+    if (extension) {
+        const techniques = resolveTechniques(extension, gltfScenegraph);
+        for (const material of json.materials || []) {
+            const materialExtension = gltfScenegraph.getObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+            if (materialExtension) {
+                // @ts-ignore TODO
+                material.technique = Object.assign({}, materialExtension, 
+                // @ts-ignore
+                techniques[materialExtension.technique]);
+                // @ts-ignore TODO
+                material.technique.values = resolveValues(material.technique, gltfScenegraph);
+            }
+            gltfScenegraph.removeObjectExtension(material, KHR_TECHNIQUES_WEBGL);
+        }
+        // Remove the top-level extension
+        gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
     }
-
-    gltfScenegraph.removeExtension(KHR_TECHNIQUES_WEBGL);
-  }
 }
-export async function encode(gltfData, options) {}
-
-function resolveTechniques(techniquesExtension, gltfScenegraph) {
-  const {
-    programs = [],
-    shaders = [],
-    techniques = []
-  } = techniquesExtension;
-  const textDecoder = new TextDecoder();
-  shaders.forEach(shader => {
-    if (Number.isFinite(shader.bufferView)) {
-      shader.code = textDecoder.decode(gltfScenegraph.getTypedArrayForBufferView(shader.bufferView));
-    } else {
-      throw new Error('KHR_techniques_webgl: no shader code');
-    }
-  });
-  programs.forEach(program => {
-    program.fragmentShader = shaders[program.fragmentShader];
-    program.vertexShader = shaders[program.vertexShader];
-  });
-  techniques.forEach(technique => {
-    technique.program = programs[technique.program];
-  });
-  return techniques;
+exports.decode = decode;
+// eslint-disable-next-line
+async function encode(gltfData, options) {
+    // TODO
+}
+exports.encode = encode;
+function resolveTechniques(techniquesExtension, 
+// programs: {[key: string]: any}[],
+// shaders: {[key: string]: any}[],
+// techniques: {[key: string]: any}[]
+gltfScenegraph) {
+    const { programs = [], shaders = [], techniques = [] } = techniquesExtension;
+    const textDecoder = new TextDecoder();
+    shaders.forEach((shader) => {
+        if (Number.isFinite(shader.bufferView)) {
+            shader.code = textDecoder.decode(gltfScenegraph.getTypedArrayForBufferView(shader.bufferView));
+        }
+        else {
+            // TODO: handle URI shader
+            throw new Error('KHR_techniques_webgl: no shader code');
+        }
+    });
+    programs.forEach((program) => {
+        program.fragmentShader = shaders[program.fragmentShader];
+        program.vertexShader = shaders[program.vertexShader];
+    });
+    techniques.forEach((technique) => {
+        technique.program = programs[technique.program];
+    });
+    return techniques;
 }
-
 function resolveValues(technique, gltfScenegraph) {
-  const values = Object.assign({}, technique.values);
-  Object.keys(technique.uniforms || {}).forEach(uniform => {
-    if (technique.uniforms[uniform].value && !(uniform in values)) {
-      values[uniform] = technique.uniforms[uniform].value;
-    }
-  });
-  Object.keys(values).forEach(uniform => {
-    if (typeof values[uniform] === 'object' && values[uniform].index !== undefined) {
-      values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);
-    }
-  });
-  return values;
+    const values = Object.assign({}, technique.values);
+    // merge values from uniforms
+    Object.keys(technique.uniforms || {}).forEach((uniform) => {
+        if (technique.uniforms[uniform].value && !(uniform in values)) {
+            values[uniform] = technique.uniforms[uniform].value;
+        }
+    });
+    // resolve textures
+    Object.keys(values).forEach((uniform) => {
+        if (typeof values[uniform] === 'object' && values[uniform].index !== undefined) {
+            // Assume this is a texture
+            // TODO: find if there are any other types that can be referenced
+            values[uniform].texture = gltfScenegraph.getTexture(values[uniform].index);
+        }
+    });
+    return values;
 }
-//# sourceMappingURL=KHR_techniques_webgl.js.map

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

@@ -1,16 +1,41 @@
-import { assert } from '../utils/assert';
-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);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypedArrayForImageData = exports.getTypedArrayForBufferView = void 0;
+// TODO - GLTFScenegraph should use these
+const assert_1 = require("../utils/assert");
+// accepts buffer view index or buffer view object
+// returns a `Uint8Array`
+function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
+    const bufferView = json.bufferViews[bufferViewIndex];
+    (0, assert_1.assert)(bufferView);
+    // Get hold of the arrayBuffer
+    const bufferIndex = bufferView.buffer;
+    const binChunk = buffers[bufferIndex];
+    (0, assert_1.assert)(binChunk);
+    const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
+    return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
 }
-export function getTypedArrayForImageData(json, buffers, imageIndex) {
-  const image = json.images[imageIndex];
-  const bufferViewIndex = json.bufferViews[image.bufferView];
-  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
+exports.getTypedArrayForBufferView = getTypedArrayForBufferView;
+// accepts accessor index or accessor object
+// returns a `Uint8Array`
+function getTypedArrayForImageData(json, buffers, imageIndex) {
+    const image = json.images[imageIndex];
+    const bufferViewIndex = json.bufferViews[image.bufferView];
+    return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
 }
-//# sourceMappingURL=get-typed-array.js.map
+exports.getTypedArrayForImageData = getTypedArrayForImageData;
+/*
+// accepts accessor index or accessor object
+// returns a typed array with type that matches the types
+export function getTypedArrayForAccessor(accessor) {
+  accessor = this.getAccessor(accessor);
+  const bufferView = this.getBufferView(accessor.bufferView);
+  const buffer = this.getBuffer(bufferView.buffer);
+  const arrayBuffer = buffer.data;
+
+  // Create a new typed array as a view into the combined buffer
+  const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);
+  const byteOffset = bufferView.byteOffset + accessor.byteOffset;
+  return new ArrayType(arrayBuffer, byteOffset, length);
+}
+*/

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

@@ -1,73 +1,73 @@
-import { getAccessorTypeFromSize, getComponentTypeFromArray } from './gltf-utils';
-export function getGLTFAccessors(attributes) {
-  const accessors = {};
-
-  for (const name in attributes) {
-    const attribute = attributes[name];
-
-    if (name !== 'indices') {
-      const glTFAccessor = getGLTFAccessor(attribute);
-      accessors[name] = glTFAccessor;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGLTFAccessor = exports.getGLTFAccessors = void 0;
+// TODO - remove
+const gltf_utils_1 = require("./gltf-utils");
+// Returns a fresh attributes object with glTF-standardized attributes names
+// Attributes that cannot be identified will not be included
+// Removes `indices` if present, as it should be stored separately from the attributes
+function getGLTFAccessors(attributes) {
+    const accessors = {};
+    for (const name in attributes) {
+        const attribute = attributes[name];
+        if (name !== 'indices') {
+            const glTFAccessor = getGLTFAccessor(attribute);
+            accessors[name] = glTFAccessor;
+        }
     }
-  }
-
-  return accessors;
+    return accessors;
 }
-export function getGLTFAccessor(attribute) {
-  const {
-    buffer,
-    size,
-    count
-  } = getAccessorData(attribute);
-  const glTFAccessor = {
-    value: buffer,
-    size,
-    byteOffset: 0,
-    count,
-    type: getAccessorTypeFromSize(size),
-    componentType: getComponentTypeFromArray(buffer)
-  };
-  return glTFAccessor;
+exports.getGLTFAccessors = getGLTFAccessors;
+// Fix up a single accessor.
+// Input: typed array or a partial accessor object
+// Return: accessor object
+function getGLTFAccessor(attribute) {
+    const { buffer, size, count } = getAccessorData(attribute);
+    const glTFAccessor = {
+        // glTF Accessor values
+        // TODO: Instead of a bufferView index we could have an actual buffer (typed array)
+        // bufferView: null,
+        // TODO: Deprecate `value` in favor of bufferView?
+        // @ts-ignore
+        value: buffer,
+        size,
+        byteOffset: 0,
+        count,
+        type: (0, gltf_utils_1.getAccessorTypeFromSize)(size),
+        componentType: (0, gltf_utils_1.getComponentTypeFromArray)(buffer)
+    };
+    return glTFAccessor;
 }
-
+exports.getGLTFAccessor = getGLTFAccessor;
+// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {
+//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];
+// }
 function getAccessorData(attribute) {
-  let buffer = attribute;
-  let size = 1;
-  let count = 0;
-
-  if (attribute && attribute.value) {
-    buffer = attribute.value;
-    size = attribute.size || 1;
-  }
-
-  if (buffer) {
-    if (!ArrayBuffer.isView(buffer)) {
-      buffer = toTypedArray(buffer, Float32Array);
+    let buffer = attribute;
+    let size = 1;
+    let count = 0;
+    if (attribute && attribute.value) {
+        buffer = attribute.value;
+        size = attribute.size || 1;
     }
-
-    count = buffer.length / size;
-  }
-
-  return {
-    buffer,
-    size,
-    count
-  };
+    if (buffer) {
+        if (!ArrayBuffer.isView(buffer)) {
+            buffer = toTypedArray(buffer, Float32Array);
+        }
+        count = buffer.length / size;
+    }
+    return { buffer, size, count };
 }
-
+// Convert non-typed arrays to arrays of specified format
 function toTypedArray(array, ArrayType, convertTypedArrays = false) {
-  if (!array) {
-    return null;
-  }
-
-  if (Array.isArray(array)) {
-    return new ArrayType(array);
-  }
-
-  if (convertTypedArrays && !(array instanceof ArrayType)) {
-    return new ArrayType(array);
-  }
-
-  return array;
+    if (!array) {
+        return null;
+    }
+    if (Array.isArray(array)) {
+        return new ArrayType(array);
+    }
+    if (convertTypedArrays && !(array instanceof ArrayType)) {
+        return new ArrayType(array);
+    }
+    return array;
 }
-//# sourceMappingURL=gltf-attribute-utils.js.map