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

package/dist/lib/extensions/KHR_draco_mesh_compression.js

@@ -1,126 +1,141 @@
-import { DracoLoader } from '@loaders.gl/draco';
-import { sliceArrayBuffer } from '@loaders.gl/loader-utils';
-import { default as Scenegraph } from '../api/gltf-scenegraph';
-import { getGLTFAccessors, getGLTFAccessor } from '../gltf-utils/gltf-attribute-utils';
+"use strict";
+// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
+// Only TRIANGLES: 0x0004 and TRIANGLE_STRIP: 0x0005 are supported
+/* eslint-disable camelcase */
+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.preprocess = exports.name = void 0;
+const draco_1 = require("@loaders.gl/draco");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const gltf_scenegraph_1 = __importDefault(require("../api/gltf-scenegraph"));
+const gltf_attribute_utils_1 = require("../gltf-utils/gltf-attribute-utils");
 const KHR_DRACO_MESH_COMPRESSION = 'KHR_draco_mesh_compression';
-export const name = KHR_DRACO_MESH_COMPRESSION;
-export function preprocess(gltfData, options, context) {
-  const scenegraph = new Scenegraph(gltfData);
-
-  for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
-    if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {}
-  }
+/** Extension name */
+exports.name = KHR_DRACO_MESH_COMPRESSION;
+function preprocess(gltfData, options, context) {
+    const scenegraph = new gltf_scenegraph_1.default(gltfData);
+    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
+        if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
+            // TODO - Remove fallback accessors to make sure we don't load unnecessary buffers
+        }
+    }
 }
-export async function decode(gltfData, options, context) {
-  var _options$gltf;
-
-  if (!(options !== null && options !== void 0 && (_options$gltf = options.gltf) !== null && _options$gltf !== void 0 && _options$gltf.decompressMeshes)) {
-    return;
-  }
-
-  const scenegraph = new Scenegraph(gltfData);
-  const promises = [];
-
-  for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
-    if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
-      promises.push(decompressPrimitive(scenegraph, primitive, options, context));
+exports.preprocess = preprocess;
+async function decode(gltfData, options, context) {
+    if (!options?.gltf?.decompressMeshes) {
+        return;
+    }
+    const scenegraph = new gltf_scenegraph_1.default(gltfData);
+    const promises = [];
+    for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
+        if (scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION)) {
+            promises.push(decompressPrimitive(scenegraph, primitive, options, context));
+        }
     }
-  }
-
-  await Promise.all(promises);
-  scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
+    // Decompress meshes in parallel
+    await Promise.all(promises);
+    // We have now decompressed all primitives, so remove the top-level extension
+    scenegraph.removeExtension(KHR_DRACO_MESH_COMPRESSION);
 }
