rogalik_common 0.3.0

Common definitions for the Rogalik 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
124
125
126
127
128
129
130
131

#[cfg(feature = "serialize")]
use serde::{Deserialize, Serialize};

use rogalik_math::vectors::Vector2f;

#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
pub struct ResourceId(pub usize);
impl ResourceId {
    pub fn next(&self) -> Self {
        Self(self.0 + 1)
    }
}

#[derive(Debug)]
pub enum EngineError {
    InvalidResource,
    ResourceNotFound,
    GraphicsInternalError,
    GraphicsNotReady,
}

#[derive(Clone, Copy, Debug)]
#[cfg_attr(feature = "serialize", derive(Serialize, Deserialize))]
pub struct Color(pub u8, pub u8, pub u8, pub u8);
impl Color {
    pub fn as_f32(&self) -> [f32; 4] {
        [
            self.0 as f32 / 255.,
            self.1 as f32 / 255.,
            self.2 as f32 / 255.,
            self.3 as f32 / 255.,
        ]
    }
    pub fn as_srgb(&self) -> [f32; 4] {
        let f = self.as_f32();
        [
            srgb_single(f[0]),
            srgb_single(f[1]),
            srgb_single(f[2]),
            f[3],
        ]
    }
}
impl Default for Color {
    fn default() -> Self {
        Self(255, 255, 255, 255)
    }
}

#[derive(Clone, Copy, Default)]
pub struct SpriteParams {
    pub color: Color,
    pub flip_x: bool,
    pub flip_y: bool,
    pub rotate: Option<f32>,
    // slice size in px, base sprite size
    pub slice: Option<(usize, Vector2f)>,
}

#[inline(always)]
fn srgb_single(v: f32) -> f32 {
    ((v + 0.055) / 1.055).powf(2.4)
}

#[derive(Clone, Copy, Default)]
pub struct MaterialParams {
    pub atlas: Option<AtlasParams>,
    pub diffuse_texture: Option<ResourceId>,
    pub normal_texture: Option<ResourceId>,
    pub shader: Option<ResourceId>,
    pub repeat: TextureRepeat,
    pub filtering: TextureFiltering,
}

#[derive(Clone, Copy, Default)]
pub struct PostProcessParams {
    pub texture: Option<ResourceId>,
    pub shader: ResourceId,
    pub repeat: TextureRepeat,
    pub filtering: TextureFiltering,
}

#[derive(Clone, Copy, Debug)]
pub struct AtlasParams {
    pub cols: usize,
    pub rows: usize,
    pub padding: Option<(f32, f32)>,
}

#[derive(Clone, Copy, Default)]
pub enum TextureRepeat {
    #[default]
    Clamp,
    Repeat,
    MirrorRepeat,
}

#[derive(Clone, Copy, Default)]
pub enum TextureFiltering {
    #[default]
    Nearest,
    Linear,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum ShaderKind {
    Sprite,
    PostProcess,
}

#[derive(Hash, Eq, PartialEq, Debug)]
pub enum BuiltInShader {
    SpriteUnlit,
    SpriteLit,
    Upscale,
    Lut,
}

#[derive(Clone, Copy)]
pub struct AudioDeviceParams {
    pub sample_rate: usize,
    pub buffer_secs: f32,
}
impl Default for AudioDeviceParams {
    fn default() -> Self {
        Self {
            sample_rate: 44100,
            buffer_secs: 0.1,
        }
    }
}