openglrustglfw
GLFW-RS only shows black square instead of rotating cubes
I am trying to reformat C++ code I created from learnopengl.com with Rust bindings and it isn't quite working as expected. I am only getting a black square when I should be getting 10 rotating textured cubes.
Here's an image of my output window whenever I run the application.
Could somebody help me figure out what's going wrong? I can't understand it and it's driving me up the walls.
The code is quite lengthy so here is link to the repository if that makes it easier to read. Github GLFW Repo
main.rs
extern crate gl;
extern crate glfw;
extern crate glm;
extern crate image;
mod shader;
// use glfw::ffi;
use gl::types::*;
use glfw::{Action, Context, Key};
use glm::*;
use std::ffi::c_void;
use std::mem::size_of;
use shader::shader::Shader;
fn main() {
let mut glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();
glfw.window_hint(glfw::WindowHint::ContextVersion(4, 3));
glfw.window_hint(glfw::WindowHint::OpenGlForwardCompat(true));
glfw.window_hint(glfw::WindowHint::OpenGlProfile(
glfw::OpenGlProfileHint::Core,
));
let (mut window, events) = glfw
.create_window(800, 600, "Hello this is window", glfw::WindowMode::Windowed)
.expect("Failed to create GLFW window.");
window.set_title("OpenGL Custom App");
window.set_key_polling(true);
window.make_current();
window.set_framebuffer_size_polling(true);
load_gl_functions(&mut window);
// ffi::glfwSetWindowSizeCallback(*window, cbfun: Option<GLFWwindowsizefun>);
// First three verticies, last two texture
let _vertices: [f32; 180] = [
-0.5, -0.5, -0.5, 0.0, 0.0, 0.5, -0.5, -0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5,
-0.5, 1.0, 1.0, -0.5, 0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 0.0, -0.5, -0.5, 0.5,
0.0, 0.0, 0.5, -0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 1.0, -0.5,
0.5, 0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, 0.5, 0.5, 1.0, 0.0, -0.5, 0.5, -0.5,
1.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, -0.5, 0.5, 0.0,
0.0, -0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5,
-0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, 0.5, 0.0, 0.0, 0.5, 0.5, 0.5,
1.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, 0.5, -0.5, -0.5, 1.0, 1.0, 0.5, -0.5, 0.5, 1.0, 0.0,
0.5, -0.5, 0.5, 1.0, 0.0, -0.5, -0.5, 0.5, 0.0, 0.0, -0.5, -0.5, -0.5, 0.0, 1.0, -0.5, 0.5,
-0.5, 0.0, 1.0, 0.5, 0.5, -0.5, 1.0, 1.0, 0.5, 0.5, 0.5, 1.0, 0.0, 0.5, 0.5, 0.5, 1.0, 0.0,
-0.5, 0.5, 0.5, 0.0, 0.0, -0.5, 0.5, -0.5, 0.0, 1.0,
];
let cube_positions: [Vec3; 10] = [
glm::vec3(0.0, 0.0, 0.0),
glm::vec3(2.0, 5.0, -15.0),
glm::vec3(-1.5, -2.2, -2.5),
glm::vec3(-3.8, -2.0, -12.3),
glm::vec3(2.4, -0.4, -3.5),
glm::vec3(-1.7, 3.0, -7.5),
glm::vec3(1.3, -2.0, -2.5),
glm::vec3(1.5, 2.0, -2.5),
glm::vec3(1.5, 0.2, -1.5),
glm::vec3(-1.3, 1.0, -1.5),
];
let mut vbo: GLuint = 0;
let mut vao: GLuint = 0;
let mut texture1: u32 = 0;
let mut texture2: u32 = 0;
let shader = Shader::create_shader(
"src/shaders/vertShader.vert",
"src/shaders/fragShader.frag",
&mut window,
)
.expect("There was an error creating the program.");
unsafe {
gl::Enable(gl::DEPTH_TEST);
// Vertices pointer
gl::GenBuffers(1, &mut vbo);
gl::GenVertexArrays(1, &mut vao);
gl::BindVertexArray(vao);
gl::BindBuffer(gl::ARRAY_BUFFER, vbo);
gl::BufferData(
gl::ARRAY_BUFFER,
size_of::<[f32; 180]>() as isize,
_vertices.as_ptr() as *const c_void,
gl::STATIC_DRAW,
);
// Vertext pointer
gl::VertexAttribPointer(
0,
3,
gl::FLOAT,
gl::FALSE,
5 * size_of::<f32>() as i32,
0 as *const c_void,
);
gl::EnableVertexAttribArray(0);
// Texture pointer
gl::VertexAttribPointer(
1,
2,
gl::FLOAT,
gl::FALSE,
5 * size_of::<f32>() as i32,
(3 * size_of::<f32>()) as *const c_void,
);
gl::EnableVertexAttribArray(1);
// Bind textures
gl::GenTextures(1, &mut texture1 as *mut u32);
gl::ActiveTexture(gl::TEXTURE0);
gl::BindTexture(gl::TEXTURE_2D, texture1);
gl::TexParameteri(
gl::TEXTURE_2D,
gl::TEXTURE_WRAP_S,
gl::MIRRORED_REPEAT as i32,
);
gl::TexParameteri(
gl::TEXTURE_2D,
gl::TEXTURE_WRAP_R,
gl::MIRRORED_REPEAT as i32,
);
gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as i32);
gl::TexParameteri(
gl::TEXTURE_2D,
gl::TEXTURE_MIN_FILTER,
gl::LINEAR_MIPMAP_LINEAR as i32,
);
let tex1 = image::open("E:\\Repos\\Rust\\RSOpenGL\\src\\textures\\wall.jpg")
.expect("Failed to load image.")
.into_rgb();
gl::TexImage2D(
gl::TEXTURE_2D,
0,
gl::RGB as i32,
tex1.width() as i32,
tex1.height() as i32,
0,
gl::RGB,
gl::UNSIGNED_BYTE,
tex1.as_ptr() as *const c_void,
);
gl::GenerateMipmap(gl::TEXTURE_2D);
// Texture 2
gl::GenTextures(1, &mut texture2 as *mut u32);
gl::ActiveTexture(gl::TEXTURE1);
gl::BindTexture(gl::TEXTURE_2D, texture2);
gl::TexParameteri(
gl::TEXTURE_2D,
gl::TEXTURE_WRAP_S,
gl::MIRRORED_REPEAT as i32,
);
gl::TexParameteri(
gl::TEXTURE_2D,
gl::TEXTURE_WRAP_R,
gl::MIRRORED_REPEAT as i32,
);
gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as i32);
gl::TexParameteri(
gl::TEXTURE_2D,
gl::TEXTURE_MIN_FILTER,
gl::LINEAR_MIPMAP_LINEAR as i32,
);
let tex2 = image::open("E:\\Repos\\Rust\\RSOpenGL\\src\\textures\\awesomeface.png")
.expect("Failed to load image.")
.into_rgb();
gl::TexImage2D(
gl::TEXTURE_2D,
0,
gl::RGB as i32,
tex2.width() as i32,
tex2.height() as i32,
0,
gl::RGB,
gl::UNSIGNED_BYTE,
tex2.as_ptr() as *const c_void,
);
gl::GenerateMipmap(gl::TEXTURE_2D);
gl::ClearColor(0.2, 0.3, 0.3, 1.0);
shader.use_shader();
shader.set_int32("texture1", 0);
shader.set_int32("texture2", 1);
}
let mut last_frame = glfw.get_time();
while window.should_close() == false {
let curr_frame: f64 = glfw.get_time();
let delta_time: f64 = curr_frame - last_frame;
println!("{}", delta_time);
last_frame = curr_frame;
// process input
unsafe {
gl::Clear(gl::COLOR_BUFFER_BIT | gl::DEPTH_BUFFER_BIT);
gl::ActiveTexture(gl::TEXTURE0);
gl::BindTexture(gl::TEXTURE_2D, texture1);
gl::ActiveTexture(gl::TEXTURE1);
gl::BindTexture(gl::TEXTURE_2D, texture2);
let projection: glm::Mat4 = glm::ext::perspective::<f32>(
glm::radians(90.0),
800 as f32 / 600 as f32,
0.1,
100.0,
);
shader.set_mat4("projection", projection);
let view: glm::Mat4 = glm::ext::look_at::<f32>(
glm::vec3(0.0, 0.0, 3.0),
glm::vec3(0.0, 0.0, 3.0) + glm::vec3(0.0, 0.0, -1.0),
glm::vec3(0.0, 1.0, 0.0),
);
shader.set_mat4("view", view);
// println!("{:?}\n{:?}", view, projection);
shader.use_shader();
gl::BindVertexArray(vao);
let mut i: f32 = 0.0;
for cube in cube_positions.iter() {
let mut model: glm::Mat4 = glm::mat4(
1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0,
);
model = glm::ext::translate(&model, *cube);
let angle: f32 = 20.0 + i;
i += 1.0;
model = glm::ext::rotate(
&model,
glm::radians(angle) * glfw.get_time() as f32,
glm::vec3(1.0, 0.3, 0.5),
);
shader.set_mat4("model", model);
// println!("{:?}", model);
gl::DrawArrays(gl::TRIANGLES, 0, 36);
}
}
glfw.poll_events();
for (_, event) in glfw::flush_messages(&events) {
handle_window_event(&mut window, event);
}
window.swap_buffers();
}
unsafe {
gl::DeleteVertexArrays(1, &vao);
gl::DeleteBuffers(1, &vbo);
// glfw::ffi::glfwTerminate(); apparently not necessary
}
}
fn handle_window_event(window: &mut glfw::Window, event: glfw::WindowEvent) {
match event {
glfw::WindowEvent::Key(Key::Escape, _, Action::Press, _) => window.set_should_close(true),
_ => {}
}
}
fn load_gl_functions(window: &mut glfw::Window) {
gl::ClearColor::load_with(|_s| window.get_proc_address("glClearColor"));
gl::Clear::load_with(|_s| window.get_proc_address("glClear"));
gl::GenBuffers::load_with(|_s| window.get_proc_address("glGenBuffers"));
gl::GenVertexArrays::load_with(|_s| window.get_proc_address("glGenVertexArrays"));
gl::BindBuffer::load_with(|_s| window.get_proc_address("glBindBuffer"));
gl::BufferData::load_with(|_s| window.get_proc_address("glBufferData"));
gl::VertexAttribPointer::load_with(|_s| window.get_proc_address("glVertexAttribPointer"));
gl::EnableVertexAttribArray::load_with(|_s| {
window.get_proc_address("glEnableVertexAttribArray")
});
gl::BindVertexArray::load_with(|_s| window.get_proc_address("glBindVertexArray"));
gl::DeleteVertexArrays::load_with(|_s| window.get_proc_address("glDeleteVertexArrays"));
gl::DeleteBuffers::load_with(|_s| window.get_proc_address("glDeleteBuffers"));
gl::GenTextures::load_with(|_s| window.get_proc_address("glGenTextures"));
gl::TexParameteri::load_with(|_s| window.get_proc_address("glTexParameteri"));
gl::TexImage2D::load_with(|_s| window.get_proc_address("glTexImage2D"));
gl::BindTexture::load_with(|_s| window.get_proc_address("glBindTexture"));
gl::ActiveTexture::load_with(|_s| window.get_proc_address("glActiveTexture"));
gl::GenerateMipmap::load_with(|_s| window.get_proc_address("glGenerateMipmap"));
gl::Enable::load_with(|_s| window.get_proc_address("glEnable"));
gl::DrawArrays::load_with(|_s| window.get_proc_address("glDrawArrays"));
}
shader.rs
extern crate gl;
extern crate glfw;
extern crate glm;
pub mod shader {
pub struct Shader {
pub id: u32,
}
impl Shader {
pub fn create_shader(vert_file_path: &str, frag_file_path: &str, window: &mut glfw::Window) -> std::result::Result<Shader, std::io::Error> {
if gl::CreateProgram::is_loaded() == false {
let result = Shader::load_gl_procs(window);
if result == false {
return Err(std::io::Error::new(
std::io::ErrorKind::Other,
"ERROR::SHADER::CANNOT_LOAD_PROGRAMS",
));
}
}
let vert_text = std::fs::read_to_string(vert_file_path).expect("Unable to read vert file");
let vert_text_ptr = vert_text.as_ptr() as *const *const gl::types::GLchar;
let frag_text = std::fs::read_to_string(frag_file_path).expect("Unable to read frag file");
let frag_text_ptr = frag_text.as_ptr() as *const *const gl::types::GLchar;
//println!("{:?} \n{:?}", vert_text_ptr, frag_text_ptr);
let id: gl::types::GLuint;
unsafe {
let vert_shader = gl::CreateShader(gl::VERTEX_SHADER);
gl::ShaderSource(vert_shader, 1, vert_text_ptr, &0);
gl::CompileShader(vert_shader);
/* STATUS_ACCESS_VIOLATION error
let mut success: i32;
let mut info_log: [gl::types::GLchar; 512] = [0; 512];
gl::GetShaderiv(vert_shader, gl::COMPILE_STATUS, success as *mut i32);
println!("{:?}", success);
if success == 0 {
gl::GetShaderInfoLog(vert_shader, 512, 0 as *mut gl::types::GLsizei, &mut info_log[0]);
for i in info_log.iter() {
print!("{}", i);
}
} */
let frag_shader = gl::CreateShader(gl::FRAGMENT_SHADER);
gl::ShaderSource(frag_shader, 1, frag_text_ptr, &0);
gl::CompileShader(frag_shader);
id = gl::CreateProgram();
gl::AttachShader(id, vert_shader);
gl::AttachShader(id, frag_shader);
gl::LinkProgram(id);
gl::DeleteShader(vert_shader);
gl::DeleteShader(frag_shader);
}
let created_shader: Shader = Shader { id: id };
return Ok(created_shader);
}
pub fn load_gl_procs(window: &mut glfw::Window) -> bool {
gl::CreateShader::load_with(|_s| window.get_proc_address("glCreateShader"));
gl::ShaderSource::load_with(|_s| window.get_proc_address("glShaderSource"));
gl::CompileShader::load_with(|_s| window.get_proc_address("glCompileShader"));
gl::GetShaderiv::load_with(|_s| window.get_proc_address("glGetShaderiv"));
gl::CreateProgram::load_with(|_s| window.get_proc_address("glCreateProgram"));
gl::AttachShader::load_with(|_s| window.get_proc_address("glAttachShader"));
gl::LinkProgram::load_with(|_s| window.get_proc_address("glLinkProgram"));
gl::GetProgramiv::load_with(|_s| window.get_proc_address("glGetProgramiv"));
gl::GetShaderInfoLog::load_with(|_s| window.get_proc_address("glGetShaderInfoLog"));
gl::GetProgramInfoLog::load_with(|_s| window.get_proc_address("glGetProgramInfoLog"));
gl::DeleteShader::load_with(|_s| window.get_proc_address("glDeleteShader"));
gl::UseProgram::load_with(|_s| window.get_proc_address("glUseProgram"));
gl::Uniform1i::load_with(|_s| window.get_proc_address("glUniform1i"));
gl::Uniform1f::load_with(|_s| window.get_proc_address("glUniform1f"));
gl::UniformMatrix4fv::load_with(|_s| window.get_proc_address("glUniformMatrix4fv"));
gl::GetUniformLocation::load_with(|_s| window.get_proc_address("glGetUniformLocation"));
// TODO Check to see if all of these are loaded
return true;
}
pub unsafe fn use_shader(&self) {
gl::UseProgram(self.id as gl::types::GLuint);
}
pub unsafe fn set_bool(&self, name: &str, value: bool) {
gl::Uniform1i(gl::GetUniformLocation(self.id, name.as_ptr() as *const gl::types::GLchar), value as gl::types::GLint);
}
pub unsafe fn set_int32(&self, name: &str, value: i32) {
gl::Uniform1i(gl::GetUniformLocation(self.id, name.as_ptr() as *const gl::types::GLchar), value as gl::types::GLint);
}
pub unsafe fn set_float32(&self, name: &str, value: f32) {
gl::Uniform1f(gl::GetUniformLocation(self.id, name.as_ptr() as *const gl::types::GLchar), value as gl::types::GLfloat);
}
pub unsafe fn set_mat4(&self, name: &str, value: glm::Mat4) {
gl::UniformMatrix4fv(gl::GetUniformLocation(self.id, name.as_ptr() as *const gl::types::GLchar), 1, gl::FALSE, &value[0][0]);
}
}
}
vertShader.vert
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoord;
out vec2 TexCoord;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
void main()
{
gl_Position = projection * view * model * vec4(aPos, 1.0);
TexCoord = aTexCoord;
}
fragShader.frag
#version 330 core
out vec4 FragColor;
in vec2 TexCoord;
uniform sampler2D texture1;
uniform sampler2D texture2;
void main()
{
// FragColor = vec4(ourColor, 1.0f);
FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.5);
}
Solution
There were actually two main problems with my program, both regarding CStrings.
Problem 1: OpenGL couldn't create the program because the text I sent it did not have a null termination character, so it had to be recasted as a CString with one.
let v_shader_code = CString::new(vert_text.as_bytes()).unwrap();
let f_shader_code = CString::new(frag_text.as_bytes()).unwrap();
Problem 2: The "set_*()" functions wouldn't work because the name was being passed as an &str without a null termination character. This also has to be cast into a c string.
pub unsafe fn set_bool(&self, name: &str, value: bool) {
gl::Uniform1i(gl::GetUniformLocation(self.id, CString::new(name).expect("Error converting &str to CString").as_c_str().as_ptr()), value as i32);
}
- float is overflowing in openGL despite being under 32 bits
- how can I create OpenGL context using Windows memory dc (c++)
- How to Practically Ship GLSL Shaders with your C++ Software
- How do you do 3D rendering in Gtk+ using OpenGL?
- glGetProgramResourceIndex returning wrong indices
- SDL2 AntiAliasing
- Problem with specular lightning artifacts in OpenGL
- In OpenGL, Drawing a spinning globe using glDrawElements has weird artifacts Seems like an edge bug? How can I debug it?
- What does the term "genType" mean in OpenGL/GLSL?
- Minimal Go OpenGL Program Segmentation Fault
- Why transform normals with the transpose of the inverse of the modelview matrix?
- How do I draw an OBJ file in OpenGL using tinyobjloader?
- Can anyone suggest a good papers or articles on the architecture of graphics drivers?
- Calling an IO Monad inside an Arrow
- Valgrind: libnvidia-glcore.so.346.47 Conditional jump or move depends on uninitialised value
- Drawing Quads in OpenGL from .obj File
- Render .obj Files with OpenGl
- Drawing a model from obj file
- GLAD initialization on multiple dlls that use GLAD
- OpenGL alpha blending
- OpenGL flip or mirror the drawing object
- Context sharing between 2 windows in SFML
- Drawing OBJ file with openGL
- Cube using single GL_TRIANGLE_STRIP
- How to access automatic mipmap level in GLSL fragment shader texture?
- How to use GLUT/OpenGL to render to a file?
- Issues with the color comand in OpenGL
- Why GLSL shader program can't link correctly?
- OpenGL not rendering on macOS Mojave
- Can I create and use an OpenGL object without generating its name?