@zephyr3d/scene 0.8.1 → 0.9.0

package/dist/animation/spring2/controller.js

@@ -0,0 +1,434 @@
+import { clamp01 } from './math.js';
+import { EPSILON } from './types.js';
+import { buildConstraints, buildSurfaceFaces } from './constraints.js';
+import { simulate, applyAngleLimits, applyResult } from './solver.js';
+import { Vector3, Quaternion, Matrix4x4 } from '@zephyr3d/base';
+
+// High-level orchestrator — SPCRJointDynamicsController API
+class SpringSystemController {
+    _config;
+    _pointsR = [];
+    _pointsRW = [];
+    _constraints = [];
+    _collidersR = [];
+    _collidersRW = [];
+    _grabbersR = [];
+    _grabbersRW = [];
+    _movableLimitTargets = [];
+    _flatPlanes = [];
+    _surfaceConstraints = [];
+    _positionsToTransform = [];
+    _fakeWaveCounter = 0;
+    _previousRootPosition = Vector3.zero();
+    _previousRootRotation = Quaternion.identity();
+    _rootTransform = null;
+    _pointTransforms = [];
+    _colliderTransforms = [];
+    _grabberTransforms = [];
+    _initialized = false;
+    _isPaused = false;
+    _fadeState = 'none';
+    _fadeTimer = 0;
+    _fadeDuration = 0;
+    constructor(config){
+        this._config = config;
+    }
+    /**
+   * 初始化物理系统
+   * @param rootTransform 根骨骼的 transform（用于检测根运动）
+   * @param rootPoints 骨骼层级的根节点数组（可以有多个根，如裙子的多条链）
+   * @param pointTransforms 所有物理点的 transform 数组（顺序必须与 BoneNode.index 对应）
+   * @param colliders 碰撞器数组（球体/胶囊体）
+   * @param grabbers 抓取器数组（用于鼠标交互等）
+   * @param flatPlanes 平面限制器数组（如地板，防止穿透）
+   */ initialize(rootTransform, rootPoints, pointTransforms, colliders, grabbers, flatPlanes) {
+        this._rootTransform = rootTransform;
+        this._pointTransforms = pointTransforms;
+        this._colliderTransforms = colliders.map((c)=>c.transform);
+        this._grabberTransforms = grabbers.map((g)=>g.transform);
+        // Build constraints
+        this._constraints = buildConstraints(rootPoints, this._config.constraintOptions);
+        this._surfaceConstraints = buildSurfaceFaces(rootPoints, this._config.constraintOptions.isLoop);
+        // Flatten bone hierarchy to point list, build parent map
+        const allPoints = [];
+        const parentMap = new Map(); // child index → parent index
+        function walk(node) {
+            allPoints.push(node);
+            for (const c of node.children){
+                parentMap.set(c.index, node.index);
+                walk(c);
+            }
+        }
+        for (const r of rootPoints){
+            walk(r);
+        }
+        const maxDepth = Math.max(...allPoints.map((p)=>p.depth));
+        // Compute boneAxis from transforms: local-space direction to first child
+        // This is critical for correct bone rotation in skinned meshes
+        const indexToNode = new Map();
+        for (const p of allPoints){
+            indexToNode.set(p.index, p);
+        }
+        for (const p of allPoints){
+            if (!p.boneAxis && p.children.length > 0) {
+                const childPos = pointTransforms[p.children[0].index].getWorldPosition();
+                const parentPos = pointTransforms[p.index].getWorldPosition();
+                // InverseTransformPoint: convert child world pos to parent local space
+                const parentRot = pointTransforms[p.index].getWorldRotation();
+                const parentScale = pointTransforms[p.index].getLocalScale();
+                const diff = Vector3.sub(childPos, parentPos);
+                const invRot = Quaternion.inverse(parentRot);
+                const localDir = invRot.transform(diff);
+                // Apply inverse scale
+                const unscaled = new Vector3(parentScale.x !== 0 ? localDir.x / parentScale.x : 0, parentScale.y !== 0 ? localDir.y / parentScale.y : 0, parentScale.z !== 0 ? localDir.z / parentScale.z : 0);
+                p.boneAxis = Vector3.normalize(unscaled);
+            }
+        }
+        // Build PointR/RW arrays
+        this._pointsR = allPoints.map((p)=>this._createPointR(p, maxDepth, parentMap, pointTransforms));
+        this._pointsRW = allPoints.map(()=>this._createPointRW());
+        this._positionsToTransform = new Array(allPoints.length).fill(Vector3.zero());
+        // Initialize colliders
+        this._collidersR = colliders.map((c)=>c.r);
+        this._collidersRW = colliders.map((c)=>this._createColliderRW(c.transform));
+        // Initialize grabbers
+        this._grabbersR = grabbers.map((g)=>g.r);
+        this._grabbersRW = grabbers.map((g)=>({
+                enabled: g.enabled ? 1 : 0,
+                position: g.transform.getWorldPosition()
+            }));
+        // Flat planes
+        this._flatPlanes = flatPlanes.map((fp)=>({
+                normal: Vector3.normalize(fp.up),
+                distance: -Vector3.dot(Vector3.normalize(fp.up), fp.position)
+            }));
+        // Capture initial state
+        this._previousRootPosition = rootTransform.getWorldPosition();
+        this._previousRootRotation = rootTransform.getWorldRotation();
+        for(let i = 0; i < this._pointsRW.length; i++){
+            const pos = pointTransforms[i].getWorldPosition();
+            this._pointsRW[i].positionCurrent = pos.clone();
+            this._pointsRW[i].positionPrevious = pos.clone();
+            this._pointsRW[i].positionCurrentTransform = pos.clone();
+            this._pointsRW[i].positionPreviousTransform = pos.clone();
+            this._pointsRW[i].positionToTransform = pos.clone();
+            this._pointsRW[i].directionPrevious = Vector3.axisPZ();
+            this._pointsRW[i].fakeWindDirection = Vector3.axisPZ();
+            this._pointsRW[i].grabberIndex = -1;
+            this._pointsRW[i].grabberDistance = 0;
+            this._pointsRW[i].friction = 0;
+        }
+        this._initialized = true;
+    }
+    /**
+   * 执行一帧物理模拟
+   * 内部流程：读取当前 transform → 运行 Verlet 积分和约束求解 → 写回 transform
+   * @param deltaTime 帧间隔时间（秒）。内部会被 subSteps 细分
+   */ step(deltaTime) {
+        if (!this._initialized || !this._rootTransform) {
+            return;
+        }
+        // Update fade
+        if (this._fadeState !== 'none') {
+            this._fadeTimer += deltaTime;
+            if (this._fadeTimer >= this._fadeDuration) {
+                this._fadeState = 'none';
+                this._fadeTimer = 0;
+            }
+        }
+        const blendRatio = this._computeBlendRatio();
+        // Capture current transforms
+        const rootPos = this._rootTransform.getWorldPosition();
+        const rootRot = this._rootTransform.getWorldRotation();
+        for(let i = 0; i < this._pointsRW.length; i++){
+            this._pointsRW[i].positionPreviousTransform = this._pointsRW[i].positionCurrentTransform.clone();
+            this._pointsRW[i].positionCurrentTransform = this._pointTransforms[i].getWorldPosition();
+        }
+        for(let i = 0; i < this._collidersRW.length; i++){
+            const t = this._colliderTransforms[i];
+            this._collidersRW[i].positionPreviousTransform = this._collidersRW[i].positionCurrentTransform.clone();
+            this._collidersRW[i].directionPreviousTransform = this._collidersRW[i].directionCurrentTransform.clone();
+            this._collidersRW[i].positionCurrentTransform = t.getWorldPosition();
+            this._collidersRW[i].directionCurrentTransform = t.getWorldRotation();
+            this._collidersRW[i].worldToLocal = Matrix4x4.compose(t.getLocalScale(), this._collidersRW[i].directionCurrentTransform, this._collidersRW[i].positionCurrentTransform).inplaceInvertAffine();
+        }
+        for(let i = 0; i < this._grabbersRW.length; i++){
+            this._grabbersRW[i].position = this._grabberTransforms[i].getWorldPosition();
+        }
+        // Run simulation
+        const params = {
+            isPaused: this._isPaused,
+            stepTime: deltaTime,
+            subSteps: this._config.subSteps,
+            rootPosition: rootPos,
+            previousRootPosition: this._previousRootPosition,
+            rootSlideLimit: this._config.rootSlideLimit,
+            rootRotation: rootRot,
+            previousRootRotation: this._previousRootRotation,
+            rootRotateLimit: this._config.rootRotateLimit,
+            windForce: this._config.windForce,
+            enableSurfaceCollision: this._config.enableSurfaceCollision,
+            surfaceConstraints: this._surfaceConstraints,
+            relaxation: this._config.relaxation,
+            constraintShrinkLimit: this._config.constraintShrinkLimit,
+            blendRatio,
+            isFakeWave: this._config.isFakeWave,
+            fakeWaveSpeed: this._config.fakeWaveSpeed,
+            fakeWavePower: this._config.fakeWavePower,
+            fakeWaveCounter: this._fakeWaveCounter,
+            collisionScale: 1.0,
+            enableBroadPhase: this._config.enableBroadPhase
+        };
+        const result = simulate(params, this._pointsR, this._pointsRW, this._constraints, this._collidersR, this._collidersRW, this._grabbersR, this._grabbersRW, this._movableLimitTargets, this._flatPlanes);
+        this._positionsToTransform = result.positionsToTransform;
+        this._fakeWaveCounter = result.fakeWaveCounter;
+        // Angle limits
+        if (this._config.angleLimitConfig.angleLimit >= 0) {
+            applyAngleLimits(this._pointsR, this._pointsRW, this._config.angleLimitConfig);
+        }
+        // Apply results
+        const transformRots = this._pointTransforms.map((t)=>t.getWorldRotation());
+        const transformLocalRots = this._pointTransforms.map((t)=>t.getLocalRotation());
+        const outputs = applyResult(this._pointsR, this._pointsRW, this._positionsToTransform, blendRatio, transformRots, transformLocalRots);
+        for(let i = 0; i < outputs.length; i++){
+            this._pointTransforms[i].setWorldPosition(outputs[i].position);
+            this._pointTransforms[i].setWorldRotation(outputs[i].rotation);
+        }
+        this._previousRootPosition = rootPos;
+        this._previousRootRotation = rootRot;
+    }
+    /**
+   * 获取所有点的模拟结果（世界坐标位置和旋转）
+   * 通常不需要手动调用——step() 已经自动写回 transform。
+   * 适用于需要在不写回 transform 的情况下读取物理结果的场景。
+   */ getResults() {
+        const transformRots = this._pointTransforms.map((t)=>t.getWorldRotation());
+        const transformLocalRots = this._pointTransforms.map((t)=>t.getLocalRotation());
+        const outputs = applyResult(this._pointsR, this._pointsRW, this._positionsToTransform, this._config.blendRatio, transformRots, transformLocalRots);
+        return outputs.map((o)=>({
+                position: o.position,
+                rotation: o.rotation
+            }));
+    }
+    /**
+   * 瞬移补偿——在角色传送/瞬移后调用
+   * 将上一帧的根骨骼位置和旋转设为当前值，
+   * 使下一帧的根运动增量为零，避免物理点因巨大位移而弹射。
+   */ warp() {
+        if (!this._rootTransform) {
+            return;
+        }
+        this._previousRootPosition = this._rootTransform.getWorldPosition();
+        this._previousRootRotation = this._rootTransform.getWorldRotation();
+    }
+    /**
+   * 重置所有物理状态
+   * 将所有点的模拟位置重置为当前 transform 位置，清除速度和抓取状态。
+   * 适用于场景切换或需要消除所有物理运动的场景。
+   */ reset() {
+        for(let i = 0; i < this._pointsRW.length; i++){
+            const pos = this._pointTransforms[i].getWorldPosition();
+            this._pointsRW[i].positionCurrent = pos.clone();
+            this._pointsRW[i].positionPrevious = pos.clone();
+            this._pointsRW[i].grabberIndex = -1;
+        }
+        this._fakeWaveCounter = 0;
+    }
+    /**
+   * 释放固定点为动态点（如脱衣、布料脱落）
+   * 将 weight 从 0 改为 1，同时重置该点的模拟状态避免瞬间弹射。
+   * @param index 点的索引
+   */ releasePoint(index) {
+        if (index < 0 || index >= this._pointsR.length) {
+            return;
+        }
+        this._pointsR[index].weight = 1;
+        const pos = this._pointTransforms[index].getWorldPosition();
+        this._pointsRW[index].positionCurrent = pos.clone();
+        this._pointsRW[index].positionPrevious = pos.clone();
+        this._pointsRW[index].grabberIndex = -1;
+    }
+    /**
+   * 将动态点重新固定为跟随动画（如重新穿戴）
+   * 将 weight 从 1 改为 0，清除抓取状态。
+   * @param index 点的索引
+   */ fixPoint(index) {
+        if (index < 0 || index >= this._pointsR.length) {
+            return;
+        }
+        this._pointsR[index].weight = 0;
+        this._pointsRW[index].grabberIndex = -1;
+    }
+    /**
+   * 查询某个点是否为固定状态（weight=0，跟随动画）
+   * @param index 点的索引
+   */ isPointFixed(index) {
+        if (index < 0 || index >= this._pointsR.length) {
+            return false;
+        }
+        return this._pointsR[index].weight <= EPSILON;
+    }
+    /** 获取物理点总数 */ get pointCount() {
+        return this._pointsR.length;
+    }
+    /**
+   * 渐入物理——从动画姿态平滑过渡到物理模拟
+   * blendRatio 从 1（纯动画）渐变到 0（纯物理）
+   * @param seconds 过渡时长（秒）
+   */ fadeIn(seconds) {
+        this._fadeState = 'in';
+        this._fadeTimer = 0;
+        this._fadeDuration = seconds;
+    }
+    /**
+   * 渐出物理——从物理模拟平滑过渡回动画姿态
+   * blendRatio 从 0（纯物理）渐变到 1（纯动画）
+   * @param seconds 过渡时长（秒）
+   */ fadeOut(seconds) {
+        this._fadeState = 'out';
+        this._fadeTimer = 0;
+        this._fadeDuration = seconds;
+    }
+    /**
+   * 设置全局风力向量
+   * 风力会按每个点的 windForceScale 和质量进行缩放
+   * @param wind 风力向量（世界坐标）
+   */ setWindForce(wind) {
+        this._config.windForce = wind;
+    }
+    /** Enable/disable broad-phase pruning for runtime performance comparison */ setBroadPhaseEnabled(enabled) {
+        this._config.enableBroadPhase = enabled;
+    }
+    /**
+   * 暂停/恢复物理模拟
+   * 暂停时仍会跟随根骨骼运动，但不进行力学积分和约束求解
+   * @param paused true=暂停, false=恢复
+   */ setPaused(paused) {
+        this._isPaused = paused;
+    }
+    /**
+   * 运行时更新碰撞器状态
+   * 用于外部直接控制碰撞器的启用/禁用和位置，而不通过 TransformAccess 读取
+   * @param index 碰撞器索引
+   * @param enabled 是否启用
+   * @param position 世界坐标位置
+   * @param rotation 世界旋转
+   */ updateColliderState(index, enabled, position, rotation) {
+        if (index >= 0 && index < this._collidersRW.length) {
+            this._collidersRW[index].enabled = enabled ? 1 : 0;
+            this._collidersRW[index].positionCurrentTransform = position;
+            this._collidersRW[index].directionCurrentTransform = rotation;
+        }
+    }
+    /**
+   * 运行时更新抓取器状态
+   * 用于鼠标拖拽等交互场景，控制抓取器的启用和位置
+   * @param index 抓取器索引
+   * @param enabled 是否启用（鼠标按下=true，松开=false）
+   * @param position 抓取器世界坐标位置
+   */ updateGrabberState(index, enabled, position) {
+        if (index >= 0 && index < this._grabbersRW.length) {
+            this._grabbersRW[index].enabled = enabled ? 1 : 0;
+            this._grabbersRW[index].position = position;
+        }
+    }
+    _computeBlendRatio() {
+        if (this._fadeState === 'in') {
+            return 1.0 - clamp01(this._fadeTimer / this._fadeDuration);
+        }
+        if (this._fadeState === 'out') {
+            return clamp01(this._fadeTimer / this._fadeDuration);
+        }
+        return this._config.blendRatio;
+    }
+    _createPointR(node, maxDepth, parentMap, transforms) {
+        const rate = maxDepth > 0 ? node.depth / maxDepth : 0;
+        const c = this._config.curves;
+        const parentIdx = parentMap.get(node.index) ?? -1;
+        const childIdx = node.children.length > 0 ? node.children[0].index : -1;
+        // Capture initial local transform for rotation blending
+        const t = transforms[node.index];
+        const initLocalPos = t.getLocalPosition();
+        const initLocalRot = t.getLocalRotation();
+        const initLocalScale = t.getLocalScale();
+        // BoneAxis: local-space direction to first child (computed in initialize)
+        const boneAxis = node.boneAxis ?? new Vector3(0, -1, 0);
+        // ParentLength: distance to parent
+        let parentLength = 0;
+        if (parentIdx !== -1) {
+            const pPos = transforms[parentIdx].getWorldPosition();
+            const cPos = transforms[node.index].getWorldPosition();
+            parentLength = Vector3.distance(pPos, cPos);
+        }
+        return {
+            parent: parentIdx,
+            child: childIdx,
+            applyInvertCollision: 0,
+            movableLimitIndex: -1,
+            movableLimitRadius: 0,
+            weight: node.isFixed ? 0 : 1,
+            mass: c.massScale.evaluate(rate),
+            resistance: clamp01(c.resistance.evaluate(rate)),
+            hardness: clamp01(c.hardness.evaluate(rate)),
+            frictionScale: c.friction.evaluate(rate),
+            sliderJointLength: c.sliderJointLength.evaluate(rate),
+            parentLength,
+            structuralShrinkVertical: c.structuralShrinkVertical.evaluate(rate) * 0.5,
+            structuralStretchVertical: c.structuralStretchVertical.evaluate(rate) * 0.5,
+            structuralShrinkHorizontal: c.structuralShrinkHorizontal.evaluate(rate) * 0.5,
+            structuralStretchHorizontal: c.structuralStretchHorizontal.evaluate(rate) * 0.5,
+            shearShrink: c.shearShrink.evaluate(rate) * 0.5,
+            shearStretch: c.shearStretch.evaluate(rate) * 0.5,
+            bendingShrinkVertical: c.bendingShrinkVertical.evaluate(rate) * 0.5,
+            bendingStretchVertical: c.bendingStretchVertical.evaluate(rate) * 0.5,
+            bendingShrinkHorizontal: c.bendingShrinkHorizontal.evaluate(rate) * 0.5,
+            bendingStretchHorizontal: c.bendingStretchHorizontal.evaluate(rate) * 0.5,
+            windForceScale: c.windForceScale.evaluate(rate) * rate,
+            fakeWavePower: c.fakeWavePower.evaluate(rate),
+            fakeWaveFreq: c.fakeWaveFreq.evaluate(rate),
+            forceFadeRatio: 0,
+            pointRadius: 0.05,
+            gravity: Vector3.scale(this._config.gravity, c.gravityScale.evaluate(rate)),
+            boneAxis,
+            initialLocalScale: initLocalScale,
+            initialLocalRotation: initLocalRot,
+            initialLocalPosition: initLocalPos
+        };
+    }
+    _createPointRW() {
+        return {
+            positionToTransform: Vector3.zero(),
+            positionCurrentTransform: Vector3.zero(),
+            positionPreviousTransform: Vector3.zero(),
+            positionCurrent: Vector3.zero(),
+            positionPrevious: Vector3.zero(),
+            directionPrevious: Vector3.axisPZ(),
+            fakeWindDirection: Vector3.axisPZ(),
+            grabberIndex: -1,
+            grabberDistance: 0,
+            friction: 0
+        };
+    }
+    _createColliderRW(transform) {
+        const pos = transform.getWorldPosition();
+        const rot = transform.getWorldRotation();
+        return {
+            positionCurrent: pos.clone(),
+            directionCurrent: Vector3.zero(),
+            boundsCenter: pos.clone(),
+            boundsRadius: 0,
+            positionCurrentTransform: pos.clone(),
+            positionPreviousTransform: pos.clone(),
+            directionCurrentTransform: rot.clone(),
+            directionPreviousTransform: rot.clone(),
+            worldToLocal: Matrix4x4.identity(),
+            localBoundsMin: Vector3.zero(),
+            localBoundsMax: Vector3.zero(),
+            radius: 0,
+            enabled: 1
+        };
+    }
+}
+
+export { SpringSystemController };
+//# sourceMappingURL=controller.js.map

