80 wmXrActionData *actiondata =
static_cast<wmXrActionData *
>(
event->customdata);
81 return (actiondata->ot == op->
type &&
98 screen =
static_cast<bScreen *
>(screen->id.next))
100 for (
ScrArea &area : screen->areabase) {
106 ED_view3d_xr_mirror_update(&area, v3d, session_exists);
109 if (session_exists) {
113 ED_view3d_xr_shading_update(
wm, v3d, scene);
157 ot->
name =
"Toggle VR Session";
158 ot->
idname =
"WM_OT_xr_session_toggle";
160 "Open a view for use with virtual reality headsets, or close it if already "
195 MEM_SAFE_DELETE(
data);
206 if (actiondata->bimanual) {
208 copy_v3_v3(
data->mat_other_prev[3], actiondata->controller_loc_other);
209 data->bimanual_prev =
true;
212 data->bimanual_prev =
false;
219 float x_axis[3], y_axis[3];
233 const float nav_inv[4][4],
241 float prev_base[4][4], curr_base[4][4];
247 const float z_axis[3] = {0.0f, 0.0f, 1.0f};
255 else if (locz_lock) {
256 curr_base[3][2] = prev_base[3][2];
274 const float nav_mat[4][4],
275 const float nav_inv[4][4],
279 const bool nav_lock = (nav_mat && nav_inv);
280 float prev[4][4], curr[4][4];
282 if (!
data->rot_lock) {
292 if (!
data->loc_lock || nav_lock) {
294 copy_v3_v3(curr[3], actiondata->controller_loc);
299 nav_mat, nav_inv,
data->loc_lock,
data->locz_lock,
data->rotz_lock, prev, curr);
326 const float nav_mat[4][4],
327 const float nav_inv[4][4],
331 const bool nav_lock = (nav_mat && nav_inv);
332 float prev[4][4], curr[4][4];
336 if (!
data->rot_lock) {
338 float x_axis_prev[3], x_axis_curr[3], y_axis_prev[3], y_axis_curr[3], z_axis_prev[3],
340 float m0[3][3], m1[3][3];
346 sub_v3_v3v3(x_axis_curr, actiondata->controller_loc, actiondata->controller_loc_other);
367 if (!
data->loc_lock || nav_lock) {
371 add_v3_v3v3(curr[3], actiondata->controller_loc, actiondata->controller_loc_other);
375 if (!
data->scale_lock) {
385 sub_v3_v3v3(
v, actiondata->controller_loc, actiondata->controller_loc_other);
394 nav_mat, nav_inv,
data->loc_lock,
data->locz_lock,
data->rotz_lock, prev, curr);
427 const wmXrActionData *actiondata =
static_cast<const wmXrActionData *
>(
event->customdata);
450 return (actiondata->bimanual &&
data->bimanual_prev);
456 return (!actiondata->bimanual &&
data->bimanual_prev);
462 return data->loc_lock &&
data->rot_lock &&
data->scale_lock;
465 return data->loc_lock &&
data->rot_lock;
469 const wmXrActionData *actiondata,
473 GHOST_XrPose nav_pose;
475 float nav_mat[4][4], nav_inv[4][4], delta[4][4],
out[4][4];
477 const bool need_navinv = (
data->loc_lock ||
data->locz_lock ||
data->rotz_lock);
491 need_navinv ? nav_mat :
nullptr,
492 need_navinv ? nav_inv :
nullptr,
499 need_navinv ? nav_mat :
nullptr,
500 need_navinv ? nav_inv :
nullptr,
513 if (!
data->rot_lock) {
518 if (!
data->scale_lock && bimanual) {
527 if (actiondata->bimanual) {
528 if (!
data->bimanual_prev) {
532 copy_v3_v3(
data->mat_other_prev[3], actiondata->controller_loc_other);
534 data->bimanual_prev =
true;
537 if (
data->bimanual_prev) {
541 data->bimanual_prev =
false;
558 const wmXrActionData *actiondata =
static_cast<const wmXrActionData *
>(
event->customdata);
588 switch (event->
val) {
604 ot->
name =
"XR Navigation Grab";
605 ot->
idname =
"WM_OT_xr_navigation_grab";
606 ot->
description =
"Navigate the VR scene by grabbing with controllers";
617 ot->
srna,
"lock_location",
false,
"Lock Location",
"Prevent changes to viewer location");
619 ot->
srna,
"lock_location_z",
false,
"Lock Elevation",
"Prevent changes to viewer elevation");
621 ot->
srna,
"lock_rotation",
false,
"Lock Rotation",
"Prevent changes to viewer rotation");
625 "Lock Up Orientation",
626 "Prevent changes to viewer up orientation");
627 RNA_def_boolean(ot->
srna,
"lock_scale",
false,
"Lock Scale",
"Prevent changes to viewer scale");
677 MEM_SAFE_DELETE(
data);
683 const float ref_quat[4],
684 const float nav_mat[4][4],
688 float ref_axes[3][3];
736 float z_axis[3], projected[3];
750 const float viewer_mat[4][4],
751 const float nav_mat[4][4],
752 const float nav_inv[4][4],
757 float z_axis[3], m[3][3], prev[4][4], curr[4][4];
775 const float nav_rotation[4],
779 float base_eul[3], base_quatz[4];
807 if (clashes_with_viewfinder) {
842 const wmXrActionData *actiondata =
static_cast<const wmXrActionData *
>(
event->customdata);
847 bool turn, snap_turn,
invert_rotation, swap_hands, locz_lock, dir_lock, speed_frame_based;
848 bool speed_interp_cubic =
false;
849 float speed, speed_max, speed_p0[2], speed_p1[2], button_state;
850 GHOST_XrPose nav_pose;
851 float nav_mat[4][4], delta[4][4],
out[4][4];
854 data->time_prev = time_now;
862 locz_lock =
RNA_boolean_get(op->
ptr, swap_hands ?
"alt_lock_location_z" :
"lock_location_z");
863 dir_lock =
RNA_boolean_get(op->
ptr, swap_hands ?
"alt_lock_direction" :
"lock_direction");
866 speed_frame_based =
false;
869 speed_max =
U.xr_navigation.turn_amount;
873 speed_max =
U.xr_navigation.turn_speed;
886 speed_interp_cubic =
true;
889 speed_p0[0] = speed_p0[1] = 0.0f;
895 speed_interp_cubic =
true;
898 speed_p1[0] = speed_p1[1] = 1.0f;
902 if (speed_max < speed) {
907 switch (actiondata->type) {
915 len_v2(actiondata->state);
916 float speed_t = (actiondata->float_threshold < 1.0f) ?
917 (button_state - actiondata->float_threshold) /
918 (1.0f - actiondata->float_threshold) :
920 if (speed_interp_cubic) {
921 float start[2], end[2], p[2];
925 speed_p0[1] = speed + speed_p0[1] * (speed_max - speed);
926 speed_p1[1] = speed + speed_p1[1] * (speed_max - speed);
934 speed += speed_t * (speed_max - speed);
949 if (dir_lock || (snap_turn &&
data->is_finished) ||
950 (snap_turn && button_state <
RNA_float_get(op->
ptr,
"snap_turn_threshold")))
960 data->is_finished =
true;
967 GHOST_XrPose viewer_pose;
968 float viewer_mat[4][4], nav_inv[4][4];
979 float viewer_scale, ref_quat[4];
987 if (!speed_frame_based) {
1015 copy_qt_qt(ref_quat, actiondata->controller_rot);
1050 ot->
name =
"XR Navigation Fly";
1051 ot->
idname =
"WM_OT_xr_navigation_fly";
1052 ot->
description =
"Move/turn relative to the VR viewer or controller";
1063 {
XR_FLY_FORWARD,
"FORWARD", 0,
"Forward",
"Move along navigation forward axis"},
1064 {
XR_FLY_BACK,
"BACK", 0,
"Back",
"Move along navigation back axis"},
1065 {
XR_FLY_LEFT,
"LEFT", 0,
"Left",
"Move along navigation left axis"},
1066 {
XR_FLY_RIGHT,
"RIGHT", 0,
"Right",
"Move along navigation right axis"},
1067 {
XR_FLY_UP,
"UP", 0,
"Up",
"Move along navigation up axis"},
1068 {
XR_FLY_DOWN,
"DOWN", 0,
"Down",
"Move along navigation down axis"},
1073 "Turn counter-clockwise around navigation up axis"},
1074 {
XR_FLY_TURNRIGHT,
"TURNRIGHT", 0,
"Turn Right",
"Turn clockwise around navigation up axis"},
1079 "Move along viewer's forward axis"},
1080 {
XR_FLY_VIEWER_BACK,
"VIEWER_BACK", 0,
"Viewer Back",
"Move along viewer's back axis"},
1081 {
XR_FLY_VIEWER_LEFT,
"VIEWER_LEFT", 0,
"Viewer Left",
"Move along viewer's left axis"},
1082 {
XR_FLY_VIEWER_RIGHT,
"VIEWER_RIGHT", 0,
"Viewer Right",
"Move along viewer's right axis"},
1084 "CONTROLLER_FORWARD",
1086 "Controller Forward",
1087 "Move along controller's forward axis"},
1088 {0,
nullptr, 0,
nullptr,
nullptr},
1091 static const float default_speed_p0[2] = {0.0f, 0.0f};
1092 static const float default_speed_p1[2] = {1.0f, 1.0f};
1098 "snap_turn_threshold",
1102 "Snap Turn Threshold",
1103 "Input state threshold when using snap turn",
1107 ot->
srna,
"lock_location_z",
false,
"Lock Elevation",
"Prevent changes to viewer elevation");
1112 "Limit movement to viewer's initial direction");
1114 "speed_frame_based",
1116 "Frame Based Speed",
1117 "Apply fixed movement deltas every update");
1119 "turn_speed_factor",
1123 "Turn Speed Factor",
1124 "Ratio between the min and max turn speed",
1133 "Ratio between the min and max fly speed",
1137 "speed_interpolation0",
1142 "Speed Interpolation 0",
1143 "First cubic spline control point between min/max speeds",
1147 "speed_interpolation1",
1152 "Speed Interpolation 1",
1153 "Second cubic spline control point between min/max speeds",
1162 "Fly mode when hands are swapped");
1164 "alt_lock_location_z",
1166 "Lock Elevation (Alt)",
1167 "When hands are swapped, prevent changes to viewer elevation");
1169 "alt_lock_direction",
1171 "Lock Direction (Alt)",
1172 "When hands are swapped, limit movement to viewer's initial direction");
1213 const float dest_width =
data->destination_indicator_width;
1221 const float sphere_width = dest_width * 0.4f;
1233 const float ring_rad_exter = dest_width;
1234 const float ring_rad_inner = dest_width * 0.85f;
1235 const float circle_rad = dest_width * 0.65f;
1237 const float top_height = dest_width * 0.2f;
1238 const float bottom_height = top_height * 0.4f;
1239 constexpr int resolution = 64;
1244 pos, 0.0f, 0.0f, bottom_height, ring_rad_exter, ring_rad_inner, resolution, 0.0f, 360.0f);
1259 const int num_control_points =
data->endpoint_idx + 1;
1260 const Span<float3> arc_control_points =
data->arc_points.as_span().take_front(
1261 num_control_points);
1264 constexpr int segment_samples = 8;
1266 num_control_points,
false, segment_samples);
1271 arc_control_points,
false, segment_samples, spline_points.
as_mutable_span());
1286 for (
int64_t i = 0; i < spline_points.
size(); i++) {
1314 op->
customdata = MEM_new<XrTeleportData>(__func__);
1347 MEM_SAFE_DELETE(
data);
1354 const wmXrActionData *actiondata)
1361 data->init_location = actiondata->controller_loc;
1368 data->teleportation_scale = viewer_scale;
1372 const float origin[3],
1373 const float direction[3],
1375 bool selectable_only,
1376 float r_location[3],
1380 float r_obmat[4][4])
1406 const float gravity = 9.81f;
1410 data->arc_points[0] =
data->init_location;
1411 const float3 direction =
data->init_direction;
1414 const float t = i * time_step;
1416 const float3 velocity_offset = direction * (velocity * t);
1417 const float3 gravity_offset =
float3(0, 0, -0.5f * gravity * t * t);
1419 const float3 offset = (velocity_offset + gravity_offset) *
data->teleportation_scale;
1421 data->arc_points[i] =
data->init_location + offset;
1428 const float3 up_vector = {0.0f, 0.0f, 1.0f};
1429 const float min_ground_dot =
M_SQRT3 / 2.0f;
1431 if (
math::dot(hit_normal, up_vector) < min_ground_dot) {
1442 const float3 &startpoint = points[i - 1];
1443 const float3 &endpoint = points[i];
1446 if (!(startpoint.z > 0 && endpoint.z < 0)) {
1451 const float alpha =
math::safe_divide(startpoint.z, (startpoint.z - endpoint.z));
1471 const float3 segment_start =
data->arc_points[i - 1];
1472 const float3 segment_end =
data->arc_points[i];
1475 const float segment_length =
math::distance(segment_start, segment_end);
1479 const float ray_precision_margin = segment_length * 0.25f;
1480 float3 segment_origin = segment_start;
1482 segment_origin += segment_direction * -ray_precision_margin;
1485 float segment_ray_length = segment_length + (ray_precision_margin * 2.0f);
1489 const Object *ob =
nullptr;
1493 &segment_ray_length,
1503 data->arc_points[i] = hit_location;
1504 data->endpoint_idx = i;
1507 if (
math::dot(segment_direction, hit_normal) > 0) {
1508 hit_normal *= -1.0f;
1537 const float view_height_offset = xr_head_height * viewer_scale;
1539 const float3 ray_destination =
data->arc_points[
data->endpoint_idx];
1540 const float3 view_destination = ray_destination +
float3(0.0f, 0.0f, view_height_offset);
1542 float3 nav_location, viewer_location;
1546 const float3 nav_destination = nav_location + (view_destination - viewer_location);
1548 return nav_destination;
1555 float3 &r_nav_destination)
1611 const wmXrActionData *actiondata =
static_cast<const wmXrActionData *
>(
event->customdata);
1619 float3 nav_destination = {};
1623 switch (
data->ray_result) {
1639 switch (event->
val) {
1661 ot->
name =
"XR Navigation Teleport";
1662 ot->
idname =
"WM_OT_xr_navigation_teleport";
1663 ot->
description =
"Set VR viewer location to controller raycast hit location";
1677 "Only allow selectable objects to influence raycast result");
1686 "Velocity force controlling the teleportation arc parabola in m/s",
1695 "Time step range controlling the teleportation arc parabola",
1706 "Visual width of the teleportation ray line",
1710 "destination_indicator_width",
1714 "Destination Indicator Width",
1715 "Visual width of the hit destination indicator",
1720 static const float default_teleport_ray_hit_color[4] = {0.4f, 0.6f, 0.9f, 1.0f};
1721 static const float default_teleport_ray_miss_color[4] = {1.0f, 0.35f, 0.35f, 1.0f};
1722 static const float default_teleport_ray_fallback_color[4] = {0.5f, 0.45f, 0.8f, 1.0f};
1726 default_teleport_ray_hit_color,
1730 "Color of raycast when it succeeds",
1736 default_teleport_ray_miss_color,
1740 "Color of raycast when it misses",
1746 default_teleport_ray_fallback_color,
1750 "Color of raycast when a fallback case succeeds",
1767 bool reset_loc, reset_rot, reset_scale;
1776 float nav_rotation[4], viewer_scale;
1801 float nav_location[3], nav_rotation[4], viewer_scale;
1802 float nav_axes[3][3],
v[3];
1841 ot->
name =
"XR Navigation Reset";
1842 ot->
idname =
"WM_OT_xr_navigation_reset";
1843 ot->
description =
"Reset VR navigation deltas relative to session base pose";
1898 switch (event->
val) {
1913 ot->
name =
"XR Navigation Swap Hands";
1914 ot->
idname =
"WM_OT_xr_navigation_swap_hands";
1915 ot->
description =
"Swap VR navigation controls between left / right controllers";
Low-level operations for curves.
Platform independent time functions.
#define BLT_I18NCONTEXT_NAVIGATION
#define OPERATOR_RETVAL_CHECK(ret)
#define REGION_DRAW_POST_VIEW
#define GPU_batch_uniform_4fv(batch, name, val)
Read Blender memory allocation and freeing.
#define ND_XR_DATA_CHANGED
#define BLI_assert_unreachable()
MutableSpan< T > as_mutable_span()
void invert_rotation(float4 rotation, float4 &result)
float3x3 scale(float3x3 mat, float2 scale)
int calculate_evaluated_num(int points_num, bool cyclic, int resolution)
void interpolate_to_evaluated(GSpan src, bool cyclic, int resolution, GMutableSpan dst)
QuaternionBase< float > Quaternion
T safe_divide(const T &a, const T &b)
T distance(const T &a, const T &b)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T interpolate(const T &a, const T &b, const FactorT &t)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
void WM_main_add_notifier(uint type, void *reference)
static void wm_xr_navlocks_apply(const float nav_mat[4][4], const float nav_inv[4][4], bool loc_lock, bool locz_lock, bool rotz_lock, float r_prev[4][4], float r_curr[4][4])
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE void negate_v3_v3(float r[3], const float a[3])
void WM_operatortype_append(void(*opfunc)(wmOperatorType *))
void wm_xr_pose_to_mat(const GHOST_XrPose *pose, float r_mat[4][4])
@ V3D_RUNTIME_XR_SESSION_ROOT
static void wm_xr_navigation_teleport_uninit(wmOperator *op)
static void wm_xr_navigation_grab_bimanual_state_update(const wmXrActionData *actiondata, XrGrabData *data)
static wmOperatorStatus wm_xr_navigation_reset_invoke(bContext *C, wmOperator *op, const wmEvent *event)
static void wm_xr_navigation_teleport_draw_destination(const XrTeleportData *data)
int RNA_enum_get(PointerRNA *ptr, const char *name)
static void wm_xr_grab_compute(const wmXrActionData *actiondata, const XrGrabData *data, const float nav_mat[4][4], const float nav_inv[4][4], bool reverse, float r_delta[4][4])
void RNA_property_float_get_array(PointerRNA *ptr, PropertyRNA *prop, float *values)
static void WM_OT_xr_navigation_swap_hands(wmOperatorType *ot)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void GPU_matrix_scale_1f(float factor)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void mat4_to_quat(float q[4], const float mat[4][4])
void imm_draw_cylinder_fill_3d(uint pos, float base, float top, float height, int slices, int stacks)
void WM_xr_session_state_nav_location_set(wmXrData *xr, const float location[3])
void wm_xr_operatortypes_register()
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
PropertyRNA * RNA_def_float_color(StructOrFunctionRNA *cont_, const char *identifier, const int len, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
static void wm_xr_fly_compute_turn(eXrFlyMode mode, float speed, const float viewer_mat[4][4], const float nav_mat[4][4], const float nav_inv[4][4], float r_delta[4][4])
void copy_m4_m3(float m1[4][4], const float m2[3][3])
bool WM_xr_session_exists(const wmXrData *xr)
static void wm_xr_fly_compute_move(eXrFlyMode mode, float speed, const float ref_quat[4], const float nav_mat[4][4], bool locz_lock, float r_delta[4][4])
bool wm_xr_viewfinder_operator_event_match_hand(bContext *C, const wmEvent *event)
void project_v3_v3v3_normalized(float out[3], const float p[3], const float v_proj[3])
static void wm_xr_navigation_teleport_cancel(bContext *, wmOperator *op)
bool WM_xr_session_state_nav_rotation_get(const wmXrData *xr, float r_rotation[4])
GPUVertFormat * immVertexFormat()
float normalize_qt(float q[4])
void immBegin(GPUPrimType, uint vertex_len)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
void quat_to_eul(float eul[3], const float quat[4])
static void wm_xr_navigation_teleport_draw(const bContext *, ARegion *, void *customdata)
static void wm_xr_grab_update(wmOperator *op, const wmXrActionData *actiondata)
static float3 wm_xr_navigation_teleport_get_nav_destination(const wmXrData *xr, XrTeleportData *data)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
bool invert_m4(float mat[4][4])
static void wm_xr_navigation_grab_cancel(bContext *, wmOperator *op)
static constexpr int g_xr_teleportation_arc_num_control_points
void mul_qt_qtqt(float q[4], const float a[4], const float b[4])
ATTR_WARN_UNUSED_RESULT const BMVert * v
void immUniformColor4fv(const float rgba[4])
bool WM_xr_session_state_viewer_scale_get(const wmXrData *xr, float *r_scale)
static void WM_OT_xr_navigation_teleport(wmOperatorType *ot)
static XrTeleportRayResult wm_xr_navigation_teleport_arc_scene_intersect(bContext *C, wmOperator *op, XrTeleportData *data)
bool WM_xr_session_state_nav_location_get(const wmXrData *xr, float r_location[3])
bool wm_xr_init(bContext *C)
static void wm_xr_basenav_rotation_calc(const wmXrData *xr, const float nav_rotation[4], float r_rotation[4])
MINLINE void mul_v3_fl(float r[3], float f)
static void wm_xr_grab_init(wmOperator *op)
PropertyRNA * RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, const int len, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
static wmOperatorStatus wm_xr_navigation_teleport_exec(bContext *, wmOperator *)
MINLINE void sub_v3_v3(float r[3], const float a[3])
static wmOperatorStatus wm_xr_navigation_teleport_modal(bContext *C, wmOperator *op, const wmEvent *event)
void mul_qt_v3(const float q[4], float r[3])
void immBindBuiltinProgram(GPUBuiltinShader shader_id)
static bool wm_xr_navigation_teleport_is_wall_hit(float3 &hit_normal)
static bool wm_xr_navigation_grab_can_do_bimanual(const wmXrActionData *actiondata, const XrGrabData *data)
void GPU_matrix_translate_3fv(const float vec[3])
@ XR_VIEWFINDER_HAND_LEFT
@ XR_VIEWFINDER_HAND_RIGHT
void quat_to_mat3(float m[3][3], const float q[4])
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
@ SCE_SNAP_TARGET_ONLY_SELECTABLE
void * ED_region_draw_cb_activate(ARegionType *art, void(*draw)(const bContext *, ARegion *, void *), void *customdata, int type)
void immUniform1f(const char *name, float x)
static bool wm_xr_navigation_grab_is_locked(const XrGrabData *data, const bool bimanual)
void imm_draw_disk_partial_fill_3d(uint pos, float x, float y, float z, float rad_inner, float rad_outer, int nsegments, float start, float sweep)
@ XR_FLY_CONTROLLER_FORWARD
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
bool ED_region_draw_cb_exit(ARegionType *art, void *handle)
static wmOperatorStatus wm_xr_navigation_fly_modal(bContext *C, wmOperator *op, const wmEvent *event)
void copy_qt_qt(float q[4], const float a[4])
void GPU_viewport_size_get_f(float coords[4])
void WM_xr_session_state_vignette_activate(wmXrData *xr)
BMesh const char void * data
static void wm_xr_navigation_teleport_raycast(Depsgraph *depsgraph, const float origin[3], const float direction[3], float *ray_dist, bool selectable_only, float r_location[3], float r_normal[3], int *r_index, const Object **r_ob, float r_obmat[4][4])
@ GPU_SHADER_3D_POLYLINE_UNIFORM_COLOR
@ GPU_SHADER_3D_UNIFORM_COLOR
wmWindowManager * CTX_wm_manager(const bContext *C)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
static wmOperatorStatus wm_xr_navigation_grab_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void axis_angle_to_quat_single(float q[4], char axis, float angle)
static void wm_xr_fly_init(wmOperator *op, const wmXrData *xr)
static void wm_xr_grab_compute_bimanual(const wmXrActionData *actiondata, const XrGrabData *data, const float nav_mat[4][4], const float nav_inv[4][4], bool reverse, float r_delta[4][4])
MINLINE void negate_v3(float r[3])
bool WM_xr_session_state_viewer_pose_location_get(const wmXrData *xr, float r_location[3])
static void WM_OT_xr_navigation_grab(wmOperatorType *ot)
static wmOperatorStatus wm_xr_navigation_swap_hands_exec(bContext *, wmOperator *)
void GPU_batch_draw(gpu::Batch *batch)
bool WM_xr_session_is_ready(const wmXrData *xr)
void unit_m4(float m[4][4])
bool ED_operator_view3d_active(bContext *C)
void wm_xr_pose_scale_to_mat(const GHOST_XrPose *pose, float scale, float r_mat[4][4])
ARegionType * BKE_regiontype_from_id(const SpaceType *st, int regionid)
SpaceType * BKE_spacetype_from_id(int spaceid)
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
static wmOperatorStatus wm_xr_navigation_teleport_invoke(bContext *C, wmOperator *op, const wmEvent *event)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
static bool wm_xr_operator_test_event(const wmOperator *op, const wmEvent *event)
void WM_xr_session_state_nav_scale_set(wmXrData *xr, float scale)
void imm_draw_circle_fill_3d(uint pos, float x, float y, float radius, int nsegments)
@ USER_XR_NAV_INVERT_ROTATION
static wmOperatorStatus wm_xr_navigation_fly_exec(bContext *, wmOperator *)
@ XR_TELEPORT_RAY_FALLBACK
static wmOperatorStatus wm_xr_navigation_fly_invoke(bContext *C, wmOperator *op, const wmEvent *event)
MINLINE void zero_v3(float r[3])
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void GPU_batch_program_set_builtin(gpu::Batch *batch, GPUBuiltinShader shader_id)
MINLINE float normalize_v3_v3(float r[3], const float a[3])
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
static void wm_xr_session_update_screen_on_exit_cb(const wmXrData *xr_data)
static void wm_xr_fly_uninit(wmOperator *op)
static void orient_mat_z_normalized(float R[4][4], const float z_axis[3])
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
static void wm_xr_navigation_teleport_generate_arc(wmOperator *op, XrTeleportData *data)
static void wm_xr_navigation_teleport_data_update(wmOperator *op, const wmXrData *xr, XrTeleportData *data, const wmXrActionData *actiondata)
static wmOperatorStatus wm_xr_navigation_grab_exec(bContext *, wmOperator *)
MINLINE float normalize_v3(float n[3])
static void WM_OT_xr_navigation_fly(wmOperatorType *ot)
MINLINE void add_v3_v3(float r[3], const float a[3])
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void immVertex3fv(uint attr_id, const float data[3])
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
Main * CTX_data_main(const bContext *C)
static wmOperatorStatus wm_xr_navigation_swap_hands_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void wm_xr_pose_to_imat(const GHOST_XrPose *pose, float r_imat[4][4])
Scene * WM_windows_scene_get_from_screen(const wmWindowManager *wm, const bScreen *screen)
static void WM_OT_xr_session_toggle(wmOperatorType *ot)
void interp_v2_v2v2v2v2_cubic(float p[2], const float v1[2], const float v2[2], const float v3[2], const float v4[2], float u)
static XrTeleportRayResult wm_xr_navigation_teleport_main(bContext *C, wmOperator *op, const wmXrData *xr, XrTeleportData *data, float3 &r_nav_destination)
void WM_xr_session_state_nav_rotation_set(wmXrData *xr, const float rotation[4])
static void wm_xr_session_update_screen(Main *bmain, const wmXrData *xr_data)
bool WM_xr_session_state_viewer_pose_rotation_get(const wmXrData *xr, float r_rotation[4])
double BLI_time_now_seconds()
static wmOperatorStatus wm_xr_navigation_swap_hands_modal(bContext *C, wmOperator *op, const wmEvent *event)
static void wm_xr_grab_uninit(wmOperator *op)
void wm_xr_session_toggle(wmWindowManager *wm, wmXrSessionExitFn session_exit_fn)
void immUniform2fv(const char *name, const float data[2])
gpu::Batch * GPU_batch_preset_sphere(int lod) ATTR_WARN_UNUSED_RESULT
static bool wm_xr_navigation_teleport_arc_clip_to_ground(Array< float3 > &points, int &end_point_idx)
static void wm_xr_navigation_grab_apply(wmXrData *xr, const wmXrActionData *actiondata, const XrGrabData *data, bool bimanual)
void GPU_blend(GPUBlend blend)
static void WM_OT_xr_navigation_reset(wmOperatorType *ot)
void wm_xr_pose_scale_to_imat(const GHOST_XrPose *pose, float scale, float r_imat[4][4])
void copy_m4_m4(float m1[4][4], const float m2[4][4])
void GPU_matrix_translate_3f(float x, float y, float z)
static void wm_xr_navigation_teleport_draw_ray(const XrTeleportData *data)
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
void immUniform1i(const char *name, int x)
static wmOperatorStatus wm_xr_session_toggle_exec(bContext *C, wmOperator *)
static wmOperatorStatus wm_xr_navigation_reset_exec(bContext *C, wmOperator *op)
VecBase< float, 3 > float3
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
void axis_angle_normalized_to_mat3(float R[3][3], const float axis[3], float angle)
void GPU_depth_test(GPUDepthTest test)
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
static bool wm_xr_navigation_grab_is_bimanual_ending(const wmXrActionData *actiondata, const XrGrabData *data)
bool IDP_EqualsProperties(const IDProperty *prop1, const IDProperty *prop2) ATTR_WARN_UNUSED_RESULT
static void wm_xr_navigation_teleport_init(wmOperator *op)
float RNA_float_get(PointerRNA *ptr, const char *name)
bool RNA_property_is_set(PointerRNA *ptr, PropertyRNA *prop)
static wmOperatorStatus wm_xr_navigation_grab_modal(bContext *C, wmOperator *op, const wmEvent *event)
View3D * CTX_wm_view3d(const bContext *C)
static void wm_xr_navigation_fly_cancel(bContext *, wmOperator *op)
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
void quat_to_mat4(float m[4][4], const float q[4])
bool WM_xr_session_state_nav_scale_get(const wmXrData *xr, float *r_scale)
static bool wm_xr_operator_sessionactive(bContext *C)
ListBaseT< wmWindowManager > wm
ListBaseT< bScreen > screens
ListBaseT< SpaceLink > spacedata
float mat_other_prev[4][4]
Array< float3 > arc_points
XrTeleportRayResult ray_result
float teleportation_scale
float destination_indicator_width
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
void(*) cancel(bContext *C, wmOperator *op)
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
struct wmOperatorType * type
XrSessionSettings session_settings
struct wmXrRuntimeData * runtime
wmXrSessionState session_state
GHOST_XrPose prev_local_pose
GHOST_XrPose prev_base_pose