Math/Easing

Author: MorganCaron

README.md

@@ -62,6 +62,7 @@
 - [`ChronoLogger`](modules/Log/ChronoLogger.mpp) - RAII timer that logs elapsed time at scope exit
 
 ### 🧮 Math
+- [`Easing`](modules/Math/Easing.mpp) - Collection of easing functions for smooth animation
 - [`Random`](modules/Math/Random.mpp) - Pseudorandom number generation
 - [`Utility`](modules/Math/Utility.mpp) - Floating-point comparison with epsilon tolerance
 

modules/Execution/EventDispatcher.mpp

@@ -21,7 +21,7 @@ export namespace CppUtils::Execution
 			{
 				auto payload = std::make_tuple(args...);
 				for (auto& function : subscriberIt->second)
-					function(&payload);
+					function(std::addressof(payload));
 			}
 		}
 

modules/Math/Easing.mpp

@@ -0,0 +1,115 @@
+export module CppUtils.Math.Easing;
+
+import std;
+
+export namespace CppUtils::Math::Easing
+{
+	[[nodiscard]] constexpr auto inQuad(std::floating_point auto value) noexcept -> auto
+	{
+		return value * value;
+	}
+
+	[[nodiscard]] constexpr auto outQuad(std::floating_point auto value) noexcept -> auto
+	{
+		return value * (2 - value);
+	}
+
+	[[nodiscard]] constexpr auto inOutQuad(std::floating_point auto value) noexcept -> auto
+	{
+		return value < 0.5 ? 2 * value * value : -1 + (4 - 2 * value) * value;
+	}
+
+	[[nodiscard]] constexpr auto inCubic(std::floating_point auto value) noexcept -> auto
+	{
+		return value * value * value;
+	}
+
+	[[nodiscard]] constexpr auto outCubic(std::floating_point auto value) noexcept -> auto
+	{
+		auto temp = value - 1;
+		return temp * temp * temp + 1;
+	}
+
+	[[nodiscard]] constexpr auto inOutCubic(std::floating_point auto value) noexcept -> auto
+	{
+		if (value < 0.5)
+			return 4 * value * value * value;
+
+		auto temp = -2 * value + 2;
+		return 1 - (temp * temp * temp) / 2;
+	}
+
+	[[nodiscard]] constexpr auto inQuart(std::floating_point auto value) noexcept -> auto
+	{
+		return value * value * value * value;
+	}
+
+	[[nodiscard]] constexpr auto outQuart(std::floating_point auto value) noexcept -> auto
+	{
+		auto temp = value - 1;
+		return 1 - temp * temp * temp * temp;
+	}
+
+	[[nodiscard]] constexpr auto inOutQuart(std::floating_point auto value) noexcept -> auto
+	{
+		if (value < 0.5)
+			return 8 * value * value * value * value;
+
+		auto temp = -2 * value + 2;
+		return 1 - (temp * temp * temp * temp) / 2;
+	}
+
+	[[nodiscard]] constexpr auto inQuint(std::floating_point auto value) noexcept -> auto
+	{
+		return value * value * value * value * value;
+	}
+
+	[[nodiscard]] constexpr auto outQuint(std::floating_point auto value) noexcept -> auto
+	{
+		auto temp = value - 1;
+		return 1 + temp * temp * temp * temp * temp;
+	}
+
+	[[nodiscard]] constexpr auto inOutQuint(std::floating_point auto value) noexcept -> auto
+	{
+		if (value < 0.5)
+			return 16 * value * value * value * value * value;
+
+		auto temp = -2 * value + 2;
+		return 1 - (temp * temp * temp * temp * temp) / 2;
+	}
+
+	[[nodiscard]] constexpr auto inSine(std::floating_point auto value) noexcept -> auto
+	{
+		return 1 - std::cos((value * std::numbers::pi_v<decltype(value)>) / 2);
+	}
+
+	[[nodiscard]] constexpr auto outSine(std::floating_point auto value) noexcept -> auto
+	{
+		return std::sin((value * std::numbers::pi_v<decltype(value)>) / 2);
+	}
+
+	[[nodiscard]] constexpr auto inOutSine(std::floating_point auto value) noexcept -> auto
+	{
+		return -(std::cos(std::numbers::pi_v<decltype(value)> * value) - 1) / 2;
+	}
+
+	[[nodiscard]] constexpr auto inCirc(std::floating_point auto value) noexcept -> auto
+	{
+		return 1 - std::sqrt(1 - std::pow(value, 2));
+	}
+
+	[[nodiscard]] constexpr auto outCirc(std::floating_point auto value) noexcept -> auto
+	{
+		return std::sqrt(1 - (value - 1) * (value - 1));
+	}
+
+	[[nodiscard]] constexpr auto inOutCirc(std::floating_point auto value) noexcept -> auto
+	{
+		if (value < 0.5)
+			return (1 - std::sqrt(1 - 4 * value * value)) / 2;
+
+		auto temp = -2 * value + 2;
+		return (std::sqrt(1 - temp * temp) + 1) / 2;
+	}
+}

