@loaders.gl/gltf 4.0.0-alpha.21 → 4.0.0-alpha.23

package/dist/lib/extensions/data-processing.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.primitivePropertyDataToAttributes = exports.getPrimitiveTextureData = exports.convertRawBufferToMetadataArray = exports.getArrayElementByteSize = void 0;
+const gltf_utils_1 = require("../gltf-utils/gltf-utils");
+const images_1 = require("@loaders.gl/images");
+const math_1 = require("@loaders.gl/math");
+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
+};
+function getArrayElementByteSize(attributeType, componentType) {
+    return (ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] *
+        ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType]);
+}
+exports.getArrayElementByteSize = getArrayElementByteSize;
+/**
+ * Converts raw bytes that are in the buffer to an array of the type defined by the schema.
+ * @param {Uint8Array} typedArray - raw bytes in the buffer
+ * @param {string} attributeType - SCALAR, VECN, MATN
+ * @param {string} componentType - type of the component in elements, e.g. 'UINT8' or 'FLOAT32'
+ * @param {number} elementCount - number of elements in the array. Default value is 1.
+ * @returns {TypedArray} Data array
+ */
+function convertRawBufferToMetadataArray(typedArray, attributeType, componentType, elementCount = 1) {
+    const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];
+    const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];
+    const length = elementCount * numberOfComponents;
+    const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];
+    // the buffer view `byteOffset` must be aligned to a multiple of the `componentType` size.
+    const offset = typedArray.byteOffset % size
+        ? Math.ceil(typedArray.byteOffset / size) * size
+        : typedArray.byteOffset;
+    return new ArrayType(typedArray.buffer, offset, length);
+}
+exports.convertRawBufferToMetadataArray = convertRawBufferToMetadataArray;
+/**
+ * Processes data encoded in the texture associated with the primitive.
+ * If Ext_mesh_featues is combined with the Ext_structural_metadata, propertyTable will also be processed.
+ * @param {GLTFScenegraph} scenegraph - Instance of the class for structured access to GLTF data.
+ * @param {GLTFTextureInfoMetadata} textureInfo - reference to the texture where extension data are stored.
+ * @param {GLTFMeshPrimitive} primitive - primitive object in the mesh
+ * @returns {number[] | null} Array of data taken. Null if data can't be taken from the texture.
+ */
+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. These data are 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.
+    */
+    const json = scenegraph.gltf.json;
+    const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
+    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
+    // textureCoordinates array contains UV coordinates of the actual data stored in the texture
+    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+    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 null;
+}
+exports.getPrimitiveTextureData = getPrimitiveTextureData;
+/**
+ * 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 {GLTFScenegraph} scenegraph - scenegraph object
+ * @param {string} attributeName - name of the attribute
+ * @param {number[]} propertyData - property data to store
+ * @param {number[]} featureTable - an array where unique data from the property data are being stored
+ * @param {GLTFMeshPrimitive} primitive - primitive object
+ */
+function primitivePropertyDataToAttributes(scenegraph, attributeName, propertyData, featureTable, primitive) {
+    if (propertyData === null)
+        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 bufferIndex = scenegraph.gltf.buffers.push({
+        arrayBuffer: typedArray.buffer,
+        byteOffset: typedArray.byteOffset,
+        byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+        size: 1,
+        componentType: (0, gltf_utils_1.getComponentTypeFromArray)(typedArray),
+        count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+}
+exports.primitivePropertyDataToAttributes = primitivePropertyDataToAttributes;
+/**
+ * Gets the value from the texture by coordinates provided.
+ * @param {ImageType} parsedImage - image where the data are stored.
+ * @param {string | undefined} mimeType - MIME type
+ * @param {Float32Array} textureCoordinates - uv coordinates to access data in the image.
+ * @param {number} index - index of uv coordinates in the array textureCoordinates
+ * @param {channels} channels - image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.
+ * @returns {number} Value taken from the image.
+ */
+function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels = [0]) {
+    const CHANNELS_MAP = [
+        { offset: 0, shift: 0 },
+        { offset: 1, shift: 8 },
+        { offset: 2, shift: 16 },
+        { 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 = CHANNELS_MAP[c];
+        const imageOffset = offset + map.offset;
+        const imageData = (0, images_1.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 = (0, math_1.emod)(u) * (w - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = (0, math_1.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;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"EXT_feature_metadata.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/deprecated/EXT_feature_metadata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,IAAI,EAQL,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAKvD,eAAO,MAAM,IAAI,yBAAuB,CAAC;AAEzC,wBAAsB,MAAM,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9F"}
+{"version":3,"file":"EXT_feature_metadata.d.ts","sourceRoot":"","sources":["../../../../src/lib/extensions/deprecated/EXT_feature_metadata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,IAAI,EAQL,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAKvD,eAAO,MAAM,IAAI,yBAA4B,CAAC;AAE9C,wBAAsB,MAAM,CAAC,QAAQ,EAAE;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAG9F"}

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

@@ -4,9 +4,10 @@ exports.decode = exports.name = void 0;
 const gltf_scenegraph_1 = require("../../api/gltf-scenegraph");
 const images_1 = require("@loaders.gl/images");
 const gltf_utils_1 = require("../../gltf-utils/gltf-utils");
+const math_1 = require("@loaders.gl/math");
 /** Extension name */
-const EXT_FEATURE_METADATA = 'EXT_feature_metadata';
-exports.name = EXT_FEATURE_METADATA;
+const EXT_FEATURE_METADATA_NAME = 'EXT_feature_metadata';
+exports.name = EXT_FEATURE_METADATA_NAME;
 async function decode(gltfData, options) {
     const scenegraph = new gltf_scenegraph_1.GLTFScenegraph(gltfData);
     decodeExtFeatureMetadata(scenegraph, options);
@@ -17,7 +18,7 @@ exports.decode = decode;
  * @param scenegraph
  */
 function decodeExtFeatureMetadata(scenegraph, options) {
-    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
+    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA_NAME);
     if (!extension)
         return;
     const schemaClasses = extension.schema?.classes;
@@ -43,7 +44,7 @@ function decodeExtFeatureMetadata(scenegraph, options) {
     }
 }
 /**
- * Navigate throw all properies in feature table and gets properties data.
+ * Navigates through all properies in feature table and gets properties data.
  * @param scenegraph
  * @param featureTable
  * @param schemaClass
@@ -60,7 +61,7 @@ function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
     }
 }
 /**
- * Navigate throw all properies in feature texture and gets properties data.
+ * Navigates through all properies in feature texture and gets properties data.
  * Data will be stored in featureTexture.properties[propertyName].data
  * @param scenegraph
  * @param featureTexture
@@ -224,26 +225,16 @@ function getVal(parsedImage, offset) {
 }
 function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
     const w = parsedImage.width;
-    const iX = emod(u) * (w - 1);
+    const iX = (0, math_1.emod)(u) * (w - 1);
     const indX = Math.round(iX);
     const h = parsedImage.height;
-    const iY = emod(v) * (h - 1);
+    const iY = (0, math_1.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;
 }
-// The following is taken from tile-converter\src\i3s-converter\helpers\batch-ids-extensions.ts
-/**
- * Handle UVs if they are out of range [0,1].
- * @param n
- * @param m
- */
-function emod(n) {
-    const a = ((n % 1) + 1) % 1;
-    return a;
-}
 /**
  * Find the feature table by class name.
  * @param featureTables

package/dist/lib/parsers/parse-gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-gltf.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAajD,OAAO;AACP,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE7B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,KAAK,CAAC;CACrB,CAAC;AAEF,4DAA4D;AAC5D,wBAAgB,MAAM,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAGpF;AAED,wBAAsB,SAAS,CAC7B,IAAI,EAAE,eAAe,EACrB,mBAAmB,KAAA,EACnB,UAAU,oBAAI,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,eAAe,CAAC,CAqB1B"}
+{"version":3,"file":"parse-gltf.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-gltf.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,aAAa,CAAC;AAcjD,OAAO;AACP,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE7B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,KAAK,CAAC;CACrB,CAAC;AAEF,4DAA4D;AAC5D,wBAAgB,MAAM,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAGpF;AAED,wBAAsB,SAAS,CAC7B,IAAI,EAAE,eAAe,EACrB,mBAAmB,KAAA,EACnB,UAAU,oBAAI,EACd,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,eAAe,CAAC,CAqB1B"}

package/dist/lib/parsers/parse-gltf.js

@@ -145,10 +145,10 @@ function getReferencesImageIndices(gltf) {
 }
 /** Asynchronously fetches and parses one image, store in images array outside of json */
 async function loadImage(gltf, image, index, options, context) {
-    const { fetch, parse } = context;
     let arrayBuffer;
     if (image.uri && !image.hasOwnProperty('bufferView')) {
         const uri = (0, resolve_url_1.resolveUrl)(image.uri, options);
+        const { fetch } = context;
         const response = await fetch(uri);
         arrayBuffer = await response.arrayBuffer();
         image.bufferView = {
@@ -161,14 +161,15 @@ async function loadImage(gltf, image, index, options, context) {
     }
     (0, assert_1.assert)(arrayBuffer, 'glTF image has no data');
     // Call `parse`
-    let parsedImage = await parse(arrayBuffer, [images_1.ImageLoader, textures_1.BasisLoader], {
+    let parsedImage = (await (0, loader_utils_1.parseFromContext)(arrayBuffer, [images_1.ImageLoader, textures_1.BasisLoader], {
         ...options,
         mimeType: image.mimeType,
         basis: options.basis || { format: (0, textures_1.selectSupportedBasisFormat)() }
-    }, context);
+    }, context));
     if (parsedImage && parsedImage[0]) {
         parsedImage = {
             compressed: true,
+            // @ts-expect-error
             mipmaps: false,
             width: parsedImage[0].width,
             height: parsedImage[0].height,
@@ -179,5 +180,6 @@ async function loadImage(gltf, image, index, options, context) {
     // const parsedImage = await parse(arrayBuffer, [ImageLoader]);
     // Store the loaded image
     gltf.images = gltf.images || [];
+    // @ts-expect-error TODO - sort out image typing asap
     gltf.images[index] = parsedImage;
 }

package/dist/lib/types/gltf-ext-mesh-features-schema.d.ts

@@ -0,0 +1,45 @@
+import { GLTFTextureInfoMetadata } from './gltf-json-schema';
+/**
+ * EXT_mesh_features extension types
+ * This is a primitive-level extension
+ * @see https://github.com/CesiumGS/glTF/tree/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features
+ * or https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_mesh_features/schema/mesh.primitive.EXT_mesh_features.schema.json
+ * An object describing feature IDs for a mesh primitive.
+ */
+export type GLTF_EXT_mesh_features = {
+    /** An array of feature ID sets. */
+    featureIds: GLTF_EXT_mesh_features_featureId[];
+    extensions?: Record<string, unknown>;
+    extras?: unknown;
+    /** For internal usage */
+    dataAttributeNames?: string[];
+};
+/**
+ * @see https://github.com/CesiumGS/glTF/blob/c38f7f37e894004353c15cd0481bc5b7381ce841/extensions/2.0/Vendor/EXT_mesh_features/schema/featureId.schema.json
+ * Feature IDs stored in an attribute or texture.
+ */
+export type GLTF_EXT_mesh_features_featureId = {
+    /** The number of unique features in the attribute or texture. */
+    featureCount: number;
+    /** A value that indicates that no feature is associated with this vertex or texel. */
+    nullFeatureId?: number;
+    /** A label assigned to this feature ID set. Labels must be alphanumeric identifiers matching the regular expression `^[a-zA-Z_][a-zA-Z0-9_]*$`. */
+    label?: string;
+    /**
+     * An attribute containing feature IDs.
+     * When `attribute` and `texture` are omitted the feature IDs are assigned to vertices by their index.
+     * @see https://github.com/CesiumGS/glTF/blob/3d-tiles-next/extensions/2.0/Vendor/EXT_mesh_features/schema/featureIdAttribute.schema.json
+     * An integer value used to construct a string in the format `_FEATURE_ID_<set index>` which is a reference to a key in `mesh.primitives.attributes`
+     * (e.g. a value of `0` corresponds to `_FEATURE_ID_0`).
+     */
+    attribute?: number;
+    /** A texture containing feature IDs. */
+    texture?: GLTFTextureInfoMetadata;
+    /** The index of the property table containing per-feature property values. Only applicable when using the `EXT_structural_metadata` extension. */
+    propertyTable?: number;
+    extensions?: Record<string, unknown>;
+    extras?: unknown;
+    /** For internal usage */
+    data?: unknown;
+};
+//# sourceMappingURL=gltf-ext-mesh-features-schema.d.ts.map

package/dist/lib/types/gltf-ext-mesh-features-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-ext-mesh-features-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/types/gltf-ext-mesh-features-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,oBAAoB,CAAC;AAG3D;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,mCAAmC;IACnC,UAAU,EAAE,gCAAgC,EAAE,CAAC;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,yBAAyB;IACzB,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gCAAgC,GAAG;IAC7C,iEAAiE;IACjE,YAAY,EAAE,MAAM,CAAC;IACrB,sFAAsF;IACtF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mJAAmJ;IACnJ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wCAAwC;IACxC,OAAO,CAAC,EAAE,uBAAuB,CAAC;IAClC,kJAAkJ;IAClJ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,yBAAyB;IACzB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC"}

package/dist/lib/types/gltf-ext-mesh-features-schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });