Bevy 下利用 Verlet 积分算法实现 2d 绳索物理效果的模拟

简单描述 Verlet 算法#

Verlet 积分算法是一种数值积分方法，常用于物理模拟中，特别适合处理粒子系统和刚体动力学。它通过跟踪粒子的位置和前一位置来计算新的位置，从而避免了速度的直接计算。这种方法在模拟绳子、布料等柔性物体时表现出色，因为它能够自然地处理约束条件。

简单来说，我们可以把绳子看作一系列质点，每两个相邻质点之间有一条约束，可以把这条约束看作一根杆子，用来确保相邻两个质点之间的距离不变，这样我们就可以实现“牵一发而动全身”。至于质点的运动主要是靠两个位置来决定的——当前位置和旧位置。杆子的约束用来更新质点的当前位置，而质点可以根据verlet算法通过旧位置和当前位置来推出新位置，从而模拟出真实的物理效果。

Bevy 中实现#

完整项目请见 👇

mengh04

verlet

Waiting for api.github.com...

00K

Waiting...

定义组件#

这是质点组件

1
#[derive(Component)]
2
struct Particle {
3
    current_pos: Vec2,
4
    old_pos: Vec2,
5
    is_locked: bool, // 这里方便后续确定是否是固定点
6
}

这是代表杆子的组件

1
#[derive(Component)]
2
struct Stick {
3
    p1: Entity,
4
    p2: Entity,
5
    length: f32,
6
}

这个是代表锁定的组件，这样后续筛选锁住的质点的时候就不需要遍历整个质点了，而是通过 ECS 系统直接找到包含 Locked 组件的质点，有利于性能的提升。

1
#[derive(Component)]
2
struct Locked;

初始化#

1
fn setup(mut commands: Commands) {
2
    // 生成一个 2D 摄像机
3
    commands.spawn(Camera2d::default());
4

5
    // 初始化一系列质点
6
    let mut prev_particle = None;
7
    for i in 0..30 {
8
        let particle = commands
9
            .spawn((Particle {
10
                current_pos: Vec2::new(0.0, 300.0 - i as f32 * 10.0), // 每两个质点之间间隔 10 个像素
11
                old_pos: Vec2::new(0.0, 300.0 - i as f32 * 10.0),
12
                is_locked: if i == 0 { true } else { false }, // 在这个 demo 里我把第一个点标记为了固定点跟随鼠标移动
13
            },))
14
            .id();
15
        if i == 0 {
16
            commands.entity(particle).insert(Locked);
17
        }
18
        if let Some(prev_particle) = prev_particle { // 在这里初始化 “杆子”
19
            commands.spawn(Stick {
20
                p1: prev_particle,
21
                p2: particle,
22
                length: 10.0,
23
            });
24
        }
25
        prev_particle = Some(particle);
26
    }
27
}

设置固定点跟随鼠标#

1
fn follow_mouse(
2
    mut query: Query<&mut Particle, With<Locked>>,
3
    q_window: Query<&Window>,
4
    q_camera: Query<(&Camera, &GlobalTransform)>,
5
) {
6
    let Ok(window) = q_window.single() else {
7
        return;
8
    };
9
    let Ok((camera, camera_transform)) = q_camera.single() else {
10
        return;
11
    };
12
    if let Some(cursor_pos) = window.cursor_position() {
13
        if let Ok(world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_pos) {
14
            let Ok(mut locked_particle) = query.single_mut() else {
15
                return;
16
            };
17
            locked_particle.current_pos = world_pos;
18
        }
19
    }
20
}

更新质点位置#

这里就是利用了 verlet 算法的地方

Verlet 积分的核心在于利用位置函数 $x(t)$ 在时间点 $t$ 附近的两个方向的 泰勒级数（Taylor Series） 展开。

1. 向前展开（预测未来）#

我们预测下一时刻 $t + \Delta t$ 的位置：

x(t + \Delta t) = x(t) + \frac{dx}{dt}\Delta t + \frac{1}{2}\frac{d^2x}{dt^2}\Delta t^2 + \frac{1}{6}\frac{d^3x}{dt^3}\Delta t^3 + O(\Delta t^4)

