Cleanup

- Use doxygen style comments
- Improve comment for XR region type
- Improve RNA descriptions for XR nav location/rotation/scale
- Split controller draw callback into separate model and aim functions

1 files changed, 136 insertions, 134 deletions

diff --git a/source/blender/windowmanager/xr/intern/wm_xr_draw.c b/source/blender/windowmanager/xr/intern/wm_xr_draw.c
index bbbf7a16c9f..3287e29cdcf 100644
--- a/source/blender/windowmanager/xr/intern/wm_xr_draw.c
+++ b/source/blender/windowmanager/xr/intern/wm_xr_draw.c
@@ -244,162 +244,164 @@ static GPUBatch *wm_xr_controller_model_batch_create(GHOST_XrContextHandle xr_co
   return GPU_batch_create_ex(GPU_PRIM_TRIS, vbo, ibo, GPU_BATCH_OWNS_VBO | GPU_BATCH_OWNS_INDEX);
 }
 
-void wm_xr_draw_controllers(const bContext *UNUSED(C), ARegion *UNUSED(region), void *customdata)
+static void wm_xr_controller_model_draw(const XrSessionSettings *settings,
+                                        GHOST_XrContextHandle xr_context,
+                                        wmXrSessionState *state)
 {
-  const wmXrData *xr = customdata;
-  const XrSessionSettings *settings = &xr->session_settings;
-  wmXrSessionState *state = &xr->runtime->session_state;
-
-  /* Model. */
-  {
-    GHOST_XrContextHandle xr_context = xr->runtime->context;
-    GHOST_XrControllerModelData model_data;
-    float color[4];
-
-    switch (settings->controller_draw_style) {
-      case XR_CONTROLLER_DRAW_DARK:
-      case XR_CONTROLLER_DRAW_DARK_RAY:
-        color[0] = color[1] = color[2] = 0.0f, color[3] = 0.4f;
-        break;
-      case XR_CONTROLLER_DRAW_LIGHT:
-      case XR_CONTROLLER_DRAW_LIGHT_RAY:
-        color[0] = 0.422f, color[1] = 0.438f, color[2] = 0.446f, color[3] = 0.4f;
-        break;
-    }
-
-    GPU_depth_test(GPU_DEPTH_NONE);
-    GPU_blend(GPU_BLEND_ALPHA);
+  GHOST_XrControllerModelData model_data;
 
-    LISTBASE_FOREACH (wmXrController *, controller, &state->controllers) {
-      GPUBatch *model = controller->model;
-      if (!model) {
-        model = controller->model = wm_xr_controller_model_batch_create(
-            xr_context, controller->subaction_path);
-      }
+  float color[4];
+  switch (settings->controller_draw_style) {
+    case XR_CONTROLLER_DRAW_DARK:
+    case XR_CONTROLLER_DRAW_DARK_RAY:
+      color[0] = color[1] = color[2] = 0.0f, color[3] = 0.4f;
+      break;
+    case XR_CONTROLLER_DRAW_LIGHT:
+    case XR_CONTROLLER_DRAW_LIGHT_RAY:
+      color[0] = 0.422f, color[1] = 0.438f, color[2] = 0.446f, color[3] = 0.4f;
+      break;
+  }
 
-      if (model &&
-          GHOST_XrGetControllerModelData(xr_context, controller->subaction_path, &model_data) &&
-          model_data.count_components > 0) {
-        GPU_batch_program_set_builtin(model, GPU_SHADER_3D_UNIFORM_COLOR);
-        GPU_batch_uniform_4fv(model, "color", color);
+  GPU_depth_test(GPU_DEPTH_NONE);
+  GPU_blend(GPU_BLEND_ALPHA);
 
-        GPU_matrix_push();
-        GPU_matrix_mul(controller->grip_mat);
-        for (unsigned int component_idx = 0; component_idx < model_data.count_components;
-             ++component_idx) {
-          const GHOST_XrControllerModelComponent *component =
-              &model_data.components[component_idx];
-          GPU_matrix_push();
-          GPU_matrix_mul(component->transform);
-          GPU_batch_draw_range(model,
-                               model->elem ? component->index_offset : component->vertex_offset,
-                               model->elem ? component->index_count : component->vertex_count);
-          GPU_matrix_pop();
-        }
-        GPU_matrix_pop();
-      }
-      else {
-        /* Fallback. */
-        const float scale = 0.05f;
-        GPUBatch *sphere = GPU_batch_preset_sphere(2);
-        GPU_batch_program_set_builtin(sphere, GPU_SHADER_3D_UNIFORM_COLOR);
-        GPU_batch_uniform_4fv(sphere, "color", color);
+  LISTBASE_FOREACH (wmXrController *, controller, &state->controllers) {
+    GPUBatch *model = controller->model;
+    if (!model) {
+      model = controller->model = wm_xr_controller_model_batch_create(xr_context,
+                                                                      controller->subaction_path);
+    }
 
+    if (model &&
+        GHOST_XrGetControllerModelData(xr_context, controller->subaction_path, &model_data) &&
+        model_data.count_components > 0) {
+      GPU_batch_program_set_builtin(model, GPU_SHADER_3D_UNIFORM_COLOR);
+      GPU_batch_uniform_4fv(model, "color", color);
+
+      GPU_matrix_push();
+      GPU_matrix_mul(controller->grip_mat);
+      for (unsigned int component_idx = 0; component_idx < model_data.count_components;
+           ++component_idx) {
+        const GHOST_XrControllerModelComponent *component = &model_data.components[component_idx];
         GPU_matrix_push();
-        GPU_matrix_mul(controller->grip_mat);
-        GPU_matrix_scale_1f(scale);
-        GPU_batch_draw(sphere);
+        GPU_matrix_mul(component->transform);
+        GPU_batch_draw_range(model,
+                             model->elem ? component->index_offset : component->vertex_offset,
+                             model->elem ? component->index_count : component->vertex_count);
         GPU_matrix_pop();
       }
+      GPU_matrix_pop();
     }
-  }
-
-  /* Aim. */
-  {
-    bool draw_ray;
-
-    switch (settings->controller_draw_style) {
-      case XR_CONTROLLER_DRAW_DARK:
-      case XR_CONTROLLER_DRAW_LIGHT:
-        draw_ray = false;
-        break;
-      case XR_CONTROLLER_DRAW_DARK_RAY:
-      case XR_CONTROLLER_DRAW_LIGHT_RAY:
-        draw_ray = true;
-        break;
+    else {
+      /* Fallback. */
+      const float scale = 0.05f;
+      GPUBatch *sphere = GPU_batch_preset_sphere(2);
+      GPU_batch_program_set_builtin(sphere, GPU_SHADER_3D_UNIFORM_COLOR);
+      GPU_batch_uniform_4fv(sphere, "color", color);
+
+      GPU_matrix_push();
+      GPU_matrix_mul(controller->grip_mat);
+      GPU_matrix_scale_1f(scale);
+      GPU_batch_draw(sphere);
+      GPU_matrix_pop();
     }
+  }
+}
 
-    GPUVertFormat *format = immVertexFormat();
-    uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
-    uint col = GPU_vertformat_attr_add(
-        format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
-    immBindBuiltinProgram(GPU_SHADER_3D_POLYLINE_FLAT_COLOR);
+static void wm_xr_controller_aim_draw(const XrSessionSettings *settings, wmXrSessionState *state)
+{
+  bool draw_ray;
+  switch (settings->controller_draw_style) {
+    case XR_CONTROLLER_DRAW_DARK:
+    case XR_CONTROLLER_DRAW_LIGHT:
+      draw_ray = false;
+      break;
+    case XR_CONTROLLER_DRAW_DARK_RAY:
+    case XR_CONTROLLER_DRAW_LIGHT_RAY:
+      draw_ray = true;
+      break;
+  }
 
-    float viewport[4];
-    GPU_viewport_size_get_f(viewport);
-    immUniform2fv("viewportSize", &viewport[2]);
+  GPUVertFormat *format = immVertexFormat();
+  uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
+  uint col = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
+  immBindBuiltinProgram(GPU_SHADER_3D_POLYLINE_FLAT_COLOR);
 
-    immUniform1f("lineWidth", 3.0f * U.pixelsize);
+  float viewport[4];
+  GPU_viewport_size_get_f(viewport);
+  immUniform2fv("viewportSize", &viewport[2]);
 
-    if (draw_ray) {
-      const uchar color[4] = {89, 89, 255, 127};
-      const float scale = settings->clip_end;
-      float ray[3];
+  immUniform1f("lineWidth", 3.0f * U.pixelsize);
 
-      GPU_depth_test(GPU_DEPTH_LESS_EQUAL);
-      GPU_blend(GPU_BLEND_ALPHA);
+  if (draw_ray) {
+    const uchar color[4] = {89, 89, 255, 127};
+    const float scale = settings->clip_end;
+    float ray[3];
 
-      immBegin(GPU_PRIM_LINES, (uint)BLI_listbase_count(&state->controllers) * 2);
+    GPU_depth_test(GPU_DEPTH_LESS_EQUAL);
+    GPU_blend(GPU_BLEND_ALPHA);
 
-      LISTBASE_FOREACH (wmXrController *, controller, &state->controllers) {
-        const float(*mat)[4] = controller->aim_mat;
-        madd_v3_v3v3fl(ray, mat[3], mat[2], -scale);
+    immBegin(GPU_PRIM_LINES, (uint)BLI_listbase_count(&state->controllers) * 2);
 
-        immAttrSkip(col);
-        immVertex3fv(pos, mat[3]);
-        immAttr4ubv(col, color);
-        immVertex3fv(pos, ray);
-      }
+    LISTBASE_FOREACH (wmXrController *, controller, &state->controllers) {
+      const float(*mat)[4] = controller->aim_mat;
+      madd_v3_v3v3fl(ray, mat[3], mat[2], -scale);
 
-      immEnd();
+      immAttrSkip(col);
+      immVertex3fv(pos, mat[3]);
+      immAttr4ubv(col, color);
+      immVertex3fv(pos, ray);
     }
-    else {
-      const uchar r[4] = {255, 51, 82, 255};
-      const uchar g[4] = {139, 220, 0, 255};
-      const uchar b[4] = {40, 144, 255, 255};
-      const float scale = 0.01f;
-      float x_axis[3], y_axis[3], z_axis[3];
-
-      GPU_depth_test(GPU_DEPTH_NONE);
-      GPU_blend(GPU_BLEND_NONE);
-
-      immBegin(GPU_PRIM_LINES, (uint)BLI_listbase_count(&state->controllers) * 6);
-
-      LISTBASE_FOREACH (wmXrController *, controller, &state->controllers) {
-        const float(*mat)[4] = controller->aim_mat;
-        madd_v3_v3v3fl(x_axis, mat[3], mat[0], scale);
-        madd_v3_v3v3fl(y_axis, mat[3], mat[1], scale);
-        madd_v3_v3v3fl(z_axis, mat[3], mat[2], scale);
-
-        immAttrSkip(col);
-        immVertex3fv(pos, mat[3]);
-        immAttr4ubv(col, r);
-        immVertex3fv(pos, x_axis);
-
-        immAttrSkip(col);
-        immVertex3fv(pos, mat[3]);
-        immAttr4ubv(col, g);
-        immVertex3fv(pos, y_axis);
-
-        immAttrSkip(col);
-        immVertex3fv(pos, mat[3]);
-        immAttr4ubv(col, b);
-        immVertex3fv(pos, z_axis);
-      }
 
-      immEnd();
+    immEnd();
+  }
+  else {
+    const uchar r[4] = {255, 51, 82, 255};
+    const uchar g[4] = {139, 220, 0, 255};
+    const uchar b[4] = {40, 144, 255, 255};
+    const float scale = 0.01f;
+    float x_axis[3], y_axis[3], z_axis[3];
+
+    GPU_depth_test(GPU_DEPTH_NONE);
+    GPU_blend(GPU_BLEND_NONE);
+
+    immBegin(GPU_PRIM_LINES, (uint)BLI_listbase_count(&state->controllers) * 6);
+
+    LISTBASE_FOREACH (wmXrController *, controller, &state->controllers) {
+      const float(*mat)[4] = controller->aim_mat;
+      madd_v3_v3v3fl(x_axis, mat[3], mat[0], scale);
+      madd_v3_v3v3fl(y_axis, mat[3], mat[1], scale);
+      madd_v3_v3v3fl(z_axis, mat[3], mat[2], scale);
+
+      immAttrSkip(col);
+      immVertex3fv(pos, mat[3]);
+      immAttr4ubv(col, r);
+      immVertex3fv(pos, x_axis);
+
+      immAttrSkip(col);
+      immVertex3fv(pos, mat[3]);
+      immAttr4ubv(col, g);
+      immVertex3fv(pos, y_axis);
+
+      immAttrSkip(col);
+      immVertex3fv(pos, mat[3]);
+      immAttr4ubv(col, b);
+      immVertex3fv(pos, z_axis);
     }
 
-    immUnbindProgram();
+    immEnd();
   }
+
+  immUnbindProgram();
+}
+
+void wm_xr_draw_controllers(const bContext *UNUSED(C), ARegion *UNUSED(region), void *customdata)
+{
+  wmXrData *xr = customdata;
+  const XrSessionSettings *settings = &xr->session_settings;
+  GHOST_XrContextHandle xr_context = xr->runtime->context;
+  wmXrSessionState *state = &xr->runtime->session_state;
+
+  wm_xr_controller_model_draw(settings, xr_context, state);
+  wm_xr_controller_aim_draw(settings, state);
 }