Setup winit window and wgpu::Device

Cargo.toml

@@ -4,9 +4,11 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+pollster = "0.2"
 rayon = "1"
 slab = "^0.4"
 smallmap = "^1.0"
 smallvec = "^1.0"
 strum = { version = "0.24", features = ["derive"] }
 wgpu = "^0.12"
+winit = "0.26"

src/lib.rs

@@ -14,20 +14,26 @@ use pass::*;
 use phase::*;
 
 pub struct Renderer {
-    pub frames_in_flight: usize,
-    pub render_passes: Vec<Box<dyn RenderPassBoxTrait>>,
+    device: Arc<wgpu::Device>,
+    queue: wgpu::Queue,
+    frames_in_flight: usize,
+    render_passes: Vec<Box<dyn RenderPassBoxTrait>>,
 }
 
-impl Default for Renderer {
-    fn default() -> Self {
+impl Renderer {
+    pub fn new(device: wgpu::Device, queue: wgpu::Queue) -> Self {
         Self {
+            device: Arc::new(device),
+            queue,
             frames_in_flight: 2,
             render_passes: Vec::new(),
         }
     }
-}
 
-impl Renderer {
+    pub fn get_device(&self) -> &Arc<wgpu::Device> {
+        &self.device
+    }
+
     pub fn add_pass<T: 'static + RenderPass>(&mut self, pass: T) {
         let pass = Arc::new(RwLock::new(pass));
         self.add_pass_arc(pass);

src/main.rs

@@ -1,9 +1,59 @@
 use cyborg::{pass, Renderer};
+use winit::{event::*, event_loop::{ControlFlow, EventLoop}, window::WindowBuilder};
+
+async fn make_window_renderer(window: &winit::window::Window) -> Renderer {
+    let size = window.inner_size();
+    let instance = wgpu::Instance::new(wgpu::Backends::all());
+    let surface = unsafe { instance.create_surface(window) };
+    let adapter = instance
+        .request_adapter(&wgpu::RequestAdapterOptions {
+            power_preference: wgpu::PowerPreference::LowPower,
+            compatible_surface: Some(&surface),
+            force_fallback_adapter: false,
+        })
+        .await
+        .unwrap();
+    let (device, queue) = adapter
+        .request_device(
+            &wgpu::DeviceDescriptor {
+                features: wgpu::Features::empty(),
+                limits: wgpu::Limits::default(),
+                label: None,
+            },
+            None,
+        )
+        .await
+        .unwrap();
+    let config = wgpu::SurfaceConfiguration {
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+        format: surface.get_preferred_format(&adapter).unwrap(),
+        width: size.width,
+        height: size.height,
+        present_mode: wgpu::PresentMode::Fifo,
+    };
+    surface.configure(&device, &config);
+
+    Renderer::new(device, queue)
+}
 
 fn main() {
-    let mut renderer = Renderer::default();
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new().build(&event_loop).unwrap();
+    let mut renderer = pollster::block_on(make_window_renderer(&window));
+
     let mesh_pass = pass::mesh::MeshPass::new();
     renderer.add_pass(mesh_pass);
 
     renderer.render();
+
+    event_loop.run(move |event, _, control_flow| match event {
+        Event::WindowEvent {
+            ref event,
+            window_id,
+        } if window_id == window.id() => match event {
+            WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+            _ => {}
+        }
+        _ => {}
+    });
 }