modules/Math/Math.mpp

@@ -1,6 +1,7 @@
 export module CppUtils.Math;
 
 export import CppUtils.Math.Concept;
+export import CppUtils.Math.Easing;
 export import CppUtils.Math.Endian;
 export import CppUtils.Math.Random;
 export import CppUtils.Math.Utility;

modules/Math/Utility.mpp

@@ -27,6 +27,23 @@ export namespace CppUtils::Math
 	static_assert(absolute(0u) == 0u);
 	static_assert(absolute(1u) == 1u);
 
+	template<std::floating_point Float>
+	[[nodiscard]] inline constexpr auto isEqual(Float lhs, Float rhs, Float epsilon = std::numeric_limits<Float>::epsilon()) noexcept -> bool
+	{
+		auto difference = absolute(lhs - rhs);
+		auto maximum = std::max(absolute(lhs), absolute(rhs));
+		if (maximum >= Float{1})
+			return difference <= epsilon * maximum;
+		else if (maximum > Float{0})
+			return difference / maximum <= epsilon;
+		return true;
+	}
+
+	static_assert(isEqual(0.0, 0.0));
+	static_assert(isEqual(0.1 + 0.2, 0.3));
+	static_assert(not isEqual(0.1 + 0.2, 0.29));
+	static_assert(not isEqual(0.1 + 0.2, 0.31));
+
 	template<Type::Numeric T>
 	[[nodiscard]] inline constexpr auto isBetween(T value, T low, T high) noexcept -> bool
 	{

tests/Terminal/Canvas.mpp

@@ -84,6 +84,30 @@ export namespace CppUtils::UnitTest::Terminal::Canvas
 			canvas.wait();
 		});
 
+		suite.addTest("Multiple Progress Bars", [&] {
+			auto canvas = CppUtils::Terminal::v2::Canvas{CppUtils::Container::Size2{50, 3}};
+			auto& layout = canvas.addWidget(std::make_unique<CppUtils::Terminal::Layout>());
+
+			auto& bar1 = layout.addWidget(std::make_unique<CppUtils::Terminal::ProgressBar>("Bar 1"));
+			auto& bar2 = layout.addWidget(std::make_unique<CppUtils::Terminal::ProgressBar>("Bar 2"));
+			auto& bar3 = layout.addWidget(std::make_unique<CppUtils::Terminal::ProgressBar>("Bar 3"));
+
+			auto scheduler = CppUtils::Thread::Scheduler{};
+			scheduler.schedule([&canvas]() mutable {
+				canvas.close();
+			}, 500ms);
+
+			for (auto i = 0.f; i <= 100.f; i += 2.f)
+			{
+				bar1.setPercent(i);
+				bar2.setPercent(CppUtils::Math::Easing::inQuad(i / 100.f) * 100.f);
+				bar3.setPercent(CppUtils::Math::Easing::outCubic(i / 100.f) * 100.f);
+				std::this_thread::sleep_for(5ms);
+			}
+
+			canvas.wait();
+		});
+
 		suite.addTest("Bouncing ball", [&] {
 			const auto terminalSize = CppUtils::Terminal::getTerminalSize();
 			auto canvasSize = terminalSize;