1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
#pragma once
#include <vector>
#include "compat/timer.hpp"
#include "api/plugin-support.hpp"
#include "mappings.hpp"
#include "compat/euler.hpp"
#include "compat/enum-operators.hpp"
#include "runtime-libraries.hpp"
#include "spline/spline.hpp"
#include "main-settings.hpp"
#include "options/options.hpp"
#include "tracklogger.hpp"
#include <QMutex>
#include <QThread>
#include <atomic>
#include <cmath>
#include <QQuaternion>
#include "export.hpp"
namespace pipeline_impl {
using namespace euler;
using namespace time_units;
using vec6_bool = Mat<bool, 6, 1>;
using vec3_bool = Mat<bool, 6, 1>;
class reltrans
{
Pose_ interp_pos;
Timer interp_timer;
// this implements smooth transition into reltrans mode
// once not aiming anymore. see `apply_pipeline()'.
Timer interp_phase_timer;
unsigned RC_stage = 0;
bool moving_to_reltans = false;
bool in_zone = false;
public:
reltrans();
void on_center();
Pose_ rotate(const rmat& rmat, const Pose_& in, vec3_bool disable) const;
Pose_ apply_neck(const rmat& R, int nz, bool disable_tz) const;
Pose apply_pipeline(reltrans_state state, const Pose& value,
const vec6_bool& disable, bool neck_enable, int neck_z);
};
enum bit_flags : unsigned {
f_none = 0,
f_center = 1 << 0,
f_held_center = 1 << 1,
f_enabled_h = 1 << 2,
f_enabled_p = 1 << 3,
f_zero = 1 << 4,
};
struct OTR_LOGIC_EXPORT bits
{
bit_flags flags{0};
QMutex lock;
void set(bit_flags flag, bool val);
void negate(bit_flags flag);
bool get(bit_flags flag);
bits();
};
DEFINE_ENUM_OPERATORS(bit_flags);
class OTR_LOGIC_EXPORT pipeline : private QThread
{
Q_OBJECT
mutable QMutex mtx;
main_settings s;
const Mappings& m;
Timer t;
Pose output_pose, raw_6dof, last_value;
Pose newpose;
runtime_libraries const& libs;
// The owner of the reference is the main window.
// This design might be useful if we decide later on to swap out
// the logger while the tracker is running.
TrackLogger& logger;
reltrans rel;
struct {
Pose P;
QQuaternion QC = QQuaternion(1,0,0,0);
QQuaternion QR = QQuaternion(1,0,0,0);
} center;
time_units::ms backlog_time {};
bool tracking_started = false;
static double map(double pos, const Map& axis);
void logic();
void run() override;
bool maybe_enable_center_on_tracking_started();
void maybe_set_center_pose(const centering_state mode, const Pose& value, bool own_center_logic);
Pose apply_center(const centering_state mode, Pose value) const;
std::tuple<Pose, Pose, vec6_bool> get_selected_axis_values(const Pose& newpose) const;
Pose maybe_apply_filter(const Pose& value) const;
Pose apply_reltrans(Pose value, vec6_bool disabled, bool centerp);
Pose apply_zero_pos(Pose value) const;
void set_center(bool x);
bits b;
public:
pipeline(const Mappings& m, const runtime_libraries& libs, TrackLogger& logger);
~pipeline() override;
void raw_and_mapped_pose(double* mapped, double* raw) const;
void start() { QThread::start(QThread::HighPriority); }
void toggle_zero();
void toggle_enabled();
void set_held_center(bool value);
void set_enabled(bool value);
void set_zero(bool value);
};
} // ns pipeline_impl
using pipeline = pipeline_impl::pipeline;
|
