Blender V5.3
wm_xr_session.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BKE_callbacks.hh"
10#include "BKE_context.hh"
11#include "BKE_global.hh"
12#include "BKE_idprop.hh"
13#include "BKE_lib_id.hh"
14#include "BKE_main.hh"
15#include "BKE_object.hh"
16#include "BKE_scene.hh"
17#include "BKE_screen.hh"
18
19#include "BLI_listbase.hh"
20#include "BLI_math_matrix_c.hh"
22#include "BLI_math_vector_c.hh"
23#include "BLI_string.hh"
24#include "BLI_time.hh"
25
26#include "DEG_depsgraph.hh"
28
29#include "DNA_camera_types.h"
30#include "DNA_space_types.h"
31
32#include "DRW_engine.hh"
33
34#include "ED_screen.hh"
35#include "ED_space_api.hh"
36
37#include "GHOST_Xr-api.hh"
38
39#include "GPU_batch.hh"
40#include "GPU_viewport.hh"
41
42#include "IMB_imbuf.hh"
43
44#include "UI_interface_icons.hh"
45#include "UI_resources.hh"
46
47#include "MEM_guardedalloc.h"
48
49#include "WM_api.hh"
50#include "WM_types.hh"
51
52#include "wm_event_system.hh"
53#include "wm_surface.hh"
54#include "wm_window.hh"
55#include "wm_xr_intern.hh"
56
57namespace blender {
58
59static wmSurface *g_xr_surface = nullptr;
60static CLG_LogRef LOG = {"wm.xr"};
61
62/* -------------------------------------------------------------------- */
63
65{
66 Main *bmain = G_MAIN;
67 wmWindowManager *wm = bmain->wm.first();
68 wmXrData *xr_data = &wm->xr;
70 XrSessionSettings *settings = &xr_data->session_settings;
71
72 /* Get action set data from Python. */
74
76
77 /* Initialize navigation. */
79 if (settings->base_scale < FLT_EPSILON) {
80 settings->base_scale = 1.0f;
81 }
82 state->prev_base_scale = settings->base_scale;
83
84 /* Initialize location scouting viewfinder. */
87
88 /* Initialize vignette. */
89 state->vignette_aperture = 1.0f;
90 state->vignette_last_update_time = BLI_time_now_seconds();
91}
92
94{
95 ListBaseT<wmXrController> *lb = &state->controllers;
96 while (wmXrController *c = static_cast<wmXrController *>(BLI_pophead(lb))) {
97 if (c->model) {
98 GPU_batch_discard(c->model);
99 }
100 BLI_freelinkN(lb, c);
101 }
102}
103
105{
106 if (state->viewfinder.render_cam_data_id != nullptr) {
107 BKE_id_free(nullptr, id_cast<ID *>(state->viewfinder.render_cam_data_id));
108 state->viewfinder.render_cam_data_id = nullptr;
109 }
110
111 if (state->viewfinder.offscreen != nullptr) {
112 GPU_offscreen_free(state->viewfinder.offscreen);
113 state->viewfinder.offscreen = nullptr;
114 }
115
116 if (state->viewfinder.viewport != nullptr) {
117 GPU_viewport_free(state->viewfinder.viewport);
118 state->viewfinder.viewport = nullptr;
119 }
120
121 GPU_TEXTURE_FREE_SAFE(state->viewfinder.backside_logo_texture);
122}
123
129
130static void wm_xr_session_exit_cb(void *customdata)
131{
132 wmXrData *xr_data = static_cast<wmXrData *>(customdata);
133 if (!xr_data->runtime) {
134 return;
135 }
136
137 xr_data->runtime->session_state.is_started = false;
138
139 if (xr_data->runtime->exit_fn) {
140 xr_data->runtime->exit_fn(xr_data);
141 }
142
143 /* Free the entire runtime data (including session state and context), to play safe. */
145}
146
148 GHOST_XrSessionBeginInfo *r_begin_info)
149{
150 /* Callback for when the session is created. This is needed to create and bind OpenXR actions
151 * after the session is created but before it is started. */
152 r_begin_info->create_fn = wm_xr_session_create_cb;
153
154 /* WM-XR exit function, does some of its own stuff and calls callback passed to
155 * wm_xr_session_toggle(), to allow external code to execute its own session-exit logic. */
156 r_begin_info->exit_fn = wm_xr_session_exit_cb;
157 r_begin_info->exit_customdata = xr_data;
158}
159
161{
162 wmXrData *xr_data = &wm->xr;
163
164 if (WM_xr_session_exists(xr_data)) {
165 /* Must set first, since #GHOST_XrSessionEnd() may immediately free the runtime. */
166 xr_data->runtime->session_state.is_started = false;
167
169 }
170 else {
171 GHOST_XrSessionBeginInfo begin_info;
172
173 xr_data->runtime->session_state.is_started = true;
174 xr_data->runtime->exit_fn = session_exit_fn;
175
176 wm_xr_session_begin_info_create(xr_data, &begin_info);
177 GHOST_XrSessionStart(xr_data->runtime->ghost_context, &begin_info);
178 }
179}
180
182{
183 return xr->runtime && xr->runtime->ghost_context && xr->runtime->session_state.is_started;
184}
185
190
195
196static void wm_xr_session_base_pose_calc(const Scene *scene,
197 const XrSessionSettings *settings,
198 GHOST_XrPose *r_base_pose,
199 float *r_base_scale)
200{
201 const Object *base_pose_object = ((settings->base_pose_type == XR_BASE_POSE_OBJECT) &&
202 settings->base_pose_object) ?
203 settings->base_pose_object :
204 scene->camera;
205
206 if (settings->base_pose_type == XR_BASE_POSE_CUSTOM) {
207 float tmp_quatx[4], tmp_quatz[4];
208
209 copy_v3_v3(r_base_pose->position, settings->base_pose_location);
210 axis_angle_to_quat_single(tmp_quatx, 'X', M_PI_2);
211 axis_angle_to_quat_single(tmp_quatz, 'Z', settings->base_pose_angle);
212 mul_qt_qtqt(r_base_pose->orientation_quat, tmp_quatz, tmp_quatx);
213 }
214 else if (base_pose_object) {
215 float tmp_quat[4];
216 float tmp_eul[3];
217
218 mat4_to_loc_quat(r_base_pose->position, tmp_quat, base_pose_object->object_to_world().ptr());
219
220 /* Only use rotation around Z-axis to align view with floor. */
221 quat_to_eul(tmp_eul, tmp_quat);
222 tmp_eul[0] = M_PI_2;
223 tmp_eul[1] = 0;
224 eul_to_quat(r_base_pose->orientation_quat, tmp_eul);
225 }
226 else {
227 copy_v3_fl(r_base_pose->position, 0.0f);
228 axis_angle_to_quat_single(r_base_pose->orientation_quat, 'X', M_PI_2);
229 }
230
231 *r_base_scale = settings->base_scale;
232}
233
234static void wm_xr_session_draw_data_populate(wmXrData *xr_data, wmXrDrawData *r_draw_data)
235{
236 const XrSessionSettings *settings = &xr_data->session_settings;
237
238 memset(r_draw_data, 0, sizeof(*r_draw_data));
239 r_draw_data->xr_data = xr_data;
240 r_draw_data->surface_data = static_cast<wmXrSurfaceData *>(g_xr_surface->customdata);
241
243 wm_xr_session_base_pose_calc(scene, settings, &r_draw_data->base_pose, &r_draw_data->base_scale);
244}
245
247 const wmXrRuntimeData *runtime_data)
248{
249 /* Try to obtain the XR root window (the window the XR session was started in). */
250 wmWindow *xr_win = CTX_wm_window(runtime_data->b_context);
251 if (xr_win && BLI_findindex(&wm->windows, xr_win) != -1) {
252 /* Root XR window is still valid, use it. */
253 return xr_win;
254 }
255 /* Otherwise, fall back. */
256 return wm->windows.first();
257}
258
265
267 const XrSessionSettings *settings)
268{
269 if (state->force_reset_to_base_pose) {
270 return true;
271 }
272 return ((settings->flag & XR_SESSION_USE_POSITION_TRACKING) == 0) &&
273 ((state->prev_base_pose_type != settings->base_pose_type) ||
274 (state->prev_base_pose_object != settings->base_pose_object));
275}
276
278 const XrSessionSettings *settings)
279{
280 if (!state->is_view_data_set) {
282 }
285 }
286
287 const bool position_tracking_toggled = ((state->prev_settings_flag &
290 if (position_tracking_toggled) {
292 }
293
295}
296
298 const XrSessionSettings *settings,
299 const GHOST_XrDrawViewInfo *draw_view,
300 wmXrDrawData *draw_data)
301{
303 const bool use_position_tracking = (settings->flag & XR_SESSION_USE_POSITION_TRACKING);
304
305 switch (event) {
307 if (use_position_tracking) {
308 /* We want to start the session exactly at landmark position.
309 * Run-times may have a non-[0,0,0] starting position that we have to subtract for that. */
310 copy_v3_v3(draw_data->eye_position_ofs, draw_view->local_pose.position);
311 }
312 else {
313 copy_v3_fl(draw_data->eye_position_ofs, 0.0f);
314 }
315 break;
316 /* This should be triggered by the VR add-on if a landmark changes. */
318 if (use_position_tracking) {
319 /* Switch exactly to base pose, so use eye offset to cancel out current position delta. */
320 copy_v3_v3(draw_data->eye_position_ofs, draw_view->local_pose.position);
321 }
322 else {
323 copy_v3_fl(draw_data->eye_position_ofs, 0.0f);
324 }
325 /* Reset navigation. */
328 break;
330 if (use_position_tracking) {
331 /* Keep the current position, and let the user move from there. */
332 copy_v3_v3(draw_data->eye_position_ofs, state->prev_eye_position_ofs);
333 }
334 else {
335 /* Back to the exact base-pose position. */
336 copy_v3_fl(draw_data->eye_position_ofs, 0.0f);
337 }
338 break;
340 /* Keep previous offset when positional tracking is disabled. */
341 copy_v3_v3(draw_data->eye_position_ofs, state->prev_eye_position_ofs);
342 break;
343 }
344}
345
347 const float new_scale,
348 const float prev_scale)
349{
350 /* Calculate view offset from the current navigation origin. */
351 const float3 viewer_location = float3(state->viewer_pose.position);
352 const float3 nav_location = float3(state->nav_pose.position);
353 const float3 viewer_base_offset = (viewer_location - nav_location) / prev_scale;
354
355 const float offset_val = prev_scale - new_scale;
356 const float3 view_scaling_offset = viewer_base_offset * offset_val;
357
358 /* On X/Y axes: Add the scaling offset to maintain relative horizontal world position. */
359 state->nav_pose.position[0] += view_scaling_offset.x;
360 state->nav_pose.position[1] += view_scaling_offset.y;
361 /* On Z axis: Scale proportionally for the scaling change to be visible. */
362 state->nav_pose.position[2] *= new_scale / prev_scale;
363}
364
366 const XrSessionSettings *settings,
367 const Scene *scene)
368{
369 /* Compute the main XR scale, the product of:
370 * - The XR session navigation scale
371 * - The XR settings view scale
372 * - The context scene unit scale
373 */
374
375 if (state->prev_view_scale_setting == 0.0f) {
376 /* First initialization. */
377 state->prev_view_scale_setting = settings->view_scale;
378 }
379
380 /* Unlike Scene and Navigation Scale changes, View Scale setting changes result in viewer
381 * location adjustments to keep the viewer at the same relative world position after scaling. */
382 if (settings->view_scale != state->prev_view_scale_setting) {
384 state, settings->view_scale, state->prev_view_scale_setting);
385 state->prev_view_scale_setting = settings->view_scale;
386 }
387
388 /* Compute XR viewer scale. */
389 const float scene_scale = scene->unit.scale_length;
390 const float new_viewer_scale = state->nav_scale * settings->view_scale * scene_scale;
391
392 /* Set viewer scale and tag XR navigation to be recalculated. */
393 if (assign_if_different(state->viewer_scale, new_viewer_scale)) {
394 state->is_navigation_dirty = true;
395 }
396}
397
399 const wmXrDrawData *draw_data,
400 const GHOST_XrDrawViewInfo *draw_view,
402{
403 GHOST_XrPose viewer_pose;
404 float viewer_mat[4][4], base_mat[4][4], nav_mat[4][4];
405
406 /* Calculate viewer matrix. */
407 copy_qt_qt(viewer_pose.orientation_quat, draw_view->local_pose.orientation_quat);
408 if ((settings->flag & XR_SESSION_USE_POSITION_TRACKING) == 0) {
409 zero_v3(viewer_pose.position);
410 }
411 else {
412 copy_v3_v3(viewer_pose.position, draw_view->local_pose.position);
413 }
414 if ((settings->flag & XR_SESSION_USE_ABSOLUTE_TRACKING) == 0) {
415 sub_v3_v3(viewer_pose.position, draw_data->eye_position_ofs);
416 }
417 wm_xr_pose_to_mat(&viewer_pose, viewer_mat);
418
419 /* Apply base pose and navigation. */
420 wm_xr_pose_scale_to_mat(&draw_data->base_pose, draw_data->base_scale, base_mat);
421 wm_xr_pose_scale_to_mat(&state->nav_pose_last_actions_sync, state->viewer_scale, nav_mat);
422 mul_m4_m4m4(state->viewer_mat_base, base_mat, viewer_mat);
423 mul_m4_m4m4(viewer_mat, nav_mat, state->viewer_mat_base);
424
425 /* Save final viewer pose and viewmat. */
426 mat4_to_loc_quat(state->viewer_pose.position, state->viewer_pose.orientation_quat, viewer_mat);
427 wm_xr_pose_scale_to_imat(&state->viewer_pose,
428 draw_data->base_scale * state->viewer_scale_last_actions_sync,
429 state->viewer_viewmat);
430
431 /* No idea why, but multiplying by two seems to make it match the VR view more. */
432 state->focal_len = 2.0f *
433 fov_to_focallength(draw_view->fov.angle_right - draw_view->fov.angle_left,
435
436 copy_v3_v3(state->prev_eye_position_ofs, draw_data->eye_position_ofs);
437 memcpy(&state->prev_base_pose, &draw_data->base_pose, sizeof(state->prev_base_pose));
438 state->prev_base_scale = draw_data->base_scale;
439 memcpy(&state->prev_local_pose, &draw_view->local_pose, sizeof(state->prev_local_pose));
440 copy_v3_v3(state->prev_eye_position_ofs, draw_data->eye_position_ofs);
441
442 state->prev_settings_flag = settings->flag;
443 state->prev_base_pose_type = settings->base_pose_type;
444 state->prev_base_pose_object = settings->base_pose_object;
445 state->is_view_data_set = true;
446 /* Assume this was already done through wm_xr_session_draw_data_update(). */
447 state->force_reset_to_base_pose = false;
448
449 const bContext *xr_context = WM_xr_session_context_get(draw_data->xr_data);
450
453}
454
456{
457 return xr->runtime ? &xr->runtime->session_state : nullptr;
458}
459
464
466{
467 if (xr->runtime == nullptr) {
468 return nullptr;
469 }
470
471 /* XR session root window. Also sets the context scene. */
473 CTX_wm_window_set(xr->runtime->b_context, xr_win);
474
475 /* `Main` may have been replaced while the session is running (global undo),
476 * in which case only the calling context is updated and this XR context is left dangling.
477 *
478 * This is the inverse of the main-context sync in #wm_event_handle_xrevent(). */
480
481 /* Unique offscreen XR area. */
483
484 /* Region for XR operator execution and modal handling. */
486 CTX_wm_region_set(xr->runtime->b_context, xr_region);
487
488 /* Return for convenience. */
489 return xr->runtime->b_context;
490}
491
493{
494 return xr->runtime ? xr->runtime->b_context : nullptr;
495}
496
497bool WM_xr_session_state_viewer_pose_location_get(const wmXrData *xr, float r_location[3])
498{
500 zero_v3(r_location);
501 return false;
502 }
503
504 copy_v3_v3(r_location, xr->runtime->session_state.viewer_pose.position);
505 return true;
506}
507
508bool WM_xr_session_state_viewer_pose_rotation_get(const wmXrData *xr, float r_rotation[4])
509{
511 unit_qt(r_rotation);
512 return false;
513 }
514
515 copy_v4_v4(r_rotation, xr->runtime->session_state.viewer_pose.orientation_quat);
516 return true;
517}
518
519bool WM_xr_session_state_viewfinder_location_get(const wmXrData *xr, float r_location[3])
520{
522 zero_v3(r_location);
523 return false;
524 }
525
527 return true;
528}
529
531{
533 unit_qt(r_rotation);
534 return false;
535 }
536
538 return true;
539}
540
547
555
562
564 bool *r_dof_enabled)
565{
567 *r_dof_enabled = 0.0f;
568 return false;
569 }
570
572 return true;
573}
574
576{
577 if (WM_xr_session_exists(xr)) {
579 }
580}
581
583{
585 *r_lens_focal = 1.0f;
586 return false;
587 }
588
590 return true;
591}
592
594{
595 if (WM_xr_session_exists(xr)) {
597 }
598}
599
601 float *r_dof_distance)
602{
604 *r_dof_distance = 1.0f;
605 return false;
606 }
607
609 return true;
610}
611
613{
614 if (WM_xr_session_exists(xr)) {
616 }
617}
618
620{
622 *r_dof_fstop = 1.0f;
623 return false;
624 }
625
627 return true;
628}
629
636
638 const wmXrData *xr, bool *r_enabled)
639{
641 *r_enabled = 0.0f;
642 return false;
643 }
644
646 return true;
647}
648
656
658{
660 *r_mode = static_cast<eXrViewfinderMode>(0);
661 return false;
662 }
663
665 return true;
666}
667
674
676 eXrViewfinderLiveAction *r_action)
677{
679 *r_action = static_cast<eXrViewfinderLiveAction>(0);
680 return false;
681 }
682
684 return true;
685}
686
695 const wmXrData *xr, eXrViewfinderPlaybackAction *r_action)
696{
698 *r_action = static_cast<eXrViewfinderPlaybackAction>(0);
699 return false;
700 }
701
703 return true;
704}
712
715{
717 *r_action = static_cast<eXrViewfinderConfirmAction>(0);
718 return false;
719 }
720
722 return true;
723}
724
732
734 float r_viewmat[4][4],
735 float *r_focal_len)
736{
738 unit_m4(r_viewmat);
739 *r_focal_len = 0.0f;
740 return false;
741 }
742
744 *r_focal_len = xr->runtime->session_state.focal_len;
745
746 return true;
747}
748
750 uint subaction_idx,
751 float r_location[3])
752{
754 (subaction_idx >= xr->runtime->session_state.controllers.count()))
755 {
756 zero_v3(r_location);
757 return false;
758 }
759
760 const wmXrController *controller = static_cast<const wmXrController *>(
761 BLI_findlink(&xr->runtime->session_state.controllers, subaction_idx));
762 BLI_assert(controller);
763 copy_v3_v3(r_location, controller->grip_pose.position);
764 return true;
765}
766
768 uint subaction_idx,
769 float r_rotation[4])
770{
772 (subaction_idx >= xr->runtime->session_state.controllers.count()))
773 {
774 unit_qt(r_rotation);
775 return false;
776 }
777
778 const wmXrController *controller = static_cast<const wmXrController *>(
779 BLI_findlink(&xr->runtime->session_state.controllers, subaction_idx));
780 BLI_assert(controller);
781 copy_qt_qt(r_rotation, controller->grip_pose.orientation_quat);
782 return true;
783}
784
786 uint subaction_idx,
787 float r_location[3])
788{
790 (subaction_idx >= xr->runtime->session_state.controllers.count()))
791 {
792 zero_v3(r_location);
793 return false;
794 }
795
796 const wmXrController *controller = static_cast<const wmXrController *>(
797 BLI_findlink(&xr->runtime->session_state.controllers, subaction_idx));
798 BLI_assert(controller);
799 copy_v3_v3(r_location, controller->aim_pose.position);
800 return true;
801}
802
804 uint subaction_idx,
805 float r_rotation[4])
806{
808 (subaction_idx >= xr->runtime->session_state.controllers.count()))
809 {
810 unit_qt(r_rotation);
811 return false;
812 }
813
814 const wmXrController *controller = static_cast<const wmXrController *>(
815 BLI_findlink(&xr->runtime->session_state.controllers, subaction_idx));
816 BLI_assert(controller);
817 copy_qt_qt(r_rotation, controller->aim_pose.orientation_quat);
818 return true;
819}
820
821bool WM_xr_session_state_nav_location_get(const wmXrData *xr, float r_location[3])
822{
824 zero_v3(r_location);
825 return false;
826 }
827
828 copy_v3_v3(r_location, xr->runtime->session_state.nav_pose.position);
829 return true;
830}
831
832void WM_xr_session_state_nav_location_set(wmXrData *xr, const float location[3])
833{
834 if (WM_xr_session_exists(xr)) {
835 copy_v3_v3(xr->runtime->session_state.nav_pose.position, location);
837 }
838}
839
840bool WM_xr_session_state_nav_rotation_get(const wmXrData *xr, float r_rotation[4])
841{
843 unit_qt(r_rotation);
844 return false;
845 }
846
847 copy_qt_qt(r_rotation, xr->runtime->session_state.nav_pose.orientation_quat);
848 return true;
849}
850
851void WM_xr_session_state_nav_rotation_set(wmXrData *xr, const float rotation[4])
852{
853 if (WM_xr_session_exists(xr)) {
854 BLI_ASSERT_UNIT_QUAT(rotation);
855 copy_qt_qt(xr->runtime->session_state.nav_pose.orientation_quat, rotation);
857 }
858}
859
860bool WM_xr_session_state_nav_scale_get(const wmXrData *xr, float *r_scale)
861{
863 *r_scale = 1.0f;
864 return false;
865 }
866
867 *r_scale = xr->runtime->session_state.nav_scale;
868 return true;
869}
870
872{
873 if (WM_xr_session_exists(xr)) {
874 /* Clamp to reasonable values. */
878 }
879}
880
881bool WM_xr_session_state_viewer_scale_get(const wmXrData *xr, float *r_scale)
882{
884 *r_scale = 1.0f;
885 return false;
886 }
887
888 *r_scale = xr->runtime->session_state.viewer_scale;
889 return true;
890}
891
893{
894 zero_v3(state->nav_pose.position);
895 unit_qt(state->nav_pose.orientation_quat);
896 state->nav_scale = 1.0f;
897 state->viewer_scale = 1.0f;
898 state->is_navigation_dirty = true;
899 state->swap_hands = false;
900}
901
903{
904 /* Create a Camera data ID to override the View3D camera (for setting parameters such as DoF).
905 * This ID is freed in #wm_xr_session_data_free. */
906 state->viewfinder.render_cam_data_id = BKE_id_new_nomain<Camera>("ViewfinderCamera");
907
908 /* Create a Camera logo texture to draw on the backside of the viewfinder. */
909 ImBuf *ibuf = ui::svg_icon_bitmap(ICON_RESTRICT_RENDER_OFF, 256.0f, false);
910 if (ibuf) {
914 state->viewfinder.backside_logo_texture = IMB_create_gpu_texture(
915 "viewfinder_backside_logo", ibuf, flags);
916 IMB_freeImBuf(ibuf);
917 }
918
919 /* Create the offscreen framebuffer and viewport used to draw the Viewfinder view texture. */
922 true,
923 gpu::TextureFormat::UNORM_8_8_8_8,
925 false,
926 nullptr);
927 state->viewfinder.viewport = GPU_viewport_create();
928}
929
931{
932 /* Runtime values. */
933 state->viewfinder.smoothing_delta_t = 0.0;
934 state->viewfinder.last_flash_trigger_time = 0.0;
935 state->viewfinder.last_focus_hit_time = 0.0;
936 state->viewfinder.last_focus_hit_success = false;
937
938 /* Capture settings. */
939 state->viewfinder.capture_dof_enabled = false;
940 state->viewfinder.capture_lens_focal = 50.0f;
941 state->viewfinder.capture_dof_fstop = 2.8f;
942 state->viewfinder.capture_dof_distance = 10.0f;
943
944 /* Playback settings. */
945 state->viewfinder.playback_show_active_capture_in_space_enabled = true;
946
947 /* Active modes. */
948 state->viewfinder.active_mode = XR_VIEWFINDER_MODE_LIVE;
949 state->viewfinder.active_action_live = XR_VIEWFINDER_ACTION_LIVE_LENS;
950 state->viewfinder.active_action_playback = XR_VIEWFINDER_ACTION_PB_BROWSE;
951}
952
954{
955 if (WM_xr_session_exists(xr)) {
956 const float intensity_pref = U.xr_navigation.vignette_intensity * 0.01f; /* 0.0 -> 1.0f. */
957
958 constexpr float min_aperture = M_SQRT1_2; /* Intensity at 0%, aperture out of view square. */
959 constexpr float max_aperture = 0.0f; /* Intensity at 100%, aperture fully closed. */
960
961 const float initial_aperture = interpf(max_aperture, min_aperture, intensity_pref);
962
964 state->vignette_aperture = min_ff(state->vignette_aperture, initial_aperture);
965 }
966}
967
969{
970 const double current_time = BLI_time_now_seconds();
971 const double delta_time = current_time - state->vignette_last_update_time;
972 constexpr float aperture_velocity_per_second = 0.3f;
973
974 /* Aperture fully opened at 1.0f, and fully closed at 0.0f. */
975 const float aperture_delta = float(delta_time) * aperture_velocity_per_second;
976 state->vignette_aperture = clamp_f(state->vignette_aperture + aperture_delta, 0.0f, 1.0f);
977 state->vignette_last_update_time = current_time;
978}
979
980/* -------------------------------------------------------------------- */
986
988{
989 if (!xr->runtime) {
990 return;
991 }
992
994}
995
996static void wm_xr_session_controller_pose_calc(const GHOST_XrPose *raw_pose,
997 const float view_ofs[3],
998 const float base_mat[4][4],
999 const float nav_mat[4][4],
1000 GHOST_XrPose *r_pose,
1001 float r_mat[4][4],
1002 float r_mat_base[4][4])
1003{
1004 float m[4][4];
1005 /* Calculate controller matrix in world space. */
1006 wm_xr_pose_to_mat(raw_pose, m);
1007
1008 /* Apply eye position offset. */
1009 sub_v3_v3(m[3], view_ofs);
1010
1011 /* Apply base pose and navigation. */
1012 mul_m4_m4m4(r_mat_base, base_mat, m);
1013 mul_m4_m4m4(r_mat, nav_mat, r_mat_base);
1014
1015 /* Save final pose. */
1016 mat4_to_loc_quat(r_pose->position, r_pose->orientation_quat, r_mat);
1017}
1018
1020 const wmXrAction *grip_action,
1021 const wmXrAction *aim_action,
1022 GHOST_IXrContext *xr_context,
1024{
1025 BLI_assert(grip_action->count_subaction_paths == aim_action->count_subaction_paths);
1026 BLI_assert(grip_action->count_subaction_paths == state->controllers.count());
1027
1028 float view_ofs[3], base_mat[4][4], nav_mat[4][4];
1029
1030 if ((settings->flag & XR_SESSION_USE_POSITION_TRACKING) == 0) {
1031 copy_v3_v3(view_ofs, state->prev_local_pose.position);
1032 }
1033 else {
1034 zero_v3(view_ofs);
1035 }
1036 if ((settings->flag & XR_SESSION_USE_ABSOLUTE_TRACKING) == 0) {
1037 add_v3_v3(view_ofs, state->prev_eye_position_ofs);
1038 }
1039
1040 wm_xr_pose_scale_to_mat(&state->prev_base_pose, state->prev_base_scale, base_mat);
1041 wm_xr_pose_scale_to_mat(&state->nav_pose, state->viewer_scale, nav_mat);
1042
1043 for (auto [subaction_idx, controller] : state->controllers.enumerate()) {
1044 controller.grip_active = ((GHOST_XrPose *)grip_action->states)[subaction_idx].is_active;
1045 wm_xr_session_controller_pose_calc(&((GHOST_XrPose *)grip_action->states)[subaction_idx],
1046 view_ofs,
1047 base_mat,
1048 nav_mat,
1049 &controller.grip_pose,
1050 controller.grip_mat,
1051 controller.grip_mat_base);
1052 controller.aim_active = ((GHOST_XrPose *)aim_action->states)[subaction_idx].is_active;
1053 wm_xr_session_controller_pose_calc(&((GHOST_XrPose *)aim_action->states)[subaction_idx],
1054 view_ofs,
1055 base_mat,
1056 nav_mat,
1057 &controller.aim_pose,
1058 controller.aim_mat,
1059 controller.aim_mat_base);
1060
1061 if (!controller.model) {
1062 /* Notify GHOST to load/continue loading the controller model data. This can be called more
1063 * than once since the model may not be available from the runtime yet. The batch itself will
1064 * be created in wm_xr_draw_controllers(). */
1065 GHOST_XrLoadControllerModel(xr_context, controller.subaction_path);
1066 }
1067 else {
1068 GHOST_XrUpdateControllerModelComponents(xr_context, controller.subaction_path);
1069 }
1070 }
1071}
1072
1074 const char *subaction_path)
1075{
1076 const wmXrController *controller = static_cast<const wmXrController *>(BLI_findstring(
1077 &state->controllers, subaction_path, offsetof(wmXrController, subaction_path)));
1078 return controller ? &controller->aim_pose : nullptr;
1079}
1080
1081BLI_INLINE bool test_float_state(const float *state, float threshold, eXrAxisFlag flag)
1082{
1083 if ((flag & XR_AXIS0_POS) != 0) {
1084 if (*state > threshold) {
1085 return true;
1086 }
1087 }
1088 else if ((flag & XR_AXIS0_NEG) != 0) {
1089 if (*state < -threshold) {
1090 return true;
1091 }
1092 }
1093 else {
1094 if (fabsf(*state) > threshold) {
1095 return true;
1096 }
1097 }
1098 return false;
1099}
1100
1101BLI_INLINE bool test_vec2f_state(const float state[2], float threshold, eXrAxisFlag flag)
1102{
1103 if ((flag & XR_AXIS0_POS) != 0) {
1104 if (state[0] < 0.0f) {
1105 return false;
1106 }
1107 }
1108 else if ((flag & XR_AXIS0_NEG) != 0) {
1109 if (state[0] > 0.0f) {
1110 return false;
1111 }
1112 }
1113 if ((flag & XR_AXIS1_POS) != 0) {
1114 if (state[1] < 0.0f) {
1115 return false;
1116 }
1117 }
1118 else if ((flag & XR_AXIS1_NEG) != 0) {
1119 if (state[1] > 0.0f) {
1120 return false;
1121 }
1122 }
1123 return (len_v2(state) > threshold);
1124}
1125
1126static bool wm_xr_session_modal_action_test(const ListBaseT<LinkData> *active_modal_actions,
1127 const wmXrAction *action,
1128 bool *r_found)
1129{
1130 if (r_found) {
1131 *r_found = false;
1132 }
1133
1134 for (LinkData &ld : *active_modal_actions) {
1135 wmXrAction *active_modal_action = static_cast<wmXrAction *>(ld.data);
1136 if (action == active_modal_action) {
1137 if (r_found) {
1138 *r_found = true;
1139 }
1140 return true;
1141 }
1142 if (action->ot == active_modal_action->ot &&
1143 IDP_EqualsProperties(action->op_properties, active_modal_action->op_properties))
1144 {
1145 /* Don't allow duplicate modal operators since this can lead to unwanted modal handler
1146 * behavior. */
1147 return false;
1148 }
1149 }
1150
1151 return true;
1152}
1153
1154static void wm_xr_session_modal_action_test_add(ListBaseT<LinkData> *active_modal_actions,
1155 const wmXrAction *action)
1156{
1157 bool found;
1158 if (wm_xr_session_modal_action_test(active_modal_actions, action, &found) && !found) {
1159 LinkData *ld = MEM_new_zeroed<LinkData>(__func__);
1160 ld->data = const_cast<wmXrAction *>(action);
1161 BLI_addtail(active_modal_actions, ld);
1162 }
1163}
1164
1165static void wm_xr_session_modal_action_remove(ListBaseT<LinkData> *active_modal_actions,
1166 const wmXrAction *action)
1167{
1168 for (LinkData &ld : *active_modal_actions) {
1169 if (action == ld.data) {
1170 BLI_freelinkN(active_modal_actions, &ld);
1171 return;
1172 }
1173 }
1174}
1175
1177 ListBaseT<wmXrHapticAction> *active_haptic_actions,
1178 const wmXrAction *action,
1179 const char *subaction_path)
1180{
1181 for (wmXrHapticAction &ha : *active_haptic_actions) {
1182 if ((action == ha.action) && (subaction_path == ha.subaction_path)) {
1183 return &ha;
1184 }
1185 }
1186 return nullptr;
1187}
1188
1189static void wm_xr_session_haptic_action_add(ListBaseT<wmXrHapticAction> *active_haptic_actions,
1190 const wmXrAction *action,
1191 const char *subaction_path,
1192 int64_t time_now)
1193{
1195 active_haptic_actions, action, subaction_path);
1196 if (ha) {
1197 /* Reset start time since OpenXR restarts haptics if they are already active. */
1198 ha->time_start = time_now;
1199 }
1200 else {
1201 ha = MEM_new_zeroed<wmXrHapticAction>(__func__);
1202 ha->action = const_cast<wmXrAction *>(action);
1203 ha->subaction_path = subaction_path;
1204 ha->time_start = time_now;
1205 BLI_addtail(active_haptic_actions, ha);
1206 }
1207}
1208
1209static void wm_xr_session_haptic_action_remove(ListBaseT<wmXrHapticAction> *active_haptic_actions,
1210 const wmXrAction *action)
1211{
1212 for (wmXrHapticAction &ha : *active_haptic_actions) {
1213 if (action == ha.action) {
1214 BLI_freelinkN(active_haptic_actions, &ha);
1215 return;
1216 }
1217 }
1218}
1219
1220static void wm_xr_session_haptic_timers_check(ListBaseT<wmXrHapticAction> *active_haptic_actions,
1221 int64_t time_now)
1222{
1223 for (wmXrHapticAction &ha : active_haptic_actions->items_mutable()) {
1224 if (time_now - ha.time_start >= ha.action->haptic_duration) {
1225 BLI_freelinkN(active_haptic_actions, &ha);
1226 }
1227 }
1228}
1229
1231 wmXrData *xr,
1232 const char *action_set_name,
1233 wmXrAction *action,
1234 uint subaction_idx,
1235 ListBaseT<LinkData> *active_modal_actions,
1236 ListBaseT<wmXrHapticAction> *active_haptic_actions,
1237 int64_t time_now,
1238 bool modal,
1239 bool haptic,
1240 short *r_val)
1241{
1242 const char *haptic_subaction_path = ((action->haptic_flag & XR_HAPTIC_MATCHUSERPATHS) != 0) ?
1243 action->subaction_paths[subaction_idx] :
1244 nullptr;
1245 bool curr = false;
1246 bool prev = false;
1247
1248 switch (action->type) {
1249 case XR_BOOLEAN_INPUT: {
1250 const bool *state = &(static_cast<bool *>(action->states))[subaction_idx];
1251 bool *state_prev = &(static_cast<bool *>(action->states_prev))[subaction_idx];
1252 if (*state) {
1253 curr = true;
1254 }
1255 if (*state_prev) {
1256 prev = true;
1257 }
1258 *state_prev = *state;
1259 break;
1260 }
1261 case XR_FLOAT_INPUT: {
1262 const float *state = &(static_cast<float *>(action->states))[subaction_idx];
1263 float *state_prev = &(static_cast<float *>(action->states_prev))[subaction_idx];
1264 if (test_float_state(
1265 state, action->float_thresholds[subaction_idx], action->axis_flags[subaction_idx]))
1266 {
1267 curr = true;
1268 }
1269 if (test_float_state(state_prev,
1270 action->float_thresholds[subaction_idx],
1271 action->axis_flags[subaction_idx]))
1272 {
1273 prev = true;
1274 }
1275 *state_prev = *state;
1276 break;
1277 }
1278 case XR_VECTOR2F_INPUT: {
1279 const float (*state)[2] = &(static_cast<float (*)[2]>(action->states))[subaction_idx];
1280 float (*state_prev)[2] = &(static_cast<float (*)[2]>(action->states_prev))[subaction_idx];
1281 if (test_vec2f_state(
1282 *state, action->float_thresholds[subaction_idx], action->axis_flags[subaction_idx]))
1283 {
1284 curr = true;
1285 }
1286 if (test_vec2f_state(*state_prev,
1287 action->float_thresholds[subaction_idx],
1288 action->axis_flags[subaction_idx]))
1289 {
1290 prev = true;
1291 }
1292 copy_v2_v2(*state_prev, *state);
1293 break;
1294 }
1295 case XR_POSE_INPUT:
1298 break;
1299 }
1300
1301 if (curr) {
1302 if (!prev) {
1303 if (modal || (action->op_flag == XR_OP_PRESS)) {
1304 *r_val = KM_PRESS;
1305 }
1306 if (haptic && (action->haptic_flag & (XR_HAPTIC_PRESS | XR_HAPTIC_REPEAT)) != 0) {
1307 /* Apply haptics. */
1309 action_set_name,
1310 action->haptic_name,
1311 haptic_subaction_path,
1312 &action->haptic_duration,
1313 &action->haptic_frequency,
1314 &action->haptic_amplitude))
1315 {
1317 active_haptic_actions, action, haptic_subaction_path, time_now);
1318 }
1319 }
1320 }
1321 else if (modal) {
1322 *r_val = KM_PRESS;
1323 }
1324 if (modal && !action->active_modal_path) {
1325 /* Set active modal path. */
1326 action->active_modal_path = action->subaction_paths[subaction_idx];
1327 /* Add to active modal actions. */
1328 wm_xr_session_modal_action_test_add(active_modal_actions, action);
1329 }
1330 if (haptic && ((action->haptic_flag & XR_HAPTIC_REPEAT) != 0)) {
1331 if (!wm_xr_session_haptic_action_find(active_haptic_actions, action, haptic_subaction_path))
1332 {
1333 /* Apply haptics. */
1335 action_set_name,
1336 action->haptic_name,
1337 haptic_subaction_path,
1338 &action->haptic_duration,
1339 &action->haptic_frequency,
1340 &action->haptic_amplitude))
1341 {
1343 active_haptic_actions, action, haptic_subaction_path, time_now);
1344 }
1345 }
1346 }
1347 }
1348 else if (prev) {
1349 if (modal || (action->op_flag == XR_OP_RELEASE)) {
1350 *r_val = KM_RELEASE;
1351 if (modal && (action->subaction_paths[subaction_idx] == action->active_modal_path)) {
1352 /* Unset active modal path. */
1353 action->active_modal_path = nullptr;
1354 /* Remove from active modal actions. */
1355 wm_xr_session_modal_action_remove(active_modal_actions, action);
1356 }
1357 }
1358 if (haptic) {
1359 if ((action->haptic_flag & XR_HAPTIC_RELEASE) != 0) {
1360 /* Apply haptics. */
1362 action_set_name,
1363 action->haptic_name,
1364 haptic_subaction_path,
1365 &action->haptic_duration,
1366 &action->haptic_frequency,
1367 &action->haptic_amplitude))
1368 {
1370 active_haptic_actions, action, haptic_subaction_path, time_now);
1371 }
1372 }
1373 else if ((action->haptic_flag & XR_HAPTIC_REPEAT) != 0) {
1374 /* Stop any active haptics. */
1375 WM_xr_haptic_action_stop(xr, action_set_name, action->haptic_name, haptic_subaction_path);
1376 wm_xr_session_haptic_action_remove(active_haptic_actions, action);
1377 }
1378 }
1379 }
1380}
1381
1383 wmXrAction *action,
1384 uint subaction_idx,
1385 uint *r_subaction_idx_other,
1386 const GHOST_XrPose **r_aim_pose_other)
1387{
1388 if ((action->action_flag & XR_ACTION_BIMANUAL) == 0) {
1389 return false;
1390 }
1391
1392 bool bimanual = false;
1393
1394 *r_subaction_idx_other = (subaction_idx == 0) ?
1395 uint(min_ii(1, action->count_subaction_paths - 1)) :
1396 0;
1397
1398 switch (action->type) {
1399 case XR_BOOLEAN_INPUT: {
1400 const bool *state = &(static_cast<bool *>(action->states))[*r_subaction_idx_other];
1401 if (*state) {
1402 bimanual = true;
1403 }
1404 break;
1405 }
1406 case XR_FLOAT_INPUT: {
1407 const float *state = &(static_cast<float *>(action->states))[*r_subaction_idx_other];
1409 action->float_thresholds[*r_subaction_idx_other],
1410 action->axis_flags[*r_subaction_idx_other]))
1411 {
1412 bimanual = true;
1413 }
1414 break;
1415 }
1416 case XR_VECTOR2F_INPUT: {
1417 const float (*state)[2] = &(
1418 static_cast<float (*)[2]>(action->states))[*r_subaction_idx_other];
1420 action->float_thresholds[*r_subaction_idx_other],
1421 action->axis_flags[*r_subaction_idx_other]))
1422 {
1423 bimanual = true;
1424 }
1425 break;
1426 }
1427 case XR_POSE_INPUT:
1430 break;
1431 }
1432
1433 if (bimanual) {
1434 *r_aim_pose_other = wm_xr_session_controller_aim_pose_find(
1435 session_state, action->subaction_paths[*r_subaction_idx_other]);
1436 }
1437
1438 return bimanual;
1439}
1440
1441static wmXrActionData *wm_xr_session_event_create(const char *action_set_name,
1442 const wmXrAction *action,
1443 const GHOST_XrPose *controller_aim_pose,
1444 const GHOST_XrPose *controller_aim_pose_other,
1445 uint subaction_idx,
1446 uint subaction_idx_other,
1447 bool bimanual)
1448{
1449 wmXrActionData *data = MEM_new_zeroed<wmXrActionData>(__func__);
1450 STRNCPY(data->action_set, action_set_name);
1451 STRNCPY(data->action, action->name);
1452 STRNCPY(data->user_path, action->subaction_paths[subaction_idx]);
1453 if (bimanual) {
1454 STRNCPY(data->user_path_other, action->subaction_paths[subaction_idx_other]);
1455 }
1456 data->type = action->type;
1457
1458 switch (action->type) {
1459 case XR_BOOLEAN_INPUT:
1460 data->state[0] = (static_cast<bool *>(action->states))[subaction_idx] ? 1.0f : 0.0f;
1461 if (bimanual) {
1462 data->state_other[0] = (static_cast<bool *>(action->states))[subaction_idx_other] ? 1.0f :
1463 0.0f;
1464 }
1465 break;
1466 case XR_FLOAT_INPUT:
1467 data->state[0] = (static_cast<float *>(action->states))[subaction_idx];
1468 if (bimanual) {
1469 data->state_other[0] = (static_cast<float *>(action->states))[subaction_idx_other];
1470 }
1471 data->float_threshold = action->float_thresholds[subaction_idx];
1472 break;
1473 case XR_VECTOR2F_INPUT:
1474 copy_v2_v2(data->state, (static_cast<float (*)[2]>(action->states))[subaction_idx]);
1475 if (bimanual) {
1476 copy_v2_v2(data->state_other,
1477 (static_cast<float (*)[2]>(action->states))[subaction_idx_other]);
1478 }
1479 data->float_threshold = action->float_thresholds[subaction_idx];
1480 break;
1481 case XR_POSE_INPUT:
1484 break;
1485 }
1486
1487 if (controller_aim_pose) {
1488 copy_v3_v3(data->controller_loc, controller_aim_pose->position);
1489 copy_qt_qt(data->controller_rot, controller_aim_pose->orientation_quat);
1490
1491 if (bimanual && controller_aim_pose_other) {
1492 copy_v3_v3(data->controller_loc_other, controller_aim_pose_other->position);
1493 copy_qt_qt(data->controller_rot_other, controller_aim_pose_other->orientation_quat);
1494 }
1495 else {
1496 data->controller_rot_other[0] = 1.0f;
1497 }
1498 }
1499 else {
1500 data->controller_rot[0] = 1.0f;
1501 data->controller_rot_other[0] = 1.0f;
1502 }
1503
1504 data->ot = action->ot;
1505 data->op_properties = action->op_properties;
1506
1507 data->bimanual = bimanual;
1508
1509 return data;
1510}
1511
1512/* Dispatch events to window queues. */
1514 GHOST_IXrContext *xr_context,
1515 wmXrActionSet *action_set,
1516 wmXrSessionState *session_state,
1517 wmWindow *win)
1518{
1519 const char *action_set_name = action_set->name;
1520
1521 const uint count = GHOST_XrGetActionCount(xr_context, action_set_name);
1522 if (count < 1) {
1523 return;
1524 }
1525
1526 const int64_t time_now = int64_t(BLI_time_now_seconds() * 1000);
1527
1528 ListBaseT<LinkData> *active_modal_actions = &action_set->active_modal_actions;
1529 ListBaseT<wmXrHapticAction> *active_haptic_actions = &action_set->active_haptic_actions;
1530
1531 wmXrAction **actions = MEM_new_array_zeroed<wmXrAction *>(count, __func__);
1532
1534 xr_context, action_set_name, reinterpret_cast<void **>(actions));
1535
1536 /* Check haptic action timers. */
1537 wm_xr_session_haptic_timers_check(active_haptic_actions, time_now);
1538
1539 for (uint action_idx = 0; action_idx < count; ++action_idx) {
1540 wmXrAction *action = actions[action_idx];
1541 if (action && action->ot) {
1542 const bool modal = action->ot->modal;
1543 const bool haptic = (GHOST_XrGetActionCustomdata(
1544 xr_context, action_set_name, action->haptic_name) != nullptr);
1545
1546 for (uint subaction_idx = 0; subaction_idx < action->count_subaction_paths; ++subaction_idx)
1547 {
1548 short val = KM_NOTHING;
1549
1550 /* Interpret action states (update modal/haptic action lists, apply haptics, etc). */
1552 action_set_name,
1553 action,
1554 subaction_idx,
1555 active_modal_actions,
1556 active_haptic_actions,
1557 time_now,
1558 modal,
1559 haptic,
1560 &val);
1561
1562 const bool is_active_modal_action = wm_xr_session_modal_action_test(
1563 active_modal_actions, action, nullptr);
1564 const bool is_active_modal_subaction = (!action->active_modal_path ||
1565 (action->subaction_paths[subaction_idx] ==
1566 action->active_modal_path));
1567
1568 if ((val != KM_NOTHING) &&
1569 (!modal || (is_active_modal_action && is_active_modal_subaction)))
1570 {
1571 const GHOST_XrPose *aim_pose = wm_xr_session_controller_aim_pose_find(
1572 session_state, action->subaction_paths[subaction_idx]);
1573 const GHOST_XrPose *aim_pose_other = nullptr;
1574 uint subaction_idx_other = 0;
1575
1576 /* Test for bimanual interaction. */
1577 const bool bimanual = wm_xr_session_action_test_bimanual(
1578 session_state, action, subaction_idx, &subaction_idx_other, &aim_pose_other);
1579
1580 wmXrActionData *actiondata = wm_xr_session_event_create(action_set_name,
1581 action,
1582 aim_pose,
1583 aim_pose_other,
1584 subaction_idx,
1585 subaction_idx_other,
1586 bimanual);
1587 wm_event_add_xrevent(win, actiondata, val);
1588 }
1589 }
1590 }
1591 }
1592
1593 MEM_delete(actions);
1594}
1595
1597{
1598 wmXrData *xr = &wm->xr;
1599 if (!xr->runtime) {
1600 return;
1601 }
1602
1603 XrSessionSettings *settings = &xr->session_settings;
1604 GHOST_IXrContext *ghost_xr_context = xr->runtime->ghost_context;
1606
1607 if (state->is_navigation_dirty) {
1608 memcpy(&state->nav_pose_last_actions_sync, &state->nav_pose, sizeof(state->nav_pose));
1609 state->viewer_scale_last_actions_sync = state->viewer_scale;
1610 state->is_navigation_dirty = false;
1611
1612 /* Update viewer pose with any navigation changes since the last actions sync so that data
1613 * is correct for queries. */
1614 float m[4][4], viewer_mat[4][4];
1615 wm_xr_pose_scale_to_mat(&state->nav_pose, state->viewer_scale, m);
1616 mul_m4_m4m4(viewer_mat, m, state->viewer_mat_base);
1617 mat4_to_loc_quat(state->viewer_pose.position, state->viewer_pose.orientation_quat, viewer_mat);
1619 &state->viewer_pose, settings->base_scale * state->viewer_scale, state->viewer_viewmat);
1620 }
1621
1622 /* Set active action set if requested previously. */
1623 if (state->active_action_set_next[0]) {
1624 WM_xr_active_action_set_set(xr, state->active_action_set_next, false);
1625 state->active_action_set_next[0] = '\0';
1626 }
1627 wmXrActionSet *active_action_set = state->active_action_set;
1628
1629 const bool synced = GHOST_XrSyncActions(ghost_xr_context,
1630 active_action_set ? active_action_set->name : nullptr);
1631 if (!synced) {
1632 return;
1633 }
1634
1635 /* Only update controller data and dispatch events for active action set. */
1636 if (active_action_set) {
1637 if (active_action_set->controller_grip_action && active_action_set->controller_aim_action) {
1639 active_action_set->controller_grip_action,
1640 active_action_set->controller_aim_action,
1641 ghost_xr_context,
1642 state);
1643 }
1644
1645 /* Set XR offscreen area View3D object type flags for operators. */
1646 bContext *xr_context = WM_xr_session_context_ensure(xr, wm);
1647 ScrArea *xr_offscreen_area = CTX_wm_area(xr_context);
1648
1649 View3D *v3d = static_cast<View3D *>(xr_offscreen_area->spacedata.first_);
1652
1654 wm_xr_session_events_dispatch(xr, ghost_xr_context, active_action_set, state, xr_win);
1655 }
1656}
1657
1659 const wmXrAction *aim_action,
1660 wmXrData *xr)
1661{
1662 UNUSED_VARS(aim_action); /* Only used for asserts. */
1663
1665 ListBaseT<wmXrController> *controllers = &state->controllers;
1666
1667 BLI_assert(grip_action->count_subaction_paths == aim_action->count_subaction_paths);
1668 const uint count = grip_action->count_subaction_paths;
1669
1671
1672 for (uint i = 0; i < count; ++i) {
1673 wmXrController *controller = MEM_new_zeroed<wmXrController>(__func__);
1674
1675 BLI_assert(STREQ(grip_action->subaction_paths[i], aim_action->subaction_paths[i]));
1676 STRNCPY(controller->subaction_path, grip_action->subaction_paths[i]);
1677
1678 BLI_addtail(controllers, controller);
1679 }
1680
1681 /* Activate draw callback. */
1682 if (g_xr_surface) {
1683 wmXrSurfaceData *surface_data = static_cast<wmXrSurfaceData *>(g_xr_surface->customdata);
1684 if (surface_data && !surface_data->controller_draw_handle) {
1685 if (surface_data->controller_art) {
1688 }
1689 }
1690 }
1691}
1692
1694{
1696
1697 /* Deactivate draw callback. */
1698 if (g_xr_surface) {
1699 wmXrSurfaceData *surface_data = static_cast<wmXrSurfaceData *>(g_xr_surface->customdata);
1700 if (surface_data && surface_data->controller_draw_handle) {
1701 if (surface_data->controller_art) {
1702 ED_region_draw_cb_exit(surface_data->controller_art, surface_data->controller_draw_handle);
1703 }
1704 surface_data->controller_draw_handle = nullptr;
1705 }
1706 }
1707}
1708 /* XR-Session Actions. */
1710
1711/* -------------------------------------------------------------------- */
1718
1727{
1729 wmXrDrawData draw_data;
1730
1731 if (!WM_xr_session_is_ready(&wm->xr)) {
1732 return;
1733 }
1734
1736 wm_xr_session_draw_data_populate(&wm->xr, &draw_data);
1737
1738 GHOST_XrSessionDrawViews(wm->xr.runtime->ghost_context, &draw_data);
1739
1740 /* There's no active frame-buffer if the session was canceled (exception while drawing views). */
1743 }
1744}
1745
1747{
1749
1750 if (!WM_xr_session_is_ready(&wm->xr)) {
1751 return;
1752 }
1753
1754 bContext *xr_context = WM_xr_session_context_ensure(&wm->xr, wm);
1756}
1757
1759 const GHOST_XrDrawViewInfo *draw_view)
1760{
1761 wmXrViewportPair *vp = nullptr;
1762 if (draw_view->view_idx >= surface_data->viewports.count()) {
1763 vp = MEM_new_zeroed<wmXrViewportPair>(__func__);
1764 BLI_addtail(&surface_data->viewports, vp);
1765 }
1766 else {
1767 vp = static_cast<wmXrViewportPair *>(
1768 BLI_findlink(&surface_data->viewports, draw_view->view_idx));
1769 }
1770 BLI_assert(vp);
1771
1772 GPUOffScreen *offscreen = vp->offscreen;
1773 GPUViewport *viewport = vp->viewport;
1774 const bool size_changed = offscreen && (GPU_offscreen_width(offscreen) != draw_view->width) &&
1775 (GPU_offscreen_height(offscreen) != draw_view->height);
1776 if (offscreen) {
1777 BLI_assert(viewport);
1778
1779 if (!size_changed) {
1780 return true;
1781 }
1782 GPU_viewport_free(viewport);
1783 GPU_offscreen_free(offscreen);
1784 }
1785
1786 char err_out[256] = "unknown";
1787 bool failure = false;
1788
1789 /* Initialize with some unsupported format to check following switch statement. */
1790 gpu::TextureFormat format = gpu::TextureFormat::UNORM_8;
1791
1792 switch (draw_view->swapchain_format) {
1793 case GHOST_kXrSwapchainFormatRGBA8:
1794 format = gpu::TextureFormat::UNORM_8_8_8_8;
1795 break;
1796 case GHOST_kXrSwapchainFormatRGBA16:
1797 format = gpu::TextureFormat::UNORM_16_16_16_16;
1798 break;
1799 case GHOST_kXrSwapchainFormatRGBA16F:
1800 format = gpu::TextureFormat::SFLOAT_16_16_16_16;
1801 break;
1802 case GHOST_kXrSwapchainFormatRGB10_A2:
1803 format = gpu::TextureFormat::UNORM_10_10_10_2;
1804 break;
1805 }
1806 BLI_assert(format != gpu::TextureFormat::UNORM_8);
1807
1808 offscreen = vp->offscreen = GPU_offscreen_create(draw_view->width,
1809 draw_view->height,
1810 true,
1811 format,
1814 false,
1815 err_out);
1816 if (offscreen) {
1817 viewport = vp->viewport = GPU_viewport_create();
1818 if (!viewport) {
1819 GPU_offscreen_free(offscreen);
1820 offscreen = vp->offscreen = nullptr;
1821 failure = true;
1822 }
1823 }
1824 else {
1825 failure = true;
1826 }
1827
1828 if (failure) {
1829 CLOG_ERROR(&LOG, "Failed to get buffer, %s", err_out);
1830 return false;
1831 }
1832
1833 return true;
1834}
1835
1837{
1838 wmXrSurfaceData *data = static_cast<wmXrSurfaceData *>(surface->customdata);
1839 ListBaseT<wmXrViewportPair> *lb = &data->viewports;
1840
1841 while (wmXrViewportPair *vp = static_cast<wmXrViewportPair *>(BLI_pophead(lb))) {
1842 if (vp->viewport) {
1843 GPU_viewport_free(vp->viewport);
1844 }
1845 if (vp->offscreen) {
1846 GPU_offscreen_free(vp->offscreen);
1847 }
1848 BLI_freelinkN(lb, vp);
1849 }
1850
1851 if (data->controller_art) {
1852 data->controller_art->drawcalls.free_no_destruct();
1853 MEM_delete(data->controller_art);
1854 }
1855
1856 wmXrSurfaceData *xr_data = static_cast<wmXrSurfaceData *>(surface->customdata);
1857 MEM_delete(xr_data);
1858
1859 g_xr_surface = nullptr;
1860}
1861
1863{
1864 if (g_xr_surface) {
1865 BLI_assert(false);
1866 return g_xr_surface;
1867 }
1868
1869 wmSurface *surface = MEM_new_zeroed<wmSurface>(__func__);
1871 data->controller_art = MEM_new_zeroed<ARegionType>("XrControllerRegionType");
1872
1876 surface->activate = DRW_xr_drawing_begin;
1877 surface->deactivate = DRW_xr_drawing_end;
1878
1879 surface->system_gpu_context = DRW_system_gpu_context_get();
1880 surface->blender_gpu_context = static_cast<GPUContext *>(DRW_xr_blender_gpu_context_get());
1881
1882 data->controller_art->regionid = RGN_TYPE_XR;
1883 surface->customdata = data;
1884
1885 g_xr_surface = surface;
1886
1887 return surface;
1888}
1889
1891{
1893
1894 wm_surface_add(surface);
1895
1896 /* Some regions may need to redraw with updated session state after the session is entirely up
1897 * and running. */
1899
1900 return surface->system_gpu_context;
1901}
1902
1904{
1905 if (g_xr_surface) { /* Might have been freed already. */
1907 }
1908
1910
1911 /* Some regions may need to redraw with updated session state after the session is entirely
1912 * stopped. */
1914}
1915
1917{
1918 if (g_xr_surface) {
1920 return data->controller_art;
1921 }
1922
1923 return nullptr;
1924}
1925 /* XR-Session Surface. */
1927
1928} // namespace blender
#define G_MAIN
General operations, lookup, etc. for blender objects.
#define BLI_ASSERT_UNIT_QUAT(q)
#define M_PI_2
#define M_SQRT1_2
Platform independent time functions.
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define DEFAULT_SENSOR_WIDTH
#define REGION_DRAW_POST_VIEW
Abstraction for XR (VR, AR, MR, ..) access via OpenXR.
int GHOST_XrLoadControllerModel(GHOST_IXrContext *xr_context, const char *subaction_path)
Definition GHOST_Xr.cc:242
unsigned int GHOST_XrGetActionCount(GHOST_IXrContext *xr_context, const char *action_set_name)
Definition GHOST_Xr.cc:226
int GHOST_XrSyncActions(GHOST_IXrContext *xr_context, const char *action_set_name)
Definition GHOST_Xr.cc:176
void GHOST_XrSessionEnd(GHOST_IXrContext *xr_context)
Definition GHOST_Xr.cc:68
void GHOST_XrGetActionCustomdataArray(GHOST_IXrContext *xr_context, const char *action_set_name, void **r_customdata_array)
Definition GHOST_Xr.cc:233
void GHOST_XrSessionStart(GHOST_IXrContext *xr_context, const GHOST_XrSessionBeginInfo *begin_info)
Definition GHOST_Xr.cc:63
void * GHOST_XrGetActionCustomdata(GHOST_IXrContext *xr_context, const char *action_set_name, const char *action_name)
Definition GHOST_Xr.cc:216
int GHOST_XrSessionIsRunning(const GHOST_IXrContext *xr_context)
Definition GHOST_Xr.cc:78
int GHOST_XrAttachActionSets(GHOST_IXrContext *xr_context)
Definition GHOST_Xr.cc:169
int GHOST_XrUpdateControllerModelComponents(GHOST_IXrContext *xr_context, const char *subaction_path)
Definition GHOST_Xr.cc:255
void GHOST_XrSessionDrawViews(GHOST_IXrContext *xr_context, void *customdata)
Definition GHOST_Xr.cc:73
#define GPU_TEXTURE_FREE_SAFE(texture)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NC_WM
Definition WM_types.hh:387
#define ND_XR_DATA_CHANGED
Definition WM_types.hh:434
#define CLAMP(a, b, c)
#define BLI_assert_unreachable()
#define UNUSED_VARS(...)
#define BLI_INLINE
#define STREQ(a, b)
#define offsetof(t, d)
#define FLT_EPSILON
float3x3 scale(float3x3 mat, float2 scale)
const int state
ImBuf * svg_icon_bitmap(uint icon_id, float size, bool multicolor=false)
BMesh Iterators.
MINLINE float min_ff(float a, float b)
void WM_main_add_notifier(uint type, void *reference)
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ XR_POSE_INPUT
@ XR_BOOLEAN_INPUT
@ XR_FLOAT_INPUT
@ XR_VIBRATION_OUTPUT
@ XR_VECTOR2F_INPUT
void wm_xr_pose_to_mat(const GHOST_XrPose *pose, float r_mat[4][4])
Definition wm_xr_draw.cc:44
void mat4_to_loc_quat(float loc[3], float quat[4], const float wmat[4][4])
static void wm_xr_session_action_states_interpret(wmXrData *xr, const char *action_set_name, wmXrAction *action, uint subaction_idx, ListBaseT< LinkData > *active_modal_actions, ListBaseT< wmXrHapticAction > *active_haptic_actions, int64_t time_now, bool modal, bool haptic, short *r_val)
void wm_xr_session_controller_data_populate(const wmXrAction *grip_action, const wmXrAction *aim_action, wmXrData *xr)
bool WM_xr_session_state_viewer_pose_matrix_info_get(const wmXrData *xr, float r_viewmat[4][4], float *r_focal_len)
gpu::FrameBuffer * GPU_framebuffer_active_get()
ScrArea * CTX_wm_area(const bContext *C)
__int64 int64_t
Definition BKE_text.h:90
@ XR_ACTION_BIMANUAL
void GPU_offscreen_free(GPUOffScreen *offscreen)
char * STRNCPY(char(&dst)[N], const char *src)
@ XR_BASE_POSE_CUSTOM
@ XR_BASE_POSE_OBJECT
GPUTextureCreateFlags
Definition IMB_imbuf.hh:611
void GPU_framebuffer_restore()
bool WM_xr_session_state_controller_aim_rotation_get(const wmXrData *xr, uint subaction_idx, float r_rotation[4])
wmWindow * wm_xr_session_root_window_or_fallback_get(const wmWindowManager *wm, const wmXrRuntimeData *runtime_data)
static void wm_xr_session_controller_data_free(wmXrSessionState *state)
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
@ BKE_CB_EVT_XR_SESSION_START_PRE
void WM_xr_session_state_nav_location_set(wmXrData *xr, const float location[3])
bool assign_if_different(T &old_value, T &&new_value)
static bool wm_xr_session_action_test_bimanual(const wmXrSessionState *session_state, wmXrAction *action, uint subaction_idx, uint *r_subaction_idx_other, const GHOST_XrPose **r_aim_pose_other)
BLI_INLINE bool test_float_state(const float *state, float threshold, eXrAxisFlag flag)
bool WM_xr_session_state_viewfinder_active_action_confirm_get(const wmXrData *xr, eXrViewfinderConfirmAction *r_action)
void WM_xr_session_state_viewfinder_trigger_flash(wmXrData *xr)
void BKE_callback_exec_null(Main *bmain, eCbEvent evt)
Definition callbacks.cc:40
void(*)(const wmXrData *xr_data) wmXrSessionExitFn
Definition wm_xr.hh:17
static void wm_xr_session_create_cb()
void WM_xr_session_state_viewfinder_active_action_live_set(wmXrData *xr, eXrViewfinderLiveAction action)
bool WM_xr_session_exists(const wmXrData *xr)
static void wm_xr_session_draw_data_populate(wmXrData *xr_data, wmXrDrawData *r_draw_data)
void wm_xr_session_actions_update(wmWindowManager *wm)
bool WM_xr_session_state_viewfinder_capture_dof_enabled_get(const wmXrData *xr, bool *r_dof_enabled)
MINLINE void copy_v2_v2(float r[2], const float a[2])
@ XR_VIEWFINDER_MODE_LIVE
bool WM_xr_session_state_viewfinder_location_get(const wmXrData *xr, float r_location[3])
void WM_xr_session_state_viewfinder_playback_show_active_capture_in_space_enabled_set(wmXrData *xr, bool enabled)
bool WM_xr_session_state_nav_rotation_get(const wmXrData *xr, float r_rotation[4])
void CTX_wm_window_set(bContext *C, wmWindow *win)
void WM_xr_session_state_viewfinder_capture_dof_fstop_set(wmXrData *xr, float dof_fstop)
eXrViewfinderPlaybackAction
@ XR_VIEWFINDER_ACTION_PB_BROWSE
bContext * WM_xr_session_context_get(const wmXrData *xr)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:615
void quat_to_eul(float eul[3], const float quat[4])
GHOST_IContext * wm_xr_session_gpu_binding_context_create()
static void wm_xr_session_base_pose_calc(const Scene *scene, const XrSessionSettings *settings, GHOST_XrPose *r_base_pose, float *r_base_scale)
void GPU_batch_discard(gpu::Batch *batch)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
wmWindow * CTX_wm_window(const bContext *C)
void wm_xr_draw_controllers(const bContext *C, ARegion *, void *customdata)
static void wm_xr_session_haptic_timers_check(ListBaseT< wmXrHapticAction > *active_haptic_actions, int64_t time_now)
void mul_qt_qtqt(float q[4], const float a[4], const float b[4])
void WM_xr_session_state_viewfinder_capture_dof_enabled_set(wmXrData *xr, bool dof_enabled)
bool WM_xr_session_state_viewer_scale_get(const wmXrData *xr, float *r_scale)
int GPU_offscreen_width(const GPUOffScreen *offscreen)
void WM_xr_session_state_vignette_update(wmXrSessionState *state)
void wm_surface_remove(wmSurface *surface)
bool WM_xr_session_state_viewfinder_orientation_get(const wmXrData *xr, float r_rotation[4])
bool WM_xr_session_state_nav_location_get(const wmXrData *xr, float r_location[3])
static void wm_xr_session_begin_info_create(wmXrData *xr_data, GHOST_XrSessionBeginInfo *r_begin_info)
bool WM_xr_session_state_viewfinder_capture_dof_fstop_get(const wmXrData *xr, float *r_dof_fstop)
void wm_window_reset_drawable()
void * BLI_pophead(ListBase *listbase) ATTR_NONNULL(1)
Definition listbase.cc:259
void WM_xr_session_state_viewfinder_capture_dof_distance_set(wmXrData *xr, float dof_distance)
MINLINE void sub_v3_v3(float r[3], const float a[3])
static void wm_xr_session_haptic_action_remove(ListBaseT< wmXrHapticAction > *active_haptic_actions, const wmXrAction *action)
bool WM_xr_session_state_viewfinder_playback_show_active_capture_in_space_enabled_get(const wmXrData *xr, bool *r_enabled)
void unit_qt(float q[4])
void wm_xr_session_controller_data_clear(wmXrSessionState *state)
bool WM_xr_session_state_viewfinder_capture_dof_distance_get(const wmXrData *xr, float *r_dof_distance)
static void wm_xr_session_surface_draw(bContext *C)
Call Ghost-XR to draw a frame.
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void wm_xr_session_state_update(const XrSessionSettings *settings, const wmXrDrawData *draw_data, const GHOST_XrDrawViewInfo *draw_view, wmXrSessionState *state)
static void wm_xr_session_modal_action_remove(ListBaseT< LinkData > *active_modal_actions, const wmXrAction *action)
void * ED_region_draw_cb_activate(ARegionType *art, void(*draw)(const bContext *, ARegion *, void *), void *customdata, int type)
bool WM_xr_session_state_controller_grip_location_get(const wmXrData *xr, uint subaction_idx, float r_location[3])
static void wm_xr_session_events_dispatch(wmXrData *xr, GHOST_IXrContext *xr_context, wmXrActionSet *action_set, wmXrSessionState *session_state, wmWindow *win)
void IMB_freeImBuf(ImBuf *ibuf)
int GPU_offscreen_height(const GPUOffScreen *offscreen)
@ SESSION_STATE_EVENT_START
@ SESSION_STATE_EVENT_POSITION_TRACKING_TOGGLE
@ SESSION_STATE_EVENT_NONE
@ SESSION_STATE_EVENT_RESET_TO_BASE_POSE
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void WM_xr_session_state_viewfinder_init(wmXrSessionState *state)
@ GPU_TEXTURE_USAGE_SHADER_READ
@ GPU_TEXTURE_USAGE_MEMORY_EXPORT
bool ED_region_draw_cb_exit(ARegionType *art, void *handle)
void WM_xr_session_state_viewfinder_active_action_confirm_set(wmXrData *xr, eXrViewfinderConfirmAction action)
void wm_xr_session_gpu_binding_context_destroy(GHOST_IContext *context)
void copy_qt_qt(float q[4], const float a[4])
void WM_xr_session_state_vignette_activate(wmXrData *xr)
BMesh const char void * data
static wmSurface * g_xr_surface
wmWindowManager * CTX_wm_manager(const bContext *C)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
void eul_to_quat(float quat[4], const float eul[3])
void axis_angle_to_quat_single(float q[4], char axis, float angle)
void WM_xr_haptic_action_stop(wmXrData *xr, const char *action_set_name, const char *action_name, const char *subaction_path)
eXrViewfinderLiveAction
@ XR_VIEWFINDER_ACTION_LIVE_LENS
bool WM_xr_session_state_viewfinder_active_action_playback_get(const wmXrData *xr, eXrViewfinderPlaybackAction *r_action)
static wmSurface * wm_xr_session_surface_create()
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
bool wm_xr_session_surface_offscreen_ensure(wmXrSurfaceData *surface_data, const GHOST_XrDrawViewInfo *draw_view)
static wmXrHapticAction * wm_xr_session_haptic_action_find(ListBaseT< wmXrHapticAction > *active_haptic_actions, const wmXrAction *action, const char *subaction_path)
bool WM_xr_session_state_viewfinder_active_action_live_get(const wmXrData *xr, eXrViewfinderLiveAction *r_action)
bool WM_xr_session_state_viewer_pose_location_get(const wmXrData *xr, float r_location[3])
ARegionType * WM_xr_surface_controller_region_type_get()
bContext * WM_xr_session_context_ensure(wmXrData *xr, const wmWindowManager *wm)
bool WM_xr_session_is_ready(const wmXrData *xr)
void unit_m4(float m[4][4])
void wm_xr_pose_scale_to_mat(const GHOST_XrPose *pose, float scale, float r_mat[4][4])
Definition wm_xr_draw.cc:50
static void wm_xr_session_exit_cb(void *customdata)
bool WM_xr_active_action_set_set(wmXrData *xr, const char *action_set_name, bool delayed)
static bool wm_xr_session_draw_data_needs_reset_to_base_pose(const wmXrSessionState *state, const XrSessionSettings *settings)
void WM_xr_session_state_nav_scale_set(wmXrData *xr, float scale)
MINLINE void zero_v3(float r[3])
void wm_xr_session_actions_init(wmXrData *xr)
void BKE_id_free(Main *bmain, void *idv)
static void wm_xr_session_scale_maintain_viewer_pos(wmXrSessionState *state, const float new_scale, const float prev_scale)
static void wm_xr_session_controller_data_update(const XrSessionSettings *settings, const wmXrAction *grip_action, const wmXrAction *aim_action, GHOST_IXrContext *xr_context, wmXrSessionState *state)
void * BKE_id_new_nomain(short type, const char *name)
Definition lib_id.cc:1617
bool WM_xr_session_state_viewfinder_active_mode_get(const wmXrData *xr, eXrViewfinderMode *r_mode)
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
Definition screen.cc:1024
static void wm_xr_session_controller_pose_calc(const GHOST_XrPose *raw_pose, const float view_ofs[3], const float base_mat[4][4], const float nav_mat[4][4], GHOST_XrPose *r_pose, float r_mat[4][4], float r_mat_base[4][4])
bool WM_xr_session_state_controller_aim_location_get(const wmXrData *xr, uint subaction_idx, float r_location[3])
bool WM_xr_haptic_action_apply(wmXrData *xr, const char *action_set_name, const char *action_name, const char *subaction_path, const int64_t *duration, const float *frequency, const float *amplitude)
MINLINE void add_v3_v3(float r[3], const float a[3])
void WM_xr_session_state_viewfinder_active_action_playback_set(wmXrData *xr, eXrViewfinderPlaybackAction action)
void GPU_viewport_free(GPUViewport *viewport)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
static wmXrSessionStateEvent wm_xr_session_state_to_event(const wmXrSessionState *state, const XrSessionSettings *settings)
MINLINE void copy_v3_fl(float r[3], float f)
gpu::Texture * IMB_create_gpu_texture(const char *name, ImBuf *ibuf, GPUTextureCreateFlags flags)
Definition util_gpu.cc:452
float fov_to_focallength(float hfov, float sensor)
void wm_surface_add(wmSurface *surface)
void wm_xr_session_draw_data_update(wmXrSessionState *state, const XrSessionSettings *settings, const GHOST_XrDrawViewInfo *draw_view, wmXrDrawData *draw_data)
void WM_xr_session_state_viewfinder_active_mode_set(wmXrData *xr, eXrViewfinderMode mode)
static void wm_xr_session_haptic_action_add(ListBaseT< wmXrHapticAction > *active_haptic_actions, const wmXrAction *action, const char *subaction_path, int64_t time_now)
void WM_xr_session_state_viewfinder_reset(wmXrSessionState *state)
static const GHOST_XrPose * wm_xr_session_controller_aim_pose_find(const wmXrSessionState *state, const char *subaction_path)
void wm_xr_runtime_data_free(wmXrRuntimeData **runtime)
Definition wm_xr.cc:192
void WM_xr_session_state_nav_rotation_set(wmXrData *xr, const float rotation[4])
wmXrViewfinderState * WM_xr_session_state_viewfinder_handle_get(const wmXrData *xr)
@ KM_NOTHING
Definition WM_types.hh:323
@ KM_RELEASE
Definition WM_types.hh:325
static CLG_LogRef LOG
Definition logging.cpp:12
bool WM_xr_session_state_viewer_pose_rotation_get(const wmXrData *xr, float r_rotation[4])
MINLINE float interpf(float target, float origin, float t)
double BLI_time_now_seconds()
Definition time.cc:30
Scene * CTX_data_scene(const bContext *C)
void wm_xr_session_toggle(wmWindowManager *wm, wmXrSessionExitFn session_exit_fn)
void CTX_wm_region_set(bContext *C, ARegion *region)
void CTX_data_main_set(bContext *C, Main *bmain)
MINLINE void copy_v4_v4(float r[4], const float a[4])
void wm_xr_session_data_free(wmXrSessionState *state)
static void wm_xr_session_modal_action_test_add(ListBaseT< LinkData > *active_modal_actions, const wmXrAction *action)
GPUOffScreen * GPU_offscreen_create(int width, int height, bool with_depth_buffer, gpu::TextureFormat format, eGPUTextureUsage usage, bool clear, char err_out[256])
bool WM_xr_session_state_viewfinder_capture_lens_focal_get(const wmXrData *xr, float *r_lens_focal)
static void wm_xr_session_do_depsgraph(bContext *C)
void wm_xr_pose_scale_to_imat(const GHOST_XrPose *pose, float scale, float r_imat[4][4])
Definition wm_xr_draw.cc:68
void copy_m4_m4(float m1[4][4], const float m2[4][4])
static void wm_xr_session_viewfinder_data_free(wmXrSessionState *state)
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
BLI_INLINE bool test_vec2f_state(const float state[2], float threshold, eXrAxisFlag flag)
VecBase< float, 3 > float3
static wmXrActionData * wm_xr_session_event_create(const char *action_set_name, const wmXrAction *action, const GHOST_XrPose *controller_aim_pose, const GHOST_XrPose *controller_aim_pose_other, uint subaction_idx, uint subaction_idx_other, bool bimanual)
wmXrSessionState * WM_xr_session_state_handle_get(const wmXrData *xr)
static void wm_xr_session_state_viewer_scale_update(wmXrSessionState *state, const XrSessionSettings *settings, const Scene *scene)
void WM_xr_session_state_viewfinder_capture_lens_focal_set(wmXrData *xr, float lens_focal)
void WM_xr_session_state_navigation_reset(wmXrSessionState *state)
MINLINE int min_ii(int a, int b)
bool WM_xr_session_state_controller_grip_rotation_get(const wmXrData *xr, uint subaction_idx, float r_rotation[4])
static bool wm_xr_session_modal_action_test(const ListBaseT< LinkData > *active_modal_actions, const wmXrAction *action, bool *r_found)
@ XR_HAPTIC_MATCHUSERPATHS
@ XR_HAPTIC_REPEAT
@ XR_HAPTIC_RELEASE
@ XR_HAPTIC_PRESS
void WM_xr_session_state_viewfinder_trigger_focus_indicator(wmXrData *xr, bool hit_success)
bool IDP_EqualsProperties(const IDProperty *prop1, const IDProperty *prop2) ATTR_WARN_UNUSED_RESULT
Definition idprop.cc:1127
@ XR_OP_RELEASE
void WM_xr_session_state_viewfinder_reset_view_smoothing(wmXrData *xr)
void WM_xr_session_base_pose_reset(wmXrData *xr)
static void wm_xr_session_surface_free_data(wmSurface *surface)
eXrViewfinderConfirmAction
@ XR_SESSION_USE_POSITION_TRACKING
@ XR_SESSION_USE_ABSOLUTE_TRACKING
GPUViewport * GPU_viewport_create()
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
bool WM_xr_session_state_nav_scale_get(const wmXrData *xr, float *r_scale)
MINLINE float clamp_f(float value, float min, float max)
void CTX_wm_area_set(bContext *C, ScrArea *area)
#define fabsf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
struct Object * camera
struct UnitSettings unit
ListBaseT< SpaceLink > spacedata
eXRSessionBasePoseType base_pose_type
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
void(*) do_depsgraph(bContext *C)
Definition wm_surface.hh:33
GPUContext * blender_gpu_context
Definition wm_surface.hh:27
GHOST_IContext * system_gpu_context
Definition wm_surface.hh:26
void(*) deactivate()
Definition wm_surface.hh:40
void(*) free_data(wmSurface *)
Definition wm_surface.hh:35
void(*) draw(bContext *)
Definition wm_surface.hh:31
wmXrAction * controller_aim_action
ListBaseT< LinkData > active_modal_actions
wmXrAction * controller_grip_action
ListBaseT< wmXrHapticAction > active_haptic_actions
IDProperty * op_properties
eXrAxisFlag * axis_flags
eXrHapticFlag haptic_flag
const char * active_modal_path
eXrActionFlag action_flag
struct wmOperatorType * ot
unsigned int count_subaction_paths
XrSessionSettings session_settings
struct wmXrRuntimeData * runtime
wmXrSurfaceData * surface_data
wmXrSessionExitFn exit_fn
wmXrSessionState session_state
GHOST_IXrContext * ghost_context
ListBaseT< wmXrController > controllers
wmXrViewfinderState viewfinder
struct ARegionType * controller_art
ListBaseT< wmXrViewportPair > viewports
eXrViewfinderLiveAction active_action_live
static constexpr int view_resolution
eXrViewfinderMode active_mode
eXrViewfinderPlaybackAction active_action_playback
eXrViewfinderConfirmAction active_action_confirm
struct GPUOffScreen * offscreen
struct GPUViewport * viewport