nightshade 0.13.1

A cross-platform data-oriented game engine.
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

use nalgebra_glm::Vec2;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct TileData {
    pub tile_id: u32,
    pub flip_x: bool,
    pub flip_y: bool,
}

impl TileData {
    pub fn new(tile_id: u32) -> Self {
        Self {
            tile_id,
            flip_x: false,
            flip_y: false,
        }
    }

    pub fn with_flip_x(mut self, flip_x: bool) -> Self {
        self.flip_x = flip_x;
        self
    }

    pub fn with_flip_y(mut self, flip_y: bool) -> Self {
        self.flip_y = flip_y;
        self
    }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct Tilemap {
    pub position: Vec2,
    pub tile_size: Vec2,
    pub grid_width: u32,
    pub grid_height: u32,
    pub tiles: Vec<Option<TileData>>,
    pub texture_index: u32,
    pub sheet_columns: u32,
    pub sheet_rows: u32,
    pub depth: f32,
    pub color: [f32; 4],
    pub uv_max: Vec2,
}

impl Default for Tilemap {
    fn default() -> Self {
        Self {
            position: Vec2::new(0.0, 0.0),
            tile_size: Vec2::new(16.0, 16.0),
            grid_width: 0,
            grid_height: 0,
            tiles: Vec::new(),
            texture_index: 0,
            sheet_columns: 1,
            sheet_rows: 1,
            depth: 0.0,
            color: [1.0, 1.0, 1.0, 1.0],
            uv_max: Vec2::new(1.0, 1.0),
        }
    }
}

impl Tilemap {
    pub fn new(position: Vec2, tile_size: Vec2, grid_width: u32, grid_height: u32) -> Self {
        let tile_count = (grid_width * grid_height) as usize;
        Self {
            position,
            tile_size,
            grid_width,
            grid_height,
            tiles: vec![None; tile_count],
            ..Default::default()
        }
    }

    pub fn with_texture(mut self, texture_index: u32) -> Self {
        self.texture_index = texture_index;
        self
    }

    pub fn with_sheet_layout(mut self, columns: u32, rows: u32) -> Self {
        self.sheet_columns = columns;
        self.sheet_rows = rows;
        self
    }

    pub fn with_depth(mut self, depth: f32) -> Self {
        self.depth = depth;
        self
    }

    pub fn with_color(mut self, color: [f32; 4]) -> Self {
        self.color = color;
        self
    }

    pub fn with_uv_max(mut self, uv_max: Vec2) -> Self {
        self.uv_max = uv_max;
        self
    }

    pub fn set_tile(&mut self, col: u32, row: u32, tile_data: Option<TileData>) {
        if col < self.grid_width && row < self.grid_height {
            let index = (row * self.grid_width + col) as usize;
            self.tiles[index] = tile_data;
        }
    }

    pub fn get_tile(&self, col: u32, row: u32) -> Option<&TileData> {
        if col < self.grid_width && row < self.grid_height {
            let index = (row * self.grid_width + col) as usize;
            self.tiles[index].as_ref()
        } else {
            None
        }
    }

    pub fn fill(&mut self, tile_data: TileData) {
        for tile in &mut self.tiles {
            *tile = Some(tile_data.clone());
        }
    }
}