Struct MyDeviceImpl 

pub struct MyDeviceImpl<'a> { /* private fields */ }

An abstraction of the wgpu::Surface<’lifetime> to create from a given winit Window.

Following is an example to create the surface using a given Window

Examples

use wgpu_quick_start::{MyDevice, create_new_device};
use winit::{event::WindowEvent, window::WindowAttributes};
use winit_app::{AppWindowEvent, Application};


fn launch() -> Result<(), Box<dyn std::error::Error>> {
   let winit_app = Application::new();
   let mut opt_device: Option<Box<dyn MyDevice>> = None;
   winit_app.run(
       WindowAttributes::default().with_title("wgpu starter app"),
       move |app_window_event| match app_window_event {
           AppWindowEvent::NewWindow(window) => match create_new_device(window) {
               Ok(value) => {
                   opt_device = Some(value);
               }
               Err(err) => {
                   // warning - Error creating new surface from the window
               }
           },
           AppWindowEvent::OnWindowEvent(event, event_loop) => {
               if let Some(local_device) = opt_device.as_mut() {
                    // Handle those events
               }
           }
       },
   )?;
   Ok(())
}

Lifetimes

The lifetime of this struct refers to the underlying lifetime of the wgpu::Surface<'lifetime> inside the same.

Implementations

impl<'a> MyDeviceImpl<'a>

pub async fn new( window: impl Into<SurfaceTarget<'a>>, dimensions: (u32, u32), ) -> GPUStarterResult<Self>

Create a new surface from the given window for the given dimensions (width, height) tuple

pub async fn new_without_window() -> GPUStarterResult<Self>

Create a new device without a ‘window’ reference. Useful for unit testing

Trait Implementations

impl<'a> MyDevice for MyDeviceImpl<'a>

fn get_device(&self) -> &Device

Retrieve the device associated with this surface

fn get_queue(&self) -> &Queue

Retrieve the underlying queue present

fn get_adapter(&self) -> &Adapter

Retrieve the adapter

fn get_current_texture(&self) -> GPUStarterResult<SurfaceTexture>

Retrieve the current texture

fn get_texture_format(&self) -> GPUStarterResult<TextureFormat>

Retrieve the texture format

fn resize(&mut self, dimensions: (u32, u32))

Resize the window