onedrop_gui/

options_ui.rs

//! egui-based Options overlay rendered on top of the MilkDrop visuals.
//!
//! The overlay shows two tabs — **Visuals** and **Engine** — covering
//! the V1 scope of the user-facing settings (see `settings.rs`). The
//! widgets mutate a `Settings` struct in place; this module also
//! returns an [`OptionsActions`] bundle so the caller can apply the
//! diff to the live engine (mesh rebuild, profile toggle, …) and
//! persist it.
//!
//! Toggled by the `Tab` key. While open, `Esc` closes the overlay
//! instead of quitting the app.

use egui_wgpu::{Renderer as EguiRenderer, RendererOptions, ScreenDescriptor};
use egui_winit::State as EguiState;
use onedrop_engine::{AudioInput, BeatDetectionMode};
use winit::event::WindowEvent;
use winit::window::Window;

use crate::settings::Settings;

/// Per-frame data the HUD needs from `main.rs`. Decoupled from
/// [`OptionsUi`] so the panel itself stays stateless about engine
/// internals.
#[derive(Debug, Clone, Default)]
pub struct HudData {
    pub fps: f32,
    pub preset_name: String,
    pub mesh_cols: u32,
    pub mesh_rows: u32,
}

/// Diff produced by drawing one frame of the Options UI.
///
/// `Some(value)` means "the user just changed this — apply it live and
/// save the settings file". `None` means "no change this frame".
/// Aggregated and consumed by `main.rs` after the egui pass returns.
#[derive(Debug, Default, Clone)]
pub struct OptionsActions {
    pub mesh_size: Option<(u32, u32)>,
    pub vsync: Option<bool>,
    pub transition_duration: Option<f32>,
    pub enable_per_frame: Option<bool>,
    pub profile: Option<bool>,
    /// Beat-detection mode the user just picked. Applied via
    /// `engine.set_beat_detection_mode`.
    pub beat_detection_mode: Option<BeatDetectionMode>,
    /// Audio input device the user just picked. `Some(None)` means
    /// "use OS default"; `Some(Some(name))` means a specific cpal
    /// device by name. `None` means no change this frame.
    pub audio_device: Option<Option<String>>,
    /// User clicked the "Apply & restart" button. `main.rs` saves the
    /// settings file and spawns a fresh process with the same CLI args.
    pub request_restart: bool,
}

impl OptionsActions {
    pub fn any(&self) -> bool {
        self.mesh_size.is_some()
            || self.vsync.is_some()
            || self.transition_duration.is_some()
            || self.enable_per_frame.is_some()
            || self.profile.is_some()
            || self.beat_detection_mode.is_some()
            || self.audio_device.is_some()
            || self.request_restart
    }
}

/// Which tab is currently in front.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Tab {
    Visuals,
    Engine,
    Playback,
    Audio,
    Window,
}

/// Stateful egui overlay. Owns the renderer + the winit event
/// translator; the visualiser keeps one of these for the life of the
/// window.
pub struct OptionsUi {
    ctx: egui::Context,
    state: EguiState,
    renderer: EguiRenderer,
    /// Whether the panel is currently drawn. Toggle from main via `Tab`.
    pub visible: bool,
    tab: Tab,
    /// Snapshot of the settings the process booted with. Restart-only
    /// fields (MSAA, texture format) compare against this to decide
    /// whether the "Apply & restart" button should be enabled.
    boot: crate::settings::Settings,
    /// Cached cpal input-device names, populated on demand by the
    /// "Refresh" button on the Audio tab. We don't enumerate every
    /// frame — cpal device enumeration on ALSA is multi-millisecond.
    audio_devices: Vec<String>,
    /// Whether the audio-device cache has been populated at least
    /// once. Drives a lazy first-fill on the user's first visit to
    /// the Audio tab.
    audio_devices_fetched: bool,
}

