@zephyr3d/editor 0.3.7 → 0.3.8

package/dist/modules/zephyr3d_scene.js

@@ -1,4 +1,4 @@
-import { Disposable, makeObservable, releaseObject, retainObject, Vector4, Vector3, DRef, AABB, Frustum, ClipState, Interpolator, Quaternion, randomUUID, DWeakRef, Matrix4x4, nextPowerOf2, Observable, weightedAverage, ObservableVector3, ObservableQuaternion, ASSERT, Ray, Vector2, applyMixins, float2half, objectKeys, halton23, CubeFace, ObservableVector4, castObservable, radian2degree, degree2radian, uint8ArrayToBase64, base64ToUint8Array, mimeTypeOf, clamp01 as clamp01$1, smoothStep, InterpolatorScalar, applyPatch, guessMimeType, diff, PRNG, splitStringByGraphemes, packFloat3, isPowerOf2, clamp as clamp$1, Matrix3x3, PathUtils, textToBase64, HttpFS, MemoryFS, objectEntries, flushPendingDisposals } from '@zephyr3d/base';
+import { Disposable, makeObservable, releaseObject, retainObject, Vector4, Vector3, DRef, AABB, Frustum, ClipState, Interpolator, Quaternion, InterpolatorScalar, randomUUID, DWeakRef, Matrix4x4, nextPowerOf2, Observable, weightedAverage, ObservableVector3, ObservableQuaternion, ASSERT, Ray, Vector2, applyMixins, float2half, objectKeys, halton23, CubeFace, ObservableVector4, castObservable, radian2degree, degree2radian, uint8ArrayToBase64, base64ToUint8Array, mimeTypeOf, clamp01 as clamp01$2, smoothStep, applyPatch, guessMimeType, diff, PRNG, splitStringByGraphemes, packFloat3, isPowerOf2, clamp as clamp$1, Matrix3x3, PathUtils, textToBase64, HttpFS, MemoryFS, objectEntries, flushPendingDisposals } from '@zephyr3d/base';
 import { PBPrimitiveType, matchVertexBuffer, PBInsideFunctionScope, ProgramBuilder, PBShaderExp, isFloatTextureFormat, getVertexAttributeIndex, VERTEX_ATTRIB_POSITION, VERTEX_ATTRIB_TEXCOORD0, getVertexAttributeFormat, hasDepthChannel, PBStructTypeInfo, PBArrayTypeInfo, PBPrimitiveTypeInfo, getVertexFormatComponentCount, TextureAtlasManager } from '@zephyr3d/device';
 
 /** @internal */ let appInstance;
@@ -3198,6 +3198,67 @@ const tmpVec3$1 = new Vector3();
     }
 }
 
