Rust - Draw Quad

draw_quad.rs

    #[wasm_bindgen(js_name = drawQuad)]
    pub fn draw_quad(&self, gl: WebGl2RenderingContext) {
        let current_program: WebGlProgram = gl.get_parameter(WebGl2RenderingContext::CURRENT_PROGRAM).unwrap().into();

        let target_texture = gl.create_texture().unwrap();
        gl.bind_texture(WebGl2RenderingContext::TEXTURE_2D, Some(&target_texture));
        let _ = gl.tex_image_2d_with_i32_and_i32_and_i32_and_format_and_type_and_opt_u8_array(
            WebGl2RenderingContext::TEXTURE_2D,
            0,
            WebGl2RenderingContext::RGBA as i32,
            256,
            256,
            0,
            WebGl2RenderingContext::RGBA,
            WebGl2RenderingContext::UNSIGNED_BYTE,
            None,
        );
        gl.tex_parameteri(
            WebGl2RenderingContext::TEXTURE_2D,
            WebGl2RenderingContext::TEXTURE_MIN_FILTER,
            WebGl2RenderingContext::LINEAR as i32,
        );
        gl.tex_parameteri(
            WebGl2RenderingContext::TEXTURE_2D,
            WebGl2RenderingContext::TEXTURE_WRAP_S,
            WebGl2RenderingContext::CLAMP_TO_EDGE as i32,
        );
        gl.tex_parameteri(
            WebGl2RenderingContext::TEXTURE_2D,
            WebGl2RenderingContext::TEXTURE_WRAP_T,
            WebGl2RenderingContext::CLAMP_TO_EDGE as i32,
        );

        let frame_buffer = gl.create_framebuffer().unwrap();
        gl.bind_framebuffer(WebGl2RenderingContext::FRAMEBUFFER, Some(&frame_buffer));

        gl.framebuffer_texture_2d(
            WebGl2RenderingContext::FRAMEBUFFER,
            WebGl2RenderingContext::COLOR_ATTACHMENT0,
            WebGl2RenderingContext::TEXTURE_2D,
            Some(&target_texture),
            0,
        );

        let vertex_shader = gl.create_shader(WebGl2RenderingContext::VERTEX_SHADER).unwrap();
        gl.shader_source(
            &vertex_shader,
            "attribute vec4 aVertexPosition; void main(void) { gl_Position = aVertexPosition; }",
        );
        gl.compile_shader(&vertex_shader);

        let fragment_shader = gl.create_shader(WebGl2RenderingContext::FRAGMENT_SHADER).unwrap();
        gl.shader_source(&fragment_shader, "void main(void) { gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); }");
        gl.compile_shader(&fragment_shader);

        let shader_program = gl.create_program().unwrap();
        gl.attach_shader(&shader_program, &vertex_shader);
        gl.attach_shader(&shader_program, &fragment_shader);
        gl.link_program(&shader_program);
        gl.use_program(Some(&shader_program));

        let vertices: [f32; 8] = [-1.0, 1.0, -1.0, -1.0, 1.0, -1.0, 1.0, 1.0];
        let vertex_buffer = gl.create_buffer().unwrap();
        gl.bind_buffer(WebGl2RenderingContext::ARRAY_BUFFER, Some(&vertex_buffer));
        gl.buffer_data_with_array_buffer_view(
            WebGl2RenderingContext::ARRAY_BUFFER,
            &Float32Array::from(vertices.as_ref()),
            WebGl2RenderingContext::STATIC_DRAW,
        );

        let position = gl.get_attrib_location(&shader_program, "aVertexPosition") as u32;
        gl.enable_vertex_attrib_array(position);
        gl.vertex_attrib_pointer_with_i32(position, 2, WebGl2RenderingContext::FLOAT, false, 0, 0);

        gl.viewport(0, 0, 10, 10);
        gl.clear_color(0.0, 0.0, 0.0, 0.0);
        gl.clear(WebGl2RenderingContext::COLOR_BUFFER_BIT);
        gl.draw_arrays(WebGl2RenderingContext::TRIANGLE_FAN, 0, 4);

        let mut data: Vec<u8> = vec![0; 10 * 10 * 4];

        let _ = gl.read_pixels_with_opt_u8_array(
            0,
            0,
            10,
            10,
            WebGl2RenderingContext::RGBA,
            WebGl2RenderingContext::UNSIGNED_BYTE,
            Some(data.as_mut_slice()),
        );

        for y in 0..10 {
            for x in 0..10 {
                let idx = (y * 10 + x) * 4 as usize;

                log!("({}, {}) - {} {} {} {}", x, y, data[idx], data[idx + 1], data[idx + 2], data[idx + 3]);
            }
        }

        gl.bind_framebuffer(WebGl2RenderingContext::FRAMEBUFFER, None);
        gl.bind_texture(WebGl2RenderingContext::TEXTURE_2D, None);

        gl.use_program(Some(&current_program));
    }