From 2ce052e54d55e9029eff00f0985e399fa1eb2c1a Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Wed, 29 Jul 2020 17:36:33 -0400
Subject: add sum types

---
 common/external/nillable.h            |  30 +++++
 common/external/tagged-union-single.h | 202 ++++++++++++++++++++++++++++++++++
 2 files changed, 232 insertions(+)
 create mode 100644 common/external/nillable.h
 create mode 100644 common/external/tagged-union-single.h

diff --git a/common/external/nillable.h b/common/external/nillable.h
new file mode 100644
index 0000000..40cf01c
--- /dev/null
+++ b/common/external/nillable.h
@@ -0,0 +1,30 @@
+inline constexpr struct nil_t {} nil;
+
+// Requirements: T is default-constructible and trivially-destructible
+template<typename T>
+struct nillable {
+    bool has_value = false;
+    T value;
+
+    nillable() = default;
+
+    nillable(nil_t) : nillable() {}
+    nillable(const T& v) : has_value(true), value(v) {}
+
+    nillable& operator=(nil_t) {
+        has_value = false;
+        return *this;
+    }
+    nillable& operator=(const T& v) {
+        value = v;
+        has_value = true;
+        return *this;
+    }
+
+    const T* operator->() const { return &value; }
+    T* operator->() { return &value; }
+
+    explicit operator bool() const { return has_value; }
+};
+
+template<typename T> nillable(T)->nillable<T>;
diff --git a/common/external/tagged-union-single.h b/common/external/tagged-union-single.h
new file mode 100644
index 0000000..bcfc1cf
--- /dev/null
+++ b/common/external/tagged-union-single.h
@@ -0,0 +1,202 @@
+#pragma once
+
+using size_t = decltype(alignof(char));
+
+namespace type_traits {
+
+template< class T > struct remove_cv { typedef T type; };
+template< class T > struct remove_cv<const T> { typedef T type; };
+template< class T > struct remove_cv<volatile T> { typedef T type; };
+template< class T > struct remove_cv<const volatile T> { typedef T type; };
+template< class T > using remove_cv_t = typename remove_cv<T>::type;
+
+template< class T > struct remove_reference { typedef T type; };
+template< class T > struct remove_reference<T&> { typedef T type; };
+template< class T > struct remove_reference<T&&> { typedef T type; };
+template< class T > using remove_reference_t = typename remove_reference<T>::type;
+
+template< class T >
+struct remove_cvref {
+    using type = remove_cv_t<remove_reference_t<T>>;
+};
+template< class T > using remove_cvref_t = typename remove_cvref<T>::type;
+
+namespace detail {
+
+template <class T> struct type_identity { using type = T; };
+
+template <class T>
+auto try_add_lvalue_reference(int)->type_identity<T&>;
+template <class T>
+auto try_add_lvalue_reference(...)->type_identity<T>;
+
+template <class T>
+auto try_add_rvalue_reference(int)->type_identity<T&&>;
+template <class T>
+auto try_add_rvalue_reference(...)->type_identity<T>;
+
+} // type_traits::detail
+
+template <class T> struct add_lvalue_reference : decltype(detail::try_add_lvalue_reference<T>(0)) {};
+template< class T > using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+
+template <class T> struct add_rvalue_reference : decltype(detail::try_add_rvalue_reference<T>(0)) {};
+template< class T > using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+
+template <typename T, typename U> inline constexpr bool is_same_v = false;
+template <typename T> inline constexpr bool is_same_v<T, T> = true;
+template <typename T> inline constexpr bool is_void_v = is_same_v<remove_cv_t<T>, void>;
+
+} // type_traits
+
+template<class T> type_traits::add_rvalue_reference_t<T> declval() noexcept;
+
+template <typename T>
+inline constexpr T maxv(const T& a, const T& b) {
+    return (b < a) ? a : b;
+}
+
+template <typename T>
+inline constexpr T minv(const T& a, const T& b) {
+    return (a < b) ? a : b;
+}
+
+template <typename T>
+inline constexpr T clampv(const T& v, const T& lo, const T& hi) {
+    return minv(maxv(v, lo), hi);
+}
+
+template <typename T>
+inline constexpr const T& select_ref(bool pred, const T& t, const T& f) {
+    return pred ? t : f;
+}
+
+template <typename First, typename... Rest>
+inline constexpr size_t max_size_of = maxv(sizeof(First), max_size_of<Rest...>);
+
+template <typename T>
+inline constexpr size_t max_size_of<T> = sizeof(T);
+
+template <typename First, typename... Rest>
+inline constexpr size_t max_align_of = maxv(alignof(First), max_align_of<Rest...>);
+
+template <typename T>
+inline constexpr size_t max_align_of<T> = alignof(T);
+
+namespace detail {
+
+template <typename... Ts>
+struct b1_index_of_impl {
+
+    template <typename...>
+    struct idx {
+        static constexpr size_t value = 0;
+    };
+
+    template <typename T, typename First, typename... Rest>
+    struct idx <T, First, Rest...> {
+        static constexpr size_t value = []() {
+            if constexpr (type_traits::is_same_v<T, First>) {
+                return sizeof...(Ts) - sizeof...(Rest);
+            }
+            return idx<T, Rest...>::value;
+        }();
+    };
+};
+
+} // detail
+
+template <typename T, typename First, typename... Rest>
+inline constexpr int base1_index_of =
+detail::b1_index_of_impl<First, Rest...>::template idx<T, First, Rest...>::value;
+
+/*
+Requirements: Every type is trivially-copyable and is not an array type
+
+Can be initialized to an empty state as if by using
+std::variant<std::monostate, First, Rest...>
+*/
+template <typename First, typename... Rest>
+struct tagged_union {
+
+    // Requirements: The return type of Visitor is default-constructible (or void)
+    // Returns a value-initialized object when in an empty or invalid state
+    template<typename Visitor>
+    inline constexpr auto visit(Visitor vis) {
+        return visit_impl<Visitor, First, Rest...>(vis);
+    }
+
+    template<typename Visitor>
+    inline constexpr auto visit(Visitor vis) const {
+        return visit_impl<Visitor, First, Rest...>(vis);
+    }
+
+    template<typename T>
+    static constexpr int id = base1_index_of<T, First, Rest...>;
+
+    int tag = 0;
+
+    struct storage_t {
+        alignas(max_align_of<First, Rest...>) char bytes[max_size_of<First, Rest...>];
+
+        template <typename T>
+        inline constexpr T& as() {
+            static_assert(id<T> != 0, "tagged_union can not hold T");
+            return reinterpret_cast<T&>(bytes);
+        }
+
+        template <typename T>
+        inline constexpr const T& as() const {
+            static_assert(id<T> != 0, "tagged_union can not hold T");
+            return reinterpret_cast<const T&>(bytes);
+        }
+
+    } storage;
+
+    constexpr tagged_union() noexcept = default;
+
+    template<typename T>
+    inline constexpr tagged_union(const T& val) noexcept {
+        tag = id<T>;
+        storage.template as<T>() = val;
+    }
+
+    template<typename T>
+    inline constexpr tagged_union& operator=(const T& val) noexcept {
+        tag = id<T>;
+        storage.template as<T>() = val;
+        return *this;
+    }
+
+private:
+    template<typename Visitor, typename T1, typename... TRest>
+    inline constexpr auto visit_impl(Visitor vis) const {
+        if (tag == id<T1>) {
+            return vis(storage.template as<T1>());
+        }
+        if constexpr (sizeof...(TRest) > 0) {
+            return visit_impl<Visitor, TRest...>(vis);
+        }
+        else {
+            using ReturnType = decltype(vis(declval<First&>()));
+            if constexpr (!type_traits::is_void_v<ReturnType>) return ReturnType{};
+        }
+    }
+
+    template<typename Visitor, typename T1, typename... TRest>
+    inline constexpr auto visit_impl(Visitor vis) {
+        if (tag == id<T1>) {
+            return vis(storage.template as<T1>());
+        }
+        if constexpr (sizeof...(TRest) > 0) {
+            return visit_impl<Visitor, TRest...>(vis);
+        }
+        else {
+            using ReturnType = decltype(vis(declval<First&>()));
+            if constexpr (!type_traits::is_void_v<ReturnType>) return ReturnType{};
+        }
+    }
+};
+
+template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
+template<class... Ts> overloaded(Ts...)->overloaded<Ts...>;
-- 
cgit v1.2.3


