Fullerene 0.1.6

Fullerene on the ODE (Open Dynamics Engine) for Rust
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! dodecahedron.rs
//!
//! Dodecahedron
//! vertices 20
//! 5 x 12 faces
//! edges 30
//!

use num::Float;

use crate::{PHF, TUV, center_indexed, divide_int};
use crate::icosahedron::Icosahedron;

/// Dodecahedron
#[derive(Debug)]
pub struct Dodecahedron<F: Float> {
  /// vtx
  pub vtx: Vec<[F; 3]>,
  /// edges (duplex)
  pub edges: Vec<(u8, [u8; 3])>,
  /// tri: Vec 12 of Vec 3 indexed triangles
  pub tri: Vec<Vec<[u8; 3]>>
}

/// impl trait TUV for Dodecahedron
impl<F: Float> TUV<F> for Dodecahedron<F> {
  /// get uv from the one texture (f v i: vertex id of expanded polyhedron)
  fn get_uv_t(&self, _f: usize, _v: usize, _i: usize,
    _r: f64, _s: f64, o: [f64; 2]) -> [F; 2] { // rot scale offset
    [<F>::from(o[0] + 0.0).unwrap(), <F>::from(o[1] + 0.0).unwrap()]
  }
  /// ref vtx
  fn ref_vtx(&self) -> &Vec<[F; 3]> { &self.vtx }
  /// ref tri
  fn ref_tri(&self) -> &Vec<Vec<[u8; 3]>> { &self.tri }
  /// with_uv
  fn with_uv(&self, tf: bool) -> PHF<F> { self.phf(tf, false) }
}

/// Dodecahedron
impl<F: Float> Dodecahedron<F> {
  /// construct
  pub fn new(r: F) -> Self {
    let icosa = Icosahedron::<F>::new(r);
    let vtx: Vec<_> = icosa.tri.iter().map(|t|
      center_indexed(&t[0], &icosa.vtx)).collect(); // 0-19
    let edges = vec![];
    let tri = vec![
  vec![[0, 4, 3], [0, 3, 2], [0, 2, 1]], // 0 [0, [4, 3, 2, 1]]
  vec![[4, 0, 7], [4, 7, 6], [4, 6, 5]], // 4 [4, [0, 7, 6, 5]]
  vec![[0, 1, 9], [0, 9, 8], [0, 8, 7]], // 8 [0, [1, 9, 8, 7]]
  vec![[1, 2, 11], [1, 11, 10], [1, 10, 9]], // 9 [1, [2, 11, 10, 9]]
  vec![[2, 3, 13], [2, 13, 12], [2, 12, 11]], // 7 [2, [3, 13, 12, 11]]
  vec![[3, 4, 5], [3, 5, 14], [3, 14, 13]], // 1 [3, [4, 5, 14, 13]]
  vec![[15, 14, 5], [15, 5, 6], [15, 6, 16]], // 11 [15, [14, 5, 6, 16]]
  vec![[16, 6, 7], [16, 7, 8], [16, 8, 17]], // 5 [16, [6, 7, 8, 17]]
  vec![[17, 8, 9], [17, 9, 10], [17, 10, 18]], // 3 [17, [8, 9, 10, 18]]
  vec![[18, 10, 11], [18, 11, 12], [18, 12, 19]], // 6 [18, [10, 11, 12, 19]]
  vec![[19, 12, 13], [19, 13, 14], [19, 14, 15]], // 10 [19, [12, 13, 14, 15]]
  vec![[19, 15, 16], [19, 16, 17], [19, 17, 18]] // 2 [19, [15, 16, 17, 18]]
    ];
    Dodecahedron{vtx, edges, tri}
  }
}

/// Dodecahedron with center
#[derive(Debug)]
pub struct DodecahedronCenter<F: Float> {
  /// vtx
  pub vtx: Vec<[F; 3]>,
  /// edges (duplex)
  pub edges: Vec<(u8, [u8; 3])>,
  /// tri: Vec 12 of Vec 5 indexed triangles
  pub tri: Vec<Vec<[u8; 3]>>
}

/// impl trait TUV for DodecahedronCenter
impl<F: Float> TUV<F> for DodecahedronCenter<F> {
  /// get uv from the one texture (f v i: vertex id of expanded polyhedron)
  fn get_uv_t(&self, _f: usize, _v: usize, _i: usize,
    _r: f64, _s: f64, o: [f64; 2]) -> [F; 2] { // rot scale offset
    [<F>::from(o[0] + 0.0).unwrap(), <F>::from(o[1] + 0.0).unwrap()]
  }
  /// ref vtx
  fn ref_vtx(&self) -> &Vec<[F; 3]> { &self.vtx }
  /// ref tri
  fn ref_tri(&self) -> &Vec<Vec<[u8; 3]>> { &self.tri }
  /// with_uv
  fn with_uv(&self, tf: bool) -> PHF<F> { self.phf(tf, true) }
}

/// Dodecahedron with center
impl<F: Float> DodecahedronCenter<F> {
  /// construct
  pub fn new(r: F) -> Self {
    let icosa = Icosahedron::<F>::new(r);
    let iv = &icosa.vtx;
/*
    let mut vtx: Vec<_> = icosa.edges.iter().map(|&(e, is)|
      divide_int(&iv[e as usize], &center_indexed(&is, &iv), 2, 1)).collect();
    let dodeca = Dodecahedron::<F>::new();
    vtx.extend(dodeca.vtx.iter().map(|&p| p));
*/
    let dodeca = Dodecahedron::<F>::new(r);
    let mut vtx: Vec<_> = dodeca.vtx.iter().map(|&p| p).collect(); // 0-19
    vtx.extend(icosa.edges.iter().map(|&(e, is)|
      divide_int(&iv[e as usize], &center_indexed(&is, &iv), 2, 1))); // 20-31
    let edges = vec![];
    let tri: Vec<_> = (20..32).into_iter().map(|q: u8| {
      let mut t = Vec::with_capacity(5); // vec![[0u8; 3]; 5];
      let o = q as usize - 20;
      t.push([q, dodeca.tri[o][0][0], dodeca.tri[o][0][1]]);
      let _: Vec<_> = (0..3).into_iter().map(|p| {
        t.push([q, dodeca.tri[o][p][1], dodeca.tri[o][p][2]]);
      }).collect();
      t.push([q, dodeca.tri[o][2][2], dodeca.tri[o][2][0]]);
      t
    }).collect();
/*
    let tri: Vec<_> = (20..32).into_iter().flat_map(|q: u8| {
      let mut t = Vec::with_capacity(5); // vec![[0u8; 3]; 5];
      let o = (q as usize - 20) * 3;
      t.push([q, dodeca.tri[o][0], dodeca.tri[o][1]]);
      let _: Vec<_> = (0..3).into_iter().map(|p| {
        t.push([q, dodeca.tri[o + p][1], dodeca.tri[o + p][2]]);
      }).collect();
      t.push([q, dodeca.tri[o + 2][2], dodeca.tri[o + 2][0]]);
      t
    }).collect();
*/
    // println!("{:?}", tri);
    DodecahedronCenter{vtx, edges, tri}
  }
}