-export function encode(gltfData, options = {}) {
-  const scenegraph = new Scenegraph(gltfData);
-
-  for (const mesh of scenegraph.json.meshes || []) {
-    compressMesh(mesh, options);
-    scenegraph.addRequiredExtension(KHR_DRACO_MESH_COMPRESSION);
-  }
+exports.decode = decode;
+function encode(gltfData, options = {}) {
+    const scenegraph = new gltf_scenegraph_1.default(gltfData);
+    for (const mesh of scenegraph.json.meshes || []) {
+        // eslint-disable-next-line camelcase
+        // @ts-ignore
+        compressMesh(mesh, options);
+        // NOTE: Only add the extension if something was actually compressed
+        scenegraph.addRequiredExtension(KHR_DRACO_MESH_COMPRESSION);
+    }
 }
-
+exports.encode = encode;
+// DECODE
+// Unpacks one mesh primitive and removes the extension from the primitive
+// DracoDecoder needs to be imported and registered by app
+// Returns: Promise that resolves when all pending draco decoder jobs for this mesh complete
+// TODO - Implement fallback behavior per KHR_DRACO_MESH_COMPRESSION spec
 async function decompressPrimitive(scenegraph, primitive, options, context) {
-  const dracoExtension = scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
-
-  if (!dracoExtension) {
-    return;
-  }
-
-  const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
-  const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset);
-  const {
-    parse
-  } = context;
-  const dracoOptions = { ...options
-  };
-  delete dracoOptions['3d-tiles'];
-  const decodedData = await parse(bufferCopy, DracoLoader, dracoOptions, context);
-  const decodedAttributes = getGLTFAccessors(decodedData.attributes);
-
-  for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
-    if (attributeName in primitive.attributes) {
-      const accessorIndex = primitive.attributes[attributeName];
-      const accessor = scenegraph.getAccessor(accessorIndex);
-
-      if (accessor !== null && accessor !== void 0 && accessor.min && accessor !== null && accessor !== void 0 && accessor.max) {
-        decodedAttribute.min = accessor.min;
-        decodedAttribute.max = accessor.max;
-      }
+    const dracoExtension = scenegraph.getObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
+    if (!dracoExtension) {
+        return;
+    }
+    const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
+    // TODO - parse does not yet deal well with byte offsets embedded in typed arrays. Copy buffer
+    // TODO - remove when `parse` is fixed to handle `byteOffset`s
+    const bufferCopy = (0, loader_utils_1.sliceArrayBuffer)(buffer.buffer, buffer.byteOffset); // , buffer.byteLength);
+    const { parse } = context;
+    const dracoOptions = { ...options };
+    // TODO - remove hack: The entire tileset might be included, too expensive to serialize
+    delete dracoOptions['3d-tiles'];
+    const decodedData = (await parse(bufferCopy, draco_1.DracoLoader, dracoOptions, context));
+    const decodedAttributes = (0, gltf_attribute_utils_1.getGLTFAccessors)(decodedData.attributes);
+    // Restore min/max values
+    for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
+        if (attributeName in primitive.attributes) {
+            const accessorIndex = primitive.attributes[attributeName];
+            const accessor = scenegraph.getAccessor(accessorIndex);
+            if (accessor?.min && accessor?.max) {
+                decodedAttribute.min = accessor.min;
+                decodedAttribute.max = accessor.max;
+            }
+        }
+    }
+    // @ts-ignore
+    primitive.attributes = decodedAttributes;
+    if (decodedData.indices) {
+        // @ts-ignore
+        primitive.indices = (0, gltf_attribute_utils_1.getGLTFAccessor)(decodedData.indices);
     }
-  }
-
-  primitive.attributes = decodedAttributes;
-
-  if (decodedData.indices) {
-    primitive.indices = getGLTFAccessor(decodedData.indices);
-  }
-
-  checkPrimitive(primitive);
+    // Extension has been processed, delete it
+    // delete primitive.extensions[KHR_DRACO_MESH_COMPRESSION];
+    checkPrimitive(primitive);
 }
