Cleanup: move grid snap functions to files where they are used

4 files changed, 155 insertions, 143 deletions

diff --git a/source/blender/editors/transform/transform_convert_node.cc b/source/blender/editors/transform/transform_convert_node.cc
index eb5eb822d69..0b5dc73a051 100644
--- a/source/blender/editors/transform/transform_convert_node.cc
+++ b/source/blender/editors/transform/transform_convert_node.cc
@@ -16,6 +16,7 @@
 #include "BKE_context.h"
 #include "BKE_node.h"
 #include "BKE_node_tree_update.h"
+#include "BKE_object.h"
 #include "BKE_report.h"
 
 #include "ED_node.h"
@@ -155,9 +156,61 @@ static void createTransNodeData(bContext * /*C*/, TransInfo *t)
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Node Transform Creation
+/** \name Flush Transform Nodes
  * \{ */
 
+static void applyGridAbsolute(TransInfo *t)
+{
+  int i;
+
+  if (!(activeSnap(t) && (t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)))) {
+    return;
+  }
+
+  float grid_size[3];
+  copy_v3_v3(grid_size, t->snap_spatial);
+  if (t->modifiers & MOD_PRECISION) {
+    mul_v3_fl(grid_size, t->snap_spatial_precision);
+  }
+
+  /* Early exit on unusable grid size. */
+  if (is_zero_v3(grid_size)) {
+    return;
+  }
+
+  FOREACH_TRANS_DATA_CONTAINER (t, tc) {
+    TransData *td;
+
+    for (i = 0, td = tc->data; i < tc->data_len; i++, td++) {
+      float iloc[3], loc[3], tvec[3];
+      if (td->flag & TD_SKIP) {
+        continue;
+      }
+
+      if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f)) {
+        continue;
+      }
+
+      copy_v3_v3(iloc, td->loc);
+      if (tc->use_local_mat) {
+        mul_m4_v3(tc->mat, iloc);
+      }
+      else if (t->options & CTX_OBJECT) {
+        BKE_object_eval_transform_all(t->depsgraph, t->scene, td->ob);
+        copy_v3_v3(iloc, td->ob->obmat[3]);
+      }
+
+      loc[0] = roundf(iloc[0] / grid_size[0]) * grid_size[0];
+      loc[1] = roundf(iloc[1] / grid_size[1]) * grid_size[1];
+      loc[2] = grid_size[2] ? roundf(iloc[2] / grid_size[2]) * grid_size[2] : iloc[2];
+
+      sub_v3_v3v3(tvec, loc, iloc);
+      mul_m3_v3(td->smtx, tvec);
+      add_v3_v3(td->loc, tvec);
+    }
+  }
+}
+
 static void flushTransNodes(TransInfo *t)
 {
   using namespace blender::ed;
diff --git a/source/blender/editors/transform/transform_mode_translate.c b/source/blender/editors/transform/transform_mode_translate.c
index b7ffba6ad58..6461182afc1 100644
--- a/source/blender/editors/transform/transform_mode_translate.c
+++ b/source/blender/editors/transform/transform_mode_translate.c
@@ -170,7 +170,7 @@ static void transdata_elem_translate_fn(void *__restrict iter_data_v,
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Transform (Translation)
+/** \name Transform (Translation) Header
  * \{ */
 
 static void translate_dist_to_str(char *r_str,
@@ -341,6 +341,96 @@ static void headerTranslation(TransInfo *t, const float vec[3], char str[UI_MAX_
   }
 }
 
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Transform (Translation) Snapping
+ * \{ */
+
+static void translate_snap_target_grid_ensure(TransInfo *t)
+{
+  /* Only need to calculate once. */
+  if ((t->tsnap.status & TARGET_GRID_INIT) == 0) {
+    if (t->data_type == &TransConvertType_Cursor3D) {
+      /* Use a fallback when transforming the cursor.
+       * In this case the center is _not_ derived from the cursor which is being transformed. */
+      copy_v3_v3(t->tsnap.snapTargetGrid, TRANS_DATA_CONTAINER_FIRST_SINGLE(t)->data->iloc);
+    }
+    else if (t->around == V3D_AROUND_CURSOR) {
+      /* Use a fallback for cursor selection,
+       * this isn't useful as a global center for absolute grid snapping
+       * since its not based on the position of the selection. */
+      tranform_snap_target_median_calc(t, t->tsnap.snapTargetGrid);
+    }
+    else {
+      copy_v3_v3(t->tsnap.snapTargetGrid, t->center_global);
+    }
+    t->tsnap.status |= TARGET_GRID_INIT;
+  }
+}
+
+static void translate_snap_grid_apply(TransInfo *t,
+                            const int max_index,
+                            const float grid_dist[3],
+                            const float loc[3],
+                            float r_out[3])
+{
+  BLI_assert(max_index <= 2);
+  translate_snap_target_grid_ensure(t);
+  const float *center_global = t->tsnap.snapTargetGrid;
+  const float *asp = t->aspect;
+
+  float in[3];
+  if (t->con.mode & CON_APPLY) {
+    BLI_assert(t->tsnap.snapElem == SCE_SNAP_MODE_NONE);
+    t->con.applyVec(t, NULL, NULL, loc, in);
+  }
+  else {
+    copy_v3_v3(in, loc);
+  }
+
+  for (int i = 0; i <= max_index; i++) {
+    const float iter_fac = grid_dist[i] * asp[i];
+    r_out[i] = iter_fac * roundf((in[i] + center_global[i]) / iter_fac) - center_global[i];
+  }
+}
+
+static bool translate_snap_grid(TransInfo *t, float *val)
+{
+  if (!activeSnap(t)) {
+    return false;
+  }
+
+  if (!(t->tsnap.mode & SCE_SNAP_MODE_GRID) || validSnap(t)) {
+    /* Don't do grid snapping if there is a valid snap point. */
+    return false;
+  }
+
+  /* Don't do grid snapping if not in 3D viewport or UV editor */
+  if (!ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE)) {
+    return false;
+  }
+
+  if (t->mode != TFM_TRANSLATION) {
+    return false;
+  }
+
+  float grid_dist[3];
+  copy_v3_v3(grid_dist, t->snap_spatial);
+  if (t->modifiers & MOD_PRECISION) {
+    mul_v3_fl(grid_dist, t->snap_spatial_precision);
+  }
+
+  /* Early bailing out if no need to snap */
+  if (is_zero_v3(grid_dist)) {
+    return false;
+  }
+
+  translate_snap_grid_apply(t, t->idx_max, grid_dist, val, val);
+  t->tsnap.snapElem = SCE_SNAP_MODE_GRID;
+  return true;
+}
+
 static void ApplySnapTranslation(TransInfo *t, float vec[3])
 {
   float point[3];
@@ -372,6 +462,12 @@ static void ApplySnapTranslation(TransInfo *t, float vec[3])
   }
 }
 
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name Transform (Translation)
+ * \{ */
+
 static void applyTranslationValue(TransInfo *t, const float vec[3])
 {
   struct TranslateCustomData *custom_data = t->custom.mode.data;
@@ -514,7 +610,7 @@ static void applyTranslation(TransInfo *t, const int UNUSED(mval[2]))
 
     t->tsnap.snapElem = SCE_SNAP_MODE_NONE;
     applySnappingAsGroup(t, global_dir);
-    transform_snap_grid(t, global_dir);
+    translate_snap_grid(t, global_dir);
 
     if (t->con.mode & CON_APPLY) {
       float in[3];
diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c
index 0d27fc1efd4..672d947936d 100644
--- a/source/blender/editors/transform/transform_snap.c
+++ b/source/blender/editors/transform/transform_snap.c
@@ -511,58 +511,6 @@ void applySnappingIndividual(TransInfo *t)
   }
 }
 
-void applyGridAbsolute(TransInfo *t)
-{
-  int i;
-
-  if (!(activeSnap(t) && (t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)))) {
-    return;
-  }
-
-  float grid_size[3];
-  copy_v3_v3(grid_size, t->snap_spatial);
-  if (t->modifiers & MOD_PRECISION) {
-    mul_v3_fl(grid_size, t->snap_spatial_precision);
-  }
-
-  /* Early exit on unusable grid size. */
-  if (is_zero_v3(grid_size)) {
-    return;
-  }
-
-  FOREACH_TRANS_DATA_CONTAINER (t, tc) {
-    TransData *td;
-
-    for (i = 0, td = tc->data; i < tc->data_len; i++, td++) {
-      float iloc[3], loc[3], tvec[3];
-      if (td->flag & TD_SKIP) {
-        continue;
-      }
-
-      if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f)) {
-        continue;
-      }
-
-      copy_v3_v3(iloc, td->loc);
-      if (tc->use_local_mat) {
-        mul_m4_v3(tc->mat, iloc);
-      }
-      else if (t->options & CTX_OBJECT) {
-        BKE_object_eval_transform_all(t->depsgraph, t->scene, td->ob);
-        copy_v3_v3(iloc, td->ob->obmat[3]);
-      }
-
-      loc[0] = roundf(iloc[0] / grid_size[0]) * grid_size[0];
-      loc[1] = roundf(iloc[1] / grid_size[1]) * grid_size[1];
-      loc[2] = grid_size[2] ? roundf(iloc[2] / grid_size[2]) * grid_size[2] : iloc[2];
-
-      sub_v3_v3v3(tvec, loc, iloc);
-      mul_m3_v3(td->smtx, tvec);
-      add_v3_v3(td->loc, tvec);
-    }
-  }
-}
-
 void applySnappingAsGroup(TransInfo *t, float *vec)
 {
   if (!activeSnap_SnappingAsGroup(t)) {
@@ -1189,7 +1137,7 @@ static void snap_calc_sequencer_fn(TransInfo *t, float *UNUSED(vec))
 /** \name Target
  * \{ */
 
-static void snap_target_median_impl(TransInfo *t, float r_median[3])
+void tranform_snap_target_median_calc(const TransInfo *t, float r_median[3])
 {
   int i_accum = 0;
 
@@ -1225,28 +1173,6 @@ static void snap_target_median_impl(TransInfo *t, float r_median[3])
   // TargetSnapOffset(t, NULL);
 }
 
-static void snap_target_grid_ensure(TransInfo *t)
-{
-  /* Only need to calculate once. */
-  if ((t->tsnap.status & TARGET_GRID_INIT) == 0) {
-    if (t->data_type == &TransConvertType_Cursor3D) {
-      /* Use a fallback when transforming the cursor.
-       * In this case the center is _not_ derived from the cursor which is being transformed. */
-      copy_v3_v3(t->tsnap.snapTargetGrid, TRANS_DATA_CONTAINER_FIRST_SINGLE(t)->data->iloc);
-    }
-    else if (t->around == V3D_AROUND_CURSOR) {
-      /* Use a fallback for cursor selection,
-       * this isn't useful as a global center for absolute grid snapping
-       * since its not based on the position of the selection. */
-      snap_target_median_impl(t, t->tsnap.snapTargetGrid);
-    }
-    else {
-      copy_v3_v3(t->tsnap.snapTargetGrid, t->center_global);
-    }
-    t->tsnap.status |= TARGET_GRID_INIT;
-  }
-}
-
 static void TargetSnapOffset(TransInfo *t, TransData *td)
 {
   if (t->spacetype == SPACE_NODE && td != NULL) {
@@ -1318,7 +1244,7 @@ static void TargetSnapMedian(TransInfo *t)
 {
   /* Only need to calculate once. */
   if ((t->tsnap.status & TARGET_INIT) == 0) {
-    snap_target_median_impl(t, t->tsnap.snapTarget);
+    tranform_snap_target_median_calc(t, t->tsnap.snapTarget);
     t->tsnap.status |= TARGET_INIT;
   }
 }
@@ -1656,68 +1582,6 @@ bool snapNodesTransform(
 /** \name snap Grid
  * \{ */
 
-static void snap_grid_apply(TransInfo *t,
-                            const int max_index,
-                            const float grid_dist[3],
-                            const float loc[3],
-                            float r_out[3])
-{
-  BLI_assert(max_index <= 2);
-  snap_target_grid_ensure(t);
-  const float *center_global = t->tsnap.snapTargetGrid;
-  const float *asp = t->aspect;
-
-  float in[3];
-  if (t->con.mode & CON_APPLY) {
-    BLI_assert(t->tsnap.snapElem == SCE_SNAP_MODE_NONE);
-    t->con.applyVec(t, NULL, NULL, loc, in);
-  }
-  else {
-    copy_v3_v3(in, loc);
-  }
-
-  for (int i = 0; i <= max_index; i++) {
-    const float iter_fac = grid_dist[i] * asp[i];
-    r_out[i] = iter_fac * roundf((in[i] + center_global[i]) / iter_fac) - center_global[i];
-  }
-}
-
-bool transform_snap_grid(TransInfo *t, float *val)
-{
-  if (!activeSnap(t)) {
-    return false;
-  }
-
-  if (!(t->tsnap.mode & SCE_SNAP_MODE_GRID) || validSnap(t)) {
-    /* Don't do grid snapping if there is a valid snap point. */
-    return false;
-  }
-
-  /* Don't do grid snapping if not in 3D viewport or UV editor */
-  if (!ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE)) {
-    return false;
-  }
-
-  if (t->mode != TFM_TRANSLATION) {
-    return false;
-  }
-
-  float grid_dist[3];
-  copy_v3_v3(grid_dist, t->snap_spatial);
-  if (t->modifiers & MOD_PRECISION) {
-    mul_v3_fl(grid_dist, t->snap_spatial_precision);
-  }
-
-  /* Early bailing out if no need to snap */
-  if (is_zero_v3(grid_dist)) {
-    return false;
-  }
-
-  snap_grid_apply(t, t->idx_max, grid_dist, val, val);
-  t->tsnap.snapElem = SCE_SNAP_MODE_GRID;
-  return true;
-}
-
 static void snap_increment_apply_ex(const TransInfo *UNUSED(t),
                                     const int max_index,
                                     const float increment_val,
diff --git a/source/blender/editors/transform/transform_snap.h b/source/blender/editors/transform/transform_snap.h
index 2b78c554ad8..16d9062e978 100644
--- a/source/blender/editors/transform/transform_snap.h
+++ b/source/blender/editors/transform/transform_snap.h
@@ -38,10 +38,10 @@ bool snapNodesTransform(struct TransInfo *t,
 
 bool transformModeUseSnap(const TransInfo *t);
 
+void tranform_snap_target_median_calc(const TransInfo *t, float r_median[3]);
 bool transform_snap_increment_ex(const TransInfo *t, bool use_local_space, float *r_val);
 bool transform_snap_increment(const TransInfo *t, float *val);
 float transform_snap_increment_get(const TransInfo *t);
-bool transform_snap_grid(TransInfo *t, float *val);
 
 bool activeSnap(const TransInfo *t);
 bool activeSnap_SnappingIndividual(const TransInfo *t);
@@ -52,7 +52,6 @@ bool validSnap(const TransInfo *t);
 void initSnapping(struct TransInfo *t, struct wmOperator *op);
 void freeSnapping(struct TransInfo *t);
 void applySnappingIndividual(TransInfo *t);
-void applyGridAbsolute(TransInfo *t);
 void applySnappingAsGroup(TransInfo *t, float *vec);
 void resetSnapping(TransInfo *t);
 eRedrawFlag handleSnapping(TransInfo *t, const struct wmEvent *event);