onedrop_renderer/

config.rs

//! Configuration for the renderer.

use serde::{Deserialize, Serialize};

/// Renderer configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RenderConfig {
    /// Output resolution width
    pub width: u32,

    /// Output resolution height
    pub height: u32,

    /// Texture format
    pub texture_format: TextureFormat,

    /// Enable multisampling
    pub msaa_samples: u32,

    /// Enable VSync
    pub vsync: bool,

    /// Target FPS (0 = unlimited)
    pub target_fps: u32,

    /// Warp-mesh column count (MilkDrop `nMeshSize` analogue). Higher =
    /// smoother per-vertex warp at the cost of CPU eval. MD2 ships
    /// 32 → 192; we default to 48 ("Medium").
    pub mesh_cols: u32,

    /// Warp-mesh row count. MD2 ships 24 → 96; default 36 ("Medium").
    pub mesh_rows: u32,
}

impl Default for RenderConfig {
    fn default() -> Self {
        let MeshSize { cols, rows } = MeshQuality::Medium.size();
        Self {
            width: 1280,
            height: 720,
            texture_format: TextureFormat::Bgra8UnormSrgb,
            msaa_samples: 1,
            vsync: true,
            target_fps: 60,
            mesh_cols: cols,
            mesh_rows: rows,
        }
    }
}

/// MilkDrop-style warp-mesh quality presets.
///
/// MD2's `nMeshSize` config knob hopped between 32×24 (default) and
/// 192×96 (max). We expose four named tiers covering that range plus a
/// `Custom` escape hatch so the UI can show a single dropdown.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum MeshQuality {
    /// 32×24 — MD2 default, fastest. Visible faceting on warp curves.
    Low,
    /// 48×36 — sweet spot for modern hardware.
    Medium,
    /// 64×48 — smooth warps, 4× the eval cost of Low.
    High,
    /// 96×72 — near-max quality, 9× Low.
    Ultra,
}

/// Concrete `cols × rows` dimensions resolved from a [`MeshQuality`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MeshSize {
    pub cols: u32,
    pub rows: u32,
}

impl MeshQuality {
    /// Resolve to concrete mesh dimensions. Aspect ratio is roughly 4:3
    /// to match MD2's reference shipping ratios.
    pub fn size(self) -> MeshSize {
        match self {
            MeshQuality::Low => MeshSize { cols: 32, rows: 24 },
            MeshQuality::Medium => MeshSize { cols: 48, rows: 36 },
            MeshQuality::High => MeshSize { cols: 64, rows: 48 },
            MeshQuality::Ultra => MeshSize { cols: 96, rows: 72 },
        }
    }

    /// Best-fit quality name for an arbitrary `cols × rows`. Returns
    /// `None` if the dimensions don't match a preset — the caller can
    /// label this as "Custom" in the UI.
    pub fn from_size(cols: u32, rows: u32) -> Option<Self> {
        for q in [
            MeshQuality::Low,
            MeshQuality::Medium,
            MeshQuality::High,
            MeshQuality::Ultra,
        ] {
            let s = q.size();
            if s.cols == cols && s.rows == rows {
                return Some(q);
            }
        }
        None
    }

    /// Human-readable label used by the GUI's options panel.
    pub fn label(self) -> &'static str {
        match self {
            MeshQuality::Low => "Low (32×24)",
            MeshQuality::Medium => "Medium (48×36)",
            MeshQuality::High => "High (64×48)",
            MeshQuality::Ultra => "Ultra (96×72)",
        }
    }
}

/// Texture format options.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TextureFormat {
    Bgra8UnormSrgb,
    Rgba8UnormSrgb,
    Bgra8Unorm,
    Rgba8Unorm,
}

impl TextureFormat {
    /// Convert to wgpu texture format.
    pub fn to_wgpu(&self) -> wgpu::TextureFormat {
        match self {
            TextureFormat::Bgra8UnormSrgb => wgpu::TextureFormat::Bgra8UnormSrgb,
            TextureFormat::Rgba8UnormSrgb => wgpu::TextureFormat::Rgba8UnormSrgb,
            TextureFormat::Bgra8Unorm => wgpu::TextureFormat::Bgra8Unorm,
            TextureFormat::Rgba8Unorm => wgpu::TextureFormat::Rgba8Unorm,
        }
    }
}

/// Render state containing dynamic parameters.
#[derive(Debug, Clone, Copy)]
pub struct RenderState {
    /// Current time in seconds
    pub time: f32,

    /// Current frame number
    pub frame: u32,

