@zephyr3d/scene 0.9.3 → 0.9.5

package/dist/utility/serialization/scene/animation.js

@@ -1,10 +1,10 @@
-import { Interpolator, base64ToUint8Array, uint8ArrayToBase64, AABB, Vector3, Matrix4x4, Quaternion } from '@zephyr3d/base';
+import { Vector3, Interpolator, base64ToUint8Array, uint8ArrayToBase64, AABB, Matrix4x4, Quaternion, DRef, InterpolatorScalar } from '@zephyr3d/base';
 import { AnimationClip } from '../../../animation/animation.js';
 import { NodeRotationTrack } from '../../../animation/rotationtrack.js';
 import { NodeEulerRotationTrack } from '../../../animation/eulerrotationtrack.js';
 import { NodeTranslationTrack } from '../../../animation/translationtrack.js';
 import { NodeScaleTrack } from '../../../animation/scaletrack.js';
-import { Skeleton } from '../../../animation/skeleton.js';
+import { Skeleton, SkeletonRig, SkinBinding } from '../../../animation/skeleton.js';
 import { AnimationTrack } from '../../../animation/animationtrack.js';
 import { PropertyTrack } from '../../../animation/proptrack.js';
 import { MorphTargetTrack } from '../../../animation/morphtrack.js';
@@ -14,7 +14,8 @@ import { PCAGeometryCacheTrack } from '../../../animation/pca_geometry_cache_tra
 import '@zephyr3d/device';
 import '../../../animation/joint_dynamics/collision.js';
 import '../../../animation/joint_dynamics/solver.js';
-import '../../../animation/joint_dynamics/joint_dynamics_system.js';
+import { createTransformAccess, JointDynamicsSystem } from '../../../animation/joint_dynamics/joint_dynamics_system.js';
+import { JointDynamicsModifier } from '../../../animation/joint_dynamics_modifier.js';
 import { defineProps } from '../types.js';
 import '../../../scene/scene.js';
 import '../../../values.js';
@@ -33,6 +34,7 @@ import '../../../material/pbrsg.js';
 import '../../../material/pbrblueprint.js';
 import '../../../material/sprite.js';
 import '../../../material/sprite_std.js';
+import '../../../material/msdf_text.js';
 import '../../blueprint/material/texture.js';
 import '../../../render/rendergraph/forward_plus_builder.js';
 import '../../../render/sky.js';
@@ -42,6 +44,7 @@ import { SceneNode } from '../../../scene/scene_node.js';
 import '../../../shadow/shadowmapper.js';
 import '../../../scene/mesh.js';
 import '../../../scene/basesprite.js';
+import '../../../scene/meshdrawable.js';
 import '../../../scene/water.js';
 import '../../../scene/particlesys.js';
 import '../../../scene/batchgroup.js';
@@ -49,6 +52,559 @@ import '../../../scene/terrain-cm/terrain-cm.js';
 import '../../../scene/terrain-cm/grass.js';
 import '../../../scene/raycast_visitor.js';
 
