use callbacks for applying accel

7 files changed, 113 insertions, 66 deletions

diff --git a/common/accel-invoke.hpp b/common/accel-invoke.hpp
new file mode 100644
index 0000000..0e264c1
--- /dev/null
+++ b/common/accel-invoke.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "accel-union.hpp"
+
+namespace rawaccel {
+
+    class accel_invoker {
+        using callback_t = double (*)(const accel_union&, double, double);
+
+        callback_t cb = &invoke_impl<accel_noaccel>;
+
+        template <typename T>
+        static double invoke_impl(const accel_union& u, double x, double w)
+        {
+            return apply_weighted(reinterpret_cast<const T&>(u), x, w);
+        }
+
+    public:
+
+        accel_invoker(const accel_args& args)
+        {
+            cb = visit_accel([](auto&& arg) { 
+                return &invoke_impl<remove_ref_t<decltype(arg)>>; 
+            }, make_mode(args), accel_union{});
+        }
+
+        accel_invoker() = default;
+
+        double invoke(const accel_union& u, double x, double weight = 1) const
+        {
+            return (*cb)(u, x, weight);
+        }
+    };
+
+    inline vec2<accel_invoker> invokers(const settings& args)
+    {
+        return {
+            accel_invoker(args.argsv.x),
+            accel_invoker(args.argsv.y)
+        };
+    }
+
+}
diff --git a/common/accel-union.hpp b/common/accel-union.hpp
index 7a6b173..3d41a18 100644
--- a/common/accel-union.hpp
+++ b/common/accel-union.hpp
@@ -34,7 +34,7 @@ namespace rawaccel {
             default: return internal_mode::noaccel;
             }
         }
-        else if (mode < accel_mode{} || mode >= accel_mode::noaccel) {
+        else if (mode == accel_mode::noaccel) {
             return internal_mode::noaccel;
         }
         else {
@@ -48,61 +48,49 @@ namespace rawaccel {
         return make_mode(args.mode, args.lut_args.mode, args.legacy);
     }
 
-    template <typename Visitor, typename Variant>
-    inline auto visit_accel(Visitor vis, Variant&& var) 
+    template <typename Visitor, typename AccelUnion>
+    constexpr auto visit_accel(Visitor vis, internal_mode mode, AccelUnion&& u)
     {
-        switch (var.tag) {
-        case internal_mode::classic_lgcy:  return vis(var.u.classic_l);
-        case internal_mode::classic_gain:  return vis(var.u.classic_g);
-        case internal_mode::jump_lgcy:     return vis(var.u.jump_l);
-        case internal_mode::jump_gain:     return vis(var.u.jump_g);
-        case internal_mode::natural_lgcy:  return vis(var.u.natural_l);
-        case internal_mode::natural_gain:  return vis(var.u.natural_g);
-        case internal_mode::power_lgcy:    return vis(var.u.power_l);
-        case internal_mode::power_gain:    return vis(var.u.power_g);
-        case internal_mode::motivity_lgcy: return vis(var.u.motivity_l);
-        case internal_mode::motivity_gain: return vis(var.u.motivity_g);
-        case internal_mode::lut_log:       return vis(var.u.log_lut);
-        case internal_mode::lut_lin:       return vis(var.u.lin_lut);
-        default:                           return vis(var.u.noaccel);
+        switch (mode) {
+        case internal_mode::classic_lgcy:  return vis(u.classic_l);
+        case internal_mode::classic_gain:  return vis(u.classic_g);
+        case internal_mode::jump_lgcy:     return vis(u.jump_l);
+        case internal_mode::jump_gain:     return vis(u.jump_g);
+        case internal_mode::natural_lgcy:  return vis(u.natural_l);
+        case internal_mode::natural_gain:  return vis(u.natural_g);
+        case internal_mode::power_lgcy:    return vis(u.power_l);
+        case internal_mode::power_gain:    return vis(u.power_g);
+        case internal_mode::motivity_lgcy: return vis(u.motivity_l);
+        case internal_mode::motivity_gain: return vis(u.motivity_g);
+        case internal_mode::lut_log:       return vis(u.log_lut);
+        case internal_mode::lut_lin:       return vis(u.lin_lut);
+        default:                           return vis(u.noaccel);
         }
     }
 
-    struct accel_variant {
-        internal_mode tag = internal_mode::noaccel;
+    union accel_union {
+        classic classic_g;
+        classic_legacy classic_l;
+        jump jump_g;
+        jump_legacy jump_l;
+        natural natural_g;
+        natural_legacy natural_l;
+        power power_g;
+        power_legacy power_l;
+        sigmoid motivity_l;
+        motivity motivity_g;
+        linear_lut lin_lut;
+        binlog_lut log_lut;
+        accel_noaccel noaccel = {};
 
-        union union_t {
-            classic classic_g;
-            classic_legacy classic_l;
-            jump jump_g;
-            jump_legacy jump_l;
-            natural natural_g;
-            natural_legacy natural_l;
-            power power_g;
-            power_legacy power_l;
-            sigmoid motivity_l;
-            motivity motivity_g;
-            linear_lut lin_lut;
-            binlog_lut log_lut;
-            accel_noaccel noaccel = {};
-        } u = {};
-
-        accel_variant(const accel_args& args) :
-            tag(make_mode(args))
+        accel_union(const accel_args& args)
         {
             visit_accel([&](auto& impl) {
                 impl = { args };
-            }, *this);
-        }
-
-        double apply(double speed, double weight = 1) const 
-        {
-            return visit_accel([=](auto&& impl) {
-                return apply_weighted(impl, speed, weight);
-            }, *this);
+            }, make_mode(args), *this);
         }
 
-        accel_variant() = default;
+        accel_union() = default;
     };
 
 }
diff --git a/common/common.vcxitems b/common/common.vcxitems
index 6d1b861..2cf2df2 100644
--- a/common/common.vcxitems
+++ b/common/common.vcxitems
@@ -15,6 +15,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="$(MSBuildThisFileDirectory)accel-classic.hpp" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)accel-invoke.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)accel-jump.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)accel-lookup.hpp" />
     <ClInclude Include="$(MSBuildThisFileDirectory)accel-motivity.hpp" />