    /// MD2 `progress` — `[0, 1]` position within the current preset's
    /// display window. `0.0` at preset load, ramps to `1.0` just
    /// before the next hard cut. Presets read it for once-per-display
    /// effects (slow fade-ins, build-ups before the next cut, intro
    /// flashes). Forwarded into the comp/warp `uniforms.progress` field
    /// each frame so user shaders see the canonical MD2 value.
    pub progress: f32,

    /// Audio levels (bass, mid, treble)
    pub audio: AudioLevels,

    /// Motion parameters
    pub motion: MotionParams,

    /// Wave parameters
    pub wave: WaveParams,

    /// Frame-buffer decay multiplier applied during the warp pass.
    /// Typical Milkdrop range: ~0.5 (very fast fade) to 1.0 (no fade).
    pub decay: f32,

    /// Display-time brightness multiplier applied in the comp pass
    /// (`f_gamma_adj` in the MD2 spec). MilkDrop default is 2.0; not a true
    /// gamma exponent — a flat multiplier.
    pub gamma_adj: f32,

    /// MilkDrop's `f_video_echo_zoom`. Scales the UV around 0.5 before
    /// sampling the previous frame for the comp pass's echo blend.
    /// `1.0` = same scale as current (passthrough sample).
    pub echo_zoom: f32,
    /// MilkDrop's `f_video_echo_alpha`. Mix weight between current frame
    /// (0.0) and echoed previous frame (1.0). Default `0.0` → echo
    /// off entirely.
    pub echo_alpha: f32,
    /// MilkDrop's `n_video_echo_orientation`. 0 = no flip, 1 = flip X,
    /// 2 = flip Y, 3 = flip both.
    pub echo_orient: u32,

    /// MilkDrop's `b_red_blue_stereo`. When true the comp pass produces an
    /// anaglyph red/cyan split — display-only, never enters the feedback
    /// loop. Typically set once at preset load, but per-frame eqs may
    /// flip it (mirrors `darken_center` semantics).
    pub red_blue_stereo: bool,

    /// Feedback filter toggles (b_invert / b_brighten / etc.).
    pub feedback: FeedbackParams,

    /// Outer + inner border draws. The renderer trims the frame edges
    /// into two coloured rings; both contribute to the feedback loop so
    /// a high-decay preset trails them inward.
    pub borders: BorderParams,

    /// Motion-vector grid. A `n_x × n_y` grid of short line segments
    /// drawn into the warp output; over successive frames the feedback
    /// pulls them into trails that visualise the motion field.
    pub motion_vectors: MotionVectorParams,

    /// Snapshot of `q1..q32` after the current frame's per-frame phase.
    /// Forwarded to the comp pass so user comp shaders can read the same
    /// q-channel state per-frame equations wrote.
    pub q_snapshot: [f32; 32],
}

impl Default for RenderState {
    fn default() -> Self {
        Self {
            time: 0.0,
            frame: 0,
            progress: 0.0,
            audio: AudioLevels::default(),
            motion: MotionParams::default(),
            wave: WaveParams::default(),
            decay: 0.98,
            gamma_adj: 2.0,
            echo_zoom: 1.0,
            echo_alpha: 0.0,
            echo_orient: 0,
            red_blue_stereo: false,
            feedback: FeedbackParams::default(),
            borders: BorderParams::default(),
            motion_vectors: MotionVectorParams::default(),
            q_snapshot: [0.0; 32],
        }
    }
}

/// Per-frame feedback filter toggles applied during the warp pass.
///
/// All fields map to MilkDrop 2 boolean flags (`bTexWrap`, `bDarkenCenter`,
/// `bInvert`, `bBrighten`, `bDarken`, `bSolarize`). The renderer packs them
/// into a single `u32` flags uniform.
#[derive(Debug, Clone, Copy, Default)]
pub struct FeedbackParams {
    /// `bTexWrap` — wrap UVs at the borders. When false, UVs are clamped.
    pub wrap: bool,
    /// `bDarkenCenter` — subtle radial darkening toward the screen center.
    pub darken_center: bool,
    /// `bInvert` — `color = 1 - color`.
    pub invert: bool,
    /// `bBrighten` — `color = sqrt(color)` (gamma 0.5).
    pub brighten: bool,
    /// `bDarken` — `color = color²` (gamma 2).
    pub darken: bool,
    /// `bSolarize` — `color = 4·color·(1 - color)`.
    pub solarize: bool,
}

