Question

我正在尝试在我的Rust射线追踪器中实现BVH算法，但是我在生存期和所有权上遇到了麻烦。我有一个特征Hittable，它可以实现许多不同的功能-Sphere，Triangle，Mesh等。因此，我有一个Vec<Box<dyn Hittable>>，我想变成这个结构的树：

pub struct BvhNode {
    bounding_box: BoundingBox,
    left: Box<dyn Hittable>,
    right: Box<dyn Hittable>,
}

因此，即使不是针对生命周期问题，我也有一种几乎有效的递归算法。我的功能看起来像

    pub fn new(objects: Vec<Box<dyn Hittable>>, start: usize, end: usize, t0: f64, t1: f64) -> Self {
        let r = util::rand();
        let comp = if r < 1. / 3. {
            util::box_x_compare
        } else if r < 2. / 3. {
            util::box_y_compare
        } else {
            util::box_z_compare
        }; // which axis to compare along (random for now)
        let num_obj = end - start;
        let mut left: Box<dyn Hittable>;
        let mut right: Box<dyn Hittable>;
        if num_obj == 1 {
            left = objects[start];
            right = objects[start];
        } else if num_obj == 2 {
            if comp(&&objects[start], &&objects[start + 1]) != Ordering::Greater {
                left = objects[start];
                right = objects[start + 1];
            } else {
                left = objects[start + 1];
                right = objects[start];
            }
        } else {
            let mut slice: Vec<&Box<dyn Hittable>> = Vec::new();
            for i in start..end { // make a copy to sort
                slice.push(&objects[i]);
            }
            slice.sort_by(comp);
            let mid = start + num_obj / 2;
            let l = BvhNode::new(objects, start, mid, t0, t1);
            let r = BvhNode::new(objects, mid, end, t0, t1);
            left = Box::new(l.clone());
            right = Box::new(r.clone());
        }

        let left_box = left.get_bounding_box(t0, t1);
        let right_box = right.get_bounding_box(t0, t1);
        
        if left_box.is_none() || right_box.is_none() {
            println!("Error: No bounding box in Bvh Node");
            panic!();
        }

        Self { left, right, bounding_box: BoundingBox::new(Point3::origin(), Point3::origin()) }
    }

首先，我遇到了一些尝试“移出vec”的问题，而这是我做不到的，因此我尝试在实现Clone的所有类型上实现Hittable 。它几乎适用于所有人，但我的Triangle结构

pub struct Triangle <'b> {
    mat: &'b Box<dyn Material>,
    bounding_box: Option<BoundingBox>,
    p: Vec<Point3<f64>>,
    n: Vec<Vector3<f64>>,
    uv: Vec<Vector2<f64>>,
}

包含对其关联的网格的材质的引用，而克隆不喜欢这种材质。我可以克隆材质本身，但是它可能很大，我不想为网格中的每个三角形都拥有数千个副本。

我觉得必须有一种更好的方法来设计系统，例如摆脱Triangle中的引用，以便可以轻松地对其进行复制。创建此结构后，我将不再需要Vec，因此能够在复制它们的过程中将move的对象移出它也可以，但是我看不到一种方法可以做到这一点。

如果有帮助，则完整文件位于GitHub here

Answer 1

通过将objects Vec更改为&mut Vec<Box<dyn Hittable>>，然后使用objects.remove()而不是对其进行索引，可以解决此问题。我必须稍微更改算法以处理新方法，但是它应该可以工作。

如何将特征对象的Vec转换为树结构？

1 个答案: