Unity软体模拟实战：从质点弹簧到位置动力学实现弹性物体

1. 项目概述：为什么要在Unity里折腾软体模拟？

如果你在Unity里做过物理交互，大概率是从一个Rigidbody和一个Box Collider开始的。刚体物理很直观，一个方块掉下来，砸到地面，砰一声，符合我们的日常认知。但当你需要一块布随风飘动，一个果冻Q弹地摇晃，或者一个充气城堡被角色压扁又弹起时，刚体那套“硬邦邦”的规则就立刻显得力不从心了。这就是“软体模拟”要解决的问题——模拟那些具有连续变形能力、内部结构柔软、受力后形状会发生显著变化的物体。

在游戏、虚拟仿真甚至一些影视预演中，软体模拟能极大提升沉浸感和视觉表现力。想象一下《塞尔达传说》里林克的滑翔伞布料，《双人成行》里面那些软绵绵的卡通角色，或者是模拟手术中柔软的组织，其底层都有软体模拟技术的支撑。Unity引擎本身内置的物理引擎（NVIDIA PhysX）主要擅长离散的刚体动力学和有限的布料模拟，对于自定义度高、性能要求苛刻或风格化明显的软体效果，往往需要我们动手实现一套模拟方案。

这次，我就结合自己踩过的坑和项目实践，从头拆解在Unity中实现软体模拟的几种核心思路、具体做法，以及如何避开那些让效果“穿帮”或性能“爆炸”的陷阱。无论你是想做一个有趣的弹性玩偶，还是为你的游戏增加一抹真实的柔软质感，这篇内容都能给你提供可直接落地的参考。

2. 软体模拟的核心思路：从质点弹簧系统到位置动力学

实现软体模拟，本质上是在求解一个物理问题：如何用计算机模拟一堆连续、柔软的材料。在游戏实时运行的帧率限制下（通常60FPS），我们无法求解复杂的偏微分方程，因此需要将连续体离散化，并用一些简化的物理模型来近似。最主流、最经典的方法莫过于质点弹簧系统。

2.1 质点弹簧系统：万变不离其宗的基础

你可以把要模拟的软体（比如一个球）想象成一个由许多小质点（Particle）组成的网格，这些质点之间通过虚拟的“弹簧”连接。这就是质点弹簧模型。

2.1.1 模型构成与受力分析

一个最简单的质点弹簧系统包含三个核心要素：

1. 质点：具有质量、位置、速度等状态。在Unity中，我们可以用一个Vector3表示位置，一个Vector3表示速度，一个float表示质量。
2. 结构弹簧：连接相邻质点，负责维持物体的基本形状。它就像一根有初始长度的橡皮筋，当被拉伸或压缩时，会产生试图恢复原长的力。
3. 弯曲弹簧/剪力弹簧：连接非直接相邻的质点（例如，网格中对角线上的点），用于抵抗弯曲和剪切变形，让软体更有体积感和抗扭能力。

每一帧，我们需要为每个质点计算合力，然后根据牛顿第二定律（F=ma）更新其速度和位置。

弹簧力的计算是核心。通常使用胡克定律的简化版：force = -springConstant * (currentLength - restLength) * direction其中，springConstant是弹簧刚度系数，currentLength是当前弹簧长度，restLength是弹簧原长，direction是从质点A指向质点B的单位向量。这个力会同时作用在两个端点的质点上，方向相反。

注意：单纯的胡克定律会导致系统永远振动下去。因此必须引入阻尼力，其方向与质点相对速度在弹簧方向上的投影相反，用于消耗能量，让振动逐渐停止。阻尼系数需要仔细调整，太小则抖动不停，太大则显得僵硬。

2.1.2 Unity中的初步实现

我们不会直接用Rigidbody来当质点，因为Unity对大量Rigidbody的更新开销很大，且难以精细控制。更常见的做法是，用普通的GameObject或Transform数组来代表质点，在MonoBehaviour的Update或FixedUpdate中手动进行物理积分。

