glw 0.1.2

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

extern crate gl;

use gl::types::*;
use std;

pub struct Mesh {
    _vertex_count: i32,
    index_count: i32,
    ibo: GLuint,
    vao: GLuint,
}

impl Mesh {
    pub fn draw(&self) {
        unsafe{
            gl::BindVertexArray(self.vao);
            gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER,self.ibo);
            gl::DrawElements(gl::TRIANGLES, self.index_count, gl::UNSIGNED_INT, std::ptr::null());
        } 
    }
}

#[derive(Default)]
pub struct MeshBuilder {
    indices: Option<Vec<i32>>,
    vertices: Option<Vec<f32>>,
}

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

    pub fn with_vertex_data(&mut self, vertex_data: &[f32]) -> &mut Self {
        //#TODO: Abstract away OpenGL calls
        self.vertices = Some(vertex_data.to_vec());

        self
    }

    pub fn with_index_data(&mut self, index_data: &[i32]) -> &mut Self {
        self.indices = Some(index_data.to_vec());
        //#TODO: Implement in a type safe way
        self
    }

    // #TODO: Build the mesh using a Vertex Description struct
    pub fn build(&self) -> Mesh {
        // Create indices
        let (mut ibo, mut vao) = (0, 0);
        let (mut vert_count, mut ind_count) = (0,0);
        if let Some(ref data) = self.indices {
            vert_count = data.len();
            unsafe {
                gl::GenBuffers(1, &mut ibo);
                gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, ibo);
                gl::BufferData(
                    gl::ELEMENT_ARRAY_BUFFER,
                    (data.len() * std::mem::size_of::<GLint>()) as GLsizeiptr,
                    &data[0] as *const GLint as *const std::os::raw::c_void,
                    gl::STATIC_DRAW,
                );
                gl::BindBuffer(gl::ELEMENT_ARRAY_BUFFER, 0);
            }
        }

        // Create VAO
        if let Some(ref data) = self.vertices {
            ind_count = data.len();

            vao = 0;
            let mut vbo = 0;
            unsafe {
                gl::GenVertexArrays(1, &mut vao);
                gl::BindVertexArray(vao);

                gl::GenBuffers(1, &mut vbo);


                gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
                gl::BufferData(
                    gl::ARRAY_BUFFER,
                    (data.len() * std::mem::size_of::<GLfloat>()) as GLsizeiptr,
                    &data[0] as *const f32 as *const std::os::raw::c_void,
                    gl::STATIC_DRAW,
                );

                gl::BindVertexArray(vao);
                gl::BindBuffer(gl::ARRAY_BUFFER, vbo);

                let stride = 8 * std::mem::size_of::<GLfloat>() as GLsizei;
                gl::EnableVertexAttribArray(0);
                gl::EnableVertexAttribArray(1);
                gl::EnableVertexAttribArray(2);

                gl::VertexAttribPointer(0, 3, gl::FLOAT, gl::FALSE, stride, std::ptr::null());

                gl::VertexAttribPointer(
                    1,
                    2,
                    gl::FLOAT,
                    gl::FALSE,
                    stride,
                    (3 * std::mem::size_of::<GLfloat>()) as *const std::os::raw::c_void,
                );

                gl::VertexAttribPointer(
                    2,
                    3,
                    gl::FLOAT,
                    gl::FALSE,
                    stride,
                    (5 * std::mem::size_of::<GLfloat>()) as *const std::os::raw::c_void,
                );

                // unbind
                gl::BindBuffer(gl::ARRAY_BUFFER, 0);
                gl::BindVertexArray(0);
            }
        }

        Mesh{
            _vertex_count: vert_count as i32,
            index_count: ind_count as i32,
            ibo,
            vao,
        }
    }
}