imgui_presentable 0.4.0

A simple way to represent Rust types in ImGui.
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

//! Imgui Presentable.
//!
//! Here are the main interfaces which allow the users to render enums
//! or structs in ImGui or egui effortlessly.
//!
//! To switch between the gui backends (ImGui and egui), use the
//! corresponding crate features. Both the features can be enabled
//! simultaneously, if necessary.
//!
//! The crate already provides some implementations for the basic Rust
//! types and some other types from other crates, feature-gated.
//!
//! For the collections, the trait is implemented automatically if the
//! element type of the collection implements the [`ImguiPresentable`]
//! or the [`EguiPresentable`] trait itself.

pub use imgui_presentable_derive::*;
mod basic_types;
#[cfg(feature = "glam")]
mod glam_types;
mod std_types;

/// The width and height of the viewport used by ImGUI.
#[cfg(feature = "imgui_backend")]
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Extent {
    /// The width of the viewport (in pixels).
    pub width: u16,
    /// The height of the viewport (in pixels).
    pub height: u16,
}
/// Allows the implementing object to be rendered as an ImGUI component.
#[cfg(feature = "imgui_backend")]
pub trait ImguiPresentable {
    /// Renders the implementor as a stand-alone window not allowing to
    /// change the values.
    fn render_window(&self, ui: &imgui::Ui, extent: Extent) {
        ui.window(std::any::type_name::<Self>())
            .resizable(true)
            .collapsible(true)
            .bg_alpha(0.7f32)
            .position([0.0, 0.0], imgui::Condition::FirstUseEver)
            .menu_bar(true)
            .build(|| self.render_component(ui, extent));
    }

    /// Renders the implementor as a sub-component not allowing to
    /// change the values.
    fn render_component(&self, ui: &imgui::Ui, extent: Extent);

    /// Renders the implementor as a stand-alone window allowing to
    /// change the values.
    fn render_window_mut(&mut self, ui: &imgui::Ui, extent: Extent) {
        ui.window(std::any::type_name::<Self>())
            .resizable(true)
            .collapsible(true)
            .bg_alpha(0.7f32)
            .position([0.0, 0.0], imgui::Condition::FirstUseEver)
            .menu_bar(true)
            .build(|| self.render_component_mut(ui, extent));
    }

    /// Renders the implementor as a sub-component allowing to change
    /// the values.
    ///
    /// # Note
    ///
    /// If not re-implemented, the default implementation shows the
    /// immutable UI.
    fn render_component_mut(&mut self, ui: &imgui::Ui, extent: Extent) {
        // ui.text("This struct doesn't provide a mutable ui.");
        self.render_component(ui, extent);
    }
}

/// Allows the implementing object to be rendered as an eGUI component.
#[cfg(feature = "egui_backend")]
pub trait EguiPresentable {
    /// Renders the implementor as a stand-alone window not allowing to
    /// change the values.
    fn render_window(&self, context: &egui::Context) {
        egui::Window::new(std::any::type_name::<Self>())
            .show(context, |ui| self.render_component(ui));
    }

    /// Renders the implementor as a sub-component not allowing to
    /// change the values.
    fn render_component(&self, ui: &mut egui::Ui);

    /// Renders the implementor as a stand-alone window allowing to
    /// change the values.
    fn render_window_mut(&mut self, context: &egui::Context) {
        egui::Window::new(std::any::type_name::<Self>())
            .show(context, |ui| self.render_component_mut(ui));
    }

    /// Renders the implementor as a sub-component allowing to change
    /// the values.
    ///
    /// # Note
    ///
    /// If not re-implemented, the default implementation shows the
    /// immutable UI.
    fn render_component_mut(&mut self, ui: &mut egui::Ui) {
        self.render_component(ui);
    }
}