InioX · make-42 · May 1, 2025 · May 1, 2025 · May 1, 2025 · May 1, 2025
diff --git a/README.md b/README.md
@@ -49,7 +49,7 @@
 - **Custom Keywords/Colors:**
      - Define your own custom keywords or colors you would like to be harmonized inside the config file, that you can then use in templates
 - **Palette Customization:**
-     - Customize the contrast and scheme type for the palette
+     - Customize the contrast, lightness and scheme type for the palette
 - **Restart Apps/Change Wallpaper:**
      - Restart supported apps and set the wallpaper on Windows, MacOS, Linux and NetBSD
 

diff --git a/benches/template.rs b/benches/template.rs
@@ -18,7 +18,7 @@ fn parse_template(data: &str) {
 
     let (scheme_dark, scheme_light) = get_schemes(source_color, &None, &None);
     let schemes =
-        get_custom_color_schemes(source_color, scheme_dark, scheme_light, &None, &None, &None);
+        get_custom_color_schemes(source_color, scheme_dark, scheme_light, &None, &None, &None, &None, &None);
     let render_data =
         get_render_data(&schemes, &source_color, &SchemesEnum::Dark, &None, None).unwrap();
 

diff --git a/module.nix b/module.nix
@@ -77,6 +77,8 @@ matugen: {
       --type ${cfg.type} \
       --json ${cfg.jsonFormat} \
       --contrast ${lib.strings.floatToString cfg.contrast} \
+      --lightness-dark ${lib.strings.floatToString cfg.lightness_dark} \
+      --lightness-light ${lib.strings.floatToString cfg.lightness_light} \
       --quiet \

8000
       > $out/theme.json
   '');
@@ -189,6 +191,22 @@ in {
       default = 0;
       example = "0.2";   
     };
+
+    lightness_dark = lib.mkOption {
+      description = "Value from -∞ to 1. -∞ represents minimum lightness, 0 represents standard (i.e. the design as spec'd), and 1 represents maximum lightness. For dark schemes, if the considered lightnesses are between 0 and 1 then this applies an affine transformation to the lightness by keeping the value for 1 at 1 and setting the value for 0 to the lightness argument and then clamping the result";
+      type = lib.types.addCheck lib.types.number (lightness_dark: lightness_dark <= 1);
+      default = 0;
+      example = "0.2";
+
+      check = lightness_light: lightness_light >= -1;
+    };
+
+    lightness_light = lib.mkOption {
+      description = "Value from -1 to +∞. -1 represents minimum lightness, 0 represents standard (i.e. the design as spec'd), and +∞ represents maximum lightness. For light schemes, if the considered lightnesses are between 0 and 1 then this applies an affine transformation to the lightness by keeping the value for 0 at 0 and setting the value for 1 to (1 + the lightness argument) and then clamping the result";
+      type = lib.types.addCheck lib.types.number (lightness_light: lightness_light >= -1);
+      default = 0;
+      example = "0.2";
+    };
 
     config = lib.mkOption {
       description = "Add things to the config not covered by other options.";

diff --git a/src/color/color.rs b/src/color/color.rs
@@ -177,6 +177,26 @@ pub fn generate_dynamic_scheme(
     }
 }
 
+pub fn adjust_color_lightness_dark(
+    color: Argb,
+    lightness_level_dark: &Option<f64>,
+) -> Argb {
+    // If lightness values were plotted on a graph, the effect of this function is to rotate the line corresponding to the identity function about x = 255 and y = 255 by setting the value at x = 0 to -lightness_level*255 and then clamping the values to between 0 and 255.
+    let pre_lightness_level = ((color.red as f64) + (color.green as f64) + (color.blue as f64))/ 3.0;
+    let adj = (pre_lightness_level / 255.0 * (1.0 - lightness_level_dark.unwrap_or(0.0)) + lightness_level_dark.unwrap_or(0.0)) / pre_lightness_level* 255.0;
+    Argb::new(color.alpha, (color.red as f64 * adj).clamp(0.0, 255.0) as u8, (color.green as f64 * adj).clamp(0.0, 255.0) as u8, (color.blue as f64 * adj).clamp(0.0, 255.0) as u8)
+}
+
+pub fn adjust_color_lightness_light(
+    color: Argb,
+    lightness_level_light: &Option<f64>,
+) -> Argb {
+    // If lightness values were plotted on a graph, the effect of this function is to rotate the line corresponding to the identity function about x = 0 and y = 0 by setting the value at x = 255 to 255+lightness_level*255 and then clamping the values to between 0 and 255.
+    let pre_lightness_level = ((color.red as f64) + (color.green as f64) + (color.blue as f64))/ 3.0;
+    let adj = pre_lightness_level / 255.0 * (1.0 + lightness_level_light.unwrap_or(0.0)) / pre_lightness_level* 255.0;
+    Argb::new(color.alpha, (color.red as f64 * adj).clamp(0.0, 255.0) as u8, (color.green as f64 * adj).clamp(0.0, 255.0) as u8, (color.blue as f64 * adj).clamp(0.0, 255.0) as u8)
+}
+
 pub fn make_custom_color(
     color: CustomColor,
     scheme_type: &Option<SchemeTypes>,

diff --git a/src/gui/init.rs b/src/gui/init.rs
@@ -114,6 +114,16 @@ impl MyApp {
                 &mut self.app.args.contrast.unwrap(),
                 -1.0..=1.0,
             ));
+            ui.label("Lightness (Dark)");
+            ui.add(egui::Slider::new(
+                &mut self.app.args.lightness_dark.unwrap(),
+                -100.0..=1.0,
+            ));
+            ui.label("Lightness (Light)");
+            ui.add(egui::Slider::new(
+                &mut self.app.args.lightness_light.unwrap(),
+                -1.0..=100.0,
+            ));
         });
         ui.label("Scheme type");
         egui::ComboBox::from_label("")

