@zephyr3d/scene 0.7.1 → 0.8.1

package/dist/animation/spring/spring_chain.js

@@ -0,0 +1,103 @@
+import { Vector3, Quaternion } from '@zephyr3d/base';
+import { createSpringParticle } from './spring_particle.js';
+import { createSpringConstraint } from './spring_constraint.js';
+
+/**
+ * Manages a chain of spring particles and constraints
+ *
+ * @public
+ */ class SpringChain {
+    /** Array of particles in the chain */ particles;
+    /** Array of constraints between particles */ constraints;
+    constructor(){
+        this.particles = [];
+        this.constraints = [];
+    }
+    /**
+   * Creates a spring chain from a bone hierarchy
+   * @param startNode - Root node of the bone chain
+   * @param endNode - End node of the bone chain (optional, if null uses all descendants)
+   * @param options - Additional options
+   * @returns A new SpringChain instance
+   */ static fromBoneChain(startNode, endNode = null, options) {
+        const chain = new SpringChain();
+        const mass = options?.mass ?? 1.0;
+        const damping = options?.damping ?? 0.95;
+        const stiffness = options?.stiffness ?? 0.8;
+        // Collect nodes from startNode to endNode
+        const nodes = [];
+        let current = startNode;
+        while(current){
+            nodes.push(current);
+            if (current === endNode) {
+                break;
+            }
+            if (current.children && current.children.length > 0) {
+                current = current.children[0].get();
+            } else {
+                break;
+            }
+        }
+        // Create particles for each bone
+        for(let i = 0; i < nodes.length; i++){
+            const node = nodes[i];
+            const worldPos = new Vector3(node.worldMatrix.m03, node.worldMatrix.m13, node.worldMatrix.m23);
+            // Get the original world rotation
+            const originalRotation = new Quaternion();
+            node.worldMatrix.decompose(null, originalRotation, null);
+            const particle = createSpringParticle(worldPos, {
+                mass,
+                damping,
+                fixed: i === 0,
+                node,
+                originalRotation
+            });
+            const particleIndex = chain.addParticle(particle);
+            // Create constraint with previous particle
+            if (i > 0) {
+                const prevIndex = particleIndex - 1;
+                const prevParticle = chain.particles[prevIndex];
+                const restLength = Vector3.distance(particle.position, prevParticle.position);
+                chain.addConstraint(createSpringConstraint(prevIndex, particleIndex, restLength, stiffness));
+            }
+        }
+        return chain;
+    }
+    /**
+   * Adds a particle to the chain
+   * @param particle - The particle to add
+   * @returns The index of the added particle
+   */ addParticle(particle) {
+        this.particles.push(particle);
+        return this.particles.length - 1;
+    }
+    /**
+   * Adds a constraint to the chain
+   * @param constraint - The constraint to add
+   */ addConstraint(constraint) {
+        this.constraints.push(constraint);
+    }
+    /**
+   * Adds cross constraints between particles for cloth-like behavior
+   * @param stiffness - Stiffness of the cross constraints
+   * @param skipDistance - Distance between particles to connect (default: 2)
+   */ addCrossConstraints(stiffness = 0.6, skipDistance = 2) {
+        for(let i = 0; i < this.particles.length - skipDistance; i++){
+            const pA = this.particles[i];
+            const pB = this.particles[i + skipDistance];
+            const restLength = Vector3.distance(pA.position, pB.position);
+            this.addConstraint(createSpringConstraint(i, i + skipDistance, restLength, stiffness));
+        }
+    }
+    /**
+   * Resets all particles to their original positions
+   */ reset() {
+        for (const particle of this.particles){
+            particle.position.set(particle.originalPosition);
+            particle.prevPosition.set(particle.originalPosition);
+        }
+    }
+}
+
+export { SpringChain };
+//# sourceMappingURL=spring_chain.js.map