+const jointDynamicsModifierSkeletons = new WeakMap();
+function encodeSkeletonBindPose(bindPose) {
+    return uint8ArrayToBase64(new Uint8Array(new Float32Array([
+        ...bindPose.position,
+        ...bindPose.rotation,
+        ...bindPose.scale
+    ]).buffer));
+}
+function decodeSkeletonBindPose(encoded) {
+    const data = new Float32Array(base64ToUint8Array(encoded).buffer);
+    return {
+        position: new Vector3(data[0], data[1], data[2]),
+        rotation: new Quaternion(data[3], data[4], data[5], data[6]),
+        scale: new Vector3(data[7], data[8], data[9])
+    };
+}
+function vectorToArray(value) {
+    return [
+        value.x,
+        value.y,
+        value.z
+    ];
+}
+function vectorFromArray(value, defaultValue = Vector3.zero()) {
+    return Array.isArray(value) ? new Vector3(value[0] ?? 0, value[1] ?? 0, value[2] ?? 0) : defaultValue.clone();
+}
+function serializeScalarCurve(value) {
+    return {
+        mode: value.mode,
+        inputs: [
+            ...value.inputs
+        ],
+        outputs: [
+            ...value.outputs
+        ]
+    };
+}
+function deserializeScalarCurve(value) {
+    return new InterpolatorScalar(value?.mode ?? 'step', new Float32Array(value?.inputs ?? [
+        0
+    ]), new Float32Array(value?.outputs ?? [
+        0
+    ]));
+}
+function serializeControllerConfig(value) {
+    const curves = {};
+    for (const [key, curve] of Object.entries(value.curves)){
+        curves[key] = serializeScalarCurve(curve);
+    }
+    return {
+        gravity: vectorToArray(value.gravity),
+        windForce: vectorToArray(value.windForce),
+        relaxation: value.relaxation,
+        subSteps: value.subSteps,
+        rootSlideLimit: value.rootSlideLimit,
+        rootRotateLimit: value.rootRotateLimit,
+        constraintShrinkLimit: value.constraintShrinkLimit,
+        blendRatio: value.blendRatio,
+        stabilizationFrameRate: value.stabilizationFrameRate,
+        isFakeWave: value.isFakeWave,
+        fakeWaveSpeed: value.fakeWaveSpeed,
+        fakeWavePower: value.fakeWavePower,
+        enableSurfaceCollision: value.enableSurfaceCollision,
+        enableBroadPhase: value.enableBroadPhase,
+        preserveTwist: value.preserveTwist,
+        angleLimitConfig: {
+            ...value.angleLimitConfig
+        },
+        curves,
+        constraintOptions: {
+            ...value.constraintOptions
+        }
+    };
+}
+function deserializeControllerConfig(value) {
+    if (!value) {
+        return undefined;
+    }
+    const curves = Object.fromEntries(Object.entries(value.curves ?? {}).map(([key, curve])=>[
+            key,
+            deserializeScalarCurve(curve)
+        ]));
+    const config = {};
+    if (value.gravity) {
+        config.gravity = vectorFromArray(value.gravity, new Vector3(0, -9.8, 0));
+    }
+    if (value.windForce) {
+        config.windForce = vectorFromArray(value.windForce);
+    }
+    for (const key of [
+        'relaxation',
+        'subSteps',
+        'rootSlideLimit',
+        'rootRotateLimit',
+        'constraintShrinkLimit',
+        'blendRatio',
+        'stabilizationFrameRate',
+        'isFakeWave',
+        'fakeWaveSpeed',
+        'fakeWavePower',
+        'enableSurfaceCollision',
+        'enableBroadPhase',
+        'preserveTwist'
+    ]){
+        if (value[key] !== undefined) {
+            config[key] = value[key];
+        }
+    }
+    if (value.angleLimitConfig) {
+        config.angleLimitConfig = {
+            ...value.angleLimitConfig
+        };
+    }
+    if (Object.keys(curves).length > 0) {
+        config.curves = curves;
+    }
+    if (value.constraintOptions) {
+        config.constraintOptions = {
+            ...value.constraintOptions
+        };
+    }
+    return config;
+}
+function findSerializedNode(root, id) {
+    if (!id) {
+        return null;
+    }
+    const prefabNode = root.getPrefabNode() ?? root;
+    return prefabNode.findNodeById(id) ?? root.scene?.findNodeById(id) ?? null;
+}
+function setJointDynamicsModifierSkeleton(modifier, skeleton) {
+    jointDynamicsModifierSkeletons.set(modifier, skeleton);
+}
+function getJointDynamicsModifierSkeleton(modifier) {
+    return jointDynamicsModifierSkeletons.get(modifier) ?? null;
+}
+const jointDynamicsPropOptions = {
+    group: 'Joint Dynamics'
+};
+function isJointDynamicsEditorPropPersistent() {
+    return false;
+}
+function updateJointDynamicsConfig(modifier, config) {
+    modifier.jointDynamicsSystem.controller.updateConfig(config);
+}
+function createJointDynamicsNumberProp(name, key, label, description, type, minValue) {
+    return {
+        name,
+        description,
+        type,
+        options: {
+            ...jointDynamicsPropOptions,
+            label,
+            ...minValue !== undefined ? {
+                minValue
+            } : {}
+        },
+        isPersistent: isJointDynamicsEditorPropPersistent,
+        get (value) {
+            value.num[0] = this.jointDynamicsSystem.controller.getConfig()[key];
+        },
+        set (value) {
+            updateJointDynamicsConfig(this, {
+                [key]: value.num[0]
+            });
+        }
+    };
+}
+function createJointDynamicsBooleanProp(name, key, label, description) {
+    return {
+        name,
+        description,
+        type: 'bool',
+        options: {
+            ...jointDynamicsPropOptions,
+            label
+        },
+        isPersistent: isJointDynamicsEditorPropPersistent,
+        get (value) {
+            value.bool[0] = this.jointDynamicsSystem.controller.getConfig()[key];
+        },
+        set (value) {
+            updateJointDynamicsConfig(this, {
+                [key]: value.bool[0]
+            });
+        }
+    };
+}
+function createJointDynamicsVectorProp(name, key, label, description) {
+    return {
+        name,
+        description,
+        type: 'vec3',
+        options: {
+            ...jointDynamicsPropOptions,
+            label
+        },
+        isPersistent: isJointDynamicsEditorPropPersistent,
+        get (value) {
+            const v = this.jointDynamicsSystem.controller.getConfig()[key];
+            value.num[0] = v.x;
+            value.num[1] = v.y;
+            value.num[2] = v.z;
+        },
+        set (value) {
+            updateJointDynamicsConfig(this, {
+                [key]: new Vector3(value.num[0], value.num[1], value.num[2])
+            });
+        }
+    };
+}
+function createJointDynamicsAngleLimitNumberProp(name, key, label, description) {
+    return {
+        name,
+        description,
+        type: 'float',
+        options: {
+            ...jointDynamicsPropOptions,
+            label
+        },
+        isPersistent: isJointDynamicsEditorPropPersistent,
+        get (value) {
+            value.num[0] = this.jointDynamicsSystem.controller.getConfig().angleLimitConfig[key];
+        },
+        set (value) {
+            updateJointDynamicsConfig(this, {
+                angleLimitConfig: {
+                    [key]: value.num[0]
+                }
+            });
+        }
+    };
+}
+function createJointDynamicsAngleLimitBooleanProp(name, key, label, description) {
+    return {
+        name,
+        description,
+        type: 'bool',
+        options: {
+            ...jointDynamicsPropOptions,
+            label
+        },
+        isPersistent: isJointDynamicsEditorPropPersistent,
+        get (value) {
+            value.bool[0] = this.jointDynamicsSystem.controller.getConfig().angleLimitConfig[key];
+        },
+        set (value) {
+            updateJointDynamicsConfig(this, {
+                angleLimitConfig: {
+                    [key]: value.bool[0]
+                }
+            });
+        }
+    };
+}
+function createJointDynamicsConstraintOptionProp(name, key, label, description) {
+    return {
+        name,
+        description,
+        type: 'bool',
+        options: {
+            ...jointDynamicsPropOptions,
+            label
+        },
+        isPersistent: isJointDynamicsEditorPropPersistent,
+        get (value) {
+            value.bool[0] = this.jointDynamicsSystem.controller.getConfig().constraintOptions[key];
+        },
+        set (value) {
+            updateJointDynamicsConfig(this, {
+                constraintOptions: {
+                    [key]: value.bool[0]
+                }
+            });
+        }
+    };
+}
+function createJointDynamicsCurveProp(name, key, label, description) {
+    return {
+        name,
+        description,
+        type: 'float',
+        options: {
+            ...jointDynamicsPropOptions,
+            label
+        },
+        isPersistent: isJointDynamicsEditorPropPersistent,
+        get (value) {
+            value.num[0] = this.jointDynamicsSystem.controller.getConfig().curves[key].evaluate(0);
+        },
+        set (value) {
+            const val = value.num[0];
+            updateJointDynamicsConfig(this, {
+                curves: {
+                    [key]: InterpolatorScalar.constant(val)
+                }
+            });
+        }
+    };
+/*
+  return {
+    name,
+    description,
+    type: 'object',
+    readonly: true,
+    options: {
+      ...jointDynamicsPropOptions,
+      label,
+      objectTypes: [Interpolator],
+      edit: 'curve1f' as const
+    },
+    isPersistent: isJointDynamicsEditorPropPersistent,
+    get(this: JointDynamicsModifier, value: Required<Pick<PropertyValue, 'object'>>) {
+      value.object[0] = this.jointDynamicsSystem.controller.getConfig().curves[key];
+    },
+    set(this: JointDynamicsModifier, value: Required<Pick<PropertyValue, 'object'>>) {
+      const curve = value.object[0];
+      if (curve instanceof InterpolatorScalar) {
+        updateJointDynamicsConfig(this, { curves: { [key]: curve } as Partial<ControllerConfig['curves']> });
+      } else if (curve instanceof Interpolator && curve.target === 'number') {
+        updateJointDynamicsConfig(this, {
+          curves: {
+            [key]: new InterpolatorScalar(
+              curve.mode,
+              new Float32Array(curve.inputs),
+              new Float32Array(curve.outputs)
+            )
+          } as Partial<ControllerConfig['curves']>
+        });
+      }
+    }
+  };
+  */ }
+/** @internal */ function getJointDynamicsModifierClass() {
+    return {
+        ctor: JointDynamicsModifier,
+        name: 'JointDynamicsModifier',
+        createFunc (ctx, init) {
+            const skeleton = ctx.findSkeletonRigById(init.skeleton) ?? ctx.findSkeletonById(init.skeleton)?.rig ?? null;
+            const systemRoot = findSerializedNode(ctx, init.systemRoot);
+            if (!skeleton || !systemRoot) {
+                return {
+                    obj: null,
+                    loadProps: false
+                };
+            }
+            const chains = (init.chains ?? []).map((chain)=>{
+                const start = findSerializedNode(ctx, chain.start);
+                const end = findSerializedNode(ctx, chain.end);
+                return start && end ? {
+                    start,
+                    end
+                } : null;
+            }).filter((chain)=>{
+                return !!chain && chain.start.isParentOf(chain.end);
+            });
+            if (chains.length === 0) {
+                return {
+                    obj: null,
+                    loadProps: false
+                };
+            }
+            const serializedColliders = init.colliders ?? [];
+            const colliders = serializedColliders.map((item)=>{
+                const transform = findSerializedNode(ctx, item.transform);
+                return {
+                    r: {
+                        ...item.collider
+                    },
+                    transform: transform ? createTransformAccess(transform) : createTransformAccess(new SceneNode(null), false)
+                };
+            });
+            const serializedGrabbers = init.grabbers ?? [];
+            const grabbers = serializedGrabbers.map((item)=>{
+                const transform = findSerializedNode(ctx, item.transform);
+                return {
+                    r: {
+                        ...item.grabber
+                    },
+                    transform: transform ? createTransformAccess(transform) : createTransformAccess(new SceneNode(null), false),
+                    enabled: item.enabled ?? false
+                };
+            });
+            const flatPlanes = (init.flatPlanes ?? []).map((item)=>({
+                    up: vectorFromArray(item.up, Vector3.axisPY()),
+                    position: vectorFromArray(item.position),
+                    enabled: item.enabled ?? true
+                }));
+            const controllerConfig = deserializeControllerConfig(init.controllerConfig);
+            const config = {
+                chainConfig: {
+                    systemRoot,
+                    chains
+                },
+                controllerConfig
+            };
+            const system = new JointDynamicsSystem(config, colliders, grabbers, flatPlanes.map((item)=>({
+                    up: item.up,
+                    position: item.position
+                })));
+            for(let i = 0; i < serializedColliders.length; i++){
+                if (serializedColliders[i]?.enabled === false) {
+                    system.controller.setColliderEnabledAt(i, false);
+                }
+            }
+            for(let i = 0; i < flatPlanes.length; i++){
+                if (!flatPlanes[i].enabled) {
+                    system.controller.setFlatPlaneEnabledAt(i, false);
+                }
+            }
+            const modifier = new JointDynamicsModifier(system);
+            modifier.enabled = init.enabled ?? true;
+            setJointDynamicsModifierSkeleton(modifier, skeleton);
+            return {
+                obj: modifier,
+                loadProps: false
+            };
+        },
+        getInitParams (obj) {
+            const skeleton = getJointDynamicsModifierSkeleton(obj);
+            const chainConfig = obj.jointDynamicsSystem.chainConfig;
+            const controllerConfig = obj.jointDynamicsSystem.controller.getConfig();
+            const init = {
+                skeleton: skeleton?.persistentId ?? '',
+                systemRoot: chainConfig.systemRoot.persistentId,
+                chains: chainConfig.chains.map((chain)=>({
+                        start: chain.start.persistentId,
+                        end: chain.end.persistentId
+                    })),
+                controllerConfig: serializeControllerConfig(controllerConfig),
+                colliders: obj.jointDynamicsSystem.getColliderSnapshots().map((item)=>({
+                        collider: {
+                            ...item.r
+                        },
+                        transform: item.transform instanceof SceneNode ? item.transform.persistentId : undefined,
+                        enabled: item.enabled
+                    })),
+                flatPlanes: obj.jointDynamicsSystem.getFlatPlaneSnapshots().map((item)=>({
+                        up: vectorToArray(item.up),
+                        position: vectorToArray(item.position),
+                        enabled: item.enabled
+                    })),
+                grabbers: obj.jointDynamicsSystem.getGrabberSnapshots().map((item)=>({
+                        grabber: {
+                            ...item.r
+                        },
+                        transform: item.transform instanceof SceneNode ? item.transform.persistentId : undefined,
+                        enabled: item.enabled
+                    })),
+                enabled: obj.enabled
+            };
+            return init;
+        },
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Commands',
+                    description: 'Reset joint dynamics modifier state',
+                    type: 'command',
+                    command () {
+                        this.reset();
+                        return false;
+                    },
+                    get (value) {
+                        value.str[0] = 'Reset';
+                    }
+                },
+                {
+                    name: 'Enabled',
+                    description: 'Whether this joint dynamics modifier is active',
+                    type: 'bool',
+                    options: {
+                        ...jointDynamicsPropOptions,
+                        label: 'Enabled'
+                    },
+                    isPersistent: isJointDynamicsEditorPropPersistent,
+                    get (value) {
+                        value.bool[0] = this.enabled;
+                    },
+                    set (value) {
+                        this.enabled = value.bool[0];
+                    }
+                },
+                {
+                    name: 'Weight',
+                    description: 'Physics blend weight. 0 uses animation only, 1 uses full joint dynamics',
+                    type: 'float',
+                    options: {
+                        ...jointDynamicsPropOptions,
+                        label: 'Weight',
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isPersistent: isJointDynamicsEditorPropPersistent,
+                    get (value) {
+                        value.num[0] = this.weight;
+                    },
+                    set (value) {
+                        this.weight = value.num[0];
+                    }
+                },
+                createJointDynamicsVectorProp('Gravity', 'gravity', 'Gravity', 'Global gravity vector'),
+                createJointDynamicsVectorProp('WindForce', 'windForce', 'Wind Force', 'Global wind force vector'),
+                createJointDynamicsNumberProp('Relaxation', 'relaxation', 'Relaxation', 'Constraint relaxation iterations per substep', 'int', 0),
+                createJointDynamicsNumberProp('SubSteps', 'subSteps', 'Sub Steps', 'Simulation substeps per frame', 'int', 1),
+                createJointDynamicsNumberProp('RootSlideLimit', 'rootSlideLimit', 'Root Slide Limit', 'Maximum root slide distance per substep. -1 means unlimited', 'float'),
+                createJointDynamicsNumberProp('RootRotateLimit', 'rootRotateLimit', 'Root Rotate Limit', 'Maximum root rotation angle per substep. -1 means unlimited', 'float'),
+                createJointDynamicsNumberProp('ConstraintShrinkLimit', 'constraintShrinkLimit', 'Shrink Limit', 'Upper limit for horizontal and shear constraint shrink power', 'float', 0),
+                createJointDynamicsNumberProp('StabilizationFrameRate', 'stabilizationFrameRate', 'Stabilization FPS', 'Target frame rate used by stabilization logic', 'float', 0),
+                createJointDynamicsBooleanProp('FakeWave', 'isFakeWave', 'Fake Wave', 'Enable sinusoidal fake wave on leaf bones'),
+                createJointDynamicsNumberProp('FakeWaveSpeed', 'fakeWaveSpeed', 'Fake Wave Speed', 'Global fake wave speed', 'float'),
+                createJointDynamicsNumberProp('FakeWavePower', 'fakeWavePower', 'Fake Wave Power', 'Global fake wave amplitude multiplier', 'float'),
+                createJointDynamicsBooleanProp('EnableSurfaceCollision', 'enableSurfaceCollision', 'Surface Collision', 'Enable triangle-based surface collision'),
+                createJointDynamicsBooleanProp('EnableBroadPhase', 'enableBroadPhase', 'Broad Phase', 'Enable broad-phase pruning before precise collider tests'),
+                createJointDynamicsBooleanProp('PreserveTwist', 'preserveTwist', 'Preserve Twist', 'Preserve each joint initial local twist after physics simulation'),
+                createJointDynamicsAngleLimitNumberProp('AngleLimit', 'angleLimit', 'Angle Limit', 'Post-simulation parent-child angle limit. -1 disables angle limiting'),
+                createJointDynamicsAngleLimitBooleanProp('AngleLimitFromRoot', 'limitFromRoot', 'Limit From Root', 'Apply angle limiting from the chain root'),
+                createJointDynamicsConstraintOptionProp('StructuralVertical', 'structuralVertical', 'Structural Vertical', 'Generate parent-child vertical constraints'),
+                createJointDynamicsConstraintOptionProp('StructuralHorizontal', 'structuralHorizontal', 'Structural Horizontal', 'Generate same-depth horizontal constraints across chains'),
+                createJointDynamicsConstraintOptionProp('Shear', 'shear', 'Shear', 'Generate diagonal cross-bracing constraints'),
+                createJointDynamicsConstraintOptionProp('BendingVertical', 'bendingVertical', 'Bending Vertical', 'Generate skip-one vertical bending constraints'),
+                createJointDynamicsConstraintOptionProp('BendingHorizontal', 'bendingHorizontal', 'Bending Horizontal', 'Generate skip-one horizontal bending constraints'),
+                createJointDynamicsConstraintOptionProp('Loop', 'isLoop', 'Loop', 'Connect the last root point back to the first root point'),
+                createJointDynamicsConstraintOptionProp('CollideStructuralVertical', 'collideStructuralVertical', 'Collide Structural V', 'Enable per-constraint collision on structural vertical pairs'),
+                createJointDynamicsConstraintOptionProp('CollideStructuralHorizontal', 'collideStructuralHorizontal', 'Collide Structural H', 'Enable per-constraint collision on structural horizontal pairs'),
+                createJointDynamicsConstraintOptionProp('CollideShear', 'collideShear', 'Collide Shear', 'Enable per-constraint collision on shear pairs'),
+                createJointDynamicsConstraintOptionProp('ConstraintSurfaceCollision', 'enableSurfaceCollision', 'Constraint Surface Collision', 'Enable surface collision in constraint generation'),
+                createJointDynamicsCurveProp('MassScale', 'massScale', 'Mass Scale', 'Depth curve that scales point mass'),
+                createJointDynamicsCurveProp('GravityScale', 'gravityScale', 'Gravity Scale', 'Depth curve that scales gravity strength'),
+                createJointDynamicsCurveProp('WindForceScale', 'windForceScale', 'Wind Force Scale', 'Depth curve that scales wind force'),
+                createJointDynamicsCurveProp('Resistance', 'resistance', 'Resistance', 'Depth curve for velocity damping'),
+                createJointDynamicsCurveProp('Hardness', 'hardness', 'Hardness', 'Depth curve for restore-to-animation stiffness'),
+                createJointDynamicsCurveProp('Friction', 'friction', 'Friction', 'Depth curve for collision friction'),
+                createJointDynamicsCurveProp('PointRadius', 'pointRadius', 'Point Radius', 'Depth curve for collision radius'),
+                createJointDynamicsCurveProp('SliderJointLength', 'sliderJointLength', 'Slider Joint Length', 'Depth curve for extra horizontal and shear constraint slack'),
+                createJointDynamicsCurveProp('AllShrinkScale', 'allShrinkScale', 'All Shrink Scale', 'Depth curve for global shrink stiffness multiplier'),
+                createJointDynamicsCurveProp('AllStretchScale', 'allStretchScale', 'All Stretch Scale', 'Depth curve for global stretch stiffness multiplier'),
+                createJointDynamicsCurveProp('StructuralShrinkVertical', 'structuralShrinkVertical', 'Structural Shrink V', 'Depth curve for structural vertical shrink stiffness'),
+                createJointDynamicsCurveProp('StructuralStretchVertical', 'structuralStretchVertical', 'Structural Stretch V', 'Depth curve for structural vertical stretch stiffness'),
+                createJointDynamicsCurveProp('StructuralShrinkHorizontal', 'structuralShrinkHorizontal', 'Structural Shrink H', 'Depth curve for structural horizontal shrink stiffness'),
+                createJointDynamicsCurveProp('StructuralStretchHorizontal', 'structuralStretchHorizontal', 'Structural Stretch H', 'Depth curve for structural horizontal stretch stiffness'),
+                createJointDynamicsCurveProp('ShearShrink', 'shearShrink', 'Shear Shrink', 'Depth curve for shear shrink stiffness'),
+                createJointDynamicsCurveProp('ShearStretch', 'shearStretch', 'Shear Stretch', 'Depth curve for shear stretch stiffness'),
+                createJointDynamicsCurveProp('BendingShrinkVertical', 'bendingShrinkVertical', 'Bending Shrink V', 'Depth curve for bending vertical shrink stiffness'),
+                createJointDynamicsCurveProp('BendingStretchVertical', 'bendingStretchVertical', 'Bending Stretch V', 'Depth curve for bending vertical stretch stiffness'),
+                createJointDynamicsCurveProp('BendingShrinkHorizontal', 'bendingShrinkHorizontal', 'Bending Shrink H', 'Depth curve for bending horizontal shrink stiffness'),
+                createJointDynamicsCurveProp('BendingStretchHorizontal', 'bendingStretchHorizontal', 'Bending Stretch H', 'Depth curve for bending horizontal stretch stiffness'),
+                createJointDynamicsCurveProp('FakeWavePowerCurve', 'fakeWavePower', 'Fake Wave Power Curve', 'Depth curve for fake wave amplitude'),
+                createJointDynamicsCurveProp('FakeWaveFreq', 'fakeWaveFreq', 'Fake Wave Freq', 'Depth curve for fake wave frequency offset')
+            ]);
+        }
+    };
+}
 /** @internal */ function getInterpolatorClass() {
     return {
         ctor: Interpolator,
@@ -786,8 +1342,10 @@ function getPCAGeometryCacheTrackClass() {
                 node.jointTypeR = 'static';
                 return node;
             });
+            const rootJoint = init.rootJoint ? prefabNode.findNodeById(init.rootJoint) : null;
             const inverseBindMatricesArray = new Float32Array(base64ToUint8Array(init.inverseBindMatrices).buffer);
             const bindPoseArray = new Float32Array(base64ToUint8Array(init.bindPose ?? init.bindPoseMatrices).buffer);
+            const rootBindPose = init.rootBindPose ? decodeSkeletonBindPose(init.rootBindPose) : undefined;
             const inverseBindMatrices = [];
             const bindPose = [];
             for(let i = 0; i < joints.length; i++){
@@ -809,7 +1367,15 @@ function getPCAGeometryCacheTrackClass() {
                     });
                 }
             }
