Struct TriangularMesh

Source

pub struct TriangularMesh<V: Vertex, I: Index> {
    pub vertices: Vec<V>,
    pub indices: Vec<I>,
}

Expand description

A triangular mesh.

Fields§

§vertices: Vec<V>

The vertex list.

§indices: Vec

The index list.

Implementations§

Source §

impl<V: Vertex, I: Index> TriangularMesh<V, I>

Source

pub fn empty() -> Self

Creates an empty triangular mesh.

Source

pub fn triangles(&self) -> Triangles<'_, V, I> ⓘ

Gets all of the triangles in a mesh.

Examples found in repository ?

examples/wavefront-lighthouse.rs (line 26)

21fn print_information(name: &str, model: &Model) {
22    println!("{}", name);
23    println!("-----------------------------");
24    println!("vertices: {}", model.mesh.vertices.len());
25    println!("indices: {}", model.mesh.indices.len());
26    println!("triangles: {}", model.mesh.triangles().count());
27    println!("");
28}

More examples

Hide additional examples

examples/wavefront-texturing.rs (line 38)

15fn main() {
16    let wavefront = mash::load::wavefront::from_path("res/world.obj").unwrap();
17
18    // Collect all doors from the model.
19    let doors: Vec<_> = wavefront.objects().filter_map(|obj| {
20        if obj.name().contains("door") {
21            let ambient_color = {
22                let material = obj.material().expect("object has no material");
23                material.ambient_color()
24            };
25
26            Some(Door {
27                ambient_color: ambient_color,
28                name: obj.name().to_owned(),
29                model: Model::new(obj).unwrap(),
30            })
31        } else {
32            None
33        }
34    }).collect();
35
36    for door in doors {
37        println!("found door named '{}' with ambient color {:?} and {} triangles",
38                 door.name, door.ambient_color, door.model.mesh.triangles().count());
39    }
40}

examples/wavefront-world.rs (line 28)

9fn main() {
10    // Load the shape into a wavefront-specific data structure.
11    let world = load::wavefront::from_path("res/world.obj").unwrap();
12
13    // Rather than converting the entire world into a single model, let's extract
14    // every object labelled 'door'.
15    let doors: Vec<Model> = world.objects().filter(|o| o.name().contains("door")).map(|object| {
16        // Convert each object into its own mesh.
17        Model::new(object).unwrap()
18    }).collect();
19
20    for door in doors {
21        println!("door model: {:?}", door);
22    }
23
24    // We can also load the entire world into a single model if we wanted.
25    let entire_world = Model::new(world).unwrap();
26
27    // Skip every second triangle if that's your kind of thing.
28    let half_triangles = entire_world.mesh.triangles().enumerate().filter(|&(idx,_)| idx%2 == 0).map(|(_,t)| t);
29    let half_world: Model = Model { mesh: half_triangles.collect() };
30
31    println!("half world: {:?}", half_world);
32}