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
extern crate pretty_env_logger;
extern crate mazth;
// use self::mazth::mat::{ Mat3x1, Mat2x1 };
use std::collections::HashMap;
use std::vec::Vec;
use std::any::Any;
use std::mem;
use interface::i_ele;
use interface::i_renderobj;
use interface::i_component;
#[derive(Clone)]
pub struct Mesh {
pub _id: u64,
// pub _pos: Vec< Mat3x1< f32 > >,
// pub _normal: Vec< Mat3x1< f32 > >,
// pub _tc: Vec< Mat2x1< f32 > >,
pub _batch_pos: Vec< f32 >,
pub _batch_normal: Vec< f32 >,
pub _batch_tc: Vec< f32 >,
// _xform: Mat4< f32 >,
}
impl Mesh {
pub fn init( id: u64 ) -> Mesh {
Mesh {
_id: id,
// _pos: vec![],
// _normal: vec![],
// _tc: vec![],
_batch_pos: vec![],
_batch_normal: vec![],
_batch_tc: vec![],
}
}
}
impl i_ele::IObjImpl for Mesh {
fn as_any( & self ) -> & Any {
self
}
fn update_components( & mut self, components: & mut Vec< Box< i_component::IComponent > > ) -> Result< (), & 'static str > {
//store vertex data
{
if self._batch_pos.len() != self._batch_normal.len() ||
self._batch_pos.len() / 3 != self._batch_tc.len() / 2
{
return Err( &"inconsistent length for position, normal, tc data" )
}
let ele_len = self._batch_pos.len();
// let pos = {
// self._pos.iter()
// .flat_map(|x| x._val[..].to_vec() )
// .collect::<Vec<_>>()
// };
// let normal = {
// self._normal.iter()
// .flat_map(|x| x.normalize().unwrap()._val[..].to_vec() )
// .collect::<Vec<_>>()
// };
// let tc = {
// self._tc.iter()
// .flat_map(|x| x._val[..].to_vec() )
// .collect::<Vec<_>>()
// };
// let pos = {
// let mut temp = vec![];
// temp.reserve_exact( 3 * self._pos.len() );
// self._pos.iter_mut().for_each( |x| temp.append( & mut x._val.to_vec() ) );
// temp
// };
// let normal = {
// let mut temp = vec![];
// temp.reserve_exact( 3 * self._normal.len() );
// self._normal.iter_mut().for_each( |x| temp.append( & mut x.normalize().unwrap()._val.to_vec() ) );
// temp
// };
// let tc = {
// let mut temp = vec![];
// temp.reserve_exact( 2 * self._tc.len() );
// self._tc.iter_mut().for_each( |x| temp.append( & mut x._val.to_vec() ) );
// temp
// };
let mut pos = vec![];
let mut normal = vec![];
let mut tc = vec![];
mem::swap( & mut pos, & mut self._batch_pos );
mem::swap( & mut normal, & mut self._batch_normal );
mem::swap( & mut tc, & mut self._batch_tc );
let data_map : HashMap< i_renderobj::BuffDataType, Vec<f32> > = [ ( i_renderobj::BuffDataType::POS, pos ),
( i_renderobj::BuffDataType::NORMAL, normal ),
( i_renderobj::BuffDataType::TC, tc ) ].into_iter().cloned().collect();
let c = i_component::ComponentRenderBuffer {
_data_dict: data_map,
};
components.push( Box::new(c) );
trace!( "load into render buffer: mesh: vertex count:{}", ele_len / 3 );
}
//todo: store uniform data
{
}
Ok( () )
}
}