refactor lut/motivity

1 files changed, 41 insertions, 40 deletions

diff --git a/common/accel-union.hpp b/common/accel-union.hpp
index 97496e1..c63a9cc 100644
--- a/common/accel-union.hpp
+++ b/common/accel-union.hpp
@@ -16,53 +16,59 @@ namespace rawaccel {
         jump_gain,
         natural_lgcy,
         natural_gain,
-        power,
-        motivity,
+        power_lgcy,
+        power_gain,
+        motivity_lgcy,
+        motivity_gain,
+        lut_log,
+        lut_lin,
         noaccel
     };
 
-    constexpr internal_mode make_mode(accel_mode m, bool legacy) 
+    constexpr internal_mode make_mode(accel_mode mode, table_mode lut_mode, bool legacy) 
     {
-        switch (m) {
-        case accel_mode::classic:
-            return legacy ? internal_mode::classic_lgcy : internal_mode::classic_gain;
-        case accel_mode::jump:
-            return legacy ? internal_mode::jump_lgcy : internal_mode::jump_gain;
-        case accel_mode::natural:
-            return legacy ? internal_mode::natural_lgcy : internal_mode::natural_gain;
-        case accel_mode::power:
-            return internal_mode::power;
-        case accel_mode::motivity:
-            return internal_mode::motivity;
-        default:
+        if (lut_mode != table_mode::off) {
+            switch (lut_mode) {
+            case table_mode::binlog: return internal_mode::lut_log;
+            case table_mode::linear: return internal_mode::lut_lin;
+            default: return internal_mode::noaccel;
+            }
+        }
+        else if (mode < accel_mode{} || mode >= accel_mode::noaccel) {
             return internal_mode::noaccel;
         }
+        else {
+            int im = static_cast<int>(mode) * 2 + (legacy ? 0 : 1);
+            return static_cast<internal_mode>(im);
+        }
     }
 
     constexpr internal_mode make_mode(const accel_args& args) 
     {
-        return make_mode(args.mode, args.legacy);
+        return make_mode(args.mode, args.lut_args.mode, args.legacy);
     }
 
     template <typename Visitor, typename Variant>
     inline auto visit_accel(Visitor vis, Variant&& var) 
     {
         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:        return vis(var.u.power);
-        case internal_mode::motivity:     return vis(var.u.motivity);
-        default:                          return vis(var.u.noaccel);
+        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);
         }
     }
 
     struct accel_variant {
-        si_pair* lookup;
-
         internal_mode tag = internal_mode::noaccel;
 
         union union_t {
@@ -72,30 +78,25 @@ namespace rawaccel {
             jump_legacy jump_l;
             natural natural_g;
             natural_legacy natural_l;
-            power power;
-            motivity motivity;
+            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, si_pair* lut = nullptr) :
-            tag(make_mode(args)), lookup(lut)
+        accel_variant(const accel_args& args) :
+            tag(make_mode(args))
         {
             visit_accel([&](auto& impl) {
                 impl = { args };
             }, *this);
-
-            if (lookup && tag == internal_mode::motivity) {
-                u.motivity.fill(lookup);
-            }
-
         }
 
         double apply(double speed) const 
         {
-            if (lookup && tag == internal_mode::motivity) {
-                return u.motivity.apply(lookup, speed);
-            }
-
             return visit_accel([=](auto&& impl) {
                 return impl(speed);
             }, *this);