tridify-rs 0.2.2

Fast wgpu render framework that aims to simplify rendering pipelines. Currently under heavy development.
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
108
109
110
111
112
113

mod egui_backend;

use std::iter;

use egui::FontDefinitions;
use wgpu::Error;
use winit::event::Event;

use crate::GpuCtx;

use self::egui_backend::*;

pub struct EguiContext {
    pub(crate) platform: Platform,
}

impl EguiContext {
    pub fn new(gpu: &GpuCtx) -> Self {
        let size = gpu.get_wnd_size();
        let platform = Platform::new(PlatformDescriptor {
            physical_width: size.x,
            physical_height: size.y,
            scale_factor: gpu.winit_wnd.scale_factor(),
            font_definitions: FontDefinitions::default(),
            style: Default::default(),
        });

        Self { platform }
    }

    pub fn event(&mut self, event: &Event<()>) { self.platform.handle_event(event); }

    pub fn start(&mut self, dt: f64) {
        self.platform.begin_frame();
        self.platform.update_time(dt);
    }

    pub fn ctx(&self) -> egui::Context { self.platform.context() }
}

pub struct EguiPass {
    pub(crate) egui_rp: RenderPass,
}
impl EguiPass {
    pub fn new(gpu: &GpuCtx) -> Self {
        let egui_rp = RenderPass::new(
            &gpu.device,
            gpu.surface.get_capabilities(&gpu.adapter).formats[0],
            1,
        );
        Self { egui_rp }
    }

    pub fn render(&mut self, gpu: &mut GpuCtx) {
        let mut egui = gpu.egui.as_mut().unwrap();
        let output_frame = match gpu.surface.get_current_texture() {
            Ok(frame) => frame,
            Err(wgpu::SurfaceError::Outdated) => {
                // This error occurs when the app is minimized on Windows.
                // Silently return here to prevent spamming the console with:
                // "The underlying surface has changed, and therefore the swap chain must be updated"
                return;
            }
            Err(e) => {
                eprintln!("Dropped frame with error: {}", e);
                return;
            }
        };
        let output_view = output_frame
            .texture
            .create_view(&wgpu::TextureViewDescriptor::default());
        let full_output = egui.platform.end_frame(Some(&gpu.winit_wnd));
        let paint_jobs = egui.platform.context().tessellate(full_output.shapes);

        let mut encoder = gpu
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
                label: Some("encoder"),
            });

        let size = gpu.get_wnd_size();
        // Upload all resources for the GPU.
        let screen_descriptor = ScreenDescriptor {
            physical_width: size.x,
            physical_height: size.y,
            scale_factor: gpu.winit_wnd.scale_factor() as f32,
        };
        let tdelta: egui::TexturesDelta = full_output.textures_delta;
        self.egui_rp
            .add_textures(&gpu.device, &gpu.queue, &tdelta)
            .expect("Error adding textures");
        self.egui_rp
            .update_buffers(&gpu.device, &gpu.queue, &paint_jobs, &screen_descriptor);

        // Record all render passes.
        self.egui_rp
            .execute(
                &mut encoder,
                &output_view,
                &paint_jobs,
                &screen_descriptor,
                Some(wgpu::Color::BLACK),
            )
            .unwrap();
        // Submit the commands.
        gpu.queue.submit(iter::once(encoder.finish()));
        output_frame.present();

        self.egui_rp
            .remove_textures(tdelta)
            .expect("Error removing textures");
    }
}