-
+// ENCODE
+// eslint-disable-next-line max-len
+// Only TRIANGLES: 0x0004 and TRIANGLE_STRIP: 0x0005 are supported
 function compressMesh(attributes, indices, mode = 4, options, context) {
-  var _context$parseSync;
-
-  if (!options.DracoWriter) {
-    throw new Error('options.gltf.DracoWriter not provided');
-  }
-
-  const compressedData = options.DracoWriter.encodeSync({
-    attributes
-  });
-  const decodedData = context === null || context === void 0 ? void 0 : (_context$parseSync = context.parseSync) === null || _context$parseSync === void 0 ? void 0 : _context$parseSync.call(context, {
-    attributes
-  });
-
-  const fauxAccessors = options._addFauxAttributes(decodedData.attributes);
-
-  const bufferViewIndex = options.addBufferView(compressedData);
-  const glTFMesh = {
-    primitives: [{
-      attributes: fauxAccessors,
-      mode,
-      extensions: {
-        [KHR_DRACO_MESH_COMPRESSION]: {
-          bufferView: bufferViewIndex,
-          attributes: fauxAccessors
-        }
-      }
-    }]
-  };
-  return glTFMesh;
+    if (!options.DracoWriter) {
+        throw new Error('options.gltf.DracoWriter not provided');
+    }
+    // TODO - use DracoWriter using encode w/ registered DracoWriter...
+    const compressedData = options.DracoWriter.encodeSync({ attributes });
+    // Draco compression may change the order and number of vertices in a mesh.
+    // To satisfy the requirement that accessors properties be correct for both
+    // compressed and uncompressed data, generators should create uncompressed
+    // attributes and indices using data that has been decompressed from the Draco buffer,
+    // rather than the original source data.
+    // @ts-ignore TODO this needs to be fixed
+    const decodedData = context?.parseSync?.({ attributes });
+    const fauxAccessors = options._addFauxAttributes(decodedData.attributes);
+    const bufferViewIndex = options.addBufferView(compressedData);
+    const glTFMesh = {
+        primitives: [
+            {
+                attributes: fauxAccessors,
+                mode,
+                extensions: {
+                    [KHR_DRACO_MESH_COMPRESSION]: {
+                        bufferView: bufferViewIndex,
+                        attributes: fauxAccessors // TODO - verify with spec
+                    }
+                }
+            }
+        ]
+    };
+    return glTFMesh;
 }
-
+// UTILS
 function checkPrimitive(primitive) {
-  if (!primitive.attributes && Object.keys(primitive.attributes).length > 0) {
-    throw new Error('glTF: Empty primitive detected: Draco decompression failure?');
-  }
+    if (!primitive.attributes && Object.keys(primitive.attributes).length > 0) {
+        throw new Error('glTF: Empty primitive detected: Draco decompression failure?');
+    }
 }