From e8417a29fb2153ea035a757f36bfa300cf8b480d Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Thu, 30 Jul 2020 17:07:35 -0400
Subject: add tweaks for st-refactor

---
 common/Error.hpp              |  10 ----
 common/accel-base.hpp         |  50 ++++++++++++++++
 common/accel-classic.hpp      |  29 ++++++++++
 common/accel-error.hpp        |  11 ++++
 common/accel-linear.hpp       |  18 ++++++
 common/accel-logarithmic.hpp  |  20 +++++++
 common/accel-natural.hpp      |  31 ++++++++++
 common/accel-noaccel.hpp      |  15 +++++
 common/accel-power.hpp        |  33 +++++++++++
 common/accel-sigmoid.hpp      |  32 +++++++++++
 common/accel_classic.cpp      |  21 -------
 common/accel_linear.cpp       |  21 -------
 common/accel_logarithmic.cpp  |  21 -------
 common/accel_natural.cpp      |  23 --------
 common/accel_noaccel.cpp      |  15 -----
 common/accel_power.cpp        |  24 --------
 common/accel_sigmoid.cpp      |  21 -------
 common/accel_types.hpp        | 130 ------------------------------------------
 common/common.vcxitems        |  20 +++----
 common/rawaccel-userspace.hpp |  53 +++++++++--------
 common/rawaccel.hpp           |  73 +++++++++++-------------
 21 files changed, 309 insertions(+), 362 deletions(-)
 delete mode 100644 common/Error.hpp
 create mode 100644 common/accel-base.hpp
 create mode 100644 common/accel-classic.hpp
 create mode 100644 common/accel-error.hpp
 create mode 100644 common/accel-linear.hpp
 create mode 100644 common/accel-logarithmic.hpp
 create mode 100644 common/accel-natural.hpp
 create mode 100644 common/accel-noaccel.hpp
 create mode 100644 common/accel-power.hpp
 create mode 100644 common/accel-sigmoid.hpp
 delete mode 100644 common/accel_classic.cpp
 delete mode 100644 common/accel_linear.cpp
 delete mode 100644 common/accel_logarithmic.cpp
 delete mode 100644 common/accel_natural.cpp
 delete mode 100644 common/accel_noaccel.cpp
 delete mode 100644 common/accel_power.cpp
 delete mode 100644 common/accel_sigmoid.cpp
 delete mode 100644 common/accel_types.hpp

