@babylonjs/loaders 9.26.0 → 9.26.2

package/USD/usdSceneMaterializer.js

@@ -4,12 +4,15 @@ import { AnimationGroup } from "@babylonjs/core/Animations/animationGroup.pure.j
 import { AbstractAssetContainer, AssetContainer } from "@babylonjs/core/assetContainer.js";
 import { Bone } from "@babylonjs/core/Bones/bone.js";
 import { Skeleton } from "@babylonjs/core/Bones/skeleton.js";
-import { Color3 } from "@babylonjs/core/Maths/math.color.pure.js";
+import { Color3, Color4 } from "@babylonjs/core/Maths/math.color.pure.js";
 import { Matrix, Quaternion, Vector3 } from "@babylonjs/core/Maths/math.vector.pure.js";
 import { Material } from "@babylonjs/core/Materials/material.pure.js";
 import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.pure.js";
 import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.pure.js";
 import { Texture } from "@babylonjs/core/Materials/Textures/texture.pure.js";
+import { CreateFactorOperand, CreateTextureOperand, LerpTexturesAsync, TextureChannel, TextureColorSpace, } from "@babylonjs/core/Materials/Textures/textureProcessor.js";
+import { MorphTarget } from "@babylonjs/core/Morph/morphTarget.js";
+import { MorphTargetManager } from "@babylonjs/core/Morph/morphTargetManager.js";
 import { CreateBox } from "@babylonjs/core/Meshes/Builders/boxBuilder.pure.js";
 import { CreateCylinder } from "@babylonjs/core/Meshes/Builders/cylinderBuilder.pure.js";
 import { CreateSphere } from "@babylonjs/core/Meshes/Builders/sphereBuilder.pure.js";
@@ -17,6 +20,7 @@ import { Mesh } from "@babylonjs/core/Meshes/mesh.pure.js";
 import { SubMesh } from "@babylonjs/core/Meshes/subMesh.js";
 import { TransformNode } from "@babylonjs/core/Meshes/transformNode.pure.js";
 import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData.js";
+import { Constants } from "@babylonjs/core/Engines/constants.js";
 import { MISSING_OFFSET, PayloadReader, readCommands, } from "./usdCommandProtocol.js";
 class DirectAssetContainer extends AbstractAssetContainer {
     dispose() {
@@ -26,6 +30,9 @@ class DirectAssetContainer extends AbstractAssetContainer {
         for (const mesh of this.meshes.splice(0)) {
             mesh.dispose();
         }
+        for (const manager of this.morphTargetManagers.splice(0)) {
+            manager.dispose();
+        }
         for (const skeleton of this.skeletons.splice(0)) {
             skeleton.dispose();
         }
@@ -92,6 +99,27 @@ function wrapMode(value) {
             throw new Error(`Invalid texture wrap mode ${value}.`);
     }
 }
+async function awaitAbortableAsync(promise, signal) {
+    if (!signal) {
+        return await promise;
+    }
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason instanceof Error ? signal.reason : new Error("USD materialization was aborted."));
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted) {
+            onAbort();
+        }
+    });
+    try {
+        return await Promise.race([promise, aborted]);
+    }
+    finally {
+        if (onAbort) {
+            signal.removeEventListener("abort", onAbort);
+        }
+    }
+}
 export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer, addToScene, signal) {
     signal?.throwIfAborted();
     const started = performance.now();
@@ -106,12 +134,25 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
     const bones = new Map();
     const geometries = new Map();
     const meshes = new Map();
+    const morphTargetManagers = new Map();
+    const morphTargets = new Map();
+    const classicInstanceSources = new Set();
+    const thinInstanceSources = new Set();
     const animationGroups = new Map();
     const textureLoads = [];
     const textureUrls = new Set();
+    const materialTextureBindings = [];
+    const processedTextures = new Map();
     const assetContainer = container instanceof AssetContainer ? container : undefined;
     let root;
     let timeCodesPerSecond = 24;
+    let rollingBack = false;
+    const caps = scene.getEngine().getCaps();
+    const processedTextureType = caps.textureHalfFloatRender && caps.textureHalfFloatLinearFiltering
+        ? Constants.TEXTURETYPE_HALF_FLOAT
+        : caps.textureFloatRender && caps.textureFloatLinearFiltering
+            ? Constants.TEXTURETYPE_FLOAT
+            : Constants.TEXTURETYPE_UNSIGNED_BYTE;
     const trackAsset = (assets, asset) => {
         assets.push(asset);
         if (assetContainer) {
@@ -137,6 +178,255 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
         }
         return variant;
     };
+    const binding = (textureId, channel, label) => {
+        if (textureId === MISSING_OFFSET) {
+            if (channel !== MISSING_OFFSET) {
+                throw new Error(`USD ${label} binding has a channel without a texture.`);
+            }
+            return undefined;
+        }
+        const descriptor = textures.get(textureId);
+        if (!descriptor) {
+            throw new Error(`USD ${label} binding references missing texture ${textureId}.`);
+        }
+        if (channel < 0 /* TextureOutputChannel.R */ || channel > 4 /* TextureOutputChannel.RGB */) {
+            throw new Error(`USD ${label} binding has invalid output channel ${channel}.`);
+        }
+        return { descriptor, channel };
+    };
+    const channelIndex = (channel) => {
+        if (channel === 4 /* TextureOutputChannel.RGB */) {
+            throw new Error("A scalar USD texture binding cannot use the RGB output.");
+        }
+        return channel;
+    };
+    const processorChannel = (channel) => {
+        switch (channel) {
+            case 0 /* TextureOutputChannel.R */:
+                return TextureChannel.R;
+            case 1 /* TextureOutputChannel.G */:
+                return TextureChannel.G;
+            case 2 /* TextureOutputChannel.B */:
+                return TextureChannel.B;
+            case 3 /* TextureOutputChannel.A */:
+                return TextureChannel.A;
+            default:
+                return TextureChannel.RGBA;
+        }
+    };
+    const processorColorSpace = (descriptor) => descriptor.sourceColorSpace === 1 /* USDTextureColorSpace.Raw */ ? TextureColorSpace.Linear : TextureColorSpace.SRGB;
+    const scalarTextureIsLinear = (binding) => binding.descriptor.sourceColorSpace === 1 /* USDTextureColorSpace.Raw */;
+    const valueTransformIs = (descriptor, scale, bias) => scale.every((value, index) => descriptor.scale[index] === value) && bias.every((value, index) => descriptor.bias[index] === value);
+    const trackProcessedTexture = (texture) => {
+        trackAsset(container.textures, texture);
+        return texture;
+    };
+    const processTextureAsync = async (name, binding, scale, bias, channel = binding.channel, preserveRange = false) => {
+        const source = binding.descriptor;
+        const size = source.texture.getSize();
+        const supportsMipMaps = !scene.getEngine().needPOTTextures || ((size.width & (size.width - 1)) === 0 && (size.height & (size.height - 1)) === 0);
+        const outputOptions = {
+            textureType: preserveRange ? processedTextureType : Constants.TEXTURETYPE_UNSIGNED_BYTE,
+            samplingMode: supportsMipMaps ? Constants.TEXTURE_TRILINEAR_SAMPLINGMODE : Constants.TEXTURE_BILINEAR_SAMPLINGMODE,
+            generateMipMaps: supportsMipMaps,
+        };
+        if (preserveRange &&
+            processedTextureType === Constants.TEXTURETYPE_UNSIGNED_BYTE &&
+            scale.slice(0, 3).some((value, index) => Math.min(bias[index], bias[index] + value) < 0)) {
+            throw new Error(`USD texture processing for '${name}' requires a floating-point render target to preserve signed values.`);
+        }
+        const key = `${source.id}:${channel}:${scale.join(",")}:${bias.join(",")}:${preserveRange}`;
+        const cached = processedTextures.get(key);
+        if (cached) {
+            return await cached;
+        }
+        const processing = (async () => {
+            const a = new Color4(bias[0], bias[1], bias[2], bias[3]);
+            const b = new Color4(bias[0] + scale[0], bias[1] + scale[1], bias[2] + scale[2], bias[3] + scale[3]);
+            const previousBlockEntityCollection = scene._blockEntityCollection;
+            scene._blockEntityCollection = true;
+            let processingPromise;
+            try {
+                processingPromise = LerpTexturesAsync(name, CreateFactorOperand(a), CreateFactorOperand(b), CreateTextureOperand(source.texture, processorChannel(channel), processorColorSpace(source)), scene, TextureColorSpace.Linear, undefined, outputOptions);
+            }
+            finally {
+                scene._blockEntityCollection = previousBlockEntityCollection;
+            }
+            const processed = await processingPromise;
+            if (!processed.texture) {
+                throw new Error(`USD texture processing for '${name}' did not produce a texture.`);
+            }
+            if (rollingBack || signal?.aborted) {
+                processed.dispose?.();
+                if (signal?.aborted) {
+                    signal.throwIfAborted();
+                }
+                throw new Error("USD materialization was rolled back.");
+            }
+            if (!assetContainer) {
+                scene.addTexture(processed.texture);
+            }
+            const texture = trackProcessedTexture(processed.texture);
+            texture.gammaSpace = false;
+            const transformedTexture = texture;
+            transformedTexture.uRotationCenter = source.texture.uRotationCenter;
+            transformedTexture.vRotationCenter = source.texture.vRotationCenter;
+            transformedTexture.wRotationCenter = source.texture.wRotationCenter;
+            transformedTexture.homogeneousRotationInUVTransform = source.texture.homogeneousRotationInUVTransform;
+            return texture;
+        })();
+        processedTextures.set(key, processing);
+        try {
+            return await processing;
+        }
+        catch (error) {
+            processedTextures.delete(key);
+            throw error;
+        }
+    };
+    const processScalarTextureAsync = async (name, binding) => {
+        const index = channelIndex(binding.channel);
+        const scale = binding.descriptor.scale[index];
+        const bias = binding.descriptor.bias[index];
+        return await processTextureAsync(name, binding, [scale, scale, scale, 1], [bias, bias, bias, 0], binding.channel);
+    };
+    const applyMaterialTextureBindingsAsync = async (bindings) => {
+        const { material, normalScale, base, opacity, normal, metallic, roughness, occlusion, emissive } = bindings;
+        if (base) {
+            if (base.channel !== 4 /* TextureOutputChannel.RGB */) {
+                throw new Error("A USD base-color texture must use the RGB output.");
+            }
+            material.albedoColor = Color3.White();
+            material.albedoTexture = valueTransformIs(base.descriptor, [1, 1, 1, 1], [0, 0, 0, 0])
+                ? base.descriptor.texture
+                : await processTextureAsync(`${material.name} base color`, base, base.descriptor.scale, base.descriptor.bias);
+        }
+        if (emissive) {
+            if (emissive.channel !== 4 /* TextureOutputChannel.RGB */) {
+                throw new Error("A USD emissive texture must use the RGB output.");
+            }
+            const descriptor = emissive.descriptor;
+            const zeroBias = descriptor.bias.slice(0, 3).every((value) => value === 0);
+            if (zeroBias) {
+                material.emissiveColor = new Color3(descriptor.scale[0], descriptor.scale[1], descriptor.scale[2]);
+                material.emissiveTexture = descriptor.texture;
+            }
+            else {
+                const factors = Array.from({ length: 3 }, (_, index) => Math.max(1, Math.abs(descriptor.bias[index]), Math.abs(descriptor.bias[index] + descriptor.scale[index])));
+                const scale = descriptor.scale.map((value, index) => (index < 3 ? value / factors[index] : value));
+                const bias = descriptor.bias.map((value, index) => (index < 3 ? value / factors[index] : value));
+                material.emissiveColor = new Color3(factors[0], factors[1], factors[2]);
+                material.emissiveTexture = await processTextureAsync(`${material.name} emissive`, emissive, scale, bias, emissive.channel, true);
+            }
+        }
+        if (normal) {
+            if (normal.channel !== 4 /* TextureOutputChannel.RGB */) {
+                throw new Error("A USD normal texture must use the RGB output.");
+            }
+            const canonicalNormal = normal.descriptor.sourceColorSpace === 1 /* USDTextureColorSpace.Raw */ && valueTransformIs(normal.descriptor, [2, 2, 2, 1], [-1, -1, -1, 0]);
+            if (canonicalNormal) {
+                material.bumpTexture = normal.descriptor.texture;
+            }
+            else {
+                const scale = Array.from(normal.descriptor.scale, (value) => value * 0.5);
+                const bias = Array.from(normal.descriptor.bias, (value, index) => (index < 3 ? (value + 1) * 0.5 : value));
+                material.bumpTexture = await processTextureAsync(`${material.name} normal`, normal, scale, bias);
+            }
+            material.bumpTexture.gammaSpace = false;
+            material.bumpTexture.level = normalScale;
+        }
+        const packedMetallicRoughness = metallic &&
+            roughness &&
+            metallic.descriptor === roughness.descriptor &&
+            (metallic.channel === 0 /* TextureOutputChannel.R */ || metallic.channel === 2 /* TextureOutputChannel.B */) &&
+            (roughness.channel === 1 /* TextureOutputChannel.G */ || roughness.channel === 3 /* TextureOutputChannel.A */) &&
+            scalarTextureIsLinear(metallic) &&
+            metallic.descriptor.bias[channelIndex(metallic.channel)] === 0 &&
+            roughness.descriptor.bias[channelIndex(roughness.channel)] === 0;
+        let packedOcclusion = false;
+        if (packedMetallicRoughness) {
+            const descriptor = metallic.descriptor;
+            material.metallicTexture = descriptor.texture;
+            material.metallic = (material.metallic ?? 1) * descriptor.scale[channelIndex(metallic.channel)];
+            material.roughness = (material.roughness ?? 1) * descriptor.scale[channelIndex(roughness.channel)];
+            material.useRoughnessFromMetallicTextureAlpha = roughness.channel === 3 /* TextureOutputChannel.A */;
+            material.useRoughnessFromMetallicTextureGreen = roughness.channel === 1 /* TextureOutputChannel.G */;
+            material.useMetallnessFromMetallicTextureBlue = metallic.channel === 2 /* TextureOutputChannel.B */;
+            packedOcclusion =
+                occlusion?.descriptor === descriptor &&
+                    occlusion.channel === 0 /* TextureOutputChannel.R */ &&
+                    descriptor.scale[0 /* TextureOutputChannel.R */] === 1 &&
+                    descriptor.bias[0 /* TextureOutputChannel.R */] === 0;
+            material.useAmbientOcclusionFromMetallicTextureRed = packedOcclusion;
+        }
+        else {
+            if (metallic) {
+                const index = channelIndex(metallic.channel);
+                const direct = scalarTextureIsLinear(metallic) &&
+                    (metallic.channel === 0 /* TextureOutputChannel.R */ || metallic.channel === 2 /* TextureOutputChannel.B */) &&
+                    metallic.descriptor.bias[index] === 0;
+                material.metallicTexture = direct ? metallic.descriptor.texture : await processScalarTextureAsync(`${material.name} metallic`, metallic);
+                material.useRoughnessFromMetallicTextureAlpha = false;
+                material.useRoughnessFromMetallicTextureGreen = false;
+                material.useMetallnessFromMetallicTextureBlue = direct && metallic.channel === 2 /* TextureOutputChannel.B */;
+                material.metallic = direct ? (material.metallic ?? 1) * metallic.descriptor.scale[index] : 1;
+            }
+            if (roughness) {
+                const index = channelIndex(roughness.channel);
+                const direct = scalarTextureIsLinear(roughness) && roughness.channel === 0 /* TextureOutputChannel.R */ && roughness.descriptor.bias[index] === 0;
+                material.microSurfaceTexture = direct ? roughness.descriptor.texture : await processScalarTextureAsync(`${material.name} roughness`, roughness);
+                material.microSurfaceTexture.gammaSpace = direct ? roughness.descriptor.texture.gammaSpace : false;
+                material.roughness = direct ? (material.roughness ?? 1) * roughness.descriptor.scale[index] : 1;
+            }
+        }
+        if (occlusion && !packedOcclusion) {
+            const index = channelIndex(occlusion.channel);
+            const direct = scalarTextureIsLinear(occlusion) &&
+                occlusion.channel === 0 /* TextureOutputChannel.R */ &&
+                occlusion.descriptor.scale[index] === 1 &&
+                occlusion.descriptor.bias[index] === 0;
+            material.ambientTexture = direct ? occlusion.descriptor.texture : await processScalarTextureAsync(`${material.name} occlusion`, occlusion);
+            material.useAmbientInGrayScale = true;
+        }
+        if (opacity) {
+            if (base &&
+                material.albedoTexture &&
+                opacity.descriptor === base.descriptor &&
+                opacity.channel === 3 /* TextureOutputChannel.A */ &&
+                opacity.descriptor.scale[3 /* TextureOutputChannel.A */] === 1 &&
+                opacity.descriptor.bias[3 /* TextureOutputChannel.A */] === 0) {
+                material.albedoTexture.hasAlpha = true;
+                material.useAlphaFromAlbedoTexture = true;
+            }
+            else {
+                const direct = opacity.channel === 3 /* TextureOutputChannel.A */ && opacity.descriptor.scale[3 /* TextureOutputChannel.A */] === 1 && opacity.descriptor.bias[3 /* TextureOutputChannel.A */] === 0;
+                material.opacityTexture = direct ? opacity.descriptor.texture : await processScalarTextureAsync(`${material.name} opacity`, opacity);
+                material.opacityTexture.gammaSpace = direct ? opacity.descriptor.texture.gammaSpace : false;
+                material.opacityTexture.getAlphaFromRGB = !direct;
+            }
+        }
+        const doubleSidedVariant = doubleSidedMaterials.get(bindings.id);
+        if (doubleSidedVariant) {
+            doubleSidedVariant.albedoColor.copyFrom(material.albedoColor);
+            doubleSidedVariant.albedoTexture = material.albedoTexture;
+            doubleSidedVariant.emissiveColor.copyFrom(material.emissiveColor);
+            doubleSidedVariant.emissiveTexture = material.emissiveTexture;
+            doubleSidedVariant.bumpTexture = material.bumpTexture;
+            doubleSidedVariant.metallic = material.metallic;
+            doubleSidedVariant.roughness = material.roughness;
+            doubleSidedVariant.metallicTexture = material.metallicTexture;
+            doubleSidedVariant.microSurfaceTexture = material.microSurfaceTexture;
+            doubleSidedVariant.ambientTexture = material.ambientTexture;
+            doubleSidedVariant.opacityTexture = material.opacityTexture;
+            doubleSidedVariant.alpha = material.alpha;
+            doubleSidedVariant.useAlphaFromAlbedoTexture = material.useAlphaFromAlbedoTexture;
+            doubleSidedVariant.useRoughnessFromMetallicTextureAlpha = material.useRoughnessFromMetallicTextureAlpha;
+            doubleSidedVariant.useRoughnessFromMetallicTextureGreen = material.useRoughnessFromMetallicTextureGreen;
+            doubleSidedVariant.useMetallnessFromMetallicTextureBlue = material.useMetallnessFromMetallicTextureBlue;
+            doubleSidedVariant.useAmbientOcclusionFromMetallicTextureRed = material.useAmbientOcclusionFromMetallicTextureRed;
+            doubleSidedVariant.useAmbientInGrayScale = material.useAmbientInGrayScale;
+        }
+    };
     try {
         const previousBlockEntityCollection = scene._blockEntityCollection;
         if (!addToScene) {
@@ -163,6 +453,9 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                     }
                     case 2 /* Command.Texture */: {
                         const id = payload.u32();
+                        if (textures.has(id)) {
+                            throw new Error(`Duplicate USD texture ${id}.`);
+                        }
                         const nameOffset = payload.u32();
                         const nameLength = payload.u32();
                         const mime = mimeType(payload.u32());
@@ -172,9 +465,19 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                         const transformOffset = payload.u32();
                         const wrapU = payload.u32();
                         const wrapV = payload.u32();
+                        const sourceColorSpace = payload.u32();
+                        const valueTransformOffset = payload.u32();
                         assertRange(dataBuffer, transformOffset, 5, 4, "texture transform");
+                        assertRange(dataBuffer, valueTransformOffset, 8, 4, "texture value transform");
                         assertRange(dataBuffer, imageOffset, imageLength, 1, "texture image");
+                        if (sourceColorSpace < 0 /* USDTextureColorSpace.Auto */ || sourceColorSpace > 2 /* USDTextureColorSpace.SRGB */) {
+                            throw new Error(`Invalid USD texture color space ${sourceColorSpace}.`);
+                        }
                         const transform = new Float32Array(dataBuffer, transformOffset, 5);
+                        const valueTransform = new Float32Array(dataBuffer, valueTransformOffset, 8);
+                        if (![...transform, ...valueTransform].every(Number.isFinite)) {
+                            throw new Error(`USD texture ${id} has a non-finite transform.`);
+                        }
                         const bytes = new Uint8Array(dataBuffer, imageOffset, imageLength);
                         const url = URL.createObjectURL(new Blob([bytes], { type: mime }));
                         textureUrls.add(url);
@@ -202,7 +505,14 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                         texture.wAng = -transform[4];
                         texture.wrapU = wrapMode(wrapU);
                         texture.wrapV = wrapMode(wrapV);
-                        textures.set(id, texture);
+                        texture.gammaSpace = sourceColorSpace !== 1 /* USDTextureColorSpace.Raw */;
+                        textures.set(id, {
+                            id,
+                            texture,
+                            sourceColorSpace,
+                            scale: valueTransform.subarray(0, 4),
+                            bias: valueTransform.subarray(4, 8),
+                        });
                         break;
                     }
                     case 3 /* Command.Material */: {
@@ -216,15 +526,8 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                         const normalScale = payload.f32();
                         const alphaCutoff = payload.f32();
                         const flags = payload.u32();
-                        const baseTexture = payload.u32();
-                        const opacityTexture = payload.u32();
-                        const normalTexture = payload.u32();
-                        const ormTexture = payload.u32();
-                        const emissiveTexture = payload.u32();
-                        const opacityChannel = payload.u32();
-                        const roughnessChannel = payload.u32();
-                        const metallicChannel = payload.u32();
-                        const occlusionChannel = payload.u32();
+                        const textureIds = Array.from({ length: 7 }, () => payload.u32());
+                        const textureChannels = Array.from({ length: 7 }, () => payload.u32());
                         assertRange(dataBuffer, baseOffset, 4, 4, "material base color");
                         assertRange(dataBuffer, emissiveOffset, 3, 4, "material emissive color");
                         const base = new Float32Array(dataBuffer, baseOffset, 4);
@@ -248,40 +551,18 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                             material.transparencyMode = 1;
                             material.alphaCutOff = alphaCutoff;
                         }
-                        if (baseTexture !== MISSING_OFFSET) {
-                            material.albedoTexture = textures.get(baseTexture) ?? null;
-                            if (material.albedoTexture && opacityTexture === MISSING_OFFSET && flags & 4 /* MaterialFlags.AlphaBlend */) {
-                                material.albedoTexture.hasAlpha = true;
-                                material.useAlphaFromAlbedoTexture = true;
-                            }
-                        }
-                        if (opacityTexture !== MISSING_OFFSET) {
-                            material.opacityTexture = textures.get(opacityTexture) ?? null;
-                            if (material.opacityTexture) {
-                                material.opacityTexture.gammaSpace = false;
-                                material.opacityTexture.getAlphaFromRGB = opacityChannel !== 3;
-                            }
-                        }
-                        if (normalTexture !== MISSING_OFFSET) {
-                            material.bumpTexture = textures.get(normalTexture) ?? null;
-                            if (material.bumpTexture) {
-                                material.bumpTexture.gammaSpace = false;
-                                material.bumpTexture.level = normalScale;
-                            }
-                        }
-                        if (ormTexture !== MISSING_OFFSET) {
-                            material.metallicTexture = textures.get(ormTexture) ?? null;
-                            if (material.metallicTexture) {
-                                material.metallicTexture.gammaSpace = false;
-                                material.useRoughnessFromMetallicTextureAlpha = roughnessChannel === 3;
-                                material.useRoughnessFromMetallicTextureGreen = roughnessChannel === 1;
-                                material.useMetallnessFromMetallicTextureBlue = metallicChannel === 2;
-                                material.useAmbientOcclusionFromMetallicTextureRed = occlusionChannel === 0;
-                            }
-                        }
-                        if (emissiveTexture !== MISSING_OFFSET) {
-                            material.emissiveTexture = textures.get(emissiveTexture) ?? null;
-                        }
+                        materialTextureBindings.push({
+                            id,
+                            material,
+                            normalScale,
+                            base: binding(textureIds[0], textureChannels[0], "base-color texture"),
+                            opacity: binding(textureIds[1], textureChannels[1], "opacity texture"),
+                            normal: binding(textureIds[2], textureChannels[2], "normal texture"),
+                            metallic: binding(textureIds[3], textureChannels[3], "metallic texture"),
+                            roughness: binding(textureIds[4], textureChannels[4], "roughness texture"),
+                            occlusion: binding(textureIds[5], textureChannels[5], "occlusion texture"),
+                            emissive: binding(textureIds[6], textureChannels[6], "emissive texture"),
+                        });
                         materials.set(id, material);
                         break;
                     }
@@ -317,19 +598,20 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                         const skeleton = new Skeleton(stringAt(dataBuffer, nameOffset, nameLength), `usd-skeleton-${id}`, scene);
                         trackAsset(container.skeletons, skeleton);
                         const jointView = new DataView(dataBuffer);
-                        assertRange(dataBuffer, jointsOffset, jointCount * 5, 4, "skeleton joints");
+                        assertRange(dataBuffer, jointsOffset, jointCount * 6, 4, "skeleton joints");
                         const created = [];
                         for (let index = 0; index < jointCount; ++index) {
-                            const offset = jointsOffset + index * 20;
+                            const offset = jointsOffset + index * 24;
                             const parentIndex = jointView.getUint32(offset, true);
                             const boneId = jointView.getUint32(offset + 4, true);
                             const jointNameOffset = jointView.getUint32(offset + 8, true);
                             const jointNameLength = jointView.getUint32(offset + 12, true);
-                            const matrixOffset = jointView.getUint32(offset + 16, true);
+                            const restMatrixOffset = jointView.getUint32(offset + 16, true);
+                            const bindMatrixOffset = jointView.getUint32(offset + 20, true);
                             if (parentIndex !== MISSING_OFFSET && parentIndex >= index) {
                                 throw new Error(`Skeleton ${id} has an invalid parent joint index.`);
                             }
-                            const bone = new Bone(stringAt(dataBuffer, jointNameOffset, jointNameLength), skeleton, parentIndex === MISSING_OFFSET ? null : created[parentIndex], matrixAt(dataBuffer, matrixOffset), matrixAt(dataBuffer, matrixOffset), undefined, index);
+                            const bone = new Bone(stringAt(dataBuffer, jointNameOffset, jointNameLength), skeleton, parentIndex === MISSING_OFFSET ? null : created[parentIndex], matrixAt(dataBuffer, restMatrixOffset), matrixAt(dataBuffer, restMatrixOffset), matrixAt(dataBuffer, bindMatrixOffset), index);
                             created.push(bone);
                             bones.set(boneId, bone);
                         }
@@ -439,6 +721,41 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                         meshes.set(id, mesh);
                         break;
                     }
