gled-ui 2.31.1

gled's egui interface, shared by the desktop app and the browser
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

use super::App;
use crate::pipeline::{renderer_callback::RendererCallback, ui_gpu};
use gled_gpu::scene_render::{EvalContext, ensure_project_matrix_pipelines, render_matrices};
use gled_svg::fixture_preview::{self, IndexMap};
use wgpu::CommandEncoderDescriptor;

impl App {
    /// Render the effect thumbnails and the LED
    /// preview on the UI device. The commands are submitted by egui's paint
    /// through `RendererCallback`, so they never race the window surface.
    #[cfg_attr(feature = "profiling", profiling::function)]
    pub(super) fn render_thumbnails_and_preview(&mut self) {
        let gpu = ui_gpu();
        let mut encoder = gpu
            .device
            .create_command_encoder(&CommandEncoderDescriptor {
                label: Some("Render thumbnails and preview"),
            });

        if let Some(project) = &self.project {
            ensure_project_matrix_pipelines(
                project,
                &mut self.thumbnails,
                &gpu,
                &self.model.replica.assets,
            );
            render_matrices(
                project,
                &mut self.thumbnails,
                &gpu,
                &mut encoder,
                &self.timing.beat_state(),
                EvalContext {
                    patch: &project.patch,
                    collections: &self.model.replica.assets,
                    sound: &*self.model.sound,
                },
            );
            self.thumbnail_textures.sync(&self.thumbnails);
        }

        let latest_output = self.model.preview.take();
        match (self.project.is_some(), latest_output) {
            (true, Some(output)) => {
                self.ui_preview.preview.upload_output(&gpu.queue, &output);
                self.preview_has_output = true;
            }
            (false, _) if self.preview_has_output => {
                self.ui_preview.preview.clear_output(&gpu.queue);
                self.preview_has_output = false;
            }
            _ => {}
        }

        let (project, collections) = (&self.project, &self.model.replica.assets);
        self.ui_preview
            .indices
            .prepare(&gpu.queue, || match project {
                Some(project) => fixture_preview::build(&project.patch, collections),
                None => IndexMap::default(),
            });
        self.ui_preview.preview.run(&mut encoder);
        RendererCallback::try_add(encoder.finish());
    }
}