milk
/
Dairy-Drift
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

we are SO back, found the issue

Milk.H 2023-03-09 13:46:53 +01:00
parent 219fc7f57f
commit 10a03e47a4
No known key found for this signature in database
GPG Key ID: 3D9DAE46AAC37BD8
3 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main.rs
View File

@ -27,8 +27,8 @@ fn main() {
glfw.window_hint(glfw::WindowHint::OpenGlProfile(glfw::OpenGlProfileHint::Core));
glfw.window_hint(glfw::WindowHint::OpenGlForwardCompat(true));
glfw.window_hint(glfw::WindowHint::Resizable(false));
glfw.window_hint(glfw::WindowHint::TransparentFramebuffer(true));
glfw.window_hint(glfw::WindowHint::Decorated(false));
glfw.window_hint(glfw::WindowHint::TransparentFramebuffer(false));
glfw.window_hint(glfw::WindowHint::Decorated(true));
let (mut window, events) = glfw.create_window(SCR_WIDTH, SCR_HEIGHT, TITLE, glfw::WindowMode::Windowed).unwrap();

1
src/model.rs
View File

@ -32,6 +32,7 @@ impl Model {
pub fn Draw(&self, shader: &shader) {
for mesh in &self.meshes {
unsafe { mesh.Draw(shader); }
}
}

63
src/model/mesh.rs
View File

@ -53,11 +53,11 @@ pub struct Mesh {
pub vertices: Vec<Vertex>,
pub indices: Vec<u32>,
pub textures: Vec<Texture>,
pub VAO: glow::VertexArray,
pub VAO: Option<glow::VertexArray>,
/* Render data */
VBO: glow::Buffer,
EBO: glow::Buffer,
VBO: Option<glow::Buffer>,
EBO: Option<glow::Buffer>,
}
impl Mesh {
@ -66,11 +66,10 @@ impl Mesh {
let mut mesh =
{
unsafe {
let mut mesh = Mesh {
Mesh {
vertices, indices, textures,
VAO: gl.create_vertex_array().unwrap(), VBO: gl.create_buffer().unwrap(), EBO: gl.create_buffer().unwrap()
};
mesh
VAO: None, VBO: None, EBO: None
}
}
};
// now that we have all the required data, set the vertex buffers and its attribute pointers.
@ -109,65 +108,65 @@ impl Mesh {
_ => panic!("unknown texture type")
};
// now set the sampler to the correct texture unit
let sampler = String::from(format!("{}{}", name, number));
let sampler = format!("{}{}", name, number);
shader.setInt(&sampler, i as i32);
//shader.gl.uniform_1_i32(shader.gl.get_uniform_location(shader.ID, &sampler).as_ref(), i as i32);
// and finally bind the texture
shader.gl.bind_texture(glow::TEXTURE_2D, Some(texture.id));
}
// draw mesh
shader.gl.bind_vertex_array(Some(self.VAO));
shader.gl.bind_vertex_array(self.VAO);
shader.gl.draw_elements(glow::TRIANGLES, self.indices.len() as i32, glow::UNSIGNED_INT, 0);
shader.gl.bind_vertex_array(None);
// always good practice to set everything back to defaults once configured.
shader.gl.active_texture(glow::TEXTURE0);
}
unsafe fn setupMesh(&mut self, gl: std::rc::Rc<glow::Context>) {
self.VAO = Some(gl.create_vertex_array().unwrap());
self.VBO = Some(gl.create_buffer().unwrap());
self.EBO = Some(gl.create_buffer().unwrap());
gl.bind_vertex_array(self.VAO);
// create buffers/arrays
gl.bind_vertex_array(Some(self.VAO));
// load data into vertex buffers
gl.bind_buffer(glow::ARRAY_BUFFER, Some(self.VBO));
// A great thing about structs with repr(C) is that their memory layout is sequential for all its items.
// The effect is that we can simply pass a pointer to the struct and it translates perfectly to a glm::vec3/2 array which
// again translates to 3/2 floats which translates to a byte array.
//let size = (self.vertices.len() * size_of::<Vertex>()) as isize;
//let data = &self.vertices[0] as *const Vertex as *const c_void;
let data: &[u8] = core::slice::from_raw_parts(
gl.bind_buffer(glow::ARRAY_BUFFER, self.VBO);
println!("vertices.len is: {}", self.vertices.len());
let data = core::slice::from_raw_parts(
self.vertices.as_ptr() as *const u8,
self.vertices.len() * core::mem::size_of::<f32>(),
self.vertices.len() * core::mem::size_of::<Vector3<f32>>() * 3,
);
gl.named_buffer_data_u8_slice(self.VBO.unwrap(), data, glow::STATIC_DRAW);
gl.buffer_data_u8_slice(glow::ARRAY_BUFFER, data, glow::STATIC_DRAW);
gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(self.EBO));
let data: &[u8] = core::slice::from_raw_parts(
gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, self.EBO);
let data = core::slice::from_raw_parts(
self.indices.as_ptr() as *const u8,
self.indices.len() * core::mem::size_of::<f32>(),
self.indices.len() * core::mem::size_of::<u32>(),
);
gl.buffer_data_u8_slice(glow::ELEMENT_ARRAY_BUFFER, data, glow::STATIC_DRAW);
gl.named_buffer_data_u8_slice(self.EBO.unwrap(), data, glow::STATIC_DRAW);
// set the vertex attribute pointers
let size = size_of::<Vertex>() as i32;
// vertex Positions
gl.enable_vertex_attrib_array(0);
gl.vertex_attrib_pointer_f32(0, 3, glow::FLOAT, false, size, offset_of!(Vertex => Position).get_byte_offset() as i32);
gl.vertex_attrib_pointer_f32(0, 3, glow::FLOAT, false, size, 0);
// vertex normals
gl.enable_vertex_attrib_array(1);
gl.vertex_attrib_pointer_f32(1, 3, glow::FLOAT, false, size, offset_of!(Vertex => Normal).get_byte_offset() as i32);
gl.vertex_attrib_pointer_f32(1, 3, glow::FLOAT, false, size, 3*4);
// vertex texture coords
gl.enable_vertex_attrib_array(2);
gl.vertex_attrib_pointer_f32(2, 2, glow::FLOAT, false, size, offset_of!(Vertex => TexCoords).get_byte_offset() as i32);
gl.vertex_attrib_pointer_f32(2, 2, glow::FLOAT, false, size, 6*4);
// vertex tangent
gl.enable_vertex_attrib_array(3);
gl.vertex_attrib_pointer_f32(3, 3, glow::FLOAT, false, size, offset_of!(Vertex => Tangent).get_byte_offset() as i32);
gl.vertex_attrib_pointer_f32(3, 3, glow::FLOAT, false, size, 8*4);
// vertex bitangent
gl.enable_vertex_attrib_array(4);
gl.vertex_attrib_pointer_f32(4, 3, glow::FLOAT, false, size, offset_of!(Vertex => Bitangent).get_byte_offset() as i32);
gl.vertex_attrib_pointer_f32(4, 3, glow::FLOAT, false, size, 11*4);
gl.bind_vertex_array(None);
}