impl OptionsUi {
    pub fn new(
        window: &Window,
        device: &wgpu::Device,
        surface_format: wgpu::TextureFormat,
        boot_settings: Settings,
    ) -> Self {
        let ctx = egui::Context::default();
        let viewport_id = ctx.viewport_id();
        let state = EguiState::new(
            ctx.clone(),
            viewport_id,
            window,
            Some(window.scale_factor() as f32),
            None,
            None,
        );
        // We composite onto the same non-MSAA surface as the blit pass,
        // so `msaa_samples = 1` (egui treats 0 and 1 as "off").
        let renderer = EguiRenderer::new(
            device,
            surface_format,
            RendererOptions {
                msaa_samples: 1,
                ..Default::default()
            },
        );
        Self {
            ctx,
            state,
            renderer,
            visible: false,
            tab: Tab::Visuals,
            boot: boot_settings,
            audio_devices: Vec::new(),
            audio_devices_fetched: false,
        }
    }

    /// Feed a winit event into egui. Returns true when egui consumed it
    /// (e.g. a click on a slider) — the caller should suppress its own
    /// handling so typing in egui doesn't also flip presets.
    pub fn on_event(&mut self, window: &Window, event: &WindowEvent) -> bool {
        let response = self.state.on_window_event(window, event);
        // Only suppress when the panel is actually drawn AND egui asked
        // for the event. When the overlay is hidden, egui has no
        // widgets to claim input.
        self.visible && response.consumed
    }

    pub fn toggle(&mut self) {
        self.visible = !self.visible;
    }

    /// Run one frame of the UI on top of `surface_view`. Returns the
    /// changes the user just made; the caller applies them to the live
    /// engine. The frame is a no-op when neither the options panel nor
    /// the HUD wants to draw anything.
    #[allow(clippy::too_many_arguments)]
    pub fn render(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        window: &Window,
        encoder: &mut wgpu::CommandEncoder,
        surface_view: &wgpu::TextureView,
        surface_size: (u32, u32),
        settings: &mut Settings,
        hud_data: &HudData,
    ) -> OptionsActions {
        let panel_visible = self.visible;
        let hud_visible = settings.window.hud;
        if !panel_visible && !hud_visible {
            return OptionsActions::default();
        }

        // Lazy first-fill of the audio device cache: enumerate once on
        // the user's first visit to the Audio tab so they don't pay
        // multi-ms cpal-enumeration latency at boot.
        if panel_visible && self.tab == Tab::Audio && !self.audio_devices_fetched {
            self.audio_devices = AudioInput::list_input_devices();
            self.audio_devices_fetched = true;
        }

        let raw_input = self.state.take_egui_input(window);
        let mut actions = OptionsActions::default();

        let visible_ptr = &mut self.visible;
        let tab_ptr = &mut self.tab;
        let actions_ref = &mut actions;
        let boot_ref = &self.boot;
        let audio_devices_ref = &self.audio_devices;
        let mut refresh_audio = false;
        let refresh_audio_ref = &mut refresh_audio;
        // `Context::run` is deprecated in egui 0.34 in favour of `run_ui`,
        // but `run_ui` hands the closure a `&mut Ui` rather than a
        // `&Context`. We want the latter so we can host the options
        // panel inside an `egui::Window`. Stay on `run` until egui
        // exposes a non-deprecated equivalent.
        #[allow(deprecated)]
        let full_output = self.ctx.run(raw_input, |ctx| {
            if panel_visible {
                draw_options_window(
                    ctx,
                    settings,
                    boot_ref,
                    visible_ptr,
                    tab_ptr,
                    actions_ref,
                    audio_devices_ref,
                    refresh_audio_ref,
                );
            }
            if hud_visible {
                draw_hud(ctx, hud_data);
            }
        });

        if refresh_audio {
            self.audio_devices = AudioInput::list_input_devices();
        }

        self.state
            .handle_platform_output(window, full_output.platform_output);

        let primitives = self
            .ctx
            .tessellate(full_output.shapes, full_output.pixels_per_point);

        let screen = ScreenDescriptor {
            size_in_pixels: [surface_size.0, surface_size.1],
            pixels_per_point: full_output.pixels_per_point,
        };

        for (id, delta) in &full_output.textures_delta.set {
            self.renderer.update_texture(device, queue, *id, delta);
        }
        self.renderer
            .update_buffers(device, queue, encoder, &primitives, &screen);

        {
            let pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("egui Pass"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: surface_view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Load,
                        store: wgpu::StoreOp::Store,
                    },
                    depth_slice: None,
                })],
                depth_stencil_attachment: None,
                timestamp_writes: None,
                occlusion_query_set: None,
                multiview_mask: None,
            });
            self.renderer
                .render(&mut pass.forget_lifetime(), &primitives, &screen);
        }

        for id in &full_output.textures_delta.free {
            self.renderer.free_texture(id);
        }

        actions
    }
}

