Merge pull request #108 from a1xd/1.6r2HEADv1.6.0masterdark-mode

v1.6

1 files changed, 37 insertions, 82 deletions

diff --git a/common/accel-union.hpp b/common/accel-union.hpp
index 8495a62..136db44 100644
--- a/common/accel-union.hpp
+++ b/common/accel-union.hpp
@@ -2,101 +2,56 @@
 
 #include "accel-classic.hpp"
 #include "accel-jump.hpp"
-#include "accel-natural.hpp"
-#include "accel-power.hpp"
+#include "accel-lookup.hpp"
 #include "accel-motivity.hpp"
+#include "accel-natural.hpp"
 #include "accel-noaccel.hpp"
+#include "accel-power.hpp"
 
 namespace rawaccel {
 
-    enum class internal_mode {
-        classic_lgcy,
-        classic_gain,
-        jump_lgcy,
-        jump_gain,
-        natural_lgcy,
-        natural_gain,
-        motivity_lgcy,
-        motivity_gain,
-        power,
-        lut_arb,
-        lut_log,
-        lut_lin,
-        noaccel
-    };
-
-    constexpr internal_mode make_mode(accel_mode mode, spaced_lut_mode lut_mode, bool legacy) 
-    {
-        if (lut_mode != spaced_lut_mode::off) {
-            switch (lut_mode) {
-            case spaced_lut_mode::binlog: return internal_mode::lut_log;
-            case spaced_lut_mode::linear: return internal_mode::lut_lin;
-            default: return internal_mode::noaccel;
-            }
-        }
-        else if (mode == accel_mode::power) {
-            return internal_mode::power;
-        }
-        else if (mode == accel_mode::arb_lookup) {
-            return internal_mode::lut_arb;
-        }
-        else if (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);
+    union accel_union {
+        accel_noaccel noaccel;
+        lookup lut;
+        classic<GAIN> classic_g;
+        classic<LEGACY> classic_l;
+        jump<GAIN> jump_g;
+        jump<LEGACY> jump_l;
+        natural<GAIN> natural_g;
+        natural<LEGACY> natural_l;
+        power<GAIN> power_g;
+        power<LEGACY> power_l;
+        loglog_sigmoid<GAIN> loglog_sigmoid_g;
+        loglog_sigmoid<LEGACY> loglog_sigmoid_l;
+
+        template <template <bool> class AccelTemplate, typename Visitor>
+        auto visit_helper(Visitor vis, bool gain)
+        {
+            if (gain) return vis(reinterpret_cast<AccelTemplate<GAIN>&>(*this));
+            else  return vis(reinterpret_cast<AccelTemplate<LEGACY>&>(*this));
         }
-    }
-
-    constexpr internal_mode make_mode(const accel_args& args) 
-    {
-        return make_mode(args.mode, args.spaced_args.mode, args.legacy);
-    }
 
-    template <typename Visitor, typename AccelUnion>
-    constexpr auto visit_accel(Visitor vis, internal_mode mode, AccelUnion&& u)
-    {
-        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::motivity_lgcy: return vis(u.motivity_l);
-        case internal_mode::motivity_gain: return vis(u.motivity_g);
-        case internal_mode::power:         return vis(u.power);
-        case internal_mode::lut_arb:       return vis(u.arb_lut);
-        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);
+        template <typename Visitor>
+        auto visit(Visitor vis, const accel_args& args)
+        {
+            switch (args.mode) {
+            case accel_mode::classic:  return visit_helper<classic>(vis, args.gain);
+            case accel_mode::jump:     return visit_helper<jump>(vis, args.gain);
+            case accel_mode::natural:  return visit_helper<natural>(vis, args.gain);
+            case accel_mode::motivity: return visit_helper<loglog_sigmoid>(vis, args.gain);
+            case accel_mode::power:    return visit_helper<power>(vis, args.gain);
+            case accel_mode::lookup:   return vis(lut);
+            default:                   return vis(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;
-        sigmoid motivity_l;
-        motivity motivity_g;
-        linear_lut lin_lut;
-        binlog_lut log_lut;
-        arbitrary_lut arb_lut;
-        accel_noaccel noaccel = {};
 
-        accel_union(const accel_args& args)
+        void init(const accel_args& args)
         {
-            visit_accel([&](auto& impl) {
+            visit([&](auto& impl) {
                 impl = { args };
-            }, make_mode(args), *this);
+            }, args);
         }
 
-        accel_union() = default;
     };
 
 }