radiance 0.7.1

Video art software designed for live performance
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
114
115
116
117
118
119
120
121
122
123
124
125
126

use egui::{vec2, Align, Checkbox, ComboBox, Layout, TextureId, Ui};
use radiance::{
    AvailableOutputScreen, ScreenOutputNodeProps, ScreenOutputNodeState, SelectedOutputScreen,
};

const PREVIEW_ASPECT_RATIO: f32 = 1.;
const NORMAL_HEIGHT: f32 = 320.;
const NORMAL_WIDTH: f32 = 240.;

pub struct ScreenOutputNodeTile<'a> {
    preview_image: TextureId,
    visible: &'a mut bool,
    screen: &'a mut Option<SelectedOutputScreen>,
    available_screens: &'a [AvailableOutputScreen],
}

impl<'a> ScreenOutputNodeTile<'a> {
    /// Returns a Vec with one entry for each props.input_count
    /// corresponding to the minimum allowable height for that input port.
    /// If there are no input ports, this function should return a 1-element Vec.
    pub fn min_input_heights(_props: &ScreenOutputNodeProps) -> Vec<f32> {
        // TODO Simplify this to just be a single f32
        (0..1).map(|_| NORMAL_HEIGHT).collect()
    }

    /// Calculates the width of the tile, given its height.
    pub fn width_for_height(_props: &ScreenOutputNodeProps, height: f32) -> f32 {
        NORMAL_WIDTH.min(0.5 * height)
    }

    /// Creates a new visual tile
    /// (builder pattern; this is not a stateful UI component)
    pub fn new(
        props: &'a mut ScreenOutputNodeProps,
        _state: &'a ScreenOutputNodeState,
        preview_image: TextureId,
    ) -> Self {
        ScreenOutputNodeTile {
            preview_image,
            visible: &mut props.visible,
            screen: &mut props.screen,
            available_screens: &props.available_screens,
        }
    }

    /// Render the contents of the ScreenOutputNodeTile (presumably into a Tile)
    pub fn add_contents(self, ui: &mut Ui) {
        let ScreenOutputNodeTile {
            preview_image,
            visible,
            screen,
            available_screens,
        } = self;

        ui.heading("Screen Output");
        // Preserve aspect ratio
        ui.with_layout(
            Layout::bottom_up(Align::Center).with_cross_justify(true),
            |ui| {
                ui.add(Checkbox::new(visible, "Visible"));

                let (mut screen_name, mut screen_resolution) = match screen.as_ref() {
                    Some(screen) => (screen.name.clone(), screen.resolution),
                    None => (String::new(), [0, 0]),
                };

                let available_resolutions: Vec<[u32; 2]> = screen
                    .as_ref()
                    .map(|screen| {
                        available_screens
                            .iter()
                            .find(|available_screen| available_screen.name == screen.name)
                            .map(|selected_available_screen| {
                                selected_available_screen
                                    .suggested_resolutions
                                    .iter()
                                    .cloned()
                            })
                    })
                    .into_iter()
                    .flatten()
                    .flatten()
                    .collect();

                let format_rez = |rez: &[u32; 2]| format!("{}x{}", rez[0], rez[1]);

                ComboBox::from_id_salt(1)
                    .selected_text(format_rez(&screen_resolution))
                    .show_ui(ui, |ui| {
                        for available_resolution in available_resolutions.iter() {
                            ui.selectable_value(
                                &mut screen_resolution,
                                *available_resolution,
                                format_rez(available_resolution),
                            );
                        }
                    });
                ComboBox::from_id_salt(0)
                    .selected_text(screen_name.as_str())
                    .show_ui(ui, |ui| {
                        for available_screen in available_screens.iter() {
                            ui.selectable_value(
                                &mut screen_name,
                                available_screen.name.clone(),
                                available_screen.name.as_str(),
                            );
                        }
                    });

                if !screen_name.is_empty() && screen_resolution != [0, 0] {
                    *screen = Some(SelectedOutputScreen {
                        name: screen_name,
                        resolution: screen_resolution,
                    });
                }

                ui.centered_and_justified(|ui| {
                    let image_size = ui.available_size();
                    let image_size = (image_size * vec2(1., 1. / PREVIEW_ASPECT_RATIO)).min_elem()
                        * vec2(1., PREVIEW_ASPECT_RATIO);
                    ui.image((preview_image, image_size));
                });
            },
        );
    }
}