diff --git a/common/Error.hpp b/common/Error.hpp
deleted file mode 100644
index ed87090..0000000
--- a/common/Error.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include <iostream>
-
-
-namespace rawaccel {
-	void error(const char* s) { 
-		throw std::domain_error(s); 
-	}
-}
diff --git a/common/accel-base.hpp b/common/accel-base.hpp
new file mode 100644
index 0000000..ed79bdb
--- /dev/null
+++ b/common/accel-base.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+namespace rawaccel {
+
+    // Error throwing calls std libraries which are unavailable in kernel mode.
+    void error(const char* s);
+
+    using milliseconds = double;
+
+    /// <summary> Struct to hold arguments for an acceleration function. </summary>
+    struct accel_args {
+        double offset = 0;
+        double accel = 0;
+        double limit = 2;
+        double exponent = 2;
+        double midpoint = 0;
+        double power_scale = 1;
+    };
+
+    /// <summary>
+    /// Struct to hold common acceleration curve implementation details.
+    /// </summary>
+    struct accel_base {
+        
+        /// <summary> Generally, the acceleration ramp rate.</summary>
+        double speed_coeff = 0;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="accel_base"/> struct.
+        /// </summary>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        accel_base(accel_args args) {
+            verify(args);
+
+            speed_coeff = args.accel;
+        }
+
+        /// <summary>
+        /// Verifies arguments as valid. Errors if not.
+        /// </summary>
+        /// <param name="args">Arguments to verified.</param>
+        void verify(accel_args args) const {
+            if (args.accel < 0) error("accel can not be negative, use a negative weight to compensate");
+        }
+
+        accel_base() = default;
+    };
+
+}
diff --git a/common/accel-classic.hpp b/common/accel-classic.hpp
new file mode 100644
index 0000000..e2eb494
--- /dev/null
+++ b/common/accel-classic.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <math.h>
+
+#include "accel-base.hpp"
+
+namespace rawaccel {
+
+	/// <summary> Struct to hold "classic" (linear raised to power) acceleration implementation. </summary>
+	struct accel_classic : accel_base {
+		double exponent;
+
+		accel_classic(accel_args args) : accel_base(args) {
+			verify(args);
+
+			exponent = args.exponent - 1;
+		}
+
+		inline double accelerate(double speed) const {
+			//f(x) = (mx)^k
+			return pow(speed_coeff * speed, exponent);
+		}
+
+		void verify(accel_args args) const {
+			if (args.exponent <= 1) error("exponent must be greater than 1");
+		}
+	};
+	
+}
diff --git a/common/accel-error.hpp b/common/accel-error.hpp
new file mode 100644
index 0000000..fa1f999
--- /dev/null
+++ b/common/accel-error.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stdexcept>
+
+namespace rawaccel {
+
+	void error(const char* s) { 
+		throw std::domain_error(s); 
+	}
+
+}
diff --git a/common/accel-linear.hpp b/common/accel-linear.hpp
new file mode 100644
index 0000000..28150a8
--- /dev/null
+++ b/common/accel-linear.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "accel-base.hpp"
+
+namespace rawaccel {
+
+	/// <summary> Struct to hold linear acceleration implementation. </summary>
+	struct accel_linear : accel_base {
+
+		accel_linear(accel_args args) : accel_base(args) {}
+
+		inline double accelerate(double speed) const {
+			//f(x) = mx
+			return speed_coeff * speed;
+		}
+	};
+
+}
diff --git a/common/accel-logarithmic.hpp b/common/accel-logarithmic.hpp
new file mode 100644
index 0000000..b628327
--- /dev/null
+++ b/common/accel-logarithmic.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <math.h>
+
+#include "accel-base.hpp"
+
+namespace rawaccel {
+
+	/// <summary> Struct to hold logarithmic acceleration implementation. </summary>
+	struct accel_logarithmic : accel_base {
+
+		accel_logarithmic(accel_args args) : accel_base(args) {}
+
+		inline double accelerate(double speed) const {
+			//f(x) = log(m*x+1)
+			return log(speed_coeff * speed + 1);
+		}
+	};
+
+}
diff --git a/common/accel-natural.hpp b/common/accel-natural.hpp
new file mode 100644
index 0000000..6ccb193
--- /dev/null
+++ b/common/accel-natural.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <math.h>
+
+#include "accel-base.hpp"
+
+namespace rawaccel {
+
+	/// <summary> Struct to hold "natural" (vanishing difference) acceleration implementation. </summary>
+	struct accel_natural : accel_base {
+		double limit = 1;
+		double midpoint = 0;
+
+		accel_natural(accel_args args) : accel_base(args) {
+			verify(args);
+
+			limit = args.limit - 1;
+			speed_coeff /= limit;
+		}
+
+		inline double accelerate(double speed) const {
+			// f(x) = k(1-e^(-mx))
+			return limit - (limit * exp(-speed_coeff * speed));
+		}
+
+		void verify(accel_args args) const {
+			if (args.limit <= 1) error("limit must be greater than 1");
+		}
+	};
+
+}
diff --git a/common/accel-noaccel.hpp b/common/accel-noaccel.hpp
new file mode 100644
index 0000000..151002a
--- /dev/null
+++ b/common/accel-noaccel.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "accel-base.hpp"
+
+namespace rawaccel {
+
+	/// <summary> Struct to hold acceleration implementation which applies no acceleration. </summary>
+	struct accel_noaccel : accel_base {
+
+		accel_noaccel(accel_args args) : accel_base(args) {}
+
+		inline double accelerate(double) const { return 0; }
+	};
+
+}
diff --git a/common/accel-power.hpp b/common/accel-power.hpp
new file mode 100644
index 0000000..c8b12cd
--- /dev/null
+++ b/common/accel-power.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <math.h>
+
+#include "accel-base.hpp"
+
+namespace rawaccel {
+
+	/// <summary> Struct to hold power (non-additive) acceleration implementation. </summary>
+	struct accel_power : accel_base {
+		double exponent;
+		double offset;
+
+		accel_power(accel_args args) {
+			verify(args);
+
+			speed_coeff = args.power_scale;
+			exponent = args.exponent;
+			offset = args.offset;
+		}
+
+		inline double accelerate(double speed) const {
+			// f(x) = (mx)^k
+			return (offset > 0 && speed < 1) ? 1 : pow(speed * speed_coeff, exponent);
+		}
+
+		void verify(accel_args args) const {
+			if (args.power_scale < 0) error("scale can not be negative");
+			if (args.exponent <= 0) error("exponent must be greater than 0");
+		}
+	};
+
+}
diff --git a/common/accel-sigmoid.hpp b/common/accel-sigmoid.hpp
new file mode 100644
index 0000000..e992e0c
--- /dev/null
+++ b/common/accel-sigmoid.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <math.h>
+
+#include "accel-base.hpp"
+
+namespace rawaccel {
+
+	/// <summary> Struct to hold sigmoid (s-shaped) acceleration implementation. </summary>
+	struct accel_sigmoid : accel_base {
+		double limit = 1;
+		double midpoint = 0;
+
+		accel_sigmoid(accel_args args) : accel_base(args) {
+			verify(args);
+
+			limit = args.limit - 1;
+			midpoint = args.midpoint;
+		}
+
+		inline double accelerate(double speed) const {
+			//f(x) = k/(1+e^(-m(c-x)))
+			return limit / (exp(-speed_coeff * (speed - midpoint)) + 1);
+		}
+
+		void verify(accel_args args) const {
+			if (args.limit <= 1) error("exponent must be greater than 1");
+			if (args.midpoint < 0) error("midpoint must not be negative");
+		}
+	};
+
+}
diff --git a/common/accel_classic.cpp b/common/accel_classic.cpp
deleted file mode 100644
index 323cd3b..0000000
--- a/common/accel_classic.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-#include "accel_types.hpp"
-
-namespace rawaccel {
-	inline accel_classic::accel_classic(accel_args args)
-		: accel_implentation(args) {}
-
-	inline double accel_classic::accelerate(double speed) {
-		//f(x) = (mx)^k
-		return pow(curve_constant_one * speed, curve_constant_two);
-	}
-
-	inline void accel_classic::verify(accel_args args) {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-}
diff --git a/common/accel_linear.cpp b/common/accel_linear.cpp
deleted file mode 100644
index 307e33e..0000000
--- a/common/accel_linear.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-#include "accel_types.hpp"
-
-namespace rawaccel {
-	inline accel_linear::accel_linear(accel_args args)
-		: accel_implentation(args) {}
-
-	inline double accel_linear::accelerate(double speed) {
-		//f(x) = mx
-		return curve_constant_one * speed;
-	}
-
-	inline void accel_linear::verify(accel_args args) {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("limit must be greater than 1");
-	}
-}
diff --git a/common/accel_logarithmic.cpp b/common/accel_logarithmic.cpp
deleted file mode 100644
index 64808a1..0000000
--- a/common/accel_logarithmic.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-#include "accel_types.hpp"
-
-namespace rawaccel {
-	inline accel_logarithmic::accel_logarithmic(accel_args args)
-		: accel_implentation(args) {}
-
-	inline double accel_logarithmic::accelerate(double speed) {
-		//f(x) = log(m*x+1)
-		return log(speed * curve_constant_one + 1);
-	}
-
-	inline void accel_logarithmic::verify(accel_args args) {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-}
diff --git a/common/accel_natural.cpp b/common/accel_natural.cpp
deleted file mode 100644
index c6f14b4..0000000
--- a/common/accel_natural.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-#include "accel_types.hpp"
-
-namespace rawaccel {
-	inline accel_natural::accel_natural(accel_args args)
-		: accel_implentation(args)
-        { curve_constant_one /= curve_constant_two; }
-
-	inline double accel_natural::accelerate(double speed) {
-		// f(x) = k(1-e^(-mx))
-		return curve_constant_two - (curve_constant_two * exp(-curve_constant_one * speed));;
-	}
-
-	inline void accel_natural::verify(accel_args args) {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-}
diff --git a/common/accel_noaccel.cpp b/common/accel_noaccel.cpp
deleted file mode 100644
index fce5dd4..0000000
--- a/common/accel_noaccel.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-#include "accel_types.hpp"
-
-namespace rawaccel {
-	inline accel_noaccel::accel_noaccel(accel_args args)
-		: accel_implentation(args) {}
-
-	inline double accel_noaccel::accelerate(double speed) { return 0; }
-
-	inline void accel_noaccel::verify(accel_args args) { }
-}
diff --git a/common/accel_power.cpp b/common/accel_power.cpp
deleted file mode 100644
index f104554..0000000
--- a/common/accel_power.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-#include "accel_types.hpp"
-
-namespace rawaccel {
-	inline accel_power::accel_power(accel_args args)
-		: accel_implentation(args)
-        { curve_constant_two++; }
-
-	inline double accel_power::accelerate(double speed) {
-		// f(x) = (mx)^k - 1
-		// The subtraction of 1 occurs with later addition of 1 in mind, 
-		// so that the input vector is directly multiplied by (mx)^k (if unweighted)
-		return (offset > 0 && speed < 1) ? 0 : pow(speed * curve_constant_one, curve_constant_two) - 1;
-	}
-
-	inline void accel_power::verify(accel_args args) {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 0) error("exponent must be greater than 0");
-	}
-}
diff --git a/common/accel_sigmoid.cpp b/common/accel_sigmoid.cpp
deleted file mode 100644
index d3b8ab7..0000000
--- a/common/accel_sigmoid.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-#include "accel_types.hpp"
-
-namespace rawaccel {
-	inline accel_sigmoid::accel_sigmoid(accel_args args)
-		: accel_implentation(args) {}
-
-	inline double accel_sigmoid::accelerate(double speed) {
-		//f(x) = k/(1+e^(-m(c-x)))
-		return curve_constant_two / (exp(-curve_constant_one * (speed - curve_constant_three)) + 1);
-	}
-
-	inline void accel_sigmoid::verify(accel_args args) {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-}
diff --git a/common/accel_types.hpp b/common/accel_types.hpp
deleted file mode 100644
index 15f5a50..0000000
--- a/common/accel_types.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-#pragma once
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-
-namespace rawaccel {
-
-// Error throwing calls std libraries which are unavailable in kernel mode.
-#ifdef _KERNEL_MODE
-    inline void error(const char*) {}
-#else
-    void error(const char* s);
-#endif
-
-    using milliseconds = double;
-
-    /// <summary> Struct to hold arguments for an acceleration function. </summary>
-    struct accel_args {
-        milliseconds time_min = 0.4;
-        double offset = 0;
-        double accel = 0;
-        double lim_exp = 2;
-        double midpoint = 0;
-    };
-
-    /// <summary>
-    /// Struct to hold acceleration curve implementation details.
-    /// </summary>
-    /// <typeparam name="T">Type of acceleration.</typeparam>
-    template <typename T>
-    struct accel_implentation {
-        
-        /// <summary> First constant for use in acceleration curves. Generally, the acceleration ramp rate.</summary>
-        double curve_constant_one = 0;
-
-        /// <summary> Second constant for use in acceleration curves. Generally, the limit or exponent in the curve. </summary>
-        double curve_constant_two = 0;
-
-        /// <summary> Third constant for use in acceleration curves. The midpoint in sigmoid mode. </summary>
-        double curve_constant_three = 0;
-
-        /// <summary> The offset past which acceleration is applied. Used in power mode. </summary>
-        double offset = 0;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="accel_implementation{T}"/> struct.
-        /// </summary>
-        /// <param name="args"></param>
-        /// <returns></returns>
-        accel_implentation(accel_args args)
-        {
-            curve_constant_one = args.accel;
-            curve_constant_two = args.lim_exp - 1;
-            curve_constant_three = args.midpoint;
-            offset = args.offset;
-        }
-
-        /// <summary>
-        /// Returns accelerated value of speed as a ratio of magnitude.
-        /// </summary>
-        /// <param name="speed">Mouse speed at which to calculate acceleration.</param>
-        /// <returns>Ratio of accelerated movement magnitude to input movement magnitude.</returns>
-        double accelerate(double speed) { return 0; }
-
-        /// <summary>
-        /// Verifies arguments as valid. Errors if not.
-        /// </summary>
-        /// <param name="args">Arguments to verified.</param>
-        void verify(accel_args args) {
-            if (args.accel < 0) error("accel can not be negative, use a negative weight to compensate");
-            if (args.time_min <= 0) error("min time must be positive");
-        }
-
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <returns></returns>
-        accel_implentation() = default;
-    };
-
-    /// <summary> Struct to hold linear acceleration implementation. </summary>
-    struct accel_linear : accel_implentation<accel_linear> {
-        accel_linear(accel_args args);
-        double accelerate(double speed);
-        void verify(accel_args args);
-    };
-
-    /// <summary> Struct to hold "classic" (linear raised to power) acceleration implementation. </summary>
-    struct accel_classic : accel_implentation<accel_classic> {
-        accel_classic(accel_args args);
-        double accelerate(double speed);
-        void verify(accel_args args);
-    };
-
-    /// <summary> Struct to hold "natural" (vanishing difference) acceleration implementation. </summary>
-    struct accel_natural : accel_implentation<accel_natural> {
-        accel_natural(accel_args args);
-        double accelerate(double speed);
-        void verify(accel_args args);
-    };
-
-    /// <summary> Struct to hold logarithmic acceleration implementation. </summary>
-    struct accel_logarithmic : accel_implentation<accel_logarithmic> {
-        accel_logarithmic(accel_args args);
-        double accelerate(double speed);
-        void verify(accel_args args);
-    };
-
-    /// <summary> Struct to hold sigmoid (s-shaped) acceleration implementation. </summary>
-    struct accel_sigmoid : accel_implentation<accel_sigmoid> {
-        accel_sigmoid(accel_args args);
-        double accelerate(double speed);
-        void verify(accel_args args);
-    };
-
-    /// <summary> Struct to hold power (non-additive) acceleration implementation. </summary>
-    struct accel_power : accel_implentation<accel_power> {
-        accel_power(accel_args args);
-        double accelerate(double speed);
-        void verify(accel_args args);
-    };
-
-    /// <summary> Struct to hold acceleration implementation which applies no acceleration. </summary>
-    struct accel_noaccel : accel_implentation<accel_noaccel> {
-        accel_noaccel(accel_args args);
-        double accelerate(double speed);
-        void verify(accel_args args);
-    };
-
-}
diff --git a/common/common.vcxitems b/common/common.vcxitems
index f33d8e1..d1e8db0 100644
--- a/common/common.vcxitems
+++ b/common/common.vcxitems
@@ -14,20 +14,18 @@
     <ProjectCapability Include="SourceItemsFromImports" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="$(MSBuildThisFileDirectory)accel_types.hpp" />
-    <ClInclude Include="$(MSBuildThisFileDirectory)Error.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-base.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-classic.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-linear.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-logarithmic.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-natural.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-noaccel.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-power.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-sigmoid.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-error.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)rawaccel-userspace.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)rawaccel.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)x64-util.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)vec2.h" />
   </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="$(MSBuildThisFileDirectory)accel_classic.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)accel_linear.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)accel_logarithmic.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)accel_natural.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)accel_noaccel.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)accel_power.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)accel_sigmoid.cpp" />
-  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index 3e8886f..49c0fcd 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -4,6 +4,7 @@
 
 #include "external/clipp.h"
 
+#include <accel-error.hpp>
 #include "rawaccel.hpp"
 
 namespace rawaccel {
@@ -12,12 +13,14 @@ inline constexpr int SYSTEM_ERROR = -1;
 inline constexpr int PARSE_ERROR = 1;
 inline constexpr int INVALID_ARGUMENT = 2;
 
-void error(const char* s) { 
-    throw std::domain_error(s); 
+template<typename Accel, typename StrFirst, typename... StrRest>
+clipp::parameter make_accel_cmd(modifier_args& args, StrFirst&& first_flag, StrRest&&... rest) {
+    return clipp::command(first_flag, rest...)
+        .set(args.acc_fn_args.accel_mode, accel_impl_t::id<Accel>);
 }
 
 mouse_modifier parse(int argc, char** argv) {
-    modifier_args modifier_args{};
+    modifier_args args{};
 
     auto make_opt_vec = [](vec2d& v, auto first_flag, auto... rest) {
         return clipp::option(first_flag, rest...) & (
@@ -38,64 +41,64 @@ mouse_modifier parse(int argc, char** argv) {
     };
 
     // default options
-    auto opt_sens = "sensitivity (default = 1)" % make_opt_vec(modifier_args.sens, "sens");
+    auto opt_sens = "sensitivity (default = 1)" % make_opt_vec(args.sens, "sens");
 
     auto opt_rot = "counter-clockwise rotation (default = 0)" % (
         clipp::option("rotate") &
-        clipp::number("degrees", modifier_args.degrees)
+        clipp::number("degrees", args.degrees)
     );
     
     // mode-independent accel options
     auto opt_weight = "accel multiplier (default = 1)" % 
-        make_opt_vec(modifier_args.acc_fn_args.weight, "weight");
+        make_opt_vec(args.acc_fn_args.weight, "weight");
 
     auto opt_offset = "speed (dots/ms) where accel kicks in (default = 0)" % (
-        clipp::option("offset") & clipp::number("speed", modifier_args.acc_fn_args.acc_args.offset)
+        clipp::option("offset") & clipp::number("speed", args.acc_fn_args.acc_args.offset)
     );
 
     auto opt_cap = "accel scale cap (default = 9)" % 
-        make_opt_vec(modifier_args.acc_fn_args.cap, "cap");
+        make_opt_vec(args.acc_fn_args.cap, "cap");
 
     auto opt_tmin = "minimum time between polls (default = 0.4)" % (
         clipp::option("tmin") &
-        clipp::number("ms", modifier_args.acc_fn_args.acc_args.time_min)
+        clipp::number("ms", args.acc_fn_args.time_min)
     );
 
-    auto accel_var = (clipp::required("accel") & clipp::number("num", modifier_args.acc_fn_args.acc_args.accel)) % "ramp rate";
-    auto limit_var = (clipp::required("limit") & clipp::number("scale", modifier_args.acc_fn_args.acc_args.lim_exp)) % "limit";
+    auto accel_var = (clipp::required("accel") & clipp::number("num", args.acc_fn_args.acc_args.accel)) % "ramp rate";
+    auto limit_var = (clipp::required("limit") & clipp::number("scale", args.acc_fn_args.acc_args.limit)) % "limit";
+    auto exp_var = (clipp::required("exponent") & clipp::number("num", args.acc_fn_args.acc_args.exponent)) % "exponent";
 
     // modes
-    auto noaccel_mode = "no-accel mode" % (
-        clipp::command("off", "noaccel").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_noaccel>)
-    );
+    auto noaccel_mode = "no-accel mode" % make_accel_cmd<accel_noaccel>(args, "off", "noaccel");
+
     auto lin_mode = "linear accel mode:" % (
-        clipp::command("linear").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_linear>),
+        make_accel_cmd<accel_linear>(args, "linear"),
         accel_var
     );
     auto classic_mode = "classic accel mode:" % (
-        clipp::command("classic").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_classic>),
+        make_accel_cmd<accel_classic>(args, "classic"),
         accel_var,
-        (clipp::required("exponent") & clipp::number("num", modifier_args.acc_fn_args.acc_args.lim_exp)) % "exponent"
+        exp_var
     );
     auto nat_mode = "natural accel mode:" % (
-        clipp::command("natural").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_natural>),
+        make_accel_cmd<accel_natural>(args, "natural"),
         accel_var,
         limit_var
     );
     auto log_mode = "logarithmic accel mode:" % (
-        clipp::command("logarithmic").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_logarithmic>),
+        make_accel_cmd<accel_logarithmic>(args, "logarithmic"),
         accel_var
     );
     auto sig_mode = "sigmoid accel mode:" % (
-        clipp::command("sigmoid").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_sigmoid>),
+        make_accel_cmd<accel_sigmoid>(args, "sigmoid"),
         accel_var,
         limit_var,
-        (clipp::required("midpoint") & clipp::number("speed", modifier_args.acc_fn_args.acc_args.midpoint)) % "midpoint"
+        (clipp::required("midpoint") & clipp::number("speed", args.acc_fn_args.acc_args.midpoint)) % "midpoint"
     );
     auto pow_mode = "power accel mode:" % (
-        clipp::command("power").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_power>) >> [&] { modifier_args.acc_fn_args.acc_args.accel = 1; },
-        (clipp::required("exponent") & clipp::number("num", modifier_args.acc_fn_args.acc_args.lim_exp)) % "exponent",
-        (clipp::option("scale") & clipp::number("num", modifier_args.acc_fn_args.acc_args.accel)) % "scale factor"
+        make_accel_cmd<accel_power>(args, "power"),
+        exp_var,
+        (clipp::option("scale") & clipp::number("num", args.acc_fn_args.acc_args.power_scale)) % "scale factor"
     );
 
     auto accel_mode_exclusive = (lin_mode | classic_mode | nat_mode | log_mode | sig_mode | pow_mode);
@@ -119,7 +122,7 @@ mouse_modifier parse(int argc, char** argv) {
         std::exit(0);
     }
 
-    return mouse_modifier(modifier_args);
+    return mouse_modifier(args);
 }
 
 } // rawaccel
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index b480e87..0aeb42d 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -7,13 +7,13 @@
 #include "x64-util.hpp"
 #include "external/tagged-union-single.h"
 
