@zephyr3d/scene 0.9.25 → 0.9.27

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

@@ -13,6 +13,13 @@ import { FixedGeometryCacheTrack } from '../../../animation/fixed_geometry_cache
 import { BoundingBox } from '../../bounding_volume.js';
 import { PCAGeometryCacheTrack } from '../../../animation/pca_geometry_cache_track.js';
 import { Skeleton, SkeletonRig, SkinBinding } from '../../../animation/skeleton.js';
+import { SpringModifier } from '../../../animation/spring_modifier.js';
+import { createSpringParticle } from '../../../animation/spring/spring_particle.js';
+import { createSpringConstraint } from '../../../animation/spring/spring_constraint.js';
+import { SpringChain } from '../../../animation/spring/spring_chain.js';
+import { SpringSystem } from '../../../animation/spring/spring_system.js';
+import { MultiChainSpringSystem } from '../../../animation/spring/multi_chain_spring_system.js';
+import { createPlaneCollider, createCapsuleCollider, createSphereCollider } from '../../../animation/spring/spring_collider.js';
 import '@zephyr3d/device';
 import '../../../animation/joint_dynamics/collision.js';
 import '../../../animation/joint_dynamics/solver.js';
@@ -30,7 +37,10 @@ import '../../../material/unlit.js';
 import '../../../material/particle.js';
 import '../../../material/subsurfaceprofile.js';
 import '../../../material/skin.js';
+import '../../../material/eye.js';
 import '../../../material/meshmaterial.js';
+import '../../../material/hair.js';
+import '../../../material/hairstrand.js';
 import '../../../material/grassmaterial.js';
 import '../../../material/terrain-cm.js';
 import '../../../material/pbrmr.js';
@@ -55,6 +65,7 @@ import '../../../scene/meshdrawable.js';
 import '../../../scene/basesprite.js';
 import '../../../material/msdf_text.js';
 import '../../../scene/water.js';
+import '../../../scene/hair.js';
 import '../../../scene/particlesys.js';
 import '../../../scene/batchgroup.js';
 import '../../../scene/terrain-cm/terrain-cm.js';
@@ -62,6 +73,7 @@ import '../../../scene/terrain-cm/grass.js';
 import '../../../scene/raycast_visitor.js';
 
 const jointDynamicsModifierSkeletons = new WeakMap();
