shambler 0.2.0

A rusty, hulking, lighting-tossing geometry processor.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

use std::collections::BTreeMap;

use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
use usage::Usage;

use super::{BrushHulls, BrushId};
use crate::face::{FaceId, FaceVertices};

pub enum BrushFaceContainmentTag {}

pub type BrushFaceContainment = Usage<BrushFaceContainmentTag, BTreeMap<BrushId, Vec<FaceId>>>;

// Find contained faces
pub fn brush_face_containment(
    brushes: &Vec<BrushId>,
    faces: &Vec<FaceId>,
    brush_faces: &BTreeMap<BrushId, Vec<FaceId>>,
    brush_hulls: &BrushHulls,
    face_vertices: &FaceVertices,
) -> BrushFaceContainment {
    brushes
        .par_iter()
        .map(|brush_id| {
            let brush_faces = &brush_faces[brush_id];
            let brush_hull = &brush_hulls[brush_id];

            (
                *brush_id,
                faces
                    .par_iter()
                    .flat_map(|face_id| {
                        // Skip checking own vertices
                        if brush_faces.contains(face_id) {
                            return None;
                        }

                        let face_verts = &face_vertices[&face_id];

                        let contained = face_verts
                            .par_iter()
                            .all(|vertex| brush_hull.contains(vertex));

                        if !contained {
                            return None;
                        }

                        Some(*face_id)
                    })
                    .collect::<Vec<_>>(),
            )
        })
        .collect()
}