+                    case 12 /* Command.MorphTarget */: {
+                        const id = payload.u32();
+                        const meshId = payload.u32();
+                        const nameOffset = payload.u32();
+                        const nameLength = payload.u32();
+                        const vertexCount = payload.u32();
+                        const positionsOffset = payload.u32();
+                        const normalsOffset = payload.u32();
+                        const influence = payload.f32();
+                        const mesh = meshes.get(meshId);
+                        if (!mesh) {
+                            throw new Error(`Morph target references missing mesh ${meshId}.`);
+                        }
+                        if (morphTargets.has(id) || vertexCount !== mesh.getTotalVertices() || !Number.isFinite(influence)) {
+                            throw new Error(`Morph target ${id} has invalid metadata.`);
+                        }
+                        assertRange(dataBuffer, positionsOffset, vertexCount * 3, 4, "morph target positions");
+                        let manager = morphTargetManagers.get(meshId);
+                        if (!manager) {
+                            manager = new MorphTargetManager(scene, mesh.name);
+                            manager.areUpdatesFrozen = true;
+                            trackAsset(container.morphTargetManagers, manager);
+                            morphTargetManagers.set(meshId, manager);
+                        }
+                        const target = new MorphTarget(stringAt(dataBuffer, nameOffset, nameLength), influence, scene, manager);
+                        target.id = `usd-morph-target-${id}`;
+                        target.setPositions(new Float32Array(dataBuffer, positionsOffset, vertexCount * 3));
+                        if (normalsOffset !== MISSING_OFFSET) {
+                            assertRange(dataBuffer, normalsOffset, vertexCount * 3, 4, "morph target normals");
+                            target.setNormals(new Float32Array(dataBuffer, normalsOffset, vertexCount * 3));
+                        }
+                        manager.addTarget(target);
+                        morphTargets.set(id, target);
+                        break;
+                    }
                     case 10 /* Command.AnalyticPrimitive */: {
                         const id = payload.u32();
                         const nodeId = payload.u32();
@@ -525,11 +842,32 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                         if (!source) {
                             throw new Error(`Instance references missing mesh ${sourceId}.`);
                         }
+                        if (thinInstanceSources.has(sourceId)) {
+                            throw new Error(`Mesh ${sourceId} cannot mix classic and thin instances.`);
+                        }
+                        classicInstanceSources.add(sourceId);
                         const instance = source.createInstance(stringAt(dataBuffer, nameOffset, nameLength));
                         trackAsset(container.meshes, instance);
                         instance.parent = nodes.get(nodeId) ?? root ?? null;
                         break;
                     }