-#include "accel_linear.cpp"
-#include "accel_classic.cpp"
-#include "accel_natural.cpp"
-#include "accel_logarithmic.cpp"
-#include "accel_sigmoid.cpp"
-#include "accel_power.cpp"
-#include "accel_noaccel.cpp"
+#include "accel-linear.hpp"
+#include "accel-classic.hpp"
+#include "accel-natural.hpp"
+#include "accel-logarithmic.hpp"
+#include "accel-sigmoid.hpp"
+#include "accel-power.hpp"
+#include "accel-noaccel.hpp"
 
 namespace rawaccel {
 
@@ -75,11 +75,11 @@ namespace rawaccel {
     };
 
     /// <summary> Tagged union to hold all accel implementations and allow "polymorphism" via a visitor call. </summary>
-    using accel_implementation_t = tagged_union<accel_linear, accel_classic, accel_natural, accel_logarithmic, accel_sigmoid, accel_power, accel_noaccel>;
+    using accel_impl_t = tagged_union<accel_linear, accel_classic, accel_natural, accel_logarithmic, accel_sigmoid, accel_power, accel_noaccel>;
 
     struct accel_fn_args {
-        accel_args acc_args = accel_args{};
-        int accel_mode = 0;
+        accel_args acc_args;
+        int accel_mode = accel_impl_t::id<accel_noaccel>;
         milliseconds time_min = 0.4;
         vec2d weight = { 1, 1 };
         vec2d cap = { 0, 0 };
@@ -100,21 +100,24 @@ namespace rawaccel {
         double speed_offset = 0;
 
         /// <summary> The acceleration implementation (i.e. curve) </summary>
-        accel_implementation_t accel;
+        accel_impl_t accel;
 
         /// <summary> The weight of acceleration applied in {x, y} dimensions. </summary>
         vec2d weight = { 1, 1 };
 
+        /// <summary> The constant added to weighted accel values to get the acceleration scale. </summary>
+        double scale_base = 1;
+
         /// <summary> The object which sets a min and max for the acceleration scale. </summary>
         vec2<accel_scale_clamp> clamp;
 
-        accel_function(accel_fn_args args) {
+        accel_function(accel_fn_args args) : accel_function() {
+            verify(args);
+
             accel.tag = args.accel_mode;
-            accel.visit([&](auto& a){ a = {args.acc_args}; });
+            accel.visit([&](auto& impl){ impl = { args.acc_args }; });
 
-            // Verification is performed by the accel_implementation object
-            // and therefore must occur after the object has been instantiated
-            verify(args.acc_args);
+            if (accel.tag == accel_impl_t::id<accel_power>) scale_base = 0;
 
             time_min = args.time_min;
             speed_offset = args.acc_args.offset;
@@ -124,20 +127,12 @@ namespace rawaccel {
         }
 
         /// <summary>
-        /// Applies mouse acceleration to a given speed, via visitor function to accel_implementation_t
-        /// </summary>
-        /// <param name="speed">Speed from which to determine acceleration</param>
-        /// <returns>Acceleration as a ratio magnitudes, as a double</returns>
-        double apply(double speed) const {
-            return accel.visit([=](auto accel_t) { return accel_t.accelerate(speed); });
-        }
-
-        /// <summary>
-        /// Verifies acceleration arguments, via visitor function to accel_implementation_t
+        /// Verifies acceleration arguments, via visitor function to accel_impl_t
         /// </summary>
         /// <param name="args">Arguments to be verified</param>
-        void verify(accel_args args) const {
-            return accel.visit([=](auto accel_t) { accel_t.verify(args); });
+        void verify(accel_fn_args args) {
+            if (args.time_min <= 0) error("min time must be positive");
+            if (args.acc_args.offset < 0) error("offset must not be negative");
         }
 
         /// <summary>
@@ -151,10 +146,12 @@ namespace rawaccel {
             double time_clamped = clampsd(time, time_min, 100);
             double speed = maxsd(mag / time_clamped - speed_offset, 0);
 
-            double accel_val = apply(speed);
+            double accel_val = accel.visit([=](auto&& impl) {
+                return impl.accelerate(speed); 
+            });
 
-            double scale_x = weight.x * accel_val + 1;
-            double scale_y = weight.y * accel_val + 1;
+            double scale_x = weight.x * accel_val + scale_base;
+            double scale_y = weight.y * accel_val + scale_base;
 
             return {
                 input.x * clamp.x(scale_x),
@@ -165,11 +162,10 @@ namespace rawaccel {
         accel_function() = default;
     };
 
-    struct modifier_args
-    {
+    struct modifier_args {
         double degrees = 0;
         vec2d sens = { 1, 1 };
-        accel_fn_args acc_fn_args = accel_fn_args{};
+        accel_fn_args acc_fn_args;
     };
 
     /// <summary> Struct to hold variables and methods for modifying mouse input </summary>
@@ -187,8 +183,8 @@ namespace rawaccel {
             if (apply_rotate) rotate = rotator(args.degrees);
             else rotate = rotator();
 
-            apply_accel = (args.acc_fn_args.accel_mode != 0 &&
-						   args.acc_fn_args.accel_mode != accel_implementation_t::id<accel_noaccel>);
+            apply_accel = args.acc_fn_args.acc_args.accel != 0 &&
+                args.acc_fn_args.accel_mode != accel_impl_t::id<accel_noaccel>;
 
             if (args.sens.x == 0) args.sens.x = 1;
             if (args.sens.y == 0) args.sens.y = 1;
@@ -226,10 +222,7 @@ namespace rawaccel {
                 input = rotate(input);
             }
 
-            if (apply_accel)
-            {
-				input = accel_fn(input, time);
-            }
+			input = accel_fn(input, time);
 
             input.x *= sensitivity.x;
             input.y *= sensitivity.y;
-- 
cgit v1.2.3


From b59cf98c2f326abeb6b993d8ecc5759d23096253 Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Thu, 30 Jul 2020 22:04:44 -0400
Subject: Make weight a member of accel_base

This exposes weight to derived accel types, which now supply a method to transform acceleration into scale.
---
 common/accel-base.hpp         | 21 +++++++++++++++++++--
 common/accel-power.hpp        | 10 +++++++++-
 common/rawaccel-userspace.hpp |  2 +-
 common/rawaccel.hpp           | 24 ++++++------------------
 4 files changed, 35 insertions(+), 22 deletions(-)

diff --git a/common/accel-base.hpp b/common/accel-base.hpp
index ed79bdb..e87b463 100644
--- a/common/accel-base.hpp
+++ b/common/accel-base.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "vec2.h"
+
 namespace rawaccel {
 
     // Error throwing calls std libraries which are unavailable in kernel mode.
@@ -15,14 +17,18 @@ namespace rawaccel {
         double exponent = 2;
         double midpoint = 0;
         double power_scale = 1;
+        vec2d weight = { 1, 1 };
     };
 
     /// <summary>
     /// Struct to hold common acceleration curve implementation details.
     /// </summary>
     struct accel_base {
-        
-        /// <summary> Generally, the acceleration ramp rate.</summary>
+
+        /// <summary> Coefficients applied to acceleration per axis.</summary>
+        vec2d weight = { 1, 1 };
+
+        /// <summary> Generally, the acceleration ramp rate.
         double speed_coeff = 0;
 
         /// <summary>
@@ -34,6 +40,17 @@ namespace rawaccel {
             verify(args);
 
             speed_coeff = args.accel;
+            weight = args.weight;
+        }
+
+        /// <summary> 
+        /// Default transformation of acceleration -> mouse input multipliers.
+        /// </summary>
+        inline vec2d scale(double accel_val) const {
+            return {
+                weight.x * accel_val + 1,
+                weight.y * accel_val + 1
+            };
         }
 
         /// <summary>
diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index c8b12cd..d96cb96 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -14,6 +14,7 @@ namespace rawaccel {
 		accel_power(accel_args args) {
 			verify(args);
 
+			weight = args.weight;
 			speed_coeff = args.power_scale;
 			exponent = args.exponent;
 			offset = args.offset;
@@ -24,8 +25,15 @@ namespace rawaccel {
 			return (offset > 0 && speed < 1) ? 1 : pow(speed * speed_coeff, exponent);
 		}
 
+		inline vec2d scale(double accel_val) const {
+			return { 
+				weight.x * accel_val,
+				weight.y * accel_val
+			};
+		}
+
 		void verify(accel_args args) const {
-			if (args.power_scale < 0) error("scale can not be negative");
+			if (args.power_scale <= 0) error("scale must be positive");
 			if (args.exponent <= 0) error("exponent must be greater than 0");
 		}
 	};
diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index 49c0fcd..6a79d23 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -50,7 +50,7 @@ mouse_modifier parse(int argc, char** argv) {
     
     // mode-independent accel options
     auto opt_weight = "accel multiplier (default = 1)" % 
-        make_opt_vec(args.acc_fn_args.weight, "weight");
+        make_opt_vec(args.acc_fn_args.acc_args.weight, "weight");
 
     auto opt_offset = "speed (dots/ms) where accel kicks in (default = 0)" % (
         clipp::option("offset") & clipp::number("speed", args.acc_fn_args.acc_args.offset)
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 0aeb42d..7be37c2 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -81,7 +81,6 @@ namespace rawaccel {
         accel_args acc_args;
         int accel_mode = accel_impl_t::id<accel_noaccel>;
         milliseconds time_min = 0.4;
-        vec2d weight = { 1, 1 };
         vec2d cap = { 0, 0 };
     };
 
@@ -102,26 +101,17 @@ namespace rawaccel {
         /// <summary> The acceleration implementation (i.e. curve) </summary>
         accel_impl_t accel;
 
-        /// <summary> The weight of acceleration applied in {x, y} dimensions. </summary>
-        vec2d weight = { 1, 1 };
-
-        /// <summary> The constant added to weighted accel values to get the acceleration scale. </summary>
-        double scale_base = 1;
-
         /// <summary> The object which sets a min and max for the acceleration scale. </summary>
         vec2<accel_scale_clamp> clamp;
 
-        accel_function(accel_fn_args args) : accel_function() {
+        accel_function(accel_fn_args args) {
             verify(args);
 
             accel.tag = args.accel_mode;
             accel.visit([&](auto& impl){ impl = { args.acc_args }; });
 
-            if (accel.tag == accel_impl_t::id<accel_power>) scale_base = 0;
-
             time_min = args.time_min;
             speed_offset = args.acc_args.offset;
-            weight = args.weight;
             clamp.x = accel_scale_clamp(args.cap.x);
             clamp.y = accel_scale_clamp(args.cap.y);
         }
@@ -146,16 +136,14 @@ namespace rawaccel {
             double time_clamped = clampsd(time, time_min, 100);
             double speed = maxsd(mag / time_clamped - speed_offset, 0);
 
-            double accel_val = accel.visit([=](auto&& impl) {
-                return impl.accelerate(speed); 
+            vec2d scale = accel.visit([=](auto&& impl) {
+                double accel_val = impl.accelerate(speed);
+                return impl.scale(accel_val); 
             });
 
-            double scale_x = weight.x * accel_val + scale_base;
-            double scale_y = weight.y * accel_val + scale_base;
-
             return {
-                input.x * clamp.x(scale_x),
-                input.y * clamp.y(scale_y)
+                input.x * clamp.x(scale.x),
+                input.y * clamp.y(scale.y)
             };
         }
 
-- 
cgit v1.2.3


From b3ed8fd4e4fcad0b749126dee62588260d74b106 Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Fri, 31 Jul 2020 01:37:41 -0400
Subject: add more tweaks for st-refactor

---
 common/accel-base.hpp                 | 16 +++++++++-------
 common/accel-classic.hpp              |  4 ++--
 common/accel-linear.hpp               |  8 ++------
 common/accel-logarithmic.hpp          |  2 +-
 common/accel-natural.hpp              |  4 ++--
 common/accel-noaccel.hpp              |  3 +--
 common/accel-power.hpp                |  4 ++--
 common/accel-sigmoid.hpp              |  4 ++--
 common/external/tagged-union-single.h |  2 +-
 common/rawaccel-userspace.hpp         |  2 +-
 common/rawaccel.hpp                   | 28 +++++++++++-----------------
 11 files changed, 34 insertions(+), 43 deletions(-)

diff --git a/common/accel-base.hpp b/common/accel-base.hpp
index e87b463..da2c96b 100644
--- a/common/accel-base.hpp
+++ b/common/accel-base.hpp
@@ -31,18 +31,20 @@ namespace rawaccel {
         /// <summary> Generally, the acceleration ramp rate.
         double speed_coeff = 0;
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="accel_base"/> struct.
-        /// </summary>
-        /// <param name="args"></param>
-        /// <returns></returns>
-        accel_base(accel_args args) {
+        accel_base(const accel_args& args) {
             verify(args);
 
             speed_coeff = args.accel;
             weight = args.weight;
         }
 
+        /// <summary> 
+        /// Default transformation of speed -> acceleration.
+        /// </summary>
+        inline double accelerate(double speed) const { 
+            return speed_coeff * speed; 
+        }
+
         /// <summary> 
         /// Default transformation of acceleration -> mouse input multipliers.
         /// </summary>
@@ -57,7 +59,7 @@ namespace rawaccel {
         /// Verifies arguments as valid. Errors if not.
         /// </summary>
         /// <param name="args">Arguments to verified.</param>
-        void verify(accel_args args) const {
+        void verify(const accel_args& args) const {
             if (args.accel < 0) error("accel can not be negative, use a negative weight to compensate");
         }
 
diff --git a/common/accel-classic.hpp b/common/accel-classic.hpp
index e2eb494..1a2adca 100644
--- a/common/accel-classic.hpp
+++ b/common/accel-classic.hpp
@@ -10,7 +10,7 @@ namespace rawaccel {
 	struct accel_classic : accel_base {
 		double exponent;
 
-		accel_classic(accel_args args) : accel_base(args) {
+		accel_classic(const accel_args& args) : accel_base(args) {
 			verify(args);
 
 			exponent = args.exponent - 1;
@@ -21,7 +21,7 @@ namespace rawaccel {
 			return pow(speed_coeff * speed, exponent);
 		}
 
-		void verify(accel_args args) const {
+		void verify(const accel_args& args) const {
 			if (args.exponent <= 1) error("exponent must be greater than 1");
 		}
 	};
diff --git a/common/accel-linear.hpp b/common/accel-linear.hpp
index 28150a8..5cbb7c6 100644
--- a/common/accel-linear.hpp
+++ b/common/accel-linear.hpp
@@ -5,14 +5,10 @@
 namespace rawaccel {
 
 	/// <summary> Struct to hold linear acceleration implementation. </summary>
-	struct accel_linear : accel_base {
+	struct accel_linear : accel_base { 
 
-		accel_linear(accel_args args) : accel_base(args) {}
+		using accel_base::accel_base; 
 
-		inline double accelerate(double speed) const {
-			//f(x) = mx
-			return speed_coeff * speed;
-		}
 	};
 
 }
diff --git a/common/accel-logarithmic.hpp b/common/accel-logarithmic.hpp
index b628327..928eda9 100644
--- a/common/accel-logarithmic.hpp
+++ b/common/accel-logarithmic.hpp
@@ -9,7 +9,7 @@ namespace rawaccel {
 	/// <summary> Struct to hold logarithmic acceleration implementation. </summary>
 	struct accel_logarithmic : accel_base {
 
-		accel_logarithmic(accel_args args) : accel_base(args) {}
+		using accel_base::accel_base;
 
 		inline double accelerate(double speed) const {
 			//f(x) = log(m*x+1)
diff --git a/common/accel-natural.hpp b/common/accel-natural.hpp
index 6ccb193..c87fda8 100644
--- a/common/accel-natural.hpp
+++ b/common/accel-natural.hpp
@@ -11,7 +11,7 @@ namespace rawaccel {
 		double limit = 1;
 		double midpoint = 0;
 
-		accel_natural(accel_args args) : accel_base(args) {
+		accel_natural(const accel_args& args) : accel_base(args) {
 			verify(args);
 
 			limit = args.limit - 1;
@@ -23,7 +23,7 @@ namespace rawaccel {
 			return limit - (limit * exp(-speed_coeff * speed));
 		}
 
-		void verify(accel_args args) const {
+		void verify(const accel_args& args) const {
 			if (args.limit <= 1) error("limit must be greater than 1");
 		}
 	};
diff --git a/common/accel-noaccel.hpp b/common/accel-noaccel.hpp
index 151002a..b7f730b 100644
--- a/common/accel-noaccel.hpp
+++ b/common/accel-noaccel.hpp
@@ -7,9 +7,8 @@ namespace rawaccel {
 	/// <summary> Struct to hold acceleration implementation which applies no acceleration. </summary>
 	struct accel_noaccel : accel_base {
 
-		accel_noaccel(accel_args args) : accel_base(args) {}
+		accel_noaccel(const accel_args&) : accel_base() {}
 
-		inline double accelerate(double) const { return 0; }
 	};
 
 }
diff --git a/common/accel-power.hpp b/common/accel-power.hpp
index d96cb96..7f4c220 100644
--- a/common/accel-power.hpp
+++ b/common/accel-power.hpp
@@ -11,7 +11,7 @@ namespace rawaccel {
 		double exponent;
 		double offset;
 
-		accel_power(accel_args args) {
+		accel_power(const accel_args& args) {
 			verify(args);
 
 			weight = args.weight;
@@ -32,7 +32,7 @@ namespace rawaccel {
 			};
 		}
 
-		void verify(accel_args args) const {
+		void verify(const accel_args& args) const {
 			if (args.power_scale <= 0) error("scale must be positive");
 			if (args.exponent <= 0) error("exponent must be greater than 0");
 		}
diff --git a/common/accel-sigmoid.hpp b/common/accel-sigmoid.hpp
index e992e0c..7cfa6c4 100644
--- a/common/accel-sigmoid.hpp
+++ b/common/accel-sigmoid.hpp
@@ -11,7 +11,7 @@ namespace rawaccel {
 		double limit = 1;
 		double midpoint = 0;
 
-		accel_sigmoid(accel_args args) : accel_base(args) {
+		accel_sigmoid(const accel_args& args) : accel_base(args) {
 			verify(args);
 
 			limit = args.limit - 1;
@@ -23,7 +23,7 @@ namespace rawaccel {
 			return limit / (exp(-speed_coeff * (speed - midpoint)) + 1);
 		}
 
-		void verify(accel_args args) const {
+		void verify(const accel_args& args) const {
 			if (args.limit <= 1) error("exponent must be greater than 1");
 			if (args.midpoint < 0) error("midpoint must not be negative");
 		}
diff --git a/common/external/tagged-union-single.h b/common/external/tagged-union-single.h
index bcfc1cf..3353325 100644
--- a/common/external/tagged-union-single.h
+++ b/common/external/tagged-union-single.h
@@ -137,7 +137,7 @@ struct tagged_union {
     int tag = 0;
 
     struct storage_t {
-        alignas(max_align_of<First, Rest...>) char bytes[max_size_of<First, Rest...>];
+        alignas(max_align_of<First, Rest...>) char bytes[max_size_of<First, Rest...>] = "";
 
         template <typename T>
         inline constexpr T& as() {
diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index 6a79d23..c80262c 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -4,7 +4,7 @@
 
 #include "external/clipp.h"
 
-#include <accel-error.hpp>
+#include "accel-error.hpp"
 #include "rawaccel.hpp"
 
 namespace rawaccel {
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 7be37c2..59a0360 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -3,7 +3,6 @@
 #define _USE_MATH_DEFINES
 #include <math.h>
 
-#include "vec2.h"
 #include "x64-util.hpp"
 #include "external/tagged-union-single.h"
 
@@ -104,8 +103,9 @@ namespace rawaccel {
         /// <summary> The object which sets a min and max for the acceleration scale. </summary>
         vec2<accel_scale_clamp> clamp;
 
-        accel_function(accel_fn_args args) {
-            verify(args);
+        accel_function(const accel_fn_args& args) {
+            if (args.time_min <= 0) error("min time must be positive");
+            if (args.acc_args.offset < 0) error("offset must not be negative");
 
             accel.tag = args.accel_mode;
             accel.visit([&](auto& impl){ impl = { args.acc_args }; });
@@ -116,15 +116,6 @@ namespace rawaccel {
             clamp.y = accel_scale_clamp(args.cap.y);
         }
 
-        /// <summary>
-        /// Verifies acceleration arguments, via visitor function to accel_impl_t
-        /// </summary>
-        /// <param name="args">Arguments to be verified</param>
-        void verify(accel_fn_args args) {
-            if (args.time_min <= 0) error("min time must be positive");
-            if (args.acc_args.offset < 0) error("offset must not be negative");
-        }
-
         /// <summary>
         /// Applies weighted acceleration to given input for given time period.
         /// </summary>
@@ -164,19 +155,22 @@ namespace rawaccel {
         accel_function accel_fn;
         vec2d sensitivity = { 1, 1 };
 
-        mouse_modifier(modifier_args args)
+        mouse_modifier(const modifier_args& args)
             : accel_fn(args.acc_fn_args)
         {
             apply_rotate = args.degrees != 0;
+
             if (apply_rotate) rotate = rotator(args.degrees);
             else rotate = rotator();
 
-            apply_accel = args.acc_fn_args.acc_args.accel != 0 &&
+            apply_accel = args.acc_fn_args.accel_mode != 0 &&
                 args.acc_fn_args.accel_mode != accel_impl_t::id<accel_noaccel>;
 
-            if (args.sens.x == 0) args.sens.x = 1;
-            if (args.sens.y == 0) args.sens.y = 1;
-            sensitivity = args.sens;
+            if (args.sens.x == 0) sensitivity.x = 1;
+            else sensitivity.x = args.sens.x;
+
+            if (args.sens.y == 0) sensitivity.y = 1;
+            else sensitivity.y = args.sens.y;
         }
 
         /// <summary>
-- 
cgit v1.2.3


From f7c88d689e924010f6f95b22894414f0b96c4aa0 Mon Sep 17 00:00:00 2001
From: a1xd <68629610+a1xd@users.noreply.github.com>
Date: Fri, 31 Jul 2020 04:52:24 -0400
Subject: update grapher/wrapper for st-refactor

---
 common/x64-util.hpp | 10 +++++++-
 grapher/Form1.cs    | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 wrapper/wrapper.cpp |  5 +++-
 wrapper/wrapper.hpp | 18 +++++++-------
 4 files changed, 89 insertions(+), 13 deletions(-)

diff --git a/common/x64-util.hpp b/common/x64-util.hpp
index 2fb61bb..40bc7c4 100644
--- a/common/x64-util.hpp
+++ b/common/x64-util.hpp
@@ -1,7 +1,13 @@
 #pragma once
 
-#include <emmintrin.h>
+#ifdef _MANAGED
+
+#include <math.h>
+inline double sqrtsd(double val) { return sqrt(val); }
+
+#else
 
+#include <emmintrin.h>
 inline double sqrtsd(double val) {
     __m128d src = _mm_load_sd(&val);
     __m128d dst = _mm_sqrt_sd(src, src);
@@ -9,6 +15,8 @@ inline double sqrtsd(double val) {
     return val;
 }
 
+#endif
+
 inline constexpr double minsd(double a, double b) {
     return (a < b) ? a : b;
 }
diff --git a/grapher/Form1.cs b/grapher/Form1.cs
index 495640e..47ef1d9 100644
--- a/grapher/Form1.cs
+++ b/grapher/Form1.cs
@@ -7,15 +7,82 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
+using System.Runtime.InteropServices;
 
 namespace grapher
 {
+    public enum accel_mode 
+    {
+        linear=1, classic, natural, logarithmic, sigmoid, power, noaccel
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    public struct vec2d 
+    {
+        public double x;
+        public double y;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    public struct accel_args
+    {
+        public double offset;
+        public double accel;
+        public double limit;
+        public double exponent;
+        public double midpoint;
+        public double power_scale;
+        public vec2d weight;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    public struct accel_fn_args
+    {
+        public accel_args acc_args;
+        public int accel_mode;
+        public double time_min;
+        public vec2d cap;
+    }
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    public struct modifier_args
+    {
+        public double degrees;
+        public vec2d sens;
+        public accel_fn_args acc_fn_args;
+    }
+
     public partial class RawAcceleration : Form
     {
         public RawAcceleration()
         {
             InitializeComponent();
-            var managedAccel = new ManagedAccel(5, 0, 0.3, 1.25, 15);
+
+            modifier_args args;
+
+            args.degrees = 0;
+            args.sens.x = 1;
+            args.sens.y = 1;
+            args.acc_fn_args.acc_args.offset = 0;
+            args.acc_fn_args.acc_args.accel = 0.01;
+            args.acc_fn_args.acc_args.limit = 2;
+            args.acc_fn_args.acc_args.exponent = 1;
+            args.acc_fn_args.acc_args.midpoint = 0;
+            args.acc_fn_args.acc_args.power_scale = 1;
+            args.acc_fn_args.acc_args.weight.x = 1;
+            args.acc_fn_args.acc_args.weight.y = 1;
+            args.acc_fn_args.accel_mode = (int)accel_mode.natural;
+            args.acc_fn_args.time_min = 0.4;
+            args.acc_fn_args.cap.x = 0;
+            args.acc_fn_args.cap.y = 0;
+
+            IntPtr args_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(args));
+            Marshal.StructureToPtr(args, args_ptr, false);
+
+            var managedAccel = new ManagedAccel(args_ptr);
+
+            Marshal.FreeHGlobal(args_ptr);
+
             var orderedPoints = new SortedDictionary<double, double>();
 
             for (int i = 0; i < 100; i++)
diff --git a/wrapper/wrapper.cpp b/wrapper/wrapper.cpp
index c1cc570..26d05ec 100644
--- a/wrapper/wrapper.cpp
+++ b/wrapper/wrapper.cpp
@@ -7,7 +7,10 @@ using namespace System;
 
 Tuple<double, double>^ ManagedAccel::Accelerate(int x, int y, double time)
 {
-	vec2d input_vec2d = {x, y};
+	vec2d input_vec2d = {
+		(double)x, 
+		(double)y
+	};
 	vec2d output = (*modifier_instance).modify_with_accel(input_vec2d, (milliseconds)time);
 
 	return gcnew Tuple<double, double>(output.x, output.y);
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index 19b0987..42f5865 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -1,11 +1,16 @@
 #pragma once
 
 #include "..\common\rawaccel.hpp";
-#include "..\common\error.hpp";
+#include "..\common\accel-error.hpp";
 #include <iostream>
 using namespace rawaccel;
 using namespace System;
 
+
+public value struct ArgsWrapper {
+    int a;
+};
+
 public ref class ManagedAccel
 {
 protected:
@@ -16,16 +21,9 @@ public:
 	{
 	}
 
-    ManagedAccel(int mode, double offset, double accel, double lim_exp, double midpoint)
+    ManagedAccel(System::IntPtr args)
     {
-        modifier_args args{};
-        args.acc_fn_args.acc_args.accel = accel;
-        args.acc_fn_args.acc_args.lim_exp = lim_exp;
-        args.acc_fn_args.acc_args.midpoint = midpoint;
-        args.acc_fn_args.accel_mode = mode;
-        args.acc_fn_args.acc_args.offset = offset;
-
-		modifier_instance = new mouse_modifier(args);
+        modifier_instance = new mouse_modifier(*reinterpret_cast<modifier_args*>(args.ToPointer()));
 	}
 
     virtual ~ManagedAccel()
-- 
cgit v1.2.3