impl FeedbackParams {
    /// Pack the flags into the `u32` bitfield consumed by the warp shader.
    /// Bit layout must match `WARP_FLAG_*` constants in `warp.wgsl`.
    pub fn to_flags(self) -> u32 {
        let mut f = 0u32;
        if self.wrap {
            f |= 1 << 0;
        }
        if self.darken_center {
            f |= 1 << 1;
        }
        if self.invert {
            f |= 1 << 2;
        }
        if self.brighten {
            f |= 1 << 3;
        }
        if self.darken {
            f |= 1 << 4;
        }
        if self.solarize {
            f |= 1 << 5;
        }
        f
    }
}

/// Audio levels.
#[derive(Debug, Clone, Copy)]
pub struct AudioLevels {
    pub bass: f32,
    pub mid: f32,
    pub treb: f32,
    pub bass_att: f32,
    pub mid_att: f32,
    pub treb_att: f32,
}

impl Default for AudioLevels {
    fn default() -> Self {
        Self {
            bass: 0.0,
            mid: 0.0,
            treb: 0.0,
            bass_att: 0.0,
            mid_att: 0.0,
            treb_att: 0.0,
        }
    }
}

/// Motion parameters.
#[derive(Debug, Clone, Copy)]
pub struct MotionParams {
    pub zoom: f32,
    pub rot: f32,
    pub cx: f32,
    pub cy: f32,
    pub dx: f32,
    pub dy: f32,
    pub warp: f32,
    pub sx: f32,
    pub sy: f32,
}

impl Default for MotionParams {
    fn default() -> Self {
        Self {
            zoom: 1.0,
            rot: 0.0,
            cx: 0.5,
            cy: 0.5,
            dx: 0.0,
            dy: 0.0,
            warp: 0.0,
            sx: 1.0,
            sy: 1.0,
        }
    }
}

/// Wave parameters mirrored from a `MilkPreset` every frame.
///
/// Holds the full MD2 `wave_*` cluster: colour, position, mode, the
/// boolean toggles (`b_wave_dots`, `b_wave_thick`, `b_additive_waves`,
/// `b_maximize_wave_color`, `b_mod_wave_alpha_by_volume`), the scalar
/// shaping params (`f_wave_scale`, `f_wave_param`, `f_wave_smoothing`),
/// and the volume-modulation envelope (`f_mod_wave_alpha_start/_end`).
/// Per-frame eqs can flip any of these, so the engine re-reads them
/// every frame — same pattern as [`FeedbackParams`].
#[derive(Debug, Clone, Copy)]
pub struct WaveParams {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
    pub x: f32,
    pub y: f32,
    /// MD2 `nWaveMode`, 0..7. See `WaveformMode::from_i32` for the
    /// mapping; out-of-range values clamp to mode 0 (Circle).
    pub mode: i32,
    /// `f_wave_scale` — amplitude multiplier (typical 0.5..2.0).
    pub scale: f32,
    /// `f_wave_param` — mode-specific shaping (rotation, separation, …).
    pub param: f32,
    /// `f_wave_smoothing` — single-pole IIR α driver applied to samples
    /// CPU-side before upload. 0 = passthrough.
    pub smoothing: f32,
    /// `b_wave_thick` — draw thick segments.
    pub thick: bool,
    /// `b_wave_dots` — draw points instead of segments.
    pub dots: bool,
    /// `b_additive_waves` — use additive blend instead of alpha blend.
    pub additive: bool,
    /// `b_maximize_wave_color` — normalize rgb so max channel = 1.
    pub maximize_color: bool,
    /// `b_mod_wave_alpha_by_volume` — scale alpha by current vol.
    pub mod_alpha_by_volume: bool,
    /// `f_mod_wave_alpha_start` — lower bound of the volume envelope.
    pub mod_alpha_start: f32,
    /// `f_mod_wave_alpha_end` — upper bound of the volume envelope.
    pub mod_alpha_end: f32,
    /// Renderer-side top-vs-bottom stereo split. When `true`, the
    /// waveform pass dispatches twice — left channel on the upper
    /// screen half (`wave_y - 0.25`) and right on the lower
    /// (`wave_y + 0.25`). Independent of any preset flag; surfaced
    /// at engine config level so the player can toggle it without
    /// editing presets.
    pub split_lr: bool,
}

impl Default for WaveParams {
    fn default() -> Self {
        Self {
            r: 1.0,
            g: 1.0,
            b: 1.0,
            a: 1.0,
            x: 0.5,
            y: 0.5,
            mode: 0,
            scale: 1.0,
            param: 0.0,
            smoothing: 0.0,
            thick: false,
            dots: false,
            additive: false,
            maximize_color: false,
            mod_alpha_by_volume: false,
            mod_alpha_start: 0.75,
            mod_alpha_end: 0.95,
            split_lr: false,
        }
    }
}

