minwebgpu 0.2.0

Minimal WebGPU toolkit for modern graphics programming with compute shaders and rendering pipelines
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

/// Internal namespace.
mod private
{
  use crate::*;
  use wasm_bindgen_futures::JsFuture;

  /// Retrieves the `web_sys::Navigator` object from the current window.
  pub fn navigator() -> web_sys::Navigator
  {
    let window = web_sys::window().unwrap();
    let navigator = window.navigator();
    navigator
  }

  /// Asynchronously requests a WebGPU adapter from the browser.
  pub async fn request_adapter() -> web_sys::GpuAdapter
  {
    let navigator = navigator();
    let gpu = navigator.gpu();

    let adapter = JsFuture::from( gpu.request_adapter() ).await.unwrap();
    adapter.dyn_into().unwrap()
  }

  /// Asynchronously requests a logical GPU device from a given adapter.
  pub async fn request_device( adapter : &web_sys::GpuAdapter ) -> web_sys::GpuDevice
  {
    let device = JsFuture::from( adapter.request_device() ).await.unwrap();
    device.dyn_into().unwrap()
  }

  /// Retrieves the WebGPU context from an HTML canvas element.
  pub fn from_canvas( canvas : &web_sys::HtmlCanvasElement ) -> Result< GL, dom::Error >
  {
    let context = canvas
    .get_context( "webgpu" )
    .map_err( |_| dom::Error::ContextRetrievingError( "Failed to get webgpu context" ) )?
    .ok_or( dom::Error::ContextRetrievingError( "No webgpu context" ) )?;

    let gl : GL = context
    .dyn_into()
    .map_err( |_| dom::Error::ContextRetrievingError( "Failed to cast to GL" ) )?;

    Ok( gl ) 
  }

  /// Configures the WebGPU canvas context for rendering.
  pub fn configure( device : &web_sys::GpuDevice, context : &GL, format : GpuTextureFormat ) -> Result< (), WebGPUError >
  {
    let configuration = web_sys::GpuCanvasConfiguration::new( device, format );

    context.configure( &configuration ).map_err( | e | error::CanvasError::ConfigurationError( format!( "{:?}", e ) ) )?;
    Ok( () )
  }

  /// Retrieves the preferred texture format for the current canvas.
  pub fn preferred_format() -> GpuTextureFormat
  {
    let navigator = navigator();
    let format = navigator.gpu().get_preferred_canvas_format();
    format
  }

  /// Gets the current texture from the WebGPU context.
  pub fn current_texture( context : &GL ) -> Result< web_sys::GpuTexture, WebGPUError >
  {
    let format = context.get_current_texture()
    .map_err( | e | error::ContextError::FailedToGetCurrentTextureError( format!( "{:?}", e ) ) )?;

    Ok( format )
  }
}

crate::mod_interface!
{
  own use 
  {
    request_adapter,
    request_device,
    from_canvas,
    navigator,
    preferred_format,
    configure,
    current_texture
  };

}