wm_xr_intern.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "CLG_log.h"
 
#include "GHOST_Types.h"
 
#include "DNA_listBase.h"
#include "DNA_xr_types.h"
 
#include "wm_xr.hh"
 
struct bContext;
struct ARegion;
struct Object;
struct wmWindow;
struct wmWindowManager;
struct wmXrActionSet;
struct wmXrData;
 
struct wmXrSessionState {
  bool is_started;

  GHOST_XrPose viewer_pose;
  float viewer_viewmat[4][4];
  float viewer_mat_base[4][4];
  float focal_len;

  char prev_base_pose_type; /* #eXRSessionBasePoseType. */
  Object *prev_base_pose_object;
  int prev_settings_flag;
  GHOST_XrPose prev_base_pose;
  float prev_base_scale;
  GHOST_XrPose prev_local_pose;
  float prev_eye_position_ofs[3];
 
  bool force_reset_to_base_pose;
  bool is_view_data_set;
  bool swap_hands;
  bool is_raycast_shown;

  GHOST_XrPose nav_pose;
  float nav_scale;
  GHOST_XrPose nav_pose_prev;
  float nav_scale_prev;
  bool is_navigation_dirty;

  ListBase controllers; /* #wmXrController. */

  struct wmXrActionSet *active_action_set;
  /* Name of the action set (if any) to activate before the next actions sync. */
  char active_action_set_next[64]; /* #MAX_NAME. */

  struct wmXrVignetteData *vignette_data;

  blender::gpu::Batch *raycast_model;
};
 
struct wmXrRuntimeData {
  GHOST_XrContextHandle context;

  wmWindow *session_root_win;

  struct ScrArea *area;

  wmXrSessionState session_state;
  wmXrSessionExitFn exit_fn;
 
  ListBase actionmaps; /* #XrActionMap. */
  short actactionmap;
  short selactionmap;
};
 
struct wmXrViewportPair {
  struct wmXrViewportPair *next, *prev;
  struct GPUOffScreen *offscreen;
  struct GPUViewport *viewport;
};
 
struct wmXrSurfaceData {
  ListBase viewports; /* #wmXrViewportPair. */

  struct ARegionType *controller_art;
  void *controller_draw_handle;
};
 
struct wmXrDrawData {
  struct Scene *scene;
  struct Depsgraph *depsgraph;
 
  wmXrData *xr_data;
  wmXrSurfaceData *surface_data;

  GHOST_XrPose base_pose;
  float base_scale;
  float eye_position_ofs[3]; /* Local/view space. */
};
 
struct wmXrController {
  struct wmXrController *next, *prev;
  char subaction_path[64]; /* #XR_MAX_USER_PATH_LENGTH. */

  bool grip_active;
  GHOST_XrPose grip_pose;
  float grip_mat[4][4];
  float grip_mat_base[4][4];
  bool aim_active;
  GHOST_XrPose aim_pose;
  float aim_mat[4][4];
  float aim_mat_base[4][4];

  blender::gpu::Batch *model;
};
 
struct wmXrAction {
  char *name;
  eXrActionType type;
  unsigned int count_subaction_paths;
  char **subaction_paths;
  void *states;
  void *states_prev;

  float *float_thresholds;
  eXrAxisFlag *axis_flags;

  const char *active_modal_path;

  struct wmOperatorType *ot;
  IDProperty *op_properties;

  char *haptic_name;
  int64_t haptic_duration;
  float haptic_frequency;
  float haptic_amplitude;

  eXrOpFlag op_flag;
  eXrActionFlag action_flag;
  eXrHapticFlag haptic_flag;
};
 
struct wmXrHapticAction {
  struct wmXrHapticAction *next, *prev;
  wmXrAction *action;
  const char *subaction_path;
  int64_t time_start;
};
 
struct wmXrActionSet {
  char *name;

  wmXrAction *controller_grip_action;
  wmXrAction *controller_aim_action;

  ListBase active_modal_actions;
  ListBase active_haptic_actions;
};
 
struct wmXrVignetteData {
  float aperture;
  float aperture_velocity;

  float initial_aperture;
  float initial_aperture_velocity;
 
  float aperture_min;
  float aperture_max;
 
  float aperture_velocity_max;
  float aperture_velocity_delta;
};
 
/* `wm_xr.cc` */
 
wmXrRuntimeData *wm_xr_runtime_data_create();
void wm_xr_runtime_data_free(wmXrRuntimeData **runtime);
 
/* `wm_xr_session.cc` */
 
void wm_xr_session_data_free(wmXrSessionState *state);
wmWindow *wm_xr_session_root_window_or_fallback_get(const wmWindowManager *wm,
                                                    const wmXrRuntimeData *runtime_data);
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_update(const XrSessionSettings *settings,
                                const wmXrDrawData *draw_data,
                                const GHOST_XrDrawViewInfo *draw_view,
                                wmXrSessionState *state);
bool wm_xr_session_surface_offscreen_ensure(wmXrSurfaceData *surface_data,
                                            const GHOST_XrDrawViewInfo *draw_view);
void *wm_xr_session_gpu_binding_context_create();
void wm_xr_session_gpu_binding_context_destroy(GHOST_ContextHandle context);
 
void wm_xr_session_actions_init(wmXrData *xr);
void wm_xr_session_actions_update(wmWindowManager *wm);
void wm_xr_session_controller_data_populate(const wmXrAction *grip_action,
                                            const wmXrAction *aim_action,
                                            wmXrData *xr);
void wm_xr_session_controller_data_clear(wmXrSessionState *state);
 
/* `wm_xr_draw.cc` */
 
void wm_xr_pose_to_mat(const GHOST_XrPose *pose, float r_mat[4][4]);
void wm_xr_pose_scale_to_mat(const GHOST_XrPose *pose, float scale, float r_mat[4][4]);
void wm_xr_pose_to_imat(const GHOST_XrPose *pose, float r_imat[4][4]);
void wm_xr_pose_scale_to_imat(const GHOST_XrPose *pose, float scale, float r_imat[4][4]);
void wm_xr_draw_view(const GHOST_XrDrawViewInfo *draw_view, void *customdata);
void wm_xr_draw_controllers(const bContext *C, ARegion *region, void *customdata);

bool wm_xr_passthrough_enabled(void *customdata);
void wm_xr_disable_passthrough(void *customdata);