#[allow(clippy::too_many_arguments)]
fn draw_options_window(
    ctx: &egui::Context,
    settings: &mut Settings,
    boot: &Settings,
    visible: &mut bool,
    tab: &mut Tab,
    actions: &mut OptionsActions,
    audio_devices: &[String],
    refresh_audio: &mut bool,
) {
    egui::Window::new("Options")
        .resizable(true)
        .default_width(460.0)
        .default_height(440.0)
        .show(ctx, |ui| {
            ui.horizontal(|ui| {
                ui.selectable_value(tab, Tab::Visuals, "Visuals");
                ui.selectable_value(tab, Tab::Engine, "Engine");
                ui.selectable_value(tab, Tab::Playback, "Playback");
                ui.selectable_value(tab, Tab::Audio, "Audio");
                ui.selectable_value(tab, Tab::Window, "Window");
                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                    if ui.small_button("Close").clicked() {
                        *visible = false;
                    }
                });
            });
            ui.separator();

            match *tab {
                Tab::Visuals => draw_visuals_tab(ui, settings, boot, actions),
                Tab::Engine => draw_engine_tab(ui, settings, actions),
                Tab::Playback => draw_playback_tab(ui, settings, actions),
                Tab::Audio => draw_audio_tab(ui, settings, actions, audio_devices, refresh_audio),
                Tab::Window => draw_window_tab(ui, settings),
            }

            ui.separator();
            ui.small("Tab toggle · Esc closes overlay");
        });
}

/// Translucent corner HUD: FPS + current preset name + mesh size.
/// Drawn even when the options panel is hidden, gated by
/// `Settings::window::hud`.
fn draw_hud(ctx: &egui::Context, data: &HudData) {
    egui::Area::new(egui::Id::new("onedrop-hud"))
        .anchor(egui::Align2::RIGHT_TOP, [-12.0, 12.0])
        .interactable(false)
        .show(ctx, |ui| {
            egui::Frame::default()
                .fill(egui::Color32::from_black_alpha(160))
                .inner_margin(egui::Margin::symmetric(10, 8))
                .corner_radius(egui::CornerRadius::same(4))
                .show(ui, |ui| {
                    ui.label(
                        egui::RichText::new(format!("{:>5.1} fps", data.fps))
                            .color(egui::Color32::WHITE)
                            .monospace(),
                    );
                    ui.label(
                        egui::RichText::new(format!("mesh {}×{}", data.mesh_cols, data.mesh_rows))
                            .color(egui::Color32::LIGHT_GRAY)
                            .monospace()
                            .small(),
                    );
                    if !data.preset_name.is_empty() {
                        ui.label(
                            egui::RichText::new(&data.preset_name)
                                .color(egui::Color32::LIGHT_GRAY)
                                .small(),
                        );
                    }
                });
        });
}

/// Concrete mesh sizes for the named quality presets. Kept in lockstep
/// with `onedrop_renderer::MeshQuality::size`; we duplicate here so the
/// dropdown can list "Custom" without forcing a round-trip through the
/// renderer crate just for labels.
const MESH_PRESETS: &[(&str, u32, u32)] = &[
    ("Low (32×24)", 32, 24),
    ("Medium (48×36)", 48, 36),
    ("High (64×48)", 64, 48),
    ("Ultra (96×72)", 96, 72),
];

