Rust 2D碰撞检测库parry2d-f64的使用，高性能几何计算与物理引擎集成

Parry 是一套2D和3D几何与碰撞检测库，包括 parry2d, parry3d, parry2d-f64 和 parry3d-f64。这些库由 Dimforge 组织使用Rust编程语言开发，完全免费且开源！

安装

在您的项目目录中运行以下Cargo命令：

cargo add parry2d-f64

或者在您的Cargo.toml中添加以下行：

parry2d-f64 = "0.22.0"

示例代码

下面是一个使用parry2d-f64进行2D碰撞检测的完整示例：

use parry2d_f64::{
    shape::{Ball, Cuboid},
    math::{Isometry, Vector},
    query::{self, Contact},
};

fn main() {
    // 创建一个球体和一个立方体
    let ball = Ball::new(1.0);
    let cube = Cuboid::new(Vector::new(1.0, 1.0));
    
    // 设置它们的位置
    let ball_pos = Isometry::translation(2.0, 0.0);
    let cube_pos = Isometry::identity();
    
    // 检测碰撞
    if let Some(contact) = query::contact(&ball_pos, &ball, &cube_pos, &cube, 0.0) {
        println!("碰撞检测结果:");
        println!("碰撞点: {:?}", contact.point);
        println!("碰撞法线: {:?}", contact.normal);
        println!("穿透深度: {:?}", contact.depth);
    } else {
        println!("没有检测到碰撞");
    }
    
    // 检测距离
    let distance = query::distance(&ball_pos, &ball, &cube_pos, &cube);
    println!("两者之间的距离: {}", distance);
}

物理引擎集成示例

下面是一个更完整的示例，展示如何将parry2d-f64与物理引擎集成：

use parry2d_f64::{
    shape::{Ball, Cuboid},
    math::{Isometry, Vector},
    query::{self, Contact},
    na::Point2,
};

struct PhysicsBody {
    shape: Box<dyn parry2d_f64::shape::Shape>,
    position: Isometry<f64>,
    velocity: Vector<f64>,
    mass: f64,
}

fn main() {
    // 创建物理世界中的两个物体
    let mut bodies = vec![
        PhysicsBody {
            shape: Box::new(Ball::new(1.0)),
            position: Isometry::translation(0.0, 0.0),
            velocity: Vector::new(1.0, 0.0),
            mass: 1.0,
        },
        PhysicsBody {
            shape: Box::new(Cuboid::new(Vector::new(1.0, 1.0))),
            position: Isometry::translation(5.0, 0.0),
            velocity: Vector::new(0.0, 0.0),
            mass: 2.0,
        },
    ];

    // 模拟物理世界
    for _ in 0..100 {
        // 更新位置
        for body in &mut bodies {
            body.position.translation.vector += body.velocity * 0.016; // 16ms时间步长
        }

        // 检测碰撞
        for i in 0..bodies.len() {
            for j in i+1..bodies.len() {
                if let Some(contact) = query::contact(
                    &bodies[i].position, 
                    bodies[i].shape.as_ref(),
                    &bodies[j].position,
                    bodies[j].shape.as_ref(),
                    0.0
                ) {
                    println!("物体 {} 和 {} 发生碰撞", i, j);
                    handle_collision(&mut bodies[i], &mut bodies[j], contact);
                }
            }
        }
    }
}

fn handle_collision(body1: &mut PhysicsBody, body2: &mut PhysicsBody, contact: Contact) {
    // 简化的碰撞响应 - 交换速度
    let temp_vel = body1.velocity;
    body1.velocity = body2.velocity;
    body2.velocity = temp_vel;
}

这个示例展示了如何:

1. 创建基本的物理物体
2. 更新它们的运动
3. 检测碰撞
4. 处理碰撞响应

您可以根据需要扩展这个基础框架，添加更复杂的物理特性如摩擦力、旋转、力矩等。

完整示例DEMO

下面是一个更完整的2D物理引擎示例，包含了碰撞检测、物理模拟和简单的渲染：

use parry2d_f64::{
    math::{Isometry, Vector},
    na::Point2,
    query::{self, Contact},
    shape::{Ball, Cuboid, Shape},
};
use std::f64::consts::PI;