diff --git a/common/rawaccel.hpp b/common/rawaccel.hpp
index 8e10644..6710a0c 100644
--- a/common/rawaccel.hpp
+++ b/common/rawaccel.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-#include "accel-union.hpp"
-#include "utility.hpp"
+#include "accel-invoke.hpp"
 
 #define _USE_MATH_DEFINES
 #include <math.h>
@@ -127,7 +126,7 @@ namespace rawaccel {
         double speed_max = 0;
         weighted_distance distance;
         vec2d range_weights = { 1, 1 };
-        vec2<accel_variant> accels;
+        vec2<accel_union> accels;
         vec2d sensitivity = { 1, 1 };
         vec2d directional_multipliers = {};
 
@@ -162,18 +161,18 @@ namespace rawaccel {
                 return;
             }
 
-            accels.x = accel_variant(args.argsv.x);
-            accels.y = accel_variant(args.argsv.y);
+            accels.x = accel_union(args.argsv.x);
+            accels.y = accel_union(args.argsv.y);
 
             distance = weighted_distance(args.dom_args);
 
             apply_directional_weight = range_weights.x != range_weights.y;
         }
 
-        void modify(vec2d& movement, milliseconds time) {
+        void modify(vec2d& movement, const vec2<accel_invoker>& inv = {}, milliseconds time = 1) {
             apply_rotation(movement);
             apply_angle_snap(movement);
-            apply_acceleration(movement, time);
+            apply_acceleration(movement, inv, time);
             apply_sensitivity(movement);
         }
 
@@ -185,7 +184,7 @@ namespace rawaccel {
             if (apply_snap) movement = snap.apply(movement);
         }
 
-        inline void apply_acceleration(vec2d& movement, milliseconds time) {
+        inline void apply_acceleration(vec2d& movement, const vec2<accel_invoker>& inv, milliseconds time) {
             double norm = dpi_factor / time;
 
             if (apply_speed_clamp) {
@@ -205,18 +204,18 @@ namespace rawaccel {
                     weight = range_weights.x;
                 }
 
-                double scale = accels.x.apply(speed, weight);
+                double scale = inv.x.invoke(accels.x, speed, weight);
                 movement.x *= scale;
                 movement.y *= scale;
             }
             else {
                 if (movement.x != 0) {
                     double x = fabs(movement.x) * norm * distance.sigma_x;
-                    movement.x *= accels.x.apply(x, range_weights.x);
+                    movement.x *= inv.x.invoke(accels.x, x, range_weights.x);
                 }
                 if (movement.y != 0) {
                     double y = fabs(movement.y) * norm * distance.sigma_y;
-                    movement.y *= accels.y.apply(y, range_weights.y);
+                    movement.y *= inv.y.invoke(accels.y, y, range_weights.y);
                 }
             }
         }
diff --git a/common/utility.hpp b/common/utility.hpp
index 5f5c186..a8e5f83 100644
--- a/common/utility.hpp
+++ b/common/utility.hpp
@@ -85,4 +85,11 @@ namespace rawaccel {
         template <typename... Ts> 
         constexpr void operator()(Ts&&...) const noexcept {}
     };
+
+    template <typename T> struct remove_ref { using type = T; };
+    template <typename T> struct remove_ref<T&> { using type = T; };
+    template <typename T> struct remove_ref<T&&> { using type = T; };
+
+    template <typename T>
+    using remove_ref_t = typename remove_ref<T>::type;
 }
diff --git a/driver/driver.cpp b/driver/driver.cpp
index 0c272e1..fa2415d 100644
--- a/driver/driver.cpp
+++ b/driver/driver.cpp
@@ -16,7 +16,8 @@ using milliseconds = double;
 
 struct {
     ra::settings args;
-    milliseconds tick_interval = 0; // set in DriverEntry
+    milliseconds tick_interval;
+    vec2<ra::accel_invoker> invokers;
     ra::mouse_modifier modifier;
 } global = {};
 
@@ -83,7 +84,7 @@ Arguments:
                     static_cast<double>(it->LastY)
                 };
 