-            const skeleton = new Skeleton(joints, inverseBindMatrices, bindPose);
+            let rig = ctx.animationSet.rigs.map((ref)=>ref.get()).find((item)=>!!item && SkeletonRig.getRigKey(item.joints, item.rootJoint) === SkeletonRig.getRigKey(joints, rootJoint)) ?? null;
+            if (!rig) {
+                rig = new SkeletonRig(joints, bindPose, {
+                    rootJoint,
+                    rootBindPose
+                });
+                ctx.animationSet.rigs.push(new DRef(rig));
+            }
+            const skeleton = new SkinBinding(rig, inverseBindMatrices, joints);
             skeleton.persistentId = init.id;
             return {
                 obj: skeleton,
@@ -833,6 +1399,8 @@ function getPCAGeometryCacheTrackClass() {
                 ], []);
             return {
                 joints: obj.joints.map((joint)=>joint.persistentId),
+                rootJoint: obj.rig.rootJoint?.persistentId ?? '',
+                rootBindPose: encodeSkeletonBindPose(obj.rig.rootBindPose),
                 inverseBindMatrices: uint8ArrayToBase64(new Uint8Array(new Float32Array(inverseBindMatrices).buffer)),
                 bindPose: uint8ArrayToBase64(new Uint8Array(new Float32Array(bindPose).buffer)),
                 id: obj.persistentId
@@ -843,6 +1411,114 @@ function getPCAGeometryCacheTrackClass() {
         }
     };
 }