+                    case 11 /* Command.ThinInstances */: {
+                        const sourceId = payload.u32();
+                        const transformsOffset = payload.u32();
+                        const instanceCount = payload.u32();
+                        const source = meshes.get(sourceId);
+                        if (!source) {
+                            throw new Error(`Thin instances reference missing mesh ${sourceId}.`);
+                        }
+                        if (thinInstanceSources.has(sourceId) || classicInstanceSources.has(sourceId)) {
+                            throw new Error(`Mesh ${sourceId} has duplicate or mixed thin instances.`);
+                        }
+                        assertRange(dataBuffer, transformsOffset, instanceCount * 16, 4, "thin instance transforms");
+                        source.thinInstanceSetBuffer("matrix", new Float32Array(dataBuffer, transformsOffset, instanceCount * 16), 16, true);
+                        source.thinInstanceEnablePicking = true;
+                        thinInstanceSources.add(sourceId);
+                        break;
+                    }
                     case 9 /* Command.Animation */: {
                         const targetKind = payload.u32();
                         const targetId = payload.u32();
@@ -539,20 +877,25 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                         const timesOffset = payload.u32();
                         const valuesOffset = payload.u32();
                         const stride = payload.u32();
-                        if (targetKind !== 0 /* AnimationTarget.Node */ && targetKind !== 1 /* AnimationTarget.Bone */) {
+                        if (targetKind !== 0 /* AnimationTarget.Node */ && targetKind !== 1 /* AnimationTarget.Bone */ && targetKind !== 2 /* AnimationTarget.MorphTarget */) {
                             throw new Error(`Invalid animation target kind ${targetKind}.`);
                         }
-                        const expectedStride = property === 0 /* AnimationProperty.Position */ || property === 2 /* AnimationProperty.Scaling */
-                            ? 3
-                            : property === 1 /* AnimationProperty.RotationQuaternion */
-                                ? 4
-                                : property === 3 /* AnimationProperty.Matrix */
-                                    ? 16
-                                    : 0;
+                        if ((targetKind === 2 /* AnimationTarget.MorphTarget */) !== (property === 4 /* AnimationProperty.Influence */)) {
+                            throw new Error(`Invalid animation property ${property} for target kind ${targetKind}.`);
+                        }
+                        const expectedStride = property === 4 /* AnimationProperty.Influence */
+                            ? 1
+                            : property === 0 /* AnimationProperty.Position */ || property === 2 /* AnimationProperty.Scaling */
+                                ? 3
+                                : property === 1 /* AnimationProperty.RotationQuaternion */
+                                    ? 4
+                                    : property === 3 /* AnimationProperty.Matrix */
+                                        ? 16
+                                        : 0;
                         if (stride !== expectedStride) {
                             throw new Error(`Invalid animation value stride ${stride} for property ${property}.`);
                         }
-                        const target = targetKind === 0 /* AnimationTarget.Node */ ? nodes.get(targetId) : bones.get(targetId);
+                        const target = targetKind === 0 /* AnimationTarget.Node */ ? nodes.get(targetId) : targetKind === 1 /* AnimationTarget.Bone */ ? bones.get(targetId) : morphTargets.get(targetId);
                         if (!target) {
                             break;
                         }
@@ -562,14 +905,18 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                                 ? "rotationQuaternion"
                                 : property === 2 /* AnimationProperty.Scaling */
                                     ? "scaling"
-                                    : targetKind === 0 /* AnimationTarget.Node */
-                                        ? NODE_MATRIX_PROPERTY
-                                        : "_matrix";
-                        const dataType = property === 1 /* AnimationProperty.RotationQuaternion */
-                            ? Animation.ANIMATIONTYPE_QUATERNION
-                            : property === 3 /* AnimationProperty.Matrix */
-                                ? Animation.ANIMATIONTYPE_MATRIX
-                                : Animation.ANIMATIONTYPE_VECTOR3;
+                                    : property === 4 /* AnimationProperty.Influence */
+                                        ? "influence"
+                                        : targetKind === 0 /* AnimationTarget.Node */
+                                            ? NODE_MATRIX_PROPERTY
+                                            : "_matrix";
+                        const dataType = property === 4 /* AnimationProperty.Influence */
+                            ? Animation.ANIMATIONTYPE_FLOAT
+                            : property === 1 /* AnimationProperty.RotationQuaternion */
+                                ? Animation.ANIMATIONTYPE_QUATERNION
+                                : property === 3 /* AnimationProperty.Matrix */
+                                    ? Animation.ANIMATIONTYPE_MATRIX
+                                    : Animation.ANIMATIONTYPE_VECTOR3;
                         const animation = new Animation(`USD ${propertyName}`, propertyName, timeCodesPerSecond, dataType, Animation.ANIMATIONLOOPMODE_CYCLE);
                         assertRange(dataBuffer, timesOffset, keyCount, 4, "animation times");
                         assertRange(dataBuffer, valuesOffset, keyCount * stride, 4, "animation values");
@@ -581,7 +928,9 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                                 ? Quaternion.FromArray(values, index * stride)
                                 : dataType === Animation.ANIMATIONTYPE_MATRIX
                                     ? Matrix.FromArray(values, index * stride)
-                                    : Vector3.FromArray(values, index * stride),
+                                    : dataType === Animation.ANIMATIONTYPE_FLOAT
+                                        ? values[index * stride]
+                                        : Vector3.FromArray(values, index * stride),
                         })));
                         let group = animationGroups.get(trackIndex);
                         if (!group) {
@@ -594,46 +943,35 @@ export async function materializeCommandBuffers(scene, commandBuffer, dataBuffer
                     }
                 }
             }