package/dist/animation/spring2/controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.js","sources":["../../../src/animation/spring2/controller.ts"],"sourcesContent":["// High-level orchestrator — SPCRJointDynamicsController API\r\n\r\nimport { clamp01 } from './math';\r\nimport {\r\n  EPSILON,\r\n  type PointR,\r\n  type PointRW,\r\n  type Constraint,\r\n  type ColliderR,\r\n  type ColliderRW,\r\n  type GrabberR,\r\n  type GrabberRW,\r\n  type AngleLimitConfig,\r\n  type FlatPlane,\r\n  type TransformAccess,\r\n  type BoneNode\r\n} from './types';\r\nimport { buildConstraints, buildSurfaceFaces, type ConstraintBuildOptions } from './constraints';\r\nimport { simulate, applyResult, applyAngleLimits, type SimulationParams } from './solver';\r\nimport type { InterpolatorScalar } from '@zephyr3d/base';\r\nimport { Vector3, Quaternion, Matrix4x4 } from '@zephyr3d/base';\r\n\r\n/**\r\n * Depth-based physics parameter curves.\r\n * Each curve is evaluated with t = pointDepth / maxDepth (0 at root, 1 at tip).\r\n * This allows parameters to vary smoothly along the bone chain.\r\n */\r\nexport interface PhysicsCurves {\r\n  /** Scales point mass by depth */\r\n  massScale: InterpolatorScalar;\r\n  /** Scales gravity strength by depth */\r\n  gravityScale: InterpolatorScalar;\r\n  /** Scales wind force effect by depth (also multiplied by depth rate) */\r\n  windForceScale: InterpolatorScalar;\r\n  /** Velocity damping [0-1]. Higher = less damping. Controls how much velocity is preserved */\r\n  resistance: InterpolatorScalar;\r\n  /** Restore-to-animation stiffness [0-1]. Higher = bone stays closer to animated pose */\r\n  hardness: InterpolatorScalar;\r\n  /** Friction multiplier by depth. Scales collision friction accumulation */\r\n  friction: InterpolatorScalar;\r\n  /** Extra slack length for horizontal/shear constraints (allows stretching) */\r\n  sliderJointLength: InterpolatorScalar;\r\n  /** Global shrink stiffness multiplier (applied to all constraint types) */\r\n  allShrinkScale: InterpolatorScalar;\r\n  /** Global stretch stiffness multiplier (applied to all constraint types) */\r\n  allStretchScale: InterpolatorScalar;\r\n  /** Structural vertical constraint shrink stiffness by depth */\r\n  structuralShrinkVertical: InterpolatorScalar;\r\n  /** Structural vertical constraint stretch stiffness by depth */\r\n  structuralStretchVertical: InterpolatorScalar;\r\n  /** Structural horizontal constraint shrink stiffness by depth */\r\n  structuralShrinkHorizontal: InterpolatorScalar;\r\n  /** Structural horizontal constraint stretch stiffness by depth */\r\n  structuralStretchHorizontal: InterpolatorScalar;\r\n  /** Shear constraint shrink stiffness by depth */\r\n  shearShrink: InterpolatorScalar;\r\n  /** Shear constraint stretch stiffness by depth */\r\n  shearStretch: InterpolatorScalar;\r\n  /** Bending vertical constraint shrink stiffness by depth */\r\n  bendingShrinkVertical: InterpolatorScalar;\r\n  /** Bending vertical constraint stretch stiffness by depth */\r\n  bendingStretchVertical: InterpolatorScalar;\r\n  /** Bending horizontal constraint shrink stiffness by depth */\r\n  bendingShrinkHorizontal: InterpolatorScalar;\r\n  /** Bending horizontal constraint stretch stiffness by depth */\r\n  bendingStretchHorizontal: InterpolatorScalar;\r\n  /** Fake wave amplitude by depth (sinusoidal pseudo-wind on leaf bones) */\r\n  fakeWavePower: InterpolatorScalar;\r\n  /** Fake wave frequency offset by depth */\r\n  fakeWaveFreq: InterpolatorScalar;\r\n}\r\n\r\n/** Top-level configuration for the physics controller */\r\nexport interface ControllerConfig {\r\n  /** Global gravity vector (e.g. {x:0, y:-9.8, z:0}) */\r\n  gravity: Vector3;\r\n  /** Global wind force vector applied to all dynamic points */\r\n  windForce: Vector3;\r\n  /** Number of constraint relaxation iterations per substep. Higher = more stable but slower */\r\n  relaxation: number;\r\n  /** Number of simulation substeps per frame. Higher = more stable at cost of performance */\r\n  subSteps: number;\r\n  /** Max root bone slide distance per substep. Excess is distributed as offset. -1 = unlimited */\r\n  rootSlideLimit: number;\r\n  /** Max root bone rotation angle (degrees) per substep. Excess is distributed. -1 = unlimited */\r\n  rootRotateLimit: number;\r\n  /** Upper limit for horizontal/shear constraint shrink power. Prevents over-compression */\r\n  constraintShrinkLimit: number;\r\n  /** Global blend ratio between physics and animation [0-1]. 0 = full physics, 1 = full animation */\r\n  blendRatio: number;\r\n  /** Target frame rate for stabilization (currently unused, reserved) */\r\n  stabilizationFrameRate: number;\r\n  /** Enable sinusoidal fake wave effect on leaf bones */\r\n  isFakeWave: boolean;\r\n  /** Fake wave global speed (accumulates over time) */\r\n  fakeWaveSpeed: number;\r\n  /** Fake wave global amplitude multiplier */\r\n  fakeWavePower: number;\r\n  /** Enable triangle-based surface collision (cloth vs colliders) */\r\n  enableSurfaceCollision: boolean;\r\n  /** Enable broad-phase pruning before precise collider tests */\r\n  enableBroadPhase: boolean;\r\n  /** Post-simulation angle limiting between parent-child bones */\r\n  angleLimitConfig: AngleLimitConfig;\r\n  /** Depth-based physics parameter curves */\r\n  curves: PhysicsCurves;\r\n  /** Which constraint types to generate and their collision flags */\r\n  constraintOptions: ConstraintBuildOptions;\r\n}\r\n\r\nexport class SpringSystemController {\r\n  private _config: ControllerConfig;\r\n  private _pointsR: PointR[] = [];\r\n  private _pointsRW: PointRW[] = [];\r\n  private _constraints: Constraint[] = [];\r\n  private _collidersR: ColliderR[] = [];\r\n  private _collidersRW: ColliderRW[] = [];\r\n  private _grabbersR: GrabberR[] = [];\r\n  private _grabbersRW: GrabberRW[] = [];\r\n  private _movableLimitTargets: Vector3[] = [];\r\n  private _flatPlanes: FlatPlane[] = [];\r\n  private _surfaceConstraints: number[] = [];\r\n  private _positionsToTransform: Vector3[] = [];\r\n  private _fakeWaveCounter = 0;\r\n  private _previousRootPosition = Vector3.zero();\r\n  private _previousRootRotation = Quaternion.identity();\r\n  private _rootTransform: TransformAccess | null = null;\r\n  private _pointTransforms: TransformAccess[] = [];\r\n  private _colliderTransforms: TransformAccess[] = [];\r\n  private _grabberTransforms: TransformAccess[] = [];\r\n  private _initialized = false;\r\n  private _isPaused = false;\r\n  private _fadeState: 'none' | 'in' | 'out' = 'none';\r\n  private _fadeTimer = 0;\r\n  private _fadeDuration = 0;\r\n\r\n  constructor(config: ControllerConfig) {\r\n    this._config = config;\r\n  }\r\n\r\n  /**\r\n   * 初始化物理系统\r\n   * @param rootTransform 根骨骼的 transform（用于检测根运动）\r\n   * @param rootPoints 骨骼层级的根节点数组（可以有多个根，如裙子的多条链）\r\n   * @param pointTransforms 所有物理点的 transform 数组（顺序必须与 BoneNode.index 对应）\r\n   * @param colliders 碰撞器数组（球体/胶囊体）\r\n   * @param grabbers 抓取器数组（用于鼠标交互等）\r\n   * @param flatPlanes 平面限制器数组（如地板，防止穿透）\r\n   */\r\n  initialize(\r\n    rootTransform: TransformAccess,\r\n    rootPoints: BoneNode[],\r\n    pointTransforms: TransformAccess[],\r\n    colliders: Array<{ r: ColliderR; transform: TransformAccess }>,\r\n    grabbers: Array<{\r\n      r: GrabberR;\r\n      transform: TransformAccess;\r\n      enabled: boolean;\r\n    }>,\r\n    flatPlanes: Array<{ up: Vector3; position: Vector3 }>\r\n  ): void {\r\n    this._rootTransform = rootTransform;\r\n    this._pointTransforms = pointTransforms;\r\n    this._colliderTransforms = colliders.map((c) => c.transform);\r\n    this._grabberTransforms = grabbers.map((g) => g.transform);\r\n\r\n    // Build constraints\r\n    this._constraints = buildConstraints(rootPoints, this._config.constraintOptions);\r\n    this._surfaceConstraints = buildSurfaceFaces(rootPoints, this._config.constraintOptions.isLoop);\r\n\r\n    // Flatten bone hierarchy to point list, build parent map\r\n    const allPoints: BoneNode[] = [];\r\n    const parentMap = new Map<number, number>(); // child index → parent index\r\n    function walk(node: BoneNode) {\r\n      allPoints.push(node);\r\n      for (const c of node.children) {\r\n        parentMap.set(c.index, node.index);\r\n        walk(c);\r\n      }\r\n    }\r\n    for (const r of rootPoints) {\r\n      walk(r);\r\n    }\r\n\r\n    const maxDepth = Math.max(...allPoints.map((p) => p.depth));\r\n\r\n    // Compute boneAxis from transforms: local-space direction to first child\r\n    // This is critical for correct bone rotation in skinned meshes\r\n    const indexToNode = new Map<number, BoneNode>();\r\n    for (const p of allPoints) {\r\n      indexToNode.set(p.index, p);\r\n    }\r\n\r\n    for (const p of allPoints) {\r\n      if (!p.boneAxis && p.children.length > 0) {\r\n        const childPos = pointTransforms[p.children[0].index].getWorldPosition();\r\n        const parentPos = pointTransforms[p.index].getWorldPosition();\r\n        // InverseTransformPoint: convert child world pos to parent local space\r\n        const parentRot = pointTransforms[p.index].getWorldRotation();\r\n        const parentScale = pointTransforms[p.index].getLocalScale();\r\n        const diff = Vector3.sub(childPos, parentPos);\r\n        const invRot = Quaternion.inverse(parentRot);\r\n        const localDir = invRot.transform(diff);\r\n        // Apply inverse scale\r\n        const unscaled = new Vector3(\r\n          parentScale.x !== 0 ? localDir.x / parentScale.x : 0,\r\n          parentScale.y !== 0 ? localDir.y / parentScale.y : 0,\r\n          parentScale.z !== 0 ? localDir.z / parentScale.z : 0\r\n        );\r\n        p.boneAxis = Vector3.normalize(unscaled);\r\n      }\r\n    }\r\n\r\n    // Build PointR/RW arrays\r\n    this._pointsR = allPoints.map((p) => this._createPointR(p, maxDepth, parentMap, pointTransforms));\r\n    this._pointsRW = allPoints.map(() => this._createPointRW());\r\n    this._positionsToTransform = new Array(allPoints.length).fill(Vector3.zero());\r\n\r\n    // Initialize colliders\r\n    this._collidersR = colliders.map((c) => c.r);\r\n    this._collidersRW = colliders.map((c) => this._createColliderRW(c.transform));\r\n\r\n    // Initialize grabbers\r\n    this._grabbersR = grabbers.map((g) => g.r);\r\n    this._grabbersRW = grabbers.map((g) => ({\r\n      enabled: g.enabled ? 1 : 0,\r\n      position: g.transform.getWorldPosition()\r\n    }));\r\n\r\n    // Flat planes\r\n    this._flatPlanes = flatPlanes.map((fp) => ({\r\n      normal: Vector3.normalize(fp.up),\r\n      distance: -Vector3.dot(Vector3.normalize(fp.up), fp.position)\r\n    }));\r\n\r\n    // Capture initial state\r\n    this._previousRootPosition = rootTransform.getWorldPosition();\r\n    this._previousRootRotation = rootTransform.getWorldRotation();\r\n\r\n    for (let i = 0; i < this._pointsRW.length; i++) {\r\n      const pos = pointTransforms[i].getWorldPosition();\r\n      this._pointsRW[i].positionCurrent = pos.clone();\r\n      this._pointsRW[i].positionPrevious = pos.clone();\r\n      this._pointsRW[i].positionCurrentTransform = pos.clone();\r\n      this._pointsRW[i].positionPreviousTransform = pos.clone();\r\n      this._pointsRW[i].positionToTransform = pos.clone();\r\n      this._pointsRW[i].directionPrevious = Vector3.axisPZ();\r\n      this._pointsRW[i].fakeWindDirection = Vector3.axisPZ();\r\n      this._pointsRW[i].grabberIndex = -1;\r\n      this._pointsRW[i].grabberDistance = 0;\r\n      this._pointsRW[i].friction = 0;\r\n    }\r\n\r\n    this._initialized = true;\r\n  }\r\n\r\n  /**\r\n   * 执行一帧物理模拟\r\n   * 内部流程：读取当前 transform → 运行 Verlet 积分和约束求解 → 写回 transform\r\n   * @param deltaTime 帧间隔时间（秒）。内部会被 subSteps 细分\r\n   */\r\n  step(deltaTime: number): void {\r\n    if (!this._initialized || !this._rootTransform) {\r\n      return;\r\n    }\r\n\r\n    // Update fade\r\n    if (this._fadeState !== 'none') {\r\n      this._fadeTimer += deltaTime;\r\n      if (this._fadeTimer >= this._fadeDuration) {\r\n        this._fadeState = 'none';\r\n        this._fadeTimer = 0;\r\n      }\r\n    }\r\n\r\n    const blendRatio = this._computeBlendRatio();\r\n\r\n    // Capture current transforms\r\n    const rootPos = this._rootTransform.getWorldPosition();\r\n    const rootRot = this._rootTransform.getWorldRotation();\r\n\r\n    for (let i = 0; i < this._pointsRW.length; i++) {\r\n      this._pointsRW[i].positionPreviousTransform = this._pointsRW[i].positionCurrentTransform.clone();\r\n      this._pointsRW[i].positionCurrentTransform = this._pointTransforms[i].getWorldPosition();\r\n    }\r\n\r\n    for (let i = 0; i < this._collidersRW.length; i++) {\r\n      const t = this._colliderTransforms[i];\r\n      this._collidersRW[i].positionPreviousTransform = this._collidersRW[i].positionCurrentTransform.clone();\r\n      this._collidersRW[i].directionPreviousTransform =\r\n        this._collidersRW[i].directionCurrentTransform.clone();\r\n      this._collidersRW[i].positionCurrentTransform = t.getWorldPosition();\r\n      this._collidersRW[i].directionCurrentTransform = t.getWorldRotation();\r\n      this._collidersRW[i].worldToLocal = Matrix4x4.compose(\r\n        t.getLocalScale(),\r\n        this._collidersRW[i].directionCurrentTransform,\r\n        this._collidersRW[i].positionCurrentTransform\r\n      ).inplaceInvertAffine();\r\n    }\r\n\r\n    for (let i = 0; i < this._grabbersRW.length; i++) {\r\n      this._grabbersRW[i].position = this._grabberTransforms[i].getWorldPosition();\r\n    }\r\n\r\n    // Run simulation\r\n    const params: SimulationParams = {\r\n      isPaused: this._isPaused,\r\n      stepTime: deltaTime,\r\n      subSteps: this._config.subSteps,\r\n      rootPosition: rootPos,\r\n      previousRootPosition: this._previousRootPosition,\r\n      rootSlideLimit: this._config.rootSlideLimit,\r\n      rootRotation: rootRot,\r\n      previousRootRotation: this._previousRootRotation,\r\n      rootRotateLimit: this._config.rootRotateLimit,\r\n      windForce: this._config.windForce,\r\n      enableSurfaceCollision: this._config.enableSurfaceCollision,\r\n      surfaceConstraints: this._surfaceConstraints,\r\n      relaxation: this._config.relaxation,\r\n      constraintShrinkLimit: this._config.constraintShrinkLimit,\r\n      blendRatio,\r\n      isFakeWave: this._config.isFakeWave,\r\n      fakeWaveSpeed: this._config.fakeWaveSpeed,\r\n      fakeWavePower: this._config.fakeWavePower,\r\n      fakeWaveCounter: this._fakeWaveCounter,\r\n      collisionScale: 1.0,\r\n      enableBroadPhase: this._config.enableBroadPhase\r\n    };\r\n\r\n    const result = simulate(\r\n      params,\r\n      this._pointsR,\r\n      this._pointsRW,\r\n      this._constraints,\r\n      this._collidersR,\r\n      this._collidersRW,\r\n      this._grabbersR,\r\n      this._grabbersRW,\r\n      this._movableLimitTargets,\r\n      this._flatPlanes\r\n    );\r\n\r\n    this._positionsToTransform = result.positionsToTransform;\r\n    this._fakeWaveCounter = result.fakeWaveCounter;\r\n\r\n    // Angle limits\r\n    if (this._config.angleLimitConfig.angleLimit >= 0) {\r\n      applyAngleLimits(this._pointsR, this._pointsRW, this._config.angleLimitConfig);\r\n    }\r\n\r\n    // Apply results\r\n    const transformRots = this._pointTransforms.map((t) => t.getWorldRotation());\r\n    const transformLocalRots = this._pointTransforms.map((t) => t.getLocalRotation());\r\n    const outputs = applyResult(\r\n      this._pointsR,\r\n      this._pointsRW,\r\n      this._positionsToTransform,\r\n      blendRatio,\r\n      transformRots,\r\n      transformLocalRots\r\n    );\r\n\r\n    for (let i = 0; i < outputs.length; i++) {\r\n      this._pointTransforms[i].setWorldPosition(outputs[i].position);\r\n      this._pointTransforms[i].setWorldRotation(outputs[i].rotation);\r\n    }\r\n\r\n    this._previousRootPosition = rootPos;\r\n    this._previousRootRotation = rootRot;\r\n  }\r\n\r\n  /**\r\n   * 获取所有点的模拟结果（世界坐标位置和旋转）\r\n   * 通常不需要手动调用——step() 已经自动写回 transform。\r\n   * 适用于需要在不写回 transform 的情况下读取物理结果的场景。\r\n   */\r\n  getResults(): Array<{ position: Vector3; rotation: Quaternion }> {\r\n    const transformRots = this._pointTransforms.map((t) => t.getWorldRotation());\r\n    const transformLocalRots = this._pointTransforms.map((t) => t.getLocalRotation());\r\n    const outputs = applyResult(\r\n      this._pointsR,\r\n      this._pointsRW,\r\n      this._positionsToTransform,\r\n      this._config.blendRatio,\r\n      transformRots,\r\n      transformLocalRots\r\n    );\r\n    return outputs.map((o) => ({ position: o.position, rotation: o.rotation }));\r\n  }\r\n\r\n  /**\r\n   * 瞬移补偿——在角色传送/瞬移后调用\r\n   * 将上一帧的根骨骼位置和旋转设为当前值，\r\n   * 使下一帧的根运动增量为零，避免物理点因巨大位移而弹射。\r\n   */\r\n  warp(): void {\r\n    if (!this._rootTransform) {\r\n      return;\r\n    }\r\n    this._previousRootPosition = this._rootTransform.getWorldPosition();\r\n    this._previousRootRotation = this._rootTransform.getWorldRotation();\r\n  }\r\n\r\n  /**\r\n   * 重置所有物理状态\r\n   * 将所有点的模拟位置重置为当前 transform 位置，清除速度和抓取状态。\r\n   * 适用于场景切换或需要消除所有物理运动的场景。\r\n   */\r\n  reset(): void {\r\n    for (let i = 0; i < this._pointsRW.length; i++) {\r\n      const pos = this._pointTransforms[i].getWorldPosition();\r\n      this._pointsRW[i].positionCurrent = pos.clone();\r\n      this._pointsRW[i].positionPrevious = pos.clone();\r\n      this._pointsRW[i].grabberIndex = -1;\r\n    }\r\n    this._fakeWaveCounter = 0;\r\n  }\r\n\r\n  /**\r\n   * 释放固定点为动态点（如脱衣、布料脱落）\r\n   * 将 weight 从 0 改为 1，同时重置该点的模拟状态避免瞬间弹射。\r\n   * @param index 点的索引\r\n   */\r\n  releasePoint(index: number): void {\r\n    if (index < 0 || index >= this._pointsR.length) {\r\n      return;\r\n    }\r\n    (this._pointsR[index] as any).weight = 1;\r\n    const pos = this._pointTransforms[index].getWorldPosition();\r\n    this._pointsRW[index].positionCurrent = pos.clone();\r\n    this._pointsRW[index].positionPrevious = pos.clone();\r\n    this._pointsRW[index].grabberIndex = -1;\r\n  }\r\n\r\n  /**\r\n   * 将动态点重新固定为跟随动画（如重新穿戴）\r\n   * 将 weight 从 1 改为 0，清除抓取状态。\r\n   * @param index 点的索引\r\n   */\r\n  fixPoint(index: number): void {\r\n    if (index < 0 || index >= this._pointsR.length) {\r\n      return;\r\n    }\r\n    (this._pointsR[index] as any).weight = 0;\r\n    this._pointsRW[index].grabberIndex = -1;\r\n  }\r\n\r\n  /**\r\n   * 查询某个点是否为固定状态（weight=0，跟随动画）\r\n   * @param index 点的索引\r\n   */\r\n  isPointFixed(index: number): boolean {\r\n    if (index < 0 || index >= this._pointsR.length) {\r\n      return false;\r\n    }\r\n    return this._pointsR[index].weight <= EPSILON;\r\n  }\r\n\r\n  /** 获取物理点总数 */\r\n  get pointCount(): number {\r\n    return this._pointsR.length;\r\n  }\r\n\r\n  /**\r\n   * 渐入物理——从动画姿态平滑过渡到物理模拟\r\n   * blendRatio 从 1（纯动画）渐变到 0（纯物理）\r\n   * @param seconds 过渡时长（秒）\r\n   */\r\n  fadeIn(seconds: number): void {\r\n    this._fadeState = 'in';\r\n    this._fadeTimer = 0;\r\n    this._fadeDuration = seconds;\r\n  }\r\n\r\n  /**\r\n   * 渐出物理——从物理模拟平滑过渡回动画姿态\r\n   * blendRatio 从 0（纯物理）渐变到 1（纯动画）\r\n   * @param seconds 过渡时长（秒）\r\n   */\r\n  fadeOut(seconds: number): void {\r\n    this._fadeState = 'out';\r\n    this._fadeTimer = 0;\r\n    this._fadeDuration = seconds;\r\n  }\r\n\r\n  /**\r\n   * 设置全局风力向量\r\n   * 风力会按每个点的 windForceScale 和质量进行缩放\r\n   * @param wind 风力向量（世界坐标）\r\n   */\r\n  setWindForce(wind: Vector3): void {\r\n    this._config.windForce = wind;\r\n  }\r\n\r\n  /** Enable/disable broad-phase pruning for runtime performance comparison */\r\n  setBroadPhaseEnabled(enabled: boolean): void {\r\n    this._config.enableBroadPhase = enabled;\r\n  }\r\n\r\n  /**\r\n   * 暂停/恢复物理模拟\r\n   * 暂停时仍会跟随根骨骼运动，但不进行力学积分和约束求解\r\n   * @param paused true=暂停, false=恢复\r\n   */\r\n  setPaused(paused: boolean): void {\r\n    this._isPaused = paused;\r\n  }\r\n\r\n  /**\r\n   * 运行时更新碰撞器状态\r\n   * 用于外部直接控制碰撞器的启用/禁用和位置，而不通过 TransformAccess 读取\r\n   * @param index 碰撞器索引\r\n   * @param enabled 是否启用\r\n   * @param position 世界坐标位置\r\n   * @param rotation 世界旋转\r\n   */\r\n  updateColliderState(index: number, enabled: boolean, position: Vector3, rotation: Quaternion): void {\r\n    if (index >= 0 && index < this._collidersRW.length) {\r\n      this._collidersRW[index].enabled = enabled ? 1 : 0;\r\n      this._collidersRW[index].positionCurrentTransform = position;\r\n      this._collidersRW[index].directionCurrentTransform = rotation;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * 运行时更新抓取器状态\r\n   * 用于鼠标拖拽等交互场景，控制抓取器的启用和位置\r\n   * @param index 抓取器索引\r\n   * @param enabled 是否启用（鼠标按下=true，松开=false）\r\n   * @param position 抓取器世界坐标位置\r\n   */\r\n  updateGrabberState(index: number, enabled: boolean, position: Vector3): void {\r\n    if (index >= 0 && index < this._grabbersRW.length) {\r\n      this._grabbersRW[index].enabled = enabled ? 1 : 0;\r\n      this._grabbersRW[index].position = position;\r\n    }\r\n  }\r\n\r\n  private _computeBlendRatio(): number {\r\n    if (this._fadeState === 'in') {\r\n      return 1.0 - clamp01(this._fadeTimer / this._fadeDuration);\r\n    }\r\n    if (this._fadeState === 'out') {\r\n      return clamp01(this._fadeTimer / this._fadeDuration);\r\n    }\r\n    return this._config.blendRatio;\r\n  }\r\n\r\n  private _createPointR(\r\n    node: BoneNode,\r\n    maxDepth: number,\r\n    parentMap: Map<number, number>,\r\n    transforms: TransformAccess[]\r\n  ): PointR {\r\n    const rate = maxDepth > 0 ? node.depth / maxDepth : 0;\r\n    const c = this._config.curves;\r\n\r\n    const parentIdx = parentMap.get(node.index) ?? -1;\r\n    const childIdx = node.children.length > 0 ? node.children[0].index : -1;\r\n\r\n    // Capture initial local transform for rotation blending\r\n    const t = transforms[node.index];\r\n    const initLocalPos = t.getLocalPosition();\r\n    const initLocalRot = t.getLocalRotation();\r\n    const initLocalScale = t.getLocalScale();\r\n\r\n    // BoneAxis: local-space direction to first child (computed in initialize)\r\n    const boneAxis = node.boneAxis ?? new Vector3(0, -1, 0);\r\n\r\n    // ParentLength: distance to parent\r\n    let parentLength = 0;\r\n    if (parentIdx !== -1) {\r\n      const pPos = transforms[parentIdx].getWorldPosition();\r\n      const cPos = transforms[node.index].getWorldPosition();\r\n      parentLength = Vector3.distance(pPos, cPos);\r\n    }\r\n\r\n    return {\r\n      parent: parentIdx,\r\n      child: childIdx,\r\n      applyInvertCollision: 0,\r\n      movableLimitIndex: -1,\r\n      movableLimitRadius: 0,\r\n      weight: node.isFixed ? 0 : 1,\r\n      mass: c.massScale.evaluate(rate),\r\n      resistance: clamp01(c.resistance.evaluate(rate)),\r\n      hardness: clamp01(c.hardness.evaluate(rate)),\r\n      frictionScale: c.friction.evaluate(rate),\r\n      sliderJointLength: c.sliderJointLength.evaluate(rate),\r\n      parentLength,\r\n      structuralShrinkVertical: c.structuralShrinkVertical.evaluate(rate) * 0.5,\r\n      structuralStretchVertical: c.structuralStretchVertical.evaluate(rate) * 0.5,\r\n      structuralShrinkHorizontal: c.structuralShrinkHorizontal.evaluate(rate) * 0.5,\r\n      structuralStretchHorizontal: c.structuralStretchHorizontal.evaluate(rate) * 0.5,\r\n      shearShrink: c.shearShrink.evaluate(rate) * 0.5,\r\n      shearStretch: c.shearStretch.evaluate(rate) * 0.5,\r\n      bendingShrinkVertical: c.bendingShrinkVertical.evaluate(rate) * 0.5,\r\n      bendingStretchVertical: c.bendingStretchVertical.evaluate(rate) * 0.5,\r\n      bendingShrinkHorizontal: c.bendingShrinkHorizontal.evaluate(rate) * 0.5,\r\n      bendingStretchHorizontal: c.bendingStretchHorizontal.evaluate(rate) * 0.5,\r\n      windForceScale: c.windForceScale.evaluate(rate) * rate,\r\n      fakeWavePower: c.fakeWavePower.evaluate(rate),\r\n      fakeWaveFreq: c.fakeWaveFreq.evaluate(rate),\r\n      forceFadeRatio: 0,\r\n      pointRadius: 0.05,\r\n      gravity: Vector3.scale(this._config.gravity, c.gravityScale.evaluate(rate)),\r\n      boneAxis,\r\n      initialLocalScale: initLocalScale,\r\n      initialLocalRotation: initLocalRot,\r\n      initialLocalPosition: initLocalPos\r\n    };\r\n  }\r\n\r\n  private _createPointRW(): PointRW {\r\n    return {\r\n      positionToTransform: Vector3.zero(),\r\n      positionCurrentTransform: Vector3.zero(),\r\n      positionPreviousTransform: Vector3.zero(),\r\n      positionCurrent: Vector3.zero(),\r\n      positionPrevious: Vector3.zero(),\r\n      directionPrevious: Vector3.axisPZ(),\r\n      fakeWindDirection: Vector3.axisPZ(),\r\n      grabberIndex: -1,\r\n      grabberDistance: 0,\r\n      friction: 0\r\n    };\r\n  }\r\n\r\n  private _createColliderRW(transform: TransformAccess): ColliderRW {\r\n    const pos = transform.getWorldPosition();\r\n    const rot = transform.getWorldRotation();\r\n    return {\r\n      positionCurrent: pos.clone(),\r\n      directionCurrent: Vector3.zero(),\r\n      boundsCenter: pos.clone(),\r\n      boundsRadius: 0,\r\n      positionCurrentTransform: pos.clone(),\r\n      positionPreviousTransform: pos.clone(),\r\n      directionCurrentTransform: rot.clone(),\r\n      directionPreviousTransform: rot.clone(),\r\n      worldToLocal: Matrix4x4.identity(),\r\n      localBoundsMin: Vector3.zero(),\r\n      localBoundsMax: Vector3.zero(),\r\n      radius: 0,\r\n      enabled: 1\r\n    };\r\n  }\r\n}\r\n"],"names":["SpringSystemController","_config","_pointsR","_pointsRW","_constraints","_collidersR","_collidersRW","_grabbersR","_grabbersRW","_movableLimitTargets","_flatPlanes","_surfaceConstraints","_positionsToTransform","_fakeWaveCounter","_previousRootPosition","Vector3","zero","_previousRootRotation","Quaternion","identity","_rootTransform","_pointTransforms","_colliderTransforms","_grabberTransforms","_initialized","_isPaused","_fadeState","_fadeTimer","_fadeDuration","config","initialize","rootTransform","rootPoints","pointTransforms","colliders","grabbers","flatPlanes","map","c","transform","g","buildConstraints","constraintOptions","buildSurfaceFaces","isLoop","allPoints","parentMap","Map","walk","node","push","children","set","index","r","maxDepth","Math","max","p","depth","indexToNode","boneAxis","length","childPos","getWorldPosition","parentPos","parentRot","getWorldRotation","parentScale","getLocalScale","diff","sub","invRot","inverse","localDir","unscaled","x","y","z","normalize","_createPointR","_createPointRW","Array","fill","_createColliderRW","enabled","position","fp","normal","up","distance","dot","i","pos","positionCurrent","clone","positionPrevious","positionCurrentTransform","positionPreviousTransform","positionToTransform","directionPrevious","axisPZ","fakeWindDirection","grabberIndex","grabberDistance","friction","step","deltaTime","blendRatio","_computeBlendRatio","rootPos","rootRot","t","directionPreviousTransform","directionCurrentTransform","worldToLocal","Matrix4x4","compose","inplaceInvertAffine","params","isPaused","stepTime","subSteps","rootPosition","previousRootPosition","rootSlideLimit","rootRotation","previousRootRotation","rootRotateLimit","windForce","enableSurfaceCollision","surfaceConstraints","relaxation","constraintShrinkLimit","isFakeWave","fakeWaveSpeed","fakeWavePower","fakeWaveCounter","collisionScale","enableBroadPhase","result","simulate","positionsToTransform","angleLimitConfig","angleLimit","applyAngleLimits","transformRots","transformLocalRots","getLocalRotation","outputs","applyResult","setWorldPosition","setWorldRotation","rotation","getResults","o","warp","reset","releasePoint","weight","fixPoint","isPointFixed","EPSILON","pointCount","fadeIn","seconds","fadeOut","setWindForce","wind","setBroadPhaseEnabled","setPaused","paused","updateColliderState","updateGrabberState","clamp01","transforms","rate","curves","parentIdx","get","childIdx","initLocalPos","getLocalPosition","initLocalRot","initLocalScale","parentLength","pPos","cPos","parent","child","applyInvertCollision","movableLimitIndex","movableLimitRadius","isFixed","mass","massScale","evaluate","resistance","hardness","frictionScale","sliderJointLength","structuralShrinkVertical","structuralStretchVertical","structuralShrinkHorizontal","structuralStretchHorizontal","shearShrink","shearStretch","bendingShrinkVertical","bendingStretchVertical","bendingShrinkHorizontal","bendingStretchHorizontal","windForceScale","fakeWaveFreq","forceFadeRatio","pointRadius","gravity","scale","gravityScale","initialLocalScale","initialLocalRotation","initialLocalPosition","rot","directionCurrent","boundsCenter","boundsRadius","localBoundsMin","localBoundsMax","radius"],"mappings":"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"}

