From 5b659e1cfbc4b8fbbd2f2bf41dc716929976c77d Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Sat, 28 Aug 2021 01:19:18 -0400
Subject: add per-device configuration

adds input and [in, out] cap for classic mode
adds input cap for power mode
change wrapper/input, now gets useful device names
change (now dev specific) dpi to adjust sensitivity
change y sensitivity to y/x ratio
remove spaced LUTs

grapher and convert do not build
---
 common/accel-power.hpp | 66 +++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 54 insertions(+), 12 deletions(-)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index c8faabb..f727369 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -3,25 +3,67 @@
 #include "rawaccel-base.hpp"
 
 #include <math.h>
+#include <float.h>
 
 namespace rawaccel {
 
-	/// <summary> Struct to hold power (non-additive) acceleration implementation. </summary>
-	struct power {
-		double pre_scale;
-		double exponent;
-		double post_scale;
+	struct power_base {
+		static double base_fn(double x, const accel_args& args)
+		{
+			// f(x) = w(mx)^k
+			return args.weight * pow(args.scale * x, args.exponent_power);
+		}
+	};
 
-		power(const accel_args& args) :
-			pre_scale(args.scale), 
-			exponent(args.exponent),
-			post_scale(args.weight) {}
+	template <bool Gain> struct power;
 
-		double operator()(double speed) const 
+	template <>
+	struct power<LEGACY> : power_base {
+		vec2d cap = { DBL_MAX, DBL_MAX };
+
+		power(const accel_args& args)
 		{
-			// f(x) = (mx)^k
-			return post_scale * pow(speed * pre_scale, exponent);
+			if (args.cap.x > 0) {
+				cap.x = args.cap.x;
+				cap.y = base_fn(cap.x, args);
+			}
 		}
+
+		double operator()(double speed, const accel_args& args) const
+		{
+			if (speed < cap.x) {
+				return base_fn(speed, args);
+			}
+			return cap.y;
+		}
+
+	};
+
+	template <>
+	struct power<GAIN> : power_base {
+		vec2d cap = { DBL_MAX, DBL_MAX };
+		double constant = 0;
+
+		power(const accel_args& args) 
+		{
+			if (args.cap.x > 0) {
+				cap.x = args.cap.x;
+				double output = base_fn(cap.x, args);
+				cap.y = output * (args.exponent_power + 1);
+				constant = -args.exponent_power * output * args.cap.x;
+			}
+		}
+
+		double operator()(double speed, const accel_args& args) const
+		{
+			if (speed < cap.x) {
+				return base_fn(speed, args);
+			}
+			else {
+				return cap.y + constant / speed;
+			}
+		}
+
 	};
 
 }
-- 
cgit v1.2.3


From 6a9272d3af202274dfbced245f0ba20b263fcd8b Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Fri, 3 Sep 2021 18:09:00 -0400
Subject: refactor vec2/math

---
 common/accel-power.hpp | 1 -
 1 file changed, 1 deletion(-)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index f727369..b3e16fb 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -2,7 +2,6 @@
 
 #include "rawaccel-base.hpp"
 
-#include <math.h>
 #include <float.h>
 
 namespace rawaccel {
-- 
cgit v1.2.3


From 7361457ed17670b37279f12fe334e7a9ce7ea34e Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Thu, 16 Sep 2021 01:29:51 -0700
Subject: Get power cap working

---
 common/accel-power.hpp | 122 +++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 114 insertions(+), 8 deletions(-)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index b3e16fb..0b9353d 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -7,10 +7,10 @@
 namespace rawaccel {
 
 	struct power_base {
-		static double base_fn(double x, const accel_args& args)
+		static double base_fn(double x, double scale, const accel_args& args)
 		{
 			// f(x) = w(mx)^k
-			return args.weight * pow(args.scale * x, args.exponent_power);
+			return args.weight * pow(scale * x, args.exponent_power);
 		}
 	};
 
@@ -18,51 +18,157 @@ namespace rawaccel {
 
 	template <>
 	struct power<LEGACY> : power_base {
-		vec2d cap = { DBL_MAX, DBL_MAX };
+		double cap = DBL_MAX;
+		double scale = 0;
 
 		power(const accel_args& args)
 		{
+			// Note that cap types may overwrite this below. 
+			scale = args.scale;
+
+			switch (args.cap_mode){
+			case classic_cap_mode::in:
+				if (args.cap.x > 0)
+				{
+					cap = base_fn(
+							args.cap.x,
+							args.scale,
+							args);
+				}
+				break;
+			case classic_cap_mode::io:
+				if (args.cap.x > 0 &&
+					args.cap.y > 1)
+				{
+					cap = args.cap.y;
+					scale = scale_from_sens_point(
+								args.cap.y,
+								args.cap.x,
+								args.exponent_power);
+				}
+				break;
+			case classic_cap_mode::out:
+			default:
+				if (args.cap.y > 1)
+				{
+					cap = args.cap.y;
+				}
+				break;
+			}
+			/*
 			if (args.cap.x > 0) {
 				cap.x = args.cap.x;
 				cap.y = base_fn(cap.x, args);
 			}
+			*/
 		}
 
 		double operator()(double speed, const accel_args& args) const
 		{
-			if (speed < cap.x) {
-				return base_fn(speed, args);
-			}
-			return cap.y;
+            return minsd(base_fn(speed, scale, args), cap);
 		}
 
+		double static scale_from_sens_point(double sens, double input, double power)
+		{
+			return pow(sens, 1 / power) / input;
+		}
 	};
 
 	template <>
 	struct power<GAIN> : power_base {
 		vec2d cap = { DBL_MAX, DBL_MAX };
 		double constant = 0;
+		double scale = 0;
 
 		power(const accel_args& args) 
 		{
+			/*
 			if (args.cap.x > 0) {
 				cap.x = args.cap.x;
 				double output = base_fn(cap.x, args);
 				cap.y = output * (args.exponent_power + 1);
 				constant = -args.exponent_power * output * args.cap.x;
 			}
+			*/
+
+			// Note that cap types may overwrite this below. 
+			scale = args.scale;
+
+			switch (args.cap_mode) {
+			case classic_cap_mode::in:
+				if (args.cap.x > 0) {
+					cap.x = args.cap.x;
+					cap.y = gain(
+								args.cap.x,
+								args.exponent_power,
+								scale);
+
+					constant = integration_constant(
+								cap.x,
+								cap.y,
+								base_fn(cap.x, scale, args));
+				}
+			case classic_cap_mode::io:
+				if (args.cap.x > 0 &&
+					args.cap.y > 1) {
+					cap.x = args.cap.x;
+					cap.y = args.cap.y;
+					scale = scale_from_gain_point(
+						args.cap.x,
+						args.cap.y,
+						args.exponent_power);
+
+					constant = integration_constant(
+								cap.x,
+								cap.y,
+								base_fn(cap.x, scale, args));
+				}
+			case classic_cap_mode::out:
+			default:
+				if (args.cap.y > 1) {
+					cap.y = args.cap.y;
+					cap.x = gain_inverse(
+								args.cap.y,
+								args.exponent_power,
+								scale);
+
+					constant = integration_constant(
+								cap.x,
+								cap.y,
+								base_fn(cap.x, scale, args));
+				}
+				break;
+			}
 		}
 
 		double operator()(double speed, const accel_args& args) const
 		{
 			if (speed < cap.x) {
-				return base_fn(speed, args);
+				return base_fn(speed, scale, args);
 			}
 			else {
 				return cap.y + constant / speed;
 			}
 		}
 
+		double static gain_inverse(double gain, double power, double scale)
+		{
+			return pow(gain / (power + 1), 1 / power) / scale;
+		}
+		double static gain(double input, double power, double scale)
+		{
+			return (power + 1) * pow(input * scale, power);
+		}
+
+		double static scale_from_gain_point(double input, double gain, double power)
+		{
+			return pow(gain / (power + 1), 1 / power) / input;
+		}
+
+		double static integration_constant(double input, double gain, double output)
+		{
+			return (output - gain) * input;
+		}
 	};
 
 }
-- 
cgit v1.2.3


From 4197e030c5cfeda5592816c8028152d9b7b599e0 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Thu, 16 Sep 2021 13:07:43 -0700
Subject: Remove weight

---
 common/accel-power.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index 0b9353d..3baeda0 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -10,7 +10,7 @@ namespace rawaccel {
 		static double base_fn(double x, double scale, const accel_args& args)
 		{
 			// f(x) = w(mx)^k
-			return args.weight * pow(scale * x, args.exponent_power);
+			return pow(scale * x, args.exponent_power);
 		}
 	};
 
-- 
cgit v1.2.3


From 1fd8881608e4ce6ab21fd78d3ebb42a941cd0e93 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Thu, 16 Sep 2021 18:33:30 -0700
Subject: Add power start from one

---
 common/accel-power.hpp | 77 +++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 63 insertions(+), 14 deletions(-)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index 3baeda0..014acae 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -23,7 +23,7 @@ namespace rawaccel {
 
 		power(const accel_args& args)
 		{
-			// Note that cap types may overwrite this below. 
+			// Note that cap types may overwrite scale below. 
 			scale = args.scale;
 
 			switch (args.cap_mode){
@@ -65,7 +65,12 @@ namespace rawaccel {
 
 		double operator()(double speed, const accel_args& args) const
 		{
-            return minsd(base_fn(speed, scale, args), cap);
+			if (args.powerStartFromOne) {
+				return minsd(maxsd(base_fn(speed, scale, args), 1), cap);
+			}
+			else {
+				return minsd(base_fn(speed, scale, args), cap);
+			}
 		}
 
 		double static scale_from_sens_point(double sens, double input, double power)
@@ -79,6 +84,7 @@ namespace rawaccel {
 		vec2d cap = { DBL_MAX, DBL_MAX };
 		double constant = 0;
 		double scale = 0;
+		vec2d startFromOne{ 0, 0 };
 
 		power(const accel_args& args) 
 		{
@@ -102,12 +108,8 @@ namespace rawaccel {
 								args.cap.x,
 								args.exponent_power,
 								scale);
-
-					constant = integration_constant(
-								cap.x,
-								cap.y,
-								base_fn(cap.x, scale, args));
 				}
+				break;
 			case classic_cap_mode::io:
 				if (args.cap.x > 0 &&
 					args.cap.y > 1) {
@@ -117,12 +119,8 @@ namespace rawaccel {
 						args.cap.x,
 						args.cap.y,
 						args.exponent_power);
-
-					constant = integration_constant(
-								cap.x,
-								cap.y,
-								base_fn(cap.x, scale, args));
 				}
+				break;
 			case classic_cap_mode::out:
 			default:
 				if (args.cap.y > 1) {
@@ -131,26 +129,77 @@ namespace rawaccel {
 								args.cap.y,
 								args.exponent_power,
 								scale);
+				}
+				break;
+			}
+
+			if (args.powerStartFromOne)
+			{
+				startFromOne.x = gain_inverse(
+									1,
+									args.exponent_power,
+									scale);
+				startFromOne.y = -1 * integration_constant(startFromOne.x,
+										1,
+										base_fn(startFromOne.x, scale, args));
+			}
 
+			if (cap.x < DBL_MAX && cap.y < DBL_MAX)
+			{
+				if (args.powerStartFromOne) {
+					constant = integration_constant(
+								cap.x,
+								cap.y,
+								startFromOneOutput(
+									startFromOne,
+									cap.x,
+									scale,
+									args));
+				}
+				else {
 					constant = integration_constant(
 								cap.x,
 								cap.y,
 								base_fn(cap.x, scale, args));
 				}
-				break;
 			}
+
 		}
 
 		double operator()(double speed, const accel_args& args) const
 		{
 			if (speed < cap.x) {
-				return base_fn(speed, scale, args);
+				if (args.powerStartFromOne) {
+					return startFromOneOutput(
+							startFromOne,
+							speed,
+							scale,
+							args);
+				}
+				else {
+					return base_fn(speed, scale, args);
+				}
 			}
 			else {
 				return cap.y + constant / speed;
 			}
 		}
 
+		double static startFromOneOutput(
+						const vec2d& startFromOne,
+						double speed,
+						double scale,
+						const accel_args& args)
+		{
+			if (speed > startFromOne.x) {
+				return base_fn(speed, scale, args) + startFromOne.y / speed;
+			}
+			else
+			{
+				return 1;
+			}
+		}
+
 		double static gain_inverse(double gain, double power, double scale)
 		{
 			return pow(gain / (power + 1), 1 / power) / scale;
-- 
cgit v1.2.3


From 115030165d539fde5440f6232879c7a076dea2ec Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Sat, 18 Sep 2021 05:20:53 -0400
Subject: generalize power start-from-1

starting output is determined by (gain) offset
---
 common/accel-power.hpp | 225 +++++++++++++++++--------------------------------
 1 file changed, 79 insertions(+), 146 deletions(-)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index 014acae..ffbadb0 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -7,10 +7,66 @@
 namespace rawaccel {
 
 	struct power_base {
-		static double base_fn(double x, double scale, const accel_args& args)
+		vec2d offset;
+		double scale;
+		double constant;
+
+		power_base(const accel_args& args)
+		{
+			auto n = args.exponent_power;
+
+			if (args.cap_mode != classic_cap_mode::io) {
+				scale = args.scale;
+			}
+			else if (args.gain) {
+				scale = scale_from_gain_point(args.cap.x, args.cap.y, n);
+			}
+			else {
+				/* 
+				* special case for legacy + io cap mode
+				* 
+				* offset is ignored because of the circular dependency:
+				*     scale -> constant -> offset
+				*/
+				offset = {};
+				constant = 0;
+				scale = scale_from_sens_point(args.cap.x, args.cap.y, n, constant);
+				return;
+			}
+
+			offset.x = gain_inverse(args.output_offset, n, scale);
+			offset.y = args.output_offset;
+			constant = offset.x * offset.y * n / (n + 1);
+		}
+
+		double base_fn(double x, const accel_args& args) const
 		{
-			// f(x) = w(mx)^k
-			return pow(scale * x, args.exponent_power);
+			if (x <= offset.x) {
+				return offset.y;
+			}
+			else {     
+				return pow(scale * x, args.exponent_power) + constant / x;
+			}
+		}
+
+		static double gain(double input, double power, double scale)
+		{
+			return (power + 1) * pow(input * scale, power);
+		}
+
+		static double gain_inverse(double gain, double power, double scale)
+		{
+			return pow(gain / (power + 1), 1 / power) / scale;
+		}
+
+		static double scale_from_gain_point(double input, double gain, double power)
+		{
+			return pow(gain / (power + 1), 1 / power) / input;
+		}
+
+		static double scale_from_sens_point(double input, double sens, double power, double C)
+		{
+			return pow(sens - C / input, 1 / power) / input;
 		}
 	};
 
@@ -19,88 +75,44 @@ namespace rawaccel {
 	template <>
 	struct power<LEGACY> : power_base {
 		double cap = DBL_MAX;
-		double scale = 0;
 
-		power(const accel_args& args)
+		power(const accel_args& args) : 
+			power_base(args)
 		{
-			// Note that cap types may overwrite scale below. 
-			scale = args.scale;
 
 			switch (args.cap_mode){
-			case classic_cap_mode::in:
-				if (args.cap.x > 0)
-				{
-					cap = base_fn(
-							args.cap.x,
-							args.scale,
-							args);
-				}
-				break;
 			case classic_cap_mode::io:
-				if (args.cap.x > 0 &&
-					args.cap.y > 1)
-				{
-					cap = args.cap.y;
-					scale = scale_from_sens_point(
-								args.cap.y,
-								args.cap.x,
-								args.exponent_power);
-				}
+				cap = args.cap.y;
+				break;
+			case classic_cap_mode::in:
+				if (args.cap.x > 0) cap = base_fn(args.cap.x, args);
 				break;
 			case classic_cap_mode::out:
 			default:
-				if (args.cap.y > 1)
-				{
-					cap = args.cap.y;
-				}
+				if (args.cap.y > 0) cap = args.cap.y;
 				break;
 			}
-			/*
-			if (args.cap.x > 0) {
-				cap.x = args.cap.x;
-				cap.y = base_fn(cap.x, args);
-			}
-			*/
 		}
 
 		double operator()(double speed, const accel_args& args) const
 		{
-			if (args.powerStartFromOne) {
-				return minsd(maxsd(base_fn(speed, scale, args), 1), cap);
-			}
-			else {
-				return minsd(base_fn(speed, scale, args), cap);
-			}
+			return minsd(base_fn(speed, args), cap);
 		}
 
-		double static scale_from_sens_point(double sens, double input, double power)
-		{
-			return pow(sens, 1 / power) / input;
-		}
 	};
 
 	template <>
 	struct power<GAIN> : power_base {
 		vec2d cap = { DBL_MAX, DBL_MAX };
-		double constant = 0;
-		double scale = 0;
-		vec2d startFromOne{ 0, 0 };
+		double constant_b;
 
-		power(const accel_args& args) 
+		power(const accel_args& args) :
+			power_base(args)
 		{
-			/*
-			if (args.cap.x > 0) {
-				cap.x = args.cap.x;
-				double output = base_fn(cap.x, args);
-				cap.y = output * (args.exponent_power + 1);
-				constant = -args.exponent_power * output * args.cap.x;
-			}
-			*/
-
-			// Note that cap types may overwrite this below. 
-			scale = args.scale;
-
 			switch (args.cap_mode) {
+			case classic_cap_mode::io:
+				cap = args.cap;
+				break;
 			case classic_cap_mode::in:
 				if (args.cap.x > 0) {
 					cap.x = args.cap.x;
@@ -110,111 +122,32 @@ namespace rawaccel {
 								scale);
 				}
 				break;
-			case classic_cap_mode::io:
-				if (args.cap.x > 0 &&
-					args.cap.y > 1) {
-					cap.x = args.cap.x;
-					cap.y = args.cap.y;
-					scale = scale_from_gain_point(
-						args.cap.x,
-						args.cap.y,
-						args.exponent_power);
-				}
-				break;
 			case classic_cap_mode::out:
 			default:
-				if (args.cap.y > 1) {
-					cap.y = args.cap.y;
+				if (args.cap.y > 0) {
 					cap.x = gain_inverse(
 								args.cap.y,
 								args.exponent_power,
 								scale);
+					cap.y = args.cap.y;
 				}
 				break;
 			}
 
-			if (args.powerStartFromOne)
-			{
-				startFromOne.x = gain_inverse(
-									1,
-									args.exponent_power,
-									scale);
-				startFromOne.y = -1 * integration_constant(startFromOne.x,
-										1,
-										base_fn(startFromOne.x, scale, args));
-			}
-
-			if (cap.x < DBL_MAX && cap.y < DBL_MAX)
-			{
-				if (args.powerStartFromOne) {
-					constant = integration_constant(
-								cap.x,
-								cap.y,
-								startFromOneOutput(
-									startFromOne,
-									cap.x,
-									scale,
-									args));
-				}
-				else {
-					constant = integration_constant(
-								cap.x,
-								cap.y,
-								base_fn(cap.x, scale, args));
-				}
-			}
-
+			constant_b = integration_constant(cap.x, cap.y, base_fn(cap.x, args));
 		}
 
 		double operator()(double speed, const accel_args& args) const
 		{
 			if (speed < cap.x) {
-				if (args.powerStartFromOne) {
-					return startFromOneOutput(
-							startFromOne,
-							speed,
-							scale,
-							args);
-				}
-				else {
-					return base_fn(speed, scale, args);
-				}
+				return base_fn(speed, args);
 			}
 			else {
-				return cap.y + constant / speed;
-			}
-		}
-
-		double static startFromOneOutput(
-						const vec2d& startFromOne,
-						double speed,
-						double scale,
-						const accel_args& args)
-		{
-			if (speed > startFromOne.x) {
-				return base_fn(speed, scale, args) + startFromOne.y / speed;
-			}
-			else
-			{
-				return 1;
+				return cap.y + constant_b / speed;
 			}
 		}
 
-		double static gain_inverse(double gain, double power, double scale)
-		{
-			return pow(gain / (power + 1), 1 / power) / scale;
-		}
-		double static gain(double input, double power, double scale)
-		{
-			return (power + 1) * pow(input * scale, power);
-		}
-
-		double static scale_from_gain_point(double input, double gain, double power)
-		{
-			return pow(gain / (power + 1), 1 / power) / input;
-		}
-
-		double static integration_constant(double input, double gain, double output)
+		static double integration_constant(double input, double gain, double output)
 		{
 			return (output - gain) * input;
 		}
-- 
cgit v1.2.3


From d270a967b606116596114744417a182b3f16218b Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Sat, 18 Sep 2021 05:39:08 -0400
Subject: rename classic_cap_mode

---
 common/accel-power.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index ffbadb0..776986d 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -15,7 +15,7 @@ namespace rawaccel {
 		{
 			auto n = args.exponent_power;
 
-			if (args.cap_mode != classic_cap_mode::io) {
+			if (args.cap_mode != cap_mode::io) {
 				scale = args.scale;
 			}
 			else if (args.gain) {
@@ -81,13 +81,13 @@ namespace rawaccel {
 		{
 
 			switch (args.cap_mode){
-			case classic_cap_mode::io:
+			case cap_mode::io:
 				cap = args.cap.y;
 				break;
-			case classic_cap_mode::in:
+			case cap_mode::in:
 				if (args.cap.x > 0) cap = base_fn(args.cap.x, args);
 				break;
-			case classic_cap_mode::out:
+			case cap_mode::out:
 			default:
 				if (args.cap.y > 0) cap = args.cap.y;
 				break;
@@ -110,10 +110,10 @@ namespace rawaccel {
 			power_base(args)
 		{
 			switch (args.cap_mode) {
-			case classic_cap_mode::io:
+			case cap_mode::io:
 				cap = args.cap;
 				break;
-			case classic_cap_mode::in:
+			case cap_mode::in:
 				if (args.cap.x > 0) {
 					cap.x = args.cap.x;
 					cap.y = gain(
@@ -122,7 +122,7 @@ namespace rawaccel {
 								scale);
 				}
 				break;
-			case classic_cap_mode::out:
+			case cap_mode::out:
 			default:
 				if (args.cap.y > 0) {
 					cap.x = gain_inverse(
-- 
cgit v1.2.3


From affe88490b3467038d576a6b6c3309e3b986c4f0 Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Tue, 21 Sep 2021 02:13:37 -0400
Subject: fix power + gain + input cap + offset edge case

just return offset when cap < offset
---
 common/accel-power.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'common/accel-power.hpp')

diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index 776986d..8e3f417 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -115,6 +115,14 @@ namespace rawaccel {
 				break;
 			case cap_mode::in:
 				if (args.cap.x > 0) {
+
+					if (args.cap.x <= offset.x) {
+						cap.x = 0;
+						cap.y = offset.y;
+						constant_b = 0;
+						return;
+					}
+
 					cap.x = args.cap.x;
 					cap.y = gain(
 								args.cap.x,
-- 
cgit v1.2.3