diff --git a/src/main.rs b/src/main.rs
@@ -59,6 +59,8 @@ impl State {
             &config_file.config.custom_colors,
             &args.r#type,
             &args.contrast,
+            &args.lightness_dark,
+            &args.lightness_light,
         );
 
         Self {
@@ -84,6 +86,8 @@ impl State {
             &self.config_file.config.custom_colors,
             &self.args.r#type,
             &self.args.contrast,
+            &self.args.lightness_dark,
+            &self.args.lightness_light,
         );
     }
 
@@ -189,6 +193,8 @@ fn main() -> Result<(), Report> {
         config: None,
         prefix: None,
         contrast: Some(0.0),
+        lightness_dark: Some(0.0),
+        lightness_light: Some(0.0),
         verbose: Some(true),
         quiet: None,
         debug: Some(true),

diff --git a/src/scheme.rs b/src/scheme.rs
@@ -4,7 +4,7 @@ use std::collections::HashMap;
 use material_colors::scheme::Scheme;
 use std::collections::BTreeSet;
 
-use crate::color::color::{generate_dynamic_scheme, make_custom_color, OwnCustomColor};
+use crate::color::color::{generate_dynamic_scheme, adjust_color_lightness_dark, adjust_color_lightness_light, make_custom_color, OwnCustomColor};
 
 #[allow(clippy::enum_variant_names)]
 #[derive(Clone, clap::ValueEnum, Debug, Copy, PartialEq)]
@@ -60,6 +60,8 @@ pub fn get_custom_color_schemes(
     custom_colors: &Option<HashMap<String, OwnCustomColor, std::hash::RandomState>>,
     scheme_type: &Option<SchemeTypes>,
     contrast: &Option<f64>,
+    lightness_dark: &Option<f64>,
+    lightness_light: &Option<f64>,
 ) -> Schemes {
     macro_rules! from_color {
         ($color: expr, $variant: ident) => {
@@ -103,8 +105,8 @@ pub fn get_custom_color_schemes(
     let custom_colors_light = custom_colors.flat_map(|c| from_color!(c, light));
 
     let schemes: Schemes = Schemes {
-        dark: BTreeSet::from_iter(scheme_dark.into_iter().chain(custom_colors_dark)),
-        light: BTreeSet::from_iter(scheme_light.into_iter().chain(custom_colors_light)),
+        dark: BTreeSet::from_iter(scheme_dark.into_iter().chain(custom_colors_dark).map(|(name, color)| (name,adjust_color_lightness_dark(color, lightness_dark)))),
+        light: BTreeSet::from_iter(scheme_light.into_iter().chain(custom_colors_light).map(|(name, color)| (name,adjust_color_lightness_light(color, lightness_light)))),
     };
     schemes
 }

diff --git a/src/util/arguments.rs b/src/util/arguments.rs
@@ -33,6 +33,22 @@ pub struct Cli {
     /// standard (i.e. the design as spec'd), and 1 represents maximum contrast.
     #[arg(long, global = true, allow_negative_numbers = true)]
     pub contrast: Option<f64>,
+
+    /// Value from -∞ to 1. -∞ represents minimum lightness, 0 represents
+    /// standard (i.e. the design as spec'd), and 1 represents maximum lightness.
+    /// For dark schemes, if the considered lightnesses are between 0 and 1 then this applies an affine
+    /// transformation to the lightness by keeping the value for 1 at 1 and setting the
+    /// value for 0 to the lightness argument and then clamping the result
+    #[arg(long, global = true, allow_negative_numbers = true)]
+    pub lightness_dark: Option<f64>,
+
+    /// Value from -1 to +∞. -1 represents minimum lightness, 0 represents
+    /// standard (i.e. the design as spec'd), and +∞ represents maximum lightness.
+    /// For light schemes, if the considered lightnesses are between 0 and 1 then this applies an affine
+    /// transformation to the lightness by keeping the value for 0 at 0 and setting the
+    /// value for 1 to (1 + the lightness argument) and then clamping the result
+    #[arg(long, global = true, allow_negative_numbers = true)]
+    pub lightness_light: Option<f64>,
 
     #[arg(short, long, global = true, action=ArgAction::SetTrue)]
     pub verbose: Option<bool>,