+const springModifierSkeletons = new WeakMap();
 function encodeSkeletonBindPose(bindPose) {
     return uint8ArrayToBase64(new Uint8Array(new Float32Array([
         ...bindPose.position,
@@ -77,6 +89,29 @@ function decodeSkeletonBindPose(encoded) {
         scale: new Vector3(data[7], data[8], data[9])
     };
 }
+function encodeSkeletonPose(pose) {
+    const values = pose.flatMap((transform)=>[
+            ...transform.position,
+            ...transform.rotation,
+            ...transform.scale
+        ]);
+    return uint8ArrayToBase64(new Uint8Array(new Float32Array(values).buffer));
+}
+function decodeSkeletonPose(encoded, jointCount) {
+    const data = new Float32Array(base64ToUint8Array(encoded).buffer);
+    if (data.length !== jointCount * 10) {
+        throw new Error('Invalid serialized skeleton pose');
+    }
+    const pose = [];
+    for(let i = 0; i < jointCount; i++){
+        pose.push({
+            position: new Vector3(data[i * 10 + 0], data[i * 10 + 1], data[i * 10 + 2]),
+            rotation: new Quaternion(data[i * 10 + 3], data[i * 10 + 4], data[i * 10 + 5], data[i * 10 + 6]),
+            scale: new Vector3(data[i * 10 + 7], data[i * 10 + 8], data[i * 10 + 9])
+        });
+    }
+    return pose;
+}
 function vectorToArray(value) {
     return [
         value.x,
@@ -87,6 +122,216 @@ function vectorToArray(value) {
 function vectorFromArray(value, defaultValue = Vector3.zero()) {
     return Array.isArray(value) ? new Vector3(value[0] ?? 0, value[1] ?? 0, value[2] ?? 0) : defaultValue.clone();
 }
+function quaternionToArray(value) {
+    return [
+        value.x,
+        value.y,
+        value.z,
+        value.w
+    ];
+}
+function quaternionFromArray(value) {
+    return Array.isArray(value) ? new Quaternion(value[0] ?? 0, value[1] ?? 0, value[2] ?? 0, value[3] ?? 1) : undefined;
+}
+function serializeSpringChain(chain) {
+    return {
+        particles: chain.particles.map((particle)=>({
+                ...particle.node ? {
+                    node: particle.node.persistentId
+                } : {},
+                ...particle.anchorNode ? {
+                    anchorNode: particle.anchorNode.persistentId
+                } : {},
+                ...particle.anchorOffset ? {
+                    anchorOffset: vectorToArray(particle.anchorOffset)
+                } : {},
+                originalPosition: vectorToArray(particle.originalPosition),
+                ...particle.originalRotation ? {
+                    originalRotation: quaternionToArray(particle.originalRotation)
+                } : {},
+                mass: particle.mass,
+                damping: particle.damping,
+                fixed: particle.fixed
+            })),
+        constraints: chain.constraints.map((constraint)=>({
+                particleA: constraint.particleA,
+                particleB: constraint.particleB,
+                restLength: constraint.restLength,
+                stiffness: constraint.stiffness,
+                compliance: constraint.compliance
+            }))
+    };
+}
+function deserializeSpringChain(ctx, data) {
+    const chain = new SpringChain();
+    for (const item of data.particles ?? []){
+        const node = findSerializedNode(ctx, item.node);
+        const anchorNode = findSerializedNode(ctx, item.anchorNode);
+        if (item.node && !node || item.anchorNode && !anchorNode) {
+            return null;
+        }
+        const position = node ? new Vector3(node.worldMatrix.m03, node.worldMatrix.m13, node.worldMatrix.m23) : vectorFromArray(item.originalPosition);
+        let originalRotation = quaternionFromArray(item.originalRotation);
+        if (node) {
+            originalRotation = new Quaternion();
+            node.worldMatrix.decompose(null, originalRotation, null);
+        }
+        chain.addParticle(createSpringParticle(position, {
+            mass: item.mass,
+            damping: item.damping,
+            fixed: item.fixed,
+            node: node ?? undefined,
+            anchorNode: anchorNode ?? undefined,
+            anchorOffset: item.anchorOffset ? vectorFromArray(item.anchorOffset) : undefined,
+            originalRotation
+        }));
+    }
+    for (const item of data.constraints ?? []){
+        if (item.particleA < 0 || item.particleB < 0 || item.particleA >= chain.particles.length || item.particleB >= chain.particles.length) {
+            return null;
+        }
+        chain.addConstraint(createSpringConstraint(item.particleA, item.particleB, item.restLength, item.stiffness, item.compliance));
+    }
+    return chain.particles.length > 0 ? chain : null;
+}
+function serializeSpringCollider(collider) {
+    switch(collider.type){
+        case 'sphere':
+            {
+                const sphere = collider;
+                return {
+                    type: 'sphere',
+                    ...sphere.node ? {
+                        node: sphere.node.persistentId
+                    } : {},
+                    enabled: sphere.enabled,
+                    center: vectorToArray(sphere.center),
+                    radius: sphere.radius,
+                    ...sphere.localRadius !== undefined ? {
+                        localRadius: sphere.localRadius
+                    } : {},
+                    ...sphere.localRadiusScaleRef !== undefined ? {
+                        localRadiusScaleRef: sphere.localRadiusScaleRef
+                    } : {},
+                    ...sphere.localOffset ? {
+                        localOffset: vectorToArray(sphere.localOffset)
+                    } : {}
+                };
+            }
+        case 'capsule':
+            {
+                const capsule = collider;
+                return {
+                    type: 'capsule',
+                    ...capsule.node ? {
+                        node: capsule.node.persistentId
+                    } : {},
+                    enabled: capsule.enabled,
+                    start: vectorToArray(capsule.start),
+                    end: vectorToArray(capsule.end),
+                    radius: capsule.radius,
+                    ...capsule.localRadius !== undefined ? {
+                        localRadius: capsule.localRadius
+                    } : {},
+                    ...capsule.localRadiusScaleRef !== undefined ? {
+                        localRadiusScaleRef: capsule.localRadiusScaleRef
+                    } : {},
+                    ...capsule.localStartOffset ? {
+                        localStartOffset: vectorToArray(capsule.localStartOffset)
+                    } : {},
+                    ...capsule.localEndOffset ? {
+                        localEndOffset: vectorToArray(capsule.localEndOffset)
+                    } : {}
+                };
+            }
+        case 'plane':
+            {
+                const plane = collider;
+                return {
+                    type: 'plane',
+                    ...plane.node ? {
+                        node: plane.node.persistentId
+                    } : {},
+                    enabled: plane.enabled,
+                    point: vectorToArray(plane.point),
+                    normal: vectorToArray(plane.normal),
+                    ...plane.localPointOffset ? {
+                        localPointOffset: vectorToArray(plane.localPointOffset)
+                    } : {},
+                    ...plane.localNormal ? {
+                        localNormal: vectorToArray(plane.localNormal)
+                    } : {}
+                };
+            }
+    }
+}
+function restoreSpringColliderRadiusScale(collider, data) {
+    const createdScaleRef = collider.localRadiusScaleRef;
+    if (data.localRadiusScaleRef !== undefined) {
+        collider.localRadiusScaleRef = data.localRadiusScaleRef;
+    } else if (data.localRadius !== undefined && createdScaleRef !== undefined && Number.isFinite(data.localRadius) && Number.isFinite(data.radius) && Math.abs(data.radius) > 1e-6) {
+        // Older serialized modifiers omitted the authored scale reference. Recover it
+        // from the stored world radius and the node scale captured by the constructor.
+        const inferredScaleRef = data.localRadius * createdScaleRef / data.radius;
+        if (Number.isFinite(inferredScaleRef) && Math.abs(inferredScaleRef) > 1e-6) {
+            collider.localRadiusScaleRef = Math.abs(inferredScaleRef);
+        }
+    }
+    collider.radius = data.radius;
+}
+function deserializeSpringCollider(ctx, data) {
+    const node = findSerializedNode(ctx, data.node);
+    if (data.node && !node) {
+        return null;
+    }
+    let collider;
+    switch(data.type){
+        case 'sphere':
+            {
+                const sphere = createSphereCollider(node && data.localOffset ? vectorFromArray(data.localOffset) : vectorFromArray(data.center), node ? data.localRadius ?? data.radius : data.radius, node ?? undefined);
+                restoreSpringColliderRadiusScale(sphere, data);
+                collider = sphere;
+                break;
+            }
+        case 'capsule':
+            {
+                const capsule = createCapsuleCollider(node && data.localStartOffset ? vectorFromArray(data.localStartOffset) : vectorFromArray(data.start), node && data.localEndOffset ? vectorFromArray(data.localEndOffset) : vectorFromArray(data.end), node ? data.localRadius ?? data.radius : data.radius, node ?? undefined);
+                restoreSpringColliderRadiusScale(capsule, data);
+                collider = capsule;
+                break;
+            }
+        case 'plane':
+            collider = createPlaneCollider(node && data.localPointOffset ? vectorFromArray(data.localPointOffset) : vectorFromArray(data.point), node && data.localNormal ? vectorFromArray(data.localNormal) : vectorFromArray(data.normal), node ?? undefined);
+            break;
+    }
+    collider.enabled = data.enabled;
+    return collider;
+}
+function getSpringSystemOptions(system) {
+    return {
+        iterations: system.iterations,
+        gravity: vectorToArray(system.gravity),
+        wind: vectorToArray(system.wind),
+        enableInertialForces: system.enableInertialForces,
+        centrifugalScale: system.centrifugalScale,
+        coriolisScale: system.coriolisScale,
+        solver: system.solver,
+        poseFollow: system.poseFollow,
+        poseFollowRoot: system.poseFollowRoot,
+        poseFollowTip: system.poseFollowTip,
+        poseFollowExponent: system.poseFollowExponent,
+        maxPoseOffset: system.maxPoseOffset,
+        maxPoseOffsetRoot: system.maxPoseOffsetRoot,
+        maxPoseOffsetTip: system.maxPoseOffsetTip
+    };
+}
+function deserializeSpringSystemOptions(options) {
+    return {
+        ...options,
+        gravity: vectorFromArray(options.gravity, new Vector3(0, -9.8, 0)),
+        wind: vectorFromArray(options.wind)
+    };
+}
 function serializeScalarCurve(value) {
     return {
         mode: value.mode,
@@ -197,6 +442,12 @@ function setJointDynamicsModifierSkeleton(modifier, skeleton) {
 function getJointDynamicsModifierSkeleton(modifier) {
     return jointDynamicsModifierSkeletons.get(modifier) ?? null;
 }
+/** @internal */ function setSpringModifierSkeleton(modifier, skeleton) {
+    springModifierSkeletons.set(modifier, skeleton);
+}
+/** @internal */ function getSpringModifierSkeleton(modifier) {
+    return springModifierSkeletons.get(modifier) ?? null;
+}
 const jointDynamicsPropOptions = {
     group: 'Joint Dynamics'
 };
@@ -394,6 +645,135 @@ function createJointDynamicsCurveProp(name, key, label, description) {
     }
   };
   */ }
+/** @internal */ function getSpringModifierClass() {
+    return {
+        ctor: SpringModifier,
+        name: 'SpringModifier',
+        createFunc (ctx, init) {
+            const skeleton = ctx.findSkeletonRigById(init.skeleton) ?? ctx.findSkeletonById(init.skeleton)?.rig ?? null;
+            if (!skeleton || !Array.isArray(init.chains) || init.chains.length === 0) {
+                return {
+                    obj: null,
+                    loadProps: false
+                };
+            }
+            const chains = init.chains.map((chain)=>deserializeSpringChain(ctx, chain));
+            if (chains.some((chain)=>!chain)) {
+                return {
+                    obj: null,
+                    loadProps: false
+                };
+            }
+            const options = deserializeSpringSystemOptions(init.options);
+            let system;
+            if (init.systemType === 'single') {
+                system = new SpringSystem(chains[0], options);
+            } else {
+                const multiChainSystem = new MultiChainSpringSystem(options);
+                for (const chain of chains){
+                    multiChainSystem.addChain(chain);
+                }
+                for (const constraint of init.interChainConstraints ?? []){
+                    if (constraint.chainAIndex < 0 || constraint.chainBIndex < 0 || constraint.chainAIndex >= chains.length || constraint.chainBIndex >= chains.length) {
+                        continue;
+                    }
+                    multiChainSystem.addInterChainConstraint({
+                        ...constraint,
+                        lambda: 0
+                    });
+                }
+                system = multiChainSystem;
+            }
+            for (const colliderData of init.colliders ?? []){
+                const collider = deserializeSpringCollider(ctx, colliderData);
+                if (collider) {
+                    system.addCollider(collider);
+                }
+            }
+            const modifier = new SpringModifier(system, init.weight ?? 1);
+            modifier.sourceId = init.sourceId ?? '';
+            modifier.enabled = init.enabled ?? true;
+            setSpringModifierSkeleton(modifier, skeleton);
+            return {
+                obj: modifier,
+                loadProps: false
+            };
+        },
+        getInitParams (obj) {
+            const skeleton = getSpringModifierSkeleton(obj);
+            const system = obj.springSystem;
+            const isMultiChain = system instanceof MultiChainSpringSystem;
+            if (!isMultiChain && !(system instanceof SpringSystem)) {
+                throw new Error('Serialize SpringModifier failed: Unsupported spring system type');
+            }
+            const chains = isMultiChain ? system.chains : [
+                system.chain
+            ];
+            const init = {
+                skeleton: skeleton?.persistentId ?? '',
+                sourceId: obj.sourceId,
+                systemType: isMultiChain ? 'multi' : 'single',
+                options: getSpringSystemOptions(system),
+                chains: chains.map(serializeSpringChain),
+                ...isMultiChain ? {
+                    interChainConstraints: system.interChainConstraints.map(({ lambda: _lambda, ...constraint })=>constraint)
+                } : {},
+                colliders: system.colliders.map(serializeSpringCollider),
+                enabled: obj.enabled,
+                weight: obj.weight
+            };
+            return init;
+        },
+        getProps () {
+            return defineProps([
+                {
+                    name: 'Commands',
+                    description: 'Reset spring modifier state',
+                    type: 'command',
+                    command () {
+                        this.reset();
+                        return false;
+                    },
+                    get (value) {
+                        value.str[0] = 'Reset';
+                    }
+                },
+                {
+                    name: 'Enabled',
+                    description: 'Whether this spring modifier is active',
+                    type: 'bool',
+                    isPersistent () {
+                        return false;
+                    },
+                    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 spring physics',
+                    type: 'float',
+                    options: {
+                        minValue: 0,
+                        maxValue: 1
+                    },
+                    isPersistent () {
+                        return false;
+                    },
+                    get (value) {
+                        value.num[0] = this.weight;
+                    },
+                    set (value) {
+                        this.weight = value.num[0];
+                    }
+                }
+            ]);
+        }
+    };
+}
 /** @internal */ function getJointDynamicsModifierClass() {
     return {
         ctor: JointDynamicsModifier,
@@ -410,9 +790,15 @@ function createJointDynamicsCurveProp(name, key, label, description) {
             const chains = (init.chains ?? []).map((chain)=>{
                 const start = findSerializedNode(ctx, chain.start);
                 const end = findSerializedNode(ctx, chain.end);
+                const startAnchor = findSerializedNode(ctx, chain.startAnchor);
+                const endAnchor = findSerializedNode(ctx, chain.endAnchor);
                 return start && end ? {
                     start,
-                    end
+                    end,
+                    startAnchor: startAnchor ?? undefined,
+                    endAnchor: endAnchor ?? undefined,
+                    startAnchorOffset: chain.startAnchorOffset ? vectorFromArray(chain.startAnchorOffset) : undefined,
+                    endAnchorOffset: chain.endAnchorOffset ? vectorFromArray(chain.endAnchorOffset) : undefined
                 } : null;
             }).filter((chain)=>{
                 return !!chain && chain.start.isParentOf(chain.end);
@@ -488,7 +874,11 @@ function createJointDynamicsCurveProp(name, key, label, description) {
                 systemRoot: chainConfig.systemRoot.persistentId,
                 chains: chainConfig.chains.map((chain)=>({
                         start: chain.start.persistentId,
-                        end: chain.end.persistentId
+                        end: chain.end.persistentId,
+                        startAnchor: chain.startAnchor?.persistentId,
+                        endAnchor: chain.endAnchor?.persistentId,
+                        startAnchorOffset: chain.startAnchorOffset ? vectorToArray(chain.startAnchorOffset) : undefined,
+                        endAnchorOffset: chain.endAnchorOffset ? vectorToArray(chain.endAnchorOffset) : undefined
                     })),
                 controllerConfig: serializeControllerConfig(controllerConfig),
                 colliders: obj.jointDynamicsSystem.getColliderSnapshots().map((item)=>({
@@ -1457,6 +1847,7 @@ function getPCAGeometryCacheTrackClass() {
             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 retargetPose = init.retargetPose ? decodeSkeletonPose(init.retargetPose, joints.length) : undefined;
             const inverseBindMatrices = [];
             const bindPose = [];
             for(let i = 0; i < joints.length; i++){
@@ -1482,7 +1873,8 @@ function getPCAGeometryCacheTrackClass() {
             if (!rig) {
                 rig = new SkeletonRig(joints, bindPose, {
                     rootJoint,
-                    rootBindPose
+                    rootBindPose,
+                    retargetPose
                 });
                 ctx.animationSet.rigs.push(new DRef(rig));
             }
@@ -1514,6 +1906,7 @@ function getPCAGeometryCacheTrackClass() {
                 rootBindPose: encodeSkeletonBindPose(obj.rig.rootBindPose),
                 inverseBindMatrices: uint8ArrayToBase64(new Uint8Array(new Float32Array(inverseBindMatrices).buffer)),
                 bindPose: uint8ArrayToBase64(new Uint8Array(new Float32Array(bindPose).buffer)),
+                retargetPose: obj.rig.hasRetargetPose ? encodeSkeletonPose(obj.rig.retargetPose) : undefined,
                 id: obj.persistentId
             };
         },
@@ -1556,9 +1949,11 @@ function getPCAGeometryCacheTrackClass() {
                     });
                 }
             }
+            const retargetPose = init.retargetPose ? decodeSkeletonPose(init.retargetPose, joints.length) : undefined;
             const rig = new SkeletonRig(joints, bindPose, {
                 rootJoint,
-                rootBindPose
+                rootBindPose,
+                retargetPose
             });
             rig.persistentId = init.id;
             return {
@@ -1580,6 +1975,7 @@ function getPCAGeometryCacheTrackClass() {
                 rootJoint: obj.rootJoint?.persistentId ?? '',
                 rootBindPose: encodeSkeletonBindPose(obj.rootBindPose),
                 bindPose: uint8ArrayToBase64(new Uint8Array(new Float32Array(bindPose).buffer)),
+                retargetPose: obj.hasRetargetPose ? encodeSkeletonPose(obj.retargetPose) : undefined,
                 id: obj.persistentId
             };
         },
@@ -1792,5 +2188,5 @@ function getPCAGeometryCacheTrackClass() {
     };
 }
 
-export { getAnimationClass, getFixedGeometryCacheTrackClass, getInterpolatorClass, getInterpolatorScalarClass, getJointDynamicsModifierClass, getJointDynamicsModifierSkeleton, getMorphTargetGroupTrackClass, getMorphTrackClass, getNodeEulerRotationTrackClass, getNodeRotationTrackClass, getNodeScaleTrackClass, getNodeTranslationTrackClass, getPCAGeometryCacheTrackClass, getPropTrackClass, getSkeletonClass, getSkeletonRigClass, getSkinBindingClass, setJointDynamicsModifierSkeleton };
+export { getAnimationClass, getFixedGeometryCacheTrackClass, getInterpolatorClass, getInterpolatorScalarClass, getJointDynamicsModifierClass, getJointDynamicsModifierSkeleton, getMorphTargetGroupTrackClass, getMorphTrackClass, getNodeEulerRotationTrackClass, getNodeRotationTrackClass, getNodeScaleTrackClass, getNodeTranslationTrackClass, getPCAGeometryCacheTrackClass, getPropTrackClass, getSkeletonClass, getSkeletonRigClass, getSkinBindingClass, getSpringModifierClass, getSpringModifierSkeleton, setJointDynamicsModifierSkeleton, setSpringModifierSkeleton };
 //# sourceMappingURL=animation.js.map