glw 0.1.4

openGL Wrapper (glw) is a small collection of constructs to wrap around unsafe opengl calls. This is very much a work in progress and I do not advise anyone to use this in a production environment.
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

use super::*;

use std::ffi::CString;
use std::rc::Rc;

#[derive(Default)]
pub struct GraphicsPipeline {
    // Open GL program ID
    id: GLuint,
}

impl Drop for GraphicsPipeline {
    fn drop(&mut self) {
        unsafe {
            gl::DeleteProgram(self.id);
        }
    }
}

impl GraphicsPipeline {
    pub fn get_id(&self) -> GLuint {
        return self.id;
    }

    fn new() -> GraphicsPipeline {
        unsafe {
            GraphicsPipeline {
                id: gl::CreateProgram()
            }
        }
    }


    pub fn set_uniform(&self, uniform_name: &str, uni: Uniform) {
        unsafe {
            let c_string : CString = CString::new(uniform_name).unwrap();
            let loc = gl::GetUniformLocation(self.id, c_string.as_ptr() as *const GLchar);
            match loc {
                -1 => {}
                _ => match uni {
                    Uniform::Float(v) => gl::Uniform1f(loc, v),
                    Uniform::Int(v) => gl::Uniform1i(loc, v),
                    Uniform::Vec2(x,y) => {
                        gl::Uniform2f(loc, x, y);
                    },
                    Uniform::Sampler2D(v) => {
                        self.set_sampler(v);

                        gl::Uniform1i(loc, v as i32);
                    }
                }
            }
        }
    }
    pub fn bind_storage_buffer(&self, buffer: GLuint, binding: GLuint){
        unsafe{
            gl::BindBufferBase(gl::SHADER_STORAGE_BUFFER,binding, buffer);
        }
    }


    fn attach(&mut self, shader : &Shader)
    {
        unsafe {
            gl::AttachShader(self.id, shader.get_id());
        }
    }

    fn link(&mut self){
        unsafe{
            gl::LinkProgram(self.id);
        }
    }

    fn set_sampler(&self, sampler : GLuint){
        unsafe {
            // Bind our input texture
            gl::ActiveTexture(gl::TEXTURE0 + sampler);
            gl::BindTexture(gl::TEXTURE_2D, sampler);
        }
    }

}

#[derive(Default)]
pub struct PipelineBuilder{
    vshader: Option<Rc<Shader>>,
    fshader: Option<Rc<Shader>>,
    cshader: Option<Rc<Shader>>,
}

impl PipelineBuilder {
    pub fn new() -> PipelineBuilder{
        PipelineBuilder::default()
    }

    pub fn with_vertex_shader(&mut self, shader: Shader) -> &mut Self {
        self.vshader = Some(Rc::new(shader));

        self
    }

    pub fn with_fragment_shader(&mut self, shader: Shader) -> &mut Self {
        self.fshader = Some(Rc::new(shader));

        self
    }

    pub fn with_compute_shader(&mut self, shader: Shader) -> &mut Self {
        self.cshader = Some(Rc::new(shader));

        self
    }

    pub fn build(&self) -> GraphicsPipeline
    {
        let mut result = GraphicsPipeline::new();

        if let Some(ref shader) = self.vshader {
            result.attach(&shader);
        }

        if let Some(ref shader) = self.cshader {
            result.attach(&shader);
        }

        if let Some(ref shader) = self.fshader {
            result.attach(&shader);
        }
        

        result.link();

        result
    }

}