package/dist/animation/spring2/math.js

@@ -0,0 +1,16 @@
+// spcr-joint-dynamics — math adapter layer
+// Wraps base/vector.ts (class-based) with plain-object API for backward compatibility
+// ── Utility ──
+function clamp(v, min, max) {
+    return v < min ? min : v > max ? max : v;
+}
+function clamp01(v) {
+    return v < 0 ? 0 : v > 1 ? 1 : v;
+}
+function smoothStep(from, to, t) {
+    const c = clamp01((t - from) / (to - from));
+    return c * c * (3 - 2 * c);
+}
+
+export { clamp, clamp01, smoothStep };
+//# sourceMappingURL=math.js.map

package/dist/animation/spring2/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","sources":["../../../src/animation/spring2/math.ts"],"sourcesContent":["// spcr-joint-dynamics — math adapter layer\n// Wraps base/vector.ts (class-based) with plain-object API for backward compatibility\n\n// ── Utility ──\n\nexport function clamp(v: number, min: number, max: number): number {\n  return v < min ? min : v > max ? max : v;\n}\n\nexport function clamp01(v: number): number {\n  return v < 0 ? 0 : v > 1 ? 1 : v;\n}\n\nexport function smoothStep(from: number, to: number, t: number): number {\n  const c = clamp01((t - from) / (to - from));\n  return c * c * (3 - 2 * c);\n}\n"],"names":["clamp","v","min","max","clamp01","smoothStep","from","to","t","c"],"mappings":"AAAA;AACA;AAEA;AAEO,SAASA,KAAMC,CAAAA,CAAS,EAAEC,GAAW,EAAEC,GAAW,EAAA;AACvD,IAAA,OAAOF,CAAIC,GAAAA,GAAAA,GAAMA,GAAMD,GAAAA,CAAAA,GAAIE,MAAMA,GAAMF,GAAAA,CAAAA;AACzC;AAEO,SAASG,QAAQH,CAAS,EAAA;AAC/B,IAAA,OAAOA,CAAI,GAAA,CAAA,GAAI,CAAIA,GAAAA,CAAAA,GAAI,IAAI,CAAIA,GAAAA,CAAAA;AACjC;AAEO,SAASI,UAAWC,CAAAA,IAAY,EAAEC,EAAU,EAAEC,CAAS,EAAA;IAC5D,MAAMC,CAAAA,GAAIL,QAAQ,CAACI,IAAIF,IAAG,KAAMC,EAAAA,GAAKD,IAAG,CAAA,CAAA;AACxC,IAAA,OAAOG,CAAIA,GAAAA,CAAAA,IAAK,CAAA,GAAI,IAAIA,CAAAA,CAAAA;AAC1B;;;;"}