+            for (const [meshId, manager] of morphTargetManagers) {
+                manager.areUpdatesFrozen = false;
+                if (!manager.isUsingTextureForTargets && manager.numTargets <= MorphTargetManager.MaxActiveMorphTargetsInVertexAttributeMode) {
+                    manager.optimizeInfluencers = false;
+                    manager.numMaxInfluencers = manager.numTargets;
+                }
+                meshes.get(meshId).morphTargetManager = manager;
+            }
         }
         finally {
             if (!addToScene) {
                 scene._blockEntityCollection = previousBlockEntityCollection;
             }
         }
-        const texturesLoaded = Promise.all(textureLoads);
-        if (signal) {
-            let onAbort;
-            const aborted = new Promise((_resolve, reject) => {
-                onAbort = () => reject(signal.reason instanceof Error ? signal.reason : new Error("USD materialization was aborted."));
-                if (signal.aborted) {
-                    onAbort();
-                }
-                else {
-                    signal.addEventListener("abort", onAbort, { once: true });
-                }
-            });
-            try {
-                await Promise.race([texturesLoaded, aborted]);
-                signal.throwIfAborted();
-            }
-            finally {
-                if (onAbort) {
-                    signal.removeEventListener("abort", onAbort);
-                }
-            }
-        }
-        else {
-            await texturesLoaded;
-        }
+        await awaitAbortableAsync(Promise.all(textureLoads), signal);
+        await awaitAbortableAsync(Promise.all(materialTextureBindings.map(async (bindings) => {
+            await applyMaterialTextureBindingsAsync(bindings);
+        })), signal);
         for (const { node, parentId } of pendingParents) {
             node.parent = nodes.get(parentId) ?? root ?? null;
         }
         return { container, materializeMs: performance.now() - started };
     }
     catch (error) {
+        rollingBack = true;
         // Decode callbacks can arrive after rollback; observe their rejections without
         // delaying cancellation on an image load that may never finish.
         void Promise.allSettled(textureLoads);
+        void Promise.allSettled(processedTextures.values());
         container.dispose();
         for (const url of textureUrls) {
             URL.revokeObjectURL(url);