-
 function* makeMeshPrimitiveIterator(scenegraph) {
-  for (const mesh of scenegraph.json.meshes || []) {
-    for (const primitive of mesh.primitives) {
-      yield primitive;
+    for (const mesh of scenegraph.json.meshes || []) {
+        for (const primitive of mesh.primitives) {
+            yield primitive;
+        }
     }
-  }
 }
-//# sourceMappingURL=KHR_draco_mesh_compression.js.map

package/dist/lib/extensions/KHR_texture_basisu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KHR_texture_basisu.d.ts","sourceRoot":"","sources":["../../../src/lib/extensions/KHR_texture_basisu.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAA0B,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAMzD,qBAAqB;AACrB,eAAO,MAAM,IAAI,uBAAqB,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAiBnF"}
+{"version":3,"file":"KHR_texture_basisu.d.ts","sourceRoot":"","sources":["../../../src/lib/extensions/KHR_texture_basisu.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAA0B,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAMzD,qBAAqB;AACrB,eAAO,MAAM,IAAI,uBAAqB,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAkBnF"}

package/dist/lib/extensions/KHR_texture_basisu.js

@@ -1,22 +1,32 @@
-import GLTFScenegraph from '../api/gltf-scenegraph';
+"use strict";
+// GLTF EXTENSION: KHR_texture_basisu
+// https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_basisu
+/* eslint-disable camelcase */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocess = exports.name = void 0;
+const gltf_scenegraph_1 = __importDefault(require("../api/gltf-scenegraph"));
 const KHR_TEXTURE_BASISU = 'KHR_texture_basisu';
-export const name = KHR_TEXTURE_BASISU;
-export function preprocess(gltfData, options) {
-  const scene = new GLTFScenegraph(gltfData);
-  const {
-    json
-  } = scene;
-
-  for (const texture of json.textures || []) {
-    const extension = scene.getObjectExtension(texture, KHR_TEXTURE_BASISU);
-
-    if (extension) {
-      texture.source = extension.source;
+/** Extension name */
+exports.name = KHR_TEXTURE_BASISU;
+/**
+ * Replaces a texture source reference with the extension texture
+ * Done in preprocess() to prevent load of default image
+ */
+function preprocess(gltfData, options) {
+    const scene = new gltf_scenegraph_1.default(gltfData);
+    const { json } = scene;
+    for (const texture of json.textures || []) {
+        const extension = scene.getObjectExtension(texture, KHR_TEXTURE_BASISU);
+        if (extension) {
+            // TODO - if multiple texture extensions are present which one wins?
+            texture.source = extension.source;
+        }
+        scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
     }
-
-    scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
-  }
-
-  scene.removeExtension(KHR_TEXTURE_BASISU);
+    // Remove the top-level extension
+    scene.removeExtension(KHR_TEXTURE_BASISU);
 }
-//# sourceMappingURL=KHR_texture_basisu.js.map
+exports.preprocess = preprocess;

package/dist/lib/extensions/KHR_texture_transform.d.ts

@@ -0,0 +1,13 @@
+/**
+ * https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_transform/README.md
+ */
+import type { GLTFWithBuffers } from '../types/gltf-types';
+import type { GLTFLoaderOptions } from '../../gltf-loader';
+export declare const name = "KHR_texture_transform";
+/**
+ * The extension entry to process the transformation
+ * @param gltfData gltf buffers and json
+ * @param options GLTFLoader options
+ */
+export declare function decode(gltfData: GLTFWithBuffers, options: GLTFLoaderOptions): Promise<void>;
+//# sourceMappingURL=KHR_texture_transform.d.ts.map

package/dist/lib/extensions/KHR_texture_transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KHR_texture_transform.d.ts","sourceRoot":"","sources":["../../../src/lib/extensions/KHR_texture_transform.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAoB,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAC5E,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAezD,eAAO,MAAM,IAAI,0BAAwB,CAAC;AA+B1C;;;;GAIG;AACH,wBAAsB,MAAM,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,iBAAiB,iBAUjF"}

package/dist/lib/extensions/KHR_texture_transform.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_transform/README.md
+ */
+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 core_1 = require("@math.gl/core");
+const gltf_utils_1 = require("../gltf-utils/gltf-utils");
+const gltf_constants_1 = require("../gltf-utils/gltf-constants");
+const gltf_scenegraph_1 = __importDefault(require("../api/gltf-scenegraph"));
+/** Extension name */
+const EXT_MESHOPT_TRANSFORM = 'KHR_texture_transform';
+exports.name = EXT_MESHOPT_TRANSFORM;
+const scratchVector = new core_1.Vector3();
+const scratchRotationMatrix = new core_1.Matrix3();
+const scratchScaleMatrix = new core_1.Matrix3();
+/**
+ * The extension entry to process the transformation
+ * @param gltfData gltf buffers and json
+ * @param options GLTFLoader options
+ */
+async function decode(gltfData, options) {
+    const gltfScenegraph = new gltf_scenegraph_1.default(gltfData);
+    const extension = gltfScenegraph.getExtension(EXT_MESHOPT_TRANSFORM);
+    if (!extension) {
+        return;
+    }
+    const materials = gltfData.json.materials || [];
+    for (let i = 0; i < materials.length; i++) {
+        transformTexCoords(i, gltfData);
+    }
+}
+exports.decode = decode;
+/**
+ * Transform TEXCOORD by material
+ * @param materialIndex processing material index
+ * @param gltfData gltf buffers and json
+ */
+function transformTexCoords(materialIndex, gltfData) {
+    // Save processed texCoords in order no to process the same twice
+    const processedTexCoords = [];
+    const material = gltfData.json.materials?.[materialIndex];
+    const baseColorTexture = material?.pbrMetallicRoughness?.baseColorTexture;
+    if (baseColorTexture) {
+        transformPrimitives(gltfData, materialIndex, baseColorTexture, processedTexCoords);
+    }
+    const emisiveTexture = material?.emissiveTexture;
+    if (emisiveTexture) {
+        transformPrimitives(gltfData, materialIndex, emisiveTexture, processedTexCoords);
+    }
+    const normalTexture = material?.normalTexture;
+    if (normalTexture) {
+        transformPrimitives(gltfData, materialIndex, normalTexture, processedTexCoords);
+    }
+    const occlusionTexture = material?.occlusionTexture;
+    if (occlusionTexture) {
+        transformPrimitives(gltfData, materialIndex, occlusionTexture, processedTexCoords);
+    }
+    const metallicRoughnessTexture = material?.pbrMetallicRoughness?.metallicRoughnessTexture;
+    if (metallicRoughnessTexture) {
+        transformPrimitives(gltfData, materialIndex, metallicRoughnessTexture, processedTexCoords);
+    }
+}
+/**
+ * Transform primitives of the particular material
+ * @param gltfData gltf data
+ * @param materialIndex primitives with this material will be transformed
+ * @param texture texture object
+ * @param processedTexCoords storage to save already processed texCoords
+ */
+function transformPrimitives(gltfData, materialIndex, texture, processedTexCoords) {
+    const transformParameters = getTransformParameters(texture, processedTexCoords);
+    if (!transformParameters) {
+        return;
+    }
+    const meshes = gltfData.json.meshes || [];
+    for (const mesh of meshes) {
+        for (const primitive of mesh.primitives) {
+            const material = primitive.material;
+            if (Number.isFinite(material) && materialIndex === material) {
+                transformPrimitive(gltfData, primitive, transformParameters);
+            }
+        }
+    }
+}
+/**
+ * Get parameters for TEXCOORD transformation
+ * @param texture texture object
+ * @param processedTexCoords storage to save already processed texCoords
+ * @returns texCoord couple and transformation matrix
+ */
+function getTransformParameters(texture, processedTexCoords) {
+    const textureInfo = texture.extensions?.[EXT_MESHOPT_TRANSFORM];
+    const { texCoord: originalTexCoord = 0 } = texture;
+    // If texCoord is not set in the extension, original attribute data will be replaced
+    const { texCoord = originalTexCoord } = textureInfo;
+    // Make sure that couple [originalTexCoord, extensionTexCoord] is not processed twice
+    const isProcessed = processedTexCoords.findIndex(([original, newTexCoord]) => original === originalTexCoord && newTexCoord === texCoord) !== -1;
+    if (!isProcessed) {
+        const matrix = makeTransformationMatrix(textureInfo);
+        if (originalTexCoord !== texCoord) {
+            texture.texCoord = texCoord;
+        }
+        processedTexCoords.push([originalTexCoord, texCoord]);
+        return { originalTexCoord, texCoord, matrix };
+    }
+    return null;
+}
+/**
+ * Transform `TEXCOORD_0` attribute in the primitive
+ * @param gltfData gltf data
+ * @param primitive primitive object
+ * @param transformParameters texCoord couple and transformation matrix
+ */
+function transformPrimitive(gltfData, primitive, transformParameters) {
+    const { originalTexCoord, texCoord, matrix } = transformParameters;
+    const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];
+    if (Number.isFinite(texCoordAccessor)) {
+        // Get accessor of the `TEXCOORD_0` attribute
+        const accessor = gltfData.json.accessors?.[texCoordAccessor];
+        if (accessor && accessor.bufferView) {
+            // Get `bufferView` of the `accessor`
+            const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
+            if (bufferView) {
+                // Get `arrayBuffer` the `bufferView` look at
+                const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
+                // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets
+                const byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+                // Deduce TypedArray type and its length from `accessor` and `bufferView` data
+                const { ArrayType, length } = (0, gltf_utils_1.getAccessorArrayTypeAndLength)(accessor, bufferView);
+                // Number of bytes each component occupies
+                const bytes = gltf_constants_1.BYTES[accessor.componentType];
+                // Number of components. For the `TEXCOORD_0` with `VEC2` type, it must return 2
+                const components = gltf_constants_1.COMPONENTS[accessor.type];
+                // Multiplier to calculate the address of the `TEXCOORD_0` element in the arrayBuffer
+                const elementAddressScale = bufferView.byteStride || bytes * components;
+                // Data transform to Float32Array
+                const result = new Float32Array(length);
+                for (let i = 0; i < accessor.count; i++) {
+                    // Take [u, v] couple from the arrayBuffer
+                    const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);
+                    // Set and transform Vector3 per https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_texture_transform#overview
+                    scratchVector.set(uv[0], uv[1], 1);
+                    scratchVector.transformByMatrix3(matrix);
+                    // Save result in Float32Array
+                    result.set([scratchVector[0], scratchVector[1]], i * components);
+                }
+                // If texCoord the same, replace gltf structural data
+                if (originalTexCoord === texCoord) {
+                    updateGltf(accessor, bufferView, gltfData.buffers, result);
+                }
+                else {
+                    // If texCoord change, create new attribute
+                    createAttribute(texCoord, accessor, primitive, gltfData, result);
+                }
+            }
+        }
+    }
+}
+/**
+ * Update GLTF structural objects with new data as we create new `Float32Array` for `TEXCOORD_0`.
+ * @param accessor accessor to change
+ * @param bufferView bufferView to change
+ * @param buffers binary buffers
+ * @param newTexcoordArray typed array with data after transformation
+ */
+function updateGltf(accessor, bufferView, buffers, newTexCoordArray) {
+    accessor.componentType = 5126;
+    buffers.push({
+        arrayBuffer: newTexCoordArray.buffer,
+        byteOffset: 0,
+        byteLength: newTexCoordArray.buffer.byteLength
+    });
+    bufferView.buffer = buffers.length - 1;
+    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+    bufferView.byteOffset = 0;
+    delete bufferView.byteStride;
+}
+/**
+ *
+ * @param newTexCoord new `texCoord` value
+ * @param originalAccessor original accessor object, that store data before transformation
+ * @param primitive primitive object
+ * @param gltfData gltf data
+ * @param newTexCoordArray typed array with data after transformation
+ * @returns
+ */
+function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, newTexCoordArray) {
+    gltfData.buffers.push({
+        arrayBuffer: newTexCoordArray.buffer,
+        byteOffset: 0,
+        byteLength: newTexCoordArray.buffer.byteLength
+    });
+    const bufferViews = gltfData.json.bufferViews;
+    if (!bufferViews) {
+        return;
+    }
+    bufferViews.push({
+        buffer: gltfData.buffers.length - 1,
+        byteLength: newTexCoordArray.buffer.byteLength,
+        byteOffset: 0
+    });
+    const accessors = gltfData.json.accessors;
+    if (!accessors) {
+        return;
+    }
+    accessors.push({
+        bufferView: bufferViews?.length - 1,
+        byteOffset: 0,
+        componentType: 5126,
+        count: originalAccessor.count,
+        type: 'VEC2'
+    });
+    primitive.attributes[`TEXCOORD_${newTexCoord}`] = accessors.length - 1;
+}
+/**
+ * Construct transformation matrix from the extension data (transition, rotation, scale)
+ * @param extensionData extension data
+ * @returns transformation matrix
+ */
+function makeTransformationMatrix(extensionData) {
+    const { offset = [0, 0], rotation = 0, scale = [1, 1] } = extensionData;
+    const translationMatirx = new core_1.Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
+    const rotationMatirx = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
+    const scaleMatrix = scratchScaleMatrix.set(scale[0], 0, 0, 0, scale[1], 0, 0, 0, 1);
+    return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
+}

package/dist/lib/extensions/deprecated/EXT_feature_metadata.d.ts

@@ -0,0 +1,6 @@
+import type { GLTF } from '../../types/gltf-types';
+export declare const name = "EXT_feature_metadata";
+export declare function decode(gltfData: {
+    json: GLTF;
+}): Promise<void>;
+//# sourceMappingURL=EXT_feature_metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EXT_feature_metadata.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/deprecated/EXT_feature_metadata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,wBAAwB,CAAC;AAcjD,eAAO,MAAM,IAAI,yBAAuB,CAAC;AAEzC,wBAAsB,MAAM,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAGlE"}