-                global.modifier.modify(input, time);
+                global.modifier.modify(input, global.invokers, time);
 
                 double carried_result_x = input.x + devExt->carry.x;
                 double carried_result_y = input.y + devExt->carry.y;
@@ -193,6 +194,7 @@ Return Value:
             ra::io_t& input = *reinterpret_cast<ra::io_t*>(buffer);
 
             global.args = input.args;
+            global.invokers = ra::invokers(input.args);
             global.modifier = input.mod;
         }
         break;
diff --git a/wrapper/wrapper.cpp b/wrapper/wrapper.cpp
index 0af7c28..84756af 100644
--- a/wrapper/wrapper.cpp
+++ b/wrapper/wrapper.cpp
@@ -321,9 +321,14 @@ public ref struct RawInputInterop
 
 };
 
+struct instance_t {
+    ra::io_t data;
+    vec2<ra::accel_invoker> inv;
+};
+
 public ref class ManagedAccel
 {
-    ra::io_t* const instance = new ra::io_t();
+    instance_t* const instance = new instance_t();
 
 public:
     ManagedAccel() {};
@@ -350,7 +355,7 @@ public:
             (double)y
         };
 
-        instance->mod.modify(in_out_vec, time);
+        instance->data.mod.modify(in_out_vec, instance->inv, time);
 
         return gcnew Tuple<double, double>(in_out_vec.x, in_out_vec.y);
     }
@@ -358,7 +363,7 @@ public:
     void Activate()
     {
         try {
-            ra::write(*instance);
+            ra::write(instance->data);
         }
         catch (const ra::error& e) {
             throw gcnew InteropException(e);
@@ -370,14 +375,15 @@ public:
         DriverSettings^ get()
         {
             DriverSettings^ settings = gcnew DriverSettings();
-            Marshal::PtrToStructure(IntPtr(&instance->args), settings);
+            Marshal::PtrToStructure(IntPtr(&instance->data.args), settings);
             return settings;
         }
 
         void set(DriverSettings^ val)
         {
-            Marshal::StructureToPtr(val, IntPtr(&instance->args), false);
-            instance->mod = { instance->args };
+            Marshal::StructureToPtr(val, IntPtr(&instance->data.args), false);
+            instance->data.mod = { instance->data.args };
+            instance->inv = ra::invokers(instance->data.args);
         }
 
     }
@@ -386,7 +392,8 @@ public:
     {
         try {
             auto active = gcnew ManagedAccel();
-            ra::read(*active->instance);
+            ra::read(active->instance->data);
+            active->instance->inv = ra::invokers(active->instance->data.args);
             return active;
         }
         catch (const ra::error& e) {