d7engine 1.1.5

A game engine in rust with SDL2 and opengl.
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use crate::core::shader::object::TextureCoordinate;
use crate::core::resource::image::Image;
use crate::core::file;

/*
this struct holds the information that is 
in a tilemap file

this data can be used for instanced texture components
to draw different tiles out of a single texture
*/
#[derive(Clone)]
pub struct TileData {
    pub name: String,
    x1: f32,
    y1: f32,
    x2: f32,
    y2: f32,
}

// helps with code readability 
// of the TileData texcorrd method
#[derive(Clone)]
pub enum TileDataRotation {
    Bottom,
    Left,
    Top,
    Right,
}

impl TileData {
    /*
    create the texture coordinates 
    from the data in the tiles
    Standard TileDataRotation is bottom (no rotation)
    */
    pub fn texcoord(&self, tile_data_rotation: &TileDataRotation) -> TextureCoordinate {
        match tile_data_rotation {
            TileDataRotation::Bottom => {
                [
                    self.x1, self.y2,       
                    self.x1, self.y1,       
                    self.x2, self.y1,    
                    self.x2, self.y2,       
                ]
            },
            TileDataRotation::Left => {
                [
                    self.x2, self.y2,  
                    self.x1, self.y2,       
                    self.x1, self.y1,       
                    self.x2, self.y1,    
                ]
            },
            TileDataRotation::Top => {
                [
                    self.x2, self.y1,    
                    self.x2, self.y2,  
                    self.x1, self.y2,       
                    self.x1, self.y1,       
                ]
            },
            TileDataRotation::Right => {
                [
                    self.x1, self.y1,       
                    self.x2, self.y1,    
                    self.x2, self.y2,  
                    self.x1, self.y2,       
                ]
            }
        }
    }
}

pub struct TileMap {
    tiles: Vec<TileData>,
    image: Image,
    pub dim: usize,
}

impl TileMap {
    /*
    create a tilemap struct 
    using the path to the file
    and the dimension of a tile in the texture e.g. 32, 64 etc.

    out data is constructed from the top left
    but texture coordinates are from bottom left
    */
    pub fn new(path: &str, image: Image, dim: usize) -> Result<Self, String> {
        let file = file::read(path)?;
        let image_dim = (image.width, image.height);

        let mut tiles = vec![];
      
        for line in file.lines() {
            // read each line and parse the values
            match Self::parse_line(&line) {
                Ok((name, x, y)) => {
                    // create the values between 0.0 and 1.0
                    let x = x as f32;
                    let y = y as f32;
                    let dim = dim as f32;
                    let width = image_dim.0;
                    let height = image_dim.1;

                    let x1 = x / width;            
                    let y1 = 1.0 - (y / height);          
                    let x2 = (x + dim) / width;                   
                    let y2 = 1.0 - ((y + dim) / height);
                    
                    let tile_data = TileData {
                        name, x1, y1, x2, y2
                    };
                    tiles.push(tile_data);
                },
                Err(_) => return Err(format!("Could not parse line '{}'", line)),
            }
        }

        let tilemap = TileMap{tiles, image, dim};
        Ok(tilemap)
    }

    // get a copy of the image
    pub fn image(&self) -> Image {
        self.image.clone()
    }

    // get all the tiledata as a vector
    pub fn as_vec(&self) -> Vec<TileData> {
        self.tiles.clone()
    }

    // get the tiledata of a certain item
    pub fn get(&self, name: &str) -> Result<TileData, String> {
        for item in &self.tiles {
            if item.name == name {
                return Ok(item.clone());
            }
        }

        Err(format!("Could not get item '{}'.", name))
    }

    // returns the values from a line of the tilemap file
    fn parse_line(line: &str) -> Result<(String, usize, usize), std::num::ParseIntError> {
        let parts: Vec<&str> = line.split(',').collect();
        let name = parts[0].to_string();
        let x = parts[1].parse::<usize>()?;
        let y = parts[2].parse::<usize>()?;
        Ok((name, x, y))
    }
}