+/** @internal */ function getSkeletonRigClass() {
+    return {
+        ctor: SkeletonRig,
+        name: 'SkeletonRig',
+        createFunc (ctx, init) {
+            const prefabNode = ctx.getPrefabNode() ?? ctx;
+            const joints = init.joints.map((id)=>prefabNode.findNodeById(id)).map((node)=>{
+                node.jointTypeT = 'static';
+                node.jointTypeS = 'static';
+                node.jointTypeR = 'static';
+                return node;
+            });
+            const rootJoint = init.rootJoint ? prefabNode.findNodeById(init.rootJoint) : null;
+            const rootBindPose = init.rootBindPose ? decodeSkeletonBindPose(init.rootBindPose) : undefined;
+            const bindPoseArray = new Float32Array(base64ToUint8Array(init.bindPose ?? init.bindPoseMatrices).buffer);
+            const bindPose = [];
+            for(let i = 0; i < joints.length; i++){
+                if (!init.bindPose) {
+                    const matrix = new Matrix4x4(bindPoseArray.slice(i * 16, i * 16 + 16));
+                    const trs = {
+                        position: new Vector3(),
+                        rotation: new Quaternion(),
+                        scale: new Vector3()
+                    };
+                    matrix.decompose(trs.scale, trs.rotation, trs.position);
+                    bindPose.push(trs);
+                } else {
+                    bindPose.push({
+                        position: new Vector3(bindPoseArray[i * 10 + 0], bindPoseArray[i * 10 + 1], bindPoseArray[i * 10 + 2]),
+                        rotation: new Quaternion(bindPoseArray[i * 10 + 3], bindPoseArray[i * 10 + 4], bindPoseArray[i * 10 + 5], bindPoseArray[i * 10 + 6]),
+                        scale: new Vector3(bindPoseArray[i * 10 + 7], bindPoseArray[i * 10 + 8], bindPoseArray[i * 10 + 9])
+                    });
+                }
+            }
+            const rig = new SkeletonRig(joints, bindPose, {
+                rootJoint,
+                rootBindPose
+            });
+            rig.persistentId = init.id;
+            return {
+                obj: rig,
+                loadProps: false
+            };
+        },
+        getInitParams (obj) {
+            const bindPose = obj.bindPose.map((v)=>[
+                    ...v.position,
+                    ...v.rotation,
+                    ...v.scale
+                ]).reduce((a, b)=>[
+                    ...a,
+                    ...b
+                ], []);
+            return {
+                joints: obj.joints.map((joint)=>joint.persistentId),
+                rootJoint: obj.rootJoint?.persistentId ?? '',
+                rootBindPose: encodeSkeletonBindPose(obj.rootBindPose),
+                bindPose: uint8ArrayToBase64(new Uint8Array(new Float32Array(bindPose).buffer)),
+                id: obj.persistentId
+            };
+        },
+        getProps () {
+            return [];
+        }
+    };
+}
+/** @internal */ function getSkinBindingClass() {
+    return {
+        ctor: SkinBinding,
+        name: 'SkinBinding',
+        createFunc (ctx, init) {
+            const rig = ctx.findSkeletonRigById(init.rig);
+            if (!rig) {
+                throw new Error(`Deserialize SkinBinding failed: skeleton rig '${init.rig}' not found`);
+            }
+            const prefabNode = ctx.getPrefabNode() ?? ctx;
+            const joints = (init.joints ?? rig.joints.map((joint)=>joint.persistentId)).map((id)=>prefabNode.findNodeById(id)).filter((node)=>!!node);
+            const inverseBindMatricesArray = new Float32Array(base64ToUint8Array(init.inverseBindMatrices).buffer);
+            const inverseBindMatrices = [];
+            for(let i = 0; i < joints.length; i++){
+                inverseBindMatrices.push(new Matrix4x4(inverseBindMatricesArray.slice(i * 16, i * 16 + 16)));
+            }
+            const binding = new SkinBinding(rig, inverseBindMatrices, joints);
+            binding.persistentId = init.id;
+            return {
+                obj: binding,
+                loadProps: false
+            };
+        },
+        getInitParams (obj) {
+            const inverseBindMatrices = obj.inverseBindMatrices.map((v)=>[
+                    ...v
+                ]).reduce((a, b)=>[
+                    ...a,
+                    ...b
+                ], []);
+            return {
+                rig: obj.rig.persistentId,
+                joints: obj.joints.map((joint)=>joint.persistentId),
+                inverseBindMatrices: uint8ArrayToBase64(new Uint8Array(new Float32Array(inverseBindMatrices).buffer)),
+                id: obj.persistentId
+            };
+        },
+        getProps () {
+            return [];
+        }
+    };
+}
 /** @internal */ function getAnimationClass(manager) {
     return {
         ctor: AnimationClip,
@@ -902,8 +1578,8 @@ function getPCAGeometryCacheTrackClass() {
                     }
                 },
                 {
-                    name: 'Skeletons',
-                    description: 'Skeleton references used by this animation clip',
+                    name: 'Rigs',
+                    description: 'Rig references used by this animation clip',
                     type: 'object',
                     isHidden () {
                         return true;
@@ -922,6 +1598,25 @@ function getPCAGeometryCacheTrackClass() {
                         }
                     }
                 },
+                {
+                    name: 'Skeletons',
+                    description: 'Legacy skeleton references used by this animation clip',
+                    type: 'object',
+                    isHidden () {
+                        return true;
+                    },
+                    get (value) {
+                        value.object[0] = [];
+                    },
+                    set (value) {
+                        if (!this.skeletons) {
+                            this.skeletons = new Set();
+                        }
+                        for (const val of value.object[0] ?? []){
+                            this.skeletons.add(val);
+                        }
+                    }
+                },
                 {
                     name: 'Tracks',
                     description: 'Animation tracks of this animation clip',
@@ -986,5 +1681,5 @@ function getPCAGeometryCacheTrackClass() {
     };
 }
 
-export { getAnimationClass, getFixedGeometryCacheTrackClass, getInterpolatorClass, getMorphTrackClass, getNodeEulerRotationTrackClass, getNodeRotationTrackClass, getNodeScaleTrackClass, getNodeTranslationTrackClass, getPCAGeometryCacheTrackClass, getPropTrackClass, getSkeletonClass };
+export { getAnimationClass, getFixedGeometryCacheTrackClass, getInterpolatorClass, getJointDynamicsModifierClass, getJointDynamicsModifierSkeleton, getMorphTrackClass, getNodeEulerRotationTrackClass, getNodeRotationTrackClass, getNodeScaleTrackClass, getNodeTranslationTrackClass, getPCAGeometryCacheTrackClass, getPropTrackClass, getSkeletonClass, getSkeletonRigClass, getSkinBindingClass, setJointDynamicsModifierSkeleton };
 //# sourceMappingURL=animation.js.map