ribir 0.4.0-alpha.60

A non-intrusive declarative GUI framework, to build modern native/wasm cross-platform applications.
Documentation 
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

#[cfg(feature = "debug")]
use ribir_core::prelude::{BoxFuture, PixelImage};
use ribir_core::prelude::{
  Color, DeviceRect, DeviceSize, GlyphProvider, PaintCommand, PainterBackend, Transform,
};
use ribir_gpu::Surface;
#[cfg(feature = "debug")]
use ribir_gpu::Texture;

use crate::winit_shell_wnd::WinitBackend;

pub struct WgpuBackend<'a> {
  surface: Surface<'a>,
  backend: ribir_gpu::GPUBackend<ribir_gpu::WgpuImpl>,
}

impl<'a> WinitBackend<'a> for WgpuBackend<'a> {
  async fn new(window: &'a winit::window::Window) -> WgpuBackend<'a> {
    let (wgpu, surface) = ribir_gpu::WgpuImpl::new(window).await;
    let size = window.inner_size();
    let size = DeviceSize::new(size.width as i32, size.height as i32);

    let mut wgpu = WgpuBackend { surface, backend: ribir_gpu::GPUBackend::new(wgpu) };
    wgpu.on_resize(size);

    wgpu
  }

  fn on_resize(&mut self, size: DeviceSize) {
    if size != self.surface.size() {
      self.surface.resize(size, self.backend.get_impl());
    }
  }

  fn begin_frame(&mut self, surface_color: Color) { self.backend.begin_frame(surface_color); }

  fn draw_commands(
    &mut self, viewport: DeviceRect, global_matrix: &Transform, commands: &[PaintCommand],
    glyph_provider: &dyn GlyphProvider,
  ) {
    self.backend.draw_commands(
      viewport,
      commands,
      global_matrix,
      self.surface.get_current_texture(),
      glyph_provider,
    );
  }

  fn end_frame(&mut self) {
    self.backend.end_frame();
    self.surface.present();
  }

  #[cfg(feature = "debug")]
  fn capture_screenshot(&mut self) -> Option<BoxFuture<'static, Option<PixelImage>>> {
    // Get size first to avoid borrow issues
    let size = self.surface.size();
    // Get the current texture from surface
    let texture = self.surface.get_current_texture();
    let rect = DeviceRect::from_size(size);

    // Copy from texture to image
    let img_future = texture.copy_as_image(&rect, self.backend.get_impl_mut());

    // Wait for the result
    Some(Box::pin(async move { img_future.await.ok() }))
  }
}