The open source OpenXR runtime
d/pssense: Add PlayStation Sense controller driver
The driver probes the Sense controller devices and interprets the button presses from HID packets
+529
+3
CMakeLists.txt
+3
CMakeLists.txt
···
312
312
option_with_deps(XRT_BUILD_DRIVER_OHMD "Enable OpenHMD driver" DEPENDS OPENHMD_FOUND)
313
313
option_with_deps(XRT_BUILD_DRIVER_OPENGLOVES "Enable OpenGloves driver" DEPENDS XRT_HAVE_LIBUDEV XRT_HAVE_BLUETOOTH)
314
314
option_with_deps(XRT_BUILD_DRIVER_PSMV "Enable Playstation Move driver" DEPENDS XRT_HAVE_INTERNAL_HID)
315
+
option_with_deps(XRT_BUILD_DRIVER_PSSENSE "Enable PlayStation Sense driver" DEPENDS XRT_HAVE_INTERNAL_HID)
315
316
option_with_deps(XRT_BUILD_DRIVER_PSVR "Enable PSVR HMD driver" DEPENDS XRT_HAVE_HIDAPI)
316
317
option_with_deps(XRT_BUILD_DRIVER_QWERTY "Enable Qwerty driver" DEPENDS XRT_HAVE_SDL2)
317
318
option_with_deps(XRT_BUILD_DRIVER_REALSENSE "Enable RealSense device driver" DEPENDS XRT_HAVE_REALSENSE)
···
369
370
"OHMD"
370
371
"OPENGLOVES"
371
372
"PSMV"
373
+
"PSSENSE"
372
374
"PSVR"
373
375
"REALSENSE"
374
376
"REMOTE"
···
557
559
message(STATUS "# DRIVER_OHMD: ${XRT_BUILD_DRIVER_OHMD}")
558
560
message(STATUS "# DRIVER_OPENGLOVES: ${XRT_BUILD_DRIVER_OPENGLOVES}")
559
561
message(STATUS "# DRIVER_PSMV: ${XRT_BUILD_DRIVER_PSMV}")
562
+
message(STATUS "# DRIVER_PSSENSE: ${XRT_BUILD_DRIVER_PSSENSE}")
560
563
message(STATUS "# DRIVER_PSVR: ${XRT_BUILD_DRIVER_PSVR}")
561
564
message(STATUS "# DRIVER_QWERTY: ${XRT_BUILD_DRIVER_QWERTY}")
562
565
message(STATUS "# DRIVER_REALSENSE: ${XRT_BUILD_DRIVER_REALSENSE}")
+6
src/xrt/drivers/CMakeLists.txt
+6
src/xrt/drivers/CMakeLists.txt
···
160
160
list(APPEND ENABLED_DRIVERS psmv)
161
161
endif()
162
162
163
+
if(XRT_BUILD_DRIVER_PSSENSE)
164
+
add_library(drv_pssense STATIC pssense/pssense_driver.c pssense/pssense_interface.h)
165
+
target_link_libraries(drv_pssense PRIVATE aux_os)
166
+
list(APPEND ENABLED_DRIVERS pssense)
167
+
endif()
168
+
163
169
if(XRT_BUILD_DRIVER_PSVR)
164
170
add_library(
165
171
drv_psvr STATIC
+434
src/xrt/drivers/pssense/pssense_driver.c
+434
src/xrt/drivers/pssense/pssense_driver.c
···
1
+
// Copyright 2023, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
/*!
4
+
* @file
5
+
* @brief PlayStation Sense controller prober and driver code.
6
+
* @author Jarett Millard <jarett.millard@gmail.com>
7
+
* @ingroup drv_pssense
8
+
*/
9
+
10
+
#include "xrt/xrt_prober.h"
11
+
12
+
#include "os/os_threading.h"
13
+
#include "os/os_hid.h"
14
+
#include "os/os_time.h"
15
+
16
+
#include "math/m_api.h"
17
+
18
+
#include "tracking/t_imu.h"
19
+
20
+
#include "util/u_var.h"
21
+
#include "util/u_debug.h"
22
+
#include "util/u_device.h"
23
+
#include "util/u_logging.h"
24
+
#include "util/u_trace_marker.h"
25
+
26
+
#include "pssense_interface.h"
27
+
28
+
#include <stdio.h>
29
+
30
+
/*!
31
+
* @addtogroup drv_pssense
32
+
* @{
33
+
*/
34
+
35
+
#define PSSENSE_TRACE(p, ...) U_LOG_XDEV_IFL_T(&p->base, p->log_level, __VA_ARGS__)
36
+
#define PSSENSE_DEBUG(p, ...) U_LOG_XDEV_IFL_D(&p->base, p->log_level, __VA_ARGS__)
37
+
#define PSSENSE_WARN(p, ...) U_LOG_XDEV_IFL_W(&p->base, p->log_level, __VA_ARGS__)
38
+
#define PSSENSE_ERROR(p, ...) U_LOG_XDEV_IFL_E(&p->base, p->log_level, __VA_ARGS__)
39
+
40
+
DEBUG_GET_ONCE_LOG_OPTION(pssense_log, "PSSENSE_LOG", U_LOGGING_WARN)
41
+
42
+
/*!
43
+
* Indices where each input is in the input list.
44
+
*/
45
+
enum pssense_input_index
46
+
{
47
+
PSSENSE_INDEX_PS_CLICK,
48
+
PSSENSE_INDEX_SHARE_CLICK,
49
+
PSSENSE_INDEX_OPTIONS_CLICK,
50
+
PSSENSE_INDEX_SQUARE_CLICK,
51
+
PSSENSE_INDEX_SQUARE_TOUCH,
52
+
PSSENSE_INDEX_TRIANGLE_CLICK,
53
+
PSSENSE_INDEX_TRIANGLE_TOUCH,
54
+
PSSENSE_INDEX_CROSS_CLICK,
55
+
PSSENSE_INDEX_CROSS_TOUCH,
56
+
PSSENSE_INDEX_CIRCLE_CLICK,
57
+
PSSENSE_INDEX_CIRCLE_TOUCH,
58
+
PSSENSE_INDEX_SQUEEZE_CLICK,
59
+
PSSENSE_INDEX_SQUEEZE_TOUCH,
60
+
PSSENSE_INDEX_SQUEEZE_PROXIMITY,
61
+
PSSENSE_INDEX_TRIGGER_CLICK,
62
+
PSSENSE_INDEX_TRIGGER_TOUCH,
63
+
PSSENSE_INDEX_TRIGGER_VALUE,
64
+
PSSENSE_INDEX_TRIGGER_PROXIMITY,
65
+
PSSENSE_INDEX_THUMBSTICK,
66
+
PSSENSE_INDEX_THUMBSTICK_CLICK,
67
+
PSSENSE_INDEX_THUMBSTICK_TOUCH
68
+
};
69
+
70
+
/*!
71
+
* HID data packet.
72
+
*/
73
+
struct pssense_data_packet
74
+
{
75
+
uint8_t header;
76
+
uint8_t thumbstick_x;
77
+
uint8_t thumbstick_y;
78
+
uint8_t trigger_value;
79
+
uint8_t trigger_proximity;
80
+
uint8_t squeeze_proximity;
81
+
uint8_t reserved;
82
+
uint8_t seq_no;
83
+
uint8_t buttons[3];
84
+
};
85
+
86
+
/*!
87
+
* PlayStation Sense state parsed from a data packet.
88
+
*/
89
+
struct pssense_input_state
90
+
{
91
+
uint64_t timestamp;
92
+
uint8_t seq_no;
93
+
94
+
bool ps_click;
95
+
bool share_click;
96
+
bool options_click;
97
+
bool square_click;
98
+
bool square_touch;
99
+
bool triangle_click;
100
+
bool triangle_touch;
101
+
bool cross_click;
102
+
bool cross_touch;
103
+
bool circle_click;
104
+
bool circle_touch;
105
+
bool squeeze_click;
106
+
bool squeeze_touch;
107
+
float squeeze_proximity;
108
+
bool trigger_click;
109
+
bool trigger_touch;
110
+
float trigger_value;
111
+
float trigger_proximity;
112
+
bool thumbstick_click;
113
+
bool thumbstick_touch;
114
+
struct xrt_vec2 thumbstick;
115
+
};
116
+
117
+
/*!
118
+
* A single PlayStation Sense Controller.
119
+
*
120
+
* @implements xrt_device
121
+
*/
122
+
struct pssense_device
123
+
{
124
+
struct xrt_device base;
125
+
126
+
struct os_hid_device *hid;
127
+
struct os_thread_helper controller_thread;
128
+
struct os_mutex lock;
129
+
130
+
enum
131
+
{
132
+
PSSENSE_HAND_LEFT,
133
+
PSSENSE_HAND_RIGHT
134
+
} hand;
135
+
136
+
enum u_logging_level log_level;
137
+
138
+
//! Input state parsed from most recent packet
139
+
struct pssense_input_state state;
140
+
141
+
struct
142
+
{
143
+
bool button_states;
144
+
} gui;
145
+
};
146
+
147
+
/*!
148
+
* Reads one packet from the device, handles time out, locking and checking if
149
+
* the thread has been told to shut down.
150
+
*/
151
+
static bool
152
+
pssense_read_one_packet(struct pssense_device *pssense, uint8_t *buffer, size_t size)
153
+
{
154
+
os_thread_helper_lock(&pssense->controller_thread);
155
+
156
+
while (os_thread_helper_is_running_locked(&pssense->controller_thread)) {
157
+
os_thread_helper_unlock(&pssense->controller_thread);
158
+
159
+
int ret = os_hid_read(pssense->hid, buffer, size, 1000);
160
+
161
+
if (ret == 0) {
162
+
PSSENSE_DEBUG(pssense, "Timeout");
163
+
164
+
// Must lock thread before check in a while.
165
+
os_thread_helper_lock(&pssense->controller_thread);
166
+
continue;
167
+
}
168
+
if (ret < 0) {
169
+
PSSENSE_ERROR(pssense, "Failed to read device '%i'!", ret);
170
+
return false;
171
+
}
172
+
if (ret != (int)size) {
173
+
PSSENSE_ERROR(pssense, "Unexpected HID packet size %i (expected %zu)", ret, size);
174
+
return false;
175
+
}
176
+
177
+
return true;
178
+
}
179
+
180
+
return false;
181
+
}
182
+
183
+
static void
184
+
pssense_parse_packet(struct pssense_device *pssense,
185
+
struct pssense_data_packet *data,
186
+
struct pssense_input_state *input)
187
+
{
188
+
input->timestamp = os_monotonic_get_ns();
189
+
input->seq_no = data->seq_no;
190
+
191
+
input->ps_click = (data->buttons[1] & 16) != 0;
192
+
input->squeeze_touch = (data->buttons[2] & 8) != 0;
193
+
input->squeeze_proximity = data->squeeze_proximity / 255.0f;
194
+
input->trigger_touch = (data->buttons[1] & 128) != 0;
195
+
input->trigger_value = data->trigger_value / 255.0f;
196
+
input->trigger_proximity = data->trigger_proximity / 255.0f;
197
+
input->thumbstick.x = (data->thumbstick_x - 128) / 128.0f;
198
+
input->thumbstick.y = (data->thumbstick_y - 128) / -128.0f;
199
+
input->thumbstick_touch = (data->buttons[2] & 4) != 0;
200
+
201
+
if (pssense->hand == PSSENSE_HAND_LEFT) {
202
+
input->share_click = (data->buttons[1] & 1) != 0;
203
+
input->square_click = (data->buttons[0] & 1) != 0;
204
+
input->square_touch = (data->buttons[2] & 2) != 0;
205
+
input->triangle_click = (data->buttons[0] & 8) != 0;
206
+
input->triangle_touch = (data->buttons[2] & 1) != 0;
207
+
input->squeeze_click = (data->buttons[0] & 16) != 0;
208
+
input->trigger_click = (data->buttons[0] & 64) != 0;
209
+
input->thumbstick_click = (data->buttons[1] & 4) != 0;
210
+
} else if (pssense->hand == PSSENSE_HAND_RIGHT) {
211
+
input->options_click = (data->buttons[1] & 2) != 0;
212
+
input->cross_click = (data->buttons[0] & 2) != 0;
213
+
input->cross_touch = (data->buttons[2] & 2) != 0;
214
+
input->circle_click = (data->buttons[0] & 4) != 0;
215
+
input->circle_touch = (data->buttons[2] & 1) != 0;
216
+
input->squeeze_click = (data->buttons[0] & 32) != 0;
217
+
input->trigger_click = (data->buttons[0] & 128) != 0;
218
+
input->thumbstick_click = (data->buttons[1] & 8) != 0;
219
+
}
220
+
}
221
+
222
+
static void *
223
+
pssense_run_thread(void *ptr)
224
+
{
225
+
U_TRACE_SET_THREAD_NAME("PS Sense");
226
+
227
+
struct pssense_device *pssense = (struct pssense_device *)ptr;
228
+
229
+
union {
230
+
uint8_t buffer[sizeof(struct pssense_data_packet)];
231
+
struct pssense_data_packet input;
232
+
} data;
233
+
struct pssense_input_state input = {0};
234
+
235
+
while (os_hid_read(pssense->hid, data.buffer, sizeof(data), 0) > 0) {
236
+
// Empty queue first
237
+
}
238
+
239
+
// Now wait for a package to sync up, it's discarded but that's okay.
240
+
if (!pssense_read_one_packet(pssense, data.buffer, sizeof(data))) {
241
+
return NULL;
242
+
}
243
+
244
+
while (pssense_read_one_packet(pssense, data.buffer, sizeof(data))) {
245
+
pssense_parse_packet(pssense, (struct pssense_data_packet *)data.buffer, &input);
246
+
os_mutex_lock(&pssense->lock);
247
+
pssense->state = input;
248
+
os_mutex_unlock(&pssense->lock);
249
+
}
250
+
251
+
return NULL;
252
+
}
253
+
254
+
static void
255
+
pssense_device_destroy(struct xrt_device *xdev)
256
+
{
257
+
struct pssense_device *pssense = (struct pssense_device *)xdev;
258
+
259
+
// Destroy the thread object.
260
+
os_thread_helper_destroy(&pssense->controller_thread);
261
+
262
+
// Now that the thread is not running we can destroy the lock.
263
+
os_mutex_destroy(&pssense->lock);
264
+
265
+
// Remove the variable tracking.
266
+
u_var_remove_root(pssense);
267
+
268
+
if (pssense->hid != NULL) {
269
+
os_hid_destroy(pssense->hid);
270
+
pssense->hid = NULL;
271
+
}
272
+
273
+
free(pssense);
274
+
}
275
+
276
+
static void
277
+
pssense_device_update_inputs(struct xrt_device *xdev)
278
+
{
279
+
struct pssense_device *pssense = (struct pssense_device *)xdev;
280
+
281
+
// Lock the data.
282
+
os_mutex_lock(&pssense->lock);
283
+
284
+
for (uint i = 0; i < (uint)sizeof(enum pssense_input_index); i++) {
285
+
pssense->base.inputs[i].timestamp = (int64_t)pssense->state.timestamp;
286
+
}
287
+
pssense->base.inputs[PSSENSE_INDEX_PS_CLICK].value.boolean = pssense->state.ps_click;
288
+
pssense->base.inputs[PSSENSE_INDEX_SHARE_CLICK].value.boolean = pssense->state.share_click;
289
+
pssense->base.inputs[PSSENSE_INDEX_OPTIONS_CLICK].value.boolean = pssense->state.options_click;
290
+
pssense->base.inputs[PSSENSE_INDEX_SQUARE_CLICK].value.boolean = pssense->state.square_click;
291
+
pssense->base.inputs[PSSENSE_INDEX_SQUARE_TOUCH].value.boolean = pssense->state.square_touch;
292
+
pssense->base.inputs[PSSENSE_INDEX_TRIANGLE_CLICK].value.boolean = pssense->state.triangle_click;
293
+
pssense->base.inputs[PSSENSE_INDEX_TRIANGLE_TOUCH].value.boolean = pssense->state.triangle_touch;
294
+
pssense->base.inputs[PSSENSE_INDEX_CROSS_CLICK].value.boolean = pssense->state.cross_click;
295
+
pssense->base.inputs[PSSENSE_INDEX_CROSS_TOUCH].value.boolean = pssense->state.cross_touch;
296
+
pssense->base.inputs[PSSENSE_INDEX_CIRCLE_CLICK].value.boolean = pssense->state.circle_click;
297
+
pssense->base.inputs[PSSENSE_INDEX_CIRCLE_TOUCH].value.boolean = pssense->state.circle_touch;
298
+
pssense->base.inputs[PSSENSE_INDEX_SQUEEZE_CLICK].value.boolean = pssense->state.squeeze_click;
299
+
pssense->base.inputs[PSSENSE_INDEX_SQUEEZE_TOUCH].value.boolean = pssense->state.squeeze_touch;
300
+
pssense->base.inputs[PSSENSE_INDEX_SQUEEZE_PROXIMITY].value.vec1.x = pssense->state.squeeze_proximity;
301
+
pssense->base.inputs[PSSENSE_INDEX_TRIGGER_CLICK].value.boolean = pssense->state.trigger_click;
302
+
pssense->base.inputs[PSSENSE_INDEX_TRIGGER_TOUCH].value.boolean = pssense->state.trigger_touch;
303
+
pssense->base.inputs[PSSENSE_INDEX_TRIGGER_VALUE].value.vec1.x = pssense->state.trigger_value;
304
+
pssense->base.inputs[PSSENSE_INDEX_TRIGGER_PROXIMITY].value.vec1.x = pssense->state.trigger_proximity;
305
+
pssense->base.inputs[PSSENSE_INDEX_THUMBSTICK].value.vec2 = pssense->state.thumbstick;
306
+
pssense->base.inputs[PSSENSE_INDEX_THUMBSTICK_CLICK].value.boolean = pssense->state.thumbstick_click;
307
+
pssense->base.inputs[PSSENSE_INDEX_THUMBSTICK_TOUCH].value.boolean = pssense->state.thumbstick_touch;
308
+
309
+
// Done now.
310
+
os_mutex_unlock(&pssense->lock);
311
+
}
312
+
313
+
#define SET_INPUT(NAME) (pssense->base.inputs[PSSENSE_INDEX_##NAME].name = XRT_INPUT_PSSENSE_##NAME)
314
+
315
+
int
316
+
pssense_found(struct xrt_prober *xp,
317
+
struct xrt_prober_device **devices,
318
+
size_t device_count,
319
+
size_t index,
320
+
cJSON *attached_data,
321
+
struct xrt_device **out_xdevs)
322
+
{
323
+
struct os_hid_device *hid = NULL;
324
+
int ret;
325
+
326
+
ret = xrt_prober_open_hid_interface(xp, devices[index], 0, &hid);
327
+
if (ret != 0) {
328
+
return -1;
329
+
}
330
+
331
+
enum u_device_alloc_flags flags = U_DEVICE_ALLOC_TRACKING_NONE;
332
+
struct pssense_device *pssense = U_DEVICE_ALLOCATE(struct pssense_device, flags, 13, 1);
333
+
334
+
PSSENSE_DEBUG(pssense, "PlayStation Sense controller found");
335
+
pssense->base.destroy = pssense_device_destroy;
336
+
pssense->base.update_inputs = pssense_device_update_inputs;
337
+
pssense->base.name = XRT_DEVICE_PSSENSE;
338
+
snprintf(pssense->base.str, XRT_DEVICE_NAME_LEN, "%s", devices[index]->product_name);
339
+
340
+
pssense->log_level = debug_get_log_option_pssense_log();
341
+
pssense->hid = hid;
342
+
343
+
if (devices[index]->product_id == PSSENSE_PID_LEFT) {
344
+
pssense->base.device_type = XRT_DEVICE_TYPE_LEFT_HAND_CONTROLLER;
345
+
pssense->hand = PSSENSE_HAND_LEFT;
346
+
} else if (devices[index]->product_id == PSSENSE_PID_RIGHT) {
347
+
pssense->base.device_type = XRT_DEVICE_TYPE_RIGHT_HAND_CONTROLLER;
348
+
pssense->hand = PSSENSE_HAND_RIGHT;
349
+
} else {
350
+
PSSENSE_ERROR(pssense, "Unable to determine controller type");
351
+
pssense_device_destroy(&pssense->base);
352
+
return -1;
353
+
}
354
+
355
+
SET_INPUT(PS_CLICK);
356
+
SET_INPUT(SHARE_CLICK);
357
+
SET_INPUT(OPTIONS_CLICK);
358
+
SET_INPUT(SQUARE_CLICK);
359
+
SET_INPUT(SQUARE_TOUCH);
360
+
SET_INPUT(TRIANGLE_CLICK);
361
+
SET_INPUT(TRIANGLE_TOUCH);
362
+
SET_INPUT(CROSS_CLICK);
363
+
SET_INPUT(CROSS_TOUCH);
364
+
SET_INPUT(CIRCLE_CLICK);
365
+
SET_INPUT(CIRCLE_TOUCH);
366
+
SET_INPUT(SQUEEZE_CLICK);
367
+
SET_INPUT(SQUEEZE_TOUCH);
368
+
SET_INPUT(SQUEEZE_PROXIMITY);
369
+
SET_INPUT(TRIGGER_CLICK);
370
+
SET_INPUT(TRIGGER_TOUCH);
371
+
SET_INPUT(TRIGGER_VALUE);
372
+
SET_INPUT(TRIGGER_PROXIMITY);
373
+
SET_INPUT(THUMBSTICK);
374
+
SET_INPUT(THUMBSTICK_CLICK);
375
+
SET_INPUT(THUMBSTICK_TOUCH);
376
+
377
+
ret = os_mutex_init(&pssense->lock);
378
+
if (ret != 0) {
379
+
PSSENSE_ERROR(pssense, "Failed to init mutex!");
380
+
pssense_device_destroy(&pssense->base);
381
+
return -1;
382
+
}
383
+
384
+
ret = os_thread_helper_init(&pssense->controller_thread);
385
+
if (ret != 0) {
386
+
PSSENSE_ERROR(pssense, "Failed to init threading!");
387
+
pssense_device_destroy(&pssense->base);
388
+
return -1;
389
+
}
390
+
391
+
ret = os_thread_helper_start(&pssense->controller_thread, pssense_run_thread, pssense);
392
+
if (ret != 0) {
393
+
PSSENSE_ERROR(pssense, "Failed to start thread!");
394
+
pssense_device_destroy(&pssense->base);
395
+
return -1;
396
+
}
397
+
398
+
u_var_add_root(pssense, pssense->base.str, false);
399
+
u_var_add_log_level(pssense, &pssense->log_level, "Log level");
400
+
401
+
u_var_add_gui_header(pssense, &pssense->gui.button_states, "Button States");
402
+
u_var_add_bool(pssense, &pssense->state.ps_click, "PS Click");
403
+
if (pssense->hand == PSSENSE_HAND_LEFT) {
404
+
u_var_add_bool(pssense, &pssense->state.share_click, "Share Click");
405
+
u_var_add_bool(pssense, &pssense->state.square_click, "Square Click");
406
+
u_var_add_bool(pssense, &pssense->state.square_touch, "Square Touch");
407
+
u_var_add_bool(pssense, &pssense->state.triangle_click, "Triangle Click");
408
+
u_var_add_bool(pssense, &pssense->state.triangle_touch, "Triangle Touch");
409
+
} else if (pssense->hand == PSSENSE_HAND_RIGHT) {
410
+
u_var_add_bool(pssense, &pssense->state.options_click, "Options Click");
411
+
u_var_add_bool(pssense, &pssense->state.cross_click, "Cross Click");
412
+
u_var_add_bool(pssense, &pssense->state.cross_touch, "Cross Touch");
413
+
u_var_add_bool(pssense, &pssense->state.circle_click, "Circle Click");
414
+
u_var_add_bool(pssense, &pssense->state.circle_touch, "Circle Touch");
415
+
}
416
+
u_var_add_bool(pssense, &pssense->state.squeeze_click, "Squeeze Click");
417
+
u_var_add_bool(pssense, &pssense->state.squeeze_touch, "Squeeze Touch");
418
+
u_var_add_ro_f32(pssense, &pssense->state.squeeze_proximity, "Squeeze Proximity");
419
+
u_var_add_bool(pssense, &pssense->state.trigger_click, "Trigger Click");
420
+
u_var_add_bool(pssense, &pssense->state.trigger_touch, "Trigger Touch");
421
+
u_var_add_ro_f32(pssense, &pssense->state.trigger_value, "Trigger");
422
+
u_var_add_ro_f32(pssense, &pssense->state.trigger_proximity, "Trigger Proximity");
423
+
u_var_add_ro_f32(pssense, &pssense->state.thumbstick.x, "Thumbstick X");
424
+
u_var_add_ro_f32(pssense, &pssense->state.thumbstick.y, "Thumbstick Y");
425
+
u_var_add_bool(pssense, &pssense->state.thumbstick_click, "Thumbstick Click");
426
+
u_var_add_bool(pssense, &pssense->state.thumbstick_touch, "Thumbstick Touch");
427
+
428
+
out_xdevs[0] = &pssense->base;
429
+
return 1;
430
+
}
431
+
432
+
/*!
433
+
* @}
434
+
*/
+50
src/xrt/drivers/pssense/pssense_interface.h
+50
src/xrt/drivers/pssense/pssense_interface.h
···
1
+
// Copyright 2023, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
/*!
4
+
* @file
5
+
* @brief Interface to @ref drv_pssense
6
+
* @author Jarett Millard <jarett.millard@gmail.com>
7
+
* @ingroup drv_pssense
8
+
*/
9
+
10
+
#pragma once
11
+
12
+
#include <stdlib.h>
13
+
14
+
#ifdef __cplusplus
15
+
extern "C" {
16
+
#endif
17
+
/*!
18
+
* @defgroup drv_pssense PlayStation Sense driver
19
+
* @ingroup drv
20
+
*
21
+
* @brief Driver for the PlayStation Sense motion controllers.
22
+
*/
23
+
24
+
#define PSSENSE_VID 0x054C
25
+
#define PSSENSE_PID_LEFT 0x0E45
26
+
#define PSSENSE_PID_RIGHT 0x0E46
27
+
28
+
/*!
29
+
* Probing function for PlayStation Sense devices.
30
+
*
31
+
* @ingroup drv_pssense
32
+
* @see xrt_prober_found_func_t
33
+
*/
34
+
int
35
+
pssense_found(struct xrt_prober *xp,
36
+
struct xrt_prober_device **devices,
37
+
size_t device_count,
38
+
size_t index,
39
+
cJSON *attached_data,
40
+
struct xrt_device **out_xdevs);
41
+
42
+
/*!
43
+
* @dir drivers/pssense
44
+
*
45
+
* @brief @ref drv_pssense files.
46
+
*/
47
+
48
+
#ifdef __cplusplus
49
+
}
50
+
#endif
+23
src/xrt/include/xrt/xrt_defines.h
+23
src/xrt/include/xrt/xrt_defines.h
···
629
629
XRT_DEVICE_HAND_INTERACTION,
630
630
631
631
XRT_DEVICE_PSMV,
632
+
XRT_DEVICE_PSSENSE,
632
633
XRT_DEVICE_HYDRA,
633
634
634
635
// Other misc stuff.
···
919
920
XRT_INPUT_ML2_CONTROLLER_GRIP_POSE = XRT_INPUT_NAME(0x0208, POSE),
920
921
XRT_INPUT_ML2_CONTROLLER_AIM_POSE = XRT_INPUT_NAME(0x0209, POSE),
921
922
XRT_INPUT_ML2_CONTROLLER_SHOULDER_CLICK = XRT_INPUT_NAME(0x020A, BOOLEAN),
923
+
924
+
XRT_INPUT_PSSENSE_PS_CLICK = XRT_INPUT_NAME(0x0300, BOOLEAN),
925
+
XRT_INPUT_PSSENSE_SHARE_CLICK = XRT_INPUT_NAME(0x0301, BOOLEAN),
926
+
XRT_INPUT_PSSENSE_OPTIONS_CLICK = XRT_INPUT_NAME(0x0302, BOOLEAN),
927
+
XRT_INPUT_PSSENSE_SQUARE_CLICK = XRT_INPUT_NAME(0x0303, BOOLEAN),
928
+
XRT_INPUT_PSSENSE_SQUARE_TOUCH = XRT_INPUT_NAME(0x0304, BOOLEAN),
929
+
XRT_INPUT_PSSENSE_TRIANGLE_CLICK = XRT_INPUT_NAME(0x0305, BOOLEAN),
930
+
XRT_INPUT_PSSENSE_TRIANGLE_TOUCH = XRT_INPUT_NAME(0x0306, BOOLEAN),
931
+
XRT_INPUT_PSSENSE_CROSS_CLICK = XRT_INPUT_NAME(0x0307, BOOLEAN),
932
+
XRT_INPUT_PSSENSE_CROSS_TOUCH = XRT_INPUT_NAME(0x0308, BOOLEAN),
933
+
XRT_INPUT_PSSENSE_CIRCLE_CLICK = XRT_INPUT_NAME(0x0309, BOOLEAN),
934
+
XRT_INPUT_PSSENSE_CIRCLE_TOUCH = XRT_INPUT_NAME(0x030a, BOOLEAN),
935
+
XRT_INPUT_PSSENSE_SQUEEZE_CLICK = XRT_INPUT_NAME(0x030b, BOOLEAN),
936
+
XRT_INPUT_PSSENSE_SQUEEZE_TOUCH = XRT_INPUT_NAME(0x030c, BOOLEAN),
937
+
XRT_INPUT_PSSENSE_SQUEEZE_PROXIMITY = XRT_INPUT_NAME(0x030d, VEC1_ZERO_TO_ONE),
938
+
XRT_INPUT_PSSENSE_TRIGGER_CLICK = XRT_INPUT_NAME(0x030e, BOOLEAN),
939
+
XRT_INPUT_PSSENSE_TRIGGER_TOUCH = XRT_INPUT_NAME(0x030f, BOOLEAN),
940
+
XRT_INPUT_PSSENSE_TRIGGER_VALUE = XRT_INPUT_NAME(0x0310, VEC1_ZERO_TO_ONE),
941
+
XRT_INPUT_PSSENSE_TRIGGER_PROXIMITY = XRT_INPUT_NAME(0x0311, VEC1_ZERO_TO_ONE),
942
+
XRT_INPUT_PSSENSE_THUMBSTICK = XRT_INPUT_NAME(0x0312, VEC2_MINUS_ONE_TO_ONE),
943
+
XRT_INPUT_PSSENSE_THUMBSTICK_CLICK = XRT_INPUT_NAME(0x0313, BOOLEAN),
944
+
XRT_INPUT_PSSENSE_THUMBSTICK_TOUCH = XRT_INPUT_NAME(0x0314, BOOLEAN),
922
945
// clang-format on
923
946
};
924
947
+4
src/xrt/targets/common/CMakeLists.txt
+4
src/xrt/targets/common/CMakeLists.txt
···
103
103
target_link_libraries(target_lists PRIVATE drv_psmv)
104
104
endif()
105
105
106
+
if(XRT_BUILD_DRIVER_PSSENSE)
107
+
target_link_libraries(target_lists PRIVATE drv_pssense)
108
+
endif()
109
+
106
110
if(XRT_BUILD_DRIVER_PSVR)
107
111
target_link_libraries(target_lists PRIVATE drv_psvr)
108
112
endif()
+9
src/xrt/targets/common/target_lists.c
+9
src/xrt/targets/common/target_lists.c
···
32
32
#include "psmv/psmv_interface.h"
33
33
#endif
34
34
35
+
#ifdef XRT_BUILD_DRIVER_PSSENSE
36
+
#include "pssense/pssense_interface.h"
37
+
#endif
38
+
35
39
#ifdef XRT_BUILD_DRIVER_PSVR
36
40
#include "psvr/psvr_interface.h"
37
41
#endif
···
150
154
{PSMV_VID, PSMV_PID_ZCM1, psmv_found, "PS Move Controller (ZCM1)", "psmv"},
151
155
{PSMV_VID, PSMV_PID_ZCM2, psmv_found, "PS Move Controller (ZCM2)", "psmv"},
152
156
#endif // XRT_BUILD_DRIVER_PSMV
157
+
158
+
#ifdef XRT_BUILD_DRIVER_PSSENSE
159
+
{PSSENSE_VID, PSSENSE_PID_LEFT, pssense_found, "PlayStation VR2 Sense Controller (L)", "pssense"},
160
+
{PSSENSE_VID, PSSENSE_PID_RIGHT, pssense_found, "PlayStation VR2 Sense Controller (R)", "pssense"},
161
+
#endif // XRT_BUILD_DRIVER_PSSENSE
153
162
154
163
#ifdef XRT_BUILD_DRIVER_HYDRA
155
164
{HYDRA_VID, HYDRA_PID, hydra_found, "Razer Hydra", "hydra"},