lemur/src/config.rs

use anyhow::Result;
use clap::{Parser, ValueEnum};
use egui::{Color32, Pos2, Vec2};
use serde::{Deserialize, Serialize};

use crate::{emulator::SimId, persistence::Persistence, window::DisplayMode};
use std::path::PathBuf;

#[derive(Parser)]
#[command(version, long_version = env!("CARGO_PKG_VERSION"))]
pub struct CliArgs {
    /// The path to a virtual boy ROM to run.
    pub rom: Option<PathBuf>,
    /// Start a GDB/LLDB debug server on this port.
    #[arg(short, long)]
    pub debug_port: Option<u16>,
    /// Enable profiling a game
    #[arg(short, long)]
    pub profile: bool,
    /// Open character data window
    #[arg(short, long)]
    pub character_data: bool,
    /// Open bgmap data window
    #[arg(short, long)]
    pub bgmap_data: bool,
    /// Open object data window
    #[arg(short, long)]
    pub object_data: bool,
    /// Open worlds window
    #[arg(long)]
    pub worlds: bool,
    /// Open frame buffers window
    #[arg(short, long)]
    pub frame_buffers: bool,
    /// Open registers window
    #[arg(short, long)]
    pub registers: bool,
    /// Open terminal
    #[arg(short, long)]
    pub terminal: bool,
    /// Watch ROM files for changes, automatically reload
    #[arg(short, long)]
    pub watch: bool,
    /// Automatically open Player 2 for multiplayer
    #[arg(long)]
    pub player2: bool,
    /// Map the first connected controller to Player 2
    #[arg(long)]
    pub player2_controller: bool,
    /// Force the application to render with CPU, rather than GPU.
    #[arg(long)]
    pub wgpu_force_fallback: Option<bool>,
    /// Set a preference for whether to use a low-power or high-performance GPU adapter
    #[arg(long)]
    pub wgpu_power_preference: Option<PowerPreferenceWrapper>,
}

#[derive(ValueEnum, Clone, Copy)]
pub enum PowerPreferenceWrapper {
    Low,
    High,
    None,
}
impl From<PowerPreferenceWrapper> for wgpu::PowerPreference {
    fn from(value: PowerPreferenceWrapper) -> Self {
        match value {
            PowerPreferenceWrapper::Low => wgpu::PowerPreference::LowPower,
            PowerPreferenceWrapper::High => wgpu::PowerPreference::HighPerformance,
            PowerPreferenceWrapper::None => wgpu::PowerPreference::None,
        }
    }
}

pub const COLOR_PRESETS: [[Color32; 2]; 3] = [
    [
        Color32::from_rgb(0xff, 0x00, 0x00),
        Color32::from_rgb(0x00, 0xc6, 0xf0),
    ],
    [
        Color32::from_rgb(0x00, 0xb4, 0x00),
        Color32::from_rgb(0xc8, 0x00, 0xff),
    ],
    [
        Color32::from_rgb(0xb4, 0x9b, 0x00),
        Color32::from_rgb(0x00, 0x00, 0xff),
    ],
];

const fn default_power_preference() -> wgpu::PowerPreference {
    wgpu::PowerPreference::LowPower
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq)]
pub struct AppConfig {
    #[serde(default = "default_power_preference")]
    pub power_preference: wgpu::PowerPreference,
    #[serde(default)]
    pub force_fallback: bool,
}

impl AppConfig {
    pub fn load(persistence: &Persistence) -> Self {
        if let Ok(config) = persistence.load_config(APP_CONFIG_FILENAME) {
            return config;
        }
        Self {
            power_preference: default_power_preference(),
            force_fallback: false,
        }
    }

    pub fn save(&self, persistence: &Persistence) -> Result<()> {
        persistence.save_config(APP_CONFIG_FILENAME, &self)
    }

    pub fn update(&mut self, args: &CliArgs) -> bool {
        let mut updated = false;
        if let Some(pref) = args.wgpu_power_preference {
            self.power_preference = pref.into();
            updated = true;
        }
        if let Some(force_fallback) = args.wgpu_force_fallback {
            self.force_fallback = force_fallback;
            updated = true;
        }
        updated
    }
}

const APP_CONFIG_FILENAME: &str = "config";

const fn default_audio_enabled() -> bool {
    true
}

#[derive(Serialize, Deserialize, Clone, PartialEq, Eq)]
pub struct SimConfig {
    pub display_mode: DisplayMode,
    pub colors: [Color32; 2],
    pub dimensions: Vec2,
    #[serde(default = "default_audio_enabled")]
    pub audio_enabled: bool,
    #[serde(default)]
    pub low_battery: bool,
    #[serde(default)]
    pub watch_rom: bool,
    #[serde(default)]
    pub position: Option<Pos2>,
}

impl SimConfig {
    pub fn load(persistence: &Persistence, sim_id: SimId) -> Self {
        if let Ok(config) = persistence.load_config(sim_config_filename(sim_id)) {
            return config;
        }
        Self {
            display_mode: DisplayMode::Anaglyph,
            colors: COLOR_PRESETS[0],
            dimensions: DisplayMode::Anaglyph.proportions() + Vec2::new(0.0, 22.0),
            audio_enabled: true,
            low_battery: false,
            watch_rom: false,
            position: None,
        }
    }

    pub fn save(&self, persistence: &Persistence, sim_id: SimId) -> Result<()> {
        persistence.save_config(sim_config_filename(sim_id), self)
    }
}

fn sim_config_filename(sim_id: SimId) -> &'static str {
    match sim_id {
        SimId::Player1 => "config_p1",
        SimId::Player2 => "config_p2",
    }
}