+function clamp01$1(value) {
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+/**
+ * Animates a model-level morph target group by name.
+ * @public
+ */ class MorphTargetGroupTrack extends AnimationTrack {
+    _groupName;
+    _interpolator;
+    _state;
+    /**
+   * Create a morph target group animation track.
+   * @param groupName - Morph target group name
+   * @param interpolator - Scalar interpolator for the group weight
+   * @param embedded - Whether this track is embedded
+   */ constructor(groupName, interpolator, embedded){
+        super(embedded ?? false);
+        this._groupName = groupName ?? '';
+        this._interpolator = interpolator ?? InterpolatorScalar.constant(0);
+        this._state = [
+            0
+        ];
+    }
+    /** Morph target group name controlled by this track. */ get groupName() {
+        return this._groupName;
+    }
+    set groupName(value) {
+        this._groupName = value ?? '';
+    }
+    /** Scalar interpolator for this track. */ get interpolator() {
+        return this._interpolator;
+    }
+    set interpolator(value) {
+        if (value && value.target !== 'number') {
+            throw new Error(`MorphTargetGroupTrack(): interpolator target must be 'number'`);
+        }
+        this._interpolator = value ?? InterpolatorScalar.constant(0);
+    }
+    /** {@inheritDoc AnimationTrack.clone} */ clone() {
+        return new MorphTargetGroupTrack(this._groupName, this._interpolator.clone(), false);
+    }
+    /** {@inheritDoc AnimationTrack.calculateState} */ calculateState(target, currentTime) {
+        this._interpolator.interpolate(currentTime, this._state);
+        return clamp01$1(this._state[0]);
+    }
+    /** {@inheritDoc AnimationTrack.applyState} */ applyState(node, weight) {
+        if (this._groupName) {
+            node.setMorphTargetGroupWeight(this._groupName, clamp01$1(weight));
+        }
+    }
+    /** {@inheritDoc AnimationTrack.mixState} */ mixState(a, b, t) {
+        return a + (b - a) * t;
+    }
+    /** {@inheritDoc AnimationTrack.getBlendId} */ getBlendId() {
+        return `morph-target-group:${this._groupName}`;
+    }
+    /** {@inheritDoc AnimationTrack.getDuration} */ getDuration() {
+        return this._interpolator.maxTime;
+    }
+}
+
 /**
  * Standardized humanoid joint names for consistent skeleton mapping across models and animations.
  *
@@ -6068,7 +6129,7 @@ function cloneInterpolator(src) {
         ...src.outputs
     ]);
 }
-function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, translationRotation, translationScale, translationAxisLocks) {
+function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, translationRotation, translationScale, translationCorrection, translationAxisLocks, rotationCorrection) {
     const si = srcSkeleton.joints.indexOf(srcJoint);
     const di = dstSkeleton.joints.indexOf(dstJoint);
     const srcBindPose = srcSkeleton.bindPose[si];
@@ -6081,24 +6142,28 @@ function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint,
         srcNode: srcJoint,
         srcBindRotInv: Quaternion.inverse(srcBindPose.rotation),
         dstBindRot: dstBindPose.rotation.clone(),
+        rotationCorrection,
         srcBindPos: srcBindPose.position.clone(),
         dstBindPos: dstBindPose.position.clone(),
-        translationScale: (srcLen > 1e-6 ? dstLen / srcLen : 1),
+        translationScale: translationScale ?? (srcLen > 1e-6 ? dstLen / srcLen : 1),
         translationRotation,
+        translationCorrection,
         translationAxisLocks
     };
 }
-function createTranslationRetargetRemap(srcNode, dstNode, srcBindPos, dstBindPos, dstJointIndex, translationScale, translationRotation, translationAxisLocks) {
+function createTranslationRetargetRemap(srcNode, dstNode, srcBindPos, dstBindPos, dstJointIndex, translationScale, translationRotation, translationCorrection, translationAxisLocks, rotationCorrection) {
     return {
         dstNode,
         dstJointIndex,
         srcNode,
         srcBindRotInv: Quaternion.identity(),
         dstBindRot: Quaternion.identity(),
+        rotationCorrection,
         srcBindPos: srcBindPos.clone(),
         dstBindPos: dstBindPos.clone(),
         translationScale,
         translationRotation,
+        translationCorrection,
         translationAxisLocks
     };
 }
@@ -6106,6 +6171,151 @@ function getBindPosition(skeleton, joint) {
     const index = skeleton.joints.indexOf(joint);
     return index >= 0 ? skeleton.bindPose[index].position : null;
 }
+function getSkeletonLocalBindTransform(skeleton, node, jointSet, cache) {
+    let transform = cache.get(node);
+    if (!transform) {
+        const bindPose = getRigBindPoseForNode(skeleton, node);
+        const position = bindPose.position.clone();
+        const rotation = bindPose.rotation.clone();
+        const parent = node.parent;
+        if (parent && jointSet.has(parent)) {
+            const parentTransform = getSkeletonLocalBindTransform(skeleton, parent, jointSet, cache);
+            parentTransform.rotation.transform(position, position);
+            position.addBy(parentTransform.position);
+            Quaternion.multiply(parentTransform.rotation, rotation, rotation);
+        }
+        transform = {
+            position,
+            rotation
+        };
+        cache.set(node, transform);
+    }
+    return transform;
+}
+function getHumanoidLateralXSign(skeleton) {
+    const mapping = skeleton.humanoidJointMapping;
+    if (!mapping) {
+        return 0;
+    }
+    const pairs = [
+        [
+            HumanoidBodyRig.LeftShoulder,
+            HumanoidBodyRig.RightShoulder
+        ],
+        [
+            HumanoidBodyRig.LeftUpperArm,
+            HumanoidBodyRig.RightUpperArm
+        ],
+        [
+            HumanoidBodyRig.LeftLowerArm,
+            HumanoidBodyRig.RightLowerArm
+        ],
+        [
+            HumanoidBodyRig.LeftHand,
+            HumanoidBodyRig.RightHand
+        ],
+        [
+            HumanoidBodyRig.LeftUpperLeg,
+            HumanoidBodyRig.RightUpperLeg
+        ],
+        [
+            HumanoidBodyRig.LeftLowerLeg,
+            HumanoidBodyRig.RightLowerLeg
+        ],
+        [
+            HumanoidBodyRig.LeftFoot,
+            HumanoidBodyRig.RightFoot
+        ],
+        [
+            HumanoidBodyRig.LeftToes,
+            HumanoidBodyRig.RightToes
+        ]
+    ];
+    const jointSet = new Set(skeleton.joints);
+    const cache = new Map();
+    let score = 0;
+    let weight = 0;
+    for (const [leftKey, rightKey] of pairs){
+        const left = mapping.body[leftKey];
+        const right = mapping.body[rightKey];
+        if (!left || !right || !jointSet.has(left) || !jointSet.has(right)) {
+            continue;
+        }
+        const dx = getSkeletonLocalBindTransform(skeleton, left, jointSet, cache).position.x - getSkeletonLocalBindTransform(skeleton, right, jointSet, cache).position.x;
+        if (Math.abs(dx) > 1e-5) {
+            score += dx;
+            weight++;
+        }
+    }
+    if (weight === 0 || Math.abs(score) < 1e-5) {
+        return 0;
+    }
+    return score > 0 ? 1 : -1;
+}
+function getHumanoidForwardZSign(skeleton) {
+    const mapping = skeleton.humanoidJointMapping;
+    if (!mapping) {
+        return 0;
+    }
+    const pairs = [
+        [
+            HumanoidBodyRig.LeftFoot,
+            HumanoidBodyRig.LeftToes
+        ],
+        [
+            HumanoidBodyRig.RightFoot,
+            HumanoidBodyRig.RightToes
+        ]
+    ];
+    const jointSet = new Set(skeleton.joints);
+    const cache = new Map();
+    let score = 0;
+    let weight = 0;
+    for (const [footKey, toesKey] of pairs){
+        const foot = mapping.body[footKey];
+        const toes = mapping.body[toesKey];
+        if (!foot || !toes || !jointSet.has(foot) || !jointSet.has(toes)) {
+            continue;
+        }
+        const dz = getSkeletonLocalBindTransform(skeleton, toes, jointSet, cache).position.z - getSkeletonLocalBindTransform(skeleton, foot, jointSet, cache).position.z;
+        if (Math.abs(dz) > 1e-5) {
+            score += dz;
+            weight++;
+        }
+    }
+    if (weight === 0 || Math.abs(score) < 1e-5) {
+        return 0;
+    }
+    return score > 0 ? 1 : -1;
+}
+function getHumanoidSignFromSkeletons(skeletons, getSign) {
+    let score = 0;
+    for (const skeleton of skeletons){
+        score += getSign(skeleton);
+    }
+    return score > 0 ? 1 : score < 0 ? -1 : 0;
+}
+function getHumanoidRotationCorrection(srcSkeleton, dstSkeleton, srcSignSkeletons = [
+    srcSkeleton
+], dstSignSkeletons = [
+    dstSkeleton
+]) {
+    const srcLateralXSign = getHumanoidLateralXSign(srcSkeleton) || getHumanoidSignFromSkeletons(srcSignSkeletons, getHumanoidLateralXSign);
+    const dstLateralXSign = getHumanoidLateralXSign(dstSkeleton) || getHumanoidSignFromSkeletons(dstSignSkeletons, getHumanoidLateralXSign);
+    const srcForwardZSign = getHumanoidForwardZSign(srcSkeleton) || getHumanoidSignFromSkeletons(srcSignSkeletons, getHumanoidForwardZSign);
+    const dstForwardZSign = getHumanoidForwardZSign(dstSkeleton) || getHumanoidSignFromSkeletons(dstSignSkeletons, getHumanoidForwardZSign);
+    const axisXSign = srcLateralXSign && dstLateralXSign && srcLateralXSign !== dstLateralXSign ? -1 : 1;
+    const axisZSign = srcForwardZSign && dstForwardZSign && srcForwardZSign !== dstForwardZSign ? -1 : 1;
+    if (axisXSign === 1 && axisZSign === 1) {
+        return null;
+    }
+    const determinant = axisXSign * axisZSign;
+    return {
+        x: determinant * axisXSign,
+        y: determinant,
+        z: determinant * axisZSign
+    };
+}
 function getRigBindPoseForNode(skeleton, node) {
     return skeleton.getBindPoseForJoint(node) ?? (node === skeleton.rootJoint ? skeleton.rootBindPose : {
         position: node.position,
@@ -6149,6 +6359,35 @@ function getHumanoidRootMotionScale(srcSkeleton, dstSkeleton) {
 function findTranslationTrack(tracks) {
     return tracks?.find((track)=>track instanceof NodeTranslationTrack) ?? null;
 }
+function findAncestorTranslationTrack(clip, node, modelRoot) {
+    let current = node.parent;
+    while(current){
+        const track = findTranslationTrack(clip.tracks.get(current));
+        if (track) {
+            return {
+                node: current,
+                track
+            };
+        }
+        if (current === modelRoot) {
+            break;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function copyMorphTargetGroupTracks(sourceClip, targetClip, target) {
+    for (const tracks of sourceClip.tracks.values()){
+        for (const track of tracks){
+            if (track instanceof MorphTargetGroupTrack) {
+                const cloned = track.clone();
+                cloned.name = track.name;
+                cloned.target = target.persistentId;
+                targetClip.addTrack(target, cloned);
+            }
+        }
+    }
+}
 function applyTranslationAxisLocks(value, bindValue, locks) {
     if (locks?.x) {
         value.x = bindValue.x;
@@ -6174,13 +6413,25 @@ function applyTranslationTangentAxisLocks(value, locks) {
 function retargetRotation(qSrcAnim, remap, out) {
     Quaternion.multiply(remap.srcBindRotInv, qSrcAnim, out);
     Quaternion.multiply(remap.dstBindRot, out, out);
+    if (remap.rotationCorrection) {
+        applyHumanoidRotationCorrection(out, remap.rotationCorrection, out);
+    }
     return out.inplaceNormalize();
 }
 function retargetRotationTangent(qSrcTangent, remap, out) {
     Quaternion.multiply(remap.srcBindRotInv, qSrcTangent, out);
     Quaternion.multiply(remap.dstBindRot, out, out);
+    if (remap.rotationCorrection) {
+        applyHumanoidRotationCorrection(out, remap.rotationCorrection, out);
+    }
     return out;
 }
+function applyHumanoidRotationCorrection(q, correction, out) {
+    return out.setXYZW(q.x * correction.x, q.y * correction.y, q.z * correction.z, q.w);
+}
+function applyHumanoidTranslationCorrection(value, correction, out) {
+    return out.setXYZ(value.x * correction.x, value.y * correction.y, value.z * correction.z);
+}
 function retargetTranslationValue(srcValue, remap, out) {
     out.setXYZ(srcValue.x, srcValue.y, srcValue.z);
     out.subBy(remap.srcBindPos);
@@ -6188,6 +6439,9 @@ function retargetTranslationValue(srcValue, remap, out) {
     if (remap.translationRotation) {
         remap.translationRotation.transform(out, out);
     }
+    if (remap.translationCorrection) {
+        applyHumanoidTranslationCorrection(out, remap.translationCorrection, out);
+    }
     out.addBy(remap.dstBindPos);
     applyTranslationAxisLocks(out, remap.dstBindPos, remap.translationAxisLocks);
     return out;
@@ -6198,6 +6452,9 @@ function retargetTranslationTangent(srcValue, remap, out) {
     if (remap.translationRotation) {
         remap.translationRotation.transform(out, out);
     }
+    if (remap.translationCorrection) {
+        applyHumanoidTranslationCorrection(out, remap.translationCorrection, out);
+    }
     applyTranslationTangentAxisLocks(out, remap.translationAxisLocks);
     return out;
 }
@@ -6297,7 +6554,7 @@ function sampleRotationTrack(track, time, fallback, out) {
     out.set(state);
     return out;
 }
-function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRotation, dstRootRotation, dstClip, remaps) {
+function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRotation, dstRootRotation, dstClip, remaps, rotationCorrection) {
     const rotationTracksByRemap = new Map();
     const times = new Set([
         0,
@@ -6334,7 +6591,10 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
     const outputsByRemap = new Map();
     const tmpLocalRot = new Quaternion();
     const tmpWorldDelta = new Quaternion();
+    const tmpRootDelta = new Quaternion();
     const tmpParentInv = new Quaternion();
+    const srcRootRotationInv = Quaternion.inverse(srcRootRotation);
+    const dstRootRotationInv = Quaternion.inverse(dstRootRotation);
     for (const remap of remaps){
         outputsByRemap.set(remap, new Float32Array(inputs.length * 4));
     }
@@ -6391,6 +6651,13 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         const srcBindWorldRot = getSrcBindWorldRot(remap.srcNode);
         const srcAnimWorldRot = getSrcAnimWorldRot(remap.srcNode, time);
         Quaternion.multiply(srcAnimWorldRot, Quaternion.inverse(srcBindWorldRot, tmpWorldDelta), tmpWorldDelta);
+        if (rotationCorrection) {
+            Quaternion.multiply(srcRootRotationInv, tmpWorldDelta, tmpRootDelta);
+            Quaternion.multiply(tmpRootDelta, srcRootRotation, tmpRootDelta);
+            applyHumanoidRotationCorrection(tmpRootDelta, rotationCorrection, tmpRootDelta);
+            Quaternion.multiply(dstRootRotation, tmpRootDelta, tmpWorldDelta);
+            Quaternion.multiply(tmpWorldDelta, dstRootRotationInv, tmpWorldDelta);
+        }
         Quaternion.multiply(tmpWorldDelta, getDstBindWorldRot(remap.dstNode), rot);
         return rot;
     }
@@ -7285,8 +7552,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             console.error(`copyHumanoidAnimationFrom: source skeleton does not have a humanoid joint mapping`);
             return null;
         }
-        const nodeMap = new Map();
-        const jointRemapBySrcNode = new Map();
+        const jointRemapsBySrcNode = new Map();
         // Find a destination skeleton that has a humanoid mapping and share at least the body rig keys
         let srcJointsFiltered = [];
         let dstJointsFiltered = [];
@@ -7299,38 +7565,34 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             if (!dstHumanoidMapping) {
                 return false;
             }
+            const srcHips = srcHumanoidMapping.body[HumanoidBodyRig.Hips];
+            const dstHips = dstHumanoidMapping.body[HumanoidBodyRig.Hips];
+            if (!srcHips || !dstHips || !srcSkeleton.joints.includes(srcHips) || !sk.joints.includes(dstHips)) {
+                return false;
+            }
             // Collect matched (srcJoint, dstJoint) pairs via shared humanoid rig keys
             const srcMatched = [];
             const dstMatched = [];
-            // Match body rig joints
-            for (const key of Object.keys(srcHumanoidMapping.body)){
-                const srcJoint = srcHumanoidMapping.body[key];
-                const dstJoint = dstHumanoidMapping.body[key];
-                if (srcJoint && dstJoint) {
+            const addMatch = (srcJoint, dstJoint)=>{
+                if (srcJoint && dstJoint && srcSkeleton.joints.includes(srcJoint) && sk.joints.includes(dstJoint)) {
                     srcMatched.push(srcJoint);
                     dstMatched.push(dstJoint);
                 }
+            };
+            // Match body rig joints
+            for (const key of Object.keys(srcHumanoidMapping.body)){
+                addMatch(srcHumanoidMapping.body[key], dstHumanoidMapping.body[key]);
             }
             // Match left hand rig joints only when both sides define them; skip silently if either is absent
             if (srcHumanoidMapping.leftHand && dstHumanoidMapping.leftHand) {
                 for (const key of Object.keys(srcHumanoidMapping.leftHand)){
-                    const srcJoint = srcHumanoidMapping.leftHand[key];
-                    const dstJoint = dstHumanoidMapping.leftHand[key];
-                    if (srcJoint && dstJoint) {
-                        srcMatched.push(srcJoint);
-                        dstMatched.push(dstJoint);
-                    }
+                    addMatch(srcHumanoidMapping.leftHand[key], dstHumanoidMapping.leftHand[key]);
                 }
             }
             // Match right hand rig joints only when both sides define them; skip silently if either is absent
             if (srcHumanoidMapping.rightHand && dstHumanoidMapping.rightHand) {
                 for (const key of Object.keys(srcHumanoidMapping.rightHand)){
-                    const srcJoint = srcHumanoidMapping.rightHand[key];
-                    const dstJoint = dstHumanoidMapping.rightHand[key];
-                    if (srcJoint && dstJoint) {
-                        srcMatched.push(srcJoint);
-                        dstMatched.push(dstJoint);
-                    }
+                    addMatch(srcHumanoidMapping.rightHand[key], dstHumanoidMapping.rightHand[key]);
                 }
             }
             if (srcMatched.length === 0) {
@@ -7368,28 +7630,69 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         const srcRootRot = computeParentChainRotation(srcRootNode, sourceSet.model, srcSkeleton);
         const dstRootRot = computeParentChainRotation(dstRootNode, this._model, dstSkeleton);
         const srcRootTranslationTrack = findTranslationTrack(sourceClip.tracks.get(srcRootNode));
-        const srcFallbackHipsTranslationTrack = !srcRootTranslationTrack && srcRootNode !== srcHipsNode ? findTranslationTrack(sourceClip.tracks.get(srcHipsNode)) : null;
-        const srcMotionTrack = srcRootTranslationTrack ?? srcFallbackHipsTranslationTrack;
-        const srcMotionNode = srcRootTranslationTrack ? srcRootNode : srcFallbackHipsTranslationTrack ? srcHipsNode : null;
+        const srcAncestorTranslationTrackInfo = !srcRootTranslationTrack ? findAncestorTranslationTrack(sourceClip, srcRootNode, sourceSet.model) : null;
+        const srcFallbackHipsTranslationTrack = !srcRootTranslationTrack && !srcAncestorTranslationTrackInfo && srcRootNode !== srcHipsNode ? findTranslationTrack(sourceClip.tracks.get(srcHipsNode)) : null;
+        const srcMotionTrack = srcRootTranslationTrack ?? srcAncestorTranslationTrackInfo?.track ?? srcFallbackHipsTranslationTrack;
+        const srcMotionNode = srcRootTranslationTrack ? srcRootNode : srcAncestorTranslationTrackInfo ? srcAncestorTranslationTrackInfo.node : srcFallbackHipsTranslationTrack ? srcHipsNode : null;
         const srcMotionParentRot = srcMotionNode ? computeParentChainRotation(srcMotionNode, sourceSet.model, srcSkeleton) : srcRootRot;
         const rootTranslationRotation = Quaternion.multiply(Quaternion.inverse(dstRootRot), srcMotionParentRot);
         const rootTranslationScale = rootMotion === 'scaled' ? typeof options.rootMotionScale === 'number' ? options.rootMotionScale : options.rootMotionScale === 'none' ? 1 : getHumanoidRootMotionScale(srcSkeleton, dstSkeleton) : 1;
         const jointRemaps = [];
-        const mappedSrcNodes = new Set();
-        const mappedDstNodes = new Set();
+        const jointRemapsByDstSkeleton = new Map([
+            [
+                dstSkeleton,
+                jointRemaps
+            ]
+        ]);
+        const srcSignSkeletons = sourceSet._rigs.map((ref)=>ref.get()).filter((sk)=>!!sk);
+        const dstSignSkeletons = this._rigs.map((ref)=>ref.get()).filter((sk)=>!!sk);
+        const humanoidRotationCorrection = getHumanoidRotationCorrection(srcSkeleton, dstSkeleton, srcSignSkeletons, dstSignSkeletons);
+        const addJointRemap = (targetSkeleton, srcJoint, dstJoint, applyRotationCorrection = true)=>{
+            if (!srcJoint || !dstJoint || !srcSkeleton.joints.includes(srcJoint) || !targetSkeleton.joints.includes(dstJoint)) {
+                return;
+            }
+            const remap = createJointRetargetRemap(srcSkeleton, targetSkeleton, srcJoint, dstJoint, undefined, undefined, humanoidRotationCorrection ?? undefined, undefined, applyRotationCorrection ? humanoidRotationCorrection ?? undefined : undefined);
+            let targetRemaps = jointRemapsByDstSkeleton.get(targetSkeleton);
+            if (!targetRemaps) {
+                targetRemaps = [];
+                jointRemapsByDstSkeleton.set(targetSkeleton, targetRemaps);
+            }
+            targetRemaps.push(remap);
+            let srcRemaps = jointRemapsBySrcNode.get(srcJoint);
+            if (!srcRemaps) {
+                srcRemaps = [];
+                jointRemapsBySrcNode.set(srcJoint, srcRemaps);
+            }
+            srcRemaps.push(remap);
+        };
+        const addHumanoidMappingRemaps = (targetSkeleton)=>{
+            const targetMapping = targetSkeleton.humanoidJointMapping;
+            if (!targetMapping) {
+                return;
+            }
+            const applyRotationCorrection = targetSkeleton === dstSkeleton;
+            for (const key of Object.keys(srcHumanoidMapping.body)){
+                addJointRemap(targetSkeleton, srcHumanoidMapping.body[key], targetMapping.body[key], applyRotationCorrection);
+            }
+            if (srcHumanoidMapping.leftHand && targetMapping.leftHand) {
+                for (const key of Object.keys(srcHumanoidMapping.leftHand)){
+                    addJointRemap(targetSkeleton, srcHumanoidMapping.leftHand[key], targetMapping.leftHand[key], applyRotationCorrection);
+                }
+            }
+            if (srcHumanoidMapping.rightHand && targetMapping.rightHand) {
+                for (const key of Object.keys(srcHumanoidMapping.rightHand)){
+                    addJointRemap(targetSkeleton, srcHumanoidMapping.rightHand[key], targetMapping.rightHand[key], applyRotationCorrection);
+                }
+            }
+        };
         // Build remap for matched joint pairs
         for(let fi = 0; fi < srcJointsFiltered.length; fi++){
-            const srcJoint = srcJointsFiltered[fi];
-            const dstJoint = dstJointsFiltered[fi];
-            if (mappedSrcNodes.has(srcJoint) || mappedDstNodes.has(dstJoint)) {
-                continue;
+            addJointRemap(dstSkeleton, srcJointsFiltered[fi], dstJointsFiltered[fi], true);
+        }
+        for (const targetSkeleton of dstSignSkeletons){
+            if (targetSkeleton !== dstSkeleton) {
+                addHumanoidMappingRemaps(targetSkeleton);
             }
-            mappedSrcNodes.add(srcJoint);
-            mappedDstNodes.add(dstJoint);
-            nodeMap.set(srcJoint, dstJoint);
-            const remap = createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint);
-            jointRemaps.push(remap);
-            jointRemapBySrcNode.set(srcJoint, remap);
         }
         const dstClip = this.createAnimation(destName);
         if (!dstClip) {
@@ -7398,9 +7701,37 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         dstClip.timeDuration = sourceClip.timeDuration;
         dstClip.weight = sourceClip.weight;
         dstClip.autoPlay = sourceClip.autoPlay;
-        // Register destination skeleton
-        dstClip.addSkeleton(dstSkeleton.persistentId);
-        bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRot, dstRootRot, dstClip, jointRemaps);
+        copyMorphTargetGroupTracks(sourceClip, dstClip, this._model);
+        for (const [targetSkeleton, targetRemaps] of jointRemapsByDstSkeleton){
+            if (targetRemaps.length === 0) {
+                continue;
+            }
+            const hasCopyableTrack = targetSkeleton === dstSkeleton || targetRemaps.some((remap)=>{
+                const srcTracks = sourceClip.tracks.get(remap.srcNode);
+                if (!srcTracks) {
+                    return false;
+                }
+                for (const srcTrack of srcTracks){
+                    if (srcTrack instanceof NodeRotationTrack || srcTrack instanceof NodeEulerRotationTrack) {
+                        return true;
+                    }
+                    if (srcTrack instanceof NodeTranslationTrack && remap.srcNode !== srcRootNode && srcTrack !== srcMotionTrack && jointTranslations === 'preserve') {
+                        return true;
+                    }
+                    if (srcTrack instanceof NodeScaleTrack) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+            if (!hasCopyableTrack) {
+                continue;
+            }
+            dstClip.addSkeleton(targetSkeleton.persistentId);
+            const targetRootNode = targetSkeleton.rootJoint ?? targetSkeleton.humanoidJointMapping?.body[HumanoidBodyRig.Hips] ?? targetRemaps[0].dstNode;
+            const targetRootRot = targetRootNode === dstRootNode ? dstRootRot : computeParentChainRotation(targetRootNode, this._model, targetSkeleton);
+            bakeHumanoidRotationTracks(sourceClip, srcSkeleton, targetSkeleton, srcRootRot, targetRootRot, dstClip, targetRemaps, humanoidRotationCorrection);
+        }
         if (rootMotion !== 'none') {
             const dstRootBindPose = getRigBindPoseForNode(dstSkeleton, dstRootNode);
             let dstRootTrack = null;
@@ -7408,7 +7739,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 dstRootTrack = createConstantTranslationTrack(dstRootBindPose.position);
             } else if (srcMotionTrack && srcMotionNode) {
                 const srcMotionBindPose = getRigBindPoseForNode(srcSkeleton, srcMotionNode);
-                const rootRemap = createTranslationRetargetRemap(srcMotionNode, dstRootNode, srcMotionBindPose.position, dstRootBindPose.position, dstSkeleton.joints.indexOf(dstRootNode), rootTranslationScale, rootTranslationRotation, options.lockRootMotionAxes);
+                const rootRemap = createTranslationRetargetRemap(srcMotionNode, dstRootNode, srcMotionBindPose.position, dstRootBindPose.position, dstSkeleton.joints.indexOf(dstRootNode), rootTranslationScale, rootTranslationRotation, humanoidRotationCorrection ?? undefined, options.lockRootMotionAxes, humanoidRotationCorrection ?? undefined);
                 dstRootTrack = retargetTranslationTrack(srcMotionTrack, rootRemap);
             }
             if (dstRootTrack) {
@@ -7418,34 +7749,33 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 dstClip.addTrack(dstRootNode, dstRootTrack);
             }
         }
-        for (const srcNode of srcJointsFiltered){
+        for (const [srcNode, srcRemaps] of jointRemapsBySrcNode){
             const srcTracks = sourceClip.tracks.get(srcNode);
             if (!srcTracks) {
                 continue;
             }
-            const dstNode = nodeMap.get(srcNode);
-            const remap = jointRemapBySrcNode.get(srcNode);
-            for (const srcTrack of srcTracks){
-                let dstTrack;
-                if (srcTrack instanceof NodeRotationTrack) {
-                    continue;
-                } else if (srcTrack instanceof NodeEulerRotationTrack) {
-                    continue;
-                } else if (srcTrack instanceof NodeTranslationTrack) {
-                    if (srcNode === srcRootNode || srcTrack === srcMotionTrack || jointTranslations !== 'preserve') {
+            for (const remap of srcRemaps){
+                const dstNode = remap.dstNode;
+                for (const srcTrack of srcTracks){
+                    let dstTrack;
+                    if (srcTrack instanceof NodeRotationTrack || srcTrack instanceof NodeEulerRotationTrack) {
+                        continue;
+                    } else if (srcTrack instanceof NodeTranslationTrack) {
+                        if (srcNode === srcRootNode || srcTrack === srcMotionTrack || jointTranslations !== 'preserve') {
+                            continue;
+                        }
+                        dstTrack = retargetTranslationTrack(srcTrack, remap);
+                    } else if (srcTrack instanceof NodeScaleTrack) {
+                        dstTrack = new NodeScaleTrack(cloneInterpolator(srcTrack.interpolator));
+                    } else {
+                        console.warn(`copyHumanoidAnimationFrom: unsupported track type '${srcTrack.constructor.name}', skipping`);
                         continue;
                     }
-                    dstTrack = retargetTranslationTrack(srcTrack, remap);
-                } else if (srcTrack instanceof NodeScaleTrack) {
-                    dstTrack = new NodeScaleTrack(cloneInterpolator(srcTrack.interpolator));
-                } else {
-                    console.warn(`copyHumanoidAnimationFrom: unsupported track type '${srcTrack.constructor.name}', skipping`);
-                    continue;
+                    dstTrack.name = srcTrack.name;
+                    dstTrack.target = dstNode.persistentId;
+                    dstTrack.jointIndex = remap.dstJointIndex;
+                    dstClip.addTrack(dstNode, dstTrack);
                 }
-                dstTrack.name = srcTrack.name;
-                dstTrack.target = dstNode.persistentId;
-                dstTrack.jointIndex = remap.dstJointIndex;
-                dstClip.addTrack(dstNode, dstTrack);
             }
         }
         return dstClip;
@@ -7538,6 +7868,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         dstClip.autoPlay = sourceClip.autoPlay;
         // Register destination skeleton
         dstClip.addSkeleton(dstSkeleton.persistentId);
+        copyMorphTargetGroupTracks(sourceClip, dstClip, this._model);
         for (const srcNode of srcJointsFiltered){
             const srcTracks = sourceClip.tracks.get(srcNode);
             if (!srcTracks) {
@@ -34266,6 +34597,16 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
     }
 }
 
+const DEFAULT_PROFILING_OPTIONS = {
+    enabled: false,
+    graph: true,
+    pass: true,
+    subpass: true,
+    includePendingUploads: true,
+    allowCrossFrame: false,
+    maxPendingFrames: 3,
+    label: 'RenderGraph'
+};
 /**
  * Executes a compiled render graph with automatic resource lifecycle management.
  *
@@ -34282,6 +34623,11 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
  * @typeParam TTexture - The concrete texture type (e.g. `Texture2D`).
  * @public
  */ class RenderGraphExecutor {
+    static _defaultProfilingOptions = false;
+    static _latestProfileResult = null;
+    static _latestPendingProfileFrame = null;
+    static _latestResolvedProfileSerial = 0;
+    static _nextProfileSerial = 0;
     /** @internal */ _allocator;
     /** @internal */ _backbufferWidth;
     /** @internal */ _backbufferHeight;
@@ -34291,10 +34637,45 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
     /** @internal */ _importedTextureAliases = new Map();
     /** @internal */ _resolvedImportedTextures = new Map();
     /** @internal */ _cleanupCallbacks = [];
-    constructor(allocator, backbufferWidth, backbufferHeight){
+    /** @internal */ _profilingOptions;
+    /** @internal */ _pendingProfileFrames = [];
+    /** @internal */ _latestProfileResult = null;
+    /** @internal */ _latestResolvedProfileSerial = 0;
+    constructor(allocator, backbufferWidth, backbufferHeight, options){
         this._allocator = allocator;
         this._backbufferWidth = backbufferWidth;
         this._backbufferHeight = backbufferHeight;
+        this._profilingOptions = this._normalizeProfilingOptions(options?.profiling ?? RenderGraphExecutor._defaultProfilingOptions, options?.device);
+    }
+    /**
+   * Set the default profiling options used by newly constructed render graph executors.
+   */ static setDefaultProfilingOptions(options) {
+        RenderGraphExecutor._defaultProfilingOptions = options;
+    }
+    /**
+   * Get the latest resolved profile result from any render graph executor.
+   */ static getLatestProfileResult() {
+        return RenderGraphExecutor._latestProfileResult;
+    }
+    /**
+   * Resolve the latest pending render graph profile result from any executor.
+   */ static resolveProfileResult() {
+        return RenderGraphExecutor._latestPendingProfileFrame?.resolvePromise ?? Promise.resolve(RenderGraphExecutor._latestProfileResult);
+    }
+    /**
+   * Enable, disable, or update timestamp profiling for this executor.
+   */ setProfilingOptions(options) {
+        this._profilingOptions = this._normalizeProfilingOptions(options, this._profilingOptions.device);
+    }
+    /**
+   * Get the latest resolved profile result produced by this executor.
+   */ getLatestProfileResult() {
+        return this._latestProfileResult;
+    }
+    /**
+   * Resolve the latest pending profile result produced by this executor.
+   */ resolveProfileResult() {
+        return this._pendingProfileFrames[this._pendingProfileFrames.length - 1]?.resolvePromise ?? Promise.resolve(this._latestProfileResult);
     }
     /**
    * Update the backbuffer dimensions used for 'backbuffer-relative' sizing.
@@ -34322,6 +34703,7 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
    */ execute(compiled) {
         this._cleanupCallbacks.length = 0;
         this._resolveImportedTextureAliases(compiled);
+        const profileFrame = this._beginProfileFrame();
         // Build per-pass allocation and release schedules
         const allocateAt = new Map(); // passIndex -> transient texture resourceIds to allocate
         const releaseAt = new Map(); // passIndex -> transient texture resourceIds to release
@@ -34377,15 +34759,19 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
                 // Execute the pass with exception safety for resource cleanup.
                 // Release errors must not hide the original pass execution error.
                 let passError = null;
+                const passProfile = this._beginPassProfileScope(profileFrame, pass);
                 try {
                     if (pass.subpasses.length > 0) {
                         const accessScope = this._createAccessScope(pass);
                         const ctx = this._createContext(accessScope);
                         for (const subpass of pass.subpasses){
+                            const subpassProfile = this._beginSubpassProfileScope(profileFrame, passProfile, pass, subpass.name);
                             try {
                                 subpass.executeFn(ctx, pass.data);
                             } catch (e) {
                                 throw this._wrapSubpassError(pass.name, subpass.name, e);
+                            } finally{
+                                this._endProfileScope(profileFrame, subpassProfile);
                             }
                         }
                     } else if (pass.executeFn) {
@@ -34395,6 +34781,8 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
                     }
                 } catch (e) {
                     passError = e;
+                } finally{
+                    this._endProfileScope(profileFrame, passProfile);
                 }
                 let releaseError = null;
                 const framebuffersToRelease = releaseFramebufferAt.get(i);
@@ -34437,6 +34825,7 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         } catch (e) {
             executionError = e;
         } finally{
+            this._finishProfileFrame(profileFrame);
             let cleanupError = null;
             try {
                 this._runCleanupCallbacks();
@@ -34478,6 +34867,216 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         this._resolvedImportedTextures.clear();
     }
     // ─── Private ────────────────────────────────────────────────────────
+    /** @internal */ _normalizeProfilingOptions(options, fallbackDevice) {
+        const source = typeof options === 'object' ? options : {};
+        const enabled = typeof options === 'boolean' ? options : source.enabled ?? true;
+        return {
+            enabled,
+            graph: source.graph ?? DEFAULT_PROFILING_OPTIONS.graph,
+            pass: source.pass ?? DEFAULT_PROFILING_OPTIONS.pass,
+            subpass: source.subpass ?? DEFAULT_PROFILING_OPTIONS.subpass,
+            includePendingUploads: source.includePendingUploads ?? DEFAULT_PROFILING_OPTIONS.includePendingUploads,
+            allowCrossFrame: source.allowCrossFrame ?? DEFAULT_PROFILING_OPTIONS.allowCrossFrame,
+            maxPendingFrames: Math.max(1, source.maxPendingFrames ?? DEFAULT_PROFILING_OPTIONS.maxPendingFrames),
+            label: source.label ?? DEFAULT_PROFILING_OPTIONS.label,
+            device: source.device ?? fallbackDevice
+        };
+    }
+    /** @internal */ _getProfilingDevice() {
+        if (this._profilingOptions.device) {
+            return this._profilingOptions.device;
+        }
+        try {
+            return getDevice();
+        } catch  {
+            return null;
+        }
+    }
+    /** @internal */ _beginProfileFrame() {
+        if (!this._profilingOptions.enabled) {
+            return null;
+        }
+        const device = this._getProfilingDevice();
+        const supported = !!device?.getDeviceCaps().miscCaps.supportTimestampQuery;
+        const rootResult = {
+            name: this._profilingOptions.label,
+            type: 'graph',
+            queryId: 0,
+            durationMs: 0,
+            status: supported ? 'resolved' : 'unsupported',
+            children: [],
+            message: supported ? undefined : 'GPU timestamp queries are not supported'
+        };
+        const result = {
+            frameId: device?.frameInfo.frameCounter ?? -1,
+            status: rootResult.status,
+            graph: rootResult,
+            passes: rootResult.children
+        };
+        const root = {
+            result: rootResult,
+            queryId: 0,
+            ended: false
+        };
+        const frame = {
+            serial: ++RenderGraphExecutor._nextProfileSerial,
+            device,
+            supported,
+            result,
+            root,
+            scopes: [],
+            resolvePromise: Promise.resolve(result)
+        };
+        if (this._profilingOptions.graph) {
+            this._beginTimestampScope(frame, root, this._profilingOptions.label);
+        }
+        return frame;
+    }
+    /** @internal */ _beginPassProfileScope(frame, pass) {
+        if (!frame || !this._profilingOptions.pass && !this._profilingOptions.subpass) {
+            return null;
+        }
+        return this._beginProfileScope(frame, frame.root, 'pass', pass.name, this._profilingOptions.pass);
+    }
+    /** @internal */ _beginSubpassProfileScope(frame, passScope, pass, subpassName) {
+        if (!frame || !this._profilingOptions.subpass) {
+            return null;
+        }
+        const parent = passScope ?? frame.root;
+        return this._beginProfileScope(frame, parent, 'subpass', subpassName, true, `${pass.name}/${subpassName}`);
+    }
+    /** @internal */ _beginProfileScope(frame, parent, type, name, queryEnabled, queryLabel) {
+        const status = frame.supported && !queryEnabled ? 'resolved' : frame.supported ? 'pending' : 'unsupported';
+        const result = {
+            name,
+            type,
+            queryId: 0,
+            durationMs: 0,
+            status,
+            children: [],
+            message: frame.supported ? undefined : 'GPU timestamp queries are not supported'
+        };
+        parent.result.children.push(result);
+        const scope = {
+            result,
+            queryId: 0,
+            ended: false
+        };
+        if (queryEnabled) {
+            this._beginTimestampScope(frame, scope, queryLabel ?? name);
+        }
+        return scope;
+    }
+    /** @internal */ _beginTimestampScope(frame, scope, label) {
+        if (!frame.supported || !frame.device) {
+            scope.result.status = 'unsupported';
+            scope.result.message = 'GPU timestamp queries are not supported';
+            return;
+        }
+        const queryId = frame.device.beginTimestampQuery(label, {
+            includePendingUploads: this._profilingOptions.includePendingUploads,
+            allowCrossFrame: this._profilingOptions.allowCrossFrame
+        });
+        scope.queryId = queryId;
+        scope.result.queryId = queryId;
+        if (queryId > 0) {
+            scope.result.status = 'pending';
+            frame.scopes.push(scope);
+        } else {
+            scope.result.status = 'unsupported';
+            scope.result.message = 'GPU timestamp query was not started';
+        }
+    }
+    /** @internal */ _endProfileScope(frame, scope) {
+        if (!frame || !frame.device || !scope || scope.ended) {
+            return;
+        }
+        scope.ended = true;
+        if (scope.queryId > 0) {
+            frame.device.endTimestampQuery(scope.queryId);
+        }
+    }
+    /** @internal */ _finishProfileFrame(frame) {
+        if (!frame) {
+            return;
+        }
+        this._endProfileScope(frame, frame.root);
+        if (frame.scopes.length === 0 || !frame.device) {
+            frame.result.status = this._aggregateProfileStatus(frame.result.graph);
+            this._publishProfileResult(frame);
+            return;
+        }
+        frame.resolvePromise = Promise.all(frame.scopes.map((scope)=>frame.device.resolveTimestampQuery(scope.queryId))).then((results)=>{
+            for(let i = 0; i < results.length; i++){
+                this._applyTimestampResult(frame.scopes[i], results[i]);
+            }
+            frame.result.status = this._aggregateProfileStatus(frame.result.graph);
+            this._publishProfileResult(frame);
+            return frame.result;
+        }).catch((err)=>{
+            const message = err instanceof Error ? err.message : String(err);
+            for (const scope of frame.scopes){
+                scope.result.status = 'failed';
+                scope.result.message = message;
+            }
+            frame.result.status = 'failed';
+            this._publishProfileResult(frame);
+            return frame.result;
+        });
+        this._trackPendingProfileFrame(frame);
+    }
+    /** @internal */ _trackPendingProfileFrame(frame) {
+        this._pendingProfileFrames.push(frame);
+        while(this._pendingProfileFrames.length > this._profilingOptions.maxPendingFrames){
+            this._pendingProfileFrames.shift();
+        }
+        RenderGraphExecutor._latestPendingProfileFrame = frame;
+    }
+    /** @internal */ _publishProfileResult(frame) {
+        this._pendingProfileFrames = this._pendingProfileFrames.filter((pending)=>pending !== frame);
+        if (frame.serial >= this._latestResolvedProfileSerial) {
+            this._latestResolvedProfileSerial = frame.serial;
+            this._latestProfileResult = frame.result;
+        }
+        if (frame.serial >= RenderGraphExecutor._latestResolvedProfileSerial) {
+            RenderGraphExecutor._latestResolvedProfileSerial = frame.serial;
+            RenderGraphExecutor._latestProfileResult = frame.result;
+        }
+        if (RenderGraphExecutor._latestPendingProfileFrame === frame) {
+            RenderGraphExecutor._latestPendingProfileFrame = null;
+        }
+    }
+    /** @internal */ _applyTimestampResult(scope, result) {
+        scope.result.queryId = result.id;
+        scope.result.durationMs = result.durationMs;
+        scope.result.status = result.status;
+        scope.result.message = result.message;
+    }
+    /** @internal */ _aggregateProfileStatus(scope) {
+        const statuses = [];
+        const collect = (node)=>{
+            statuses.push(node.status);
+            for (const child of node.children){
+                collect(child);
+            }
+        };
+        collect(scope);
+        for (const status of [
+            'failed',
+            'invalid',
+            'exhausted',
+            'pending',
+            'auto-closed'
+        ]){
+            if (statuses.includes(status)) {
+                return status;
+            }
+        }
+        if (statuses.includes('unsupported')) {
+            return 'unsupported';
+        }
+        return 'resolved';
+    }
     /** @internal */ _resolveSize(desc) {
         const mode = desc.sizeMode ?? 'backbuffer-relative';
         if (mode === 'absolute') {
@@ -41257,7 +41856,7 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
         device.clearFrameBuffer(packed ? new Vector4(0, 0, 0, 1) : new Vector4(1, 0, 0, 1), null, null);
         const bindgroup = packed ? SAO._bindgroupPacked : SAO._bindgroup;
         bindgroup.setValue('flip', this.needFlip(device) ? 1 : 0);
-        bindgroup.setTexture('depthTex', sceneDepthTexture);
+        bindgroup.setTexture('depthTex', sceneDepthTexture, fetchSampler('clamp_nearest_nomip'));
         bindgroup.setValue('scale', this._saoScale);
         bindgroup.setValue('invProj', Matrix4x4.invert(ctx.camera.getProjectionMatrix()));
         bindgroup.setValue('bias', this._saoBias);
@@ -44342,6 +44941,24 @@ function getLightPassColorAttachments(ctx, colorAttachment) {
         sss: !!sss
     };
 }
+// ─── Forward+ Graph Builder ─────────────────────────────────────────
+/**
+ * Constructs a render graph representing the forward+ pipeline.
+ *
+ * Each step in the existing `SceneRenderer._renderScene` becomes a graph pass.
+ * Execute callbacks delegate to the existing rendering code, sharing a mutable
+ * `FrameState`.
+ *
+ * @param graph - The render graph to populate.
+ * @param ctx - The draw context for this frame.
+ * @param renderQueue - The culled render queue.
+ * @param options - Pipeline feature toggles.
+ * @returns The backbuffer handle (graph output).
+ *
+ * @public
+ */ function buildForwardPlusGraph(graph, ctx, renderQueue, options) {
+    return buildForwardPlusGraphInternal(graph, ctx, renderQueue, options).backbuffer;
+}
 function buildForwardPlusGraphInternal(graph, ctx, renderQueue, options) {
     const backbuffer = graph.importTexture('backbuffer');
     ctx.SSS = !!options.sss;
@@ -60559,7 +61176,7 @@ function segmentMayCollideBroadPhase(point1, point2, colRW) {
         return pointMayCollideBroadPhase(point1, colRW);
     }
     const toCenter = Vector3.sub(colRW.boundsCenter, point1, _broadPhaseToCenter);
-    const t = clamp01$1(Vector3.dot(toCenter, segmentDir) / lenSq);
+    const t = clamp01$2(Vector3.dot(toCenter, segmentDir) / lenSq);
     const closestPoint = Vector3.scale(segmentDir, t, _broadPhaseClosestPoint);
     Vector3.add(point1, closestPoint, closestPoint);
     const delta = Vector3.sub(colRW.boundsCenter, closestPoint, _broadPhaseDelta);
@@ -60606,7 +61223,7 @@ function pointUpdatePass1(pointsR, pointsRW, stepDelta, stepTime_x2_half, rootSl
                 // Applying resistance to gravity would incorrectly attenuate acceleration each frame,
                 // causing energy errors and instability under high gravity.
                 Vector3.scale(moveDir, ptR.resistance, moveDir);
-                Vector3.scale(moveDir, 1.0 - clamp01$1(ptRW.friction * ptR.frictionScale), moveDir);
+                Vector3.scale(moveDir, 1.0 - clamp01$2(ptRW.friction * ptR.frictionScale), moveDir);
                 // Clamp per-step velocity to a multiple of bone rest length.
                 // During fast root rotations the Verlet velocity can become very large,
                 // overwhelming the constraint solver and causing the hair to lose shape.
@@ -60750,7 +61367,7 @@ function surfaceCollision(pointsRW, collidersR, collidersRW, surfaceConstraints)
                         Vector3.sub(rwPt.positionCurrent, result.intersectionPoint, intersectToPt);
                         const intersectLen = intersectToPt.magnitude;
                         let rate = intersectLen > EPSILON$1 ? centerToPt.magnitude / intersectLen : 0;
-                        rate = clamp01$1(Math.abs(rate));
+                        rate = clamp01$2(Math.abs(rate));
                         Vector3.scale(pushDir, (result.radius - pushMag) * rate, pushVec);
                         Vector3.add(rwPt.positionCurrent, pushVec, rwPt.positionCurrent);
                     }
@@ -61025,8 +61642,8 @@ function constraintUpdate(pointsR, pointsRW, constraints, collidersR, collidersR
                         const pushDist = pushout.magnitude;
                         if (pushDist > EPSILON$1) {
                             const ptDist = Vector3.sub(rwB.positionCurrent, rwA.positionCurrent, segment).magnitude * 0.5;
-                            const rateP1 = ptDist > EPSILON$1 ? clamp01$1(Vector3.sub(lineRes.pointOnLine, rwA.positionCurrent, pointToA).magnitude / ptDist) : 0;
-                            const rateP2 = ptDist > EPSILON$1 ? clamp01$1(Vector3.sub(lineRes.pointOnLine, rwB.positionCurrent, pointToB).magnitude / ptDist) : 0;
+                            const rateP1 = ptDist > EPSILON$1 ? clamp01$2(Vector3.sub(lineRes.pointOnLine, rwA.positionCurrent, pointToA).magnitude / ptDist) : 0;
+                            const rateP2 = ptDist > EPSILON$1 ? clamp01$2(Vector3.sub(lineRes.pointOnLine, rwB.positionCurrent, pointToB).magnitude / ptDist) : 0;
                             Vector3.scale(pushout, 1 / pushDist, pushN);
                             Vector3.scale(pushN, Math.max(lineRes.radius - pushDist, 0), pushVec);
                             if (weightA > EPSILON$1) {
@@ -61038,7 +61655,7 @@ function constraintUpdate(pointsR, pointsRW, constraints, collidersR, collidersR
                                 Vector3.add(rwB.positionCurrent, scaledDisp, rwB.positionCurrent);
                             }
                             const dotUp = Vector3.dot(AXIS_Y, Vector3.normalize(pushout, pushN));
-                            friction = Math.max(friction, colR.friction * clamp01$1(dotUp));
+                            friction = Math.max(friction, colR.friction * clamp01$2(dotUp));
                         }
                     }
                 }
@@ -61933,7 +62550,7 @@ function isBoneFixed(roots, index) {
             this._config.constraintShrinkLimit = Math.max(0, config.constraintShrinkLimit);
         }
         if (typeof config.blendRatio === 'number') {
-            this._config.blendRatio = clamp01$1(config.blendRatio);
+            this._config.blendRatio = clamp01$2(config.blendRatio);
         }
         if (typeof config.stabilizationFrameRate === 'number') {
             this._config.stabilizationFrameRate = config.stabilizationFrameRate;
@@ -62165,7 +62782,7 @@ function isBoneFixed(roots, index) {
         return this._config.blendRatio;
     }
     set blendRatio(value) {
-        this._config.blendRatio = clamp01$1(value);
+        this._config.blendRatio = clamp01$2(value);
     }
     /**
    * Pauses or resumes the physics simulation.
@@ -62415,10 +63032,10 @@ function isBoneFixed(roots, index) {
     }
     _computeBlendRatio() {
         if (this._fadeState === 'in') {
-            return 1.0 - clamp01$1(this._fadeTimer / this._fadeDuration);
+            return 1.0 - clamp01$2(this._fadeTimer / this._fadeDuration);
         }
         if (this._fadeState === 'out') {
-            return clamp01$1(this._fadeTimer / this._fadeDuration);
+            return clamp01$2(this._fadeTimer / this._fadeDuration);
         }
         return this._config.blendRatio;
     }
@@ -62604,8 +63221,8 @@ function isBoneFixed(roots, index) {
         const allShrinkScale = c.allShrinkScale.evaluate(rate);
         const allStretchScale = c.allStretchScale.evaluate(rate);
         point.mass = c.massScale.evaluate(rate);
-        point.resistance = clamp01$1(c.resistance.evaluate(rate));
-        point.hardness = clamp01$1(c.hardness.evaluate(rate));
+        point.resistance = clamp01$2(c.resistance.evaluate(rate));
+        point.hardness = clamp01$2(c.hardness.evaluate(rate));
         point.frictionScale = c.friction.evaluate(rate);
         point.sliderJointLength = c.sliderJointLength.evaluate(rate);
         point.structuralShrinkVertical = c.structuralShrinkVertical.evaluate(rate) * allShrinkScale * 0.5;
@@ -62728,7 +63345,7 @@ function isBoneFixed(roots, index) {
         config.relaxation = Math.max(0, Math.trunc(config.relaxation));
         config.subSteps = Math.max(1, Math.trunc(config.subSteps));
         config.constraintShrinkLimit = Math.max(0, config.constraintShrinkLimit);
-        config.blendRatio = clamp01$1(config.blendRatio);
+        config.blendRatio = clamp01$2(config.blendRatio);
         return config;
     }
 }
@@ -65231,6 +65848,74 @@ function createJointDynamicsCurveProp(name, key, label, description) {
         }
     };
 }
+/** @internal */ function getMorphTargetGroupTrackClass() {
+    return {
+        ctor: MorphTargetGroupTrack,
+        name: 'MorphTargetGroupTrack',
+        getProps () {
+            return defineProps([
+                {
+                    name: 'TrackName',
+                    description: 'The track name',
+                    type: 'string',
+                    options: {
+                        label: 'Name'
+                    },
+                    get (value) {
+                        value.str[0] = this.name;
+                    },
+                    set (value) {
+                        this.name = value.str[0];
+                    }
+                },
+                {
+                    name: 'GroupName',
+                    description: 'Morph target group controlled by this track',
+                    type: 'string',
+                    get (value) {
+                        value.str[0] = this.groupName;
+                    },
+                    set (value) {
+                        this.groupName = value.str[0];
+                    }
+                },
+                {
+                    name: 'Interpolator',
+                    description: 'Scalar interpolator object for this track',
+                    type: 'object',
+                    options: {
+                        objectTypes: [
+                            Interpolator
+                        ]
+                    },
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.object[0] = this.interpolator;
+                    },
+                    set (value) {
+                        this.interpolator = value.object[0];
+                    }
+                },
+                {
+                    name: 'TrackTarget',
+                    description: 'Target object this track applys to',
+                    type: 'string',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.str[0] = this.target;
+                    },
+                    set (value) {
+                        this.target = value.str[0];
+                    }
+                }
+            ]);
+        }
+    };
+}
 function encodeFloat32Array(values) {
     return uint8ArrayToBase64(new Uint8Array(values.buffer, values.byteOffset, values.byteLength));
 }
@@ -79775,6 +80460,7 @@ const defaultValues = {
             getFixedGeometryCacheTrackClass(),
             getPCAGeometryCacheTrackClass(),
             getMorphTrackClass(),
+            getMorphTargetGroupTrackClass(),
             getSceneNodeClass(this),
             getGraphNodeClass(),
             getMeshClass(),
@@ -91519,6 +92205,14 @@ class GPUClothWrapBinding {
                                     animation.addTrack(mesh, morphTrack);
                                 }
                             }
+                        } else if (track.type === 'morph-target-group') {
+                            const groupName = track.morphTargetGroupName;
+                            if (groupName) {
+                                const morphTargetGroupTrack = new MorphTargetGroupTrack(groupName, track.interpolator, true);
+                                morphTargetGroupTrack.name = groupName;
+                                morphTargetGroupTrack.target = group.persistentId;
+                                animation.addTrack(group, morphTargetGroupTrack);
+                            }
                         } else if (track.type === 'geometry-cache') {
                             const subMesh = track.node.mesh?.subMeshes[track.subMeshIndex];
                             const mesh = subMesh ? meshMap.get(subMesh) : null;
@@ -95220,5 +95914,5 @@ const DEFAULT_PADDING = 6;
     }
 }
 
-export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationController, AnimationPlayback, AnimationSet, AnimationTimeline, AnimationTimelineRunner, AnimationTrack, AnyConditionNode, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, AssetHierarchyNode, AssetManager, AssetScene, AssetSkeleton, AvatarOutfitInstance, AvatarWardrobe, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, BatchGroup, BillboardMatrixNode, BlinnMaterial, Blitter, Bloom, BoundingBox, BoxFilterBlitter, BoxFrameShape, BoxShape, CAMERA_POS_Y, CCDSolver, Camera, CameraNearFarNode, CameraPositionNode, CameraVectorNode, CapsuleShape, CeilNode, ClampNode, Clipmap, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, ColorAdjust, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, Compositor, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstraintType, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, EPSILON$1 as EPSILON, ESM, ElapsedTimeNode, Engine, EnvConstantAmbient, EnvHemisphericAmbient, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, FWidthNode, FXAA, FaceForwardNode, FixedGeometryCacheTrack, FloorNode, FmaNode, Fog, FontAsset, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, GrassInstances, GrassLayer, GrassMaterial, GrassQuadtreeNode, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, HumanoidBodyRig, HumanoidHandRig, IKAngleConstraint, IKChain, IKConstraint, IKModifier, IKSolver, InputManager, InstanceBindGroupAllocator, InstanceIndexNode, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, LightPass, Log2Node, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, MakeVectorNode, Material, MaterialBlueprintIR, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, MinNode, MixNode, ModNode, MorphTargetTrack, MultiChainSpringSystem, NamedObject, NodeEulerRotationTrack, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, PCAGeometryCacheTrack, PCFOPT, PCFPD, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, PixelNormalNode, PixelWorldPositionNode, PlaneShape, PointLight, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, PropertyTrack, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, RenderPass, RenderQueue, RenderTarget, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, SAO, SSS, SaturateNode, Scene, SceneNode, SceneRenderer, ScreenAdapter, ScreenRenderTarget, ScriptAttachment, ScriptRegistry, ScriptingSystem, SelectionNode, ShaderHelper, ShadowMapPass, ShadowMapper, ShadowRegion, Shape, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, SkeletonModifier, SkeletonRig, SkinBinding, SkyEnvTextureNode, SkyRenderer, SmoothStepNode, SphereShape, SpotLight, SpringChain, SpringModifier, SpringSystem, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, SubsurfaceProfile, SwizzleNode, TAA, TAA_DEBUG_ALAPH, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_EDGE, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_NONE, TAA_DEBUG_STRENGTH, TAA_DEBUG_VELOCITY, TanHNode, TanNode, TetrahedronFrameShape, TetrahedronShape, TextSprite, TextureSampleGrad, TextureSampleNode, Tonemap, TorusShape, TransformNode, TwoBoneIKSolver, UnlitMaterial, VSM, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, Water, WaterShaderImpl, WeightedBlendedOIT, aerialPerspective, aerialPerspectiveLut, appInstance, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, atmosphereLUTRendered, buildConstraints, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, copyTexture, createAPLutProgram, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createGradientNoiseTexture, createMultiScatteringLutProgram, createPlaneCollider, createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2, createRandomNoiseTexture, createSkyViewLutProgram, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, createTransmittanceLutProgram, debugTexture, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, extractLocalTwist, fetchNormalizedFloatForDevice, fetchSampler, gammaToLinear, generateMSDF, getAerialPerspectiveLut, getApp, getAtmosphereParamsStruct, getBatchGroupClass, getCameraClass, getDefaultAtmosphereParams, getDefaultTexture2D, getDefaultTexture2DArray, getDefaultTextureCube, getDevice, getDirectionalLightClass, getEngine, getGraphNodeClass, getInput, getMeshClass, getMultiScattering, getMultiScatteringLut, getNodeTypeComponents, getOrthoCameraClass, getParticleNodeClass, getPerspectiveCameraClass, getPointLightClass, getPunctualLightClass, getRectLightClass, getRuntimeScriptProperties, getSceneNodeClass, getSkyView, getSkyViewLut, getSpotLightClass, getTransmittanceLut, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, integralMultiScattering, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mieAbsorption, mieCoefficient, miePhase, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, multiScatteringLut, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, ozoneAbsorption, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scattering, scriptProp, setApp, setSceneMeshAssetBinding, simulate, skyBox, skyViewLut, smoothNoise3D, sortRootPointsByProximity, temporalResolve, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, tryGetApp, uniformSphereSamples, updateColliderFromNode, uvToTransmittanceLut, uvToViewDir, valueNoise, viewDirToUV, whiteNoise, worleyFBM, worleyNoise };
+export { AABBTree, ABufferOIT, ATMOSPHERIC_FOG_BIT, AbsNode, AbstractPostEffect, AllConditionNode, AnimationClip, AnimationController, AnimationPlayback, AnimationSet, AnimationTimeline, AnimationTimelineRunner, AnimationTrack, AnyConditionNode, Application, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, AssetHierarchyNode, AssetManager, AssetScene, AssetSkeleton, AvatarOutfitInstance, AvatarWardrobe, BUILTIN_ASSET_TEST_CUBEMAP, BUILTIN_ASSET_TEXTURE_SHEEN_LUT, BaseCameraController, BaseGraphNode, BaseLight, BaseSprite, BaseTextureNode, BatchGroup, BillboardMatrixNode, BlinnMaterial, Blitter, Bloom, BoundingBox, BoxFilterBlitter, BoxFrameShape, BoxShape, CAMERA_POS_Y, CCDSolver, Camera, CameraNearFarNode, CameraPositionNode, CameraVectorNode, CapsuleShape, CeilNode, ClampNode, Clipmap, ClipmapTerrain, ClipmapTerrainMaterial, ColliderForce, ColorAdjust, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, Compositor, ConstantBVec2Node, ConstantBVec3Node, ConstantBVec4Node, ConstantBooleanNode, ConstantScalarNode, ConstantTexture2DArrayNode, ConstantTexture2DNode, ConstantTextureCubeNode, ConstantVec2Node, ConstantVec3Node, ConstantVec4Node, ConstraintType, CopyBlitter, CosHNode, CosNode, CrossProductNode, CubemapSHProjector, CullVisitor, CylinderShape, DDXNode, DDYNode, Degrees2RadiansNode, DepthPass, DevicePoolAllocator, DirectionalLight, DistanceNode, DotProductNode, DracoMeshDecoder, EPSILON$1 as EPSILON, ESM, ElapsedTimeNode, Engine, EnvConstantAmbient, EnvHemisphericAmbient, EnvLightWrapper, EnvShIBL, Environment, EnvironmentLighting, EqualNode, Exp2Node, ExpNode, FABRIKSolver, FBMWaveGenerator, FFTWaveGenerator, FPSCameraController, FWidthNode, FXAA, FaceForwardNode, FixedGeometryCacheTrack, FloorNode, FmaNode, Fog, FontAsset, FractNode, FunctionCallNode, FunctionInputNode, FunctionOutputNode, GPUClothSystem, GaussianBlurBlitter, GenericMathNode, GerstnerWaveGenerator, GraphNode, GrassInstances, GrassLayer, GrassMaterial, GrassQuadtreeNode, GrassRenderer, Grayscale, HEIGHT_FOG_BIT, Hash1Node, Hash2Node, Hash3Node, HistoryResourceManager, HumanoidBodyRig, HumanoidHandRig, IKAngleConstraint, IKChain, IKConstraint, IKModifier, IKSolver, InputManager, InstanceBindGroupAllocator, InstanceIndexNode, InvProjMatrixNode, InvSqrtNode, InvViewProjMatrixNode, JointDynamicsModifier, JointDynamicsSystem, JointDynamicsSystemController, LIGHT_TYPE_DIRECTIONAL, LIGHT_TYPE_NONE, LIGHT_TYPE_POINT, LIGHT_TYPE_RECT, LIGHT_TYPE_SPOT, LambertMaterial, LengthNode, LightPass, Log2Node, LogNode, LogicallyAndNode, LogicallyOrNode, MAX_CLUSTERED_LIGHTS, MAX_GERSTNER_WAVE_COUNT, MAX_MORPH_ATTRIBUTES, MAX_MORPH_TARGETS, MAX_TERRAIN_MIPMAP_LEVELS, MORPH_ATTRIBUTE_VECTOR_COUNT, MORPH_TARGET_COLOR, MORPH_TARGET_NORMAL, MORPH_TARGET_POSITION, MORPH_TARGET_TANGENT, MORPH_TARGET_TEX0, MORPH_TARGET_TEX1, MORPH_TARGET_TEX2, MORPH_TARGET_TEX3, MORPH_WEIGHTS_VECTOR_COUNT, MSDFText, MSDFTextAtlasManager, MSDFTextSprite, MToonMaterial, MakeVectorNode, Material, MaterialBlueprintIR, MaterialVaryingFlags, MaxNode, Mesh, MeshMaterial, MinNode, MixNode, ModNode, MorphTargetGroupTrack, MorphTargetTrack, MultiChainSpringSystem, NamedObject, NodeEulerRotationTrack, NodeRotationTrack, NodeScaleTrack, NodeTranslationTrack, NormalizeNode, NotEqualNode, Octree, OctreeNode, OctreeNodeChunk, OctreePlacement, OrbitCameraController, OrthoCamera, PBRBlockNode, PBRBluePrintMaterial, PBRMetallicRoughnessMaterial, PBRSpecularGlossinessMaterial, PCAGeometryCacheTrack, PCFOPT, PCFPD, PannerNode, ParticleMaterial, ParticleSystem, PerlinNoise2DNode, PerspectiveCamera, PixelNormalNode, PixelWorldPositionNode, PlaneShape, PointLight, PostEffectLayer, PowNode, Primitive, ProjectionMatrixNode, PropertyTrack, PunctualLight, QUEUE_OPAQUE, QUEUE_TRANSPARENT, RENDER_PASS_TYPE_DEPTH, RENDER_PASS_TYPE_LIGHT, RENDER_PASS_TYPE_OBJECT_COLOR, RENDER_PASS_TYPE_SHADOWMAP, RGHandle, RGHistoryResources, RGSubpass, Radians2DegreesNode, RaycastVisitor, RectLight, ReflectNode, RefractNode, RenderGraph, RenderGraphExecutor, RenderPass, RenderQueue, RenderTarget, ResolveVertexNormalNode, ResolveVertexPositionNode, ResolveVertexTangentNode, ResourceManager, RotateAboutAxisNode, RuntimeScript, SAO, SSS, SaturateNode, Scene, SceneNode, SceneRenderer, ScreenAdapter, ScreenRenderTarget, ScriptAttachment, ScriptRegistry, ScriptingSystem, SelectionNode, ShaderHelper, ShadowMapPass, ShadowMapper, ShadowRegion, Shape, SharedModel, SignNode, SimplexNoise2DNode, SinHNode, SinNode, Skeleton, SkeletonModifier, SkeletonRig, SkinBinding, SkyEnvTextureNode, SkyRenderer, SmoothStepNode, SphereShape, SpotLight, SpringChain, SpringModifier, SpringSystem, Sprite, SpriteBlockNode, SpriteBlueprintMaterial, SpriteMaterial, SqrtNode, StandardSpriteMaterial, StepNode, SubsurfaceProfile, SwizzleNode, TAA, TAA_DEBUG_ALAPH, TAA_DEBUG_CURRENT_COLOR, TAA_DEBUG_EDGE, TAA_DEBUG_HISTORY_COLOR, TAA_DEBUG_MOTION_VECTOR, TAA_DEBUG_NONE, TAA_DEBUG_STRENGTH, TAA_DEBUG_VELOCITY, TanHNode, TanNode, TetrahedronFrameShape, TetrahedronShape, TextSprite, TextureSampleGrad, TextureSampleNode, Tonemap, TorusShape, TransformNode, TwoBoneIKSolver, UnlitMaterial, VSM, VertexBinormalNode, VertexBlockNode, VertexColorNode, VertexIndexNode, VertexNormalNode, VertexOutputNode, VertexPositionNode, VertexTangentNode, VertexUVNode, ViewMatrixNode, ViewProjMatrixNode, Water, WaterShaderImpl, WeightedBlendedOIT, aerialPerspective, aerialPerspectiveLut, appInstance, applyAngleLimits, applyMaterialMixins, applyResult, applyRuntimeScriptConfig, atmosphereLUTRendered, buildConstraints, buildForwardPlusGraph, buildMSDFShape, buildSurfaceFaces, checkSurfaceCollision, collisionDetection, collisionDetectionCapsule, collisionDetectionSphere, computeMaxDepth, computeNearestPoints, copyTexture, createAPLutProgram, createCapsuleCollider, createGPUClothWrapBindingData, createGeometryCacheState, createGradientNoiseTexture, createMultiScatteringLutProgram, createPlaneCollider, createProgramFFT2H, createProgramFFT2V, createProgramH0, createProgramHk, createProgramOcean, createProgramPostFFT2, createRandomNoiseTexture, createSkyViewLutProgram, createSphereCollider, createSpringConstraint, createSpringParticle, createTransformAccess, createTransmittanceLutProgram, debugTexture, decode2HalfFromRGBA, decodeFloatFromRGBA, decodeNormalizedFloatFromRGBA, decodeRGBM, defineProps, encode2HalfToRGBA, encodeFloatToRGBA, encodeNormalizedFloatToRGBA, encodeRGBM, ensureGeometryCacheMeshBinding, executeForwardPlusGraph, extractLocalTwist, fetchNormalizedFloatForDevice, fetchSampler, gammaToLinear, generateMSDF, getAerialPerspectiveLut, getApp, getAtmosphereParamsStruct, getBatchGroupClass, getCameraClass, getDefaultAtmosphereParams, getDefaultTexture2D, getDefaultTexture2DArray, getDefaultTextureCube, getDevice, getDirectionalLightClass, getEngine, getGraphNodeClass, getInput, getMeshClass, getMultiScattering, getMultiScatteringLut, getNodeTypeComponents, getOrthoCameraClass, getParticleNodeClass, getPerspectiveCameraClass, getPointLightClass, getPunctualLightClass, getRectLightClass, getRuntimeScriptProperties, getSceneNodeClass, getSkyView, getSkyViewLut, getSpotLightClass, getTransmittanceLut, gradient, hash11, hash12, hash13, hash21, hash22, hash23, hash31, hash32, hash33, integralMultiScattering, interleavedGradientNoise, isGPUClothSupported, linearToGamma, mieAbsorption, mieCoefficient, miePhase, mixGeometryCacheBoundingBox, mixinAlbedoColor, mixinBlinnPhong, mixinFoliage, mixinLambert, mixinLight, mixinPBRBluePrint, mixinPBRCommon, mixinPBRMetallicRoughness, mixinPBRSpecularGlossness, mixinTextureProps, mixinVertexColor, multiScatteringLut, noise3D, normalizeRuntimeScriptConfig, normalizeScriptAttachmentConfig, normalizeScriptAttachments, ozoneAbsorption, panoramaToCubemap, perlinNoise2D, perlinNoise3D, prefilterCubemap, pushInCollisionDetection, pushInFromCapsule, pushInFromCollider, pushInFromSphere, pushoutFromCapsule, pushoutFromCollider, pushoutFromSphere, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, restoreGeometryCacheMeshBinding, scattering, scriptProp, setApp, setSceneMeshAssetBinding, simulate, skyBox, skyViewLut, smoothNoise3D, sortRootPointsByProximity, temporalResolve, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, tryGetApp, uniformSphereSamples, updateColliderFromNode, uvToTransmittanceLut, uvToViewDir, valueNoise, viewDirToUV, whiteNoise, worleyFBM, worleyNoise };
 //# sourceMappingURL=zephyr3d_scene.js.map