package/dist/animation/spring/spring_chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring_chain.js","sources":["../../../src/animation/spring/spring_chain.ts"],"sourcesContent":["import { Vector3, Quaternion } from '@zephyr3d/base';\r\nimport type { SceneNode } from '../../scene/scene_node';\r\nimport type { SpringParticle } from './spring_particle';\r\nimport { createSpringParticle } from './spring_particle';\r\nimport type { SpringConstraint } from './spring_constraint';\r\nimport { createSpringConstraint } from './spring_constraint';\r\n\r\n/**\r\n * Manages a chain of spring particles and constraints\r\n *\r\n * @public\r\n */\r\nexport class SpringChain {\r\n  /** Array of particles in the chain */\r\n  particles: SpringParticle[];\r\n  /** Array of constraints between particles */\r\n  constraints: SpringConstraint[];\r\n\r\n  constructor() {\r\n    this.particles = [];\r\n    this.constraints = [];\r\n  }\r\n\r\n  /**\r\n   * Creates a spring chain from a bone hierarchy\r\n   * @param startNode - Root node of the bone chain\r\n   * @param endNode - End node of the bone chain (optional, if null uses all descendants)\r\n   * @param options - Additional options\r\n   * @returns A new SpringChain instance\r\n   */\r\n  static fromBoneChain(\r\n    startNode: SceneNode,\r\n    endNode: SceneNode | null = null,\r\n    options?: {\r\n      mass?: number;\r\n      damping?: number;\r\n      stiffness?: number;\r\n    }\r\n  ): SpringChain {\r\n    const chain = new SpringChain();\r\n    const mass = options?.mass ?? 1.0;\r\n    const damping = options?.damping ?? 0.95;\r\n    const stiffness = options?.stiffness ?? 0.8;\r\n\r\n    // Collect nodes from startNode to endNode\r\n    const nodes: SceneNode[] = [];\r\n    let current: SceneNode | null = startNode;\r\n\r\n    while (current) {\r\n      nodes.push(current);\r\n      if (current === endNode) {\r\n        break;\r\n      }\r\n\r\n      if (current.children && current.children.length > 0) {\r\n        current = current.children[0].get();\r\n      } else {\r\n        break;\r\n      }\r\n    }\r\n\r\n    // Create particles for each bone\r\n    for (let i = 0; i < nodes.length; i++) {\r\n      const node = nodes[i];\r\n      const worldPos = new Vector3(node.worldMatrix.m03, node.worldMatrix.m13, node.worldMatrix.m23);\r\n\r\n      // Get the original world rotation\r\n      const originalRotation = new Quaternion();\r\n      node.worldMatrix.decompose(null, originalRotation, null);\r\n\r\n      const particle = createSpringParticle(worldPos, {\r\n        mass,\r\n        damping,\r\n        fixed: i === 0, // First particle is fixed (anchor)\r\n        node,\r\n        originalRotation\r\n      });\r\n\r\n      const particleIndex = chain.addParticle(particle);\r\n\r\n      // Create constraint with previous particle\r\n      if (i > 0) {\r\n        const prevIndex = particleIndex - 1;\r\n        const prevParticle = chain.particles[prevIndex];\r\n        const restLength = Vector3.distance(particle.position, prevParticle.position);\r\n\r\n        chain.addConstraint(createSpringConstraint(prevIndex, particleIndex, restLength, stiffness));\r\n      }\r\n    }\r\n\r\n    return chain;\r\n  }\r\n\r\n  /**\r\n   * Adds a particle to the chain\r\n   * @param particle - The particle to add\r\n   * @returns The index of the added particle\r\n   */\r\n  addParticle(particle: SpringParticle): number {\r\n    this.particles.push(particle);\r\n    return this.particles.length - 1;\r\n  }\r\n\r\n  /**\r\n   * Adds a constraint to the chain\r\n   * @param constraint - The constraint to add\r\n   */\r\n  addConstraint(constraint: SpringConstraint): void {\r\n    this.constraints.push(constraint);\r\n  }\r\n\r\n  /**\r\n   * Adds cross constraints between particles for cloth-like behavior\r\n   * @param stiffness - Stiffness of the cross constraints\r\n   * @param skipDistance - Distance between particles to connect (default: 2)\r\n   */\r\n  addCrossConstraints(stiffness: number = 0.6, skipDistance: number = 2): void {\r\n    for (let i = 0; i < this.particles.length - skipDistance; i++) {\r\n      const pA = this.particles[i];\r\n      const pB = this.particles[i + skipDistance];\r\n      const restLength = Vector3.distance(pA.position, pB.position);\r\n\r\n      this.addConstraint(createSpringConstraint(i, i + skipDistance, restLength, stiffness));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Resets all particles to their original positions\r\n   */\r\n  reset(): void {\r\n    for (const particle of this.particles) {\r\n      particle.position.set(particle.originalPosition);\r\n      particle.prevPosition.set(particle.originalPosition);\r\n    }\r\n  }\r\n}\r\n"],"names":["SpringChain","particles","constraints","fromBoneChain","startNode","endNode","options","chain","mass","damping","stiffness","nodes","current","push","children","length","get","i","node","worldPos","Vector3","worldMatrix","m03","m13","m23","originalRotation","Quaternion","decompose","particle","createSpringParticle","fixed","particleIndex","addParticle","prevIndex","prevParticle","restLength","distance","position","addConstraint","createSpringConstraint","constraint","addCrossConstraints","skipDistance","pA","pB","reset","set","originalPosition","prevPosition"],"mappings":"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"}

package/dist/animation/spring/spring_collider.js

@@ -0,0 +1,247 @@
+import { Vector3 } from '@zephyr3d/base';
+
+/**
+ * Creates a sphere collider
+ * @param centerOrOffset - Center position in world space, or local offset if node is provided
+ * @param radius - Radius of the sphere
+ * @param node - Optional scene node to attach to (if provided, centerOrOffset is treated as local offset)
+ *
+ * @public
+ */ function createSphereCollider(centerOrOffset, radius, node) {
+    if (node) {
+        // If node is provided, treat centerOrOffset as local offset
+        const worldMatrix = node.worldMatrix;
+        const worldCenter = new Vector3(worldMatrix.m03 + centerOrOffset.x, worldMatrix.m13 + centerOrOffset.y, worldMatrix.m23 + centerOrOffset.z);
+        return {
+            type: 'sphere',
+            center: worldCenter,
+            radius,
+            node,
+            enabled: true,
+            localOffset: centerOrOffset.clone()
+        };
+    } else {
+        // No node, use as world position
+        return {
+            type: 'sphere',
+            center: centerOrOffset.clone(),
+            radius,
+            node: null,
+            enabled: true
+        };
+    }
+}
+/**
+ * Creates a capsule collider
+ * @param startOrOffset - Start point in world space, or local offset if node is provided
+ * @param endOrOffset - End point in world space, or local offset if node is provided
+ * @param radius - Radius of the capsule
+ * @param node - Optional scene node to attach to (if provided, offsets are treated as local)
+ *
+ * @public
+ */ function createCapsuleCollider(startOrOffset, endOrOffset, radius, node) {
+    if (node) {
+        // If node is provided, treat as local offsets
+        const worldMatrix = node.worldMatrix;
+        const worldStart = new Vector3(worldMatrix.m03 + startOrOffset.x, worldMatrix.m13 + startOrOffset.y, worldMatrix.m23 + startOrOffset.z);
+        const worldEnd = new Vector3(worldMatrix.m03 + endOrOffset.x, worldMatrix.m13 + endOrOffset.y, worldMatrix.m23 + endOrOffset.z);
+        return {
+            type: 'capsule',
+            start: worldStart,
+            end: worldEnd,
+            radius,
+            node,
+            enabled: true,
+            localStartOffset: startOrOffset.clone(),
+            localEndOffset: endOrOffset.clone()
+        };
+    } else {
+        // No node, use as world positions
+        return {
+            type: 'capsule',
+            start: startOrOffset.clone(),
+            end: endOrOffset.clone(),
+            radius,
+            node: null,
+            enabled: true
+        };
+    }
+}
+/**
+ * Creates a plane collider
+ * @param pointOrOffset - Point on plane in world space, or local offset if node is provided
+ * @param normal - Normal vector (will be normalized)
+ * @param node - Optional scene node to attach to (if provided, pointOrOffset is treated as local offset)
+ *
+ * @public
+ */ function createPlaneCollider(pointOrOffset, normal, node) {
+    const normalizedNormal = new Vector3();
+    Vector3.normalize(normal, normalizedNormal);
+    if (node) {
+        // If node is provided, treat as local offset
+        const worldMatrix = node.worldMatrix;
+        const worldPoint = new Vector3(worldMatrix.m03 + pointOrOffset.x, worldMatrix.m13 + pointOrOffset.y, worldMatrix.m23 + pointOrOffset.z);
+        return {
+            type: 'plane',
+            point: worldPoint,
+            normal: normalizedNormal.clone(),
+            node,
+            enabled: true,
+            localPointOffset: pointOrOffset.clone(),
+            localNormal: normalizedNormal.clone()
+        };
+    } else {
+        // No node, use as world position
+        return {
+            type: 'plane',
+            point: pointOrOffset.clone(),
+            normal: normalizedNormal,
+            node: null,
+            enabled: true
+        };
+    }
+}
+/**
+ * Resolves collision between a particle and a sphere collider
+ * @returns true if collision occurred
+ *
+ * @public
+ */ function resolveSphereCollision(particlePos, collider) {
+    const toParticle = Vector3.sub(particlePos, collider.center, new Vector3());
+    const distSq = toParticle.magnitudeSq;
+    const radiusSq = collider.radius * collider.radius;
+    if (distSq < radiusSq && distSq > 0.0001) {
+        // Particle is inside sphere, push it out
+        const dist = Math.sqrt(distSq);
+        const penetration = collider.radius - dist;
+        // Push particle to sphere surface
+        Vector3.normalize(toParticle, toParticle);
+        toParticle.scaleBy(penetration);
+        Vector3.add(particlePos, toParticle, particlePos);
+        return true;
+    }
+    return false;
+}
+/**
+ * Resolves collision between a particle and a capsule collider
+ * @returns true if collision occurred
+ *
+ * @public
+ */ function resolveCapsuleCollision(particlePos, collider) {
+    // Find closest point on capsule axis
+    const axis = Vector3.sub(collider.end, collider.start, new Vector3());
+    const axisLength = axis.magnitude;
+    if (axisLength < 0.0001) {
+        // Degenerate capsule, treat as sphere
+        const toParticle = Vector3.sub(particlePos, collider.start, new Vector3());
+        const distSq = toParticle.magnitudeSq;
+        const radiusSq = collider.radius * collider.radius;
+        if (distSq < radiusSq && distSq > 0.0001) {
+            const dist = Math.sqrt(distSq);
+            const penetration = collider.radius - dist;
+            Vector3.normalize(toParticle, toParticle);
+            toParticle.scaleBy(penetration);
+            Vector3.add(particlePos, toParticle, particlePos);
+            return true;
+        }
+        return false;
+    }
+    Vector3.normalize(axis, axis);
+    const toParticle = Vector3.sub(particlePos, collider.start, new Vector3());
+    const projection = Vector3.dot(toParticle, axis);
+    // Clamp projection to capsule length
+    const t = Math.max(0, Math.min(axisLength, projection));
+    // Closest point on capsule axis
+    const closestPoint = Vector3.add(collider.start, Vector3.scale(axis, t, new Vector3()), new Vector3());
+    // Check distance from closest point
+    const toParticleFromAxis = Vector3.sub(particlePos, closestPoint, new Vector3());
+    const distSq = toParticleFromAxis.magnitudeSq;
+    const radiusSq = collider.radius * collider.radius;
+    if (distSq < radiusSq && distSq > 0.0001) {
+        const dist = Math.sqrt(distSq);
+        const penetration = collider.radius - dist;
+        Vector3.normalize(toParticleFromAxis, toParticleFromAxis);
+        toParticleFromAxis.scaleBy(penetration);
+        Vector3.add(particlePos, toParticleFromAxis, particlePos);
+        return true;
+    }
+    return false;
+}
+/**
+ * Resolves collision between a particle and a plane collider
+ * @returns true if collision occurred
+ *
+ * @public
+ */ function resolvePlaneCollision(particlePos, collider) {
+    const toParticle = Vector3.sub(particlePos, collider.point, new Vector3());
+    const distance = Vector3.dot(toParticle, collider.normal);
+    if (distance < 0) {
+        // Particle is below plane, push it up
+        const correction = Vector3.scale(collider.normal, -distance, new Vector3());
+        Vector3.add(particlePos, correction, particlePos);
+        return true;
+    }
+    return false;
+}
+/**
+ * Updates collider position from its associated node
+ *
+ * @public
+ */ function updateColliderFromNode(collider) {
+    if (!collider.node || !collider.enabled) {
+        return;
+    }
+    const worldMatrix = collider.node.worldMatrix;
+    switch(collider.type){
+        case 'sphere':
+            {
+                const sphere = collider;
+                if (sphere.localOffset) {
+                    // Transform local offset to world space
+                    worldMatrix.transformPointAffine(sphere.localOffset, sphere.center);
+                } else {
+                    // No local offset, just use node position
+                    sphere.center.x = worldMatrix.m03;
+                    sphere.center.y = worldMatrix.m13;
+                    sphere.center.z = worldMatrix.m23;
+                }
+                break;
+            }
+        case 'capsule':
+            {
+                const capsule = collider;
+                if (capsule.localStartOffset && capsule.localEndOffset) {
+                    // Transform local offsets to world space
+                    worldMatrix.transformPointAffine(capsule.localStartOffset, capsule.start);
+                    worldMatrix.transformPointAffine(capsule.localEndOffset, capsule.end);
+                } else {
+                    // No local offsets, just use node position for start
+                    capsule.start.x = worldMatrix.m03;
+                    capsule.start.y = worldMatrix.m13;
+                    capsule.start.z = worldMatrix.m23;
+                }
+                break;
+            }
+        case 'plane':
+            {
+                const plane = collider;
+                if (plane.localPointOffset) {
+                    // Transform local offset to world space
+                    worldMatrix.transformPointAffine(plane.localPointOffset, plane.point);
+                } else {
+                    // No local offset, just use node position
+                    plane.point.x = worldMatrix.m03;
+                    plane.point.y = worldMatrix.m13;
+                    plane.point.z = worldMatrix.m23;
+                }
+                if (plane.localNormal) {
+                    // Transform local normal to world space (rotation only)
+                    worldMatrix.transformVectorAffine(plane.localNormal, plane.normal).inplaceNormalize;
+                }
+                break;
+            }
+    }
+}
+
+export { createCapsuleCollider, createPlaneCollider, createSphereCollider, resolveCapsuleCollision, resolvePlaneCollision, resolveSphereCollision, updateColliderFromNode };
+//# sourceMappingURL=spring_collider.js.map

package/dist/animation/spring/spring_collider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring_collider.js","sources":["../../../src/animation/spring/spring_collider.ts"],"sourcesContent":["import type { Nullable } from '@zephyr3d/base';\r\nimport { Vector3 } from '@zephyr3d/base';\r\nimport type { SceneNode } from '../../scene/scene_node';\r\n\r\n/**\r\n * Base interface for spring collision shapes\r\n *\r\n * @public\r\n */\r\nexport interface SpringCollider {\r\n  /** Type of collider */\r\n  type: 'sphere' | 'capsule' | 'plane';\r\n  /** Associated scene node (optional, for dynamic colliders) */\r\n  node?: Nullable<SceneNode>;\r\n  /** Whether this collider is enabled */\r\n  enabled: boolean;\r\n}\r\n\r\n/**\r\n * Sphere collider for spring collision detection\r\n *\r\n * @public\r\n */\r\nexport interface SphereCollider extends SpringCollider {\r\n  type: 'sphere';\r\n  /** Center position in world space */\r\n  center: Vector3;\r\n  /** Radius of the sphere */\r\n  radius: number;\r\n  /** Local offset from node (if node is set) */\r\n  localOffset?: Vector3;\r\n}\r\n\r\n/**\r\n * Capsule collider for spring collision detection\r\n *\r\n * @public\r\n */\r\nexport interface CapsuleCollider extends SpringCollider {\r\n  type: 'capsule';\r\n  /** Start point of the capsule axis in world space */\r\n  start: Vector3;\r\n  /** End point of the capsule axis in world space */\r\n  end: Vector3;\r\n  /** Radius of the capsule */\r\n  radius: number;\r\n  /** Local start offset from node (if node is set) */\r\n  localStartOffset?: Vector3;\r\n  /** Local end offset from node (if node is set) */\r\n  localEndOffset?: Vector3;\r\n}\r\n\r\n/**\r\n * Plane collider for spring collision detection\r\n *\r\n * @public\r\n */\r\nexport interface PlaneCollider extends SpringCollider {\r\n  type: 'plane';\r\n  /** Point on the plane in world space */\r\n  point: Vector3;\r\n  /** Normal vector of the plane (should be normalized) */\r\n  normal: Vector3;\r\n  /** Local point offset from node (if node is set) */\r\n  localPointOffset?: Vector3;\r\n  /** Local normal direction (if node is set) */\r\n  localNormal?: Vector3;\r\n}\r\n\r\n/**\r\n * Creates a sphere collider\r\n * @param centerOrOffset - Center position in world space, or local offset if node is provided\r\n * @param radius - Radius of the sphere\r\n * @param node - Optional scene node to attach to (if provided, centerOrOffset is treated as local offset)\r\n *\r\n * @public\r\n */\r\nexport function createSphereCollider(\r\n  centerOrOffset: Vector3,\r\n  radius: number,\r\n  node?: SceneNode\r\n): SphereCollider {\r\n  if (node) {\r\n    // If node is provided, treat centerOrOffset as local offset\r\n    const worldMatrix = node.worldMatrix;\r\n    const worldCenter = new Vector3(\r\n      worldMatrix.m03 + centerOrOffset.x,\r\n      worldMatrix.m13 + centerOrOffset.y,\r\n      worldMatrix.m23 + centerOrOffset.z\r\n    );\r\n\r\n    return {\r\n      type: 'sphere',\r\n      center: worldCenter,\r\n      radius,\r\n      node,\r\n      enabled: true,\r\n      localOffset: centerOrOffset.clone()\r\n    };\r\n  } else {\r\n    // No node, use as world position\r\n    return {\r\n      type: 'sphere',\r\n      center: centerOrOffset.clone(),\r\n      radius,\r\n      node: null,\r\n      enabled: true\r\n    };\r\n  }\r\n}\r\n\r\n/**\r\n * Creates a capsule collider\r\n * @param startOrOffset - Start point in world space, or local offset if node is provided\r\n * @param endOrOffset - End point in world space, or local offset if node is provided\r\n * @param radius - Radius of the capsule\r\n * @param node - Optional scene node to attach to (if provided, offsets are treated as local)\r\n *\r\n * @public\r\n */\r\nexport function createCapsuleCollider(\r\n  startOrOffset: Vector3,\r\n  endOrOffset: Vector3,\r\n  radius: number,\r\n  node?: SceneNode\r\n): CapsuleCollider {\r\n  if (node) {\r\n    // If node is provided, treat as local offsets\r\n    const worldMatrix = node.worldMatrix;\r\n    const worldStart = new Vector3(\r\n      worldMatrix.m03 + startOrOffset.x,\r\n      worldMatrix.m13 + startOrOffset.y,\r\n      worldMatrix.m23 + startOrOffset.z\r\n    );\r\n    const worldEnd = new Vector3(\r\n      worldMatrix.m03 + endOrOffset.x,\r\n      worldMatrix.m13 + endOrOffset.y,\r\n      worldMatrix.m23 + endOrOffset.z\r\n    );\r\n\r\n    return {\r\n      type: 'capsule',\r\n      start: worldStart,\r\n      end: worldEnd,\r\n      radius,\r\n      node,\r\n      enabled: true,\r\n      localStartOffset: startOrOffset.clone(),\r\n      localEndOffset: endOrOffset.clone()\r\n    };\r\n  } else {\r\n    // No node, use as world positions\r\n    return {\r\n      type: 'capsule',\r\n      start: startOrOffset.clone(),\r\n      end: endOrOffset.clone(),\r\n      radius,\r\n      node: null,\r\n      enabled: true\r\n    };\r\n  }\r\n}\r\n\r\n/**\r\n * Creates a plane collider\r\n * @param pointOrOffset - Point on plane in world space, or local offset if node is provided\r\n * @param normal - Normal vector (will be normalized)\r\n * @param node - Optional scene node to attach to (if provided, pointOrOffset is treated as local offset)\r\n *\r\n * @public\r\n */\r\nexport function createPlaneCollider(\r\n  pointOrOffset: Vector3,\r\n  normal: Vector3,\r\n  node?: SceneNode\r\n): PlaneCollider {\r\n  const normalizedNormal = new Vector3();\r\n  Vector3.normalize(normal, normalizedNormal);\r\n\r\n  if (node) {\r\n    // If node is provided, treat as local offset\r\n    const worldMatrix = node.worldMatrix;\r\n    const worldPoint = new Vector3(\r\n      worldMatrix.m03 + pointOrOffset.x,\r\n      worldMatrix.m13 + pointOrOffset.y,\r\n      worldMatrix.m23 + pointOrOffset.z\r\n    );\r\n\r\n    return {\r\n      type: 'plane',\r\n      point: worldPoint,\r\n      normal: normalizedNormal.clone(),\r\n      node,\r\n      enabled: true,\r\n      localPointOffset: pointOrOffset.clone(),\r\n      localNormal: normalizedNormal.clone()\r\n    };\r\n  } else {\r\n    // No node, use as world position\r\n    return {\r\n      type: 'plane',\r\n      point: pointOrOffset.clone(),\r\n      normal: normalizedNormal,\r\n      node: null,\r\n      enabled: true\r\n    };\r\n  }\r\n}\r\n\r\n/**\r\n * Resolves collision between a particle and a sphere collider\r\n * @returns true if collision occurred\r\n *\r\n * @public\r\n */\r\nexport function resolveSphereCollision(particlePos: Vector3, collider: SphereCollider): boolean {\r\n  const toParticle = Vector3.sub(particlePos, collider.center, new Vector3());\r\n  const distSq = toParticle.magnitudeSq;\r\n  const radiusSq = collider.radius * collider.radius;\r\n\r\n  if (distSq < radiusSq && distSq > 0.0001) {\r\n    // Particle is inside sphere, push it out\r\n    const dist = Math.sqrt(distSq);\r\n    const penetration = collider.radius - dist;\r\n\r\n    // Push particle to sphere surface\r\n    Vector3.normalize(toParticle, toParticle);\r\n    toParticle.scaleBy(penetration);\r\n    Vector3.add(particlePos, toParticle, particlePos);\r\n\r\n    return true;\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\n/**\r\n * Resolves collision between a particle and a capsule collider\r\n * @returns true if collision occurred\r\n *\r\n * @public\r\n */\r\nexport function resolveCapsuleCollision(particlePos: Vector3, collider: CapsuleCollider): boolean {\r\n  // Find closest point on capsule axis\r\n  const axis = Vector3.sub(collider.end, collider.start, new Vector3());\r\n  const axisLength = axis.magnitude;\r\n\r\n  if (axisLength < 0.0001) {\r\n    // Degenerate capsule, treat as sphere\r\n    const toParticle = Vector3.sub(particlePos, collider.start, new Vector3());\r\n    const distSq = toParticle.magnitudeSq;\r\n    const radiusSq = collider.radius * collider.radius;\r\n\r\n    if (distSq < radiusSq && distSq > 0.0001) {\r\n      const dist = Math.sqrt(distSq);\r\n      const penetration = collider.radius - dist;\r\n      Vector3.normalize(toParticle, toParticle);\r\n      toParticle.scaleBy(penetration);\r\n      Vector3.add(particlePos, toParticle, particlePos);\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  Vector3.normalize(axis, axis);\r\n\r\n  const toParticle = Vector3.sub(particlePos, collider.start, new Vector3());\r\n  const projection = Vector3.dot(toParticle, axis);\r\n\r\n  // Clamp projection to capsule length\r\n  const t = Math.max(0, Math.min(axisLength, projection));\r\n\r\n  // Closest point on capsule axis\r\n  const closestPoint = Vector3.add(collider.start, Vector3.scale(axis, t, new Vector3()), new Vector3());\r\n\r\n  // Check distance from closest point\r\n  const toParticleFromAxis = Vector3.sub(particlePos, closestPoint, new Vector3());\r\n  const distSq = toParticleFromAxis.magnitudeSq;\r\n  const radiusSq = collider.radius * collider.radius;\r\n\r\n  if (distSq < radiusSq && distSq > 0.0001) {\r\n    const dist = Math.sqrt(distSq);\r\n    const penetration = collider.radius - dist;\r\n    Vector3.normalize(toParticleFromAxis, toParticleFromAxis);\r\n    toParticleFromAxis.scaleBy(penetration);\r\n    Vector3.add(particlePos, toParticleFromAxis, particlePos);\r\n    return true;\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\n/**\r\n * Resolves collision between a particle and a plane collider\r\n * @returns true if collision occurred\r\n *\r\n * @public\r\n */\r\nexport function resolvePlaneCollision(particlePos: Vector3, collider: PlaneCollider): boolean {\r\n  const toParticle = Vector3.sub(particlePos, collider.point, new Vector3());\r\n  const distance = Vector3.dot(toParticle, collider.normal);\r\n\r\n  if (distance < 0) {\r\n    // Particle is below plane, push it up\r\n    const correction = Vector3.scale(collider.normal, -distance, new Vector3());\r\n    Vector3.add(particlePos, correction, particlePos);\r\n    return true;\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\n/**\r\n * Updates collider position from its associated node\r\n *\r\n * @public\r\n */\r\nexport function updateColliderFromNode(collider: SpringCollider): void {\r\n  if (!collider.node || !collider.enabled) {\r\n    return;\r\n  }\r\n\r\n  const worldMatrix = collider.node.worldMatrix;\r\n\r\n  switch (collider.type) {\r\n    case 'sphere': {\r\n      const sphere = collider as SphereCollider;\r\n      if (sphere.localOffset) {\r\n        // Transform local offset to world space\r\n        worldMatrix.transformPointAffine(sphere.localOffset, sphere.center);\r\n      } else {\r\n        // No local offset, just use node position\r\n        sphere.center.x = worldMatrix.m03;\r\n        sphere.center.y = worldMatrix.m13;\r\n        sphere.center.z = worldMatrix.m23;\r\n      }\r\n      break;\r\n    }\r\n\r\n    case 'capsule': {\r\n      const capsule = collider as CapsuleCollider;\r\n      if (capsule.localStartOffset && capsule.localEndOffset) {\r\n        // Transform local offsets to world space\r\n        worldMatrix.transformPointAffine(capsule.localStartOffset, capsule.start);\r\n        worldMatrix.transformPointAffine(capsule.localEndOffset, capsule.end);\r\n      } else {\r\n        // No local offsets, just use node position for start\r\n        capsule.start.x = worldMatrix.m03;\r\n        capsule.start.y = worldMatrix.m13;\r\n        capsule.start.z = worldMatrix.m23;\r\n      }\r\n      break;\r\n    }\r\n\r\n    case 'plane': {\r\n      const plane = collider as PlaneCollider;\r\n      if (plane.localPointOffset) {\r\n        // Transform local offset to world space\r\n        worldMatrix.transformPointAffine(plane.localPointOffset, plane.point);\r\n      } else {\r\n        // No local offset, just use node position\r\n        plane.point.x = worldMatrix.m03;\r\n        plane.point.y = worldMatrix.m13;\r\n        plane.point.z = worldMatrix.m23;\r\n      }\r\n\r\n      if (plane.localNormal) {\r\n        // Transform local normal to world space (rotation only)\r\n        worldMatrix.transformVectorAffine(plane.localNormal, plane.normal).inplaceNormalize;\r\n      }\r\n      break;\r\n    }\r\n  }\r\n}\r\n"],"names":["createSphereCollider","centerOrOffset","radius","node","worldMatrix","worldCenter","Vector3","m03","x","m13","y","m23","z","type","center","enabled","localOffset","clone","createCapsuleCollider","startOrOffset","endOrOffset","worldStart","worldEnd","start","end","localStartOffset","localEndOffset","createPlaneCollider","pointOrOffset","normal","normalizedNormal","normalize","worldPoint","point","localPointOffset","localNormal","resolveSphereCollision","particlePos","collider","toParticle","sub","distSq","magnitudeSq","radiusSq","dist","Math","sqrt","penetration","scaleBy","add","resolveCapsuleCollision","axis","axisLength","magnitude","projection","dot","t","max","min","closestPoint","scale","toParticleFromAxis","resolvePlaneCollision","distance","correction","updateColliderFromNode","sphere","transformPointAffine","capsule","plane","transformVectorAffine","inplaceNormalize"],"mappings":"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"}

package/dist/animation/spring/spring_constraint.js

@@ -0,0 +1,21 @@
+/**
+ * Represents a spring constraint between two particles
+ *
+ * @public
+ */ /**
+ * Creates a new spring constraint
+ *
+ * @public
+ */ function createSpringConstraint(particleA, particleB, restLength, stiffness = 0.8, compliance = 0) {
+    return {
+        particleA,
+        particleB,
+        restLength,
+        stiffness,
+        compliance,
+        lambda: 0
+    };
+}
+
+export { createSpringConstraint };
+//# sourceMappingURL=spring_constraint.js.map

package/dist/animation/spring/spring_constraint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring_constraint.js","sources":["../../../src/animation/spring/spring_constraint.ts"],"sourcesContent":["/**\r\n * Represents a spring constraint between two particles\r\n *\r\n * @public\r\n */\r\nexport interface SpringConstraint {\r\n  /** Index of the first particle */\r\n  particleA: number;\r\n  /** Index of the second particle */\r\n  particleB: number;\r\n  /** Rest length of the spring */\r\n  restLength: number;\r\n  /** Stiffness coefficient [0-1] used by Verlet solver (0 = no constraint, 1 = rigid) */\r\n  stiffness: number;\r\n  /**\r\n   * XPBD compliance (inverse stiffness) in m/N.\r\n   * 0 = perfectly rigid, larger values = softer spring.\r\n   * Typical ranges: 0 (rigid) ~ 1e-7 (very stiff) ~ 1e-3 (soft cloth) ~ 1e-1 (rubber band).\r\n   * Only used when solver is 'xpbd'.\r\n   */\r\n  compliance: number;\r\n  /**\r\n   * XPBD Lagrange multiplier accumulator, reset to 0 at the start of each time step.\r\n   * Managed internally by the solver — do not set manually.\r\n   */\r\n  lambda: number;\r\n}\r\n\r\n/**\r\n * Creates a new spring constraint\r\n *\r\n * @public\r\n */\r\nexport function createSpringConstraint(\r\n  particleA: number,\r\n  particleB: number,\r\n  restLength: number,\r\n  stiffness: number = 0.8,\r\n  compliance: number = 0\r\n): SpringConstraint {\r\n  return {\r\n    particleA,\r\n    particleB,\r\n    restLength,\r\n    stiffness,\r\n    compliance,\r\n    lambda: 0\r\n  };\r\n}\r\n"],"names":["createSpringConstraint","particleA","particleB","restLength","stiffness","compliance","lambda"],"mappings":"AAAA;;;;;;;;AAgCC,IACM,SAASA,sBACdC,CAAAA,SAAiB,EACjBC,SAAiB,EACjBC,UAAkB,EAClBC,SAAAA,GAAoB,GAAG,EACvBC,aAAqB,CAAC,EAAA;IAEtB,OAAO;AACLJ,QAAAA,SAAAA;AACAC,QAAAA,SAAAA;AACAC,QAAAA,UAAAA;AACAC,QAAAA,SAAAA;AACAC,QAAAA,UAAAA;QACAC,MAAQ,EAAA;AACV,KAAA;AACF;;;;"}

package/dist/animation/spring/spring_particle.js

@@ -0,0 +1,20 @@
+/**
+ * Creates a new spring particle
+ *
+ * @public
+ */ function createSpringParticle(position, options) {
+    return {
+        position: position.clone(),
+        prevPosition: position.clone(),
+        originalPosition: position.clone(),
+        originalRotation: options?.originalRotation?.clone() ?? null,
+        mass: options?.mass ?? 1.0,
+        damping: options?.damping ?? 0.95,
+        fixed: options?.fixed ?? false,
+        node: options?.node ?? null,
+        lastFramePosition: position.clone()
+    };
+}
+
+export { createSpringParticle };
+//# sourceMappingURL=spring_particle.js.map

package/dist/animation/spring/spring_particle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spring_particle.js","sources":["../../../src/animation/spring/spring_particle.ts"],"sourcesContent":["import type { Vector3, Quaternion, Nullable } from '@zephyr3d/base';\r\nimport type { SceneNode } from '../../scene/scene_node';\r\n\r\n/**\r\n * Represents a particle in the spring system\r\n *\r\n * @public\r\n */\r\nexport interface SpringParticle {\r\n  /** Current position in world space */\r\n  position: Vector3;\r\n  /** Previous position for Verlet integration */\r\n  prevPosition: Vector3;\r\n  /** Original position for reset */\r\n  originalPosition: Vector3;\r\n  /** Original world rotation (for calculating rotation delta) */\r\n  originalRotation: Quaternion | null;\r\n  /** Mass of the particle (affects inertia) */\r\n  mass: number;\r\n  /** Damping coefficient [0-1] (0 = no damping, 1 = full damping) */\r\n  damping: number;\r\n  /** Whether this particle is fixed (anchor point) */\r\n  fixed: boolean;\r\n  /** Associated scene node (optional) */\r\n  node: Nullable<SceneNode>;\r\n  /** Previous frame position (used to calculate velocity for inertial forces) */\r\n  lastFramePosition: Vector3;\r\n  /** Position history for rotation center estimation (for fixed particles) */\r\n  positionHistory?: Vector3[];\r\n}\r\n\r\n/**\r\n * Creates a new spring particle\r\n *\r\n * @public\r\n */\r\nexport function createSpringParticle(\r\n  position: Vector3,\r\n  options?: {\r\n    mass?: number;\r\n    damping?: number;\r\n    fixed?: boolean;\r\n    node?: SceneNode;\r\n    originalRotation?: Quaternion;\r\n  }\r\n): SpringParticle {\r\n  return {\r\n    position: position.clone(),\r\n    prevPosition: position.clone(),\r\n    originalPosition: position.clone(),\r\n    originalRotation: options?.originalRotation?.clone() ?? null,\r\n    mass: options?.mass ?? 1.0,\r\n    damping: options?.damping ?? 0.95,\r\n    fixed: options?.fixed ?? false,\r\n    node: options?.node ?? null,\r\n    lastFramePosition: position.clone()\r\n  };\r\n}\r\n"],"names":["createSpringParticle","position","options","clone","prevPosition","originalPosition","originalRotation","mass","damping","fixed","node","lastFramePosition"],"mappings":"AA+BA;;;;AAIC,IACM,SAASA,oBACdC,CAAAA,QAAiB,EACjBC,OAMC,EAAA;IAED,OAAO;AACLD,QAAAA,QAAAA,EAAUA,SAASE,KAAK,EAAA;AACxBC,QAAAA,YAAAA,EAAcH,SAASE,KAAK,EAAA;AAC5BE,QAAAA,gBAAAA,EAAkBJ,SAASE,KAAK,EAAA;QAChCG,gBAAkBJ,EAAAA,OAAAA,EAASI,kBAAkBH,KAAW,EAAA,IAAA,IAAA;AACxDI,QAAAA,IAAAA,EAAML,SAASK,IAAQ,IAAA,GAAA;AACvBC,QAAAA,OAAAA,EAASN,SAASM,OAAW,IAAA,IAAA;AAC7BC,QAAAA,KAAAA,EAAOP,SAASO,KAAS,IAAA,KAAA;AACzBC,QAAAA,IAAAA,EAAMR,SAASQ,IAAQ,IAAA,IAAA;AACvBC,QAAAA,iBAAAA,EAAmBV,SAASE,KAAK;AACnC,KAAA;AACF;;;;"}