From ed0bbc22681681a16b7d45b05133c38a0b82006f Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Mon, 29 Mar 2021 18:01:20 -0400 Subject: formatting + file renames --- common/accel-union.hpp | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 common/accel-union.hpp (limited to 'common/accel-union.hpp') diff --git a/common/accel-union.hpp b/common/accel-union.hpp new file mode 100644 index 0000000..86d0cf4 --- /dev/null +++ b/common/accel-union.hpp @@ -0,0 +1,98 @@ +#pragma once + +#include "accel-classic.hpp" +#include "accel-natural.hpp" +#include "accel-power.hpp" +#include "accel-motivity.hpp" +#include "accel-noaccel.hpp" + +namespace rawaccel { + + enum class internal_mode { + classic_lgcy, + classic_gain, + natural_lgcy, + natural_gain, + power, + motivity, + noaccel + }; + + constexpr internal_mode make_mode(accel_mode m, bool legacy) + { + switch (m) { + case accel_mode::classic: + return legacy ? internal_mode::classic_lgcy : internal_mode::classic_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: + return internal_mode::noaccel; + } + } + + constexpr internal_mode make_mode(const accel_args& args) + { + return make_mode(args.mode, args.legacy); + } + + template + 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::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); + } + } + + struct accel_variant { + si_pair* lookup; + + internal_mode tag = internal_mode::noaccel; + + union union_t { + classic classic_g; + classic_legacy classic_l; + natural natural_g; + natural_legacy natural_l; + power power; + motivity motivity; + accel_noaccel noaccel = {}; + } u = {}; + + accel_variant(const accel_args& args, si_pair* lut = nullptr) : + tag(make_mode(args)), lookup(lut) + { + 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); + } + + accel_variant() = default; + }; + +} -- cgit v1.2.3 From 5a0db3165d1ad050fd5e3f48d290f5ec7289a4f2 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Mon, 29 Mar 2021 19:41:42 -0400 Subject: add jump type --- common/accel-union.hpp | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'common/accel-union.hpp') diff --git a/common/accel-union.hpp b/common/accel-union.hpp index 86d0cf4..97496e1 100644 --- a/common/accel-union.hpp +++ b/common/accel-union.hpp @@ -1,6 +1,7 @@ #pragma once #include "accel-classic.hpp" +#include "accel-jump.hpp" #include "accel-natural.hpp" #include "accel-power.hpp" #include "accel-motivity.hpp" @@ -11,6 +12,8 @@ namespace rawaccel { enum class internal_mode { classic_lgcy, classic_gain, + jump_lgcy, + jump_gain, natural_lgcy, natural_gain, power, @@ -23,6 +26,8 @@ namespace rawaccel { 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: @@ -45,6 +50,8 @@ namespace rawaccel { 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); @@ -61,6 +68,8 @@ namespace rawaccel { 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; -- cgit v1.2.3 From fa3ebfb1eb054ba88824a908c996094bb98e85c5 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Tue, 30 Mar 2021 18:27:02 -0400 Subject: refactor lut/motivity --- common/accel-union.hpp | 81 +++++++++++++++++++++++++------------------------- 1 file changed, 41 insertions(+), 40 deletions(-) (limited to 'common/accel-union.hpp') 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(mode) * 2 + (legacy ? 0 : 1); + return static_cast(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 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); -- cgit v1.2.3 From 31ffabf6f32ae14b6e2f6ce33763bf4ef1bff809 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Thu, 1 Apr 2021 19:40:19 -0400 Subject: make weights work in by component mode domain weights now applied under inf norm range weights now applied when equal --- common/accel-union.hpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'common/accel-union.hpp') diff --git a/common/accel-union.hpp b/common/accel-union.hpp index c63a9cc..7a6b173 100644 --- a/common/accel-union.hpp +++ b/common/accel-union.hpp @@ -95,10 +95,10 @@ namespace rawaccel { }, *this); } - double apply(double speed) const + double apply(double speed, double weight = 1) const { return visit_accel([=](auto&& impl) { - return impl(speed); + return apply_weighted(impl, speed, weight); }, *this); } -- cgit v1.2.3 From d8140fb31ba622f48756986d4d66db6b6ab8b511 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Thu, 1 Apr 2021 23:28:41 -0400 Subject: use callbacks for applying accel --- common/accel-union.hpp | 80 +++++++++++++++++++++----------------------------- 1 file changed, 34 insertions(+), 46 deletions(-) (limited to 'common/accel-union.hpp') 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 - inline auto visit_accel(Visitor vis, Variant&& var) + template + 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; }; } -- cgit v1.2.3 From 7c1f14845bc948e9ea25908e96099203d9433a69 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Tue, 6 Apr 2021 01:21:42 -0400 Subject: update wrapper + writer to handle lut grapher is building but applying options still broken for the most part --- common/accel-union.hpp | 3 +++ 1 file changed, 3 insertions(+) (limited to 'common/accel-union.hpp') diff --git a/common/accel-union.hpp b/common/accel-union.hpp index 3d41a18..7f3d5d5 100644 --- a/common/accel-union.hpp +++ b/common/accel-union.hpp @@ -22,6 +22,7 @@ namespace rawaccel { motivity_gain, lut_log, lut_lin, + lut_arb, noaccel }; @@ -31,6 +32,7 @@ namespace rawaccel { switch (lut_mode) { case table_mode::binlog: return internal_mode::lut_log; case table_mode::linear: return internal_mode::lut_lin; + case table_mode::arbitrary: return internal_mode::lut_arb; default: return internal_mode::noaccel; } } @@ -64,6 +66,7 @@ namespace rawaccel { 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); + case internal_mode::lut_arb: default: return vis(u.noaccel); } } -- cgit v1.2.3 From aad1822effaa16c29dba316601923f31d66ce063 Mon Sep 17 00:00:00 2001 From: Jacob Palecki Date: Thu, 8 Apr 2021 21:49:25 -0700 Subject: Progress in arbitrary --- common/accel-union.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'common/accel-union.hpp') diff --git a/common/accel-union.hpp b/common/accel-union.hpp index 7f3d5d5..f5c26ba 100644 --- a/common/accel-union.hpp +++ b/common/accel-union.hpp @@ -66,7 +66,7 @@ namespace rawaccel { 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); - case internal_mode::lut_arb: + case internal_mode::lut_arb: return vis(u.arb_lut); default: return vis(u.noaccel); } } @@ -84,6 +84,7 @@ namespace rawaccel { motivity motivity_g; linear_lut lin_lut; binlog_lut log_lut; + arbitrary_lut arb_lut; accel_noaccel noaccel = {}; accel_union(const accel_args& args) -- cgit v1.2.3 From a6926be0e911b7b7637861866f41c3bca31a87a3 Mon Sep 17 00:00:00 2001 From: a1xd <68629610+a1xd@users.noreply.github.com> Date: Tue, 13 Apr 2021 23:59:21 -0400 Subject: move arbitrary input into settings separate arbitrary mode from spaced modes, arbitrary now deserializes from default settings file --- common/accel-union.hpp | 32 +++++++++++++++++--------------- 1 file changed, 17 insertions(+), 15 deletions(-) (limited to 'common/accel-union.hpp') diff --git a/common/accel-union.hpp b/common/accel-union.hpp index f5c26ba..8495a62 100644 --- a/common/accel-union.hpp +++ b/common/accel-union.hpp @@ -16,27 +16,31 @@ namespace rawaccel { jump_gain, natural_lgcy, natural_gain, - power_lgcy, - power_gain, motivity_lgcy, motivity_gain, + power, + lut_arb, lut_log, lut_lin, - lut_arb, noaccel }; - constexpr internal_mode make_mode(accel_mode mode, table_mode lut_mode, bool legacy) + constexpr internal_mode make_mode(accel_mode mode, spaced_lut_mode lut_mode, bool legacy) { - if (lut_mode != table_mode::off) { + if (lut_mode != spaced_lut_mode::off) { switch (lut_mode) { - case table_mode::binlog: return internal_mode::lut_log; - case table_mode::linear: return internal_mode::lut_lin; - case table_mode::arbitrary: return internal_mode::lut_arb; + 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::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 { @@ -47,7 +51,7 @@ namespace rawaccel { constexpr internal_mode make_mode(const accel_args& args) { - return make_mode(args.mode, args.lut_args.mode, args.legacy); + return make_mode(args.mode, args.spaced_args.mode, args.legacy); } template @@ -60,13 +64,12 @@ namespace rawaccel { 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::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); - case internal_mode::lut_arb: return vis(u.arb_lut); default: return vis(u.noaccel); } } @@ -78,8 +81,7 @@ namespace rawaccel { jump_legacy jump_l; natural natural_g; natural_legacy natural_l; - power power_g; - power_legacy power_l; + power power; sigmoid motivity_l; motivity motivity_g; linear_lut lin_lut; -- cgit v1.2.3