From 3226272a2d49bcbaec72ec735c22b4e0cc2a5c57 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Mon, 27 Jul 2020 19:31:09 -0700
Subject: skeleton

---
 common/external/tagged-union-single.h | 202 ++++++++++++++++++++++++++++++++++
 common/rawaccel-userspace.hpp         |   2 +-
 common/rawaccel.hpp                   | 192 +++++++++++++++++++++++---------
 wrapper/wrapper.cpp                   |   2 +-
 wrapper/wrapper.hpp                   |   2 +-
 5 files changed, 342 insertions(+), 58 deletions(-)
 create mode 100644 common/external/tagged-union-single.h

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...>;
diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index db50b35..bca6997 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -19,7 +19,7 @@ void error(const char* s) {
 variables parse(int argc, char** argv) {
     double degrees = 0;
     vec2d sens = { 1, 1 };
-    accel_function::args_t accel_args{};
+    args_t accel_args{};
 
     auto make_opt_vec = [](vec2d& v, auto first_flag, auto... rest) {
         return clipp::option(first_flag, rest...) & (
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 095af76..f7f9df7 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -5,6 +5,7 @@
 
 #include "vec2.h"
 #include "x64-util.hpp"
+#include "external/tagged-union-single.h"
 
 namespace rawaccel {   
 
@@ -55,8 +56,119 @@ struct accel_scale_clamp {
 
 void error(const char*);
 
+using milliseconds = double;
+
+struct args_t {
+	mode accel_mode = mode::noaccel;
+	milliseconds time_min = 0.4;
+	double offset = 0;
+	double accel = 0;
+	double lim_exp = 2;
+	double midpoint = 0;
+	vec2d weight = { 1, 1 };
+	vec2d cap = { 0, 0 };
+};
+
+struct accel_implentation {
+	double b = 0;
+	double k = 0;
+	double m = 0;
+	double offset = 0;
+
+	accel_implentation(args_t args)
+	{
+		b = args.accel;
+		k = args.lim_exp;
+		m = args.midpoint;
+		offset = args.offset;
+	}
+
+	double virtual accelerate(double speed) { return 0; }
+	void virtual verify(args_t 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");
+	}
+
+	accel_implentation() = default;
+};
+
+struct accel_linear : accel_implentation {
+    accel_linear(args_t args)
+        : accel_implentation(args) {}
+
+    double virtual accelerate(double speed) override {
+		return b * speed;
+	}
+
+	void virtual verify(args_t args) override {
+		accel_implentation::verify(args);
+		if (args.lim_exp <= 1) error("limit must be greater than 1");
+	}
+};
+
+struct accel_classic : accel_implentation {
+    accel_classic(args_t args)
+        : accel_implentation(args) {}
+
+	double virtual accelerate(double speed) override {
+		return pow(b * speed, k); 
+
+	}
+
+	void virtual verify(args_t args) override {
+		accel_implentation::verify(args);
+		if (args.lim_exp <= 1) error("exponent must be greater than 1");
+	}
+};
+
+struct accel_logarithmic : accel_implentation {
+    accel_logarithmic(args_t args)
+        : accel_implentation(args) {}
+
+	double virtual accelerate(double speed) override {
+		return log(speed * b + 1); 
+	}
+
+	void virtual verify(args_t args) override {
+		accel_implentation::verify(args);
+		if (args.lim_exp <= 1) error("exponent must be greater than 1");
+	}
+};
+
+struct accel_sigmoid : accel_implentation {
+    accel_sigmoid(args_t args)
+        : accel_implentation(args) {}
+
+	double virtual accelerate(double speed) override {
+		return k / (exp(-b * (speed - m)) + 1); 
+
+	}
+
+	void virtual verify(args_t args) override {
+		accel_implentation::verify(args);
+		if (args.lim_exp <= 1) error("exponent must be greater than 1");
+	}
+};
+
+struct accel_power : accel_implentation {
+    accel_power(args_t args)
+        : accel_implentation(args) {}
+
+	double virtual accelerate(double speed) override {
+		return (offset > 0 && speed < 1) ? 0 : pow(speed*b, k) - 1;
+
+
+	}
+
+	void virtual verify(args_t args) override {
+		accel_implentation::verify(args);
+		if (args.lim_exp <= 1) error("exponent must be greater than 1");
+	}
+};
+
+using accel_implementation_t = tagged_union<accel_implentation, accel_linear, accel_classic, accel_logarithmic, accel_sigmoid, accel_power>;
+
 struct accel_function {
-    using milliseconds = double;
 
     /* 
     This value is ideally a few microseconds lower than 
@@ -77,63 +189,13 @@ struct accel_function {
     // or the exponent for classic and power modes
     double k = 1; 
     
+	accel_implementation_t accel = accel_implentation{};
+
     vec2d weight = { 1, 1 };
     vec2<accel_scale_clamp> clamp;
 
-    inline vec2d operator()(const vec2d& input, milliseconds time, mode accel_mode) const {
-        double mag = sqrtsd(input.x * input.x + input.y * input.y);
-        double time_clamped = clampsd(time, time_min, 100);
-        double speed = maxsd(mag / time_clamped - speed_offset, 0);
-
-        double accel_val = 0;
-
-        switch (accel_mode) {
-        case mode::linear: accel_val = b * speed; 
-            break;
-        case mode::classic: accel_val = pow(b * speed, k); 
-            break;
-        case mode::natural: accel_val = k - (k * exp(-b * speed)); 
-            break;
-        case mode::logarithmic: accel_val = log(speed * b + 1); 
-            break;
-        case mode::sigmoid: accel_val = k / (exp(-b * (speed - m)) + 1); 
-            break;
-        case mode::power: accel_val = (speed_offset > 0 && speed < 1) ? 0 : pow(speed*b, k) - 1;
-            break;
-        default:
-            break;
-        }
-
-        double scale_x = weight.x * accel_val + 1;
-        double scale_y = weight.y * accel_val + 1;
-
-        return { 
-            input.x * clamp.x(scale_x), 
-            input.y * clamp.y(scale_y) 
-        };
-    }
-
-    struct args_t {
-        mode accel_mode = mode::noaccel;
-        milliseconds time_min = 0.4;
-        double offset = 0;
-        double accel = 0;
-        double lim_exp = 2;
-        double midpoint = 0;
-        vec2d weight = { 1, 1 };
-        vec2d cap = { 0, 0 };
-    };
-
     accel_function(args_t args) {
-        // Preconditions to guard against division by zero and
-        // ensure the C math functions can not return NaN or -Inf.
-        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");
-        if (args.lim_exp <= 1) {
-            if (args.accel_mode == mode::classic) error("exponent must be greater than 1");
-            if (args.accel_mode == mode::power) { if (args.lim_exp <=0 ) error("exponent must be greater than 0"); }
-            else error("limit must be greater than 1");
-        }
+        accel = accel_linear(args);
 
         time_min = args.time_min;
         m = args.midpoint;
@@ -148,6 +210,26 @@ struct accel_function {
         clamp.y = accel_scale_clamp(args.cap.y);
     }
 
+	double apply(double speed) const {
+		return accel.visit([=](auto accel_t) { return accel_t.accelerate(speed); });
+	}
+
+    inline vec2d operator()(const vec2d& input, milliseconds time, mode accel_mode) const {
+        double mag = sqrtsd(input.x * input.x + input.y * input.y);
+        double time_clamped = clampsd(time, time_min, 100);
+        double speed = maxsd(mag / time_clamped - speed_offset, 0);
+
+        double accel_val = apply(speed);
+
+        double scale_x = weight.x * accel_val + 1;
+        double scale_y = weight.y * accel_val + 1;
+
+        return { 
+            input.x * clamp.x(scale_x), 
+            input.y * clamp.y(scale_y) 
+        };
+    }
+
     accel_function() = default;
 };
 
@@ -159,7 +241,7 @@ struct variables {
     accel_function accel_fn;
     vec2d sensitivity = { 1, 1 };
 
-    variables(double degrees, vec2d sens, accel_function::args_t accel_args)
+    variables(double degrees, vec2d sens, args_t accel_args)
         : accel_fn(accel_args)
     {
         apply_rotate = degrees != 0;
diff --git a/wrapper/wrapper.cpp b/wrapper/wrapper.cpp
index df3f796..f3d069a 100644
--- a/wrapper/wrapper.cpp
+++ b/wrapper/wrapper.cpp
@@ -8,7 +8,7 @@ using namespace System;
 Tuple<double, double>^ ManagedAccel::Accelerate(int x, int y, double time, double mode)
 {
 	vec2d input_vec2d = {x, y};
-	vec2d output = (*accel_instance)(input_vec2d, (accel_function::milliseconds)time, (rawaccel::mode)mode);
+	vec2d output = (*accel_instance)(input_vec2d, (milliseconds)time, (rawaccel::mode)mode);
 
 	return gcnew Tuple<double, double>(output.x, output.y);
 }
\ No newline at end of file
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index 24bcadb..a5699ac 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -18,7 +18,7 @@ public:
 
     ManagedAccel(double mode, double offset, double accel, double lim_exp, double midpoint)
     {
-        accel_function::args_t args{};
+        args_t args{};
         args.accel = accel;
         args.lim_exp = lim_exp;
         args.midpoint = midpoint;
-- 
cgit v1.2.3


From 894a13926f79e209e3b619012cd2bb6961d959e2 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 01:53:32 -0700
Subject: Further refactoring and comments

---
 common/Error.hpp       |  10 +
 common/common.vcxitems |   1 +
 common/rawaccel.hpp    | 546 ++++++++++++++++++++++++++++---------------------
 wrapper/wrapper.hpp    |   2 +-
 4 files changed, 323 insertions(+), 236 deletions(-)
 create mode 100644 common/Error.hpp

diff --git a/common/Error.hpp b/common/Error.hpp
new file mode 100644
index 0000000..ed87090
--- /dev/null
+++ b/common/Error.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <iostream>
+
+
+namespace rawaccel {
+	void error(const char* s) { 
+		throw std::domain_error(s); 
+	}
+}
diff --git a/common/common.vcxitems b/common/common.vcxitems
index f60f78a..224792c 100644
--- a/common/common.vcxitems
+++ b/common/common.vcxitems
@@ -14,6 +14,7 @@
     <ProjectCapability Include="SourceItemsFromImports" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="$(MSBuildThisFileDirectory)Error.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)rawaccel-userspace.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)rawaccel.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)x64-util.hpp" />
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index f7f9df7..3380e4c 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -7,256 +7,332 @@
 #include "x64-util.hpp"
 #include "external/tagged-union-single.h"
 
-namespace rawaccel {   
+namespace rawaccel {
 
-enum class mode { noaccel, linear, classic, natural, logarithmic, sigmoid, power };
+    enum class mode { noaccel, linear, classic, natural, logarithmic, sigmoid, power };
 
-struct rotator {
-    vec2d rot_vec = { 1, 0 };
+    struct rotator {
+        vec2d rot_vec = { 1, 0 };
 
-    inline vec2d operator()(const vec2d& input) const {
-        return { 
-            input.x * rot_vec.x - input.y * rot_vec.y,
-            input.x * rot_vec.y + input.y * rot_vec.x
-        };
-    }
+        inline vec2d operator()(const vec2d& input) const {
+            return {
+                input.x * rot_vec.x - input.y * rot_vec.y,
+                input.x * rot_vec.y + input.y * rot_vec.x
+            };
+        }
 
-    rotator(double degrees) {
-        double rads = degrees * M_PI / 180;
-        rot_vec = { cos(rads), sin(rads) };
-    }
+        rotator(double degrees) {
+            double rads = degrees * M_PI / 180;
+            rot_vec = { cos(rads), sin(rads) };
+        }
 
-    rotator() = default;
-};
+        rotator() = default;
+    };
 
-struct accel_scale_clamp {
-    double lo = 0;
-    double hi = 9;
+    struct accel_scale_clamp {
+        double lo = 0;
+        double hi = 9;
 
-    inline double operator()(double scale) const {
-        return clampsd(scale, lo, hi);
-    }
+        inline double operator()(double scale) const {
+            return clampsd(scale, lo, hi);
+        }
 
-    accel_scale_clamp(double cap) : accel_scale_clamp() {
-        if (cap <= 0) {
-            // use default, effectively uncapped accel
-            return;
+        accel_scale_clamp(double cap) : accel_scale_clamp() {
+            if (cap <= 0) {
+                // use default, effectively uncapped accel
+                return;
+            }
+
+            if (cap < 1) {
+                // assume negative accel
+                lo = cap;
+                hi = 1;
+            }
+            else hi = cap;
         }
 
-        if (cap < 1) {
-            // assume negative accel
-            lo = cap;
-            hi = 1;
+        accel_scale_clamp() = default;
+    };
+
+#ifdef _KERNEL_MODE
+    void error(const char*) {}
+#else
+    void error(const char* s);
+#endif
+
+    using milliseconds = double;
+
+    struct args_t {
+        mode accel_mode = mode::noaccel;
+        milliseconds time_min = 0.4;
+        double offset = 0;
+        double accel = 0;
+        double lim_exp = 2;
+        double midpoint = 0;
+        vec2d weight = { 1, 1 };
+        vec2d cap = { 0, 0 };
+    };
+
+    /// <summary>
+    /// Struct to hold acceleration implementation details.
+    /// </summary>
+    /// <typeparam name="T">Type of acceleration.</typeparam>
+    template <typename T>
+    struct accel_implentation {
+        
+        /// <summary> The acceleration ramp rate.</summary>
+        double b = 0;
+
+        /// <summary> The limit or exponent for various modes. </summary>
+        double k = 0;
+
+        /// <summary> The midpoint in sigmoid mode. </summary>
+        double m = 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(args_t args)
+        {
+            b = args.accel;
+            k = args.lim_exp - 1;
+            m = 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(args_t 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");
         }
-        else hi = cap;
-    }
-
-    accel_scale_clamp() = default;
-};
-
-void error(const char*);
-
-using milliseconds = double;
-
-struct args_t {
-	mode accel_mode = mode::noaccel;
-	milliseconds time_min = 0.4;
-	double offset = 0;
-	double accel = 0;
-	double lim_exp = 2;
-	double midpoint = 0;
-	vec2d weight = { 1, 1 };
-	vec2d cap = { 0, 0 };
-};
-
-struct accel_implentation {
-	double b = 0;
-	double k = 0;
-	double m = 0;
-	double offset = 0;
-
-	accel_implentation(args_t args)
-	{
-		b = args.accel;
-		k = args.lim_exp;
-		m = args.midpoint;
-		offset = args.offset;
-	}
-
-	double virtual accelerate(double speed) { return 0; }
-	void virtual verify(args_t 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");
-	}
-
-	accel_implentation() = default;
-};
-
-struct accel_linear : accel_implentation {
-    accel_linear(args_t args)
-        : accel_implentation(args) {}
-
-    double virtual accelerate(double speed) override {
-		return b * speed;
-	}
-
-	void virtual verify(args_t args) override {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("limit must be greater than 1");
-	}
-};
-
-struct accel_classic : accel_implentation {
-    accel_classic(args_t args)
-        : accel_implentation(args) {}
-
-	double virtual accelerate(double speed) override {
-		return pow(b * speed, k); 
-
-	}
-
-	void virtual verify(args_t args) override {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-};
-
-struct accel_logarithmic : accel_implentation {
-    accel_logarithmic(args_t args)
-        : accel_implentation(args) {}
-
-	double virtual accelerate(double speed) override {
-		return log(speed * b + 1); 
-	}
-
-	void virtual verify(args_t args) override {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-};
-
-struct accel_sigmoid : accel_implentation {
-    accel_sigmoid(args_t args)
-        : accel_implentation(args) {}
-
-	double virtual accelerate(double speed) override {
-		return k / (exp(-b * (speed - m)) + 1); 
-
-	}
-
-	void virtual verify(args_t args) override {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-};
-
-struct accel_power : accel_implentation {
-    accel_power(args_t args)
-        : accel_implentation(args) {}
-
-	double virtual accelerate(double speed) override {
-		return (offset > 0 && speed < 1) ? 0 : pow(speed*b, k) - 1;
-
-
-	}
-
-	void virtual verify(args_t args) override {
-		accel_implentation::verify(args);
-		if (args.lim_exp <= 1) error("exponent must be greater than 1");
-	}
-};
-
-using accel_implementation_t = tagged_union<accel_implentation, accel_linear, accel_classic, accel_logarithmic, accel_sigmoid, accel_power>;
-
-struct accel_function {
-
-    /* 
-    This value is ideally a few microseconds lower than 
-    the user's mouse polling interval, though it should
-    not matter if the system is stable.
-    */
-    milliseconds time_min = 0.4;
-    
-    double speed_offset = 0;
 
-    // speed midpoint in sigmoid mode
-    double m = 0;
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        accel_implentation() = default;
+    };
+
+    /// <summary> Struct to hold linear acceleration implementation. </summary>
+    struct accel_linear : accel_implentation<accel_linear> {
+
+        accel_linear(args_t args)
+            : accel_implentation(args) {}
+
+        double accelerate(double speed) {
+            //f(x) = mx
+            return b * speed;
+        }
+
+        void verify(args_t args) {
+            accel_implentation::verify(args);
+            if (args.lim_exp <= 1) error("limit must be greater than 1");
+        }
+    };
 
-    // accel ramp rate
-    double b = 0; 
+    /// <summary> Struct to hold "classic" (linear raised to power) acceleration implementation. </summary>
+    struct accel_classic : accel_implentation<accel_classic> {
+        accel_classic(args_t args)
+            : accel_implentation(args) {}
+
+        double accelerate(double speed) {
+            //f(x) = (mx)^k
+            return pow(b * speed, k);
+        }
+
+        void verify(args_t args) {
+            accel_implentation::verify(args);
+            if (args.lim_exp <= 1) error("exponent must be greater than 1");
+        }
+    };
+
+    /// <summary> Struct to hold "natural" (vanishing difference) acceleration implementation. </summary>
+    struct accel_natural : accel_implentation<accel_natural> {
+        accel_natural(args_t args)
+            : accel_implentation(args) 
+        { b /= k; }
+
+        double accelerate(double speed) {
+            // f(x) = k(1-e^(-mx))
+            return k - (k * exp(-b * speed));;
+        }
+
+        void verify(args_t args) {
+            accel_implentation::verify(args);
+            if (args.lim_exp <= 1) error("exponent must be greater than 1");
+        }
+    };
+
+    /// <summary> Struct to hold logarithmic acceleration implementation. </summary>
+    struct accel_logarithmic : accel_implentation<accel_logarithmic> {
+        accel_logarithmic(args_t args)
+            : accel_implentation(args) {}
+
+        double accelerate(double speed) {
+            return log(speed * b + 1);
+        }
 
-    // the limit for natural and sigmoid modes
-    // or the exponent for classic and power modes
-    double k = 1; 
+        void verify(args_t args) {
+            accel_implentation::verify(args);
+            if (args.lim_exp <= 1) error("exponent must be greater than 1");
+        }
+    };
+
+    /// <summary> Struct to hold sigmoid (s-shaped) acceleration implementation. </summary>
+    struct accel_sigmoid : accel_implentation<accel_sigmoid> {
+        accel_sigmoid(args_t args)
+            : accel_implentation(args) {}
+
+        double accelerate(double speed) {
+            //f(x) = k/(1+e^(-m(c-x)))
+            return k / (exp(-b * (speed - m)) + 1);
+        }
+
+        void verify(args_t args) {
+            accel_implentation::verify(args);
+            if (args.lim_exp <= 1) error("exponent must be greater than 1");
+        }
+    };
+
+    /// <summary> Struct to hold power (non-additive) acceleration implementation. </summary>
+    struct accel_power : accel_implentation<accel_power> {
+        accel_power(args_t args)
+            : accel_implentation(args)
+        { k++; }
+
+        double accelerate(double speed) {
+            //f(x) = (mx)^k - 1
+            // The subtraction of 1 is 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 * b, k) - 1;
+        }
+
+        void verify(args_t args) {
+            accel_implentation::verify(args);
+            if (args.lim_exp <= 0) error("exponent must be greater than 0");
+        }
+    };
+
+    /// <summary> Struct to hold acceleration implementation which applies no acceleration. </summary>
+    struct accel_noaccel : accel_implentation<accel_noaccel> {
+        accel_noaccel(args_t args)
+            : accel_implentation(args) {}
+
+        double accelerate(double speed) { return 0; }
+
+        void verify(args_t args) {}
+    };
     
-	accel_implementation_t accel = accel_implentation{};
+    using accel_implementation_t = tagged_union<accel_linear, accel_classic, accel_natural, accel_logarithmic, accel_sigmoid, accel_power, accel_noaccel>;
+
+    struct accel_function {
+
+        /*
+        This value is ideally a few microseconds lower than
+        the user's mouse polling interval, though it should
+        not matter if the system is stable.
+        */
+        milliseconds time_min = 0.4;
+
+        /// <summary> The offset past which acceleration is applied. </summary>
+        double speed_offset = 0;
+
+        accel_implementation_t accel;
+
+        vec2d weight = { 1, 1 };
+        vec2<accel_scale_clamp> clamp;
+
+        accel_function(args_t args) {
+            switch (args.accel_mode)
+            {
+				case mode::linear: accel = accel_linear(args);
+                    break;
+				case mode::classic: accel = accel_classic(args);
+                    break;
+				case mode::natural: accel = accel_natural(args);
+                    break;
+				case mode::logarithmic: accel = accel_logarithmic(args);
+                    break;
+				case mode::sigmoid: accel = accel_sigmoid(args);
+                    break;
+				case mode::power: accel = accel_power(args);
+            }
+
+            verify(args);
+
+            time_min = args.time_min;
+            speed_offset = args.offset;
+            weight = args.weight;
+            clamp.x = accel_scale_clamp(args.cap.x);
+            clamp.y = accel_scale_clamp(args.cap.y);
+        }
+
+        double apply(double speed) const {
+            return accel.visit([=](auto accel_t) { return accel_t.accelerate(speed); });
+        }
 
-    vec2d weight = { 1, 1 };
-    vec2<accel_scale_clamp> clamp;
+        void verify(args_t args) const {
+            return accel.visit([=](auto accel_t) { accel_t.verify(args); });
+        }
 
-    accel_function(args_t args) {
-        accel = accel_linear(args);
+        inline vec2d operator()(const vec2d& input, milliseconds time, mode accel_mode) const {
+            double mag = sqrtsd(input.x * input.x + input.y * input.y);
+            double time_clamped = clampsd(time, time_min, 100);
+            double speed = maxsd(mag / time_clamped - speed_offset, 0);
 
-        time_min = args.time_min;
-        m = args.midpoint;
-        b = args.accel;
-        k = args.lim_exp - 1;
-        if (args.accel_mode == mode::natural) b /= k;
-        if (args.accel_mode == mode::power) k++;
-        
-        speed_offset = args.offset;
-        weight = args.weight;
-        clamp.x = accel_scale_clamp(args.cap.x);
-        clamp.y = accel_scale_clamp(args.cap.y);
-    }
-
-	double apply(double speed) const {
-		return accel.visit([=](auto accel_t) { return accel_t.accelerate(speed); });
-	}
-
-    inline vec2d operator()(const vec2d& input, milliseconds time, mode accel_mode) const {
-        double mag = sqrtsd(input.x * input.x + input.y * input.y);
-        double time_clamped = clampsd(time, time_min, 100);
-        double speed = maxsd(mag / time_clamped - speed_offset, 0);
-
-        double accel_val = apply(speed);
-
-        double scale_x = weight.x * accel_val + 1;
-        double scale_y = weight.y * accel_val + 1;
-
-        return { 
-            input.x * clamp.x(scale_x), 
-            input.y * clamp.y(scale_y) 
-        };
-    }
-
-    accel_function() = default;
-};
-
-struct variables {
-    bool apply_rotate = false;
-    bool apply_accel = false;
-    mode accel_mode = mode::noaccel;
-    rotator rotate;
-    accel_function accel_fn;
-    vec2d sensitivity = { 1, 1 };
-
-    variables(double degrees, vec2d sens, args_t accel_args)
-        : accel_fn(accel_args)
-    {
-        apply_rotate = degrees != 0;
-        if (apply_rotate) rotate = rotator(degrees);
-        else rotate = rotator();
-
-        apply_accel = accel_args.accel_mode != mode::noaccel;
-        accel_mode = accel_args.accel_mode;
-
-        if (sens.x == 0) sens.x = 1;
-        if (sens.y == 0) sens.y = 1;
-        sensitivity = sens;
-    }
-
-    variables() = default;
-};
-
-} // rawaccel
+            double accel_val = apply(speed);
+
+            double scale_x = weight.x * accel_val + 1;
+            double scale_y = weight.y * accel_val + 1;
+
+            return {
+                input.x * clamp.x(scale_x),
+                input.y * clamp.y(scale_y)
+            };
+        }
+
+        accel_function() = default;
+    };
+
+    struct variables {
+        bool apply_rotate = false;
+        bool apply_accel = false;
+        mode accel_mode = mode::noaccel;
+        rotator rotate;
+        accel_function accel_fn;
+        vec2d sensitivity = { 1, 1 };
+
+        variables(double degrees, vec2d sens, args_t accel_args)
+            : accel_fn(accel_args)
+        {
+            apply_rotate = degrees != 0;
+            if (apply_rotate) rotate = rotator(degrees);
+            else rotate = rotator();
+
+            apply_accel = accel_args.accel_mode != mode::noaccel;
+            accel_mode = accel_args.accel_mode;
+
+            if (sens.x == 0) sens.x = 1;
+            if (sens.y == 0) sens.y = 1;
+            sensitivity = sens;
+        }
+
+        variables() = default;
+    };
+
+} // rawaccel
\ No newline at end of file
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index a5699ac..e9bbf2e 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "..\common\rawaccel.hpp";
-#include "..\common\rawaccel-userspace.hpp";
+#include "..\common\error.hpp";
 #include <iostream>
 using namespace rawaccel;
 using namespace System;
-- 
cgit v1.2.3


From f7a1883e4d26ebb2904518236656d53d8b5645b7 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 02:09:21 -0700
Subject: Remove extra mode from variables

---
 common/rawaccel.hpp | 4 +---
 driver/driver.cpp   | 2 +-
 wrapper/wrapper.cpp | 2 +-
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 3380e4c..28d9ee2 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -290,7 +290,7 @@ namespace rawaccel {
             return accel.visit([=](auto accel_t) { accel_t.verify(args); });
         }
 
-        inline vec2d operator()(const vec2d& input, milliseconds time, mode accel_mode) const {
+        inline vec2d operator()(const vec2d& input, milliseconds time) const {
             double mag = sqrtsd(input.x * input.x + input.y * input.y);
             double time_clamped = clampsd(time, time_min, 100);
             double speed = maxsd(mag / time_clamped - speed_offset, 0);
@@ -312,7 +312,6 @@ namespace rawaccel {
     struct variables {
         bool apply_rotate = false;
         bool apply_accel = false;
-        mode accel_mode = mode::noaccel;
         rotator rotate;
         accel_function accel_fn;
         vec2d sensitivity = { 1, 1 };
@@ -325,7 +324,6 @@ namespace rawaccel {
             else rotate = rotator();
 
             apply_accel = accel_args.accel_mode != mode::noaccel;
-            accel_mode = accel_args.accel_mode;
 
             if (sens.x == 0) sens.x = 1;
             if (sens.y == 0) sens.y = 1;
diff --git a/driver/driver.cpp b/driver/driver.cpp
index e77ac5f..5523f28 100644
--- a/driver/driver.cpp
+++ b/driver/driver.cpp
@@ -83,7 +83,7 @@ Arguments:
                     DebugPrint(("RA time < min with %d ticks\n", ticks));
                 }
 
-                input = global.vars.accel_fn(input, time, global.vars.accel_mode);
+                input = global.vars.accel_fn(input, time);
             }
 
             double result_x = input.x * global.vars.sensitivity.x + local_carry.x;
diff --git a/wrapper/wrapper.cpp b/wrapper/wrapper.cpp
index f3d069a..2c004e4 100644
--- a/wrapper/wrapper.cpp
+++ b/wrapper/wrapper.cpp
@@ -8,7 +8,7 @@ using namespace System;
 Tuple<double, double>^ ManagedAccel::Accelerate(int x, int y, double time, double mode)
 {
 	vec2d input_vec2d = {x, y};
-	vec2d output = (*accel_instance)(input_vec2d, (milliseconds)time, (rawaccel::mode)mode);
+	vec2d output = (*accel_instance)(input_vec2d, (milliseconds)time);
 
 	return gcnew Tuple<double, double>(output.x, output.y);
 }
\ No newline at end of file
-- 
cgit v1.2.3


From b1ef35050600978318581586691f5a8f119abf5b Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 02:44:09 -0700
Subject: Rename variables and add modify functions

---
 common/rawaccel-userspace.hpp |  4 ++--
 common/rawaccel.hpp           | 19 ++++++++++++++++---
 console/console.cpp           |  4 ++--
 driver/driver.cpp             | 26 +++++++++++++-------------
 4 files changed, 33 insertions(+), 20 deletions(-)

diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index bca6997..d0722b6 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -16,7 +16,7 @@ void error(const char* s) {
     throw std::domain_error(s); 
 }
 
-variables parse(int argc, char** argv) {
+mouse_modifier parse(int argc, char** argv) {
     double degrees = 0;
     vec2d sens = { 1, 1 };
     args_t accel_args{};
@@ -121,7 +121,7 @@ variables parse(int argc, char** argv) {
         std::exit(0);
     }
 
-    return variables(-degrees, sens, accel_args);
+    return mouse_modifier(-degrees, sens, accel_args);
 }
 
 } // rawaccel
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 28d9ee2..9b35568 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -309,14 +309,14 @@ namespace rawaccel {
         accel_function() = default;
     };
 
-    struct variables {
+    struct mouse_modifier {
         bool apply_rotate = false;
         bool apply_accel = false;
         rotator rotate;
         accel_function accel_fn;
         vec2d sensitivity = { 1, 1 };
 
-        variables(double degrees, vec2d sens, args_t accel_args)
+        mouse_modifier(double degrees, vec2d sens, args_t accel_args)
             : accel_fn(accel_args)
         {
             apply_rotate = degrees != 0;
@@ -330,7 +330,20 @@ namespace rawaccel {
             sensitivity = sens;
         }
 
-        variables() = default;
+        vec2d modify(vec2d input)
+        {
+            if (apply_rotate)
+            {
+                return rotate(input);
+            }
+        }
+
+        vec2d modify(vec2d input, milliseconds time)
+        {
+            return accel_fn(modify(input), time);
+        }
+
+        mouse_modifier() = default;
     };
 
 } // rawaccel
\ No newline at end of file
diff --git a/console/console.cpp b/console/console.cpp
index 6606cac..490051c 100644
--- a/console/console.cpp
+++ b/console/console.cpp
@@ -9,7 +9,7 @@
 
 namespace ra = rawaccel;
 
-void write(ra::variables vars) {
+void write(ra::mouse_modifier vars) {
 	HANDLE ra_handle = INVALID_HANDLE_VALUE;
 
 	ra_handle = CreateFileW(L"\\\\.\\rawaccel", 0, 0, 0, OPEN_EXISTING, 0, 0);
@@ -24,7 +24,7 @@ void write(ra::variables vars) {
 		ra_handle,               
 		RA_WRITE,
 		&vars,    
-		sizeof(ra::variables),      
+		sizeof(ra::mouse_modifier),      
 		NULL,                     // output buffer
 		0,                        // output buffer size
 		&dummy,                   // bytes returned
diff --git a/driver/driver.cpp b/driver/driver.cpp
index 5523f28..9704b21 100644
--- a/driver/driver.cpp
+++ b/driver/driver.cpp
@@ -15,7 +15,7 @@ using milliseconds = double;
 
 struct {
     milliseconds tick_interval = 0; // set in DriverEntry
-    ra::variables vars;
+    ra::mouse_modifier modifier;
 } global;
 
 VOID
@@ -69,25 +69,25 @@ Arguments:
                 static_cast<double>(it->LastY)
             };
 
-            if (global.vars.apply_rotate) {
-                input = global.vars.rotate(input);
-            }
-
-            if (global.vars.apply_accel && local_apply_accel) {
+            if (global.modifier.apply_accel && local_apply_accel) {
                 auto now = KeQueryPerformanceCounter(NULL).QuadPart;
                 auto ticks = now - devExt->counter.QuadPart;
                 devExt->counter.QuadPart = now;
 
                 milliseconds time = ticks * global.tick_interval;
-                if (time < global.vars.accel_fn.time_min) {
+                if (time < global.modifier.accel_fn.time_min) {
                     DebugPrint(("RA time < min with %d ticks\n", ticks));
                 }
 
-                input = global.vars.accel_fn(input, time);
+                input = global.modifier.modify(input, time);
+            }
+            else
+            {
+                input = global.modifier.modify(input);
             }
 
-            double result_x = input.x * global.vars.sensitivity.x + local_carry.x;
-            double result_y = input.y * global.vars.sensitivity.y + local_carry.y;
+            double result_x = input.x * global.modifier.sensitivity.x + local_carry.x;
+            double result_y = input.y * global.modifier.sensitivity.y + local_carry.y;
 
             LONG out_x = static_cast<LONG>(result_x);
             LONG out_y = static_cast<LONG>(result_y);
@@ -154,7 +154,7 @@ Return Value:
 
     DebugPrint(("Ioctl received into filter control object.\n"));
 
-    if (InputBufferLength != sizeof(ra::variables)) {
+    if (InputBufferLength != sizeof(ra::mouse_modifier)) {
         DebugPrint(("Received unknown request of %u bytes\n", InputBufferLength));
         // status maps to win32 error code 1784: ERROR_INVALID_USER_BUFFER
         WdfRequestComplete(Request, STATUS_INVALID_BUFFER_SIZE);
@@ -163,7 +163,7 @@ Return Value:
 
     status = WdfRequestRetrieveInputBuffer(
         Request,
-        sizeof(ra::variables),
+        sizeof(ra::mouse_modifier),
         &input_buffer,
         &input_size
     );
@@ -175,7 +175,7 @@ Return Value:
         return;
     }
 
-    global.vars = *reinterpret_cast<ra::variables*>(input_buffer);
+    global.modifier = *reinterpret_cast<ra::mouse_modifier*>(input_buffer);
 
     WdfRequestComplete(Request, STATUS_SUCCESS);
 }
-- 
cgit v1.2.3


From 41a2448dc9a76b7d39e86cc5ee3b1d6a1583ba72 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 13:25:53 -0700
Subject: Fix not all paths returning value

---
 common/rawaccel.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 9b35568..9d4b5e3 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -330,15 +330,17 @@ namespace rawaccel {
             sensitivity = sens;
         }
 
-        vec2d modify(vec2d input)
+        inline vec2d modify(vec2d input)
         {
             if (apply_rotate)
             {
                 return rotate(input);
             }
+
+            return input;
         }
 
-        vec2d modify(vec2d input, milliseconds time)
+        inline vec2d modify(vec2d input, milliseconds time)
         {
             return accel_fn(modify(input), time);
         }
-- 
cgit v1.2.3


From 9e55978ad8b8da90bb30407047b399e9c430c070 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 14:54:31 -0700
Subject: More comments and light refactoring

---
 common/rawaccel.hpp | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 grapher/Form1.cs    |  4 ++--
 wrapper/wrapper.cpp |  2 +-
 wrapper/wrapper.hpp |  2 +-
 4 files changed, 61 insertions(+), 7 deletions(-)

diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 9d4b5e3..2b45c06 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -9,11 +9,20 @@
 
 namespace rawaccel {
 
+    /// <summary> Enum to hold acceleration implementation types (i.e. types of curves.) </summary>
     enum class mode { noaccel, linear, classic, natural, logarithmic, sigmoid, power };
 
+    /// <summary> Struct to hold vector rotation details. </summary>
     struct rotator {
+
+        /// <summary> Rotational vector, which points in the direction of the post-rotation positive y axis. </summary>
         vec2d rot_vec = { 1, 0 };
 
+        /// <summary>
+        /// Rotates given input vector according to struct's rotational vector.
+        /// </summary>
+        /// <param name="input">Input vector to be rotated</param>
+        /// <returns>2d vector of rotated input.</returns>
         inline vec2d operator()(const vec2d& input) const {
             return {
                 input.x * rot_vec.x - input.y * rot_vec.y,
@@ -29,10 +38,16 @@ namespace rawaccel {
         rotator() = default;
     };
 
+    /// <summary> Struct to hold clamp (min and max) details for acceleration application </summary>
     struct accel_scale_clamp {
         double lo = 0;
         double hi = 9;
 
+        /// <summary>
+        /// Clamps given input to min at lo, max at hi.
+        /// </summary>
+        /// <param name="scale">Double to be clamped</param>
+        /// <returns>Clamped input as double</returns>
         inline double operator()(double scale) const {
             return clampsd(scale, lo, hi);
         }
@@ -54,6 +69,7 @@ namespace rawaccel {
         accel_scale_clamp() = default;
     };
 
+// Error throwing calls std libraries which are unavailable in kernel mode.
 #ifdef _KERNEL_MODE
     void error(const char*) {}
 #else
@@ -62,6 +78,7 @@ namespace rawaccel {
 
     using milliseconds = double;
 
+    /// <summary> Struct to hold arguments for an acceleration function. </summary>
     struct args_t {
         mode accel_mode = mode::noaccel;
         milliseconds time_min = 0.4;
@@ -74,7 +91,7 @@ namespace rawaccel {
     };
 
     /// <summary>
-    /// Struct to hold acceleration implementation details.
+    /// Struct to hold acceleration curve implementation details.
     /// </summary>
     /// <typeparam name="T">Type of acceleration.</typeparam>
     template <typename T>
@@ -216,8 +233,8 @@ namespace rawaccel {
         { k++; }
 
         double accelerate(double speed) {
-            //f(x) = (mx)^k - 1
-            // The subtraction of 1 is with later addition of 1 in mind, 
+            // 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 * b, k) - 1;
         }
@@ -238,8 +255,10 @@ namespace rawaccel {
         void verify(args_t args) {}
     };
     
+    /// <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>;
 
+    /// <summary> Struct for holding acceleration application details. </summary>
     struct accel_function {
 
         /*
@@ -247,14 +266,19 @@ namespace rawaccel {
         the user's mouse polling interval, though it should
         not matter if the system is stable.
         */
+        /// <summary> The minimum time period for one mouse movement. </summary>
         milliseconds time_min = 0.4;
 
         /// <summary> The offset past which acceleration is applied. </summary>
         double speed_offset = 0;
 
+        /// <summary> The acceleration implementation (i.e. curve) </summary>
         accel_implementation_t accel;
 
+        /// <summary> The weight of acceleration applied in {x, y} dimensions. </summary>
         vec2d weight = { 1, 1 };
+
+        /// <summary> The object which sets a min and max for the acceleration scale. </summary>
         vec2<accel_scale_clamp> clamp;
 
         accel_function(args_t args) {
@@ -273,6 +297,8 @@ namespace rawaccel {
 				case mode::power: accel = accel_power(args);
             }
 
+            // Verification is performed by the accel_implementation object
+            // and therefore must occur after the object has been instantiated
             verify(args);
 
             time_min = args.time_min;
@@ -282,14 +308,29 @@ namespace rawaccel {
             clamp.y = accel_scale_clamp(args.cap.y);
         }
 
+        /// <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
+        /// </summary>
+        /// <param name="args">Arguments to be verified</param>
         void verify(args_t args) const {
             return accel.visit([=](auto accel_t) { accel_t.verify(args); });
         }
 
+        /// <summary>
+        /// Applies weighted acceleration to given input for given time period.
+        /// </summary>
+        /// <param name="input">2d vector of {x, y} mouse movement to be accelerated</param>
+        /// <param name="time">Time period over which input movement was accumulated</param>
+        /// <returns></returns>
         inline vec2d operator()(const vec2d& input, milliseconds time) const {
             double mag = sqrtsd(input.x * input.x + input.y * input.y);
             double time_clamped = clampsd(time, time_min, 100);
@@ -309,6 +350,7 @@ namespace rawaccel {
         accel_function() = default;
     };
 
+    /// <summary> Struct to hold variables and methods for modifying mouse input </summary>
     struct mouse_modifier {
         bool apply_rotate = false;
         bool apply_accel = false;
@@ -330,6 +372,12 @@ namespace rawaccel {
             sensitivity = sens;
         }
 
+        /// <summary>
+        /// Applies modification without acceleration. Rotation is the only
+        /// modification currently implemented.
+        /// </summary>
+        /// <param name="input">Input to be modified.</param>
+        /// <returns>2d vector of modified input.</returns>
         inline vec2d modify(vec2d input)
         {
             if (apply_rotate)
@@ -340,6 +388,12 @@ namespace rawaccel {
             return input;
         }
 
+        /// <summary>
+        /// Applies modification, including acceleration.
+        /// </summary>
+        /// <param name="input">Input to be modified</param>
+        /// <param name="time">Time period for determining acceleration.</param>
+        /// <returns>2d vector with modified input.</returns>
         inline vec2d modify(vec2d input, milliseconds time)
         {
             return accel_fn(modify(input), time);
diff --git a/grapher/Form1.cs b/grapher/Form1.cs
index 1915b01..4165b0f 100644
--- a/grapher/Form1.cs
+++ b/grapher/Form1.cs
@@ -15,14 +15,14 @@ namespace grapher
         public RawAcceleration()
         {
             InitializeComponent();
-            var managedAccel = new ManagedAccel(6, 0, 1, 0.025, 0);
+            var managedAccel = new ManagedAccel(6, 0, 1.333, 0.05, 0);
             var orderedPoints = new SortedDictionary<double, double>();
 
             for (int i = 0; i < 100; i++)
             {
                 for (int j = 0; j <= i; j++)
                 {
-                    var output = managedAccel.Accelerate(i, j, 1, 6);
+                    var output = managedAccel.Accelerate(i, j, 1);
 
                     var inMagnitude = Magnitude(i,j);
                     var outMagnitude = Magnitude(output.Item1, output.Item2);
diff --git a/wrapper/wrapper.cpp b/wrapper/wrapper.cpp
index 2c004e4..1adafba 100644
--- a/wrapper/wrapper.cpp
+++ b/wrapper/wrapper.cpp
@@ -5,7 +5,7 @@
 using namespace rawaccel;
 using namespace System;
 
-Tuple<double, double>^ ManagedAccel::Accelerate(int x, int y, double time, double mode)
+Tuple<double, double>^ ManagedAccel::Accelerate(int x, int y, double time)
 {
 	vec2d input_vec2d = {x, y};
 	vec2d output = (*accel_instance)(input_vec2d, (milliseconds)time);
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index e9bbf2e..0307b4c 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -48,5 +48,5 @@ public:
         return accel_instance;
     }
 
-    Tuple<double, double>^ Accelerate(int x, int y, double time, double mode);
+    Tuple<double, double>^ Accelerate(int x, int y, double time);
 };
\ No newline at end of file
-- 
cgit v1.2.3


From 06d6d8d3e3cb5186daab029f2d7c7fa3ea0438d2 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 15:25:41 -0700
Subject: Rename acceleration constants, arguments

---
 common/rawaccel-userspace.hpp |  2 +-
 common/rawaccel.hpp           | 74 +++++++++++++++++++++----------------------
 wrapper/wrapper.hpp           |  2 +-
 3 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index d0722b6..5996364 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -19,7 +19,7 @@ void error(const char* s) {
 mouse_modifier parse(int argc, char** argv) {
     double degrees = 0;
     vec2d sens = { 1, 1 };
-    args_t accel_args{};
+    accel_args accel_args{};
 
     auto make_opt_vec = [](vec2d& v, auto first_flag, auto... rest) {
         return clipp::option(first_flag, rest...) & (
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 2b45c06..e904350 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -79,7 +79,7 @@ namespace rawaccel {
     using milliseconds = double;
 
     /// <summary> Struct to hold arguments for an acceleration function. </summary>
-    struct args_t {
+    struct accel_args {
         mode accel_mode = mode::noaccel;
         milliseconds time_min = 0.4;
         double offset = 0;
@@ -97,14 +97,14 @@ namespace rawaccel {
     template <typename T>
     struct accel_implentation {
         
-        /// <summary> The acceleration ramp rate.</summary>
-        double b = 0;
+        /// <summary> First constant for use in acceleration curves. Generally, the acceleration ramp rate.</summary>
+        double curve_constant_one = 0;
 
-        /// <summary> The limit or exponent for various modes. </summary>
-        double k = 0;
+        /// <summary> Second constant for use in acceleration curves. Generally, the limit or exponent in the curve. </summary>
+        double curve_constant_two = 0;
 
-        /// <summary> The midpoint in sigmoid mode. </summary>
-        double m = 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;
@@ -114,11 +114,11 @@ namespace rawaccel {
         /// </summary>
         /// <param name="args"></param>
         /// <returns></returns>
-        accel_implentation(args_t args)
+        accel_implentation(accel_args args)
         {
-            b = args.accel;
-            k = args.lim_exp - 1;
-            m = args.midpoint;
+            curve_constant_one = args.accel;
+            curve_constant_two = args.lim_exp - 1;
+            curve_constant_three = args.midpoint;
             offset = args.offset;
         }
 
@@ -133,7 +133,7 @@ namespace rawaccel {
         /// Verifies arguments as valid. Errors if not.
         /// </summary>
         /// <param name="args">Arguments to verified.</param>
-        void verify(args_t args) {
+        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");
         }
@@ -148,15 +148,15 @@ namespace rawaccel {
     /// <summary> Struct to hold linear acceleration implementation. </summary>
     struct accel_linear : accel_implentation<accel_linear> {
 
-        accel_linear(args_t args)
+        accel_linear(accel_args args)
             : accel_implentation(args) {}
 
         double accelerate(double speed) {
             //f(x) = mx
-            return b * speed;
+            return curve_constant_one * speed;
         }
 
-        void verify(args_t args) {
+        void verify(accel_args args) {
             accel_implentation::verify(args);
             if (args.lim_exp <= 1) error("limit must be greater than 1");
         }
@@ -164,15 +164,15 @@ namespace rawaccel {
 
     /// <summary> Struct to hold "classic" (linear raised to power) acceleration implementation. </summary>
     struct accel_classic : accel_implentation<accel_classic> {
-        accel_classic(args_t args)
+        accel_classic(accel_args args)
             : accel_implentation(args) {}
 
         double accelerate(double speed) {
             //f(x) = (mx)^k
-            return pow(b * speed, k);
+            return pow(curve_constant_one * speed, curve_constant_two);
         }
 
-        void verify(args_t args) {
+        void verify(accel_args args) {
             accel_implentation::verify(args);
             if (args.lim_exp <= 1) error("exponent must be greater than 1");
         }
@@ -180,16 +180,16 @@ namespace rawaccel {
 
     /// <summary> Struct to hold "natural" (vanishing difference) acceleration implementation. </summary>
     struct accel_natural : accel_implentation<accel_natural> {
-        accel_natural(args_t args)
+        accel_natural(accel_args args)
             : accel_implentation(args) 
-        { b /= k; }
+        { curve_constant_one /= curve_constant_two; }
 
         double accelerate(double speed) {
             // f(x) = k(1-e^(-mx))
-            return k - (k * exp(-b * speed));;
+            return curve_constant_two - (curve_constant_two * exp(-curve_constant_one * speed));;
         }
 
-        void verify(args_t args) {
+        void verify(accel_args args) {
             accel_implentation::verify(args);
             if (args.lim_exp <= 1) error("exponent must be greater than 1");
         }
@@ -197,14 +197,14 @@ namespace rawaccel {
 
     /// <summary> Struct to hold logarithmic acceleration implementation. </summary>
     struct accel_logarithmic : accel_implentation<accel_logarithmic> {
-        accel_logarithmic(args_t args)
+        accel_logarithmic(accel_args args)
             : accel_implentation(args) {}
 
         double accelerate(double speed) {
-            return log(speed * b + 1);
+            return log(speed * curve_constant_one + 1);
         }
 
-        void verify(args_t args) {
+        void verify(accel_args args) {
             accel_implentation::verify(args);
             if (args.lim_exp <= 1) error("exponent must be greater than 1");
         }
@@ -212,15 +212,15 @@ namespace rawaccel {
 
     /// <summary> Struct to hold sigmoid (s-shaped) acceleration implementation. </summary>
     struct accel_sigmoid : accel_implentation<accel_sigmoid> {
-        accel_sigmoid(args_t args)
+        accel_sigmoid(accel_args args)
             : accel_implentation(args) {}
 
         double accelerate(double speed) {
             //f(x) = k/(1+e^(-m(c-x)))
-            return k / (exp(-b * (speed - m)) + 1);
+            return curve_constant_two / (exp(-curve_constant_one * (speed - curve_constant_three)) + 1);
         }
 
-        void verify(args_t args) {
+        void verify(accel_args args) {
             accel_implentation::verify(args);
             if (args.lim_exp <= 1) error("exponent must be greater than 1");
         }
@@ -228,18 +228,18 @@ namespace rawaccel {
 
     /// <summary> Struct to hold power (non-additive) acceleration implementation. </summary>
     struct accel_power : accel_implentation<accel_power> {
-        accel_power(args_t args)
+        accel_power(accel_args args)
             : accel_implentation(args)
-        { k++; }
+        { curve_constant_two++; }
 
         double 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 * b, k) - 1;
+            return (offset > 0 && speed < 1) ? 0 : pow(speed * curve_constant_one, curve_constant_two) - 1;
         }
 
-        void verify(args_t args) {
+        void verify(accel_args args) {
             accel_implentation::verify(args);
             if (args.lim_exp <= 0) error("exponent must be greater than 0");
         }
@@ -247,12 +247,12 @@ namespace rawaccel {
 
     /// <summary> Struct to hold acceleration implementation which applies no acceleration. </summary>
     struct accel_noaccel : accel_implentation<accel_noaccel> {
-        accel_noaccel(args_t args)
+        accel_noaccel(accel_args args)
             : accel_implentation(args) {}
 
         double accelerate(double speed) { return 0; }
 
-        void verify(args_t args) {}
+        void verify(accel_args args) {}
     };
     
     /// <summary> Tagged union to hold all accel implementations and allow "polymorphism" via a visitor call. </summary>
@@ -281,7 +281,7 @@ namespace rawaccel {
         /// <summary> The object which sets a min and max for the acceleration scale. </summary>
         vec2<accel_scale_clamp> clamp;
 
-        accel_function(args_t args) {
+        accel_function(accel_args args) {
             switch (args.accel_mode)
             {
 				case mode::linear: accel = accel_linear(args);
@@ -321,7 +321,7 @@ namespace rawaccel {
         /// Verifies acceleration arguments, via visitor function to accel_implementation_t
         /// </summary>
         /// <param name="args">Arguments to be verified</param>
-        void verify(args_t args) const {
+        void verify(accel_args args) const {
             return accel.visit([=](auto accel_t) { accel_t.verify(args); });
         }
 
@@ -358,7 +358,7 @@ namespace rawaccel {
         accel_function accel_fn;
         vec2d sensitivity = { 1, 1 };
 
-        mouse_modifier(double degrees, vec2d sens, args_t accel_args)
+        mouse_modifier(double degrees, vec2d sens, accel_args accel_args)
             : accel_fn(accel_args)
         {
             apply_rotate = degrees != 0;
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index 0307b4c..271b61b 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -18,7 +18,7 @@ public:
 
     ManagedAccel(double mode, double offset, double accel, double lim_exp, double midpoint)
     {
-        args_t args{};
+        accel_args args{};
         args.accel = accel;
         args.lim_exp = lim_exp;
         args.midpoint = midpoint;
-- 
cgit v1.2.3


From cdd82efdfdd7c2e9b4c2ed9777792f9921eedb9e Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 17:21:39 -0700
Subject: Get rid of enum and use types\tags directly

---
 common/rawaccel-userspace.hpp | 14 +++++++-------
 common/rawaccel.hpp           | 24 +++++-------------------
 grapher/Form1.cs              |  2 +-
 wrapper/wrapper.hpp           |  4 ++--
 4 files changed, 15 insertions(+), 29 deletions(-)

diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index 5996364..82a9e98 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -68,34 +68,34 @@ mouse_modifier parse(int argc, char** argv) {
 
     // modes
     auto noaccel_mode = "no-accel mode" % (
-        clipp::command("off", "noaccel").set(accel_args.accel_mode, mode::noaccel)
+        clipp::command("off", "noaccel").set(accel_args.accel_mode, accel_implementation_t::id<accel_noaccel>)
     );
     auto lin_mode = "linear accel mode:" % (
-        clipp::command("linear").set(accel_args.accel_mode, mode::linear),
+        clipp::command("linear").set(accel_args.accel_mode, accel_implementation_t::id<accel_linear>),
         accel_var
     );
     auto classic_mode = "classic accel mode:" % (
-        clipp::command("classic").set(accel_args.accel_mode, mode::classic),
+        clipp::command("classic").set(accel_args.accel_mode, accel_implementation_t::id<accel_classic>),
         accel_var,
         (clipp::required("exponent") & clipp::number("num", accel_args.lim_exp)) % "exponent"
     );
     auto nat_mode = "natural accel mode:" % (
-        clipp::command("natural").set(accel_args.accel_mode, mode::natural),
+        clipp::command("natural").set(accel_args.accel_mode, accel_implementation_t::id<accel_natural>),
         accel_var,
         limit_var
     );
     auto log_mode = "logarithmic accel mode:" % (
-        clipp::command("logarithmic").set(accel_args.accel_mode, mode::logarithmic),
+        clipp::command("logarithmic").set(accel_args.accel_mode, accel_implementation_t::id<accel_logarithmic>),
         accel_var
     );
     auto sig_mode = "sigmoid accel mode:" % (
-        clipp::command("sigmoid").set(accel_args.accel_mode, mode::sigmoid),
+        clipp::command("sigmoid").set(accel_args.accel_mode, accel_implementation_t::id<accel_sigmoid>),
         accel_var,
         limit_var,
         (clipp::required("midpoint") & clipp::number("speed", accel_args.midpoint)) % "midpoint"
     );
     auto pow_mode = "power accel mode:" % (
-        clipp::command("power").set(accel_args.accel_mode, mode::power) >> [&] { accel_args.accel = 1; },
+        clipp::command("power").set(accel_args.accel_mode, accel_implementation_t::id<accel_power>) >> [&] { accel_args.accel = 1; },
         (clipp::required("exponent") & clipp::number("num", accel_args.lim_exp)) % "exponent",
         (clipp::option("scale") & clipp::number("num", accel_args.accel)) % "scale factor"
     );
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index e904350..08829dd 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -9,9 +9,6 @@
 
 namespace rawaccel {
 
-    /// <summary> Enum to hold acceleration implementation types (i.e. types of curves.) </summary>
-    enum class mode { noaccel, linear, classic, natural, logarithmic, sigmoid, power };
-
     /// <summary> Struct to hold vector rotation details. </summary>
     struct rotator {
 
@@ -80,7 +77,7 @@ namespace rawaccel {
 
     /// <summary> Struct to hold arguments for an acceleration function. </summary>
     struct accel_args {
-        mode accel_mode = mode::noaccel;
+        int accel_mode = 0;
         milliseconds time_min = 0.4;
         double offset = 0;
         double accel = 0;
@@ -282,20 +279,8 @@ namespace rawaccel {
         vec2<accel_scale_clamp> clamp;
 
         accel_function(accel_args args) {
-            switch (args.accel_mode)
-            {
-				case mode::linear: accel = accel_linear(args);
-                    break;
-				case mode::classic: accel = accel_classic(args);
-                    break;
-				case mode::natural: accel = accel_natural(args);
-                    break;
-				case mode::logarithmic: accel = accel_logarithmic(args);
-                    break;
-				case mode::sigmoid: accel = accel_sigmoid(args);
-                    break;
-				case mode::power: accel = accel_power(args);
-            }
+            accel.tag = args.accel_mode;
+            accel.visit([&](auto& a){ a = {args}; });
 
             // Verification is performed by the accel_implementation object
             // and therefore must occur after the object has been instantiated
@@ -365,7 +350,8 @@ namespace rawaccel {
             if (apply_rotate) rotate = rotator(degrees);
             else rotate = rotator();
 
-            apply_accel = accel_args.accel_mode != mode::noaccel;
+            apply_accel = (accel_args.accel_mode != 0 &&
+						   accel_args.accel_mode != accel_implementation_t::id<accel_noaccel>);
 
             if (sens.x == 0) sens.x = 1;
             if (sens.y == 0) sens.y = 1;
diff --git a/grapher/Form1.cs b/grapher/Form1.cs
index 4165b0f..495640e 100644
--- a/grapher/Form1.cs
+++ b/grapher/Form1.cs
@@ -15,7 +15,7 @@ namespace grapher
         public RawAcceleration()
         {
             InitializeComponent();
-            var managedAccel = new ManagedAccel(6, 0, 1.333, 0.05, 0);
+            var managedAccel = new ManagedAccel(5, 0, 0.3, 1.25, 15);
             var orderedPoints = new SortedDictionary<double, double>();
 
             for (int i = 0; i < 100; i++)
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index 271b61b..727bfcc 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -16,13 +16,13 @@ public:
 	{
 	}
 
-    ManagedAccel(double mode, double offset, double accel, double lim_exp, double midpoint)
+    ManagedAccel(int mode, double offset, double accel, double lim_exp, double midpoint)
     {
         accel_args args{};
         args.accel = accel;
         args.lim_exp = lim_exp;
         args.midpoint = midpoint;
-        args.accel_mode = (rawaccel::mode)mode;
+        args.accel_mode = mode;
         args.offset = offset;
 
 		accel_instance = new accel_function(args);
-- 
cgit v1.2.3


From 344f759dad28c8b3866d7942bd8927ef1caaf6ab Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Tue, 28 Jul 2020 18:16:12 -0700
Subject: add per-class args structs

---
 common/rawaccel-userspace.hpp | 44 ++++++++++++++++----------------
 common/rawaccel.hpp           | 58 ++++++++++++++++++++++++++-----------------
 wrapper/wrapper.hpp           | 10 ++++----
 3 files changed, 61 insertions(+), 51 deletions(-)

diff --git a/common/rawaccel-userspace.hpp b/common/rawaccel-userspace.hpp
index 82a9e98..3e8886f 100644
--- a/common/rawaccel-userspace.hpp
+++ b/common/rawaccel-userspace.hpp
@@ -17,9 +17,7 @@ void error(const char* s) {
 }
 
 mouse_modifier parse(int argc, char** argv) {
-    double degrees = 0;
-    vec2d sens = { 1, 1 };
-    accel_args accel_args{};
+    modifier_args modifier_args{};
 
     auto make_opt_vec = [](vec2d& v, auto first_flag, auto... rest) {
         return clipp::option(first_flag, rest...) & (
@@ -40,64 +38,64 @@ mouse_modifier parse(int argc, char** argv) {
     };
 
     // default options
-    auto opt_sens = "sensitivity (default = 1)" % make_opt_vec(sens, "sens");
+    auto opt_sens = "sensitivity (default = 1)" % make_opt_vec(modifier_args.sens, "sens");
 
     auto opt_rot = "counter-clockwise rotation (default = 0)" % (
         clipp::option("rotate") &
-        clipp::number("degrees", degrees)
+        clipp::number("degrees", modifier_args.degrees)
     );
     
     // mode-independent accel options
     auto opt_weight = "accel multiplier (default = 1)" % 
-        make_opt_vec(accel_args.weight, "weight");
+        make_opt_vec(modifier_args.acc_fn_args.weight, "weight");
 
     auto opt_offset = "speed (dots/ms) where accel kicks in (default = 0)" % (
-        clipp::option("offset") & clipp::number("speed", accel_args.offset)
+        clipp::option("offset") & clipp::number("speed", modifier_args.acc_fn_args.acc_args.offset)
     );
 
     auto opt_cap = "accel scale cap (default = 9)" % 
-        make_opt_vec(accel_args.cap, "cap");
+        make_opt_vec(modifier_args.acc_fn_args.cap, "cap");
 
     auto opt_tmin = "minimum time between polls (default = 0.4)" % (
         clipp::option("tmin") &
-        clipp::number("ms", accel_args.time_min)
+        clipp::number("ms", modifier_args.acc_fn_args.acc_args.time_min)
     );
 
-    auto accel_var = (clipp::required("accel") & clipp::number("num", accel_args.accel)) % "ramp rate";
-    auto limit_var = (clipp::required("limit") & clipp::number("scale", accel_args.lim_exp)) % "limit";
+    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";
 
     // modes
     auto noaccel_mode = "no-accel mode" % (
-        clipp::command("off", "noaccel").set(accel_args.accel_mode, accel_implementation_t::id<accel_noaccel>)
+        clipp::command("off", "noaccel").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_noaccel>)
     );
     auto lin_mode = "linear accel mode:" % (
-        clipp::command("linear").set(accel_args.accel_mode, accel_implementation_t::id<accel_linear>),
+        clipp::command("linear").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_linear>),
         accel_var
     );
     auto classic_mode = "classic accel mode:" % (
-        clipp::command("classic").set(accel_args.accel_mode, accel_implementation_t::id<accel_classic>),
+        clipp::command("classic").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_classic>),
         accel_var,
-        (clipp::required("exponent") & clipp::number("num", accel_args.lim_exp)) % "exponent"
+        (clipp::required("exponent") & clipp::number("num", modifier_args.acc_fn_args.acc_args.lim_exp)) % "exponent"
     );
     auto nat_mode = "natural accel mode:" % (
-        clipp::command("natural").set(accel_args.accel_mode, accel_implementation_t::id<accel_natural>),
+        clipp::command("natural").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_natural>),
         accel_var,
         limit_var
     );
     auto log_mode = "logarithmic accel mode:" % (
-        clipp::command("logarithmic").set(accel_args.accel_mode, accel_implementation_t::id<accel_logarithmic>),
+        clipp::command("logarithmic").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_logarithmic>),
         accel_var
     );
     auto sig_mode = "sigmoid accel mode:" % (
-        clipp::command("sigmoid").set(accel_args.accel_mode, accel_implementation_t::id<accel_sigmoid>),
+        clipp::command("sigmoid").set(modifier_args.acc_fn_args.accel_mode, accel_implementation_t::id<accel_sigmoid>),
         accel_var,
         limit_var,
-        (clipp::required("midpoint") & clipp::number("speed", accel_args.midpoint)) % "midpoint"
+        (clipp::required("midpoint") & clipp::number("speed", modifier_args.acc_fn_args.acc_args.midpoint)) % "midpoint"
     );
     auto pow_mode = "power accel mode:" % (
-        clipp::command("power").set(accel_args.accel_mode, accel_implementation_t::id<accel_power>) >> [&] { accel_args.accel = 1; },
-        (clipp::required("exponent") & clipp::number("num", accel_args.lim_exp)) % "exponent",
-        (clipp::option("scale") & clipp::number("num", accel_args.accel)) % "scale factor"
+        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"
     );
 
     auto accel_mode_exclusive = (lin_mode | classic_mode | nat_mode | log_mode | sig_mode | pow_mode);
@@ -121,7 +119,7 @@ mouse_modifier parse(int argc, char** argv) {
         std::exit(0);
     }
 
-    return mouse_modifier(-degrees, sens, accel_args);
+    return mouse_modifier(modifier_args);
 }
 
 } // rawaccel
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 08829dd..9cfa5e7 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -9,6 +9,13 @@
 
 namespace rawaccel {
 
+// Error throwing calls std libraries which are unavailable in kernel mode.
+#ifdef _KERNEL_MODE
+    void error(const char*) {}
+#else
+    void error(const char* s);
+#endif
+
     /// <summary> Struct to hold vector rotation details. </summary>
     struct rotator {
 
@@ -66,25 +73,15 @@ namespace rawaccel {
         accel_scale_clamp() = default;
     };
 
-// Error throwing calls std libraries which are unavailable in kernel mode.
-#ifdef _KERNEL_MODE
-    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 {
-        int accel_mode = 0;
         milliseconds time_min = 0.4;
         double offset = 0;
         double accel = 0;
         double lim_exp = 2;
         double midpoint = 0;
-        vec2d weight = { 1, 1 };
-        vec2d cap = { 0, 0 };
     };
 
     /// <summary>
@@ -255,6 +252,14 @@ 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>;
 
+    struct accel_fn_args {
+        accel_args acc_args = accel_args{};
+        int accel_mode = 0;
+        milliseconds time_min = 0.4;
+        vec2d weight = { 1, 1 };
+        vec2d cap = { 0, 0 };
+    };
+
     /// <summary> Struct for holding acceleration application details. </summary>
     struct accel_function {
 
@@ -278,16 +283,16 @@ namespace rawaccel {
         /// <summary> The object which sets a min and max for the acceleration scale. </summary>
         vec2<accel_scale_clamp> clamp;
 
-        accel_function(accel_args args) {
+        accel_function(accel_fn_args args) {
             accel.tag = args.accel_mode;
-            accel.visit([&](auto& a){ a = {args}; });
+            accel.visit([&](auto& a){ a = {args.acc_args}; });
 
             // Verification is performed by the accel_implementation object
             // and therefore must occur after the object has been instantiated
-            verify(args);
+            verify(args.acc_args);
 
             time_min = args.time_min;
-            speed_offset = args.offset;
+            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);
@@ -335,6 +340,13 @@ namespace rawaccel {
         accel_function() = default;
     };
 
+    struct modifier_args
+    {
+        double degrees = 0;
+        vec2d sens = { 1, 1 };
+        accel_fn_args acc_fn_args = accel_fn_args{};
+    };
+
     /// <summary> Struct to hold variables and methods for modifying mouse input </summary>
     struct mouse_modifier {
         bool apply_rotate = false;
@@ -343,19 +355,19 @@ namespace rawaccel {
         accel_function accel_fn;
         vec2d sensitivity = { 1, 1 };
 
-        mouse_modifier(double degrees, vec2d sens, accel_args accel_args)
-            : accel_fn(accel_args)
+        mouse_modifier(modifier_args args)
+            : accel_fn(args.acc_fn_args)
         {
-            apply_rotate = degrees != 0;
-            if (apply_rotate) rotate = rotator(degrees);
+            apply_rotate = args.degrees != 0;
+            if (apply_rotate) rotate = rotator(args.degrees);
             else rotate = rotator();
 
-            apply_accel = (accel_args.accel_mode != 0 &&
-						   accel_args.accel_mode != accel_implementation_t::id<accel_noaccel>);
+            apply_accel = (args.acc_fn_args.accel_mode != 0 &&
+						   args.acc_fn_args.accel_mode != accel_implementation_t::id<accel_noaccel>);
 
-            if (sens.x == 0) sens.x = 1;
-            if (sens.y == 0) sens.y = 1;
-            sensitivity = sens;
+            if (args.sens.x == 0) args.sens.x = 1;
+            if (args.sens.y == 0) args.sens.y = 1;
+            sensitivity = args.sens;
         }
 
         /// <summary>
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index 727bfcc..2cbc01c 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -18,12 +18,12 @@ public:
 
     ManagedAccel(int mode, double offset, double accel, double lim_exp, double midpoint)
     {
-        accel_args args{};
-        args.accel = accel;
-        args.lim_exp = lim_exp;
-        args.midpoint = midpoint;
+        accel_fn_args args{};
+        args.acc_args.accel = accel;
+        args.acc_args.lim_exp = lim_exp;
+        args.acc_args.midpoint = midpoint;
         args.accel_mode = mode;
-        args.offset = offset;
+        args.acc_args.offset = offset;
 
 		accel_instance = new accel_function(args);
 	}
-- 
cgit v1.2.3


From 33317e79489848ae537ac78b9c9e70372857aee8 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Wed, 29 Jul 2020 00:35:39 -0700
Subject: Separate accel implementations into files

---
 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       |  10 ++
 common/rawaccel.hpp          | 212 +++++--------------------------------------
 driver/driver.cpp            |   8 +-
 11 files changed, 314 insertions(+), 192 deletions(-)
 create mode 100644 common/accel_classic.cpp
 create mode 100644 common/accel_linear.cpp
 create mode 100644 common/accel_logarithmic.cpp
 create mode 100644 common/accel_natural.cpp
 create mode 100644 common/accel_noaccel.cpp
 create mode 100644 common/accel_power.cpp
 create mode 100644 common/accel_sigmoid.cpp
 create mode 100644 common/accel_types.hpp

diff --git a/common/accel_classic.cpp b/common/accel_classic.cpp
new file mode 100644
index 0000000..e4e7ab9
--- /dev/null
+++ b/common/accel_classic.cpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "accel_types.hpp"
+
+namespace rawaccel {
+	accel_classic::accel_classic(accel_args args)
+		: accel_implentation(args) {}
+
+	double accel_classic::accelerate(double speed) {
+		//f(x) = (mx)^k
+		return pow(curve_constant_one * speed, curve_constant_two);
+	}
+
+	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
new file mode 100644
index 0000000..d12e798
--- /dev/null
+++ b/common/accel_linear.cpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "accel_types.hpp"
+
+namespace rawaccel {
+	accel_linear::accel_linear(accel_args args)
+		: accel_implentation(args) {}
+
+	double accel_linear::accelerate(double speed) {
+		//f(x) = mx
+		return curve_constant_one * speed;
+	}
+
+	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
new file mode 100644
index 0000000..c127bcb
--- /dev/null
+++ b/common/accel_logarithmic.cpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "accel_types.hpp"
+
+namespace rawaccel {
+	accel_logarithmic::accel_logarithmic(accel_args args)
+		: accel_implentation(args) {}
+
+	double accel_logarithmic::accelerate(double speed) {
+		//f(x) = log(m*x+1)
+		return log(speed * curve_constant_one + 1);
+	}
+
+	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
new file mode 100644
index 0000000..ba9bc02
--- /dev/null
+++ b/common/accel_natural.cpp
@@ -0,0 +1,23 @@
+
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "accel_types.hpp"
+
+namespace rawaccel {
+	accel_natural::accel_natural(accel_args args)
+		: accel_implentation(args)
+        { curve_constant_one /= curve_constant_two; }
+
+	double accel_natural::accelerate(double speed) {
+		// f(x) = k(1-e^(-mx))
+		return curve_constant_two - (curve_constant_two * exp(-curve_constant_one * speed));;
+	}
+
+	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
new file mode 100644
index 0000000..50506a7
--- /dev/null
+++ b/common/accel_noaccel.cpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "accel_types.hpp"
+
+namespace rawaccel {
+	accel_noaccel::accel_noaccel(accel_args args)
+		: accel_implentation(args) {}
+
+	double accel_noaccel::accelerate(double speed) { return 0; }
+
+	void accel_noaccel::verify(accel_args args) { }
+}
diff --git a/common/accel_power.cpp b/common/accel_power.cpp
new file mode 100644
index 0000000..26f800d
--- /dev/null
+++ b/common/accel_power.cpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "accel_types.hpp"
+
+namespace rawaccel {
+	accel_power::accel_power(accel_args args)
+		: accel_implentation(args)
+        { curve_constant_two++; }
+
+	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;
+	}
+
+	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
new file mode 100644
index 0000000..c5280bc
--- /dev/null
+++ b/common/accel_sigmoid.cpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "accel_types.hpp"
+
+namespace rawaccel {
+	accel_sigmoid::accel_sigmoid(accel_args args)
+		: accel_implentation(args) {}
+
+	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);
+	}
+
+	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
new file mode 100644
index 0000000..c931097
--- /dev/null
+++ b/common/accel_types.hpp
@@ -0,0 +1,130 @@
+#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
+    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 224792c..f33d8e1 100644
--- a/common/common.vcxitems
+++ b/common/common.vcxitems
@@ -14,10 +14,20 @@
     <ProjectCapability Include="SourceItemsFromImports" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel_types.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)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.hpp b/common/rawaccel.hpp
index 9cfa5e7..d0c1b66 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -7,14 +7,15 @@
 #include "x64-util.hpp"
 #include "external/tagged-union-single.h"
 
-namespace rawaccel {
+#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"
 
-// Error throwing calls std libraries which are unavailable in kernel mode.
-#ifdef _KERNEL_MODE
-    void error(const char*) {}
-#else
-    void error(const char* s);
-#endif
+namespace rawaccel {
 
     /// <summary> Struct to hold vector rotation details. </summary>
     struct rotator {
@@ -73,182 +74,6 @@ namespace rawaccel {
         accel_scale_clamp() = default;
     };
 
-    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)
-            : accel_implentation(args) {}
-
-        double accelerate(double speed) {
-            //f(x) = mx
-            return curve_constant_one * speed;
-        }
-
-        void verify(accel_args args) {
-            accel_implentation::verify(args);
-            if (args.lim_exp <= 1) error("limit must be greater than 1");
-        }
-    };
-
-    /// <summary> Struct to hold "classic" (linear raised to power) acceleration implementation. </summary>
-    struct accel_classic : accel_implentation<accel_classic> {
-        accel_classic(accel_args args)
-            : accel_implentation(args) {}
-
-        double accelerate(double speed) {
-            //f(x) = (mx)^k
-            return pow(curve_constant_one * speed, curve_constant_two);
-        }
-
-        void verify(accel_args args) {
-            accel_implentation::verify(args);
-            if (args.lim_exp <= 1) error("exponent must be greater than 1");
-        }
-    };
-
-    /// <summary> Struct to hold "natural" (vanishing difference) acceleration implementation. </summary>
-    struct accel_natural : accel_implentation<accel_natural> {
-        accel_natural(accel_args args)
-            : accel_implentation(args) 
-        { curve_constant_one /= curve_constant_two; }
-
-        double accelerate(double speed) {
-            // f(x) = k(1-e^(-mx))
-            return curve_constant_two - (curve_constant_two * exp(-curve_constant_one * speed));;
-        }
-
-        void verify(accel_args args) {
-            accel_implentation::verify(args);
-            if (args.lim_exp <= 1) error("exponent must be greater than 1");
-        }
-    };
-
-    /// <summary> Struct to hold logarithmic acceleration implementation. </summary>
-    struct accel_logarithmic : accel_implentation<accel_logarithmic> {
-        accel_logarithmic(accel_args args)
-            : accel_implentation(args) {}
-
-        double accelerate(double speed) {
-            return log(speed * curve_constant_one + 1);
-        }
-
-        void verify(accel_args args) {
-            accel_implentation::verify(args);
-            if (args.lim_exp <= 1) error("exponent must be greater than 1");
-        }
-    };
-
-    /// <summary> Struct to hold sigmoid (s-shaped) acceleration implementation. </summary>
-    struct accel_sigmoid : accel_implentation<accel_sigmoid> {
-        accel_sigmoid(accel_args args)
-            : accel_implentation(args) {}
-
-        double accelerate(double speed) {
-            //f(x) = k/(1+e^(-m(c-x)))
-            return curve_constant_two / (exp(-curve_constant_one * (speed - curve_constant_three)) + 1);
-        }
-
-        void verify(accel_args args) {
-            accel_implentation::verify(args);
-            if (args.lim_exp <= 1) error("exponent must be greater than 1");
-        }
-    };
-
-    /// <summary> Struct to hold power (non-additive) acceleration implementation. </summary>
-    struct accel_power : accel_implentation<accel_power> {
-        accel_power(accel_args args)
-            : accel_implentation(args)
-        { curve_constant_two++; }
-
-        double 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;
-        }
-
-        void verify(accel_args args) {
-            accel_implentation::verify(args);
-            if (args.lim_exp <= 0) error("exponent must be greater than 0");
-        }
-    };
-
-    /// <summary> Struct to hold acceleration implementation which applies no acceleration. </summary>
-    struct accel_noaccel : accel_implentation<accel_noaccel> {
-        accel_noaccel(accel_args args)
-            : accel_implentation(args) {}
-
-        double accelerate(double speed) { return 0; }
-
-        void verify(accel_args args) {}
-    };
-    
     /// <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>;
 
@@ -371,18 +196,20 @@ namespace rawaccel {
         }
 
         /// <summary>
-        /// Applies modification without acceleration. Rotation is the only
-        /// modification currently implemented.
+        /// Applies modification without acceleration.
         /// </summary>
         /// <param name="input">Input to be modified.</param>
         /// <returns>2d vector of modified input.</returns>
-        inline vec2d modify(vec2d input)
+        inline vec2d modify_without_accel(vec2d input)
         {
             if (apply_rotate)
             {
                 return rotate(input);
             }
 
+            input.x *= sensitivity.x;
+            input.y *= sensitivity.y;
+
             return input;
         }
 
@@ -392,9 +219,18 @@ namespace rawaccel {
         /// <param name="input">Input to be modified</param>
         /// <param name="time">Time period for determining acceleration.</param>
         /// <returns>2d vector with modified input.</returns>
-        inline vec2d modify(vec2d input, milliseconds time)
+        inline vec2d modify_with_accel(vec2d input, milliseconds time)
         {
-            return accel_fn(modify(input), time);
+            if (apply_rotate)
+            {
+                return rotate(input);
+            }
+
+            input = accel_fn(input, time);
+            input.x *= sensitivity.x;
+            input.y *= sensitivity.y;
+
+            return input;
         }
 
         mouse_modifier() = default;
diff --git a/driver/driver.cpp b/driver/driver.cpp
index 9704b21..1f9cebd 100644
--- a/driver/driver.cpp
+++ b/driver/driver.cpp
@@ -79,15 +79,15 @@ Arguments:
                     DebugPrint(("RA time < min with %d ticks\n", ticks));
                 }
 
-                input = global.modifier.modify(input, time);
+                input = global.modifier.modify_with_accel(input, time);
             }
             else
             {
-                input = global.modifier.modify(input);
+                input = global.modifier.modify_without_accel(input);
             }
 
-            double result_x = input.x * global.modifier.sensitivity.x + local_carry.x;
-            double result_y = input.y * global.modifier.sensitivity.y + local_carry.y;
+            double result_x = input.x + local_carry.x;
+            double result_y = input.y + local_carry.y;
 
             LONG out_x = static_cast<LONG>(result_x);
             LONG out_y = static_cast<LONG>(result_y);
-- 
cgit v1.2.3


From 7963edee802d5a7b51f1867a5133857c403c8ef6 Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Wed, 29 Jul 2020 01:10:29 -0700
Subject: Inline methods for linking, and fix sens application bug

---
 common/accel_classic.cpp     |  6 +++---
 common/accel_linear.cpp      |  6 +++---
 common/accel_logarithmic.cpp |  6 +++---
 common/accel_natural.cpp     |  6 +++---
 common/accel_noaccel.cpp     |  6 +++---
 common/accel_power.cpp       |  6 +++---
 common/accel_sigmoid.cpp     |  6 +++---
 common/accel_types.hpp       |  2 +-
 common/rawaccel.hpp          | 10 +++++++---
 9 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/common/accel_classic.cpp b/common/accel_classic.cpp
index e4e7ab9..323cd3b 100644
--- a/common/accel_classic.cpp
+++ b/common/accel_classic.cpp
@@ -6,15 +6,15 @@
 #include "accel_types.hpp"
 
 namespace rawaccel {
-	accel_classic::accel_classic(accel_args args)
+	inline accel_classic::accel_classic(accel_args args)
 		: accel_implentation(args) {}
 
-	double accel_classic::accelerate(double speed) {
+	inline double accel_classic::accelerate(double speed) {
 		//f(x) = (mx)^k
 		return pow(curve_constant_one * speed, curve_constant_two);
 	}
 
-	void accel_classic::verify(accel_args args) {
+	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
index d12e798..307e33e 100644
--- a/common/accel_linear.cpp
+++ b/common/accel_linear.cpp
@@ -6,15 +6,15 @@
 #include "accel_types.hpp"
 
 namespace rawaccel {
-	accel_linear::accel_linear(accel_args args)
+	inline accel_linear::accel_linear(accel_args args)
 		: accel_implentation(args) {}
 
-	double accel_linear::accelerate(double speed) {
+	inline double accel_linear::accelerate(double speed) {
 		//f(x) = mx
 		return curve_constant_one * speed;
 	}
 
-	void accel_linear::verify(accel_args args) {
+	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
index c127bcb..64808a1 100644
--- a/common/accel_logarithmic.cpp
+++ b/common/accel_logarithmic.cpp
@@ -6,15 +6,15 @@
 #include "accel_types.hpp"
 
 namespace rawaccel {
-	accel_logarithmic::accel_logarithmic(accel_args args)
+	inline accel_logarithmic::accel_logarithmic(accel_args args)
 		: accel_implentation(args) {}
 
-	double accel_logarithmic::accelerate(double speed) {
+	inline double accel_logarithmic::accelerate(double speed) {
 		//f(x) = log(m*x+1)
 		return log(speed * curve_constant_one + 1);
 	}
 
-	void accel_logarithmic::verify(accel_args args) {
+	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
index ba9bc02..c6f14b4 100644
--- a/common/accel_natural.cpp
+++ b/common/accel_natural.cpp
@@ -7,16 +7,16 @@
 #include "accel_types.hpp"
 
 namespace rawaccel {
-	accel_natural::accel_natural(accel_args args)
+	inline accel_natural::accel_natural(accel_args args)
 		: accel_implentation(args)
         { curve_constant_one /= curve_constant_two; }
 
-	double accel_natural::accelerate(double speed) {
+	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));;
 	}
 
-	void accel_natural::verify(accel_args args) {
+	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
index 50506a7..fce5dd4 100644
--- a/common/accel_noaccel.cpp
+++ b/common/accel_noaccel.cpp
@@ -6,10 +6,10 @@
 #include "accel_types.hpp"
 
 namespace rawaccel {
-	accel_noaccel::accel_noaccel(accel_args args)
+	inline accel_noaccel::accel_noaccel(accel_args args)
 		: accel_implentation(args) {}
 
-	double accel_noaccel::accelerate(double speed) { return 0; }
+	inline double accel_noaccel::accelerate(double speed) { return 0; }
 
-	void accel_noaccel::verify(accel_args args) { }
+	inline void accel_noaccel::verify(accel_args args) { }
 }
diff --git a/common/accel_power.cpp b/common/accel_power.cpp
index 26f800d..f104554 100644
--- a/common/accel_power.cpp
+++ b/common/accel_power.cpp
@@ -6,18 +6,18 @@
 #include "accel_types.hpp"
 
 namespace rawaccel {
-	accel_power::accel_power(accel_args args)
+	inline accel_power::accel_power(accel_args args)
 		: accel_implentation(args)
         { curve_constant_two++; }
 
-	double accel_power::accelerate(double speed) {
+	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;
 	}
 
-	void accel_power::verify(accel_args args) {
+	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
index c5280bc..d3b8ab7 100644
--- a/common/accel_sigmoid.cpp
+++ b/common/accel_sigmoid.cpp
@@ -6,15 +6,15 @@
 #include "accel_types.hpp"
 
 namespace rawaccel {
-	accel_sigmoid::accel_sigmoid(accel_args args)
+	inline accel_sigmoid::accel_sigmoid(accel_args args)
 		: accel_implentation(args) {}
 
-	double accel_sigmoid::accelerate(double speed) {
+	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);
 	}
 
-	void accel_sigmoid::verify(accel_args args) {
+	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
index c931097..15f5a50 100644
--- a/common/accel_types.hpp
+++ b/common/accel_types.hpp
@@ -7,7 +7,7 @@ namespace rawaccel {
 
 // Error throwing calls std libraries which are unavailable in kernel mode.
 #ifdef _KERNEL_MODE
-    void error(const char*) {}
+    inline void error(const char*) {}
 #else
     void error(const char* s);
 #endif
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index d0c1b66..6f737da 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -204,7 +204,7 @@ namespace rawaccel {
         {
             if (apply_rotate)
             {
-                return rotate(input);
+                input = rotate(input);
             }
 
             input.x *= sensitivity.x;
@@ -223,10 +223,14 @@ namespace rawaccel {
         {
             if (apply_rotate)
             {
-                return rotate(input);
+                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 6bb5b03e2afb0dd52204dfb1924dfd096387de3a Mon Sep 17 00:00:00 2001
From: Jacob Palecki <JacobPalecki@gmail.com>
Date: Wed, 29 Jul 2020 11:52:36 -0700
Subject: Use modifier object in wrapper

---
 common/rawaccel.hpp |  2 +-
 wrapper/wrapper.cpp |  2 +-
 wrapper/wrapper.hpp | 32 ++++++++++++++++----------------
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 6f737da..b480e87 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -20,7 +20,7 @@ namespace rawaccel {
     /// <summary> Struct to hold vector rotation details. </summary>
     struct rotator {
 
-        /// <summary> Rotational vector, which points in the direction of the post-rotation positive y axis. </summary>
+        /// <summary> Rotational vector, which points in the direction of the post-rotation positive x axis. </summary>
         vec2d rot_vec = { 1, 0 };
 
         /// <summary>
diff --git a/wrapper/wrapper.cpp b/wrapper/wrapper.cpp
index 1adafba..c1cc570 100644
--- a/wrapper/wrapper.cpp
+++ b/wrapper/wrapper.cpp
@@ -8,7 +8,7 @@ using namespace System;
 Tuple<double, double>^ ManagedAccel::Accelerate(int x, int y, double time)
 {
 	vec2d input_vec2d = {x, y};
-	vec2d output = (*accel_instance)(input_vec2d, (milliseconds)time);
+	vec2d output = (*modifier_instance).modify_with_accel(input_vec2d, (milliseconds)time);
 
 	return gcnew Tuple<double, double>(output.x, output.y);
 }
\ No newline at end of file
diff --git a/wrapper/wrapper.hpp b/wrapper/wrapper.hpp
index 2cbc01c..19b0987 100644
--- a/wrapper/wrapper.hpp
+++ b/wrapper/wrapper.hpp
@@ -9,43 +9,43 @@ using namespace System;
 public ref class ManagedAccel
 {
 protected:
-	accel_function* accel_instance;
+	mouse_modifier* modifier_instance;
 public:
-	ManagedAccel(accel_function* accel)
-		: accel_instance(accel)
+	ManagedAccel(mouse_modifier* accel)
+		: modifier_instance(accel)
 	{
 	}
 
     ManagedAccel(int mode, double offset, double accel, double lim_exp, double midpoint)
     {
-        accel_fn_args args{};
-        args.acc_args.accel = accel;
-        args.acc_args.lim_exp = lim_exp;
-        args.acc_args.midpoint = midpoint;
-        args.accel_mode = mode;
-        args.acc_args.offset = offset;
+        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;
 
-		accel_instance = new accel_function(args);
+		modifier_instance = new mouse_modifier(args);
 	}
 
     virtual ~ManagedAccel()
     {
-        if (accel_instance != nullptr)
+        if (modifier_instance!= nullptr)
         {
-            delete accel_instance;
+            delete modifier_instance;
         }
     }
     !ManagedAccel()
     {
-        if (accel_instance != nullptr)
+        if (modifier_instance!= nullptr)
         {
-            delete accel_instance;
+            delete modifier_instance;
         }
     }
 
-    accel_function* GetInstance()
+    mouse_modifier* GetInstance()
     {
-        return accel_instance;
+        return modifier_instance;
     }
 
     Tuple<double, double>^ Accelerate(int x, int y, double time);
-- 
cgit v1.2.3