matrixfurry.com
The open source OpenXR runtime
monado: Apply clang-tidy fixes to most of the codebase.
All at least visually inspected, some revised from the auto-fixit
+25
-19
.clang-tidy
+25
-19
.clang-tidy
···
1
---
2
# SPDX-License-Identifier: CC0-1.0
3
-
# SPDX-FileCopyrightText: 2018-2020 Collabora, Ltd. and the Monado contributors
4
-
# Ideally we'd turn back on a few of these that are disabled near the end
5
-
Checks: 'clang-diagnostic-*,
6
-
clang-analyzer-*,
7
-
performance-*,
8
-
bugprone-*,
9
-
cert-*,
10
-
readability-*,
11
-
misc-*,
12
-
-modernize-*,
13
-
-clang-analyzer-security.insecureAPI.strcpy,
14
-
-bugprone-macro-parentheses,
15
-
-readability-braces-around-statements,
16
-
-misc-unused-parameters,
17
-
-readability-implicit-bool-conversion,
18
-
-clang-diagnostic-missing-field-initializers,
19
-
-clang-diagnostic-missing-braces,
20
-
-readability-uppercase-literal-suffix,
21
-
-misc-non-private-member-variables-in-classes'
22
WarningsAsErrors: ''
23
HeaderFilterRegex: 'src/xrt/.*'
24
AnalyzeTemporaryDtors: false
···
1
---
2
# SPDX-License-Identifier: CC0-1.0
3
+
# SPDX-FileCopyrightText: 2018-2022, Collabora, Ltd. and the Monado contributors
4
+
# Ideally we'd turn back on some of these that are disabled.
5
+
# Things on the same line are synonyms
6
+
Checks: |
7
+
clang-diagnostic-*,
8
+
clang-analyzer-*,
9
+
performance-*,
10
+
bugprone-*,
11
+
cert-*,
12
+
readability-*,
13
+
misc-*,
14
+
-modernize-*,
15
+
-misc-static-assert,
16
+
-bugprone-macro-parentheses,
17
+
-bugprone-reserved-identifier,-cert-dcl37-c,-cert-dcl51-cpp,
18
+
-clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
19
+
-clang-analyzer-security.insecureAPI.strcpy,
20
+
-clang-diagnostic-missing-braces,
21
+
-clang-diagnostic-missing-field-initializers,
22
+
-misc-non-private-member-variables-in-classes,
23
+
-misc-unused-parameters,
24
+
-readability-braces-around-statements,
25
+
-readability-implicit-bool-conversion,
26
+
-readability-redundant-access-specifiers,
27
+
-readability-uppercase-literal-suffix,
28
WarningsAsErrors: ''
29
HeaderFilterRegex: 'src/xrt/.*'
30
AnalyzeTemporaryDtors: false
+1
-1
src/xrt/auxiliary/gstreamer/gst_sink.h
+1
-1
src/xrt/auxiliary/gstreamer/gst_sink.h
+1
-1
src/xrt/auxiliary/math/m_api.h
+1
-1
src/xrt/auxiliary/math/m_api.h
+3
-1
src/xrt/auxiliary/math/m_filter_fifo.c
+3
-1
src/xrt/auxiliary/math/m_filter_fifo.c
+1
-1
src/xrt/auxiliary/math/m_filter_one_euro.c
+1
-1
src/xrt/auxiliary/math/m_filter_one_euro.c
+2
-2
src/xrt/auxiliary/math/m_filter_one_euro.h
+2
-2
src/xrt/auxiliary/math/m_filter_one_euro.h
···
102
};
103
104
void
105
-
m_filter_euro_f32_init(struct m_filter_euro_f32 *f, double fc_min, double beta, double fc_min_d);
106
void
107
m_filter_euro_f32_run(struct m_filter_euro_f32 *f, uint64_t ts, const float *in_y, float *out_y);
108
109
void
110
-
m_filter_euro_vec2_init(struct m_filter_euro_vec2 *f, double fc_min, double beta, double fc_min_d);
111
void
112
m_filter_euro_vec2_run(struct m_filter_euro_vec2 *f, uint64_t ts, const struct xrt_vec2 *in_y, struct xrt_vec2 *out_y);
113
void
···
102
};
103
104
void
105
+
m_filter_euro_f32_init(struct m_filter_euro_f32 *f, double fc_min, double fc_min_d, double beta);
106
void
107
m_filter_euro_f32_run(struct m_filter_euro_f32 *f, uint64_t ts, const float *in_y, float *out_y);
108
109
void
110
+
m_filter_euro_vec2_init(struct m_filter_euro_vec2 *f, double fc_min, double fc_min_d, double beta);
111
void
112
m_filter_euro_vec2_run(struct m_filter_euro_vec2 *f, uint64_t ts, const struct xrt_vec2 *in_y, struct xrt_vec2 *out_y);
113
void
+6
-3
src/xrt/auxiliary/math/m_imu_3dof.c
+6
-3
src/xrt/auxiliary/math/m_imu_3dof.c
···
117
return;
118
}
119
120
-
const float gravity_tolerance = .9f, gyro_tolerance = .1f;
121
-
const float min_tilt_error = 0.05f, max_tilt_error = 0.01f;
122
123
/*
124
* If the device is within tolerance levels, count this
···
196
f->grav.error_angle += correction_radians;
197
198
// Perform the correction.
199
-
struct xrt_quat corr_quat, old_orient;
200
math_quat_from_angle_vector(correction_radians, &f->grav.error_axis, &corr_quat);
201
old_orient = f->rot;
202
math_quat_rotate(&corr_quat, &old_orient, &f->rot);
···
117
return;
118
}
119
120
+
const float gravity_tolerance = .9f;
121
+
const float gyro_tolerance = .1f;
122
+
const float min_tilt_error = 0.05f;
123
+
const float max_tilt_error = 0.01f;
124
125
/*
126
* If the device is within tolerance levels, count this
···
198
f->grav.error_angle += correction_radians;
199
200
// Perform the correction.
201
+
struct xrt_quat corr_quat;
202
+
struct xrt_quat old_orient;
203
math_quat_from_angle_vector(correction_radians, &f->grav.error_axis, &corr_quat);
204
old_orient = f->rot;
205
math_quat_rotate(&corr_quat, &old_orient, &f->rot);
+1
-1
src/xrt/auxiliary/math/m_imu_3dof.h
+1
-1
src/xrt/auxiliary/math/m_imu_3dof.h
+4
-2
src/xrt/auxiliary/math/m_imu_pre.c
+4
-2
src/xrt/auxiliary/math/m_imu_pre.c
+4
-4
src/xrt/auxiliary/math/m_permutation.c
+4
-4
src/xrt/auxiliary/math/m_permutation.c
+6
-2
src/xrt/auxiliary/math/m_relation_history.h
+6
-2
src/xrt/auxiliary/math/m_relation_history.h
···
54
* @public @memberof m_relation_history
55
*/
56
bool
57
-
m_relation_history_push(struct m_relation_history *rh, struct xrt_space_relation const *in_relation, uint64_t ts);
58
59
/*!
60
* @brief Interpolates or extrapolates to the desired timestamp.
···
65
* @public @memberof m_relation_history
66
*/
67
enum m_relation_history_result
68
-
m_relation_history_get(struct m_relation_history *rh, uint64_t at_time_ns, struct xrt_space_relation *out_relation);
69
70
/*!
71
* @brief Get the latest report in the buffer, if any.
···
54
* @public @memberof m_relation_history
55
*/
56
bool
57
+
m_relation_history_push(struct m_relation_history *rh,
58
+
struct xrt_space_relation const *in_relation,
59
+
uint64_t timestamp);
60
61
/*!
62
* @brief Interpolates or extrapolates to the desired timestamp.
···
67
* @public @memberof m_relation_history
68
*/
69
enum m_relation_history_result
70
+
m_relation_history_get(struct m_relation_history *rh,
71
+
uint64_t at_timestamp_ns,
72
+
struct xrt_space_relation *out_relation);
73
74
/*!
75
* @brief Get the latest report in the buffer, if any.
+1
-2
src/xrt/auxiliary/math/m_space.h
+1
-2
src/xrt/auxiliary/math/m_space.h
+1
-1
src/xrt/auxiliary/os/os_ble.h
+1
-1
src/xrt/auxiliary/os/os_ble.h
+18
-9
src/xrt/auxiliary/os/os_ble_dbus.c
+18
-9
src/xrt/auxiliary/os/os_ble_dbus.c
···
72
{
73
// Create an array of bytes.
74
const char *container_signature = "y"; // dbus type signature string
75
-
DBusMessageIter iter, array;
76
77
// attach it to our dbus message
78
dbus_message_iter_init_append(msg, &iter);
···
86
{
87
// Create an empty array of string variant dicts.
88
const char *container_signature = "{sv}"; // dbus type signature string
89
-
DBusMessageIter iter, options;
90
91
// attach it to our dbus message
92
dbus_message_iter_init_append(msg, &iter);
···
521
static int
522
device_has_uuid(const DBusMessageIter *dict, const char *uuid, const char **out_path_str)
523
{
524
-
DBusMessageIter iface_elm, first_elm;
525
const char *iface_str;
526
const char *path_str;
527
···
616
static int
617
gatt_char_has_uuid_and_notify(const DBusMessageIter *dict, const char *uuid, const char **out_path_str)
618
{
619
-
DBusMessageIter first_elm, iface_elm;
620
const char *iface_str;
621
const char *path_str;
622
const char *uuid_str;
···
753
DBusMessage *msg = NULL;
754
DBusMessageIter args;
755
char *response = NULL;
756
-
int ret, type;
757
758
I(bch, "Connecting '%s'", dbus_address);
759
···
794
static int
795
ble_connect_all_devices_with_service_uuid(struct ble_conn_helper *bch, const char *service_uuid)
796
{
797
-
DBusMessageIter args, first_elm;
798
DBusMessage *msg = NULL;
799
800
int ret = ble_get_managed_objects(bch, &msg);
···
833
DBusMessage *msg = NULL;
834
DBusMessageIter args;
835
char *response = NULL;
836
-
int ret, type;
837
838
msg = dbus_message_new_method_call("org.bluez", // target for the method call
839
dbus_address, // object to call on
···
877
get_path_to_notify_char(
878
struct ble_conn_helper *bch, const char *dev_uuid, const char *char_uuid, char *output, size_t output_len)
879
{
880
-
DBusMessageIter args, first_elm;
881
DBusMessage *msg;
882
883
int ret = ble_get_managed_objects(bch, &msg);
···
1078
os_ble_broadcast_write_value(const char *service_uuid, const char *char_uuid, uint8_t value)
1079
{
1080
struct ble_conn_helper bch = {0};
1081
-
DBusMessageIter args, first_elm;
1082
DBusMessage *msg = NULL;
1083
int ret = 0;
1084
···
72
{
73
// Create an array of bytes.
74
const char *container_signature = "y"; // dbus type signature string
75
+
DBusMessageIter iter;
76
+
DBusMessageIter array;
77
78
// attach it to our dbus message
79
dbus_message_iter_init_append(msg, &iter);
···
87
{
88
// Create an empty array of string variant dicts.
89
const char *container_signature = "{sv}"; // dbus type signature string
90
+
DBusMessageIter iter;
91
+
DBusMessageIter options;
92
93
// attach it to our dbus message
94
dbus_message_iter_init_append(msg, &iter);
···
523
static int
524
device_has_uuid(const DBusMessageIter *dict, const char *uuid, const char **out_path_str)
525
{
526
+
DBusMessageIter iface_elm;
527
+
DBusMessageIter first_elm;
528
const char *iface_str;
529
const char *path_str;
530
···
619
static int
620
gatt_char_has_uuid_and_notify(const DBusMessageIter *dict, const char *uuid, const char **out_path_str)
621
{
622
+
DBusMessageIter first_elm;
623
+
DBusMessageIter iface_elm;
624
const char *iface_str;
625
const char *path_str;
626
const char *uuid_str;
···
757
DBusMessage *msg = NULL;
758
DBusMessageIter args;
759
char *response = NULL;
760
+
int ret;
761
+
int type;
762
763
I(bch, "Connecting '%s'", dbus_address);
764
···
799
static int
800
ble_connect_all_devices_with_service_uuid(struct ble_conn_helper *bch, const char *service_uuid)
801
{
802
+
DBusMessageIter args;
803
+
DBusMessageIter first_elm;
804
DBusMessage *msg = NULL;
805
806
int ret = ble_get_managed_objects(bch, &msg);
···
839
DBusMessage *msg = NULL;
840
DBusMessageIter args;
841
char *response = NULL;
842
+
int ret;
843
+
int type;
844
845
msg = dbus_message_new_method_call("org.bluez", // target for the method call
846
dbus_address, // object to call on
···
884
get_path_to_notify_char(
885
struct ble_conn_helper *bch, const char *dev_uuid, const char *char_uuid, char *output, size_t output_len)
886
{
887
+
DBusMessageIter args;
888
+
DBusMessageIter first_elm;
889
DBusMessage *msg;
890
891
int ret = ble_get_managed_objects(bch, &msg);
···
1086
os_ble_broadcast_write_value(const char *service_uuid, const char *char_uuid, uint8_t value)
1087
{
1088
struct ble_conn_helper bch = {0};
1089
+
DBusMessageIter args;
1090
+
DBusMessageIter first_elm;
1091
DBusMessage *msg = NULL;
1092
int ret = 0;
1093
+2
-2
src/xrt/auxiliary/tracking/t_calibration.cpp
+2
-2
src/xrt/auxiliary/tracking/t_calibration.cpp
···
1390
1391
//! Helper for NormalizedCoordsCache constructors
1392
static inline std::vector<cv::Vec2f>
1393
-
generateInputCoordsAndReserveOutputCoords(cv::Size size, std::vector<cv::Vec2f> &outputCoords)
1394
{
1395
std::vector<cv::Vec2f> inputCoords;
1396
···
1408
1409
//! Helper for NormalizedCoordsCache constructors
1410
static inline void
1411
-
populateCacheMats(cv::Size size,
1412
const std::vector<cv::Vec2f> &inputCoords,
1413
const std::vector<cv::Vec2f> &outputCoords,
1414
cv::Mat_<float> &cacheX,
···
1390
1391
//! Helper for NormalizedCoordsCache constructors
1392
static inline std::vector<cv::Vec2f>
1393
+
generateInputCoordsAndReserveOutputCoords(const cv::Size &size, std::vector<cv::Vec2f> &outputCoords)
1394
{
1395
std::vector<cv::Vec2f> inputCoords;
1396
···
1408
1409
//! Helper for NormalizedCoordsCache constructors
1410
static inline void
1411
+
populateCacheMats(const cv::Size &size,
1412
const std::vector<cv::Vec2f> &inputCoords,
1413
const std::vector<cv::Vec2f> &outputCoords,
1414
cv::Mat_<float> &cacheX,
+1
-1
src/xrt/auxiliary/tracking/t_debug_hsv_filter.cpp
+1
-1
src/xrt/auxiliary/tracking/t_debug_hsv_filter.cpp
+3
-3
src/xrt/auxiliary/tracking/t_debug_hsv_picker.cpp
+3
-3
src/xrt/auxiliary/tracking/t_debug_hsv_picker.cpp
···
79
{
80
for (uint32_t y = 0; y < xf->height; y++) {
81
uint8_t *src = (uint8_t *)xf->data + y * xf->stride;
82
-
auto hsv = d.debug.hsv.ptr<uint8_t>(y);
83
for (uint32_t x = 0; x < xf->width; x++) {
84
uint8_t y = src[0];
85
uint8_t cb = src[1];
···
106
{
107
for (uint32_t y = 0; y < xf->height; y++) {
108
uint8_t *src = (uint8_t *)xf->data + y * xf->stride;
109
-
auto hsv = d.debug.hsv.ptr<uint8_t>(y);
110
for (uint32_t x = 0; x < xf->width; x += 2) {
111
uint8_t y1 = src[0];
112
uint8_t cb = src[1];
···
211
extern "C" void
212
t_debug_hsv_picker_destroy(struct xrt_frame_node *node)
213
{
214
-
auto d = container_of(node, DebugHSVPicker, node);
215
delete d;
216
}
217
···
79
{
80
for (uint32_t y = 0; y < xf->height; y++) {
81
uint8_t *src = (uint8_t *)xf->data + y * xf->stride;
82
+
auto *hsv = d.debug.hsv.ptr<uint8_t>(y);
83
for (uint32_t x = 0; x < xf->width; x++) {
84
uint8_t y = src[0];
85
uint8_t cb = src[1];
···
106
{
107
for (uint32_t y = 0; y < xf->height; y++) {
108
uint8_t *src = (uint8_t *)xf->data + y * xf->stride;
109
+
auto *hsv = d.debug.hsv.ptr<uint8_t>(y);
110
for (uint32_t x = 0; x < xf->width; x += 2) {
111
uint8_t y1 = src[0];
112
uint8_t cb = src[1];
···
211
extern "C" void
212
t_debug_hsv_picker_destroy(struct xrt_frame_node *node)
213
{
214
+
auto *d = container_of(node, DebugHSVPicker, node);
215
delete d;
216
}
217
+4
-4
src/xrt/auxiliary/tracking/t_debug_hsv_viewer.cpp
+4
-4
src/xrt/auxiliary/tracking/t_debug_hsv_viewer.cpp
···
107
108
for (uint32_t yp = 0; yp < SIZE; yp++) {
109
for (int chan = 0; chan < NUM_CHAN; chan++) {
110
-
auto hsv_cap = bgr.ptr<uint8_t>(yp + SIZE * chan);
111
-
auto hsv_opt = bgr.ptr<uint8_t>(yp + SIZE * chan) + 256 * 3;
112
-
auto hsv_diff = bgr.ptr<uint8_t>(yp + SIZE * chan) + 512 * 3;
113
int mask = 1 << chan;
114
115
for (uint32_t xp = 0; xp < SIZE; xp++) {
···
160
extern "C" void
161
t_debug_hsv_viewer_destroy(struct xrt_frame_node *node)
162
{
163
-
auto d = container_of(node, DebugHSVViewer, node);
164
delete d;
165
}
166
···
107
108
for (uint32_t yp = 0; yp < SIZE; yp++) {
109
for (int chan = 0; chan < NUM_CHAN; chan++) {
110
+
auto *hsv_cap = bgr.ptr<uint8_t>(yp + SIZE * chan);
111
+
auto *hsv_opt = bgr.ptr<uint8_t>(yp + SIZE * chan) + 256 * 3;
112
+
auto *hsv_diff = bgr.ptr<uint8_t>(yp + SIZE * chan) + 512 * 3;
113
int mask = 1 << chan;
114
115
for (uint32_t xp = 0; xp < SIZE; xp++) {
···
160
extern "C" void
161
t_debug_hsv_viewer_destroy(struct xrt_frame_node *node)
162
{
163
+
auto *d = container_of(node, DebugHSVViewer, node);
164
delete d;
165
}
166
+2
-2
src/xrt/auxiliary/tracking/t_frame_cv_mat_wrapper.cpp
+2
-2
src/xrt/auxiliary/tracking/t_frame_cv_mat_wrapper.cpp
···
79
*/
80
81
void
82
-
FrameMat::wrapR8G8B8(cv::Mat mat, xrt_frame **fm_out, const Params /*&&?*/ params)
83
{
84
assert(mat.channels() == 3);
85
assert(mat.type() == CV_8UC3);
···
96
}
97
98
void
99
-
FrameMat::wrapL8(cv::Mat mat, xrt_frame **fm_out, const Params /*&&?*/ params)
100
{
101
assert(mat.channels() == 1);
102
assert(mat.type() == CV_8UC1);
···
79
*/
80
81
void
82
+
FrameMat::wrapR8G8B8(const cv::Mat &mat, xrt_frame **fm_out, const Params /*&&?*/ params)
83
{
84
assert(mat.channels() == 3);
85
assert(mat.type() == CV_8UC3);
···
96
}
97
98
void
99
+
FrameMat::wrapL8(const cv::Mat &mat, xrt_frame **fm_out, const Params /*&&?*/ params)
100
{
101
assert(mat.channels() == 1);
102
assert(mat.type() == CV_8UC1);
+4
-4
src/xrt/auxiliary/tracking/t_frame_cv_mat_wrapper.hpp
+4
-4
src/xrt/auxiliary/tracking/t_frame_cv_mat_wrapper.hpp
···
29
};
30
31
32
-
public:
33
// Exposed to the C api.
34
struct xrt_frame frame = {};
35
···
37
cv::Mat matrix = cv::Mat();
38
39
40
-
public:
41
/*!
42
* Only public due to C needed to destroy it.
43
*/
···
50
* its reference count decremented so make sure it's a valid pointer.
51
*/
52
static void
53
-
wrapR8G8B8(cv::Mat mat, xrt_frame **xf_ptr, const Params params = {});
54
55
/*!
56
* Wraps the given cv::Mat assuming it's a 8bit format matrix.
···
59
* its reference count decremented so make sure it's a valid pointer.
60
*/
61
static void
62
-
wrapL8(cv::Mat mat, xrt_frame **xf_ptr, const Params params = {});
63
64
65
private:
···
29
};
30
31
32
+
33
// Exposed to the C api.
34
struct xrt_frame frame = {};
35
···
37
cv::Mat matrix = cv::Mat();
38
39
40
+
41
/*!
42
* Only public due to C needed to destroy it.
43
*/
···
50
* its reference count decremented so make sure it's a valid pointer.
51
*/
52
static void
53
+
wrapR8G8B8(const cv::Mat &mat, xrt_frame **fm_out, Params params = {});
54
55
/*!
56
* Wraps the given cv::Mat assuming it's a 8bit format matrix.
···
59
* its reference count decremented so make sure it's a valid pointer.
60
*/
61
static void
62
+
wrapL8(const cv::Mat &mat, xrt_frame **fm_out, Params params = {});
63
64
65
private:
+6
-3
src/xrt/auxiliary/tracking/t_helper_debug_sink.hpp
+6
-3
src/xrt/auxiliary/tracking/t_helper_debug_sink.hpp
···
28
AlwaysSingle,
29
};
30
31
-
public:
32
Kind kind = AllAvailable;
33
struct u_sink_debug usd = {};
34
struct xrt_frame *frame = {};
···
36
cv::Mat rgb[2] = {};
37
38
39
-
public:
40
HelperDebugSink(Kind kind)
41
{
42
this->kind = kind;
···
60
61
// But what about second breakfast?
62
bool second_view = false;
63
-
int rows, cols, width, height;
64
65
cols = xf->width;
66
rows = xf->height;
···
28
AlwaysSingle,
29
};
30
31
+
32
Kind kind = AllAvailable;
33
struct u_sink_debug usd = {};
34
struct xrt_frame *frame = {};
···
36
cv::Mat rgb[2] = {};
37
38
39
+
40
HelperDebugSink(Kind kind)
41
{
42
this->kind = kind;
···
60
61
// But what about second breakfast?
62
bool second_view = false;
63
+
int rows;
64
+
int cols;
65
+
int width;
66
+
int height;
67
68
cols = xf->width;
69
rows = xf->height;
+1
-1
src/xrt/auxiliary/tracking/t_tracker_hand.cpp
+1
-1
src/xrt/auxiliary/tracking/t_tracker_hand.cpp
+5
-5
src/xrt/auxiliary/tracking/t_tracker_psmv.cpp
+5
-5
src/xrt/auxiliary/tracking/t_tracker_psmv.cpp
···
215
216
//! Convert our 2d point + disparities into 3d points.
217
static cv::Point3f
218
-
world_point_from_blobs(cv::Point2f left, cv::Point2f right, const cv::Matx44d &disparity_to_depth)
219
{
220
float disp = left.x - right.x;
221
cv::Vec4d xydw(left.x, left.y, disp, 1.0f);
···
278
do_view(t, t.view[1], r_grey, t.debug.rgb[1]);
279
280
cv::Point3f last_point(t.tracked_object_position.x, t.tracked_object_position.y, t.tracked_object_position.z);
281
-
auto nearest_world = make_lowest_score_finder<cv::Point3f>([&](cv::Point3f world_point) {
282
//! @todo don't really need the square root to be done here.
283
return cv::norm(world_point - last_point);
284
});
···
289
for (const cv::KeyPoint &l_keypoint : t.view[0].keypoints) {
290
cv::Point2f l_blob = l_keypoint.pt;
291
292
-
auto nearest_blob =
293
-
make_lowest_score_finder<cv::Point2f>([&](cv::Point2f r_blob) { return l_blob.x - r_blob.x; });
294
295
for (const cv::KeyPoint &r_keypoint : t.view[1].keypoints) {
296
cv::Point2f r_blob = r_keypoint.pt;
···
507
extern "C" void
508
t_psmv_node_destroy(struct xrt_frame_node *node)
509
{
510
-
auto t_ptr = container_of(node, TrackerPSMV, node);
511
os_thread_helper_destroy(&t_ptr->oth);
512
513
// Tidy variable setup.
···
215
216
//! Convert our 2d point + disparities into 3d points.
217
static cv::Point3f
218
+
world_point_from_blobs(const cv::Point2f &left, const cv::Point2f &right, const cv::Matx44d &disparity_to_depth)
219
{
220
float disp = left.x - right.x;
221
cv::Vec4d xydw(left.x, left.y, disp, 1.0f);
···
278
do_view(t, t.view[1], r_grey, t.debug.rgb[1]);
279
280
cv::Point3f last_point(t.tracked_object_position.x, t.tracked_object_position.y, t.tracked_object_position.z);
281
+
auto nearest_world = make_lowest_score_finder<cv::Point3f>([&](const cv::Point3f &world_point) {
282
//! @todo don't really need the square root to be done here.
283
return cv::norm(world_point - last_point);
284
});
···
289
for (const cv::KeyPoint &l_keypoint : t.view[0].keypoints) {
290
cv::Point2f l_blob = l_keypoint.pt;
291
292
+
auto nearest_blob = make_lowest_score_finder<cv::Point2f>(
293
+
[&](const cv::Point2f &r_blob) { return l_blob.x - r_blob.x; });
294
295
for (const cv::KeyPoint &r_keypoint : t.view[1].keypoints) {
296
cv::Point2f r_blob = r_keypoint.pt;
···
507
extern "C" void
508
t_psmv_node_destroy(struct xrt_frame_node *node)
509
{
510
+
auto *t_ptr = container_of(node, TrackerPSMV, node);
511
os_thread_helper_destroy(&t_ptr->oth);
512
513
// Tidy variable setup.
+19
-17
src/xrt/auxiliary/tracking/t_tracker_psvr.cpp
+19
-17
src/xrt/auxiliary/tracking/t_tracker_psvr.cpp
···
314
}
315
316
static float
317
-
dist_3d_cv(cv::Point3f a, cv::Point3f b)
318
{
319
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) + (a.z - b.z) * (a.z - b.z));
320
}
···
508
remove_outliers(std::vector<blob_point_t> *orig_points, std::vector<blob_point_t> *pruned_points, float outlier_thresh)
509
{
510
511
-
if (orig_points->size() == 0) {
512
return;
513
}
514
···
523
temp_points.push_back(orig_points->at(i));
524
}
525
}
526
-
if (temp_points.size() == 0) {
527
return;
528
}
529
···
620
static void
621
match_triangles(Eigen::Matrix4f *t1_mat,
622
Eigen::Matrix4f *t1_to_t2_mat,
623
-
Eigen::Vector4f t1_a,
624
-
Eigen::Vector4f t1_b,
625
-
Eigen::Vector4f t1_c,
626
-
Eigen::Vector4f t2_a,
627
-
Eigen::Vector4f t2_b,
628
-
Eigen::Vector4f t2_c)
629
{
630
// given 3 vertices in 'model space', and a corresponding 3 vertices
631
// in 'world space', compute the transformation matrix to map one
···
834
proximity_data.push_back(p);
835
}
836
837
-
if (proximity_data.size() > 0) {
838
839
// use the IMU rotation and the measured points in
840
// world space to compute a transform from model to world space.
···
899
Eigen::Matrix4f imu_solved_pose =
900
solve_with_imu(t, measured_points, last_measurement, solved, PSVR_SEARCH_RADIUS);
901
902
-
if (measured_points->size() < PSVR_OPTICAL_SOLVE_THRESH && last_measurement->size() > 0) {
903
return imu_solved_pose;
904
}
905
···
998
float prev_diff = last_diff(t, &meas_solved, &t.last_vertices);
999
float imu_diff = last_diff(t, &meas_solved, solved);
1000
1001
-
Eigen::Vector4f tl_pos, tr_pos, bl_pos, br_pos;
1002
bool has_bl = false;
1003
bool has_br = false;
1004
bool has_tl = false;
···
1147
uint32_t indices[PSVR_NUM_LEDS];
1148
1149
1150
-
public:
1151
~Helper()
1152
{
1153
m_permutator_reset(&mp);
···
1269
1270
1271
static void
1272
-
sample_line(cv::Mat &src, cv::Point2i start, cv::Point2i end, int *inside_length)
1273
{
1274
// use bresenhams algorithm to sample the
1275
// pixels between two points in an image
···
1589
// Convert our 2d point + disparities into 3d points.
1590
std::vector<blob_data_t> blob_datas;
1591
1592
-
if (t.l_blobs.size() > 0) {
1593
for (uint32_t i = 0; i < t.l_blobs.size(); i++) {
1594
float disp = t.r_blobs[i].pt.x - t.l_blobs[i].pt.x;
1595
cv::Vec4d xydw(t.l_blobs[i].pt.x, t.l_blobs[i].pt.y, disp, 1.0f);
···
1785
t.last_vertices.push_back(solved[i]);
1786
}
1787
1788
-
if (t.last_vertices.size() > 0) {
1789
filter_update(&t.last_vertices, t.track_filters, dt / 1000.0f);
1790
}
1791
···
1999
extern "C" void
2000
t_psvr_node_destroy(struct xrt_frame_node *node)
2001
{
2002
-
auto t_ptr = container_of(node, TrackerPSVR, node);
2003
2004
os_thread_helper_destroy(&t_ptr->oth);
2005
···
314
}
315
316
static float
317
+
dist_3d_cv(const cv::Point3f &a, const cv::Point3f &b)
318
{
319
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) + (a.z - b.z) * (a.z - b.z));
320
}
···
508
remove_outliers(std::vector<blob_point_t> *orig_points, std::vector<blob_point_t> *pruned_points, float outlier_thresh)
509
{
510
511
+
if (orig_points->empty()) {
512
return;
513
}
514
···
523
temp_points.push_back(orig_points->at(i));
524
}
525
}
526
+
if (temp_points.empty()) {
527
return;
528
}
529
···
620
static void
621
match_triangles(Eigen::Matrix4f *t1_mat,
622
Eigen::Matrix4f *t1_to_t2_mat,
623
+
const Eigen::Vector4f &t1_a,
624
+
const Eigen::Vector4f &t1_b,
625
+
const Eigen::Vector4f &t1_c,
626
+
const Eigen::Vector4f &t2_a,
627
+
const Eigen::Vector4f &t2_b,
628
+
const Eigen::Vector4f &t2_c)
629
{
630
// given 3 vertices in 'model space', and a corresponding 3 vertices
631
// in 'world space', compute the transformation matrix to map one
···
834
proximity_data.push_back(p);
835
}
836
837
+
if (!proximity_data.empty()) {
838
839
// use the IMU rotation and the measured points in
840
// world space to compute a transform from model to world space.
···
899
Eigen::Matrix4f imu_solved_pose =
900
solve_with_imu(t, measured_points, last_measurement, solved, PSVR_SEARCH_RADIUS);
901
902
+
if (measured_points->size() < PSVR_OPTICAL_SOLVE_THRESH && !last_measurement->empty()) {
903
return imu_solved_pose;
904
}
905
···
998
float prev_diff = last_diff(t, &meas_solved, &t.last_vertices);
999
float imu_diff = last_diff(t, &meas_solved, solved);
1000
1001
+
Eigen::Vector4f tl_pos;
1002
+
Eigen::Vector4f tr_pos;
1003
+
Eigen::Vector4f bl_pos;
1004
+
Eigen::Vector4f br_pos;
1005
bool has_bl = false;
1006
bool has_br = false;
1007
bool has_tl = false;
···
1150
uint32_t indices[PSVR_NUM_LEDS];
1151
1152
1153
~Helper()
1154
{
1155
m_permutator_reset(&mp);
···
1271
1272
1273
static void
1274
+
sample_line(cv::Mat &src, const cv::Point2i &start, const cv::Point2i &end, int *inside_length)
1275
{
1276
// use bresenhams algorithm to sample the
1277
// pixels between two points in an image
···
1591
// Convert our 2d point + disparities into 3d points.
1592
std::vector<blob_data_t> blob_datas;
1593
1594
+
if (!t.l_blobs.empty()) {
1595
for (uint32_t i = 0; i < t.l_blobs.size(); i++) {
1596
float disp = t.r_blobs[i].pt.x - t.l_blobs[i].pt.x;
1597
cv::Vec4d xydw(t.l_blobs[i].pt.x, t.l_blobs[i].pt.y, disp, 1.0f);
···
1787
t.last_vertices.push_back(solved[i]);
1788
}
1789
1790
+
if (!t.last_vertices.empty()) {
1791
filter_update(&t.last_vertices, t.track_filters, dt / 1000.0f);
1792
}
1793
···
2001
extern "C" void
2002
t_psvr_node_destroy(struct xrt_frame_node *node)
2003
{
2004
+
auto *t_ptr = container_of(node, TrackerPSVR, node);
2005
2006
os_thread_helper_destroy(&t_ptr->oth);
2007
+4
-4
src/xrt/auxiliary/tracking/t_tracking.h
+4
-4
src/xrt/auxiliary/tracking/t_tracking.h
···
99
};
100
101
/*!
102
-
* Allocates a new stereo calibration data, unreferences the old @p calib.
103
*
104
* Also initializes t_camera_calibration::distortion_num in t_stereo_camera_calibration::view, only 5 and 14 is
105
* accepted.
···
107
* @public @memberof t_stereo_camera_calibration
108
*/
109
void
110
-
t_stereo_camera_calibration_alloc(struct t_stereo_camera_calibration **calib, uint32_t distortion_num);
111
112
/*!
113
* Only to be called by @p t_stereo_camera_calibration_reference.
···
188
* @relates t_stereo_camera_calibration
189
*/
190
bool
191
-
t_stereo_camera_calibration_from_json_v2(cJSON *json, struct t_stereo_camera_calibration **out_data);
192
193
/*!
194
* Convert the given stereo calibration data into a json object in v2 format.
···
196
* @relates t_stereo_camera_calibration
197
*/
198
bool
199
-
t_stereo_camera_calibration_to_json_v2(cJSON **out_json, struct t_stereo_camera_calibration *data);
200
201
202
/*!
···
99
};
100
101
/*!
102
+
* Allocates a new stereo calibration data, unreferences the old data pointed to by @p out_c.
103
*
104
* Also initializes t_camera_calibration::distortion_num in t_stereo_camera_calibration::view, only 5 and 14 is
105
* accepted.
···
107
* @public @memberof t_stereo_camera_calibration
108
*/
109
void
110
+
t_stereo_camera_calibration_alloc(struct t_stereo_camera_calibration **out_c, uint32_t distortion_num);
111
112
/*!
113
* Only to be called by @p t_stereo_camera_calibration_reference.
···
188
* @relates t_stereo_camera_calibration
189
*/
190
bool
191
+
t_stereo_camera_calibration_from_json_v2(cJSON *json, struct t_stereo_camera_calibration **out_stereo);
192
193
/*!
194
* Convert the given stereo calibration data into a json object in v2 format.
···
196
* @relates t_stereo_camera_calibration
197
*/
198
bool
199
+
t_stereo_camera_calibration_to_json_v2(cJSON **out_cjson, struct t_stereo_camera_calibration *data);
200
201
202
/*!
+3
-7
src/xrt/auxiliary/util/u_config_json.c
+3
-7
src/xrt/auxiliary/util/u_config_json.c
···
7
* @ingroup st_prober
8
*/
9
10
-
#ifdef _MSC_VER
11
-
#define _CRT_SECURE_NO_WARNINGS
12
-
#endif
13
-
14
#include <xrt/xrt_device.h>
15
#include "xrt/xrt_settings.h"
16
#include "xrt/xrt_config.h"
···
311
bad |= !get_obj_str(override, "tracker_device_serial", o->tracker_device_serial, XRT_DEVICE_NAME_LEN);
312
313
char override_type[256];
314
-
bad |= !get_obj_str(override, "type", override_type, 256);
315
-
if (strncmp(override_type, "direct", 256) == 0) {
316
o->override_type = XRT_TRACKING_OVERRIDE_DIRECT;
317
-
} else if (strncmp(override_type, "attached", 256) == 0) {
318
o->override_type = XRT_TRACKING_OVERRIDE_ATTACHED;
319
}
320
···
7
* @ingroup st_prober
8
*/
9
10
#include <xrt/xrt_device.h>
11
#include "xrt/xrt_settings.h"
12
#include "xrt/xrt_config.h"
···
307
bad |= !get_obj_str(override, "tracker_device_serial", o->tracker_device_serial, XRT_DEVICE_NAME_LEN);
308
309
char override_type[256];
310
+
bad |= !get_obj_str(override, "type", override_type, sizeof(override_type));
311
+
if (strncmp(override_type, "direct", sizeof(override_type) - 1) == 0) {
312
o->override_type = XRT_TRACKING_OVERRIDE_DIRECT;
313
+
} else if (strncmp(override_type, "attached", sizeof(override_type) - 1) == 0) {
314
o->override_type = XRT_TRACKING_OVERRIDE_ATTACHED;
315
}
316
+8
-8
src/xrt/auxiliary/util/u_distortion.c
+8
-8
src/xrt/auxiliary/util/u_distortion.c
···
83
84
// Tan-angle to texture coordinates
85
// clang-format off
86
-
l_values.texture.size.x = tan(-args->fov.angle_left) + tan(args->fov.angle_right);
87
-
l_values.texture.size.y = tan(args->fov.angle_up) + tan(-args->fov.angle_down);
88
-
l_values.texture.offset.x = tan(-args->fov.angle_left);
89
-
l_values.texture.offset.y = tan(-args->fov.angle_down);
90
// clang-format on
91
92
// Fix up views not covering the entire screen.
···
118
119
// Tanangle to texture coordinates
120
// clang-format off
121
-
r_values.texture.size.x = tan(-args->fov.angle_left) + tan(args->fov.angle_right);
122
-
r_values.texture.size.y = tan(args->fov.angle_up) + tan(-args->fov.angle_down);
123
-
r_values.texture.offset.x = tan(-args->fov.angle_left);
124
-
r_values.texture.offset.y = tan(-args->fov.angle_down);
125
// clang-format on
126
127
// Fix up views not covering the entire screen.
···
83
84
// Tan-angle to texture coordinates
85
// clang-format off
86
+
l_values.texture.size.x = tanf(-args->fov.angle_left) + tanf(args->fov.angle_right);
87
+
l_values.texture.size.y = tanf(args->fov.angle_up) + tanf(-args->fov.angle_down);
88
+
l_values.texture.offset.x = tanf(-args->fov.angle_left);
89
+
l_values.texture.offset.y = tanf(-args->fov.angle_down);
90
// clang-format on
91
92
// Fix up views not covering the entire screen.
···
118
119
// Tanangle to texture coordinates
120
// clang-format off
121
+
r_values.texture.size.x = tanf(-args->fov.angle_left) + tanf(args->fov.angle_right);
122
+
r_values.texture.size.y = tanf(args->fov.angle_up) + tanf(-args->fov.angle_down);
123
+
r_values.texture.offset.x = tanf(-args->fov.angle_left);
124
+
r_values.texture.offset.y = tanf(-args->fov.angle_down);
125
// clang-format on
126
127
// Fix up views not covering the entire screen.
+8
-8
src/xrt/auxiliary/util/u_distortion_mesh.c
+8
-8
src/xrt/auxiliary/util/u_distortion_mesh.c
···
301
302
struct xrt_fov fov = values->fov[view];
303
304
-
float left_ray_bound = tan(fov.angle_left);
305
-
float right_ray_bound = tan(fov.angle_right);
306
-
float up_ray_bound = tan(fov.angle_up);
307
-
float down_ray_bound = tan(fov.angle_down);
308
309
float u_eye = math_map_ranges(x_ray, left_ray_bound, right_ray_bound, 0, 1);
310
···
363
364
struct xrt_fov fov = values->fov[view];
365
366
-
float left_ray_bound = tan(fov.angle_left);
367
-
float right_ray_bound = tan(fov.angle_right);
368
-
float up_ray_bound = tan(fov.angle_up);
369
-
float down_ray_bound = tan(fov.angle_down);
370
// printf("%f %f", fov.angle_down, fov.angle_up);
371
372
float u_eye = math_map_ranges(x_ray, left_ray_bound, right_ray_bound, 0, 1);
···
301
302
struct xrt_fov fov = values->fov[view];
303
304
+
float left_ray_bound = tanf(fov.angle_left);
305
+
float right_ray_bound = tanf(fov.angle_right);
306
+
float up_ray_bound = tanf(fov.angle_up);
307
+
float down_ray_bound = tanf(fov.angle_down);
308
309
float u_eye = math_map_ranges(x_ray, left_ray_bound, right_ray_bound, 0, 1);
310
···
363
364
struct xrt_fov fov = values->fov[view];
365
366
+
float left_ray_bound = tanf(fov.angle_left);
367
+
float right_ray_bound = tanf(fov.angle_right);
368
+
float up_ray_bound = tanf(fov.angle_up);
369
+
float down_ray_bound = tanf(fov.angle_down);
370
// printf("%f %f", fov.angle_down, fov.angle_up);
371
372
float u_eye = math_map_ranges(x_ray, left_ray_bound, right_ray_bound, 0, 1);
+4
-4
src/xrt/auxiliary/util/u_file.c
+4
-4
src/xrt/auxiliary/util/u_file.c
···
66
}
67
68
ssize_t
69
-
u_file_get_path_in_config_dir(const char *filename, char *out_path, size_t out_path_size)
70
{
71
char tmp[PATH_MAX];
72
ssize_t i = u_file_get_config_dir(tmp, sizeof(tmp));
···
74
return -1;
75
}
76
77
-
return snprintf(out_path, out_path_size, "%s/%s", tmp, filename);
78
}
79
80
FILE *
···
117
}
118
119
ssize_t
120
-
u_file_get_path_in_runtime_dir(const char *filename, char *out_path, size_t out_path_size)
121
{
122
char tmp[PATH_MAX];
123
ssize_t i = u_file_get_runtime_dir(tmp, sizeof(tmp));
···
125
return -1;
126
}
127
128
-
return snprintf(out_path, out_path_size, "%s/%s", tmp, filename);
129
}
130
131
#endif
···
66
}
67
68
ssize_t
69
+
u_file_get_path_in_config_dir(const char *suffix, char *out_path, size_t out_path_size)
70
{
71
char tmp[PATH_MAX];
72
ssize_t i = u_file_get_config_dir(tmp, sizeof(tmp));
···
74
return -1;
75
}
76
77
+
return snprintf(out_path, out_path_size, "%s/%s", tmp, suffix);
78
}
79
80
FILE *
···
117
}
118
119
ssize_t
120
+
u_file_get_path_in_runtime_dir(const char *suffix, char *out_path, size_t out_path_size)
121
{
122
char tmp[PATH_MAX];
123
ssize_t i = u_file_get_runtime_dir(tmp, sizeof(tmp));
···
125
return -1;
126
}
127
128
+
return snprintf(out_path, out_path_size, "%s/%s", tmp, suffix);
129
}
130
131
#endif
+1
-1
src/xrt/auxiliary/util/u_file.h
+1
-1
src/xrt/auxiliary/util/u_file.h
+2
-2
src/xrt/auxiliary/util/u_hashmap.cpp
+2
-2
src/xrt/auxiliary/util/u_hashmap.cpp
+2
-2
src/xrt/auxiliary/util/u_hashset.cpp
+2
-2
src/xrt/auxiliary/util/u_hashset.cpp
+1
-3
src/xrt/auxiliary/util/u_id_ringbuffer.cpp
+1
-3
src/xrt/auxiliary/util/u_id_ringbuffer.cpp
+2
-4
src/xrt/auxiliary/util/u_index_fifo.h
+2
-4
src/xrt/auxiliary/util/u_index_fifo.h
+1
-1
src/xrt/auxiliary/util/u_json.hpp
+1
-1
src/xrt/auxiliary/util/u_json.hpp
+2
-2
src/xrt/auxiliary/util/u_pacing_app.c
+2
-2
src/xrt/auxiliary/util/u_pacing_app.c
+2
-2
src/xrt/auxiliary/util/u_pacing_compositor.c
+2
-2
src/xrt/auxiliary/util/u_pacing_compositor.c
···
675
xrt_result_t
676
u_pc_display_timing_create(uint64_t estimated_frame_period_ns,
677
const struct u_pc_display_timing_config *config,
678
-
struct u_pacing_compositor **out_uft)
679
{
680
struct pacing_compositor *pc = U_TYPED_CALLOC(struct pacing_compositor);
681
pc->base.predict = pc_predict;
···
699
// Extra margin that is added to compositor time.
700
pc->margin_ns = config->margin_ns;
701
702
-
*out_uft = &pc->base;
703
704
double estimated_frame_period_ms = ns_to_ms(estimated_frame_period_ns);
705
UPC_LOG_I("Created compositor pacing (%.2fms)", estimated_frame_period_ms);
···
675
xrt_result_t
676
u_pc_display_timing_create(uint64_t estimated_frame_period_ns,
677
const struct u_pc_display_timing_config *config,
678
+
struct u_pacing_compositor **out_upc)
679
{
680
struct pacing_compositor *pc = U_TYPED_CALLOC(struct pacing_compositor);
681
pc->base.predict = pc_predict;
···
699
// Extra margin that is added to compositor time.
700
pc->margin_ns = config->margin_ns;
701
702
+
*out_upc = &pc->base;
703
704
double estimated_frame_period_ms = ns_to_ms(estimated_frame_period_ns);
705
UPC_LOG_I("Created compositor pacing (%.2fms)", estimated_frame_period_ms);
+2
-2
src/xrt/auxiliary/util/u_pacing_compositor_fake.c
+2
-2
src/xrt/auxiliary/util/u_pacing_compositor_fake.c
···
177
*/
178
179
xrt_result_t
180
-
u_pc_fake_create(uint64_t estimated_frame_period_ns, uint64_t now_ns, struct u_pacing_compositor **out_uft)
181
{
182
struct fake_timing *ft = U_TYPED_CALLOC(struct fake_timing);
183
ft->base.predict = pc_predict;
···
200
ft->last_display_time_ns = now_ns + U_TIME_1MS_IN_NS * 50.0;
201
202
// Return value.
203
-
*out_uft = &ft->base;
204
205
U_LOG_I("Created fake timing");
206
···
177
*/
178
179
xrt_result_t
180
+
u_pc_fake_create(uint64_t estimated_frame_period_ns, uint64_t now_ns, struct u_pacing_compositor **out_upc)
181
{
182
struct fake_timing *ft = U_TYPED_CALLOC(struct fake_timing);
183
ft->base.predict = pc_predict;
···
200
ft->last_display_time_ns = now_ns + U_TIME_1MS_IN_NS * 50.0;
201
202
// Return value.
203
+
*out_upc = &ft->base;
204
205
U_LOG_I("Created fake timing");
206
+2
-1
src/xrt/auxiliary/util/u_sink_stereo_sbs_to_slam_sbs.c
+2
-1
src/xrt/auxiliary/util/u_sink_stereo_sbs_to_slam_sbs.c
+1
-4
src/xrt/auxiliary/util/u_string_list.hpp
+1
-4
src/xrt/auxiliary/util/u_string_list.hpp
+5
-5
src/xrt/auxiliary/util/u_template_historybuf_const_iterator.inl
+5
-5
src/xrt/auxiliary/util/u_template_historybuf_const_iterator.inl
···
42
43
// copy and move as you wish
44
HistoryBufConstIterator(HistoryBufConstIterator const &) = default;
45
-
HistoryBufConstIterator(HistoryBufConstIterator &&) = default;
46
HistoryBufConstIterator &
47
operator=(HistoryBufConstIterator const &) = default;
48
HistoryBufConstIterator &
49
-
operator=(HistoryBufConstIterator &&) = default;
50
51
//! Implicit conversion from a non-const iterator
52
HistoryBufConstIterator(const HistoryBufIterator<T, MaxSize> &other);
···
119
static Self
120
begin(container_type &container, const RingBufferHelper &helper)
121
{
122
-
return {&container, std::move(base::begin(helper))};
123
}
124
125
//! Construct the "past the end" iterator that can be decremented safely
126
static Self
127
end(container_type &container, const RingBufferHelper &helper)
128
{
129
-
return {&container, std::move(base::end(helper))};
130
}
131
132
// for use internally
133
HistoryBufConstIterator(container_type *container, base &&iter_base)
134
-
: base(std::move(iter_base)), container_(container)
135
{}
136
container_type *container_{nullptr};
137
};
···
42
43
// copy and move as you wish
44
HistoryBufConstIterator(HistoryBufConstIterator const &) = default;
45
+
HistoryBufConstIterator(HistoryBufConstIterator &&) noexcept = default;
46
HistoryBufConstIterator &
47
operator=(HistoryBufConstIterator const &) = default;
48
HistoryBufConstIterator &
49
+
operator=(HistoryBufConstIterator &&) noexcept = default;
50
51
//! Implicit conversion from a non-const iterator
52
HistoryBufConstIterator(const HistoryBufIterator<T, MaxSize> &other);
···
119
static Self
120
begin(container_type &container, const RingBufferHelper &helper)
121
{
122
+
return {&container, base::begin(helper)};
123
}
124
125
//! Construct the "past the end" iterator that can be decremented safely
126
static Self
127
end(container_type &container, const RingBufferHelper &helper)
128
{
129
+
return {&container, base::end(helper)};
130
}
131
132
// for use internally
133
HistoryBufConstIterator(container_type *container, base &&iter_base)
134
+
: base(iter_base), container_(container)
135
{}
136
container_type *container_{nullptr};
137
};
+6
-7
src/xrt/auxiliary/util/u_template_historybuf_iterator.inl
+6
-7
src/xrt/auxiliary/util/u_template_historybuf_iterator.inl
···
41
42
// copy and move as you wish
43
HistoryBufIterator(HistoryBufIterator const &) = default;
44
-
HistoryBufIterator(HistoryBufIterator &&) = default;
45
HistoryBufIterator &
46
operator=(HistoryBufIterator const &) = default;
47
HistoryBufIterator &
48
-
operator=(HistoryBufIterator &&) = default;
49
50
//! Is this iterator valid?
51
bool
···
115
static Self
116
begin(container_type &container, const RingBufferHelper &helper)
117
{
118
-
return {&container, std::move(base::begin(helper))};
119
}
120
121
//! Construct the "past the end" iterator that can be decremented safely
122
static Self
123
end(container_type &container, const RingBufferHelper &helper)
124
{
125
-
return {&container, std::move(base::end(helper))};
126
}
127
128
// for use internally
129
-
HistoryBufIterator(container_type *container, base &&iter_base)
130
-
: base(std::move(iter_base)), container_(container)
131
{}
132
container_type *container_{nullptr};
133
};
···
136
inline typename HistoryBufIterator<T, MaxSize>::reference
137
HistoryBufIterator<T, MaxSize>::operator*() const
138
{
139
-
auto ptr = container_->get_at_index(base::index());
140
if (ptr == nullptr) {
141
throw std::out_of_range("Iterator index out of range");
142
}
···
41
42
// copy and move as you wish
43
HistoryBufIterator(HistoryBufIterator const &) = default;
44
+
HistoryBufIterator(HistoryBufIterator &&) noexcept = default;
45
HistoryBufIterator &
46
operator=(HistoryBufIterator const &) = default;
47
HistoryBufIterator &
48
+
operator=(HistoryBufIterator &&) noexcept = default;
49
50
//! Is this iterator valid?
51
bool
···
115
static Self
116
begin(container_type &container, const RingBufferHelper &helper)
117
{
118
+
return {&container, base::begin(helper)};
119
}
120
121
//! Construct the "past the end" iterator that can be decremented safely
122
static Self
123
end(container_type &container, const RingBufferHelper &helper)
124
{
125
+
return {&container, base::end(helper)};
126
}
127
128
// for use internally
129
+
HistoryBufIterator(container_type *container, base &&iter_base) : base(iter_base), container_(container)
130
{}
131
container_type *container_{nullptr};
132
};
···
135
inline typename HistoryBufIterator<T, MaxSize>::reference
136
HistoryBufIterator<T, MaxSize>::operator*() const
137
{
138
+
auto *ptr = container_->get_at_index(base::index());
139
if (ptr == nullptr) {
140
throw std::out_of_range("Iterator index out of range");
141
}
+11
-11
src/xrt/auxiliary/util/u_worker.c
+11
-11
src/xrt/auxiliary/util/u_worker.c
···
109
*/
110
111
static inline struct group *
112
-
group(struct u_worker_group *uwp)
113
{
114
-
return (struct group *)uwp;
115
}
116
117
static inline struct pool *
···
464
}
465
466
void
467
-
u_worker_group_push(struct u_worker_group *uwp, u_worker_group_func_t f, void *data)
468
{
469
XRT_TRACE_MARKER();
470
471
-
struct group *g = group(uwp);
472
struct pool *p = pool(g->uwtp);
473
474
os_mutex_lock(&p->mutex);
···
476
os_mutex_unlock(&p->mutex);
477
478
//! @todo Don't wait all, wait one.
479
-
u_worker_group_wait_all(uwp);
480
481
os_mutex_lock(&p->mutex);
482
}
···
492
}
493
494
void
495
-
u_worker_group_wait_all(struct u_worker_group *uwp)
496
{
497
XRT_TRACE_MARKER();
498
499
-
struct group *g = group(uwp);
500
struct pool *p = pool(g->uwtp);
501
502
os_mutex_lock(&p->mutex);
···
517
}
518
519
void
520
-
u_worker_group_destroy(struct u_worker_group *uwp)
521
{
522
XRT_TRACE_MARKER();
523
524
-
struct group *g = group(uwp);
525
assert(g->base.reference.count == 0);
526
527
-
u_worker_group_wait_all(uwp);
528
529
u_worker_thread_pool_reference(&g->uwtp, NULL);
530
531
os_cond_destroy(&g->waiting.cond);
532
533
-
free(uwp);
534
}
···
109
*/
110
111
static inline struct group *
112
+
group(struct u_worker_group *uwg)
113
{
114
+
return (struct group *)uwg;
115
}
116
117
static inline struct pool *
···
464
}
465
466
void
467
+
u_worker_group_push(struct u_worker_group *uwg, u_worker_group_func_t f, void *data)
468
{
469
XRT_TRACE_MARKER();
470
471
+
struct group *g = group(uwg);
472
struct pool *p = pool(g->uwtp);
473
474
os_mutex_lock(&p->mutex);
···
476
os_mutex_unlock(&p->mutex);
477
478
//! @todo Don't wait all, wait one.
479
+
u_worker_group_wait_all(uwg);
480
481
os_mutex_lock(&p->mutex);
482
}
···
492
}
493
494
void
495
+
u_worker_group_wait_all(struct u_worker_group *uwg)
496
{
497
XRT_TRACE_MARKER();
498
499
+
struct group *g = group(uwg);
500
struct pool *p = pool(g->uwtp);
501
502
os_mutex_lock(&p->mutex);
···
517
}
518
519
void
520
+
u_worker_group_destroy(struct u_worker_group *uwg)
521
{
522
XRT_TRACE_MARKER();
523
524
+
struct group *g = group(uwg);
525
assert(g->base.reference.count == 0);
526
527
+
u_worker_group_wait_all(uwg);
528
529
u_worker_thread_pool_reference(&g->uwtp, NULL);
530
531
os_cond_destroy(&g->waiting.cond);
532
533
+
free(uwg);
534
}
+9
-4
src/xrt/auxiliary/vive/vive_config.c
+9
-4
src/xrt/auxiliary/vive/vive_config.c
···
60
static void
61
_get_pose_from_pos_x_z(const cJSON *obj, struct xrt_pose *pose)
62
{
63
-
struct xrt_vec3 plus_x, plus_z;
64
JSON_VEC3(obj, "plus_x", &plus_x);
65
JSON_VEC3(obj, "plus_z", &plus_z);
66
JSON_VEC3(obj, "position", &pose->position);
···
248
if (!found_camera_json) {
249
U_LOG_W("HMD is Index, but no cameras in json file!");
250
return false;
251
-
} else if (!succeeded_parsing_json) {
252
U_LOG_E("Failed to parse Index camera calibration!");
253
return false;
254
}
···
264
d->cameras.view[1].headref = camera_to_head;
265
266
// Calculate where in the right camera space the left camera is.
267
-
struct xrt_pose invert, left_in_right;
268
math_pose_invert(&d->cameras.view[1].headref, &invert);
269
math_pose_transform(&d->cameras.view[0].headref, &invert, &left_in_right);
270
d->cameras.left_in_right = left_in_right;
···
321
}
322
323
struct xrt_vec3 pos = d->cameras.opencv.position;
324
-
struct xrt_vec3 x = {1, 0, 0}, y = {0, 1, 0}, z = {0, 0, 1};
325
math_quat_rotate_vec3(&d->cameras.opencv.orientation, &x, &x);
326
math_quat_rotate_vec3(&d->cameras.opencv.orientation, &y, &y);
327
math_quat_rotate_vec3(&d->cameras.opencv.orientation, &z, &z);
···
60
static void
61
_get_pose_from_pos_x_z(const cJSON *obj, struct xrt_pose *pose)
62
{
63
+
struct xrt_vec3 plus_x;
64
+
struct xrt_vec3 plus_z;
65
JSON_VEC3(obj, "plus_x", &plus_x);
66
JSON_VEC3(obj, "plus_z", &plus_z);
67
JSON_VEC3(obj, "position", &pose->position);
···
249
if (!found_camera_json) {
250
U_LOG_W("HMD is Index, but no cameras in json file!");
251
return false;
252
+
}
253
+
if (!succeeded_parsing_json) {
254
U_LOG_E("Failed to parse Index camera calibration!");
255
return false;
256
}
···
266
d->cameras.view[1].headref = camera_to_head;
267
268
// Calculate where in the right camera space the left camera is.
269
+
struct xrt_pose invert;
270
+
struct xrt_pose left_in_right;
271
math_pose_invert(&d->cameras.view[1].headref, &invert);
272
math_pose_transform(&d->cameras.view[0].headref, &invert, &left_in_right);
273
d->cameras.left_in_right = left_in_right;
···
324
}
325
326
struct xrt_vec3 pos = d->cameras.opencv.position;
327
+
struct xrt_vec3 x = XRT_VEC3_UNIT_X;
328
+
struct xrt_vec3 y = XRT_VEC3_UNIT_Y;
329
+
struct xrt_vec3 z = XRT_VEC3_UNIT_Z;
330
math_quat_rotate_vec3(&d->cameras.opencv.orientation, &x, &x);
331
math_quat_rotate_vec3(&d->cameras.opencv.orientation, &y, &y);
332
math_quat_rotate_vec3(&d->cameras.opencv.orientation, &z, &z);
+1
-1
src/xrt/auxiliary/vive/vive_config.h
+1
-1
src/xrt/auxiliary/vive/vive_config.h
+2
-2
src/xrt/auxiliary/vk/vk_helpers.h
+2
-2
src/xrt/auxiliary/vk/vk_helpers.h
···
540
vk_create_device(struct vk_bundle *vk,
541
int forced_index,
542
bool only_compute,
543
-
VkQueueGlobalPriorityEXT global_priorty,
544
struct u_string_list *required_device_ext_list,
545
struct u_string_list *optional_device_ext_list,
546
const struct vk_device_features *optional_device_features);
···
953
* Does error logging.
954
*/
955
VkResult
956
-
vk_create_command_buffer(struct vk_bundle *vk, VkCommandBuffer *out_cmd);
957
958
/*!
959
* Destroys a command buffer, takes the cmd_pool_mutex.
···
540
vk_create_device(struct vk_bundle *vk,
541
int forced_index,
542
bool only_compute,
543
+
VkQueueGlobalPriorityEXT global_priority,
544
struct u_string_list *required_device_ext_list,
545
struct u_string_list *optional_device_ext_list,
546
const struct vk_device_features *optional_device_features);
···
953
* Does error logging.
954
*/
955
VkResult
956
+
vk_create_command_buffer(struct vk_bundle *vk, VkCommandBuffer *out_command_buffer);
957
958
/*!
959
* Destroys a command buffer, takes the cmd_pool_mutex.
-2
src/xrt/auxiliary/vk/vk_image_readback_to_xf_pool.c
-2
src/xrt/auxiliary/vk/vk_image_readback_to_xf_pool.c
+3
-8
src/xrt/auxiliary/vk/vk_sync_objects.c
+3
-8
src/xrt/auxiliary/vk/vk_sync_objects.c
···
29
#if defined(XRT_GRAPHICS_SYNC_HANDLE_IS_FD)
30
if (vk->external.binary_semaphore_opaque_fd) {
31
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
32
-
} else {
33
-
return 0;
34
}
35
#elif defined(XRT_GRAPHICS_SYNC_HANDLE_IS_WIN32_HANDLE)
36
if (vk->external.binary_semaphore_win32_handle) {
37
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
38
-
} else {
39
-
return 0;
40
}
41
#else
42
#error "Need to port semaphore type code."
43
#endif
44
}
45
46
#ifdef VK_KHR_timeline_semaphore
···
50
#if defined(XRT_GRAPHICS_SYNC_HANDLE_IS_FD)
51
if (vk->external.timeline_semaphore_opaque_fd) {
52
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
53
-
} else {
54
-
return 0;
55
}
56
#elif defined(XRT_GRAPHICS_SYNC_HANDLE_IS_WIN32_HANDLE)
57
if (vk->external.timeline_semaphore_win32_handle) {
58
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
59
-
} else {
60
-
return 0;
61
}
62
#else
63
#error "Need to port semaphore type code."
64
#endif
65
}
66
#endif
67
···
29
#if defined(XRT_GRAPHICS_SYNC_HANDLE_IS_FD)
30
if (vk->external.binary_semaphore_opaque_fd) {
31
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
32
}
33
+
34
#elif defined(XRT_GRAPHICS_SYNC_HANDLE_IS_WIN32_HANDLE)
35
if (vk->external.binary_semaphore_win32_handle) {
36
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
37
}
38
#else
39
#error "Need to port semaphore type code."
40
#endif
41
+
return 0;
42
}
43
44
#ifdef VK_KHR_timeline_semaphore
···
48
#if defined(XRT_GRAPHICS_SYNC_HANDLE_IS_FD)
49
if (vk->external.timeline_semaphore_opaque_fd) {
50
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
51
}
52
#elif defined(XRT_GRAPHICS_SYNC_HANDLE_IS_WIN32_HANDLE)
53
if (vk->external.timeline_semaphore_win32_handle) {
54
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
55
}
56
#else
57
#error "Need to port semaphore type code."
58
#endif
59
+
return 0;
60
}
61
#endif
62
+6
-2
src/xrt/compositor/client/comp_gl_client.c
+6
-2
src/xrt/compositor/client/comp_gl_client.c
···
233
const struct xrt_layer_data *data)
234
{
235
struct client_gl_compositor *c = client_gl_compositor(xc);
236
-
struct xrt_swapchain *l_xscn, *r_xscn;
237
238
assert(data->type == XRT_LAYER_STEREO_PROJECTION);
239
···
256
const struct xrt_layer_data *data)
257
{
258
struct client_gl_compositor *c = client_gl_compositor(xc);
259
-
struct xrt_swapchain *l_xscn, *r_xscn, *l_d_xscn, *r_d_xscn;
260
261
assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH);
262
···
233
const struct xrt_layer_data *data)
234
{
235
struct client_gl_compositor *c = client_gl_compositor(xc);
236
+
struct xrt_swapchain *l_xscn;
237
+
struct xrt_swapchain *r_xscn;
238
239
assert(data->type == XRT_LAYER_STEREO_PROJECTION);
240
···
257
const struct xrt_layer_data *data)
258
{
259
struct client_gl_compositor *c = client_gl_compositor(xc);
260
+
struct xrt_swapchain *l_xscn;
261
+
struct xrt_swapchain *r_xscn;
262
+
struct xrt_swapchain *l_d_xscn;
263
+
struct xrt_swapchain *r_d_xscn;
264
265
assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH);
266
+1
-1
src/xrt/compositor/client/comp_gl_memobj_swapchain.h
+1
-1
src/xrt/compositor/client/comp_gl_memobj_swapchain.h
+6
-2
src/xrt/compositor/client/comp_vk_client.c
+6
-2
src/xrt/compositor/client/comp_vk_client.c
···
451
const struct xrt_layer_data *data)
452
{
453
struct client_vk_compositor *c = client_vk_compositor(xc);
454
-
struct xrt_swapchain *l_xscn, *r_xscn;
455
456
assert(data->type == XRT_LAYER_STEREO_PROJECTION);
457
···
472
const struct xrt_layer_data *data)
473
{
474
struct client_vk_compositor *c = client_vk_compositor(xc);
475
-
struct xrt_swapchain *l_xscn, *r_xscn, *l_d_xscn, *r_d_xscn;
476
477
assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH);
478
···
451
const struct xrt_layer_data *data)
452
{
453
struct client_vk_compositor *c = client_vk_compositor(xc);
454
+
struct xrt_swapchain *l_xscn;
455
+
struct xrt_swapchain *r_xscn;
456
457
assert(data->type == XRT_LAYER_STEREO_PROJECTION);
458
···
473
const struct xrt_layer_data *data)
474
{
475
struct client_vk_compositor *c = client_vk_compositor(xc);
476
+
struct xrt_swapchain *l_xscn;
477
+
struct xrt_swapchain *r_xscn;
478
+
struct xrt_swapchain *l_d_xscn;
479
+
struct xrt_swapchain *r_d_xscn;
480
481
assert(data->type == XRT_LAYER_STEREO_PROJECTION_DEPTH);
482
+4
-5
src/xrt/compositor/main/comp_renderer.c
+4
-5
src/xrt/compositor/main/comp_renderer.c
···
732
renderer_close_renderings_and_fences(r);
733
return;
734
}
735
-
736
-
renderer_ensure_images_and_renderings(r, true); // Force recreate.
737
-
738
-
return;
739
}
740
741
static void
···
1572
}
1573
1574
void
1575
-
comp_renderer_add_debug_vars(struct comp_renderer *r)
1576
{
1577
r->mirror_to_debug_gui.push_every_frame_out_of_X = 2;
1578
1579
u_frame_times_widget_init(&r->mirror_to_debug_gui.push_frame_times, 0.f, 0.f);
···
732
renderer_close_renderings_and_fences(r);
733
return;
734
}
735
+
// Force recreate.
736
+
renderer_ensure_images_and_renderings(r, true);
737
}
738
739
static void
···
1570
}
1571
1572
void
1573
+
comp_renderer_add_debug_vars(struct comp_renderer *self)
1574
{
1575
+
struct comp_renderer *r = self;
1576
r->mirror_to_debug_gui.push_every_frame_out_of_X = 2;
1577
1578
u_frame_times_widget_init(&r->mirror_to_debug_gui.push_frame_times, 0.f, 0.f);
+4
-2
src/xrt/drivers/arduino/arduino_device.c
+4
-2
src/xrt/drivers/arduino/arduino_device.c
···
149
timepoint_ns timestamp_ns,
150
time_duration_ns delta_ns)
151
{
152
-
struct xrt_vec3 accel, gyro;
153
m_imu_pre_filter_data(&ad->pre_filter, &sample->accel, &sample->gyro, &accel, &gyro);
154
155
ad->device_time += (uint64_t)sample->delta * 1000;
···
231
{
232
struct arduino_device *ad = (struct arduino_device *)ptr;
233
uint8_t buffer[20];
234
-
timepoint_ns then_ns, now_ns;
235
struct arduino_parsed_input input; // = {0};
236
237
// wait for a package to sync up, it's discarded but that's okay.
···
149
timepoint_ns timestamp_ns,
150
time_duration_ns delta_ns)
151
{
152
+
struct xrt_vec3 accel;
153
+
struct xrt_vec3 gyro;
154
m_imu_pre_filter_data(&ad->pre_filter, &sample->accel, &sample->gyro, &accel, &gyro);
155
156
ad->device_time += (uint64_t)sample->delta * 1000;
···
232
{
233
struct arduino_device *ad = (struct arduino_device *)ptr;
234
uint8_t buffer[20];
235
+
timepoint_ns then_ns;
236
+
timepoint_ns now_ns;
237
struct arduino_parsed_input input; // = {0};
238
239
// wait for a package to sync up, it's discarded but that's okay.
+2
-1
src/xrt/drivers/daydream/daydream_device.c
+2
-1
src/xrt/drivers/daydream/daydream_device.c
+1
-3
src/xrt/drivers/euroc/euroc_device.c
+1
-3
src/xrt/drivers/euroc/euroc_device.c
+2
-3
src/xrt/drivers/euroc/euroc_player.cpp
+2
-3
src/xrt/drivers/euroc/euroc_player.cpp
···
453
{
454
bool stereo = ep->playback.stereo;
455
456
-
struct xrt_frame *left_xf = NULL, *right_xf = NULL;
457
euroc_player_load_next_frame(ep, true, left_xf);
458
if (stereo) {
459
// TODO: Some SLAM systems expect synced frames, but that's not an
···
787
m_ff_vec3_f32_free(&ep->accel_ff);
788
789
free(ep);
790
-
791
-
return;
792
}
793
794
···
453
{
454
bool stereo = ep->playback.stereo;
455
456
+
struct xrt_frame *left_xf = NULL;
457
+
struct xrt_frame *right_xf = NULL;
458
euroc_player_load_next_frame(ep, true, left_xf);
459
if (stereo) {
460
// TODO: Some SLAM systems expect synced frames, but that's not an
···
788
m_ff_vec3_f32_free(&ep->accel_ff);
789
790
free(ep);
791
}
792
793
+1
-1
src/xrt/drivers/north_star/distortion_3d/deformation_northstar.cpp
+1
-1
src/xrt/drivers/north_star/distortion_3d/deformation_northstar.cpp
+17
-11
src/xrt/drivers/north_star/distortion_3d/deformation_northstar.h
+17
-11
src/xrt/drivers/north_star/distortion_3d/deformation_northstar.h
···
20
LoadOpticalData(struct ns_3d_eye *eye);
21
22
Vector3
23
-
GetEyePosition()
24
{
25
return eyePosition;
26
}
···
35
SolveDisplayUVToRenderUV(const Vector2 &inputUV, Vector2 const &initialGuess, int iterations);
36
37
Vector2
38
-
DisplayUVToRenderUVPreviousSeed(Vector2 inputUV);
39
40
void
41
RegenerateMesh();
42
43
void
44
-
UpdateEyePosition(const Vector3 pos)
45
{
46
eyePosition.x = pos.x;
47
eyePosition.y = pos.y;
48
eyePosition.z = pos.z;
49
}
50
51
-
const Vector4
52
GetCameraProjection()
53
{
54
return cameraProjection;
···
62
}
63
64
void
65
-
UpdateClipToWorld(Matrix4x4 eyeRotationMatrix)
66
{
67
Matrix4x4 eyeToWorld = Matrix4x4::Translate(eyePosition) * eyeRotationMatrix;
68
eyeToWorld.m02 *= -1;
···
73
74
Vector3 eyePosition;
75
76
-
inline void
77
-
ViewportPointToRayDirection(Vector2 UV, Vector3 cameraPosition, Matrix4x4 clipToWorld, Vector3 &out)
78
{
79
Vector3 tmp;
80
tmp.x = UV.x - 0.5f;
···
84
85
float mag = dir.Magnitude();
86
out = dir / mag;
87
-
return;
88
}
89
90
private:
···
107
108
// supporting functions
109
inline Vector3
110
-
Project(Vector3 v1, Vector3 v2)
111
{
112
Vector3 v2Norm = (v2 / v2.Magnitude());
113
return v2Norm * Vector3::Dot(v1, v2Norm);
114
}
115
116
inline float
117
-
intersectLineSphere(Vector3 Origin, Vector3 Direction, Vector3 spherePos, float SphereRadiusSqrd, bool frontSide = true)
118
{
119
Vector3 L = spherePos - Origin;
120
Vector3 offsetFromSphereCenterToRay = Project(L, Direction) - L;
···
125
}
126
127
inline float
128
-
intersectPlane(Vector3 n, Vector3 p0, Vector3 l0, Vector3 l)
129
{
130
131
float denom = Vector3::Dot((Vector3::Zero() - n), l);
···
20
LoadOpticalData(struct ns_3d_eye *eye);
21
22
Vector3
23
+
GetEyePosition() const
24
{
25
return eyePosition;
26
}
···
35
SolveDisplayUVToRenderUV(const Vector2 &inputUV, Vector2 const &initialGuess, int iterations);
36
37
Vector2
38
+
DisplayUVToRenderUVPreviousSeed(const Vector2 &inputUV);
39
40
void
41
RegenerateMesh();
42
43
void
44
+
UpdateEyePosition(const Vector3 &pos)
45
{
46
eyePosition.x = pos.x;
47
eyePosition.y = pos.y;
48
eyePosition.z = pos.z;
49
}
50
51
+
Vector4
52
GetCameraProjection()
53
{
54
return cameraProjection;
···
62
}
63
64
void
65
+
UpdateClipToWorld(const Matrix4x4 &eyeRotationMatrix)
66
{
67
Matrix4x4 eyeToWorld = Matrix4x4::Translate(eyePosition) * eyeRotationMatrix;
68
eyeToWorld.m02 *= -1;
···
73
74
Vector3 eyePosition;
75
76
+
static inline void
77
+
ViewportPointToRayDirection(const Vector2 &UV,
78
+
const Vector3 &cameraPosition,
79
+
const Matrix4x4 &clipToWorld,
80
+
Vector3 &out)
81
{
82
Vector3 tmp;
83
tmp.x = UV.x - 0.5f;
···
87
88
float mag = dir.Magnitude();
89
out = dir / mag;
90
}
91
92
private:
···
109
110
// supporting functions
111
inline Vector3
112
+
Project(const Vector3 &v1, const Vector3 &v2)
113
{
114
Vector3 v2Norm = (v2 / v2.Magnitude());
115
return v2Norm * Vector3::Dot(v1, v2Norm);
116
}
117
118
inline float
119
+
intersectLineSphere(const Vector3 &Origin,
120
+
const Vector3 &Direction,
121
+
const Vector3 &spherePos,
122
+
float SphereRadiusSqrd,
123
+
bool frontSide = true)
124
{
125
Vector3 L = spherePos - Origin;
126
Vector3 offsetFromSphereCenterToRay = Project(L, Direction) - L;
···
131
}
132
133
inline float
134
+
intersectPlane(const Vector3 &n, const Vector3 &p0, const Vector3 &l0, const Vector3 &l)
135
{
136
137
float denom = Vector3::Dot((Vector3::Zero() - n), l);
+24
-18
src/xrt/drivers/north_star/distortion_3d/utility_northstar.h
+24
-18
src/xrt/drivers/north_star/distortion_3d/utility_northstar.h
···
84
};
85
86
inline Vector3
87
-
operator-(Vector3 &rhs) const
88
{
89
Vector3 ret;
90
ret.x = (x - rhs.x);
···
158
}
159
160
inline static float
161
-
Angle(Vector3 v0, Vector3 v1)
162
{
163
Vector3 dir0 = v0.Normalized();
164
Vector3 dir1 = v1.Normalized();
···
196
}
197
198
inline static Vector3
199
-
Reflect(Vector3 inDirection, Vector3 inNormal)
200
{
201
return inNormal * -2.F * Dot(inNormal, inDirection) + inDirection;
202
}
···
235
236
237
inline void
238
-
rotate(Vector3 axis, float radians)
239
{
240
float cos_theta = cosf(radians);
241
float sin_theta = sinf(radians);
···
251
}
252
253
inline Vector3
254
-
Cross(const Vector3 in) const
255
{
256
Vector3 ret;
257
ret.x = y * in.z - z * in.y;
···
489
}
490
491
inline Matrix4x4 // Until clang-format-11 is on the CI.
492
-
operator*(const Matrix4x4 &_in)
493
{
494
Matrix4x4 ret;
495
ret.m00 = (m00 * _in.m00) + (m01 * _in.m10) + (m02 * _in.m20) + (m03 * _in.m30);
···
536
}
537
538
inline static Matrix4x4
539
-
Translate(Vector3 vector)
540
{
541
Matrix4x4 m;
542
m.m00 = 1.f;
···
559
}
560
561
inline Vector3
562
-
MultiplyVector(Vector3 vector) const
563
{
564
Vector3 res;
565
res.x = m00 * vector.x + m01 * vector.y + m02 * vector.z;
···
569
}
570
571
inline Vector3
572
-
MultiplyPoint3x4(Vector3 point) const
573
{
574
Vector3 res;
575
res.x = m00 * point.x + m01 * point.y + m02 * point.z + m03;
···
744
class Ray
745
{
746
public:
747
-
inline Ray(Vector3 origin, Vector3 direction)
748
{
749
m_Origin = origin;
750
direction.Normalize();
···
754
}
755
756
inline Vector3
757
-
GetPoint(float distance)
758
{
759
return m_Origin + m_Direction * distance;
760
}
···
872
Vector3 euler;
873
const static float PI_OVER_2 = M_PI * 0.5f;
874
const static float EPSILON = 1e-10f;
875
-
float sqw, sqx, sqy, sqz;
876
877
// quick conversion to Euler angles to give tilt to user
878
sqw = in.w * in.w;
···
974
}
975
976
inline static Quaternion
977
-
AxisAngle(Vector3 axis, float angle)
978
{
979
float halfAngle = angle * .5f;
980
float s = (float)sin(halfAngle);
···
987
}
988
989
inline static Quaternion
990
-
LookAt(Vector3 sourcePoint, Vector3 destPoint)
991
{
992
Vector3 forwardVector = (destPoint - sourcePoint).Normalized();
993
···
1007
}
1008
1009
inline static Quaternion
1010
-
QuaternionLookRotation(Vector3 forward, Vector3 Up)
1011
{
1012
1013
Vector3 vector1 = forward.Normalized();
···
1066
}
1067
1068
inline static Quaternion
1069
-
FromMatrix(const Matrix4x4 m)
1070
{
1071
float tr = m.m00 + m.m11 + m.m22;
1072
-
float qx, qy, qz, qw;
1073
1074
if (tr > 0) {
1075
float S = sqrtf(tr + 1.f) * 2.f;
···
1166
//}
1167
1168
inline static Quaternion
1169
-
FromToRotation(Vector3 dir0, Vector3 dir1)
1170
{
1171
Vector3 axis = dir0.Cross(dir1).Normalized();
1172
float angle = Vector3::Angle(dir0, dir1);
···
84
};
85
86
inline Vector3
87
+
operator-(const Vector3 &rhs) const
88
{
89
Vector3 ret;
90
ret.x = (x - rhs.x);
···
158
}
159
160
inline static float
161
+
Angle(const Vector3 &v0, const Vector3 &v1)
162
{
163
Vector3 dir0 = v0.Normalized();
164
Vector3 dir1 = v1.Normalized();
···
196
}
197
198
inline static Vector3
199
+
Reflect(const Vector3 &inDirection, const Vector3 &inNormal)
200
{
201
return inNormal * -2.F * Dot(inNormal, inDirection) + inDirection;
202
}
···
235
236
237
inline void
238
+
rotate(const Vector3 &axis, float radians)
239
{
240
float cos_theta = cosf(radians);
241
float sin_theta = sinf(radians);
···
251
}
252
253
inline Vector3
254
+
Cross(const Vector3 &in) const
255
{
256
Vector3 ret;
257
ret.x = y * in.z - z * in.y;
···
489
}
490
491
inline Matrix4x4 // Until clang-format-11 is on the CI.
492
+
operator*(const Matrix4x4 &_in) const
493
{
494
Matrix4x4 ret;
495
ret.m00 = (m00 * _in.m00) + (m01 * _in.m10) + (m02 * _in.m20) + (m03 * _in.m30);
···
536
}
537
538
inline static Matrix4x4
539
+
Translate(const Vector3 &vector)
540
{
541
Matrix4x4 m;
542
m.m00 = 1.f;
···
559
}
560
561
inline Vector3
562
+
MultiplyVector(const Vector3 &vector) const
563
{
564
Vector3 res;
565
res.x = m00 * vector.x + m01 * vector.y + m02 * vector.z;
···
569
}
570
571
inline Vector3
572
+
MultiplyPoint3x4(const Vector3 &point) const
573
{
574
Vector3 res;
575
res.x = m00 * point.x + m01 * point.y + m02 * point.z + m03;
···
744
class Ray
745
{
746
public:
747
+
inline Ray(const Vector3 &origin, Vector3 direction)
748
{
749
m_Origin = origin;
750
direction.Normalize();
···
754
}
755
756
inline Vector3
757
+
GetPoint(float distance) const
758
{
759
return m_Origin + m_Direction * distance;
760
}
···
872
Vector3 euler;
873
const static float PI_OVER_2 = M_PI * 0.5f;
874
const static float EPSILON = 1e-10f;
875
+
float sqw;
876
+
float sqx;
877
+
float sqy;
878
+
float sqz;
879
880
// quick conversion to Euler angles to give tilt to user
881
sqw = in.w * in.w;
···
977
}
978
979
inline static Quaternion
980
+
AxisAngle(const Vector3 &axis, float angle)
981
{
982
float halfAngle = angle * .5f;
983
float s = (float)sin(halfAngle);
···
990
}
991
992
inline static Quaternion
993
+
LookAt(const Vector3 &sourcePoint, const Vector3 &destPoint)
994
{
995
Vector3 forwardVector = (destPoint - sourcePoint).Normalized();
996
···
1010
}
1011
1012
inline static Quaternion
1013
+
QuaternionLookRotation(const Vector3 &forward, const Vector3 &Up)
1014
{
1015
1016
Vector3 vector1 = forward.Normalized();
···
1069
}
1070
1071
inline static Quaternion
1072
+
FromMatrix(const Matrix4x4 &m)
1073
{
1074
float tr = m.m00 + m.m11 + m.m22;
1075
+
float qx;
1076
+
float qy;
1077
+
float qz;
1078
+
float qw;
1079
1080
if (tr > 0) {
1081
float S = sqrtf(tr + 1.f) * 2.f;
···
1172
//}
1173
1174
inline static Quaternion
1175
+
FromToRotation(const Vector3 &dir0, const Vector3 &dir1)
1176
{
1177
Vector3 axis = dir0.Cross(dir1).Normalized();
1178
float angle = Vector3::Angle(dir0, dir1);
+2
-2
src/xrt/drivers/north_star/ns_hmd.c
+2
-2
src/xrt/drivers/north_star/ns_hmd.c
···
107
assert(fabsf(out_fov.angle_right) < M_PI_2);
108
memcpy(left_fov, &out_fov, sizeof(struct xrt_fov));
109
memcpy(right_fov, &out_fov, sizeof(struct xrt_fov));
110
-
return;
111
}
112
113
bool
···
641
// avoid unintended consequences. As soon as you have a specific reason to support it, go ahead and support it.
642
ns->base.hmd->blend_mode_count = idx;
643
644
-
uint64_t start, end;
645
646
start = os_monotonic_get_ns();
647
u_distortion_mesh_fill_in_compute(&ns->base);
···
107
assert(fabsf(out_fov.angle_right) < M_PI_2);
108
memcpy(left_fov, &out_fov, sizeof(struct xrt_fov));
109
memcpy(right_fov, &out_fov, sizeof(struct xrt_fov));
110
}
111
112
bool
···
640
// avoid unintended consequences. As soon as you have a specific reason to support it, go ahead and support it.
641
ns->base.hmd->blend_mode_count = idx;
642
643
+
uint64_t start;
644
+
uint64_t end;
645
646
start = os_monotonic_get_ns();
647
u_distortion_mesh_fill_in_compute(&ns->base);
+4
-2
src/xrt/drivers/psmv/psmv_driver.c
+4
-2
src/xrt/drivers/psmv/psmv_driver.c
···
1295
struct psmv_calibration_zcm1 data;
1296
uint8_t *dst = (uint8_t *)&data;
1297
int ret = 0;
1298
-
size_t src_offset, dst_offset;
1299
1300
for (int i = 0; i < 3; i++) {
1301
struct psmv_calibration_part part = {0};
···
1511
struct psmv_calibration_zcm2 data;
1512
uint8_t *dst = (uint8_t *)&data;
1513
int ret = 0;
1514
-
size_t src_offset, dst_offset;
1515
1516
for (int i = 0; i < 2; i++) {
1517
struct psmv_calibration_part part = {0};
···
1295
struct psmv_calibration_zcm1 data;
1296
uint8_t *dst = (uint8_t *)&data;
1297
int ret = 0;
1298
+
size_t src_offset;
1299
+
size_t dst_offset;
1300
1301
for (int i = 0; i < 3; i++) {
1302
struct psmv_calibration_part part = {0};
···
1512
struct psmv_calibration_zcm2 data;
1513
uint8_t *dst = (uint8_t *)&data;
1514
int ret = 0;
1515
+
size_t src_offset;
1516
+
size_t dst_offset;
1517
1518
for (int i = 0; i < 2; i++) {
1519
struct psmv_calibration_part part = {0};
+4
-2
src/xrt/drivers/qwerty/qwerty_device.c
+4
-2
src/xrt/drivers/qwerty/qwerty_device.c
···
177
qd->yaw_delta = 0;
178
qd->pitch_delta = 0;
179
180
-
struct xrt_quat x_rotation, y_rotation;
181
const struct xrt_vec3 x_axis = XRT_VEC3_UNIT_X;
182
const struct xrt_vec3 y_axis = XRT_VEC3_UNIT_Y;
183
math_quat_from_angle_vector(x_look_speed, &x_axis, &x_rotation);
···
231
qwerty_hmd_create(void)
232
{
233
enum u_device_alloc_flags flags = U_DEVICE_ALLOC_HMD | U_DEVICE_ALLOC_TRACKING_NONE;
234
-
size_t input_count = 1, output_count = 0;
235
struct qwerty_hmd *qh = U_DEVICE_ALLOCATE(struct qwerty_hmd, flags, input_count, output_count);
236
assert(qh);
237
···
177
qd->yaw_delta = 0;
178
qd->pitch_delta = 0;
179
180
+
struct xrt_quat x_rotation;
181
+
struct xrt_quat y_rotation;
182
const struct xrt_vec3 x_axis = XRT_VEC3_UNIT_X;
183
const struct xrt_vec3 y_axis = XRT_VEC3_UNIT_Y;
184
math_quat_from_angle_vector(x_look_speed, &x_axis, &x_rotation);
···
232
qwerty_hmd_create(void)
233
{
234
enum u_device_alloc_flags flags = U_DEVICE_ALLOC_HMD | U_DEVICE_ALLOC_TRACKING_NONE;
235
+
size_t input_count = 1;
236
+
size_t output_count = 0;
237
struct qwerty_hmd *qh = U_DEVICE_ALLOCATE(struct qwerty_hmd, flags, input_count, output_count);
238
assert(qh);
239
+6
-2
src/xrt/drivers/qwerty/qwerty_sdl.c
+6
-2
src/xrt/drivers/qwerty/qwerty_sdl.c
···
46
static struct qwerty_device *
47
default_qwerty_device(struct xrt_device **xdevs, size_t xdev_count, struct qwerty_system *qsys)
48
{
49
-
int head, left, right;
50
head = left = right = XRT_DEVICE_ROLE_UNASSIGNED;
51
u_device_assign_xdev_roles(xdevs, xdev_count, &head, &left, &right);
52
···
72
static struct qwerty_controller *
73
default_qwerty_controller(struct xrt_device **xdevs, size_t xdev_count, struct qwerty_system *qsys)
74
{
75
-
int head, left, right;
76
head = left = right = XRT_DEVICE_ROLE_UNASSIGNED;
77
u_device_assign_xdev_roles(xdevs, xdev_count, &head, &left, &right);
78
···
46
static struct qwerty_device *
47
default_qwerty_device(struct xrt_device **xdevs, size_t xdev_count, struct qwerty_system *qsys)
48
{
49
+
int head;
50
+
int left;
51
+
int right;
52
head = left = right = XRT_DEVICE_ROLE_UNASSIGNED;
53
u_device_assign_xdev_roles(xdevs, xdev_count, &head, &left, &right);
54
···
74
static struct qwerty_controller *
75
default_qwerty_controller(struct xrt_device **xdevs, size_t xdev_count, struct qwerty_system *qsys)
76
{
77
+
int head;
78
+
int left;
79
+
int right;
80
head = left = right = XRT_DEVICE_ROLE_UNASSIGNED;
81
u_device_assign_xdev_roles(xdevs, xdev_count, &head, &left, &right);
82
+7
-4
src/xrt/drivers/remote/r_hub.c
+7
-4
src/xrt/drivers/remote/r_hub.c
···
29
#define __USE_MISC // SOL_TCP on C11
30
#endif
31
#ifndef _BSD_SOURCE
32
-
#define _BSD_SOURCE // same, but for musl
33
#endif
34
35
#include <netinet/tcp.h>
···
85
do_accept(struct r_hub *r)
86
{
87
struct sockaddr_in addr = {0};
88
-
int ret, conn_fd;
89
90
socklen_t addr_length = (socklen_t)sizeof(addr);
91
ret = accept(r->accept_fd, (struct sockaddr *)&addr, &addr_length);
···
286
ssize_t ret = read(rc->fd, ptr, size - current);
287
if (ret < 0) {
288
return ret;
289
-
} else if (ret > 0) {
290
current += (size_t)ret;
291
} else {
292
U_LOG_I("Disconnected!");
···
309
ssize_t ret = write(rc->fd, ptr, size - current);
310
if (ret < 0) {
311
return ret;
312
-
} else if (ret > 0) {
313
current += (size_t)ret;
314
} else {
315
U_LOG_I("Disconnected!");
···
29
#define __USE_MISC // SOL_TCP on C11
30
#endif
31
#ifndef _BSD_SOURCE
32
+
#define _BSD_SOURCE // same, but for musl // NOLINT
33
#endif
34
35
#include <netinet/tcp.h>
···
85
do_accept(struct r_hub *r)
86
{
87
struct sockaddr_in addr = {0};
88
+
int ret;
89
+
int conn_fd;
90
91
socklen_t addr_length = (socklen_t)sizeof(addr);
92
ret = accept(r->accept_fd, (struct sockaddr *)&addr, &addr_length);
···
287
ssize_t ret = read(rc->fd, ptr, size - current);
288
if (ret < 0) {
289
return ret;
290
+
}
291
+
if (ret > 0) {
292
current += (size_t)ret;
293
} else {
294
U_LOG_I("Disconnected!");
···
311
ssize_t ret = write(rc->fd, ptr, size - current);
312
if (ret < 0) {
313
return ret;
314
+
}
315
+
if (ret > 0) {
316
current += (size_t)ret;
317
} else {
318
U_LOG_I("Disconnected!");
+2
-1
src/xrt/drivers/vive/vive_device.c
+2
-1
src/xrt/drivers/vive/vive_device.c
+10
-5
src/xrt/drivers/wmr/wmr_bt_controller.c
+10
-5
src/xrt/drivers/wmr/wmr_bt_controller.c
···
72
if (size < 0) {
73
WMR_ERROR(d, "WMR Controller (Bluetooth): Error reading from device");
74
return false;
75
-
} else if (size == 0) {
76
WMR_TRACE(d, "WMR Controller (Bluetooth): No data to read from device");
77
return true; // No more messages, return.
78
}
···
163
{
164
struct wmr_controller_fw_cmd_response fw_cmd_response;
165
166
-
uint8_t *data, *data_pos, *data_end;
167
-
uint32_t data_size, remain;
168
169
struct wmr_controller_fw_cmd fw_cmd;
170
memset(&fw_cmd, 0, sizeof(fw_cmd));
···
224
static bool
225
read_controller_config(struct wmr_bt_controller *d)
226
{
227
-
unsigned char *data = NULL, *config_json_block;
228
size_t data_size;
229
int ret;
230
···
234
// USB PID/VID are visible in them, but it's not clear
235
// what the layout is and we don't use them currently,
236
// so this if 0 code is just exemplary.
237
-
238
// Read serials
239
ret = wmr_read_fw_block(d, 0x03, &data, &data_size);
240
if (ret < 0 || data == NULL)
···
72
if (size < 0) {
73
WMR_ERROR(d, "WMR Controller (Bluetooth): Error reading from device");
74
return false;
75
+
}
76
+
if (size == 0) {
77
WMR_TRACE(d, "WMR Controller (Bluetooth): No data to read from device");
78
return true; // No more messages, return.
79
}
···
164
{
165
struct wmr_controller_fw_cmd_response fw_cmd_response;
166
167
+
uint8_t *data;
168
+
uint8_t *data_pos;
169
+
uint8_t *data_end;
170
+
uint32_t data_size;
171
+
uint32_t remain;
172
173
struct wmr_controller_fw_cmd fw_cmd;
174
memset(&fw_cmd, 0, sizeof(fw_cmd));
···
228
static bool
229
read_controller_config(struct wmr_bt_controller *d)
230
{
231
+
unsigned char *data = NULL;
232
+
unsigned char *config_json_block;
233
size_t data_size;
234
int ret;
235
···
239
// USB PID/VID are visible in them, but it's not clear
240
// what the layout is and we don't use them currently,
241
// so this if 0 code is just exemplary.
242
+
243
// Read serials
244
ret = wmr_read_fw_block(d, 0x03, &data, &data_size);
245
if (ret < 0 || data == NULL)
+11
-5
src/xrt/drivers/wmr/wmr_camera.c
+11
-5
src/xrt/drivers/wmr/wmr_camera.c
···
140
static bool
141
compute_frame_size(struct wmr_camera *cam)
142
{
143
-
int i, cams_found = 0;
144
-
int width, height;
145
-
size_t F, n_packets, leftover;
146
147
F = 26;
148
···
402
DRV_TRACE_MARKER();
403
404
struct wmr_camera *cam = calloc(1, sizeof(struct wmr_camera));
405
-
int res, i;
406
407
cam->log_level = log_level;
408
cam->debug_gain = DEFAULT_GAIN;
···
572
{
573
DRV_TRACE_MARKER();
574
575
-
int res, i;
576
577
if (!cam->running) {
578
return true;
···
140
static bool
141
compute_frame_size(struct wmr_camera *cam)
142
{
143
+
int i;
144
+
int cams_found = 0;
145
+
int width;
146
+
int height;
147
+
size_t F;
148
+
size_t n_packets;
149
+
size_t leftover;
150
151
F = 26;
152
···
406
DRV_TRACE_MARKER();
407
408
struct wmr_camera *cam = calloc(1, sizeof(struct wmr_camera));
409
+
int res;
410
+
int i;
411
412
cam->log_level = log_level;
413
cam->debug_gain = DEFAULT_GAIN;
···
577
{
578
DRV_TRACE_MARKER();
579
580
+
int res;
581
+
int i;
582
583
if (!cam->running) {
584
return true;
+2
-2
src/xrt/drivers/wmr/wmr_controller_protocol.c
+2
-2
src/xrt/drivers/wmr/wmr_controller_protocol.c
···
20
*/
21
22
static inline void
23
-
vec3_from_wmr_controller_accel(int32_t sample[3], struct xrt_vec3 *out_vec)
24
{
25
// Reverb G1 observation: 1g is approximately 490,000.
26
···
31
32
33
static inline void
34
-
vec3_from_wmr_controller_gyro(int32_t sample[3], struct xrt_vec3 *out_vec)
35
{
36
out_vec->x = (float)sample[0] * 0.00001f;
37
out_vec->y = (float)sample[1] * 0.00001f;
···
20
*/
21
22
static inline void
23
+
vec3_from_wmr_controller_accel(const int32_t sample[3], struct xrt_vec3 *out_vec)
24
{
25
// Reverb G1 observation: 1g is approximately 490,000.
26
···
31
32
33
static inline void
34
+
vec3_from_wmr_controller_gyro(const int32_t sample[3], struct xrt_vec3 *out_vec)
35
{
36
out_vec->x = (float)sample[0] * 0.00001f;
37
out_vec->y = (float)sample[1] * 0.00001f;
+14
-8
src/xrt/drivers/wmr/wmr_hmd.c
+14
-8
src/xrt/drivers/wmr/wmr_hmd.c
···
124
for (int i = 0; i < 4; i++) {
125
pkt->video_timestamp[i] = read64(&buffer);
126
}
127
-
128
-
return;
129
}
130
131
···
349
if (size < 0) {
350
WMR_ERROR(wh, "Error reading from Hololens Sensors device. Call to os_hid_read returned %i", size);
351
return false;
352
-
} else if (size == 0) {
353
WMR_TRACE(wh, "No more data to read");
354
return true; // No more messages, return.
355
} else {
···
432
WMR_ERROR(wh, "Error reading from companion (HMD control) device. Call to os_hid_read returned %i",
433
size);
434
return false;
435
-
} else if (size == 0) {
436
WMR_TRACE(wh, "No more data to read");
437
return true; // No more messages, return.
438
} else {
···
797
798
unsigned char meta[84];
799
uint8_t *data;
800
-
int size, data_size;
801
802
size = wmr_read_config_part(wh, 0x06, meta, sizeof(meta));
803
WMR_DEBUG(wh, "(0x06, meta) => %d", size);
···
837
{
838
DRV_TRACE_MARKER();
839
840
-
unsigned char *data = NULL, *config_json_block;
841
size_t data_size;
842
int ret;
843
···
1117
1118
assert(view == 0 || view == 1);
1119
1120
-
float tanangle_left = 0.0f, tanangle_right = 0.0f, tanangle_up = 0.0f, tanangle_down = 0.0f;
1121
1122
const struct wmr_distortion_eye_config *ec = wh->config.eye_params + view;
1123
struct wmr_hmd_distortion_params *distortion_params = wh->distortion_params + view;
···
1241
1242
enum u_device_alloc_flags flags =
1243
(enum u_device_alloc_flags)(U_DEVICE_ALLOC_HMD | U_DEVICE_ALLOC_TRACKING_NONE);
1244
-
int ret = 0, i;
1245
int eye;
1246
1247
struct wmr_hmd *wh = U_DEVICE_ALLOCATE(struct wmr_hmd, flags, 1, 0);
···
124
for (int i = 0; i < 4; i++) {
125
pkt->video_timestamp[i] = read64(&buffer);
126
}
127
}
128
129
···
347
if (size < 0) {
348
WMR_ERROR(wh, "Error reading from Hololens Sensors device. Call to os_hid_read returned %i", size);
349
return false;
350
+
}
351
+
if (size == 0) {
352
WMR_TRACE(wh, "No more data to read");
353
return true; // No more messages, return.
354
} else {
···
431
WMR_ERROR(wh, "Error reading from companion (HMD control) device. Call to os_hid_read returned %i",
432
size);
433
return false;
434
+
}
435
+
if (size == 0) {
436
WMR_TRACE(wh, "No more data to read");
437
return true; // No more messages, return.
438
} else {
···
797
798
unsigned char meta[84];
799
uint8_t *data;
800
+
int size;
801
+
int data_size;
802
803
size = wmr_read_config_part(wh, 0x06, meta, sizeof(meta));
804
WMR_DEBUG(wh, "(0x06, meta) => %d", size);
···
838
{
839
DRV_TRACE_MARKER();
840
841
+
unsigned char *data = NULL;
842
+
unsigned char *config_json_block;
843
size_t data_size;
844
int ret;
845
···
1119
1120
assert(view == 0 || view == 1);
1121
1122
+
float tanangle_left = 0.0f;
1123
+
float tanangle_right = 0.0f;
1124
+
float tanangle_up = 0.0f;
1125
+
float tanangle_down = 0.0f;
1126
1127
const struct wmr_distortion_eye_config *ec = wh->config.eye_params + view;
1128
struct wmr_hmd_distortion_params *distortion_params = wh->distortion_params + view;
···
1246
1247
enum u_device_alloc_flags flags =
1248
(enum u_device_alloc_flags)(U_DEVICE_ALLOC_HMD | U_DEVICE_ALLOC_TRACKING_NONE);
1249
+
int ret = 0;
1250
+
int i;
1251
int eye;
1252
1253
struct wmr_hmd *wh = U_DEVICE_ALLOCATE(struct wmr_hmd, flags, 1, 0);
+4
-1
src/xrt/drivers/wmr/wmr_source.c
+4
-1
src/xrt/drivers/wmr/wmr_source.c
+4
-1
src/xrt/drivers/wmr/wmr_source.h
+4
-1
src/xrt/drivers/wmr/wmr_source.h
···
32
//! @todo IMU data should be generated from within the data source, but right
33
//! now we need this function because it is being generated from wmr_hmd
34
void
35
-
wmr_source_push_imu_packet(struct xrt_fs *xfs, uint64_t ts[4], struct xrt_vec3 accels[4], struct xrt_vec3 gyros[4]);
36
37
/*!
38
* @}
···
32
//! @todo IMU data should be generated from within the data source, but right
33
//! now we need this function because it is being generated from wmr_hmd
34
void
35
+
wmr_source_push_imu_packet(struct xrt_fs *xfs,
36
+
const uint64_t ts[4],
37
+
struct xrt_vec3 accels[4],
38
+
struct xrt_vec3 gyros[4]);
39
40
/*!
41
* @}
+2
-2
src/xrt/include/xrt/xrt_gfx_egl.h
+2
-2
src/xrt/include/xrt/xrt_gfx_egl.h
···
19
typedef void *EGLDisplay;
20
typedef void *EGLConfig;
21
typedef void *EGLContext;
22
-
typedef void (*__eglMustCastToProperFunctionPointerType)(void);
23
typedef __eglMustCastToProperFunctionPointerType (*PFNEGLGETPROCADDRESSPROC)(const char *proc);
24
struct time_state;
25
···
34
EGLDisplay display,
35
EGLConfig config,
36
EGLContext context,
37
-
PFNEGLGETPROCADDRESSPROC getProcAddress,
38
struct xrt_compositor_gl **out_xcgl);
39
40
#ifdef __cplusplus
···
19
typedef void *EGLDisplay;
20
typedef void *EGLConfig;
21
typedef void *EGLContext;
22
+
typedef void (*__eglMustCastToProperFunctionPointerType)(void); // NOLINT
23
typedef __eglMustCastToProperFunctionPointerType (*PFNEGLGETPROCADDRESSPROC)(const char *proc);
24
struct time_state;
25
···
34
EGLDisplay display,
35
EGLConfig config,
36
EGLContext context,
37
+
PFNEGLGETPROCADDRESSPROC get_gl_procaddr,
38
struct xrt_compositor_gl **out_xcgl);
39
40
#ifdef __cplusplus
+1
-1
src/xrt/include/xrt/xrt_gfx_xlib.h
+1
-1
src/xrt/include/xrt/xrt_gfx_xlib.h
+1
-1
src/xrt/include/xrt/xrt_openxr_includes.h
+1
-1
src/xrt/include/xrt/xrt_openxr_includes.h
+2
-2
src/xrt/ipc/server/ipc_server.h
+2
-2
src/xrt/ipc/server/ipc_server.h
···
347
* @ingroup ipc_server
348
*/
349
void
350
-
ipc_server_set_active_client(struct ipc_server *s, int active_client_index);
351
352
/*!
353
* Called by client threads to set a session to active.
···
379
* @ingroup ipc_server
380
*/
381
void *
382
-
ipc_server_client_thread(void *_cs);
383
384
/*!
385
* This destroys the native compositor for this client and any extra objects
···
347
* @ingroup ipc_server
348
*/
349
void
350
+
ipc_server_set_active_client(struct ipc_server *s, int client_id);
351
352
/*!
353
* Called by client threads to set a session to active.
···
379
* @ingroup ipc_server
380
*/
381
void *
382
+
ipc_server_client_thread(void *_ics);
383
384
/*!
385
* This destroys the native compositor for this client and any extra objects
+4
-2
src/xrt/ipc/server/ipc_server_mainloop_linux.c
+4
-2
src/xrt/ipc/server/ipc_server_mainloop_linux.c
···
76
{
77
// no fd provided
78
struct sockaddr_un addr;
79
-
int fd, ret;
80
81
fd = socket(PF_UNIX, SOCK_STREAM, 0);
82
if (fd < 0) {
···
143
static int
144
init_listen_socket(struct ipc_server_mainloop *ml)
145
{
146
-
int fd = -1, ret;
147
ml->listen_socket = -1;
148
149
ret = get_systemd_socket(ml, &fd);
···
76
{
77
// no fd provided
78
struct sockaddr_un addr;
79
+
int fd;
80
+
int ret;
81
82
fd = socket(PF_UNIX, SOCK_STREAM, 0);
83
if (fd < 0) {
···
144
static int
145
init_listen_socket(struct ipc_server_mainloop *ml)
146
{
147
+
int fd = -1;
148
+
int ret;
149
ml->listen_socket = -1;
150
151
ret = get_systemd_socket(ml, &fd);
+1
-1
src/xrt/state_trackers/gui/gui_common.h
+1
-1
src/xrt/state_trackers/gui/gui_common.h
+3
-1
src/xrt/state_trackers/gui/gui_ogl.c
+3
-1
src/xrt/state_trackers/gui/gui_ogl.c
+2
-1
src/xrt/state_trackers/gui/gui_scene_tracking_overrides.c
+2
-1
src/xrt/state_trackers/gui/gui_scene_tracking_overrides.c
···
214
struct xrt_tracking_override *o = &ts->overrides[ts->gui_edit_override_index];
215
216
igBegin("Tracker Device Offset", NULL, 0);
217
-
int target = -1, tracker = -1;
218
if (get_indices(p, ts, o, &target, &tracker)) {
219
igText("Editing %s [%s] <- %s [%s]", p->xdevs[target]->str, o->target_device_serial,
220
p->xdevs[tracker]->str, o->tracker_device_serial);
···
214
struct xrt_tracking_override *o = &ts->overrides[ts->gui_edit_override_index];
215
216
igBegin("Tracker Device Offset", NULL, 0);
217
+
int target = -1;
218
+
int tracker = -1;
219
if (get_indices(p, ts, o, &target, &tracker)) {
220
igText("Editing %s [%s] <- %s [%s]", p->xdevs[target]->str, o->target_device_serial,
221
p->xdevs[tracker]->str, o->tracker_device_serial);
+4
-2
src/xrt/state_trackers/oxr/oxr_api_session.c
+4
-2
src/xrt/state_trackers/oxr/oxr_api_session.c
···
33
34
XrResult ret;
35
struct oxr_instance *inst;
36
-
struct oxr_session *sess, **link;
37
struct oxr_logger log;
38
OXR_VERIFY_INSTANCE_AND_INIT_LOG(&log, instance, inst, "xrCreateSession");
39
···
64
{
65
OXR_TRACE_MARKER();
66
67
-
struct oxr_session *sess, **link;
68
struct oxr_instance *inst;
69
struct oxr_logger log;
70
OXR_VERIFY_SESSION_AND_INIT_LOG(&log, session, sess, "xrDestroySession");
···
33
34
XrResult ret;
35
struct oxr_instance *inst;
36
+
struct oxr_session *sess;
37
+
struct oxr_session **link;
38
struct oxr_logger log;
39
OXR_VERIFY_INSTANCE_AND_INIT_LOG(&log, instance, inst, "xrCreateSession");
40
···
65
{
66
OXR_TRACE_MARKER();
67
68
+
struct oxr_session *sess;
69
+
struct oxr_session **link;
70
struct oxr_instance *inst;
71
struct oxr_logger log;
72
OXR_VERIFY_SESSION_AND_INIT_LOG(&log, session, sess, "xrDestroySession");
+27
-22
src/xrt/state_trackers/oxr/oxr_api_verify.h
+27
-22
src/xrt/state_trackers/oxr/oxr_api_verify.h
···
14
#endif
15
16
17
-
#define _OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_thing, THING, name, lookup) \
18
do { \
19
oxr_log_init(log, name); \
20
if (thing == XR_NULL_HANDLE) { \
···
31
oxr_log_set_instance(log, lookup); \
32
} while (0)
33
34
-
#define _OXR_VERIFY_SET(log, arg, new_arg, oxr_thing, THING) \
35
do { \
36
if (arg == XR_NULL_HANDLE) { \
37
return oxr_error(log, XR_ERROR_HANDLE_INVALID, "(" #arg " == NULL)"); \
···
50
51
// clang-format off
52
#define OXR_VERIFY_INSTANCE_AND_INIT_LOG(log, thing, new_thing, name) \
53
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_instance, INSTANCE, name, new_thing)
54
#define OXR_VERIFY_MESSENGER_AND_INIT_LOG(log, thing, new_thing, name) \
55
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_messenger, MESSENGER, name, new_thing->inst)
56
#define OXR_VERIFY_SESSION_AND_INIT_LOG(log, thing, new_thing, name) \
57
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_session, SESSION, name, new_thing->sys->inst)
58
#define OXR_VERIFY_SPACE_AND_INIT_LOG(log, thing, new_thing, name) \
59
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_space, SPACE, name, new_thing->sess->sys->inst)
60
#define OXR_VERIFY_ACTION_AND_INIT_LOG(log, thing, new_thing, name) \
61
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_action, ACTION, name, new_thing->act_set->inst)
62
#define OXR_VERIFY_SWAPCHAIN_AND_INIT_LOG(log, thing, new_thing, name) \
63
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_swapchain, SWAPCHAIN, name, new_thing->sess->sys->inst)
64
#define OXR_VERIFY_ACTIONSET_AND_INIT_LOG(log, thing, new_thing, name) \
65
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_action_set, ACTIONSET, name, new_thing->inst)
66
#define OXR_VERIFY_HAND_TRACKER_AND_INIT_LOG(log, thing, new_thing, name) \
67
-
_OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_hand_tracker, HTRACKER, name, new_thing->sess->sys->inst)
68
// clang-format on
69
70
-
#define OXR_VERIFY_INSTANCE_NOT_NULL(log, arg, new_arg) _OXR_VERIFY_SET(log, arg, new_arg, oxr_instance, INSTANCE);
71
-
#define OXR_VERIFY_MESSENGER_NOT_NULL(log, arg, new_arg) _OXR_VERIFY_SET(log, arg, new_arg, oxr_messenger, MESSENGER);
72
-
#define OXR_VERIFY_SESSION_NOT_NULL(log, arg, new_arg) _OXR_VERIFY_SET(log, arg, new_arg, oxr_session, SESSION);
73
-
#define OXR_VERIFY_SPACE_NOT_NULL(log, arg, new_arg) _OXR_VERIFY_SET(log, arg, new_arg, oxr_space, SPACE);
74
-
#define OXR_VERIFY_ACTION_NOT_NULL(log, arg, new_arg) _OXR_VERIFY_SET(log, arg, new_arg, oxr_action, ACTION);
75
-
#define OXR_VERIFY_SWAPCHAIN_NOT_NULL(log, arg, new_arg) _OXR_VERIFY_SET(log, arg, new_arg, oxr_swapchain, SWAPCHAIN);
76
-
#define OXR_VERIFY_ACTIONSET_NOT_NULL(log, arg, new_arg) _OXR_VERIFY_SET(log, arg, new_arg, oxr_action_set, ACTIONSET);
77
78
/*!
79
* Checks if a required extension is enabled.
···
203
* Verify a single path level that sits inside of a fixed sized array.
204
*/
205
XrResult
206
-
oxr_verify_fixed_size_single_level_path(struct oxr_logger *, const char *path, uint32_t array_size, const char *name);
207
208
/*!
209
* Verify an arbitrary UTF-8 string that sits inside of a fixed sized array.
210
*/
211
XrResult
212
-
oxr_verify_localized_name(struct oxr_logger *, const char *string, uint32_t array_size, const char *name);
213
214
/*!
215
* Verify a set of subaction paths for action creation.
···
248
const char *view_conf_name);
249
250
XrResult
251
-
oxr_verify_XrSessionCreateInfo(struct oxr_logger *, const struct oxr_instance *, const XrSessionCreateInfo *);
252
253
#if defined(XR_USE_PLATFORM_XLIB) && defined(XR_USE_GRAPHICS_API_OPENGL)
254
XrResult
255
-
oxr_verify_XrGraphicsBindingOpenGLXlibKHR(struct oxr_logger *, const XrGraphicsBindingOpenGLXlibKHR *);
256
#endif // defined(XR_USE_PLATFORM_XLIB) && defined(XR_USE_GRAPHICS_API_OPENGL)
257
258
#if defined(XR_USE_GRAPHICS_API_VULKAN)
259
XrResult
260
-
oxr_verify_XrGraphicsBindingVulkanKHR(struct oxr_logger *, const XrGraphicsBindingVulkanKHR *);
261
#endif // defined(XR_USE_GRAPHICS_API_VULKAN)
262
263
#if defined(XR_USE_PLATFORM_EGL) && defined(XR_USE_GRAPHICS_API_OPENGL)
···
14
#endif
15
16
17
+
#define OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_thing, THING, name, lookup) \
18
do { \
19
oxr_log_init(log, name); \
20
if (thing == XR_NULL_HANDLE) { \
···
31
oxr_log_set_instance(log, lookup); \
32
} while (0)
33
34
+
#define OXR_VERIFY_SET(log, arg, new_arg, oxr_thing, THING) \
35
do { \
36
if (arg == XR_NULL_HANDLE) { \
37
return oxr_error(log, XR_ERROR_HANDLE_INVALID, "(" #arg " == NULL)"); \
···
50
51
// clang-format off
52
#define OXR_VERIFY_INSTANCE_AND_INIT_LOG(log, thing, new_thing, name) \
53
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_instance, INSTANCE, name, new_thing)
54
#define OXR_VERIFY_MESSENGER_AND_INIT_LOG(log, thing, new_thing, name) \
55
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_messenger, MESSENGER, name, new_thing->inst)
56
#define OXR_VERIFY_SESSION_AND_INIT_LOG(log, thing, new_thing, name) \
57
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_session, SESSION, name, new_thing->sys->inst)
58
#define OXR_VERIFY_SPACE_AND_INIT_LOG(log, thing, new_thing, name) \
59
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_space, SPACE, name, new_thing->sess->sys->inst)
60
#define OXR_VERIFY_ACTION_AND_INIT_LOG(log, thing, new_thing, name) \
61
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_action, ACTION, name, new_thing->act_set->inst)
62
#define OXR_VERIFY_SWAPCHAIN_AND_INIT_LOG(log, thing, new_thing, name) \
63
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_swapchain, SWAPCHAIN, name, new_thing->sess->sys->inst)
64
#define OXR_VERIFY_ACTIONSET_AND_INIT_LOG(log, thing, new_thing, name) \
65
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_action_set, ACTIONSET, name, new_thing->inst)
66
#define OXR_VERIFY_HAND_TRACKER_AND_INIT_LOG(log, thing, new_thing, name) \
67
+
OXR_VERIFY_AND_SET_AND_INIT(log, thing, new_thing, oxr_hand_tracker, HTRACKER, name, new_thing->sess->sys->inst)
68
// clang-format on
69
70
+
#define OXR_VERIFY_INSTANCE_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_instance, INSTANCE);
71
+
#define OXR_VERIFY_MESSENGER_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_messenger, MESSENGER);
72
+
#define OXR_VERIFY_SESSION_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_session, SESSION);
73
+
#define OXR_VERIFY_SPACE_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_space, SPACE);
74
+
#define OXR_VERIFY_ACTION_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_action, ACTION);
75
+
#define OXR_VERIFY_SWAPCHAIN_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_swapchain, SWAPCHAIN);
76
+
#define OXR_VERIFY_ACTIONSET_NOT_NULL(log, arg, new_arg) OXR_VERIFY_SET(log, arg, new_arg, oxr_action_set, ACTIONSET);
77
78
/*!
79
* Checks if a required extension is enabled.
···
203
* Verify a single path level that sits inside of a fixed sized array.
204
*/
205
XrResult
206
+
oxr_verify_fixed_size_single_level_path(struct oxr_logger * /*log*/,
207
+
const char *path,
208
+
uint32_t array_size,
209
+
const char *name);
210
211
/*!
212
* Verify an arbitrary UTF-8 string that sits inside of a fixed sized array.
213
*/
214
XrResult
215
+
oxr_verify_localized_name(struct oxr_logger * /*log*/, const char *string, uint32_t array_size, const char *name);
216
217
/*!
218
* Verify a set of subaction paths for action creation.
···
251
const char *view_conf_name);
252
253
XrResult
254
+
oxr_verify_XrSessionCreateInfo(struct oxr_logger * /*log*/,
255
+
const struct oxr_instance * /*inst*/,
256
+
const XrSessionCreateInfo * /*createInfo*/);
257
258
#if defined(XR_USE_PLATFORM_XLIB) && defined(XR_USE_GRAPHICS_API_OPENGL)
259
XrResult
260
+
oxr_verify_XrGraphicsBindingOpenGLXlibKHR(struct oxr_logger * /*log*/, const XrGraphicsBindingOpenGLXlibKHR * /*next*/);
261
#endif // defined(XR_USE_PLATFORM_XLIB) && defined(XR_USE_GRAPHICS_API_OPENGL)
262
263
#if defined(XR_USE_GRAPHICS_API_VULKAN)
264
XrResult
265
+
oxr_verify_XrGraphicsBindingVulkanKHR(struct oxr_logger * /*log*/, const XrGraphicsBindingVulkanKHR * /*next*/);
266
#endif // defined(XR_USE_GRAPHICS_API_VULKAN)
267
268
#if defined(XR_USE_PLATFORM_EGL) && defined(XR_USE_GRAPHICS_API_OPENGL)
+7
-8
src/xrt/state_trackers/oxr/oxr_input.c
+7
-8
src/xrt/state_trackers/oxr/oxr_input.c
+1
-1
src/xrt/state_trackers/oxr/oxr_input_transform.h
+1
-1
src/xrt/state_trackers/oxr/oxr_input_transform.h
+3
-1
src/xrt/state_trackers/oxr/oxr_instance.c
+3
-1
src/xrt/state_trackers/oxr/oxr_instance.c
+6
-6
src/xrt/state_trackers/oxr/oxr_objects.h
+6
-6
src/xrt/state_trackers/oxr/oxr_objects.h
···
815
}
816
817
XrResult
818
-
oxr_create_swapchain(struct oxr_logger *,
819
struct oxr_session *sess,
820
-
const XrSwapchainCreateInfo *,
821
struct oxr_swapchain **out_swapchain);
822
823
···
1007
1008
#if defined(XR_USE_GRAPHICS_API_OPENGL) || defined(XR_USE_GRAPHICS_API_OPENGL_ES)
1009
XrResult
1010
-
oxr_swapchain_gl_create(struct oxr_logger *,
1011
struct oxr_session *sess,
1012
-
const XrSwapchainCreateInfo *,
1013
struct oxr_swapchain **out_swapchain);
1014
1015
#endif // XR_USE_GRAPHICS_API_OPENGL || XR_USE_GRAPHICS_API_OPENGL_ES
···
1081
struct oxr_session *sess);
1082
1083
XrResult
1084
-
oxr_swapchain_vk_create(struct oxr_logger *,
1085
struct oxr_session *sess,
1086
-
const XrSwapchainCreateInfo *,
1087
struct oxr_swapchain **out_swapchain);
1088
1089
#endif
···
815
}
816
817
XrResult
818
+
oxr_create_swapchain(struct oxr_logger * /*log*/,
819
struct oxr_session *sess,
820
+
const XrSwapchainCreateInfo * /*createInfo*/,
821
struct oxr_swapchain **out_swapchain);
822
823
···
1007
1008
#if defined(XR_USE_GRAPHICS_API_OPENGL) || defined(XR_USE_GRAPHICS_API_OPENGL_ES)
1009
XrResult
1010
+
oxr_swapchain_gl_create(struct oxr_logger * /*log*/,
1011
struct oxr_session *sess,
1012
+
const XrSwapchainCreateInfo * /*createInfo*/,
1013
struct oxr_swapchain **out_swapchain);
1014
1015
#endif // XR_USE_GRAPHICS_API_OPENGL || XR_USE_GRAPHICS_API_OPENGL_ES
···
1081
struct oxr_session *sess);
1082
1083
XrResult
1084
+
oxr_swapchain_vk_create(struct oxr_logger * /*log*/,
1085
struct oxr_session *sess,
1086
+
const XrSwapchainCreateInfo * /*createInfo*/,
1087
struct oxr_swapchain **out_swapchain);
1088
1089
#endif
+2
-1
src/xrt/state_trackers/oxr/oxr_space.c
+2
-1
src/xrt/state_trackers/oxr/oxr_space.c
···
274
struct xrt_device *head_xdev = GET_XDEV_BY_ROLE(spc->sess->sys, head);
275
*out_xdev = head_xdev;
276
return oxr_space_ref_get_pure_relation(log, spc->sess, spc->space_type, head_xdev, time, out_relation);
277
-
} else if (spc->space_type == OXR_SPACE_TYPE_ACTION) {
278
struct oxr_action_input *input = NULL;
279
oxr_action_get_pose_input(spc->sess, spc->act_key, &spc->subaction_paths, &input);
280
···
274
struct xrt_device *head_xdev = GET_XDEV_BY_ROLE(spc->sess->sys, head);
275
*out_xdev = head_xdev;
276
return oxr_space_ref_get_pure_relation(log, spc->sess, spc->space_type, head_xdev, time, out_relation);
277
+
}
278
+
if (spc->space_type == OXR_SPACE_TYPE_ACTION) {
279
struct oxr_action_input *input = NULL;
280
oxr_action_get_pose_input(spc->sess, spc->act_key, &spc->subaction_paths, &input);
281
+2
-1
src/xrt/state_trackers/oxr/oxr_swapchain.c
+2
-1
src/xrt/state_trackers/oxr/oxr_swapchain.c
···
212
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED,
213
"Specified swapchain creation flag is valid, "
214
"but not supported");
215
-
} else if (xret == XRT_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED) {
216
return oxr_error(log, XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED,
217
"Specified swapchain format is not supported");
218
}
···
212
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED,
213
"Specified swapchain creation flag is valid, "
214
"but not supported");
215
+
}
216
+
if (xret == XRT_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED) {
217
return oxr_error(log, XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED,
218
"Specified swapchain format is not supported");
219
}
+25
-11
src/xrt/state_trackers/prober/p_udev.c
+25
-11
src/xrt/state_trackers/prober/p_udev.c
···
148
p_udev_enumerate_usb(struct prober *p, struct udev *udev)
149
{
150
struct udev_enumerate *enumerate;
151
-
struct udev_list_entry *devices, *dev_list_entry;
152
153
enumerate = udev_enumerate_new(udev);
154
udev_enumerate_add_match_subsystem(enumerate, "usb");
···
253
p_udev_enumerate_v4l2(struct prober *p, struct udev *udev)
254
{
255
struct udev_enumerate *enumerate;
256
-
struct udev_list_entry *devices, *dev_list_entry;
257
258
enumerate = udev_enumerate_new(udev);
259
udev_enumerate_add_match_subsystem(enumerate, "video4linux");
···
371
p_udev_enumerate_hidraw(struct prober *p, struct udev *udev)
372
{
373
struct udev_enumerate *enumerate;
374
-
struct udev_list_entry *devices, *dev_list_entry;
375
376
enumerate = udev_enumerate_new(udev);
377
udev_enumerate_add_match_subsystem(enumerate, "hidraw");
···
383
{
384
struct prober_device *pdev = NULL;
385
struct udev_device *raw_dev = NULL;
386
-
uint16_t vendor_id, product_id, interface;
387
uint8_t dev_class = 0;
388
uint16_t usb_bus = 0;
389
uint16_t usb_addr = 0;
···
497
uint16_t *out_usb_bus,
498
uint16_t *out_usb_addr)
499
{
500
-
uint16_t dummy_vendor, dummy_product;
501
struct udev_device *usb_dev;
502
503
if (bus_type != HIDRAW_BUS_USB) {
···
549
struct udev_device *hid_dev;
550
char *serial_utf8 = NULL;
551
uint64_t bluetooth_serial = 0;
552
-
uint16_t vendor_id = 0, product_id = 0;
553
char product_name[sizeof(*out_product_name)];
554
uint32_t bus_type;
555
const char *uevent;
···
626
uint16_t *out_usb_addr,
627
struct udev_device **out_usb_device)
628
{
629
-
struct udev_device *parent_dev, *usb_interface, *usb_device;
630
631
parent_dev = udev_device_get_parent(raw_dev);
632
usb_interface = udev_device_get_parent_with_subsystem_devtype(raw_dev, "usb", "usb_interface");
···
664
static int
665
p_udev_get_vendor_id_product(struct udev_device *usb_dev, uint16_t *out_vendor_id, uint16_t *out_product_id)
666
{
667
-
uint16_t vendor_id, product_id;
668
int ret;
669
670
ret = p_udev_get_sysattr_u16_base16(usb_dev, "idVendor", &vendor_id);
···
691
uint16_t *out_usb_bus,
692
uint16_t *out_usb_addr)
693
{
694
-
uint16_t vendor_id, product_id, dev_class;
695
int ret;
696
697
// First get the vendor and product ids.
···
727
static int
728
p_udev_get_usb_device_address_path(struct udev_device *usb_dev, uint16_t *out_usb_bus, uint16_t *out_usb_addr)
729
{
730
-
uint16_t bus = 0, addr = 0;
731
732
const char *dev_path = udev_device_get_devnode(usb_dev);
733
if (dev_path == NULL) {
···
748
static int
749
p_udev_get_usb_device_address_sysfs(struct udev_device *usb_dev, uint16_t *out_usb_bus, uint16_t *out_usb_addr)
750
{
751
-
uint16_t usb_bus = 0, usb_addr = 0;
752
int ret;
753
754
ret = p_udev_get_sysattr_u16_base16(usb_dev, "busnum", &usb_bus);
···
148
p_udev_enumerate_usb(struct prober *p, struct udev *udev)
149
{
150
struct udev_enumerate *enumerate;
151
+
struct udev_list_entry *devices;
152
+
struct udev_list_entry *dev_list_entry;
153
154
enumerate = udev_enumerate_new(udev);
155
udev_enumerate_add_match_subsystem(enumerate, "usb");
···
254
p_udev_enumerate_v4l2(struct prober *p, struct udev *udev)
255
{
256
struct udev_enumerate *enumerate;
257
+
struct udev_list_entry *devices;
258
+
struct udev_list_entry *dev_list_entry;
259
260
enumerate = udev_enumerate_new(udev);
261
udev_enumerate_add_match_subsystem(enumerate, "video4linux");
···
373
p_udev_enumerate_hidraw(struct prober *p, struct udev *udev)
374
{
375
struct udev_enumerate *enumerate;
376
+
struct udev_list_entry *devices;
377
+
struct udev_list_entry *dev_list_entry;
378
379
enumerate = udev_enumerate_new(udev);
380
udev_enumerate_add_match_subsystem(enumerate, "hidraw");
···
386
{
387
struct prober_device *pdev = NULL;
388
struct udev_device *raw_dev = NULL;
389
+
uint16_t vendor_id;
390
+
uint16_t product_id;
391
+
uint16_t interface;
392
uint8_t dev_class = 0;
393
uint16_t usb_bus = 0;
394
uint16_t usb_addr = 0;
···
502
uint16_t *out_usb_bus,
503
uint16_t *out_usb_addr)
504
{
505
+
uint16_t dummy_vendor;
506
+
uint16_t dummy_product;
507
struct udev_device *usb_dev;
508
509
if (bus_type != HIDRAW_BUS_USB) {
···
555
struct udev_device *hid_dev;
556
char *serial_utf8 = NULL;
557
uint64_t bluetooth_serial = 0;
558
+
uint16_t vendor_id = 0;
559
+
uint16_t product_id = 0;
560
char product_name[sizeof(*out_product_name)];
561
uint32_t bus_type;
562
const char *uevent;
···
633
uint16_t *out_usb_addr,
634
struct udev_device **out_usb_device)
635
{
636
+
struct udev_device *parent_dev;
637
+
struct udev_device *usb_interface;
638
+
struct udev_device *usb_device;
639
640
parent_dev = udev_device_get_parent(raw_dev);
641
usb_interface = udev_device_get_parent_with_subsystem_devtype(raw_dev, "usb", "usb_interface");
···
673
static int
674
p_udev_get_vendor_id_product(struct udev_device *usb_dev, uint16_t *out_vendor_id, uint16_t *out_product_id)
675
{
676
+
uint16_t vendor_id;
677
+
uint16_t product_id;
678
int ret;
679
680
ret = p_udev_get_sysattr_u16_base16(usb_dev, "idVendor", &vendor_id);
···
701
uint16_t *out_usb_bus,
702
uint16_t *out_usb_addr)
703
{
704
+
uint16_t vendor_id;
705
+
uint16_t product_id;
706
+
uint16_t dev_class;
707
int ret;
708
709
// First get the vendor and product ids.
···
739
static int
740
p_udev_get_usb_device_address_path(struct udev_device *usb_dev, uint16_t *out_usb_bus, uint16_t *out_usb_addr)
741
{
742
+
uint16_t bus = 0;
743
+
uint16_t addr = 0;
744
745
const char *dev_path = udev_device_get_devnode(usb_dev);
746
if (dev_path == NULL) {
···
761
static int
762
p_udev_get_usb_device_address_sysfs(struct udev_device *usb_dev, uint16_t *out_usb_bus, uint16_t *out_usb_addr)
763
{
764
+
uint16_t usb_bus = 0;
765
+
uint16_t usb_addr = 0;
766
int ret;
767
768
ret = p_udev_get_sysattr_u16_base16(usb_dev, "busnum", &usb_bus);
+5
-5
src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp
+5
-5
src/xrt/state_trackers/steamvr_drv/ovrd_driver.cpp
···
359
}
360
}
361
362
-
struct profile_template *
363
get_profile_template(enum xrt_device_name device_name)
364
{
365
for (int i = 0; i < NUM_PROFILE_TEMPLATES; i++) {
···
1155
1156
ret = xrt_instance_select(m_xinst, xdevs, NUM_XDEVS);
1157
1158
-
int head, left, right;
1159
1160
u_device_assign_xdev_roles(xdevs, NUM_XDEVS, &head, &left, &right);
1161
···
1212
if (m_xinst) {
1213
xrt_instance_destroy(&m_xinst);
1214
}
1215
-
1216
-
return;
1217
}
1218
1219
void
···
1247
}
1248
out.vibration.frequency = freq;
1249
1250
-
if (controller->m_output_controls.size() < 1) {
1251
ovrd_log("Controller %s has no outputs\n", controller->m_xdev->str);
1252
return;
1253
}
···
359
}
360
}
361
362
+
static struct profile_template *
363
get_profile_template(enum xrt_device_name device_name)
364
{
365
for (int i = 0; i < NUM_PROFILE_TEMPLATES; i++) {
···
1155
1156
ret = xrt_instance_select(m_xinst, xdevs, NUM_XDEVS);
1157
1158
+
int head;
1159
+
int left;
1160
+
int right;
1161
1162
u_device_assign_xdev_roles(xdevs, NUM_XDEVS, &head, &left, &right);
1163
···
1214
if (m_xinst) {
1215
xrt_instance_destroy(&m_xinst);
1216
}
1217
}
1218
1219
void
···
1247
}
1248
out.vibration.frequency = freq;
1249
1250
+
if (controller->m_output_controls.empty()) {
1251
ovrd_log("Controller %s has no outputs\n", controller->m_xdev->str);
1252
return;
1253
}
+1
-1
src/xrt/targets/common/target_instance.c
+1
-1
src/xrt/targets/common/target_instance.c
+1
-1
src/xrt/targets/common/target_instance_no_comp.c
+1
-1
src/xrt/targets/common/target_instance_no_comp.c
+2
-2
src/xrt/targets/openxr/target.c
+2
-2
src/xrt/targets/openxr/target.c
···
23
ipc_instance_create(struct xrt_instance_info *i_info, struct xrt_instance **out_xinst);
24
25
int
26
-
xrt_instance_create(struct xrt_instance_info *i_info, struct xrt_instance **out_xinst)
27
{
28
u_trace_marker_init();
29
30
XRT_TRACE_MARKER();
31
32
-
return ipc_instance_create(i_info, out_xinst);
33
}
34
35
#else
···
23
ipc_instance_create(struct xrt_instance_info *i_info, struct xrt_instance **out_xinst);
24
25
int
26
+
xrt_instance_create(struct xrt_instance_info *ii, struct xrt_instance **out_xinst)
27
{
28
u_trace_marker_init();
29
30
XRT_TRACE_MARKER();
31
32
+
return ipc_instance_create(ii, out_xinst);
33
}
34
35
#else
+1
-1
tests/tests_history_buf.cpp
+1
-1
tests/tests_history_buf.cpp
+1
-1
tests/tests_id_ringbuffer.cpp
+1
-1
tests/tests_id_ringbuffer.cpp