finishing up

code/beginner/tutorial2-swapchain/src/challenge.rs

@@ -62,7 +62,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -87,11 +87,11 @@ impl State {
         }
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -153,18 +153,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 window.request_redraw();

code/beginner/tutorial2-swapchain/src/main.rs

@@ -55,7 +55,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -66,11 +66,11 @@ impl State {
         false
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -137,18 +137,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial3-pipeline/src/challenge.rs

@@ -162,7 +162,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -188,11 +188,11 @@ impl State {
         }
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -266,18 +266,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial3-pipeline/src/main.rs

@@ -107,7 +107,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -118,11 +118,11 @@ impl State {
         false
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -192,18 +192,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial4-buffer/src/challenge.rs

@@ -216,7 +216,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -240,11 +240,11 @@ impl State {
         }
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -331,18 +331,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial4-buffer/src/main.rs

@@ -172,7 +172,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -183,11 +183,11 @@ impl State {
         false
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -259,18 +259,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial5-textures/src/challenge.rs

@@ -255,7 +255,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -279,11 +279,11 @@ impl State {
         }
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -362,18 +362,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial5-textures/src/main.rs

@@ -226,7 +226,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -237,11 +237,11 @@ impl State {
         false
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
 
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -314,18 +314,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial6-uniforms/src/challenge.rs

@@ -428,7 +428,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -441,7 +441,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.uniform_staging.camera);
         self.uniform_staging.model_rotation += cgmath::Deg(2.0);
         self.uniform_staging.update_uniforms(&mut self.uniforms);
@@ -460,7 +460,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -534,18 +534,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial6-uniforms/src/main.rs

@@ -418,7 +418,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -431,7 +431,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -449,7 +449,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -523,18 +523,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial7-instancing/examples/array_instances.rs

@@ -449,7 +449,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -462,7 +462,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -484,7 +484,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -558,18 +558,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial7-instancing/examples/naive.rs

@@ -448,7 +448,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -461,7 +461,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -479,7 +479,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -580,18 +580,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial7-instancing/examples/storage_instances.rs

@@ -487,7 +487,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -500,7 +500,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -518,7 +518,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -592,18 +592,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial7-instancing/examples/texture_instances.rs

@@ -582,7 +582,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -595,7 +595,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -613,7 +613,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -687,18 +687,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial7-instancing/examples/vertex_instances.rs

@@ -507,7 +507,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -520,7 +520,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -538,7 +538,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -613,18 +613,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial7-instancing/src/challenge.rs

@@ -516,7 +516,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -529,7 +529,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -560,7 +560,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -634,18 +634,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial7-instancing/src/main.rs

@@ -504,7 +504,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -517,7 +517,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -535,7 +535,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -610,18 +610,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial8-depth/src/challenge.rs

@@ -629,7 +629,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -647,7 +647,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -665,7 +665,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -848,18 +848,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial8-depth/src/main.rs

@@ -500,7 +500,7 @@ impl State {
     }
 
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.size = new_size;
         self.sc_desc.width = new_size.width;
         self.sc_desc.height = new_size.height;
@@ -515,7 +515,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -533,7 +533,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
 
@@ -615,18 +615,18 @@ fn main() {
                         }
                     }
                     WindowEvent::Resized(physical_size) => {
-                        block_on(state.resize(*physical_size));
+                        state.resize(*physical_size);
                     }
                     WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                         // new_inner_size is &mut so w have to dereference it twice
-                        block_on(state.resize(**new_inner_size));
+                        state.resize(**new_inner_size);
                     }
                     _ => {}
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             Event::MainEventsCleared => {
                 // RedrawRequested will only trigger once, unless we manually

code/beginner/tutorial9-models/src/main.rs

@@ -422,7 +422,7 @@ impl State {
         }
     }
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.depth_texture = texture::Texture::create_depth_texture(&self.device, &self.sc_desc, "depth_texture");
         self.camera.aspect = self.sc_desc.width as f32 / self.sc_desc.height as f32;
         self.size = new_size;
@@ -434,7 +434,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -457,7 +457,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
         .expect("Timeout getting texture");
         let mut encoder =
@@ -532,18 +532,18 @@ fn main() {
                             _ => {}
                         },
                         WindowEvent::Resized(physical_size) => {
-                            block_on(state.resize(*physical_size));
+                            state.resize(*physical_size);
                         }
                         WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                            block_on(state.resize(**new_inner_size));
+                            state.resize(**new_inner_size);
                         }
                         _ => {}
                     }
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             _ => {}
         }

code/intermediate/tutorial10-lighting/src/main.rs

@@ -530,7 +530,7 @@ impl State {
 
     }
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         self.depth_texture = texture::Texture::create_depth_texture(&self.device, &self.sc_desc, "depth_texture");
         self.camera.aspect = self.sc_desc.width as f32 / self.sc_desc.height as f32;
         self.size = new_size;
@@ -544,7 +544,7 @@ impl State {
         self.camera_controller.process_events(event)
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         self.camera_controller.update_camera(&mut self.camera);
         self.uniforms.update_view_proj(&self.camera);
 
@@ -585,7 +585,7 @@ impl State {
         self.queue.submit(&[encoder.finish()]);
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         let frame = self.swap_chain.get_next_texture()
             .expect("Timeout getting texture");
         let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { 
@@ -666,18 +666,18 @@ fn main() {
                             _ => {}
                         },
                         WindowEvent::Resized(physical_size) => {
-                            block_on(state.resize(*physical_size));
+                            state.resize(*physical_size);
                         }
                         WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
-                            block_on(state.resize(**new_inner_size));
+                            state.resize(**new_inner_size);
                         }
                         _ => {}
                     }
                 }
             }
             Event::RedrawRequested(_) => {
-                block_on(state.update());
-                block_on(state.render());
+                state.update();
+                state.render();
             }
             _ => {}
         }

docs/beginner/tutorial2-swapchain/README.md

@@ -22,7 +22,7 @@ impl State {
         unimplemented!()
     }
 
-    async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
         unimplemented!()
     }
 
@@ -31,11 +31,11 @@ impl State {
         unimplemented!()
     }
 
-    async fn update(&mut self) {
+    fn update(&mut self) {
         unimplemented!()
     }
 
-    async fn render(&mut self) {
+    fn render(&mut self) {
         unimplemented!()
     }
 }
@@ -148,7 +148,7 @@ If we want to support resizing in our application, we're going to need to recrea
 
 ```rust
 // impl State
-async fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
+fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
     self.size = new_size;
     self.sc_desc.width = new_size.width;
     self.sc_desc.height = new_size.height;

docs/beginner/tutorial6-uniforms/README.md

@@ -378,7 +378,7 @@ Up to this point, the camera controller isn't actually doing anything. The value
 Enough about that though, let's get into actually implementing the code.
 
 ```rust
-async fn update(&mut self) {
+fn update(&mut self) {
     self.camera_controller.update_camera(&mut self.camera);
     self.uniforms.update_view_proj(&self.camera);