2 files changed, 31 insertions(+), 26 deletions(-)

M crates/client/src/rendering/mod.rs
M crates/client/src/shaders/fragment.glsl

@@ 11,13 11,19 @@ pub struct App {
     program: glow::Program,
     vertex_array: glow::VertexArray,
     vertex_buffer: glow::Buffer,
+    element_buffer: glow::Buffer,
     gl: Option<glow::Context>,
 }
 
-const VERTICES: [f32; 6] = [
-    0.0, 1.0,
+const VERTICES: [f32; 8] = [
     -1.0, -1.0,
     1.0, -1.0,
+    1.0, 1.0,
+    -1.0, 1.0,
+];
+const INDICES: [u32; 6] = [
+    0, 1, 2,
+    2, 3, 0,
 ];
 
 impl ApplicationHandler for App {


@@ 50,39 56,37 @@ impl ApplicationHandler for App {
         }
         let (gl, shader_version) = (glow::Context::from_webgl2_context(context), "#version 300 es");
         unsafe {
-            let vertex_shader = gl.create_shader(glow::VERTEX_SHADER).expect("Failed to create vertex shader");
-            let fragment_shader = gl.create_shader(glow::FRAGMENT_SHADER).expect("Failed to create fragment shader");
-
-            let vertex_source = include_str!("../shaders/vertex.glsl");
-            let fragment_source = include_str!("../shaders/fragment.glsl");
+            let shaders = [
+                ("vertex", include_str!("../shaders/vertex.glsl"), glow::VERTEX_SHADER),
+                ("fragment", include_str!("../shaders/fragment.glsl"), glow::FRAGMENT_SHADER),
+            ];
+            let program = gl.create_program().expect("Failed to create program");
 
-            gl.shader_source(vertex_shader, &format!("{}\n{}", shader_version, vertex_source));
-            gl.compile_shader(vertex_shader);
-            if !gl.get_shader_compile_status(vertex_shader) {
-                tracing::error!("error in vertex shader: {}", gl.get_shader_info_log(vertex_shader));
-            }
-            gl.shader_source(fragment_shader, &format!("{}\n{}", shader_version, fragment_source));
-            gl.compile_shader(fragment_shader);
-            if !gl.get_shader_compile_status(fragment_shader) {
-                tracing::error!("error in fragment shader: {}", gl.get_shader_info_log(fragment_shader));
+            for (name, source, shader_type) in shaders {
+                let shader = gl.create_shader(shader_type).expect("Failed to create vertex shader");
+                gl.shader_source(shader, &format!("{}\n{}", shader_version, source));
+                gl.compile_shader(shader);
+                if !gl.get_shader_compile_status(shader) {
+                    tracing::error!("error in {} shader: {}", name, gl.get_shader_info_log(shader));
+                }
+                gl.attach_shader(program, shader);
+                gl.delete_shader(shader);
             }
-
-            let program = gl.create_program().expect("Failed to create program");
-            gl.attach_shader(program, vertex_shader);
-            gl.attach_shader(program, fragment_shader);
             gl.link_program(program);
 
-            gl.delete_shader(vertex_shader);
-            gl.delete_shader(fragment_shader);
-
             gl.use_program(Some(program));
 
             let vertex_array = gl.create_vertex_array().expect("Failed to create vertex array");
             gl.bind_vertex_array(Some(vertex_array));
             let vertex_buffer = gl.create_buffer().expect("Failed to create vertex buffer");
             gl.bind_buffer(glow::ARRAY_BUFFER, Some(vertex_buffer));
+            let element_buffer = gl.create_buffer().expect("Failed to create element buffer");
+            gl.bind_buffer(glow::ELEMENT_ARRAY_BUFFER, Some(element_buffer));
             gl.buffer_data_u8_slice(glow::ARRAY_BUFFER,
-                std::slice::from_raw_parts(VERTICES.as_ptr() as *const u8, 6*4),
+                std::slice::from_raw_parts(VERTICES.as_ptr() as *const u8, 8*4),
+                glow::STATIC_DRAW);
+            gl.buffer_data_u8_slice(glow::ELEMENT_ARRAY_BUFFER,
+                std::slice::from_raw_parts(INDICES.as_ptr() as *const u8, 6*4),
                 glow::STATIC_DRAW);
 
             gl.vertex_attrib_pointer_f32(0, 2, glow::FLOAT, false, 2*std::mem::size_of::<f32>() as i32, 0);


@@ 94,6 98,7 @@ impl ApplicationHandler for App {
             self.program = program;
             self.vertex_array = vertex_array;
             self.vertex_buffer = vertex_buffer;
+            self.element_buffer = element_buffer;
         }
         #[cfg(target_arch = "wasm32")]
         web_sys::window().unwrap().set_onresize(Some(Closure::<dyn Fn(Event)>::new(move |_| {


@@ 124,7 129,7 @@ impl ApplicationHandler for App {
 
                 unsafe {
                     gl.clear(glow::COLOR_BUFFER_BIT);
-                    gl.draw_arrays(glow::TRIANGLES, 0, 3);
+                    gl.draw_elements(glow::TRIANGLES, 6, glow::UNSIGNED_INT, 0);
                 }
 
                 window.request_redraw();

@@ 5,5 5,5 @@ in vec2 v_pos;
 out vec4 color;
 
 void main() {
-    color = vec4(v_pos+1.0f, 0.0f, 1.0f);
+    color = vec4((v_pos+1.0f)/2.0f, 0.5f, 1.0f);
 }