very generic modm:ui:color

src/modm/math/saturation/saturated.hpp

@@ -42,7 +42,7 @@ class Saturated
 	using TP = std::remove_reference_t<T>;
 	using TS = std::conditional_t<std::is_signed_v<T>, T, std::make_signed_t<modm::WideType<TP>>>;
 
-	T value = 0;
+	T value{0};
 private:
 	static constexpr TP min = std::numeric_limits<TP>::min();
 	static constexpr TP max = std::numeric_limits<TP>::max();

src/modm/math/scaling_unsigned.hpp

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2021, Thomas Sommer
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <algorithm>
+
+#include <modm/math/utils/integer_traits.hpp>
+// #include <modm/architecture/interface/assert.hpp>
+
+namespace modm {
+
+/**
+ * @brief 		Unsigned integer with arbitrary digits and scaling value on conversion
+ * 				between instances with different digits.
+ *
+ * @tparam D 	Number of Digits
+ *
+ * @author		Thomas Sommer
+ */
+template<int D>
+class ScalingUnsigned {
+public:
+	static constexpr int Digits = D;
+
+	using T = uint_t<D>::least;
+	static constexpr T min = 0;
+	static constexpr T max = bitmask<D>();
+
+	constexpr ScalingUnsigned() = default;
+
+	// FIXME want both:
+	// COMPTIME: static_assert(value <= max, "value out of range")
+	// RUNTIME: std::min(value, max) or modm_assert(value <= max, ...)
+	constexpr ScalingUnsigned(T value)
+		: value(std::min(value, max)) {
+		// TODO disable via lbuild option
+		// modm_assert_continue_fail_debug(value <= max, "ScalingUnsigned", "constructor", "value out of range");
+	}
+
+	// Construct from bigger or equal ScalingUnsigned
+	template <int E, std::enable_if_t<(D <= E), void*> = nullptr>
+	constexpr ScalingUnsigned(const ScalingUnsigned<E>& other)
+		: value(other.value >> (E - D)) {}
+
+	template <int E, std::enable_if_t<(D <= E), void*> = nullptr>
+	constexpr ScalingUnsigned(ScalingUnsigned<E> &&other)
+		: value(other.value >> (E - D)) {}
+
+	// Construct from smaller ScalingUnsigned
+	template <int E, std::enable_if_t<(D > E), void*> = nullptr>
+	constexpr ScalingUnsigned(const ScalingUnsigned<E>& other)
+		: value(other.value * max / other.max)
+	{}
+
+	template <int E, std::enable_if_t<(D > E), void*> = nullptr>
+	constexpr ScalingUnsigned(ScalingUnsigned<E> &&other)
+		: value(other.value * max / other.max)
+	{}
+
+	/* 	// Faster construction from from single digit
+	constexpr ScalingUnsigned(const ScalingUnsigned<1> &other) : value(other.value ? bitmask<D>() : 0){}
+
+	// constexpr ScalingUnsigned(ScalingUnsigned<1> &&other) : value(other.value ? bitmask<D>() : 0){}
+	constexpr ScalingUnsigned& operator=(const ScalingUnsigned<1> &other) {
+		value = other.value ? bitmask<D>() : 0;
+		return *this;
+	} */
+
+	// Assign ScalingUnsigned with more or equal Digits
+	template <int E, std::enable_if_t<(D <= E), void*> = nullptr>
+	void operator=(const ScalingUnsigned<E>& other) {
+		value = other.value >> (E - D);
+	}
+
+	// Assign ScalingUnsigned with less Digits
+	template <int E, std::enable_if_t<(D > E), void*> = nullptr>
+	void operator=(const ScalingUnsigned<E>& other) {
+		value = other.value * max / other.max;
+	}
+
+	// FIXME want both:
+	// COMPTIME: static_assert(value <= max, "value out of range")
+	// RUNTIME: std::min(value, max) or modm_assert(value <= max, ...)
+	void setValue(T value) {
+		this->value = std::min(value, max);
+		// TODO disable via lbuild option
+		// modm_assert_continue_fail_debug(value <= max, "modm::ScalingUnsigned", "setValue()", "value out of range");
+	}
+
+	T getValue() const
+	{ return value; }
+
+	// operator T&() { return value; }
+	// operator T() const { return value; }
+
+	constexpr auto operator<=>(const ScalingUnsigned<D> &) const = default;
+
+protected:
+	T value{0};
+private:
+	template<int>
+	friend class ScalingUnsigned;
+};
+
+}

src/modm/math/scaling_unsigned.lb

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2021, Thomas Sommer
+#
+# This file is part of the modm project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+# -----------------------------------------------------------------------------
+
+def init(module):
+    module.name = ":math:scaling_unsigned"
+    module.description = """
+# Scaling Unsigned
+
+Unsigned integer with arbitrary digits and scaling value on conversion between
+instances with different digits. F.e. a 2bit scaling unsigned of 0b11 becomes
+0b1111 when converted to a 4bit scaling unsigned.
+
+It's the baseclass to all in modm::color::* but may have wider applications.
+
+"""
+
+def prepare(module, options):
+    module.depends(":utils")
+    return True
+
+def build(env):
+    env.outbasepath = "modm/src/modm/math"
+    env.copy("scaling_unsigned.hpp")

src/modm/ui/color.hpp

@@ -1,8 +1,4 @@
 /*
- * Copyright (c) 2009, Martin Rosekeit
- * Copyright (c) 2009-2013, Fabian Greif
- * Copyright (c) 2012-2013, 2015, Niklas Hauser
- * Copyright (c) 2013, David Hebbeker
  * Copyright (c) 2021, Thomas Sommer
  *
  * This file is part of the modm project.
@@ -12,10 +8,11 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 // ----------------------------------------------------------------------------
+#pragma once
 
+#include "color/gray.hpp"
 #include "color/rgb.hpp"
 #include "color/hsv.hpp"
-#include "color/brightness.hpp"
 
-#include "color/rgb565.hpp"
-#include "color/rgbhtml.hpp"
+#include "color/rgb_html.hpp"
+#include "color/rgb_stacked.hpp"

src/modm/ui/color/color.lb

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 #
-# Copyright (c) 2018, Niklas Hauser
+# Copyright (c) 2021, Thomas Sommer
 #
 # This file is part of the modm project.
 #
@@ -18,11 +18,20 @@ def init(module):
 Color containers and converters in various formats: RGB, HSV, Brightness, Rgb565
 """
 
+
 def prepare(module, options):
-    module.depends(":math:utils")
+    module.depends(
+		":math:utils",
+		":math:scaling_unsigned",
+		":math:saturation"
+	)
     return True
 
+
 def build(env):
     env.outbasepath = "modm/src/modm/ui/color"
-    env.copy(".")
+
+    ignore = ["*pattern*"]
+    env.copy(".", ignore=env.ignore_paths(*ignore))
+
     env.copy("../color.hpp")