Merge pull request #40 from tamirelazar/feat/per-preset-tone-curves

feat: per-preset tone curves via render/art-defaults payload (#32)

Author: tamirelazar

src/app/mod.rs

@@ -537,7 +537,10 @@ pub fn print_mode(
     let background_color = config.background_color.as_ref().and_then(|c| hex_to_rgb(c));
 
     let dither_mode = args.dither_mode().unwrap_or(DitherMode::None);
-    let intensity_mapping = args.intensity_mapping().ok();
+    let intensity_mapping = args
+        .to_render_art_defaults()
+        .ok()
+        .map(|a| a.intensity_mapping);
 
     let mut buffer = FrameBuffer::from_downsampled(
         downsampled.cells(),
@@ -719,7 +722,10 @@ pub fn capture_frames_mode(
         };
 
         let background_color = config.background_color.as_ref().and_then(|c| hex_to_rgb(c));
-        let intensity_mapping = args.intensity_mapping().ok();
+        let intensity_mapping = args
+            .to_render_art_defaults()
+            .ok()
+            .map(|a| a.intensity_mapping);
 
         let opt_aux_frame = if temporal_strength > 0.0 {
             crate::render::downsample::downsample_aux(
@@ -952,7 +958,10 @@ pub fn export_gif_mode(
         };
 
         let background_color = config.background_color.as_ref().and_then(|c| hex_to_rgb(c));
-        let intensity_mapping = args.intensity_mapping().ok();
+        let intensity_mapping = args
+            .to_render_art_defaults()
+            .ok()
+            .map(|a| a.intensity_mapping);
 
         let opt_aux_frame = if temporal_strength > 0.0 {
             crate::render::downsample::downsample_aux(
@@ -1123,7 +1132,10 @@ pub fn export_webm_mode(
         };
 
         let background_color = config.background_color.as_ref().and_then(|c| hex_to_rgb(c));
-        let intensity_mapping = args.intensity_mapping().ok();
+        let intensity_mapping = args
+            .to_render_art_defaults()
+            .ok()
+            .map(|a| a.intensity_mapping);
 
         let opt_aux_frame = if temporal_strength > 0.0 {
             crate::render::downsample::downsample_aux(

src/app/runner.rs

@@ -243,8 +243,9 @@ pub fn run_simulation(
     };
 
     let initial_intensity_mapping = args
-        .intensity_mapping()
-        .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?;
+        .to_render_art_defaults()
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e))?
+        .intensity_mapping;
 
     renderer.set_intensity_mapping(Some(initial_intensity_mapping.clone()));
 

src/cli.rs

@@ -1050,11 +1050,11 @@ pub struct Args {
     #[arg(
         long = "intensity-mapping",
         value_name = "MODE",
-        default_value = intensity_mapping::DEFAULT_TYPE,
-        help = "Intensity-to-color mapping (linear, log, exp, sqrt, square, sigmoid, smoothstep, quantize, perlin, split)"
+        help = "Intensity-to-color mapping (linear, log, exp, sqrt, square, sigmoid, smoothstep, quantize, perlin, split) [default: per-preset, currently log]"
     )]
     /// Intensity mapping mode for non-linear color distribution.
-    pub intensity_mapping: String,
+    /// `None` means "use the per-preset render default" (see `RenderArtDefaults`).
+    pub intensity_mapping: Option<String>,
 
     #[arg(
         long = "intensity-mapping-base",
@@ -1771,11 +1771,20 @@ impl Args {
         }
     }
 
+    /// The intensity-mapping type string, falling back to the historical
+    /// default when the flag is absent. Used by paths that always need a
+    /// concrete mapping (e.g. the pause-logo "sim" passthrough).
+    fn intensity_mapping_str(&self) -> &str {
+        self.intensity_mapping
+            .as_deref()
+            .unwrap_or(intensity_mapping::DEFAULT_TYPE)
+    }
+
     /// Parses the intensity mapping configuration.
     pub fn intensity_mapping(&self) -> Result<crate::render::palette::IntensityMapping, String> {
         use crate::render::palette::{IntensityMapping, MappingFunction};
 
-        match self.intensity_mapping.to_lowercase().as_str() {
+        match self.intensity_mapping_str().to_lowercase().as_str() {
             "linear" => Ok(IntensityMapping::linear()),
             "log" | "logarithmic" => Ok(IntensityMapping::logarithmic(self.intensity_mapping_base)),
             "exp" | "exponential" => Ok(IntensityMapping::exponential(self.intensity_mapping_base)),
@@ -1818,7 +1827,7 @@ impl Args {
             )),
             _ => Err(format!(
                 "Invalid intensity mapping: {}",
-                self.intensity_mapping
+                self.intensity_mapping_str()
             )),
         }
     }
@@ -1950,6 +1959,23 @@ impl Args {
         SimConfig::try_from(self)
     }
 
+    /// Resolves the render-layer art defaults: per-preset defaults overridden
+    /// by explicit intensity-mapping CLI flags. Render counterpart to
+    /// [`Args::to_sim_config`] (spec §5 — render params stay out of `SimConfig`).
+    /// When no preset is set, falls back to `RenderArtDefaults::default()` (log10).
+    pub(crate) fn to_render_art_defaults(
+        &self,
+    ) -> Result<crate::render_art_defaults::RenderArtDefaults, String> {
+        let mut art = match self.preset {
+            Some(preset) => crate::render_art_defaults::RenderArtDefaults::from(preset),
+            None => crate::render_art_defaults::RenderArtDefaults::default(),
+        };
+        if self.intensity_mapping.is_some() {
+            art.intensity_mapping = self.intensity_mapping()?;
+        }
+        Ok(art)
+    }
+
     /// Validates arguments at the CLI boundary.
     ///
     /// Covers terminal/resolution/fps bounds and other CLI-specific options that
@@ -2097,7 +2123,7 @@ impl Default for Args {
             reverse_palette: false,
             invert_palette: false,
             palette_shift: 0.0,
-            intensity_mapping: intensity_mapping::DEFAULT_TYPE.to_string(),
+            intensity_mapping: None,
             intensity_mapping_base: intensity::DEFAULT_LOG_BASE,
             intensity_mapping_gamma: 2.2,
             intensity_mapping_levels: 8,
@@ -2785,4 +2811,42 @@ mod tests {
         );
         assert!(DepositCurve::from_str("bogus").is_err());
     }
+
+    #[test]
+    fn render_art_defaults_uses_preset_default_when_flag_absent() {
+        use crate::render::palette::IntensityMapping;
+        let args = Args {
+            preset: Some(crate::simulation::config::Preset::Vortex),
+            intensity_mapping: None,
+            ..Default::default()
+        };
+        let art = args.to_render_art_defaults().unwrap();
+        // #32: every preset defaults to log10.
+        assert_eq!(art.intensity_mapping, IntensityMapping::logarithmic(10.0));
+    }
+
+    #[test]
+    fn render_art_defaults_cli_flag_overrides_preset() {
+        use crate::render::palette::IntensityMapping;
+        let args = Args {
+            preset: Some(crate::simulation::config::Preset::Vortex),
+            intensity_mapping: Some("linear".to_string()),
+            ..Default::default()
+        };
+        let art = args.to_render_art_defaults().unwrap();
+        assert_eq!(art.intensity_mapping, IntensityMapping::linear());
+    }
+
+    #[test]
+    fn render_art_defaults_none_preset_falls_back_to_default() {
+        use crate::render::palette::IntensityMapping;
+        let args = Args {
+            preset: None,
+            intensity_mapping: None,
+            ..Default::default()
+        };
+        let art = args.to_render_art_defaults().unwrap();
+        // No preset + no flag → RenderArtDefaults::default() == log10.
+        assert_eq!(art.intensity_mapping, IntensityMapping::logarithmic(10.0));
+    }
 }

src/lib.rs

@@ -70,6 +70,8 @@ pub mod overlay;
 pub mod palette_manager;
 /// Rendering logic (ASCII/Unicode, color palettes, dithering).
 pub mod render;
+/// Per-preset render/art-layer defaults.
+pub(crate) mod render_art_defaults;
 /// Core simulation logic (agents, trail map).
 pub mod simulation;
 /// Terminal handling (input, output, raw mode).

src/render_art_defaults.rs

@@ -0,0 +1,98 @@
+//! Per-preset render/art-layer defaults.
+//!
+//! `RenderArtDefaults` is the render-layer counterpart to [`SimConfig`]: it is
+//! resolved from the active [`Preset`] alongside the sim config, carrying render
+//! parameters (currently `intensity_mapping`) that must not pollute the sim layer.
+//! For now every preset uses the historical global default (log10); tasteful
+//! per-preset values land in the showcase-presets issue (#36).
+
+use crate::render::palette::IntensityMapping;
+use crate::simulation::config::Preset;
+
+/// Render-layer art defaults resolved per [`Preset`], emitted alongside
+/// [`crate::simulation::config::SimConfig`]. Keeps render concerns out of the
+/// sim layer (spec §5). Currently carries only `intensity_mapping`; later
+/// render-layer levers extend this struct.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct RenderArtDefaults {
+    /// Brightness→color tone curve. Default = global log10 (historical default).
+    pub intensity_mapping: IntensityMapping,
+}
+
+impl Default for RenderArtDefaults {
+    fn default() -> Self {
+        Self {
+            intensity_mapping: IntensityMapping::logarithmic(10.0),
+        }
+    }
+}
+
+impl From<Preset> for RenderArtDefaults {
+    /// Per-preset render defaults. For #32 every preset uses the historical
+    /// global log10 so output is byte-identical; tasteful per-preset values
+    /// are deferred to the showcase-presets issue (#36).
+    fn from(_preset: Preset) -> Self {
+        Self::default()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::render::palette::IntensityMapping;
+    use crate::simulation::config::Preset;
+
+    #[test]
+    fn default_is_log10() {
+        assert_eq!(
+            RenderArtDefaults::default().intensity_mapping,
+            IntensityMapping::logarithmic(10.0)
+        );
+    }
+
+    #[test]
+    fn every_preset_defaults_to_log10() {
+        // Back-compat invariant for #32: payload is pure plumbing, so every
+        // preset must resolve to today's global default. Per-preset tuning is #36.
+        // NOTE: `Preset::ALL` does not exist in this codebase — list explicitly.
+        let log10 = IntensityMapping::logarithmic(10.0);
+        for preset in [
+            Preset::Network,
+            Preset::Exploratory,
+            Preset::Tendrils,
+            Preset::Organic,
+            Preset::Minimal,
+            Preset::Moss,
+            Preset::Cosmic,
+            Preset::Fire,
+            Preset::Zen,
+            Preset::Storm,
+            Preset::River,
+            Preset::Ethereal,
+            Preset::PetriDish,
+            Preset::Vortex,
+            Preset::Lightning,
+            Preset::Crystal,
+            Preset::ChaosEdge,
+            Preset::Blob,
+            Preset::Worm,
+            Preset::Pulse,
+            Preset::Coral,
+            Preset::Flocking,
+            Preset::Maze,
+            Preset::Ripple,
+            Preset::Vortex36,
+            Preset::Chameleon,
+            Preset::DynamicTendrils,
+            Preset::MorphingCoral,
+            Preset::ReactiveSwarm,
+            Preset::DuelingModulators,
+        ] {
+            assert_eq!(
+                RenderArtDefaults::from(preset).intensity_mapping,
+                log10,
+                "preset {preset:?} must default to log10 in #32"
+            );
+        }
+    }
+}

tests/cli_integration.rs

@@ -65,3 +65,16 @@ fn test_cli_print_mode() {
     let stdout = String::from_utf8_lossy(&output.stdout);
     assert!(!stdout.is_empty());
 }
+
+#[test]
+fn intensity_mapping_absent_is_none_present_is_some() {
+    use clap::Parser;
+    let bare = tslime::cli::Args::parse_from(["tslime"]);
+    assert!(
+        bare.intensity_mapping.is_none(),
+        "bare run must leave flag unset"
+    );
+
+    let explicit = tslime::cli::Args::parse_from(["tslime", "--intensity-mapping", "linear"]);
+    assert_eq!(explicit.intensity_mapping.as_deref(), Some("linear"));
+}