Blender V5.3
wm_xr_draw.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
12
13#include <cstring>
14
15#include "DNA_userdef_types.h"
16
17#include "BLI_listbase.hh"
18#include "BLI_math_geom_c.hh"
19#include "BLI_math_matrix_c.hh"
21#include "BLI_math_vector_c.hh"
22
23#include "BKE_context.hh"
24#include "BKE_scene.hh"
25
27
28#include "GHOST_Xr-api.hh"
29
30#include "GPU_batch_presets.hh"
31#include "GPU_immediate.hh"
32#include "GPU_matrix.hh"
33#include "GPU_state.hh"
34#include "GPU_viewport.hh"
35
36#include "UI_resources.hh"
37
38#include "WM_api.hh"
39
40#include "wm_xr_intern.hh"
41
42namespace blender {
43
44void wm_xr_pose_to_mat(const GHOST_XrPose *pose, float r_mat[4][4])
45{
46 quat_to_mat4(r_mat, pose->orientation_quat);
47 copy_v3_v3(r_mat[3], pose->position);
48}
49
50void wm_xr_pose_scale_to_mat(const GHOST_XrPose *pose, float scale, float r_mat[4][4])
51{
52 wm_xr_pose_to_mat(pose, r_mat);
53
54 BLI_assert(scale > 0.0f);
55 mul_v3_fl(r_mat[0], scale);
56 mul_v3_fl(r_mat[1], scale);
57 mul_v3_fl(r_mat[2], scale);
58}
59
60void wm_xr_pose_to_imat(const GHOST_XrPose *pose, float r_imat[4][4])
61{
62 float iquat[4];
63 invert_qt_qt_normalized(iquat, pose->orientation_quat);
64 quat_to_mat4(r_imat, iquat);
65 translate_m4(r_imat, -pose->position[0], -pose->position[1], -pose->position[2]);
66}
67
68void wm_xr_pose_scale_to_imat(const GHOST_XrPose *pose, float scale, float r_imat[4][4])
69{
70 float iquat[4];
71 invert_qt_qt_normalized(iquat, pose->orientation_quat);
72 quat_to_mat4(r_imat, iquat);
73
74 BLI_assert(scale > 0.0f);
75 scale = 1.0f / scale;
76 mul_v3_fl(r_imat[0], scale);
77 mul_v3_fl(r_imat[1], scale);
78 mul_v3_fl(r_imat[2], scale);
79
80 translate_m4(r_imat, -pose->position[0], -pose->position[1], -pose->position[2]);
81}
82
83static void wm_xr_draw_matrices_create(const wmXrDrawData *draw_data,
84 const GHOST_XrDrawViewInfo *draw_view,
85 const XrSessionSettings *session_settings,
86 const wmXrSessionState *session_state,
87 float r_viewmat[4][4],
88 float r_projmat[4][4])
89{
90 GHOST_XrPose eye_pose;
91 float eye_inv[4][4], base_inv[4][4], nav_inv[4][4], m[4][4];
92
93 /* Calculate inverse eye matrix. */
94 copy_qt_qt(eye_pose.orientation_quat, draw_view->eye_pose.orientation_quat);
95 copy_v3_v3(eye_pose.position, draw_view->eye_pose.position);
96 if ((session_settings->flag & XR_SESSION_USE_POSITION_TRACKING) == 0) {
97 sub_v3_v3(eye_pose.position, draw_view->local_pose.position);
98 }
99 if ((session_settings->flag & XR_SESSION_USE_ABSOLUTE_TRACKING) == 0) {
100 sub_v3_v3(eye_pose.position, draw_data->eye_position_ofs);
101 }
102
103 wm_xr_pose_to_imat(&eye_pose, eye_inv);
104
105 /* Apply base pose and navigation. */
106 wm_xr_pose_scale_to_imat(&draw_data->base_pose, draw_data->base_scale, base_inv);
108 session_state->viewer_scale_last_actions_sync,
109 nav_inv);
110 mul_m4_m4m4(m, eye_inv, base_inv);
111 mul_m4_m4m4(r_viewmat, m, nav_inv);
112
113 perspective_m4_fov(r_projmat,
114 draw_view->fov.angle_left,
115 draw_view->fov.angle_right,
116 draw_view->fov.angle_up,
117 draw_view->fov.angle_down,
118 session_settings->clip_start,
119 session_settings->clip_end);
120}
121
123 const wmXrRuntimeData *runtime_data,
124 const wmXrSurfaceData *surface_data,
125 const GHOST_XrDrawViewInfo *draw_view)
126{
127 const wmXrViewportPair *vp = static_cast<const wmXrViewportPair *>(
128 BLI_findlink(&surface_data->viewports, draw_view->view_idx));
129 BLI_assert(vp && vp->viewport);
130
131 const bool is_upside_down = GHOST_XrSessionNeedsUpsideDownDrawing(runtime_data->ghost_context);
132 rcti rect{};
133 rect.xmin = 0;
134 rect.ymin = 0;
135 rect.xmax = draw_view->width - 1;
136 rect.ymax = draw_view->height - 1;
137
138 wmViewport(&rect);
139
140 /* For upside down contexts, draw with inverted y-values. */
141 if (is_upside_down) {
142 std::swap(rect.ymin, rect.ymax);
143 }
144 GPU_viewport_draw_to_screen_ex(vp->viewport, 0, &rect, draw_view->expects_srgb_buffer, true);
145}
146
147void wm_xr_draw_view(const GHOST_XrDrawViewInfo *draw_view, void *customdata)
148{
149 wmXrDrawData *draw_data = static_cast<wmXrDrawData *>(customdata);
150 wmXrData *xr_data = draw_data->xr_data;
151 wmXrSurfaceData *surface_data = draw_data->surface_data;
152 wmXrSessionState *session_state = &xr_data->runtime->session_state;
153 XrSessionSettings *settings = &xr_data->session_settings;
154
155 const int display_flags = V3D_OFSDRAW_OVERRIDE_SCENE_SETTINGS | settings->draw_flags;
156
157 float viewmat[4][4], winmat[4][4];
158
160
161 wm_xr_session_draw_data_update(session_state, settings, draw_view, draw_data);
162 wm_xr_draw_matrices_create(draw_data, draw_view, settings, session_state, viewmat, winmat);
163 wm_xr_session_state_update(settings, draw_data, draw_view, session_state);
164
165 if (!wm_xr_session_surface_offscreen_ensure(surface_data, draw_view)) {
166 return;
167 }
168
169 const wmXrViewportPair *vp = static_cast<const wmXrViewportPair *>(
170 BLI_findlink(&surface_data->viewports, draw_view->view_idx));
171 BLI_assert(vp && vp->offscreen && vp->viewport);
172
173 /* In case a framebuffer is still bound from drawing the last eye. */
175 /* Some systems have drawing glitches without this. */
176 GPU_clear_depth(1.0f);
177
178 /* XR context is ensured before each draw in #wm_xr_session_surface_draw. */
179 bContext *xr_context = WM_xr_session_context_get(xr_data);
180 Scene *scene = CTX_data_scene(xr_context);
181
182 /* The XR context depsgraph is separately evaluated outside of drawing within the XR surface
183 * #do_depsgraph callback. Thus, obtain the depsgraph directly without evaluating it. */
184 Depsgraph *depsgraph = CTX_data_depsgraph_pointer(xr_context);
185
186 if (draw_view->view_idx == 0) {
187 /* Only render location scouting viewfinder on first eye draw. */
189 }
190
191 /* Draws the view into the surface_data->viewport's frame-buffers. */
193 scene,
194 &settings->shading,
195 xr_context,
196 eDrawType(settings->shading.type),
199 draw_view->width,
200 draw_view->height,
201 display_flags,
202 viewmat,
203 winmat,
204 settings->clip_start,
205 settings->clip_end,
206 session_state->vignette_aperture,
207 true,
208 false,
209 true,
210 nullptr,
211 false,
212 nullptr,
213 vp->offscreen,
214 vp->viewport);
215
216 /* The draw-manager uses both GPUOffscreen and GPUViewport to manage frame and texture buffers. A
217 * call to GPU_viewport_draw_to_screen() is still needed to get the final result from the
218 * viewport buffers composited together and potentially color managed for display on screen.
219 * It needs a bound frame-buffer to draw into, for which we simply reuse the GPUOffscreen one.
220 *
221 * In a next step, Ghost-XR will use the currently bound frame-buffer to retrieve the image
222 * to be submitted to the OpenXR swap-chain. So do not un-bind the off-screen yet! */
223
224 GPU_offscreen_bind(vp->offscreen, false);
225
226 wm_xr_draw_viewport_buffers_to_active_framebuffer(xr_data->runtime, surface_data, draw_view);
227}
228
229bool wm_xr_passthrough_enabled(void *customdata)
230{
231 wmXrDrawData *draw_data = static_cast<wmXrDrawData *>(customdata);
232 wmXrData *xr_data = draw_data->xr_data;
233 XrSessionSettings *settings = &xr_data->session_settings;
234
235 return (settings->draw_flags & V3D_OFSDRAW_XR_SHOW_PASSTHROUGH) != 0;
236}
237
238void wm_xr_disable_passthrough(void *customdata)
239{
240 wmXrDrawData *draw_data = static_cast<wmXrDrawData *>(customdata);
241 wmXrData *xr_data = draw_data->xr_data;
242 XrSessionSettings *settings = &xr_data->session_settings;
243
245 WM_global_report(RPT_INFO, "Passthrough not available");
246}
247
249 const char *subaction_path)
250{
251 GHOST_XrControllerModelData model_data;
252
253 if (!GHOST_XrGetControllerModelData(xr_context, subaction_path, &model_data) ||
254 model_data.count_vertices < 1)
255 {
256 return nullptr;
257 }
258
259 GPUVertFormat format = {0};
260 GPU_vertformat_attr_add(&format, "pos", gpu::VertAttrType::SFLOAT_32_32_32);
261 GPU_vertformat_attr_add(&format, "nor", gpu::VertAttrType::SFLOAT_32_32_32);
262
263 gpu::VertBuf *vbo = GPU_vertbuf_create_with_format(format);
264 GPU_vertbuf_data_alloc(*vbo, model_data.count_vertices);
265 vbo->data<GHOST_XrControllerModelVertex>().copy_from(
266 {model_data.vertices, model_data.count_vertices});
267
268 gpu::IndexBuf *ibo = nullptr;
269 if (model_data.count_indices > 0 && ((model_data.count_indices % 3) == 0)) {
270 GPUIndexBufBuilder ibo_builder;
271 const uint prim_len = model_data.count_indices / 3;
272 GPU_indexbuf_init(&ibo_builder, GPU_PRIM_TRIS, prim_len, model_data.count_vertices);
273 for (uint i = 0; i < prim_len; ++i) {
274 const uint32_t *idx = &model_data.indices[i * 3];
275 GPU_indexbuf_add_tri_verts(&ibo_builder, idx[0], idx[1], idx[2]);
276 }
277 ibo = GPU_indexbuf_build(&ibo_builder);
278 }
279
281}
282
284 GHOST_IXrContext *xr_context,
286{
287 GHOST_XrControllerModelData model_data;
288
289 float color[4];
290 switch (settings->controller_draw_style) {
293 color[0] = color[1] = color[2] = 0.0f;
294 color[3] = 0.4f;
295 break;
298 color[0] = 0.422f;
299 color[1] = 0.438f;
300 color[2] = 0.446f;
301 color[3] = 0.4f;
302 break;
303 }
304
307
308 for (wmXrController &controller : state->controllers) {
309 if (!controller.grip_active) {
310 continue;
311 }
312
313 gpu::Batch *model = controller.model;
314 if (!model) {
315 model = controller.model = wm_xr_controller_model_batch_create(xr_context,
316 controller.subaction_path);
317 }
318
319 if (model &&
320 GHOST_XrGetControllerModelData(xr_context, controller.subaction_path, &model_data) &&
321 model_data.count_components > 0)
322 {
324 GPU_batch_uniform_4fv(model, "color", color);
325
327 GPU_matrix_mul(controller.grip_mat);
328 for (uint component_idx = 0; component_idx < model_data.count_components; ++component_idx) {
329 const GHOST_XrControllerModelComponent *component = &model_data.components[component_idx];
331 GPU_matrix_mul(component->transform);
333 model->elem ? component->index_offset : component->vertex_offset,
334 model->elem ? component->index_count : component->vertex_count);
336 }
338 }
339 else {
340 /* Fallback. */
341 const float scale = 0.05f;
342 gpu::Batch *sphere = GPU_batch_preset_sphere(2);
344 GPU_batch_uniform_4fv(sphere, "color", color);
345
347 GPU_matrix_mul(controller.grip_mat);
349 GPU_batch_draw(sphere);
351 }
352 }
353}
354
356{
357 const bool draw_ray = ELEM(
359
360 GPUVertFormat *format = immVertexFormat();
361 uint pos = GPU_vertformat_attr_add(format, "pos", gpu::VertAttrType::SFLOAT_32_32_32);
362 uint col = GPU_vertformat_attr_add(format, "color", gpu::VertAttrType::SFLOAT_32_32_32_32);
364
365 float viewport[4];
366 GPU_viewport_size_get_f(viewport);
367 immUniform2fv("viewportSize", &viewport[2]);
368
369 immUniform1f("lineWidth", 3.0f * U.pixelsize);
370
371 if (draw_ray) {
372 const float color[4] = {0.33f, 0.33f, 1.0f, 0.5f};
373 const float scale = settings->clip_end;
374 float ray[3];
375
378
379 for (wmXrController &controller : state->controllers) {
380 if (!controller.grip_active) {
381 continue;
382 }
383
385
386 const float (*mat)[4] = controller.aim_mat;
387 madd_v3_v3v3fl(ray, mat[3], mat[2], -scale);
388
389 immAttrSkip(col);
390 immVertex3fv(pos, mat[3]);
391 immAttr4fv(col, color);
392 immVertex3fv(pos, ray);
393
394 immEnd();
395 }
396 }
397 else {
398 const float r[4] = {255 / 255.0f, 51 / 255.0f, 82 / 255.0f, 255 / 255.0f};
399 const float g[4] = {139 / 255.0f, 220 / 255.0f, 0 / 255.0f, 255 / 255.0f};
400 const float b[4] = {40 / 255.0f, 144 / 255.0f, 255 / 255.0f, 255 / 255.0f};
401 const float scale = 0.01f;
402 float x_axis[3], y_axis[3], z_axis[3];
403
406
407 for (wmXrController &controller : state->controllers) {
408 if (!controller.grip_active) {
409 continue;
410 }
411
413
414 const float (*mat)[4] = controller.aim_mat;
415 madd_v3_v3v3fl(x_axis, mat[3], mat[0], scale);
416 madd_v3_v3v3fl(y_axis, mat[3], mat[1], scale);
417 madd_v3_v3v3fl(z_axis, mat[3], mat[2], scale);
418
419 immAttrSkip(col);
420 immVertex3fv(pos, mat[3]);
421 immAttr4fv(col, r);
422 immVertex3fv(pos, x_axis);
423
424 immAttrSkip(col);
425 immVertex3fv(pos, mat[3]);
426 immAttr4fv(col, g);
427 immVertex3fv(pos, y_axis);
428
429 immAttrSkip(col);
430 immVertex3fv(pos, mat[3]);
431 immAttr4fv(col, b);
432 immVertex3fv(pos, z_axis);
433
434 immEnd();
435 }
436 }
437
439}
440
441void wm_xr_draw_controllers(const bContext *C, ARegion * /*region*/, void *customdata)
442{
443 wmXrData *xr = static_cast<wmXrData *>(customdata);
444 const XrSessionSettings *settings = &xr->session_settings;
445 GHOST_IXrContext *xr_context = xr->runtime->ghost_context;
447
448 wm_xr_controller_model_draw(settings, xr_context, state);
450 wm_xr_viewfinder_draw(C, settings, state);
451}
452
453} // namespace blender
Abstraction for XR (VR, AR, MR, ..) access via OpenXR.
int GHOST_XrGetControllerModelData(GHOST_IXrContext *xr_context, const char *subaction_path, GHOST_XrControllerModelData *r_data)
Definition GHOST_Xr.cc:263
int GHOST_XrSessionNeedsUpsideDownDrawing(const GHOST_IXrContext *xr_context)
Definition GHOST_Xr.cc:108
#define GPU_batch_uniform_4fv(batch, name, val)
Definition GPU_batch.hh:275
#define C
Definition RandGen.cpp:29
#define ELEM(...)
MutableSpan< T > data()
float3x3 scale(float3x3 mat, float2 scale)
const int state
BMesh Iterators.
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
void GPU_viewport_draw_to_screen_ex(GPUViewport *viewport, int view, const rcti *rect, bool display_colorspace, bool do_overlay_merge)
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void wm_xr_pose_to_mat(const GHOST_XrPose *pose, float r_mat[4][4])
Definition wm_xr_draw.cc:44
bool wm_xr_passthrough_enabled(void *customdata)
Check if XR passthrough is enabled.
static void wm_xr_controller_aim_draw(const XrSessionSettings *settings, wmXrSessionState *state)
void wmViewport(const rcti *winrct)
gpu::Batch * GPU_batch_create_ex(GPUPrimType primitive_type, gpu::VertBuf *vertex_buf, gpu::IndexBuf *index_buf, GPUBatchFlag owns_flag)
Definition gpu_batch.cc:53
static void wm_xr_draw_matrices_create(const wmXrDrawData *draw_data, const GHOST_XrDrawViewInfo *draw_view, const XrSessionSettings *session_settings, const wmXrSessionState *session_state, float r_viewmat[4][4], float r_projmat[4][4])
Definition wm_xr_draw.cc:83
void GPU_indexbuf_init(GPUIndexBufBuilder *, GPUPrimType, uint prim_len, uint vertex_len)
void immEnd()
@ XR_CONTROLLER_DRAW_LIGHT
@ XR_CONTROLLER_DRAW_LIGHT_RAY
@ XR_CONTROLLER_DRAW_DARK
@ XR_CONTROLLER_DRAW_DARK_RAY
void GPU_framebuffer_restore()
void GPU_matrix_scale_1f(float factor)
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
void wm_xr_draw_view(const GHOST_XrDrawViewInfo *draw_view, void *customdata)
Draw a viewport for a single eye.
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
void perspective_m4_fov(float mat[4][4], float angle_left, float angle_right, float angle_up, float angle_down, float nearClip, float farClip)
void immAttrSkip(uint attr_id)
GPUVertFormat * immVertexFormat()
void GPU_clear_depth(float depth)
bContext * WM_xr_session_context_get(const wmXrData *xr)
void immBegin(GPUPrimType, uint vertex_len)
@ V3D_OFSDRAW_XR_SHOW_PASSTHROUGH
@ V3D_OFSDRAW_OVERRIDE_SCENE_SETTINGS
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void wm_xr_draw_controllers(const bContext *C, ARegion *, void *customdata)
void translate_m4(float mat[4][4], float Tx, float Ty, float Tz)
void immUnbindProgram()
void GPU_batch_draw_range(gpu::Batch *batch, int vertex_first, int vertex_count)
void GPU_matrix_mul(const float m[4][4])
MINLINE void mul_v3_fl(float r[3], float f)
@ GPU_BLEND_NONE
Definition GPU_state.hh:88
@ GPU_BLEND_ALPHA
Definition GPU_state.hh:90
MINLINE void sub_v3_v3(float r[3], const float a[3])
void immBindBuiltinProgram(GPUBuiltinShader shader_id)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
unsigned int uint32_t
Definition BKE_text.h:81
void wm_xr_viewfinder_render_view(wmXrData *xr_data)
void wm_xr_session_state_update(const XrSessionSettings *settings, const wmXrDrawData *draw_data, const GHOST_XrDrawViewInfo *draw_view, wmXrSessionState *state)
gpu::IndexBuf * GPU_indexbuf_build(GPUIndexBufBuilder *)
void immUniform1f(const char *name, float x)
@ GPU_DEPTH_NONE
Definition GPU_state.hh:132
@ GPU_DEPTH_LESS_EQUAL
Definition GPU_state.hh:135
void copy_qt_qt(float q[4], const float a[4])
void GPU_viewport_size_get_f(float coords[4])
Definition gpu_state.cc:258
void immAttr4fv(uint attr_id, const float data[4])
static void wm_xr_draw_viewport_buffers_to_active_framebuffer(const wmXrRuntimeData *runtime_data, const wmXrSurfaceData *surface_data, const GHOST_XrDrawViewInfo *draw_view)
@ GPU_SHADER_3D_POLYLINE_FLAT_COLOR
bool wm_xr_session_surface_offscreen_ensure(wmXrSurfaceData *surface_data, const GHOST_XrDrawViewInfo *draw_view)
void GPU_batch_draw(gpu::Batch *batch)
bool WM_xr_session_is_ready(const wmXrData *xr)
@ GPU_BATCH_OWNS_VBO
Definition GPU_batch.hh:44
@ GPU_BATCH_OWNS_INDEX
Definition GPU_batch.hh:48
void ED_view3d_draw_offscreen_simple(Depsgraph *depsgraph, Scene *scene, View3DShading *shading_override, bContext *context, eDrawType drawtype, int object_type_exclude_viewport_override, int object_type_exclude_select_override, int winx, int winy, unsigned int draw_flags, const float viewmat[4][4], const float winmat[4][4], float clip_start, float clip_end, float xr_vignette_aperture, bool is_xr_surface, bool is_image_render, bool draw_background, const char *viewname, bool do_color_management, Object *camera_override, GPUOffScreen *ofs, GPUViewport *viewport)
void wm_xr_pose_scale_to_mat(const GHOST_XrPose *pose, float scale, float r_mat[4][4])
Definition wm_xr_draw.cc:50
void WM_global_report(eReportType type, const char *message)
void GPU_offscreen_bind(GPUOffScreen *offscreen, bool save)
void GPU_indexbuf_add_tri_verts(GPUIndexBufBuilder *, uint v1, uint v2, uint v3)
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
void GPU_batch_program_set_builtin(gpu::Batch *batch, GPUBuiltinShader shader_id)
void immVertex3fv(uint attr_id, const float data[3])
void wm_xr_pose_to_imat(const GHOST_XrPose *pose, float r_imat[4][4])
Definition wm_xr_draw.cc:60
void wm_xr_viewfinder_draw(const bContext *C, const XrSessionSettings *settings, wmXrSessionState *state)
void wm_xr_session_draw_data_update(wmXrSessionState *state, const XrSessionSettings *settings, const GHOST_XrDrawViewInfo *draw_view, wmXrDrawData *draw_data)
void GPU_vertbuf_data_alloc(gpu::VertBuf &verts, uint v_len)
static gpu::Batch * wm_xr_controller_model_batch_create(GHOST_IXrContext *xr_context, const char *subaction_path)
Scene * CTX_data_scene(const bContext *C)
void immUniform2fv(const char *name, const float data[2])
gpu::Batch * GPU_batch_preset_sphere(int lod) ATTR_WARN_UNUSED_RESULT
void invert_qt_qt_normalized(float q1[4], const float q2[4])
void wm_xr_disable_passthrough(void *customdata)
Disable XR passthrough if not supported.
void GPU_blend(GPUBlend blend)
Definition gpu_state.cc:44
void wm_xr_pose_scale_to_imat(const GHOST_XrPose *pose, float scale, float r_imat[4][4])
Definition wm_xr_draw.cc:68
static void wm_xr_controller_model_draw(const XrSessionSettings *settings, GHOST_IXrContext *xr_context, wmXrSessionState *state)
void GPU_matrix_pop()
void GPU_depth_test(GPUDepthTest test)
Definition gpu_state.cc:70
void GPU_matrix_push()
@ XR_SESSION_USE_POSITION_TRACKING
@ XR_SESSION_USE_ABSOLUTE_TRACKING
void quat_to_mat4(float m[4][4], const float q[4])
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct View3DShading shading
XrSessionSettings session_settings
struct wmXrRuntimeData * runtime
wmXrSurfaceData * surface_data
wmXrSessionState session_state
GHOST_IXrContext * ghost_context
GHOST_XrPose nav_pose_last_actions_sync
ListBaseT< wmXrViewportPair > viewports
struct GPUOffScreen * offscreen
struct GPUViewport * viewport