witer 0.11.4

An iterator-based Win32 windowing library
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use egui::{Context, ViewportId};
use egui_wgpu::{Renderer, ScreenDescriptor};
use wgpu::{CommandEncoder, Device, Queue, TextureFormat, TextureView};
use witer::{
  compat::egui::{EventResponse, State},
  Message,
  Window,
};

pub struct EguiRenderer {
  pub context: Context,
  state: State,
  renderer: Renderer,
}

#[allow(unused)]
impl EguiRenderer {
  pub fn new(
    device: &Device,
    output_color_format: TextureFormat,
    output_depth_format: Option<TextureFormat>,
    msaa_samples: u32,
    window: &Window,
  ) -> EguiRenderer {
    let egui_context = Context::default();
    let egui_state = State::new(
      egui_context.clone(),
      ViewportId::default(),
      window,
      Some(window.scale_factor() as f32),
      None,
    );
    let egui_renderer = egui_wgpu::Renderer::new(
      device,
      output_color_format,
      output_depth_format,
      msaa_samples,
    );

    EguiRenderer {
      context: egui_context,
      state: egui_state,
      renderer: egui_renderer,
    }
  }

  pub fn handle_input(&mut self, window: &Window, event: &Message) -> EventResponse {
    self.state.on_window_event(window, event)
  }

  #[allow(clippy::too_many_arguments)]
  pub fn draw(
    &mut self,
    device: &Device,
    queue: &Queue,
    encoder: &mut CommandEncoder,
    window: &Window,
    window_surface_view: &TextureView,
    screen_descriptor: ScreenDescriptor,
    run_ui: impl FnOnce(&Context),
  ) {
    let raw_input = self.state.take_egui_input(window);
    let full_output = self.context.run(raw_input, |ui| {
      run_ui(&self.context);
    });

    self
      .state
      .handle_platform_output(window, full_output.platform_output);

    let tris = self
      .context
      .tessellate(full_output.shapes, full_output.pixels_per_point);

    for (id, image_delta) in &full_output.textures_delta.set {
      self
        .renderer
        .update_texture(device, queue, *id, image_delta);
    }

    self
      .renderer
      .update_buffers(device, queue, encoder, &tris, &screen_descriptor);

    {
      let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
        label: Some("EGUI Pass"),
        color_attachments: &[Some(wgpu::RenderPassColorAttachment {
          view: window_surface_view,
          resolve_target: None,
          ops: wgpu::Operations {
            load: wgpu::LoadOp::Load,
            store: wgpu::StoreOp::Store,
          },
        })],
        depth_stencil_attachment: None,
        timestamp_writes: None,
        occlusion_query_set: None,
      });
      self.renderer.render(&mut rpass, &tris, &screen_descriptor);
    }

    for x in &full_output.textures_delta.free {
      self.renderer.free_texture(x)
    }
  }
}