e2r 0.10.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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::collections::HashMap;
use std::string::String;


use implement::render::router;

pub struct TextureCollection {
    _textures: HashMap< u64, ( router::ShaderType, i64 ) >,
    _id_to_descrip: HashMap< u64, String >,
    _descrip_to_id: HashMap< String, u64 >,
    _id_generator: u64,
}


impl Default for TextureCollection {
    fn default() -> TextureCollection {
        TextureCollection {
            _textures: HashMap::new(),
            _id_to_descrip: HashMap::new(),
            _descrip_to_id: HashMap::new(),
            _id_generator: 0u64,
        }
    }
}

impl Drop for TextureCollection {
    fn drop( & mut self ) {
        self._textures.clear();
    }
}

impl TextureCollection {
    pub fn add( & mut self, shader_type: router::ShaderType, internal_handle: i64, descrip: String ) -> Result< (u64), & 'static str > {
        let mut handle = self._id_generator;
        while self._textures.contains_key( &handle ) {
            handle = handle + 1;
        }
        match self._textures.insert( handle, ( shader_type, internal_handle ) ) {
            None => (),
            Some( ( _shader_type, _old_handle ) ) => {
                return Err( &"adding texture handle failed")
            }
        }
        self._id_generator = handle;
        self._id_to_descrip.insert( handle, descrip.clone() );
        self._descrip_to_id.insert( descrip, handle );
        Ok( handle )
    }
    pub fn put( & mut self, id: u64, shader_type: router::ShaderType, internal_handle: i64, descrip: String ) -> Result< (), & 'static str > {
        match self._textures.insert( id, ( shader_type, internal_handle ) ) {
            None => (),
            Some( ( shader_type, old_handle ) ) => {
                router::delete_texture( old_handle, shader_type )?;
                trace!( "removed old texture( {} ).", old_handle );
            }
        }
        self._id_to_descrip.insert( id, descrip.clone() );
        self._descrip_to_id.insert( descrip, id );
        Ok( () )
    }
    pub fn clear( & mut self ) -> Result< (), & 'static str > {
        for ( &_k, &( ref shader_type, ref handle ) ) in self._textures.iter() {
            router::delete_texture( *handle, (*shader_type).clone() )?
        }
        self._id_to_descrip.clear();
        self._descrip_to_id.clear();
        Ok( () )
    }
    pub fn remove( & mut self, id: u64 ) -> Result< (), & 'static str > {
        match self._textures.remove( &id ) {
            Some( ( shader_type, handle ) ) => {
                router::delete_texture( handle, shader_type )?;
                if let Some( descrip ) = self._id_to_descrip.remove( &id ) {
                    self._descrip_to_id.remove( &descrip );
                }
            },
            None => (),
        }
        Ok( () )
    }
    pub fn get( & mut self, id: u64 ) -> Option< i64 > {
        match self._textures.get( &id ) {
            Some( &( ref _shader_type, ref handle ) ) => {
                return Some( *handle )
            },
            None => return None
        }
    }
}