// 物理物体结构体
struct PhysicsBody {
    shape: Box<dyn Shape>,
    position: Isometry<f64>,
    velocity: Vector<f64>,
    angular_velocity: f64,
    mass: f64,
    restitution: f64, // 弹性系数
}

// 物理世界结构体
struct PhysicsWorld {
    bodies: Vec<PhysicsBody>,
    gravity: Vector<f64>,
}

impl PhysicsWorld {
    fn new() -> Self {
        PhysicsWorld {
            bodies: Vec::new(),
            gravity: Vector::new(0.0, -9.81),
        }
    }

    fn add_body(&mut self, body: PhysicsBody) {
        self.bodies.push(body);
    }

    fn step(&mut self, dt: f64) {
        // 应用重力并更新位置
        for body in &mut self.bodies {
            body.velocity += self.gravity * dt;
            body.position.translation.vector += body.velocity * dt;
            body.position.rotation = body.position.rotation
                .rotate(body.angular_velocity * dt);
        }

        // 碰撞检测和响应
        for i in 0..self.bodies.len() {
            for j in i + 1..self.bodies.len() {
                if let Some(contact) = query::contact(
                    &self.bodies[i].position,
                    self.bodies[i].shape.as_ref(),
                    &self.bodies[j].position,
                    self.bodies[j].shape.as_ref(),
                    0.0,
                ) {
                    self.resolve_collision(i, j, contact);
                }
            }
        }
    }

    fn resolve_collision(&mut self, i: usize, j: usize, contact: Contact) {
        // 更真实的碰撞响应
        let body1 = &mut self.bodies[i];
        let body2 = &mut self.bodies[j];

        let relative_velocity = body2.velocity - body1.velocity;
        let velocity_along_normal = relative_velocity.dot(&contact.normal);

        // 如果物体正在分离，不需要处理碰撞
        if velocity_along_normal > 0.0 {
            return;
        }

        // 计算冲量
        let restitution = body1.restitution.min(body2.restitution);
        let mut impulse_magnitude = -(1.0 + restitution) * velocity_along_normal;
        impulse_magnitude /= 1.0 / body1.mass + 1.0 / body2.mass;

        let impulse = contact.normal * impulse_magnitude;

        // 应用冲量
        body1.velocity -= impulse / body1.mass;
        body2.velocity += impulse / body2.mass;

        // 简单的位置修正以避免物体重叠
        let correction = contact.normal * contact.depth * 0.2;
        body1.position.translation.vector -= correction / body1.mass;
        body2.position.translation.vector += correction / body2.mass;
    }
}

fn main() {
    let mut world = PhysicsWorld::new();

    // 添加一个静态地面
    world.add_body(PhysicsBody {
        shape: Box::new(Cuboid::new(Vector::new(10.0, 0.5))),
        position: Isometry::translation(0.0, -5.0),
        velocity: Vector::zeros(),
        angular_velocity: 0.0,
        mass: f64::INFINITY, // 无限质量表示静态物体
        restitution: 0.5,
    });

    // 添加一些动态物体
    for i in 0..5 {
        world.add_body(PhysicsBody {
            shape: if i % 2 == 0 {
                Box::new(Ball::new(0.5))
            } else {
                Box::new(Cuboid::new(Vector::new(0.5, 0.5)))
            },
            position: Isometry::translation(i as f64 * 1.5 - 3.0, 5.0),
            velocity: Vector::new(0.0, 0.0),
            angular_velocity: if i % 2 == 0 { 0.0 } else { PI / 4.0 },
            mass: 1.0,
            restitution: 0.7,
        });
    }

    // 模拟1000步
    for step in 0..1000 {
        world.step(0.016); // 16ms时间步长

        // 每100步打印一次状态
        if step % 100 == 0 {
            println!("Step {}", step);
            for (i, body) in world.bodies.iter().enumerate() {
                println!(
                    "Body {}: position = {:?}, velocity = {:?}",
                    i, body.position.translation.vector, body.velocity
                );
            }
            println!();
        }
    }
}

这个完整示例展示了：

1. 创建物理世界和物体
2. 处理重力、速度和位置更新
3. 更真实的碰撞响应（包含弹性和冲量计算）
4. 支持圆形和矩形两种形状
5. 静态物体和动态物体的区分
6. 简单的模拟状态输出

您可以通过添加更多物理特性来扩展这个示例，如摩擦力、空气阻力、关节约束等。