使用物理符号简化表示（ $v$ 为速度， $a$ 为加速度）：

x(t + \Delta t) = x(t) + v\Delta t + \frac{1}{2}a\Delta t^2 + \frac{1}{6}j\Delta t^3 + O(\Delta t^4) \quad \text{--- (式1)}

2. 向后展开（回溯过去）#

同理，我们可以写出上一时刻 $t - \Delta t$ 的位置：

x(t - \Delta t) = x(t) - v\Delta t + \frac{1}{2}a\Delta t^2 - \frac{1}{6}j\Delta t^3 + O(\Delta t^4) \quad \text{--- (式2)}

3. 相加消去速度项#

将 (式1) 和 (式2) 相加，奇数阶导数项（包括速度 $v$ 和加加速度 $j$ ）由于正负抵消而消失：

x(t + \Delta t) + x(t - \Delta t) = 2x(t) + a\Delta t^2 + O(\Delta t^4)

4. 最终公式#

移项解出 $x(t + \Delta t)$ ，得到 Verlet 积分的标准形式： $x(t + \Delta t) = 2x(t) - x(t - \Delta t) + a\Delta t^2$

为了对应代码逻辑，将其拆解为： $x(t + \Delta t) = x(t) + \underbrace{(x(t) - x(t - \Delta t))}_{\text{惯性 (Velocity)}} + \underbrace{a\Delta t^2}_{\text{受力 (Acceleration)}}$

1
fn update_particles(time: Res<Time>, mut q_particles: Query<&mut Particle, Without<Locked>>) {
2
    let dt = time.delta_secs();
3
    let dt_square = dt * dt;
4
    let gravity = Vec2::new(0.0, -1500.0);
5

6
    for mut particle in q_particles.iter_mut() {
7
        let velocity = particle.current_pos - particle.old_pos;
8
        let new_pos = particle.current_pos + velocity + gravity * dt_square;
9
        particle.old_pos = particle.current_pos;
10
        particle.current_pos = new_pos;
11
    }
12
}

处理约束#

1
fn handle_sticks(q_sticks: Query<&Stick>, mut q_particles: Query<&mut Particle>) {
2
    for _ in 0..50 {
3
        for stick in q_sticks.iter() {
4
            if let Ok([mut p1, mut p2]) = q_particles.get_many_mut([stick.p1, stick.p2]) {
5
                let delta = p2.current_pos - p1.current_pos;
6
                let distance = delta.length();
7
                if distance == 0.0 {
8
                    continue;
9
                }
10
                let diff = (distance - stick.length) / distance;
11
                let offset = delta * diff;
12

13
                match (p1.is_locked, p2.is_locked) {
14
                    (true, true) => {}
15
                    (true, false) => {
16
                        p2.current_pos -= offset;
17
                    }
18
                    (false, true) => {
19
                        p1.current_pos += offset;
20
                    }
21
                    (false, false) => {
22
                        p1.current_pos += offset * 0.5;
23
                        p2.current_pos -= offset * 0.5;
24
                    }
25
                }
26
            }
27
        }
28
    }
29
}

最后用 gizmos 画出来#

1
fn draw_particles(mut gizmos: Gizmos, query: Query<(&Particle, Has<Locked>)>) {
2
    for (particle, is_locked) in query.iter() {
3
        if is_locked {
4
            gizmos.circle_2d(particle.current_pos, 3.0, Color::srgb(1.0, 0.0, 0.0));
5
        } else {
6
            gizmos.circle_2d(particle.current_pos, 3.0, Color::srgb(0.0, 1.0, 0.0));
7
        }
8
    }
9
}

主函数#

1
fn main() {
2
    App::new()
3
        .add_plugins(DefaultPlugins)
4
        .add_systems(Startup, setup)
5
        .add_systems(
6
            FixedUpdate,
7
            (follow_mouse, update_particles, handle_sticks).chain(),
8
        )
9
        .add_systems(Update, draw_particles)
10
        .run();
11
}