fn draw_visuals_tab(
    ui: &mut egui::Ui,
    settings: &mut Settings,
    boot: &Settings,
    actions: &mut OptionsActions,
) {
    let v = &mut settings.visuals;

    ui.heading("Warp mesh");
    ui.label(
        "Density of the per-vertex warp grid. Higher = smoother \
         distortions, scales CPU eval cost roughly linearly.",
    );

    // Resolve the current size to a preset label, or "Custom".
    let current_preset = MESH_PRESETS
        .iter()
        .find(|(_, c, r)| *c == v.mesh_cols && *r == v.mesh_rows)
        .map(|(name, _, _)| *name)
        .unwrap_or("Custom");

    egui::ComboBox::from_label("Quality")
        .selected_text(current_preset)
        .show_ui(ui, |ui| {
            for (name, cols, rows) in MESH_PRESETS {
                let selected = v.mesh_cols == *cols && v.mesh_rows == *rows;
                if ui.selectable_label(selected, *name).clicked() && !selected {
                    v.mesh_cols = *cols;
                    v.mesh_rows = *rows;
                    actions.mesh_size = Some((*cols, *rows));
                }
            }
            let is_custom = MESH_PRESETS
                .iter()
                .all(|(_, c, r)| *c != v.mesh_cols || *r != v.mesh_rows);
            // Visual indicator only — the actual custom values are
            // driven by the sliders below.
            let _ = ui.selectable_label(is_custom, "Custom…");
        });

    ui.add_space(4.0);
    ui.label("Custom override");
    let mut cols_buf = v.mesh_cols;
    let mut rows_buf = v.mesh_rows;
    let resp_cols = ui.add(egui::Slider::new(&mut cols_buf, 8..=192).text("cols"));
    let resp_rows = ui.add(egui::Slider::new(&mut rows_buf, 6..=96).text("rows"));
    // Apply only when the slider drag is released so we don't rebuild
    // the GPU buffer every pixel of slider travel.
    if (resp_cols.drag_stopped() || resp_cols.lost_focus())
        || (resp_rows.drag_stopped() || resp_rows.lost_focus())
    {
        if cols_buf != v.mesh_cols || rows_buf != v.mesh_rows {
            v.mesh_cols = cols_buf;
            v.mesh_rows = rows_buf;
            actions.mesh_size = Some((cols_buf, rows_buf));
        }
    } else {
        // Reflect live drag in the displayed value but don't apply yet.
        v.mesh_cols = cols_buf;
        v.mesh_rows = rows_buf;
    }

    ui.add_space(8.0);
    ui.separator();
    ui.heading("Display");

    // VSync is live-applicable — the surface just needs reconfigure.
    if ui.checkbox(&mut v.vsync, "VSync").changed() {
        actions.vsync = Some(v.vsync);
    }
    ui.small("Applied immediately. Disabling uncaps frame rate.");

    ui.add(egui::Slider::new(&mut v.target_fps, 0..=240).text("FPS cap (0 = unlimited)"));

    // MSAA changes are pipeline-bound: every render pass we own
    // hard-codes `MultisampleState::default()`. A live rebuild would
    // touch ~9 pipelines; the pragmatic V1 path is to persist the new
    // value and relaunch the process so the next boot picks it up.
    ui.add(egui::Slider::new(&mut v.msaa_samples, 1..=8).text("MSAA samples"));
    let msaa_dirty = v.msaa_samples != boot.visuals.msaa_samples;
    ui.horizontal(|ui| {
        ui.small(if msaa_dirty {
            "Pending — restart required to apply."
        } else {
            "Matches running configuration."
        });
        if ui
            .add_enabled(msaa_dirty, egui::Button::new("Apply & restart"))
            .clicked()
        {
            actions.request_restart = true;
        }
    });
}

fn draw_engine_tab(ui: &mut egui::Ui, settings: &mut Settings, actions: &mut OptionsActions) {
    let e = &mut settings.engine;

    ui.heading("Equations");

    if ui
        .checkbox(&mut e.enable_per_frame, "Per-frame equations")
        .changed()
    {
        actions.enable_per_frame = Some(e.enable_per_frame);
    }
    ui.small("Run preset `per_frame` blocks every frame. Off freezes motion.");

    ui.add_space(8.0);
    ui.separator();
    ui.heading("Transitions");

    let resp = ui.add(
        egui::Slider::new(&mut e.transition_duration_s, 0.0..=10.0)
            .text("Crossfade duration (s)")
            .suffix(" s"),
    );
    if resp.drag_stopped() || resp.lost_focus() {
        actions.transition_duration = Some(e.transition_duration_s);
    }
    ui.small("0 = instant cut. MD2 default is 2.7s.");

    ui.add_space(8.0);
    ui.separator();
    ui.heading("Diagnostics");

    if ui.checkbox(&mut e.profile, "Per-phase profiling").changed() {
        actions.profile = Some(e.profile);
    }
    ui.small("Logs wall-clock breakdown of each update phase.");
}