public class SoftBodyParticle : MonoBehaviour { public Vector3 velocity; public float mass = 1.0f; public bool isFixed = false; // 是否固定位置（如悬挂点） void Start() { velocity = Vector3.zero; } } public class Spring { public SoftBodyParticle particleA; public SoftBodyParticle particleB; public float restLength; public float springConstant; public float dampingConstant; }

在管理类中，每帧遍历所有弹簧，计算弹簧力并累加到对应质点上，然后遍历所有质点，用显式欧拉法积分：

void FixedUpdate() { // 1. 清空每个质点的累积力（通常只保留重力） foreach (var p in particles) { p.force = Vector3.down * gravity * p.mass; } // 2. 计算所有弹簧力 foreach (var s in springs) { Vector3 deltaPos = s.particleB.position - s.particleA.position; float currentLength = deltaPos.magnitude; if (Mathf.Approximately(currentLength, 0)) continue; Vector3 dir = deltaPos / currentLength; // 胡克定律 + 阻尼 float springForceMag = s.springConstant * (currentLength - s.restLength); float relVel = Vector3.Dot(s.particleB.velocity - s.particleA.velocity, dir); float dampingForceMag = s.dampingConstant * relVel; float totalForceMag = springForceMag + dampingForceMag; Vector3 force = dir * totalForceMag; // 作用力与反作用力 if (!s.particleA.isFixed) s.particleA.force += force; if (!s.particleB.isFixed) s.particleB.force -= force; // 方向相反 } // 3. 积分：更新速度和位置 (显式欧拉，简单但不稳定) float dt = Time.fixedDeltaTime; foreach (var p in particles) { if (p.isFixed) continue; Vector3 acceleration = p.force / p.mass; p.velocity += acceleration * dt; p.position += p.velocity * dt; } }

2.1.3 显式欧拉法的陷阱与改进

上面用的显式欧拉积分法虽然简单，但有个致命缺点：稳定性差。弹簧刚度(springConstant)或时间步长(dt)稍大，系统就容易“爆炸”，质点会飞得到处都是。这是因为该方法对未来状态的预测过于激进。

在实际项目中，我们通常会采用更稳定的积分器：

• 韦尔莱积分：在游戏物理中非常常见，尤其适用于粒子系统。它利用上一帧的位置和加速度来计算新位置，通常比显式欧拉更稳定。
• 半隐式欧拉法：先更新速度，再用新速度更新位置，比显式欧拉稳定一个数量级，是游戏物理中质点更新的主流选择。
• 龙格-库塔法：精度更高，但计算量也更大，在实时软体模拟中较少使用。

将上面的积分部分改为半隐式欧拉法：

// 半隐式欧拉积分 foreach (var p in particles) { if (p.isFixed) continue; Vector3 acceleration = p.force / p.mass; p.velocity += acceleration * dt; // 用当前力更新速度 p.position += p.velocity * dt; // 用新速度更新位置 }

这个简单的改动能显著提升模拟的稳定性，允许你使用更大的springConstant或应对更剧烈的碰撞。

2.2 位置动力学：更稳定、更艺术的控制方法

质点弹簧系统基于力，符合物理直觉，但调参（弹簧刚度、阻尼）是个技术活，且容易不稳定。另一种在游戏和动画中越来越流行的思路是位置动力学。它不直接计算力，而是定义约束条件，然后通过迭代求解直接修正质点的位置。

2.2.1 核心思想：约束投影

想象一下，对于连接质点A和B的弹簧，其约束就是“两者之间的距离应尽可能接近原长”。位置动力学每帧会做这样的事：

1. 先根据外力（如重力）和当前速度，预测每个质点下一帧的“临时位置”。
2. 然后，遍历所有约束（如距离约束、弯曲约束），对每一对受约束的质点，移动它们的临时位置，使其满足约束条件（例如，将距离拉回或推到原长）。
3. 重复步骤2若干次（迭代），让所有约束都得到尽可能的满足。
4. 最后，根据修正后的临时位置和上一帧的位置，计算出新的速度。

这种方法最大的优点是无条件稳定。无论时间步长多大，系统都不会爆炸（但可能会变得很“软”或失真）。它非常适合实现那些看起来“软乎乎”、风格化强烈的效果，比如卡通角色的摇晃。

2.2.2 距离约束的简单实现

一个最基本的距离约束实现如下：

void SatisfyDistanceConstraint(Particle p1, Particle p2, float restLength) { Vector3 delta = p2.tempPosition - p1.tempPosition; float currentDistance = delta.magnitude; if (Mathf.Approximately(currentDistance, 0)) return; // 计算需要修正的偏移量 float correctionFactor = (currentDistance - restLength) / currentDistance; // 根据质量比例分配偏移 (假设质量倒数) float invMass1 = 1.0f / p1.mass; float invMass2 = 1.0f / p2.mass; float totalInvMass = invMass1 + invMass2; if (!p1.isFixed) { p1.tempPosition += delta * (correctionFactor * (invMass1 / totalInvMass)); } if (!p2.isFixed) { p2.tempPosition -= delta * (correctionFactor * (invMass2 / totalInvMass)); } }

在主循环中，我们会先更新临时位置（加上重力等外力），然后多次迭代调用所有约束的Satisfy函数，最后用临时位置更新实际位置和速度。

2.2.3 与质点弹簧的对比与选型

特性	质点弹簧系统 (Force-Based)	位置动力学 (Position-Based)
物理基础	基于牛顿力学，计算力与加速度	基于几何约束，直接修正位置
稳定性	条件稳定，依赖积分器和参数	无条件稳定，不易爆炸
性能开销	相对较低，计算一次力即可	较高，需要多次迭代求解约束
调参直观性	需要调弹簧刚度、阻尼，有物理意义	调约束刚度、迭代次数，更偏向“感觉”
效果倾向	更偏向真实物理的弹性振动	更偏向可控、风格化的柔软变形
适合场景	需要较真实物理反馈的模拟，如布料、绳索	卡通软体、角色软组织、对稳定性要求高的交互

实操心得：对于游戏中的大多数软体需求（比如一个摇晃的史莱姆、一个吊着的旗帜），位置动力学往往是更省心的选择。你不需要担心数值爆炸，通过调整迭代次数就能在性能和效果间取得平衡。追求物理精度或需要与Unity物理引擎深度交互（如精确的碰撞响应）时，再考虑优化后的质点弹簧系统。

3. 从理论到网格：构建一个可渲染的软体对象

有了模拟核心，我们需要一个具体的物体来承载这些质点和约束。最常见的方式就是从一个3D网格开始。

3.1 网格生成与质点绑定

假设我们要模拟一个软体球。

1. 生成基础网格：可以在3D建模软件中创建一个低精度的球体模型（例如，由多个三角形面片组成的经纬球或立方球），导入Unity。网格顶点（Vertices）将作为我们模拟的质点。顶点数直接决定了模拟的精度和性能开销。
2. 创建质点与弹簧/约束：
   • 遍历网格的所有顶点，为每个顶点创建一个Particle数据对象，存储其质量、位置、速度等。初始位置就是顶点的模型空间或世界空间坐标。
   • 构建结构弹簧：遍历网格的所有边（每个三角形包含三条边）。对于每条边，连接其两个端点顶点对应的质点，创建一根弹簧，其原长就是两顶点间的初始距离。
   • 构建弯曲弹簧：为了抵抗弯曲，我们需要连接那些共享一个顶点的非相邻边。一个简单的方法是，对于每个三角形，连接其三个顶点中不相邻的两两组合（即三角形的三条边本身是结构弹簧，我们还需要增加比如从顶点0到顶点2的弹簧，如果它们不是直接边的话）。更系统的方法是寻找“角度约束”或连接距离为2的顶点。

一个常见的坑：弹簧原长的计算。一定要在模型初始化的静止状态下计算弹簧原长，这个长度是弹簧“想要”保持的长度。如果你在模型已经发生变形后才计算，模拟就会从变形后的状态开始，永远回不到初始形状。

3.2 实时更新网格与渲染

模拟每帧更新的是质点的位置（即顶点位置）。我们需要将这些新位置写回Mesh，并更新法线，才能看到形变效果。

public class SoftBodyMesh : MonoBehaviour { private Mesh originalMesh; private Mesh deformedMesh; private Vector3[] originalVertices; private Vector3[] currentVertices; private Particle[] particles; // 与顶点一一对应 void Start() { MeshFilter mf = GetComponent<MeshFilter>(); originalMesh = mf.mesh; deformedMesh = Instantiate(originalMesh); // 复制一个Mesh进行修改 mf.mesh = deformedMesh; originalVertices = originalMesh.vertices; currentVertices = new Vector3[originalVertices.Length]; originalMesh.vertices.CopyTo(currentVertices, 0); // 初始化粒子 particles = new Particle[originalVertices.Length]; for (int i = 0; i < originalVertices.Length; i++) { particles[i] = new Particle(); particles[i].position = transform.TransformPoint(originalVertices[i]); // 转换为世界坐标 particles[i].mass = 1.0f; } // ... 初始化弹簧/约束 ... } void FixedUpdate() { // 1. 执行物理模拟，更新 particles[i].position (世界坐标) Simulate(); // 2. 将世界坐标的粒子位置，转换回模型空间的顶点位置 for (int i = 0; i < currentVertices.Length; i++) { currentVertices[i] = transform.InverseTransformPoint(particles[i].position); } // 3. 更新Mesh deformedMesh.vertices = currentVertices; // 必须重新计算法线，否则光照会出错 deformedMesh.RecalculateNormals(); // 如果碰撞体依赖Mesh，可能还需要 RecalculateBounds() // deformedMesh.RecalculateBounds(); } }

重要提示：直接修改Mesh.vertices并RecalculateNormals()在每帧进行，对性能有一定影响，尤其是顶点数较多时。对于移动平台或大量软体，这是主要性能瓶颈之一。优化方法包括：

1. 使用Job System和Burst Compiler进行并行顶点计算。
2. 在GPU上通过Compute Shader进行模拟和顶点变换（高阶技巧）。
3. 降低网格分辨率，用更少的顶点进行模拟，然后通过Shader或后期处理平滑表面。

3.3 碰撞检测与响应

软体不能穿墙。我们需要让每个质点都能与环境中的碰撞体进行交互。

3.3.1 质点级别的碰撞检测

最简单的做法是，在更新每个质点位置后，进行一轮碰撞检测与响应：

void HandleCollisions(Particle p) { // 简单球形检测 float radius = 0.1f; // 质点的碰撞半径 Vector3 direction; float distance; // 假设与一个平面碰撞（例如，y=0的地面） if (p.position.y < radius) { p.position.y = radius; // 将质点推到地面之上 // 碰撞响应：简单摩擦力与法向速度反射 float friction = 0.8f; p.velocity.x *= friction; p.velocity.z *= friction; p.velocity.y = -p.velocity.y * 0.5f; // 加入能量损失 } // 与球形碰撞体交互（更通用） // Vector3 sphereCenter = ...; // float sphereRadius = ...; // Vector3 toParticle = p.position - sphereCenter; // if (toParticle.magnitude < (sphereRadius + radius)) { // // 发生碰撞，将质点推到球体表面 // Vector3 normal = toParticle.normalized; // p.position = sphereCenter + normal * (sphereRadius + radius); // // 速度反射 // float dot = Vector3.Dot(p.velocity, normal); // if (dot < 0) { // p.velocity = p.velocity - (1.0f + bounciness) * dot * normal; // } // } }

将碰撞处理集成到物理积分步骤之后。对于复杂场景，可以使用Physics.OverlapSphere或Physics.CheckSphere来检测与Unity物理引擎中碰撞体的交互，但这会带来额外的性能开销。

3.3.2 保持体积：内部约束的重要性

仅有边上的结构弹簧，软体在受压时会像泄气的皮球一样轻易被压扁，缺乏“体积感”。为了模拟体积保持，我们需要引入体积约束或压力模型。

一个简单有效的体积约束思路：

1. 将软体网格视为由许多四面体组成（如果是实体）。计算初始状态下的总体积。
2. 每帧计算当前所有四面体的体积之和。
3. 如果当前体积与初始体积有差异，就对每个顶点施加一个力，将其沿法向推离或拉近中心，以恢复体积。

对于封闭的三角面片网格（如球体），可以将其视为一个空腔，计算其内部压力。压力与体积变化率相关，然后对每个三角形面片施加一个垂直于其表面、大小与面积和压力成正比的力，这个力再平均分配到三个顶点上。这能很好地模拟充气物体的感觉。

4. 性能优化与高级技巧：让软体真正“可用”

一个基础的软体模拟跑起来不难，但要把它用到实际项目中，尤其是移动端或包含多个软体的场景，性能优化至关重要。

4.1 多线程与作业系统

Unity的Job System和Burst Compiler是优化这类密集计算任务的利器。我们可以将质点的力累积、积分、约束求解等步骤包装成IJobParallelFor作业。

// 示例：使用Jobs更新质点位置（简化版） public struct UpdateParticlesJob : IJobParallelFor { public NativeArray<Vector3> positions; public NativeArray<Vector3> velocities; public NativeArray<Vector3> forces; public NativeArray<float> masses; public float deltaTime; public void Execute(int index) { // 半隐式欧拉积分 Vector3 acceleration = forces[index] / masses[index]; velocities[index] = velocities[index] + acceleration * deltaTime; positions[index] = positions[index] + velocities[index] * deltaTime; // 清空力，为下一帧准备（或在另一个Job中做） forces[index] = Vector3.zero; } }

在主线程中，你需要使用NativeArray来存储粒子数据，每帧调度这些Job。但要注意，约束求解（特别是位置动力学中的迭代）因为数据依赖性强，难以完美并行化，通常需要小心处理或放在主线程。

4.2 层次化模拟与动态拓扑

不是所有部分都需要同样的模拟精度。

• 层次化模拟：对网格进行简化，在低分辨率网格上进行物理模拟，然后通过插值（如线性混合或双四元数蒙皮）将变形传递到高分辨率渲染网格上。这能大幅降低物理计算量。
• 动态拓扑：对于像布料撕裂这样的效果，需要动态地切断弹簧连接。这需要在数据结构上支持弹簧的添加和移除，并在断裂时触发粒子分离和新边的生成。

4.3 与Unity生态的整合

4.3.1 使用Unity Collider进行碰撞

虽然我们可以自己实现质点碰撞，但为了与场景中其他使用Unity物理的对象交互，最好还是利用现有的碰撞系统。一种折中方案是：

1. 为软体生成一个简化的碰撞代理网格（比如用更少的顶点生成一个凸包或简单的球体/胶囊体集合）。
2. 在这个代理网格上挂载Rigidbody和Collider，并设置为Kinematic（由脚本控制运动）。
3. 每帧，根据软体模拟的整体形变（如所有质点的平均位置和包围盒），更新这个代理Rigidbody的位置和旋转。
4. 当代理碰撞体与其他物体发生碰撞时，获取碰撞点、法向和冲量信息，然后将这个碰撞影响反向施加到软体对应的质点上。

这样，软体既能与复杂的世界碰撞，又能保持自身的柔软变形。

4.3.2 使用Shader增强视觉效果

物理模拟的顶点数有限，模型表面可能显得棱角分明。我们可以通过Shader进行曲面细分或顶点法线平滑来提升视觉质量。

• 法线平滑：在RecalculateNormals()后，可以额外进行一步法线平均平滑，让表面看起来更柔和。
• 曲面细分：在支持曲面细分的平台上，可以在Domain Shader中根据物理模拟后的顶点位置，插值出更光滑的表面。
• 基于距离场的变形：一种更高级的方法是将软体的形变编码为距离场（SDF），在Shader中通过采样SDF来渲染表面。这能实现极其平滑的变形和融合效果，但实现复杂度也更高。

5. 实战：构建一个弹性果冻球

让我们把上面的理论整合起来，一步步创建一个有碰撞、有体积感的果冻球。

5.1 准备阶段

1. 在Unity中创建一个Sphere，将其Mesh Filter中的Mesh复制一份以备修改。
2. 创建一个JellySphere脚本，挂载到该物体上。

5.2 数据结构初始化

public class JellySphere : MonoBehaviour { public float particleMass = 0.1f; public float structuralSpringStiffness = 100.0f; public float bendSpringStiffness = 10.0f; public float volumeStiffness = 50.0f; public float damping = 5.0f; public int solverIterations = 5; // 约束求解迭代次数 private Mesh originalMesh, workingMesh; private Vector3[] originalVertices; private Particle[] particles; private List<Spring> structuralSprings; private List<Spring> bendSprings; private float initialVolume; void Start() { MeshFilter mf = GetComponent<MeshFilter>(); originalMesh = mf.sharedMesh; workingMesh = Instantiate(originalMesh); mf.mesh = workingMesh; originalVertices = originalMesh.vertices; InitializeParticles(); InitializeSprings(); CalculateInitialVolume(); } void InitializeParticles() { particles = new Particle[originalVertices.Length]; for (int i=0; i<particles.Length; i++) { particles[i] = new Particle(); particles[i].position = transform.TransformPoint(originalVertices[i]); particles[i].prevPosition = particles[i].position; particles[i].mass = particleMass; particles[i].isFixed = false; } // 固定顶部几个点模拟悬挂？ // particles[topVertexIndex].isFixed = true; } void InitializeSprings() { structuralSprings = new List<Spring>(); bendSprings = new List<Spring>(); // 获取网格三角形 int[] triangles = originalMesh.triangles; Dictionary<Edge, bool> edgeMap = new Dictionary<Edge, bool>(); // 1. 遍历三角形，找到所有唯一的边（结构弹簧） for (int i=0; i<triangles.Length; i+=3) { int a = triangles[i], b = triangles[i+1], c = triangles[i+2]; RegisterSpring(a, b, edgeMap, structuralSprings); RegisterSpring(b, c, edgeMap, structuralSprings); RegisterSpring(c, a, edgeMap, structuralSprings); } // 2. 寻找弯曲弹簧（这里简化：连接距离为2的顶点） // 可以通过邻接表找到共享顶点的非相邻边，此处省略复杂实现，可以先不加。 } void RegisterSpring(int idxA, int idxB, Dictionary<Edge, bool> map, List<Spring> list) { Edge edge = new Edge(Mathf.Min(idxA, idxB), Mathf.Max(idxA, idxB)); if (!map.ContainsKey(edge)) { map[edge] = true; Spring s = new Spring(); s.particleA = particles[idxA]; s.particleB = particles[idxB]; s.restLength = Vector3.Distance(s.particleA.position, s.particleB.position); s.stiffness = structuralSpringStiffness; s.damping = damping; list.Add(s); } } }

5.3 模拟循环与约束求解在FixedUpdate中，我们采用位置动力学（PBD）风格进行迭代求解，因为它更稳定。

void FixedUpdate() { float dt = Time.fixedDeltaTime; // 步骤1: 外力积分（重力） for (int i=0; i<particles.Length; i++) { if (particles[i].isFixed) continue; // Verlet积分中的位置预测 Vector3 tempPos = particles[i].position; particles[i].position = particles[i].position + (particles[i].position - particles[i].prevPosition) + (Physics.gravity * dt * dt); particles[i].prevPosition = tempPos; } // 步骤2: 迭代求解约束 for (int iter=0; iter<solverIterations; iter++) { // 距离约束 foreach (var s in structuralSprings) { SatisfyDistanceConstraint(s.particleA, s.particleB, s.restLength, s.stiffness); } // 体积约束（简化版，对四面体或整体施加） // SatisfyVolumeConstraint(); // 碰撞约束 foreach (var p in particles) { if (p.isFixed) continue; SatisfySphereCollision(p, Vector3.zero, 5.0f); // 与一个大球体碰撞 SatisfyFloorCollision(p, 0.0f); } } // 步骤3: 更新速度（用于阻尼等，PBD中速度是派生量） for (int i=0; i<particles.Length; i++) { particles[i].velocity = (particles[i].position - particles[i].prevPosition) / dt; } // 步骤4: 更新渲染网格 UpdateMesh(); }

5.4 体积约束的简化实现这里实现一个基于整体缩放的比例体积约束，虽然不精确但有效果：

void SatisfyVolumeConstraint() { // 计算当前顶点包围盒的近似体积（或计算网格体积） Vector3 center = Vector3.zero; foreach (var p in particles) center += p.position; center /= particles.Length; float currentScale = 0f; foreach (var p in particles) currentScale += (p.position - center).magnitude; currentScale /= particles.Length; // 假设初始体积对应一个平均半径 initialScale float initialScale = ...; // 在Start中计算 float scaleFactor = initialScale / currentScale; float stiffness = 0.1f; // 体积约束强度 // 将每个粒子向中心拉近或推远 foreach (var p in particles) { if (p.isFixed) continue; Vector3 toCenter = p.position - center; float targetDist = toCenter.magnitude * scaleFactor; if (Mathf.Abs(targetDist - toCenter.magnitude) > 0.001f) { Vector3 dir = toCenter.normalized; p.position = center + dir * Mathf.Lerp(toCenter.magnitude, targetDist, stiffness); } } }

5.5 最终效果与调整运行后，这个球体将具有弹性。你可以调整参数来获得不同感觉：

• structuralSpringStiffness：调高会让果冻更硬，像橡胶；调低则更软，像布丁。
• damping：调高能快速停止晃动，显得粘稠；调低则会长时间振动。
• solverIterations：迭代次数越多，约束满足得越好，体积保持和形状恢复越强，但性能开销越大。通常3-5次已足够。
• 给顶部一两个质点设置isFixed=true，就能模拟一个吊着的果冻，效果非常有趣。

6. 常见问题、排查与进阶方向

6.1 模拟不稳定，物体“爆炸”或剧烈抖动

• 原因1：时间步长过大或帧率不稳。确保在FixedUpdate中使用固定的Time.fixedDeltaTime进行积分，避免使用Update中的Time.deltaTime。
• 原因2：弹簧刚度过高。在显式积分中，过高的springConstant会导致数值不稳定。尝试降低刚度，或切换到更稳定的积分器（半隐式欧拉、韦尔莱），或直接采用位置动力学方法。
• 原因3：缺乏阻尼或阻尼太小。确保为弹簧力添加了速度阻尼项。
• 原因4：碰撞响应过冲。在碰撞处理中，将质点推离碰撞体表面后，如果下一帧速度仍然指向碰撞体，会再次穿透。确保碰撞后对法向速度进行了合理的反射和衰减。

6.2 软体过于“软塌”，无法保持形状

• 原因1：缺乏弯曲约束或体积约束。只有结构弹簧的物体就像一串珠子，无法抵抗弯曲和体积压缩。务必添加弯曲弹簧和/或体积约束。
• 原因2：约束迭代次数不足。在位置动力学中，增加solverIterations可以更好地满足所有约束，使物体更坚挺。
• 原因3：质点质量分布不均。检查是否所有质点质量设置合理。固定点（isFixed）的质量应设为无限大（或在计算中忽略）。

6.3 性能瓶颈

• 瓶颈通常在顶点/质点数量。首先考虑降低模拟网格的分辨率。
• 使用Profiler分析，看时间是耗在物理计算、约束求解还是Mesh更新上。针对性地优化：
  • 物理计算：尝试使用Job System并行化。
  • 约束求解：尝试使用空间分区数据结构（如网格或BVH）来减少需要检查的约束对，特别是对于长距离约束。
  • Mesh更新：如果不需要每帧更新碰撞体，可以跳过RecalculateBounds()。考虑将法线计算也放到Job中。

6.4 进阶方向

• 异构软体：模拟由不同材料组成的软体，例如包着硬芯的软糖。可以为不同的弹簧组设置不同的物理参数。
• 塑性变形：当形变超过某个阈值时，永久性地改变弹簧的原长，从而实现塑性变形（捏橡皮泥）。
• 撕裂与切割：动态检测弹簧的拉伸程度，超过极限时断开弹簧连接，并可能在断口处生成新的顶点和弹簧。
• 流体耦合：用软体模拟海绵，并与简单的流体粒子系统（SPH）结合，模拟吸水和渗水效果。

实现软体模拟是一个在物理真实性、性能开销和艺术可控性之间寻找平衡的过程。从最简单的质点弹簧开始，理解力的传递和积分；再尝试位置动力学，享受其稳定性带来的便利；最后根据项目需求，融入碰撞、体积保持和优化策略。这个过程本身，就是对实时物理模拟最生动的学习。