helper module for OpenGL

helper.rs

// Version 0.0.1

use gl;
use gl::types::*;
use std::ffi::CString;

pub fn create_program(
    vertex_shader: &str,
    fragment_shader: &str
) -> Result<GLuint, String> {
    use std::ptr::{null, null_mut};

    unsafe {
        let vertex_shader_id = gl::CreateShader(gl::VERTEX_SHADER);
        let fragment_shader_id = gl::CreateShader(gl::FRAGMENT_SHADER);

        let mut result = 0;
        let mut info_log_length = 0;

        gl::ShaderSource(vertex_shader_id, 1,
            &CString::new(vertex_shader).unwrap().as_ptr(),
            null());
        gl::CompileShader(vertex_shader_id);

        gl::GetShaderiv(vertex_shader_id, gl::COMPILE_STATUS, &mut result);
        gl::GetShaderiv(vertex_shader_id, gl::INFO_LOG_LENGTH,
            &mut info_log_length);
        if info_log_length > 0 {
            let mut vertex_shader_error_message: Vec<u8> =
                vec![0; info_log_length as usize + 1];
            gl::GetShaderInfoLog(vertex_shader_id, info_log_length, null_mut(),
                vertex_shader_error_message.as_mut_ptr() as *mut _);
            let error_message = String::from_utf8(vertex_shader_error_message)
                .unwrap();
            return Err(format!("Compiling vertex shader: {}", error_message));
        }

        gl::ShaderSource(fragment_shader_id, 1,
            &CString::new(fragment_shader).unwrap().as_ptr(),
            null());
        gl::CompileShader(fragment_shader_id);

        gl::GetShaderiv(fragment_shader_id, gl::COMPILE_STATUS, &mut result);
        gl::GetShaderiv(fragment_shader_id, gl::INFO_LOG_LENGTH,
            &mut info_log_length);
        if info_log_length > 0 {
            let mut fragment_shader_error_message: Vec<u8> =
                vec![0; info_log_length as usize + 1];
            gl::GetShaderInfoLog(fragment_shader_id, info_log_length, null_mut(),
                fragment_shader_error_message.as_mut_ptr() as *mut _);
            let error_message = String::from_utf8(fragment_shader_error_message)
                .unwrap();
            return Err(format!("Compiling fragment shader: {}", error_message));
        }

        let program_id = gl::CreateProgram();
        gl::AttachShader(program_id, vertex_shader_id);
        gl::AttachShader(program_id, fragment_shader_id);
        gl::LinkProgram(program_id);

        gl::GetProgramiv(program_id, gl::LINK_STATUS, &mut result);
        gl::GetProgramiv(program_id, gl::INFO_LOG_LENGTH, &mut info_log_length);
        if info_log_length > 0 {
            let mut program_error_message: Vec<u8> =
                vec![0; info_log_length as usize + 1];
            gl::GetProgramInfoLog(program_id, info_log_length, null_mut(),
                program_error_message.as_mut_ptr() as *mut _);
            let error_message = String::from_utf8(program_error_message)
                .unwrap();
            return Err(format!("Linking program: {}", error_message));
        }

        gl::DetachShader(program_id, vertex_shader_id);
        gl::DetachShader(program_id, fragment_shader_id);

        gl::DeleteShader(vertex_shader_id);
        gl::DeleteShader(fragment_shader_id);

        Ok(program_id)
    }
}

pub fn get_uniform_location(program_id: GLuint, name: &str) -> GLint {
    unsafe {
        gl::GetUniformLocation(program_id,
            CString::new(name).unwrap().as_ptr())
    }
}

pub fn get_attrib_location(program_id: GLuint, name: &str) -> GLint {
    unsafe {
        gl::GetAttribLocation(program_id,
            CString::new(name).unwrap().as_ptr())
    }
}

pub fn create_static_buffer<T>(data: &[T]) -> GLuint {
    use std::mem::size_of;

    let mut vertex_buffer: GLuint = 0;
    unsafe {
        gl::GenBuffers(1, &mut vertex_buffer);
        gl::BindBuffer(gl::ARRAY_BUFFER, vertex_buffer);
        gl::BufferData(gl::ARRAY_BUFFER, (size_of::<T>() * data.len()) as isize,
            data.as_ptr() as *const _, gl::STATIC_DRAW);
    }
    vertex_buffer
}

pub fn clear_color(color: [f32; 4], depth: bool) {
    unsafe {
        gl::ClearColor(
            color[0],
            color[1],
            color[2],
            color[3]
        );
        gl::Clear(gl::COLOR_BUFFER_BIT |
            if depth { gl::DEPTH_BUFFER_BIT } else { 0 }
        );
    }
}

pub fn disable_depth() {
    unsafe {
        gl::Disable(gl::DEPTH_TEST);
    }
}

pub fn enable_depth_less() {
    unsafe {
        gl::Enable(gl::DEPTH_TEST);
        gl::DepthFunc(gl::LESS);
    }
}