compatdb_core/

value.rs

//! The values of the settings that choose between implementations: the
//! Direct3D trees, the wined3d renderer and the Mac driver's OpenGL.

use std::{fmt, str::FromStr};

use crate::{EnvEntry, FieldError, Key};

/// Which implementation of the DXGI family a process loads.
///
/// D3D10, D3D10.1, D3D11 and D3D12 travel together because they all create
/// their device through one `dxgi.dll`, and each implementation's modules only
/// work with its own.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum Dxgi {
    /// DXMT, which a built-in rule gives every program.
    Dxmt,
    /// Wine's own wined3d, what upstream Wine loads, and so what a process
    /// gets when no rule names an implementation.
    Wined3d,
}

impl Dxgi {
    /// Every implementation.
    pub const ALL: &'static [Self] = &[Self::Dxmt, Self::Wined3d];

    /// The wire spelling, which is also the `lib/wine/dxgi/<name>` tree.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Dxmt => "dxmt",
            Self::Wined3d => "wined3d",
        }
    }
}

/// Which D3D9 implementation a process loads. Independent of [`Dxgi`]: neither
/// implementation's `d3d9.dll` touches `dxgi.dll`.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum D3d9 {
    /// mtld3d, which a built-in rule gives every program.
    Mtld3d,
    /// Wine's own wined3d, what upstream Wine loads, and so what a process
    /// gets when no rule names an implementation.
    Wined3d,
}

impl D3d9 {
    /// Every implementation.
    pub const ALL: &'static [Self] = &[Self::Mtld3d, Self::Wined3d];

    /// The wire spelling, which is also the `lib/wine/d3d9/<name>` tree.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Mtld3d => "mtld3d",
            Self::Wined3d => "wined3d",
        }
    }
}

/// Which renderer wined3d, Wine's own Direct3D, draws with in a process.
///
/// One `wined3d.dll` serves every wined3d user in a process (the wined3d trees
/// of [`Dxgi`] and [`D3d9`], D3D8 and `DirectDraw`), and it reads its settings
/// once, so this is a setting of the process, not of a family. It chooses no
/// tree: [`Dxgi`] and [`D3d9`] still decide whether wined3d is used at all.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum Wined3d {
    /// OpenGL, wined3d's own default.
    Gl,
    /// Vulkan, on the bundle's `KosmicKrisp`.
    Vulkan,
}

impl Wined3d {
    /// The environment variable wined3d reads its settings from, a list of
    /// `name=value` options.
    pub const CONFIG_VAR: &'static str = "WINE_D3D_CONFIG";

    /// Every renderer.
    pub const ALL: &'static [Self] = &[Self::Gl, Self::Vulkan];

    /// The wire spelling, which is also the value of wined3d's `renderer`
    /// option.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Gl => "gl",
            Self::Vulkan => "vulkan",
        }
    }
}

/// Which OpenGL the Mac driver gives a process.
///
/// The value is the process's own: ntdll stores it for winemac.drv, which
/// reads it when OpenGL is first initialized, so a program does not take the
/// choice of the program that started it.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum OpenGl {
    /// Mesa's EGL, with Zink on `KosmicKrisp`. Without a GPU `KosmicKrisp`
    /// can use, the process gets no OpenGL.
    Egl,
    /// Apple's OpenGL, upstream Wine's.
    Cgl,
}

impl OpenGl {
    /// Every OpenGL.
    pub const ALL: &'static [Self] = &[Self::Egl, Self::Cgl];

    /// The wire spelling.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Egl => "egl",
            Self::Cgl => "cgl",
        }
    }
}

/// The variables that show the Metal performance HUD, each with the value
/// that `metal_hud` set to `true` gives it.
pub const METAL_HUD_ENV: [(&str, &str); 3] = [
    ("MTL_HUD_ENABLED", "1"),
    ("MTL_HUD_ALIGNMENT", "28"),
    (
        "MTL_HUD_ELEMENTS",
        "device,rosetta,layersize,memory,fps,frameinterval,shaders,frameintervalgraph,gputime,\
         thermal,layerscale,refreshrate,gamemode,client",
    ),
];

/// The environment entries `metal_hud` stands for.
///
/// With `on`, each variable of [`METAL_HUD_ENV`] is set to its value, and
/// otherwise each of them is removed, so a process does not show the HUD
/// that the process which started it asked for.
#[must_use]
pub fn metal_hud_env(on: bool) -> Vec<EnvEntry> {
    METAL_HUD_ENV
        .iter()
        .map(|&(name, value)| EnvEntry::literal(name, if on { value } else { "" }))
        .collect()
}

/// The value of `all` that `name` spells `s`, ASCII-case-insensitively, or
/// the error for the setting `key`, whose spellings without `default` are
/// the ones it lists.
fn parse_word<T: Copy>(
    key: Key,
    all: &[T],
    name: fn(T) -> &'static str,
    s: &str,
) -> Result<T, FieldError> {
    all.iter()
        .copied()
        .find(|value| name(*value).eq_ignore_ascii_case(s))
        .ok_or_else(|| FieldError::BadValue {
            key,
            value: s.to_owned(),
            expected: key
                .values()
                .split_last()
                .map_or(&[], |(_default, words)| words),
        })
}

impl FromStr for Dxgi {
    type Err = FieldError;

    /// The implementation spelled `s`, ASCII-case-insensitively.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        parse_word(Key::Dxgi, Self::ALL, Self::as_str, s)
    }
}

impl FromStr for D3d9 {
    type Err = FieldError;

    /// The implementation spelled `s`, ASCII-case-insensitively.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        parse_word(Key::D3d9, Self::ALL, Self::as_str, s)
    }
}

impl FromStr for Wined3d {
    type Err = FieldError;

    /// The renderer spelled `s`, ASCII-case-insensitively.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        parse_word(Key::Wined3d, Self::ALL, Self::as_str, s)
    }
}

impl FromStr for OpenGl {
    type Err = FieldError;

    /// The OpenGL spelled `s`, ASCII-case-insensitively.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        parse_word(Key::OpenGl, Self::ALL, Self::as_str, s)
    }
}

impl fmt::Display for Dxgi {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

impl fmt::Display for D3d9 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

impl fmt::Display for Wined3d {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

impl fmt::Display for OpenGl {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

#[cfg(test)]
mod tests;