veloren_voxygen/ui/
egui.rs

1use crate::{
2    scene::{DebugShape, DebugShapeId, Scene},
3    session::settings_change::{Graphics, SettingsChange},
4    settings::Settings,
5    window::Window,
6};
7use client::Client;
8use egui::{Context, ViewportId};
9use egui_winit::State as WinitState;
10use voxygen_egui::{EguiAction, EguiDebugInfo, EguiDebugShapeAction, EguiInnerState};
11
12pub struct EguiState {
13    pub winit_state: WinitState,
14    egui_inner_state: EguiInnerState,
15    new_debug_shape_id: Option<u64>,
16}
17
18impl EguiState {
19    pub fn new(window: &Window) -> Self {
20        let egui_ctx = Context::default();
21        let winit_state = WinitState::new(
22            egui_ctx,
23            ViewportId::ROOT,
24            window.window(),
25            Some(window.scale_factor() as f32),
26            None,
27            None,
28        );
29
30        Self {
31            winit_state,
32            egui_inner_state: EguiInnerState::default(),
33            new_debug_shape_id: None,
34        }
35    }
36
37    pub fn maintain(
38        &mut self,
39        client: &mut Client,
40        scene: &mut Scene,
41        window: &winit::window::Window,
42        debug_info: Option<EguiDebugInfo>,
43        settings: &Settings,
44    ) -> Option<SettingsChange> {
45        use crate::render::ExperimentalShader;
46        use strum::IntoEnumIterator;
47        let experimental_shaders = ExperimentalShader::iter()
48            .map(|s| {
49                (
50                    s.to_string(),
51                    settings
52                        .graphics
53                        .render_mode
54                        .experimental_shaders
55                        .contains(&s),
56                )
57            })
58            .collect();
59
60        let egui_actions = voxygen_egui::maintain(
61            &mut self.winit_state,
62            &mut self.egui_inner_state,
63            client,
64            window,
65            debug_info,
66            self.new_debug_shape_id.take(),
67            experimental_shaders,
68        );
69
70        let mut new_render_mode = None;
71
72        egui_actions
73            .actions
74            .into_iter()
75            .for_each(|action| match action {
76                EguiAction::ChatCommand { cmd, args } => {
77                    client.send_command(cmd.keyword().into(), args);
78                },
79                EguiAction::DebugShape(debug_shape_action) => match debug_shape_action {
80                    EguiDebugShapeAction::AddCylinder { height, radius } => {
81                        let shape_id = scene
82                            .debug
83                            .add_shape(DebugShape::Cylinder { height, radius });
84                        self.new_debug_shape_id = Some(shape_id.0);
85                    },
86                    EguiDebugShapeAction::RemoveShape(debug_shape_id) => {
87                        scene.debug.remove_shape(DebugShapeId(debug_shape_id));
88                    },
89                    EguiDebugShapeAction::SetPosAndColor { id, pos, color } => {
90                        let identity_ori = [0.0, 0.0, 0.0, 1.0];
91                        scene
92                            .debug
93                            .set_context(DebugShapeId(id), pos, color, identity_ori);
94                    },
95                },
96                EguiAction::SetExperimentalShader(shader, enabled) => {
97                    if let Ok(shader) = ExperimentalShader::try_from(shader.as_str()) {
98                        let shaders = &mut new_render_mode
99                            .get_or_insert_with(|| settings.graphics.render_mode.clone())
100                            .experimental_shaders;
101
102                        if enabled {
103                            shaders.insert(shader);
104                        } else {
105                            shaders.remove(&shader);
106                        }
107                    }
108                },
109                EguiAction::SetShowDebugVector(enabled) => {
110                    scene.debug_vectors_enabled = enabled;
111                },
112            });
113
114        new_render_mode.map(|rm| SettingsChange::Graphics(Graphics::ChangeRenderMode(Box::new(rm))))
115    }
116}