Update API for in-progress wgpu-gl PR to wgpu / gfx

Cargo.toml

@@ -20,6 +20,7 @@ metal = ["wgn/gfx-backend-metal"]
 dx11 = ["wgn/gfx-backend-dx11"]
 dx12 = ["wgn/gfx-backend-dx12"]
 vulkan = ["wgn/gfx-backend-vulkan"]
+gl = ["wgn/gfx-backend-gl"]
 
 [dependencies]
 #TODO: only depend on the published version

examples/framework.rs

@@ -44,16 +44,62 @@ pub fn run<E: Example>(title: &str) {
         EventsLoop,
         KeyboardInput,
         VirtualKeyCode,
-        Window,
         WindowEvent,
     };
 
-    info!("Initializing the device...");
     env_logger::init();
-    let instance = wgpu::Instance::new();
-    let adapter = instance.get_adapter(&wgpu::AdapterDescriptor {
-        power_preference: wgpu::PowerPreference::LowPower,
-    });
+
+    let mut events_loop = EventsLoop::new();
+
+    info!("Initializing the window...");
+
+    #[cfg(not(feature = "gl"))]
+    let (_instance, _window, hidpi_factor, size, surface, adapter) = {
+        use wgpu::winit::Window;
+
+        let instance = wgpu::Instance::new();
+
+        let window = Window::new(&events_loop).unwrap();
+        window.set_title(title);
+        let hidpi_factor = window.get_hidpi_factor();
+        let size = window
+            .get_inner_size()
+            .unwrap()
+            .to_physical(hidpi_factor);
+
+        let surface = instance.create_surface(&window);
+
+        let adapter = instance.get_adapter(&wgpu::AdapterDescriptor {
+            power_preference: wgpu::PowerPreference::LowPower,
+        });
+
+        (instance, window, hidpi_factor, size, surface, adapter)
+    };
+
+    #[cfg(feature = "gl")]
+    let (hidpi_factor, size, surface, adapter) = {
+        let wb = wgpu::winit::WindowBuilder::new();
+        let cb = wgpu::glutin::ContextBuilder::new().with_vsync(true);
+        let context = wgpu::glutin::WindowedContext::new_windowed(wb, cb, &events_loop).unwrap();
+        context.window().set_title(title);
+
+        let hidpi_factor = context.window().get_hidpi_factor();
+        let size = context
+            .window()
+            .get_inner_size()
+            .unwrap()
+            .to_physical(hidpi_factor);
+
+        let surface = wgpu::Surface::create(context);
+
+        let adapter = surface.get_adapter(&wgpu::AdapterDescriptor {
+            power_preference: wgpu::PowerPreference::LowPower,
+        });
+
+        (hidpi_factor, size, surface, adapter)
+    };
+
+
     let mut device = adapter.request_device(&wgpu::DeviceDescriptor {
         extensions: wgpu::Extensions {
             anisotropic_filtering: false,
@@ -61,16 +107,6 @@ pub fn run<E: Example>(title: &str) {
         limits: wgpu::Limits::default(),
     });
 
-    info!("Initializing the window...");
-    let mut events_loop = EventsLoop::new();
-    let window = Window::new(&events_loop).unwrap();
-    window.set_title(title);
-    let size = window
-        .get_inner_size()
-        .unwrap()
-        .to_physical(window.get_hidpi_factor());
-
-    let surface = instance.create_surface(&window);
     let mut sc_desc = wgpu::SwapChainDescriptor {
         usage: wgpu::TextureUsage::OUTPUT_ATTACHMENT,
         format: wgpu::TextureFormat::Bgra8Unorm,
@@ -90,7 +126,7 @@ pub fn run<E: Example>(title: &str) {
                 event: WindowEvent::Resized(size),
                 ..
             } => {
-                let physical = size.to_physical(window.get_hidpi_factor());
+                let physical = size.to_physical(hidpi_factor);
                 info!("Resizing to {:?}", physical);
                 sc_desc.width = physical.width.round() as u32;
                 sc_desc.height = physical.height.round() as u32;

examples/hello-triangle/main.rs

@@ -1,10 +1,59 @@
 fn main() {
+    use wgpu::winit::{
+        ElementState,
+        Event,
+        EventsLoop,
+        KeyboardInput,
+        VirtualKeyCode,
+        WindowEvent,
+    };
+
     env_logger::init();
 
-    let instance = wgpu::Instance::new();
-    let adapter = instance.get_adapter(&wgpu::AdapterDescriptor {
-        power_preference: wgpu::PowerPreference::LowPower,
-    });
+    let mut events_loop = EventsLoop::new();
+
+    #[cfg(not(feature = "gl"))]
+    let (_instance, _window, size, surface, adapter) = {
+        use wgpu::winit::Window;
+
+        let instance = wgpu::Instance::new();
+
+        let window = Window::new(&events_loop).unwrap();
+        let size = window
+            .get_inner_size()
+            .unwrap()
+            .to_physical(window.get_hidpi_factor());
+
+        let surface = instance.create_surface(&window);
+
+        let adapter = instance.get_adapter(&wgpu::AdapterDescriptor {
+            power_preference: wgpu::PowerPreference::LowPower,
+        });
+
+        (instance, window, size, surface, adapter)
+    };
+
+    #[cfg(feature = "gl")]
+    let (size, surface, adapter) = {
+        let wb = wgpu::winit::WindowBuilder::new();
+        let cb = wgpu::glutin::ContextBuilder::new().with_vsync(true);
+        let context = wgpu::glutin::WindowedContext::new_windowed(wb, cb, &events_loop).unwrap();
+
+        let size = context
+            .window()
+            .get_inner_size()
+            .unwrap()
+            .to_physical(context.window().get_hidpi_factor());
+
+        let surface = wgpu::Surface::create(context);
+
+        let adapter = surface.get_adapter(&wgpu::AdapterDescriptor {
+            power_preference: wgpu::PowerPreference::LowPower,
+        });
+
+        (size, surface, adapter)
+    };
+
     let mut device = adapter.request_device(&wgpu::DeviceDescriptor {
         extensions: wgpu::Extensions {
             anisotropic_filtering: false,
@@ -57,24 +106,6 @@ fn main() {
         sample_count: 1,
     });
 
-    use wgpu::winit::{
-        ElementState,
-        Event,
-        EventsLoop,
-        KeyboardInput,
-        VirtualKeyCode,
-        Window,
-        WindowEvent,
-    };
-
-    let mut events_loop = EventsLoop::new();
-    let window = Window::new(&events_loop).unwrap();
-    let size = window
-        .get_inner_size()
-        .unwrap()
-        .to_physical(window.get_hidpi_factor());
-
-    let surface = instance.create_surface(&window);
     let mut swap_chain = device.create_swap_chain(
         &surface,
         &wgpu::SwapChainDescriptor {

src/lib.rs

@@ -60,6 +60,9 @@ pub use wgn::{
     VertexFormat,
 };
 
+#[cfg(feature = "gl")]
+pub use wgn::glutin;
+
 //TODO: avoid heap allocating vectors during resource creation.
 #[derive(Default)]
 struct Temp {
@@ -72,6 +75,7 @@ struct Temp {
 ///
 /// An `Instance` represents the entire context of a running `wgpu` instance. The `Instance`
 /// allows the querying of [`Adapter`] objects and the creation of [`Surface`] objects.
+#[cfg(not(feature = "gl"))]
 pub struct Instance {
     id: wgn::InstanceId,
 }
@@ -453,6 +457,7 @@ where
     }
 }
 
+#[cfg(not(feature = "gl"))]
 impl Instance {
     /// Create a new `Instance` object.
     pub fn new() -> Self {
@@ -491,6 +496,21 @@ impl Instance {
     }
 }
 
+#[cfg(feature = "gl")]
+impl Surface {
+    pub fn create(windowed_context: wgn::glutin::WindowedContext) -> Surface {
+        Surface {
+            id: wgn::wgpu_gl_create_surface(windowed_context)
+        }
+    }
+
+    pub fn get_adapter(&self, desc: &AdapterDescriptor) -> Adapter {
+        Adapter {
+            id: wgn::wgpu_gl_surface_get_adapter(self.id, desc),
+        }
+    }
+}
+
 impl Adapter {
     /// Requests a connection to a physical device, creating a logical device.
     ///