/// Beat-detection mode variants the picker can offer. Mirrors
/// `BeatDetectionMode::next()`'s cycle so the dropdown order is
/// predictable. The `HardCut6` variant has a `special_preset` field
/// that the GUI never edits — we materialise it with an empty string
/// when the user selects it, which `BeatDetector` handles identically.
const BEAT_MODE_NAMES: &[&str] = &[
    "Off", "HardCut1", "HardCut2", "HardCut3", "HardCut4", "HardCut5", "HardCut6",
];

fn mode_from_name(name: &str) -> BeatDetectionMode {
    match name {
        "HardCut1" => BeatDetectionMode::HardCut1,
        "HardCut2" => BeatDetectionMode::HardCut2,
        "HardCut3" => BeatDetectionMode::HardCut3,
        "HardCut4" => BeatDetectionMode::HardCut4,
        "HardCut5" => BeatDetectionMode::HardCut5,
        "HardCut6" => BeatDetectionMode::HardCut6 {
            special_preset: String::new(),
        },
        _ => BeatDetectionMode::Off,
    }
}

fn draw_playback_tab(ui: &mut egui::Ui, settings: &mut Settings, actions: &mut OptionsActions) {
    let p = &mut settings.playback;

    ui.heading("Auto preset change");

    let current = p.beat_detection_mode.clone();
    egui::ComboBox::from_label("Beat-detection mode")
        .selected_text(&current)
        .show_ui(ui, |ui| {
            for name in BEAT_MODE_NAMES {
                if ui.selectable_label(current == *name, *name).clicked() && current != *name {
                    p.beat_detection_mode = (*name).to_string();
                    actions.beat_detection_mode = Some(mode_from_name(name));
                }
            }
        });
    ui.small(
        "Off = manual only. HardCut1–6 trigger preset changes on bass/treb \
         spikes — same modes as the F8 cycle.",
    );

    ui.add_space(8.0);
    ui.separator();
    ui.heading("Preset directories");
    ui.small(
        "Set via `--preset-dir` on the command line. Default search path: \
         ~/.config/onedrop/presets, then test-presets/ in the workspace, \
         then /usr/share/onedrop/presets.",
    );
}

fn draw_audio_tab(
    ui: &mut egui::Ui,
    settings: &mut Settings,
    actions: &mut OptionsActions,
    devices: &[String],
    refresh: &mut bool,
) {
    let a = &mut settings.audio;

    ui.heading("Input device");

    let label = a.input_device.clone().unwrap_or_else(|| "Default".into());
    egui::ComboBox::from_label("Source")
        .selected_text(&label)
        .show_ui(ui, |ui| {
            // The Default entry always sits at the top — clicking it
            // clears any saved device name and falls back to whatever
            // the OS picks at the time of the call.
            let default_selected = a.input_device.is_none();
            if ui
                .selectable_label(default_selected, "Default (OS-picked)")
                .clicked()
                && !default_selected
            {
                a.input_device = None;
                actions.audio_device = Some(None);
            }
            ui.separator();
            for name in devices {
                let selected = a.input_device.as_deref() == Some(name.as_str());
                if ui.selectable_label(selected, name).clicked() && !selected {
                    a.input_device = Some(name.clone());
                    actions.audio_device = Some(Some(name.clone()));
                }
            }
        });

    ui.horizontal(|ui| {
        ui.small(format!("{} device(s) discovered.", devices.len()));
        if ui.small_button("Refresh").clicked() {
            *refresh = true;
        }
    });
    ui.small(
        "Changing the device restarts the cpal stream. If the named \
         device disappears between launches, OneDrop falls back to the \
         OS default and logs a warning.",
    );
}

fn draw_window_tab(ui: &mut egui::Ui, settings: &mut Settings) {
    let w = &mut settings.window;

    ui.heading("HUD overlay");
    ui.checkbox(&mut w.hud, "Show FPS + preset HUD");
    ui.small("Top-right corner overlay. Always live-applied.");

    ui.add_space(8.0);
    ui.separator();
    ui.heading("Mouse cursor");
    ui.add(
        egui::Slider::new(&mut w.cursor_auto_hide_secs, 0.0..=15.0)
            .text("Auto-hide after (s)")
            .suffix(" s"),
    );
    ui.small("0 = always visible. Moving the mouse re-shows it.");
}