@loaders.gl/gltf 3.2.7 → 3.3.0-alpha.3

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"}

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/gltf-utils/gltf-constants.d.ts

@@ -1,3 +1,20 @@
+export declare const COMPONENTS: {
+    SCALAR: number;
+    VEC2: number;
+    VEC3: number;
+    VEC4: number;
+    MAT2: number;
+    MAT3: number;
+    MAT4: number;
+};
+export declare const BYTES: {
+    5120: number;
+    5121: number;
+    5122: number;
+    5123: number;
+    5125: number;
+    5126: number;
+};
 export declare function getBytesFromComponentType(componentType: any): any;
 export declare function getSizeFromAccessorType(type: any): any;
 export declare function getGLEnumFromSamplerParameter(parameter: any): any;

package/dist/lib/gltf-utils/gltf-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-constants.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-constants.ts"],"names":[],"mappings":"AAqBA,wBAAgB,yBAAyB,CAAC,aAAa,KAAA,OAEtD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,OAE3C;AAED,wBAAgB,6BAA6B,CAAC,SAAS,KAAA,OActD"}
+{"version":3,"file":"gltf-constants.d.ts","sourceRoot":"","sources":["../../../src/lib/gltf-utils/gltf-constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;CAQtB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;CAOjB,CAAC;AAIF,wBAAgB,yBAAyB,CAAC,aAAa,KAAA,OAEtD;AAED,wBAAgB,uBAAuB,CAAC,IAAI,KAAA,OAE3C;AAED,wBAAgB,6BAA6B,CAAC,SAAS,KAAA,OActD"}

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGLEnumFromSamplerParameter = exports.getSizeFromAccessorType = exports.getBytesFromComponentType = void 0;
-const COMPONENTS = {
+exports.getGLEnumFromSamplerParameter = exports.getSizeFromAccessorType = exports.getBytesFromComponentType = exports.BYTES = exports.COMPONENTS = void 0;
+exports.COMPONENTS = {
     SCALAR: 1,
     VEC2: 2,
     VEC3: 3,
@@ -10,7 +10,7 @@ const COMPONENTS = {
     MAT3: 9,
     MAT4: 16
 };
-const BYTES = {
+exports.BYTES = {
     5120: 1,
     5121: 1,
     5122: 2,
@@ -20,11 +20,11 @@ const BYTES = {
 };
 // ENUM LOOKUP
 function getBytesFromComponentType(componentType) {
-    return BYTES[componentType];
+    return exports.BYTES[componentType];
 }
 exports.getBytesFromComponentType = getBytesFromComponentType;
 function getSizeFromAccessorType(type) {
-    return COMPONENTS[type];
+    return exports.COMPONENTS[type];
 }
 exports.getSizeFromAccessorType = getSizeFromAccessorType;
 function getGLEnumFromSamplerParameter(parameter) {