e2r 0.2.0

experimental rendering engine in 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

use implement::math::mat::Mat3x1;
use implement::math::mat::Mat2x1;
use std::collections::HashMap;
use std::vec::Vec;
use std::any::Any;

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 > >,
    // _xform: Mat4< f32 >,
}

impl Mesh {
    pub fn init( id: u64 ) -> Mesh {
        Mesh {
            _id: id,
            _pos: vec![],
            _normal: vec![],
            _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._pos.len() != self._normal.len() ||
                self._pos.len() != self._tc.len()
            {
                return Err( &"unequal length for position, normal, tc data" )
            }
            let ele_len = self._pos.len();
            let mut pos = vec![];
            let mut normal = vec![];
            let mut tc = vec![];
            for i in 0..self._pos.len() {
                pos.extend_from_slice( &self._pos[i]._val[..] );
            }
            for i in 0..self._normal.len() {
                normal.extend_from_slice( &self._normal[i]._val[..] );
            }
            for i in 0..self._tc.len() {
                tc.extend_from_slice( &self._tc[i]._val[..] );
            }
            let data_map : HashMap< i_renderobj::BuffDataType, Vec<f32> > =  [ ( i_renderobj::BuffDataType::POS, pos ),
                                                                                 ( i_renderobj::BuffDataType::NORMAL, normal ),
                                                                                 ( i_renderobj::BuffDataType::TC, tc ) ].iter().cloned().collect();

            let c = i_component::ComponentRenderBuffer {
                _data_dict: data_map,
            };
            components.push( Box::new(c) );
            println!( "load into render buffer: mesh: vertex count:{}", ele_len / 3 );
        }
        //store uniform data
        {

            
        }
        Ok( () )
    }
}