tea_render 0.1.1

A lib for easier use of OpenGL functions
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

#[derive(Default, Debug, PartialEq, Eq, Copy, Clone)]
pub enum PixelFormat {
    Alpha,
    Luminance,
    LuminanceAlpha,
    RGB,
    #[default]
    RGBA,
}

impl GlEnum for PixelFormat {
    fn to_enum(&self) -> u32 {
        match self {
            PixelFormat::Alpha => { return gl::ALPHA },
            PixelFormat::Luminance => { return gl::LUMINANCE },
            PixelFormat::LuminanceAlpha => { return gl::LUMINANCE_ALPHA },
            PixelFormat::RGB => { return gl::RGB },
            PixelFormat::RGBA => { return gl::RGBA }
        }
    }
}

#[derive(Default, Debug, PartialEq, Eq, Copy, Clone)]
pub enum TexTarget {
    Texture2D,
    CubeMapPositiveX,
    CubeMapNegativeX,
    CubeMapPositiveY,
    CubeMapNegativeY,
    CubeMapPositiveZ,
    CubeMapNegativeZ,

    Count
}

impl GlEnum for TexTarget {
    fn to_enum(&self) -> u32 {
        match self {
            Self::Texture2D => { gl::TEXTURE_2D },
            Self::CubeMapPositiveX => { gl::TEXTURE_CUBE_MAP_POSITIVE_X },
            Self::CubeMapNegativeX => { gl::TEXTURE_CUBE_MAP_NEGATIVE_X },
            Self::CubeMapPositiveY => { gl::TEXTURE_CUBE_MAP_POSITIVE_Y },
            Self::CubeMapNegativeY => { gl::TEXTURE_CUBE_MAP_NEGATIVE_Y },
            Self::CubeMapPositiveZ => { gl::TEXTURE_CUBE_MAP_POSITIVE_Z },
            Self::CubeMapNegativeZ => { gl::TEXTURE_CUBE_MAP_NEGATIVE_Z },
        }
    }
}

impl TexTarget {
    pub fn get_binding(&self) -> u32 {
        match self {
            Self::Texture2D => { gl::TEXTURE_BINDING_2D },
            _ => { gl::NONE }
        }
    }
}

#[derive(Default, Debug, PartialEq, Eq, Copy, Clone)]
pub enum TexFilter {
    #[default]
    Nearest,
    Linear,
    // only for min filter
    NearestMipmapNearest,
    LinearMipmapNearest,
    NearestMipmapLinear,
    LinearMipmapLinear
}

impl GlEnum for TexFilter {
    fn to_enum(&self) -> u32 {
        match self {
            Self::Nearest => { gl::NEAREST },
            Self::Linear => { gl::LINEAR },
            Self::NearestMipmapNearest => { gl::NEAREST_MIPMAP_NEAREST },
            Self::LinearMipmapNearest => { gl::LINEAR_MIPMAP_NEAREST },
            Self::NearestMipmapLinear => { gl::NEAREST_MIPMAP_LINEAR },
            Self::LinearMipmapLinear => { gl::LINEAR_MIPMAP_LINEAR },
        }
    }
}

#[derive(Default, Debug, PartialEq, Eq, Copy, Clone)]
pub enum TexWrap {
    #[default]
    Repeat,
    MirroredRepeat,
    ClampToEdge,
}

impl GlEnum for TexWrap {
    fn to_enum(&self) -> u32 {
        match self {
            Self::Repeat => { gl::REPEAT },
            Self::MirroredRepeat => { gl::MIRRORED_REPEAT }
            Self::ClampToEdge => { gl::CLAMP_TO_EDGE },
        }
    }
}


#[derive(Default, Debug, PartialEq, Eq, Copy, Clone)]
pub enum TexParam {
    MinFilter(TexFilter),
    MagFilter(TexFilter),
    WrapS(TexWrap),
    WrapT(TexWrap)
}

impl GlEnum for TexParam {
    fn to_enum(&self) -> u32 {
        match self {
            Self::MinFilter(_) => { gl::TEXTURE_MIN_FILTER },
            Self::MagFilter(_) => { gl::TEXTURE_MAG_FILTER },
            Self::WrapS(_) => { gl::TEXTURE_WRAP_S },
            Self::WrapT(_) => { gl::TEXTURE_WRAP_T },
        }
    }
}