Rust游戏引擎中Vector内对象互访数据的实现方案咨询

在Rust中，由于严格的借用规则，迭代Vec时无法同时持有整个Vec的不可变引用和单个元素的可变引用。针对游戏引擎中对象需要访问其他对象数据的场景，有以下几种可行方案：

方案1：通过索引遍历而非迭代器 #

放弃使用迭代器，改用索引访问单个元素，这样可以同时持有Vec的不可变引用。这种方式符合Rust的借用规则——每次仅对单个元素进行可变借用，传递给update的是整个Vec的不可变引用，两者不会产生冲突。

修改你的示例代码：

use std::vec::Vec;

struct Object {
    a: u32,
    b: u32,
}

impl Object {
    fn new() -> Self {
        Self {
            a: 0,
            b: 0,
        }
    }
    
    fn update(&mut self, objects: &Vec<Option<Object>>) {
        // 修改自身状态
        self.b += 1;
        // 访问其他对象的数据
        if let Some(other) = objects.get(0).and_then(|o| o.as_ref()) {
            println!("Other object's a: {}", other.a);
        }
    }
}

fn main() {
    let mut vector: Vec<Option<Object>> = Vec::new();
    vector.push(Some(Object::new()));
    vector.push(Some(Object::new()));
    vector.push(Some(Object::new()));

    // 用索引遍历
    for i in 0..vector.len() {
        if let Some(o) = &mut vector[i] {
            o.update(&vector);
        }
    }
}

方案2：使用状态快照（双缓冲） #

如果对象更新不需要依赖其他对象实时更新后的状态，可以先创建所有对象只读数据的快照（比如复制position、rotation等字段），然后基于快照进行更新。这种方式完全规避了借用冲突，是游戏开发中常用的模式（比如物理更新通常基于上一帧状态）。

示例代码：

use std::vec::Vec;

// 抽离只读数据
struct ObjectState {
    a: u32,
}

struct Object {
    state: ObjectState,
    b: u32, // 可变内部状态
}

impl Object {
    fn new() -> Self {
        Self {
            state: ObjectState { a: 0 },
            b: 0,
        }
    }
    
    fn update(&mut self, all_states: &[ObjectState]) {
        // 修改自身可变状态
        self.b += 1;
        // 访问快照中的其他对象数据
        if let Some(other_state) = all_states.get(0) {
            println!("Other object's a: {}", other_state.a);
        }
    }
}

fn main() {
    let mut vector: Vec<Option<Object>> = Vec::new();
    vector.push(Some(Object::new()));
    vector.push(Some(Object::new()));
    vector.push(Some(Object::new()));

    // 生成状态快照
    let state_snapshot: Vec<ObjectState> = vector
        .iter()
        .filter_map(|obj| obj.as_ref().map(|o| o.state.clone()))
        .collect();

    // 基于快照更新对象
    for obj in &mut vector {
        if let Some(o) = obj {
            o.update(&state_snapshot);
        }
    }
}

方案3：使用RefCell实现内部可变性 #

如果必须访问其他对象的实时更新状态，可以用RefCell将对象包裹，绕开编译期借用检查，转而在运行时验证。注意：这种方式可能会引发运行时panic（比如同时获取同一元素的可变和不可变引用），需确保业务逻辑中不会出现冲突借用。

示例代码：

use std::cell::RefCell;
use std::vec::Vec;

struct Object {
    a: u32,
    b: u32,
}

impl Object {
    fn new() -> Self {
        Self {
            a: 0,
            b: 0,
        }
    }
    
    fn update(&mut self, objects: &[RefCell<Option<Object>>]) {
        // 修改自身状态
        self.b += 1;
        // 访问其他对象的实时状态
        if let Some(other_obj) = objects[1].borrow().as_ref() {
            println!("Other object's b (updated): {}", other_obj.b);
        }
    }
}

fn main() {
    let vector: Vec<RefCell<Option<Object>>> = vec![
        RefCell::new(Some(Object::new())),
        RefCell::new(Some(Object::new())),
        RefCell::new(Some(Object::new())),
    ];

    for i in 0..vector.len() {
        let mut obj_ref = vector[i].borrow_mut();
        if let Some(o) = obj_ref.as_mut() {
            o.update(&vector);
        }
    }
}

方案4：采用实体组件系统（ECS）架构（推荐长期方案） #

对于游戏引擎来说，ECS是更适配的架构模式，它将数据（组件）与逻辑（系统）分离，完全避免了手动管理对象引用的问题。常用的Rust ECS库有bevy_ecs、specs等，系统可以通过查询获取所需组件，框架会自动处理内存和借用。

简化示例思路：

// 基于bevy的伪代码
use bevy::prelude::*;

// 定义组件：存储数据
#[derive(Component, Debug)]
struct Position(f32, f32);

#[derive(Component)]
struct Velocity(f32, f32);

// 系统：处理逻辑，查询所需组件
fn move_objects(mut query: Query<(&mut Position, &Velocity)>) {
    for (mut pos, vel) in &mut query {
        pos.0 += vel.0;
        pos.1 += vel.1;
    }
}

fn check_collisions(query: Query<&Position>) {
    for (i, pos) in query.iter().enumerate() {
        // 检查与其他Position的碰撞
        println!("Object {} position: {:?}", i, pos);
    }
}

fn main() {
    App::new()
        .add_systems(Update, (move_objects, check_collisions))
        .run();
}

内容的提问来源于stack exchange，提问作者theflamingtiger