/// Outer + inner border parameters mirrored from a `MilkPreset` every
/// frame.
///
/// The renderer paints two rectangular rings just after the custom
/// shapes pass, before the blur pyramid, so the rings both feed back
/// next frame (a high-decay preset will trail them inward) and
/// contribute to `GetBlur*`.
///
/// Sizes are in MD2 preset units — a fraction of the **shorter** screen
/// dimension, identical to the MD2 reference renderer. `outer_size` /
/// `inner_size` past `0.5` clamp at half because the rings would
/// otherwise overlap themselves; that's a no-op visually since the
/// inner ring is drawn just inboard of the outer.
#[derive(Debug, Clone, Copy)]
pub struct BorderParams {
    /// Outer ring thickness in `[0, 0.5]` (fraction of the shorter
    /// screen dimension).
    pub outer_size: f32,
    /// Outer ring RGBA. Skipping the pass when `outer_color.a == 0.0`
    /// matches MD2's default behaviour of an invisible outer border.
    pub outer_color: [f32; 4],
    /// Inner ring thickness in `[0, 0.5]`.
    pub inner_size: f32,
    /// Inner ring RGBA. Skipping the pass when `inner_color.a == 0.0`.
    pub inner_color: [f32; 4],
}

impl Default for BorderParams {
    fn default() -> Self {
        // Mirrors `default_preset.rs`: 1 % outer black border (alpha 0
        // → invisible), 1 % inner mid-grey border (alpha 0 → invisible).
        Self {
            outer_size: 0.01,
            outer_color: [0.0, 0.0, 0.0, 0.0],
            inner_size: 0.01,
            inner_color: [0.25, 0.25, 0.25, 0.0],
        }
    }
}

/// Motion-vector grid parameters.
///
/// MD2 draws an `n_x × n_y` grid of short line segments into the warp
/// output every frame; the feedback path then pulls them into trails
/// that visualise the per-pixel motion field. Trails emerge from the
/// warp, the segments themselves are stateless — we just paint them
/// at the same screen-space grid every frame, offset by `(dx, dy)`.
///
/// MD2 caps the grid at `64 × 48` and the renderer enforces the same
/// clamp regardless of what the preset declares.
#[derive(Debug, Clone, Copy)]
pub struct MotionVectorParams {
    /// Grid width in cells, clamped to `[0, 64]`.
    pub grid_x: u32,
    /// Grid height in cells, clamped to `[0, 48]`.
    pub grid_y: u32,
    /// Horizontal grid offset in MD2 preset-UV units `[0, 1]`. Typical
    /// presets animate this so the grid drifts across the screen.
    pub dx: f32,
    /// Vertical grid offset in MD2 preset-UV units `[0, 1]`.
    pub dy: f32,
    /// Segment length as a fraction of horizontal cell spacing.
    pub length: f32,
    /// Segment colour RGBA. `a == 0.0` → no draw.
    pub color: [f32; 4],
}

impl Default for MotionVectorParams {
    fn default() -> Self {
        // Mirrors `default_preset.rs`: 12×9 grid (the MD2 default),
        // length 0.9, fully transparent so the pass is a no-op until
        // a preset enables it.
        Self {
            grid_x: 12,
            grid_y: 9,
            dx: 0.0,
            dy: 0.0,
            length: 0.9,
            color: [1.0, 1.0, 1.0, 0.0],
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn feedback_default_is_all_false() {
        let f = FeedbackParams::default();
        assert_eq!(f.to_flags(), 0);
    }

    #[test]
    fn feedback_each_flag_has_distinct_bit() {
        let cases = [
            (
                FeedbackParams {
                    wrap: true,
                    ..Default::default()
                },
                1u32 << 0,
            ),
            (
                FeedbackParams {
                    darken_center: true,
                    ..Default::default()
                },
                1u32 << 1,
            ),
            (
                FeedbackParams {
                    invert: true,
                    ..Default::default()
                },
                1u32 << 2,
            ),
            (
                FeedbackParams {
                    brighten: true,
                    ..Default::default()
                },
                1u32 << 3,
            ),
            (
                FeedbackParams {
                    darken: true,
                    ..Default::default()
                },
                1u32 << 4,
            ),
            (
                FeedbackParams {
                    solarize: true,
                    ..Default::default()
                },
                1u32 << 5,
            ),
        ];
        for (params, expected) in cases {
            assert_eq!(params.to_flags(), expected, "params = {:?}", params);
        }
    }

    #[test]
    fn feedback_all_flags_combine() {
        let f = FeedbackParams {
            wrap: true,
            darken_center: true,
            invert: true,
            brighten: true,
            darken: true,
            solarize: true,
        };
        assert_eq!(f.to_flags(), 0b111111);
    }
}