Got clear screen to display

! WIP, rendering code is fully temporary

src/canvas.rs

@@ -86,7 +86,7 @@ impl Canvas {
     }
 
     pub fn clear(&mut self) {
-        self.renderer.clear(&self.clear_color);
+        todo!();
     }
 
     //--Input functions--

src/lib.rs

@@ -24,7 +24,7 @@ pub fn run_canvas<A: 'static + Application>(title: &'static str, size: Size, mut
     let event_loop = EventLoop::new();
     let window = WindowBuilder::new()
         .with_inner_size(size)
-        .with_resizable(false)
+        //.with_resizable(false)
         .with_title(title)
         .with_visible(false) //keep window invisible until we are ready to write to it
         .build(&event_loop)

src/main.rs

@@ -43,66 +43,66 @@ impl Application for ExampleApp {
         };
 
         // inputs
-        if canvas.key_pressed(Key::A) {
+        //if canvas.key_pressed(Key::A) {
-            unimplemented!();
+        //    unimplemented!();
-        }
+        //}
+        //
+        //if canvas.key_released(Key::A) {
+        //    unimplemented!();
+        //}
+        //
+        //match canvas.get_key_presses() {
+        //    Key::A => unimplemented!(),
+        //    _ => (),
+        //}
+        //
+        //match canvas.get_key_releases() {
+        //    Key::A => unimplemented!(),
+        //    _ => (),
+        //}
 
-        if canvas.key_released(Key::A) {
+        //let _mouse = canvas.get_mouse_position();
-            unimplemented!();
-        }
 
-        match canvas.get_key_presses() {
+        //// outputs
-            Key::A => unimplemented!(),
+        //canvas.set_clear_color(Color::BLACK);
-            _ => (),
+        //canvas.clear();
-        }
 
-        match canvas.get_key_releases() {
+        //// white rectangle inset by one in the sprite
-            Key::A => unimplemented!(),
+        //let mut bas_sprite = canvas.create_shape_sprite();
-            _ => (),
+        //bas_sprite.set_shape(Shape::Rectangle (Rectangle {size: Size {w: 38, h: 38}}));
-        }
+        //bas_sprite.set_color(Color::WHITE);
+        //canvas.draw(&bas_sprite);
 
-        let _mouse = canvas.get_mouse_position();
+        //// 20 x 20 sprite of a picture
+        //let texture = canvas.create_texture_from_file(
+        //    Position {x: 0, y: 0}, 
+        //    "texture.png", 
+        //    Some(Color::WHITE)
+        //);
+        //let mut pix_sprite = canvas.create_texture_sprite(Size {w: 20, h: 20}, 1.0);
+        //pix_sprite.set_texture(texture, Some(Position {x: 0, y: 0}));
+        //canvas.draw(&pix_sprite);
 
-        // outputs
+        //// scaled sprite of a manually drawed texture
-        canvas.set_clear_color(Color::BLACK);
+        //let texture = canvas.create_texture(Size {w: 20, h: 20}, Some(Color::WHITE));
-        canvas.clear();
+        //texture.borrow_mut().set_pixel(Position {x: 0, y: 0}, Pixel::rgb(0, 255, 0));
+        //let _  = texture.borrow_mut().iter_mut(); //iterate on whole texture
+        //pix_sprite = canvas.create_texture_sprite(Size {w: 20, h: 20}, 2.0);
+        //pix_sprite.set_texture(texture, None);
+        //let _  = pix_sprite.iter_mut(); //only iterate on the part used by the sprite
+        //canvas.draw(&pix_sprite);
 
-        // white rectangle inset by one in the sprite
+        //// floating text
-        let mut bas_sprite = canvas.create_shape_sprite();
+        //let mut txt_sprite = canvas.create_text_sprite(Size {w: 10, h: 10}, 5.0);
-        bas_sprite.set_shape(Shape::Rectangle (Rectangle {size: Size {w: 38, h: 38}}));
+        //txt_sprite.set_text("text");
-        bas_sprite.set_color(Color::WHITE);
+        //txt_sprite.set_color(Color::BLACK);
-        canvas.draw(&bas_sprite);
 
-        // 20 x 20 sprite of a picture
+        //// generic operations
-        let texture = canvas.create_texture_from_file(
+        //txt_sprite.set_position(Position {x: 0, y: 0});
-            Position {x: 0, y: 0}, 
+        //txt_sprite.set_rotation(50.0);
-            "texture.png", 
+        //txt_sprite.set_alpha(255);
-            Some(Color::WHITE)
+        //txt_sprite.set_scale(0.5);
-        );
+        //canvas.draw(&txt_sprite);
-        let mut pix_sprite = canvas.create_texture_sprite(Size {w: 20, h: 20}, 1.0);
-        pix_sprite.set_texture(texture, Some(Position {x: 0, y: 0}));
-        canvas.draw(&pix_sprite);
-
-        // scaled sprite of a manually drawed texture
-        let texture = canvas.create_texture(Size {w: 20, h: 20}, Some(Color::WHITE));
-        texture.borrow_mut().set_pixel(Position {x: 0, y: 0}, Pixel::rgb(0, 255, 0));
-        let _  = texture.borrow_mut().iter_mut(); //iterate on whole texture
-        pix_sprite = canvas.create_texture_sprite(Size {w: 20, h: 20}, 2.0);
-        pix_sprite.set_texture(texture, None);
-        let _  = pix_sprite.iter_mut(); //only iterate on the part used by the sprite
-        canvas.draw(&pix_sprite);
-
-        // floating text
-        let mut txt_sprite = canvas.create_text_sprite(Size {w: 10, h: 10}, 5.0);
-        txt_sprite.set_text("text");
-        txt_sprite.set_color(Color::BLACK);
-
-        // generic operations
-        txt_sprite.set_position(Position {x: 0, y: 0});
-        txt_sprite.set_rotation(50.0);
-        txt_sprite.set_alpha(255);
-        txt_sprite.set_scale(0.5);
-        canvas.draw(&txt_sprite);
 
         canvas.update();
 

src/renderer.rs

@@ -82,12 +82,44 @@ impl WgpuRenderer {
         self.surface.configure(&self.device, &self.config);
     }
 
-    pub fn clear(&mut self, _color: &Pixel) {
-        unimplemented!();
-    }
-
     pub fn present(&mut self) {
-        unimplemented!();
+        let output = self.surface.get_current_texture()
+            .map_err(|err| match err {
+                wgpu::SurfaceError::Lost => {
+                    warn!("Lost surface, trying resizing");
+                    self.resize(self.size);
+                    self.surface.get_current_texture()
+                },
+                _ => Err(err)
+        }).unwrap();
+
+        let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());
+        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+            label: Some("Render Encoder"),
+        });
+
+        {
+            let _render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Render Pass"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color {
+                            r: 0.1,
+                            g: 0.2,
+                            b: 0.3,
+                            a: 1.0,
+                        }),
+                        store: true,
+                    },
+                })],
+                depth_stencil_attachment: None,
+            });
+        }
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+        output.present();
     }
 }