Fix WebGl -> WebGl2 bug

3 files changed, 126 insertions, 9 deletions

diff --git a/WebInterface/wasm/asm-paint/Cargo.toml b/WebInterface/wasm/asm-paint/Cargo.toml
index e2b1e17..748bb8e 100644
--- a/WebInterface/wasm/asm-paint/Cargo.toml
+++ b/WebInterface/wasm/asm-paint/Cargo.toml
@@ -14,6 +14,7 @@ crate-type = ["cdylib"]
 wasm-bindgen = "0.2"
 log = "0.4"
 fern = "0.5"
+js-sys = "0.3"
 
 [dependencies.web-sys]
 version = "0.3"
@@ -21,9 +22,6 @@ features = [
     'Document',
     'Element',
     'HtmlCanvasElement',
-    'WebGlBuffer',
-    'WebGlRenderingContext',
-    'WebGlProgram',
-    'WebGlShader',
+    'WebGl2RenderingContext',
     'Window'
 ]
diff --git a/WebInterface/wasm/asm-paint/src/canvas.rs b/WebInterface/wasm/asm-paint/src/canvas.rs
index a1ef415..1956be0 100644
--- a/WebInterface/wasm/asm-paint/src/canvas.rs
+++ b/WebInterface/wasm/asm-paint/src/canvas.rs
@@ -1,10 +1,10 @@
 use web_sys;
-use web_sys::{WebGlProgram, WebGlRenderingContext, WebGlShader};
+use web_sys::{WebGl2RenderingContext};
 use wasm_bindgen::JsCast;
 
 pub struct Canvas {
     element: web_sys::HtmlCanvasElement,
-    ctx: WebGlRenderingContext,
+    ctx: WebGl2RenderingContext,
 }
 
 impl Canvas {
@@ -13,15 +13,15 @@ impl Canvas {
             element.dyn_into::<web_sys::HtmlCanvasElement>()
             .ok()?;
         debug!("create webgl2 context");
-        error!("'{:#?}'", element.get_context("webgl2").ok()??.dyn_into::<WebGlRenderingContext>());
         let ctx = element.get_context("webgl2").ok()??
-            .dyn_into::<WebGlRenderingContext>().ok()?;
+            .dyn_into::<WebGl2RenderingContext>().ok()?;
+        info!("created webgl2 context successfully");
         Some(Self {
             element, ctx
         })
     }
 
     pub fn render(&self) {
-        info!("rich kidd");
+        info!("do a barrel roll");
     }
 }
diff --git a/WebInterface/wasm/asm-paint/src/lib.rs b/WebInterface/wasm/asm-paint/src/lib.rs
index 8b0ee8f..432c370 100644
--- a/WebInterface/wasm/asm-paint/src/lib.rs
+++ b/WebInterface/wasm/asm-paint/src/lib.rs
@@ -17,3 +17,122 @@ pub fn entry() {
     let app = app::App::new().unwrap();
     app.run();
 }
+
+/*
+use js_sys::WebAssembly;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use web_sys::{WebGlProgram, WebGlRenderingContext, WebGlShader};
+
+#[wasm_bindgen(start)]
+pub fn start() -> Result<(), JsValue> {
+    let document = web_sys::window().unwrap().document().unwrap();
+    let canvas = document.get_element_by_id("canvas").unwrap();
+    let canvas: web_sys::HtmlCanvasElement = canvas.dyn_into::<web_sys::HtmlCanvasElement>()?;
+
+    let context = canvas
+        .get_context("webgl")?
+        .unwrap()
+        .dyn_into::<WebGlRenderingContext>()?;
+
+    let vert_shader = compile_shader(
+        &context,
+        WebGlRenderingContext::VERTEX_SHADER,
+        r#"
+        attribute vec4 position;
+        void main() {
+            gl_Position = position;
+        }
+    "#,
+    )?;
+    let frag_shader = compile_shader(
+        &context,
+        WebGlRenderingContext::FRAGMENT_SHADER,
+        r#"
+        void main() {
+            gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
+        }
+    "#,
+    )?;
+    let program = link_program(&context, &vert_shader, &frag_shader)?;
+    context.use_program(Some(&program));
+
+    let vertices: [f32; 9] = [-0.7, -0.7, 0.0, 0.7, -0.7, 0.0, 0.0, 0.7, 0.0];
+    let memory_buffer = wasm_bindgen::memory()
+        .dyn_into::<WebAssembly::Memory>()?
+        .buffer();
+    let vertices_location = vertices.as_ptr() as u32 / 4;
+    let vert_array = js_sys::Float32Array::new(&memory_buffer)
+        .subarray(vertices_location, vertices_location + vertices.len() as u32);
+
+    let buffer = context.create_buffer().ok_or("failed to create buffer")?;
+    context.bind_buffer(WebGlRenderingContext::ARRAY_BUFFER, Some(&buffer));
+    context.buffer_data_with_array_buffer_view(
+        WebGlRenderingContext::ARRAY_BUFFER,
+        &vert_array,
+        WebGlRenderingContext::STATIC_DRAW,
+    );
+    context.vertex_attrib_pointer_with_i32(0, 3, WebGlRenderingContext::FLOAT, false, 0, 0);
+    context.enable_vertex_attrib_array(0);
+
+    context.clear_color(0.0, 0.0, 0.0, 1.0);
+    context.clear(WebGlRenderingContext::COLOR_BUFFER_BIT);
+
+    context.draw_arrays(
+        WebGlRenderingContext::TRIANGLES,
+        0,
+        (vertices.len() / 3) as i32,
+    );
+    Ok(())
+}
+
+pub fn compile_shader(
+    context: &WebGlRenderingContext,
+    shader_type: u32,
+    source: &str,
+) -> Result<WebGlShader, String> {
+    let shader = context
+        .create_shader(shader_type)
+        .ok_or_else(|| String::from("Unable to create shader object"))?;
+    context.shader_source(&shader, source);
+    context.compile_shader(&shader);
+
+    if context
+        .get_shader_parameter(&shader, WebGlRenderingContext::COMPILE_STATUS)
+        .as_bool()
+        .unwrap_or(false)
+    {
+        Ok(shader)
+    } else {
+        Err(context
+            .get_shader_info_log(&shader)
+            .unwrap_or_else(|| String::from("Unknown error creating shader")))
+    }
+}
+
+pub fn link_program(
+    context: &WebGlRenderingContext,
+    vert_shader: &WebGlShader,
+    frag_shader: &WebGlShader,
+) -> Result<WebGlProgram, String> {
+    let program = context
+        .create_program()
+        .ok_or_else(|| String::from("Unable to create shader object"))?;
+
+    context.attach_shader(&program, vert_shader);
+    context.attach_shader(&program, frag_shader);
+    context.link_program(&program);
+
+    if context
+        .get_program_parameter(&program, WebGlRenderingContext::LINK_STATUS)
+        .as_bool()
+        .unwrap_or(false)
+    {
+        Ok(program)
+    } else {
+        Err(context
+            .get_program_info_log(&program)
+            .unwrap_or_else(|| String::from("Unknown error creating program object")))
+    }
+}
+*/