diff --git a/source/blender/editors/include/ED_transform_snap_object_context.h b/source/blender/editors/include/ED_transform_snap_object_context.h
index f9ca578f282..99b7d95c74c 100644
--- a/source/blender/editors/include/ED_transform_snap_object_context.h
+++ b/source/blender/editors/include/ED_transform_snap_object_context.h
@@ -53,7 +53,7 @@ struct SnapObjectHitDepth {
 /** parameters that define which objects will be used to snap. */
 struct SnapObjectParams {
   /* Special context sensitive handling for the active or selected object. */
-  eSnapTargetSelect snap_target_select;
+  eSnapTargetOP snap_target_select;
   /* Geometry for snapping in edit mode. */
   eSnapEditType edit_mode_type;
   /* snap to the closest element, use when using more than one snap type */
diff --git a/source/blender/editors/transform/transform.c b/source/blender/editors/transform/transform.c
index ff93bcaf8ca..c9cf572e9ad 100644
--- a/source/blender/editors/transform/transform.c
+++ b/source/blender/editors/transform/transform.c
@@ -1573,9 +1573,9 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
     if ((prop = RNA_struct_find_property(op->ptr, "snap_elements"))) {
       RNA_property_enum_set(op->ptr, prop, t->tsnap.mode);
       RNA_boolean_set(op->ptr, "use_snap_project", t->tsnap.project);
-      RNA_enum_set(op->ptr, "snap_target", t->tsnap.source_select);
+      RNA_enum_set(op->ptr, "snap_target", t->tsnap.source_operation);
 
-      eSnapTargetSelect target = t->tsnap.target_select;
+      eSnapTargetOP target = t->tsnap.target_operation;
       RNA_boolean_set(op->ptr, "use_snap_self", (target & SCE_SNAP_TARGET_NOT_ACTIVE) == 0);
       RNA_boolean_set(op->ptr, "use_snap_edit", (target & SCE_SNAP_TARGET_NOT_EDITED) == 0);
       RNA_boolean_set(op->ptr, "use_snap_nonedit", (target & SCE_SNAP_TARGET_NOT_NONEDITED) == 0);
diff --git a/source/blender/editors/transform/transform.h b/source/blender/editors/transform/transform.h
index 29df931e136..13362cee2b6 100644
--- a/source/blender/editors/transform/transform.h
+++ b/source/blender/editors/transform/transform.h
@@ -160,13 +160,13 @@ ENUM_OPERATORS(eTModifier, MOD_NODE_ATTACH)
 typedef enum eTSnap {
   SNAP_RESETTED = 0,
   SNAP_FORCED = 1 << 0,
-  TARGET_INIT = 1 << 1,
+  SNAP_SOURCE_FOUND = 1 << 1,
   /* Special flag for snap to grid. */
-  TARGET_GRID_INIT = 1 << 2,
-  POINT_INIT = 1 << 3,
-  MULTI_POINTS = 1 << 4,
+  SNAP_TARGET_GRID_FOUND = 1 << 2,
+  SNAP_TARGET_FOUND = 1 << 3,
+  SNAP_MULTI_POINTS = 1 << 4,
 } eTSnap;
-ENUM_OPERATORS(eTSnap, MULTI_POINTS)
+ENUM_OPERATORS(eTSnap, SNAP_MULTI_POINTS)
 
 /** #TransCon.mode, #TransInfo.con.mode */
 typedef enum {
@@ -276,9 +276,9 @@ typedef struct TransSnap {
   /* Method(s) used for snapping source to target */
   eSnapMode mode;
   /* Part of source to snap to target */
-  eSnapSourceSelect source_select;
+  eSnapSourceOP source_operation;
   /* Determines which objects are possible target */
-  eSnapTargetSelect target_select;
+  eSnapTargetOP target_operation;
   bool align;
   bool project;
   bool peel;
@@ -288,25 +288,25 @@ typedef struct TransSnap {
   /* Snapped Element Type (currently for objects only). */
   eSnapMode snapElem;
   /** snapping from this point (in global-space). */
-  float snapTarget[3];
+  float snap_source[3];
   /** to this point (in global-space). */
-  float snapPoint[3];
-  float snapTargetGrid[3];
+  float snap_target[3];
+  float snap_target_grid[3];
   float snapNormal[3];
   char snapNodeBorder;
   ListBase points;
   TransSnapPoint *selectedPoint;
   double last;
-  void (*applySnap)(struct TransInfo *, float *);
-  void (*calcSnap)(struct TransInfo *, float *);
-  void (*targetSnap)(struct TransInfo *);
+  void (*snap_target_fn)(struct TransInfo *, float *);
+  void (*snap_source_fn)(struct TransInfo *);
   /**
    * Get the transform distance between two points (used by Closest snap)
    *
    * \note Return value can be anything,
    * where the smallest absolute value defines what's closest.
    */
-  float (*distance)(struct TransInfo *t, const float p1[3], const float p2[3]);
+  float (*snap_mode_distance_fn)(struct TransInfo *t, const float p1[3], const float p2[3]);
+  void (*snap_mode_apply_fn)(struct TransInfo *, float *);
 
   /**
    * Re-usable snap context data.
diff --git a/source/blender/editors/transform/transform_constraints.c b/source/blender/editors/transform/transform_constraints.c
index b0db9398e80..61adc98c258 100644
--- a/source/blender/editors/transform/transform_constraints.c
+++ b/source/blender/editors/transform/transform_constraints.c
@@ -270,12 +270,12 @@ static void axisProjection(const TransInfo *t,
 static void constraint_snap_plane_to_edge(const TransInfo *t, const float plane[4], float r_out[3])
 {
   float lambda;
-  const float *edge_snap_point = t->tsnap.snapPoint;
+  const float *edge_snap_point = t->tsnap.snap_target;
   const float *edge_dir = t->tsnap.snapNormal;
   bool is_aligned = fabsf(dot_v3v3(edge_dir, plane)) < CONSTRAIN_EPSILON;
   if (!is_aligned && isect_ray_plane_v3(edge_snap_point, edge_dir, plane, &lambda, false)) {
     madd_v3_v3v3fl(r_out, edge_snap_point, edge_dir, lambda);
-    sub_v3_v3(r_out, t->tsnap.snapTarget);
+    sub_v3_v3(r_out, t->tsnap.snap_source);
   }
 }
 
@@ -284,13 +284,13 @@ static void UNUSED_FUNCTION(constraint_snap_plane_to_face(const TransInfo *t,
                                                           float r_out[3]))
 {
   float face_plane[4], isect_orig[3], isect_dir[3];
-  const float *face_snap_point = t->tsnap.snapPoint;
+  const float *face_snap_point = t->tsnap.snap_target;
   const float *face_normal = t->tsnap.snapNormal;
   plane_from_point_normal_v3(face_plane, face_snap_point, face_normal);
   bool is_aligned = fabsf(dot_v3v3(plane, face_plane)) > (1.0f - CONSTRAIN_EPSILON);
   if (!is_aligned && isect_plane_plane_v3(plane, face_plane, isect_orig, isect_dir)) {
     closest_to_ray_v3(r_out, face_snap_point, isect_orig, isect_dir);
-    sub_v3_v3(r_out, t->tsnap.snapTarget);
+    sub_v3_v3(r_out, t->tsnap.snap_source);
   }
 }
 
@@ -299,11 +299,11 @@ void transform_constraint_snap_axis_to_edge(const TransInfo *t,
                                             float r_out[3])
 {
   float lambda;
-  const float *edge_snap_point = t->tsnap.snapPoint;
+  const float *edge_snap_point = t->tsnap.snap_target;
   const float *edge_dir = t->tsnap.snapNormal;
   bool is_aligned = fabsf(dot_v3v3(axis, edge_dir)) > (1.0f - CONSTRAIN_EPSILON);
   if (!is_aligned &&
-      isect_ray_ray_v3(t->tsnap.snapTarget, axis, edge_snap_point, edge_dir, &lambda, NULL)) {
+      isect_ray_ray_v3(t->tsnap.snap_source, axis, edge_snap_point, edge_dir, &lambda, NULL)) {
     mul_v3_v3fl(r_out, axis, lambda);
   }
 }
@@ -314,11 +314,11 @@ void transform_constraint_snap_axis_to_face(const TransInfo *t,
 {
   float lambda;
   float face_plane[4];
-  const float *face_snap_point = t->tsnap.snapPoint;
+  const float *face_snap_point = t->tsnap.snap_target;
   const float *face_normal = t->tsnap.snapNormal;
   plane_from_point_normal_v3(face_plane, face_snap_point, face_normal);
   bool is_aligned = fabsf(dot_v3v3(axis, face_plane)) < CONSTRAIN_EPSILON;
-  if (!is_aligned && isect_ray_plane_v3(t->tsnap.snapTarget, axis, face_plane, &lambda, false)) {
+  if (!is_aligned && isect_ray_plane_v3(t->tsnap.snap_source, axis, face_plane, &lambda, false)) {
     mul_v3_v3fl(r_out, axis, lambda);
   }
 }
diff --git a/source/blender/editors/transform/transform_mode_edge_seq_slide.c b/source/blender/editors/transform/transform_mode_edge_seq_slide.c
index ae824b5a712..4c7670ae302 100644
--- a/source/blender/editors/transform/transform_mode_edge_seq_slide.c
+++ b/source/blender/editors/transform/transform_mode_edge_seq_slide.c
@@ -110,7 +110,7 @@ static void applySeqSlide(TransInfo *t, const int UNUSED(mval[2]))
 void initSeqSlide(TransInfo *t)
 {
   t->transform = applySeqSlide;
-  t->tsnap.applySnap = transform_snap_sequencer_apply_translate;
+  t->tsnap.snap_mode_apply_fn = transform_snap_sequencer_apply_translate;
 
   initMouseInputMode(t, &t->mouse, INPUT_VECTOR);
 
diff --git a/source/blender/editors/transform/transform_mode_edge_slide.c b/source/blender/editors/transform/transform_mode_edge_slide.c
index 2d4cc7e2c76..6920deea574 100644
--- a/source/blender/editors/transform/transform_mode_edge_slide.c
+++ b/source/blender/editors/transform/transform_mode_edge_slide.c
@@ -1272,7 +1272,7 @@ static void edge_slide_snap_apply(TransInfo *t, float *value)
   }
 
   getSnapPoint(t, dvec);
-  sub_v3_v3(dvec, t->tsnap.snapTarget);
+  sub_v3_v3(dvec, t->tsnap.snap_source);
   add_v3_v3v3(snap_point, co_orig, dvec);
 
   float perc = *value;
@@ -1498,8 +1498,8 @@ void initEdgeSlide_ex(
   t->mode = TFM_EDGE_SLIDE;
   t->transform = applyEdgeSlide;
   t->handleEvent = handleEventEdgeSlide;
-  t->tsnap.applySnap = edge_slide_snap_apply;
-  t->tsnap.distance = transform_snap_distance_len_squared_fn;
+  t->tsnap.snap_mode_apply_fn = edge_slide_snap_apply;
+  t->tsnap.snap_mode_distance_fn = transform_snap_distance_len_squared_fn;
 
   {
     EdgeSlideParams *slp = MEM_callocN(sizeof(*slp), __func__);
diff --git a/source/blender/editors/transform/transform_mode_resize.c b/source/blender/editors/transform/transform_mode_resize.c
index 668e1ed567f..ae90463b7f3 100644
--- a/source/blender/editors/transform/transform_mode_resize.c
+++ b/source/blender/editors/transform/transform_mode_resize.c
@@ -79,7 +79,7 @@ static void ApplySnapResize(TransInfo *t, float vec[3])
   float point[3];
   getSnapPoint(t, point);
 
-  float dist = ResizeBetween(t, t->tsnap.snapTarget, point);
+  float dist = ResizeBetween(t, t->tsnap.snap_source, point);
   if (dist != TRANSFORM_DIST_INVALID) {
     copy_v3_fl(vec, dist);
   }
@@ -287,8 +287,8 @@ void initResize(TransInfo *t, float mouse_dir_constraint[3])
 {
   t->mode = TFM_RESIZE;
   t->transform = applyResize;
-  t->tsnap.applySnap = ApplySnapResize;
-  t->tsnap.distance = ResizeBetween;
+  t->tsnap.snap_mode_apply_fn = ApplySnapResize;
+  t->tsnap.snap_mode_distance_fn = ResizeBetween;
 
   if (is_zero_v3(mouse_dir_constraint)) {
     initMouseInputMode(t, &t->mouse, INPUT_SPRING_FLIP);
diff --git a/source/blender/editors/transform/transform_mode_rotate.c b/source/blender/editors/transform/transform_mode_rotate.c
index a56d3b23149..0a49fdefd83 100644
--- a/source/blender/editors/transform/transform_mode_rotate.c
+++ b/source/blender/editors/transform/transform_mode_rotate.c
@@ -219,7 +219,7 @@ static void ApplySnapRotation(TransInfo *t, float *value)
   float point[3];
   getSnapPoint(t, point);
 
-  float dist = RotationBetween(t, t->tsnap.snapTarget, point);
+  float dist = RotationBetween(t, t->tsnap.snap_source, point);
   *value = dist;
 }
 
@@ -429,8 +429,8 @@ void initRotation(TransInfo *t)
   t->mode = TFM_ROTATION;
   t->transform = applyRotation;
   t->transform_matrix = applyRotationMatrix;
-  t->tsnap.applySnap = ApplySnapRotation;
-  t->tsnap.distance = RotationBetween;
+  t->tsnap.snap_mode_apply_fn = ApplySnapRotation;
+  t->tsnap.snap_mode_distance_fn = RotationBetween;
 
   initMouseInputMode(t, &t->mouse, INPUT_ANGLE);
 
diff --git a/source/blender/editors/transform/transform_mode_translate.c b/source/blender/editors/transform/transform_mode_translate.c
index 9257512268d..b171b227aa6 100644
--- a/source/blender/editors/transform/transform_mode_translate.c
+++ b/source/blender/editors/transform/transform_mode_translate.c
@@ -351,22 +351,22 @@ static void headerTranslation(TransInfo *t, const float vec[3], char str[UI_MAX_
 static void translate_snap_target_grid_ensure(TransInfo *t)
 {
   /* Only need to calculate once. */
-  if ((t->tsnap.status & TARGET_GRID_INIT) == 0) {
+  if ((t->tsnap.status & SNAP_TARGET_GRID_FOUND) == 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);
+      copy_v3_v3(t->tsnap.snap_target_grid, 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);
+      tranform_snap_target_median_calc(t, t->tsnap.snap_target_grid);
     }
     else {
-      copy_v3_v3(t->tsnap.snapTargetGrid, t->center_global);
+      copy_v3_v3(t->tsnap.snap_target_grid, t->center_global);
     }
-    t->tsnap.status |= TARGET_GRID_INIT;
+    t->tsnap.status |= SNAP_TARGET_GRID_FOUND;
   }
 }
 
@@ -378,7 +378,7 @@ static void translate_snap_grid_apply(TransInfo *t,
 {
   BLI_assert(max_index <= 2);
   translate_snap_target_grid_ensure(t);
-  const float *center_global = t->tsnap.snapTargetGrid;
+  const float *center_global = t->tsnap.snap_target_grid;
   const float *asp = t->aspect;
 
   float in[3];
@@ -440,10 +440,10 @@ static void ApplySnapTranslation(TransInfo *t, float vec[3])
   if (t->spacetype == SPACE_NODE) {
     char border = t->tsnap.snapNodeBorder;
     if (border & (NODE_LEFT | NODE_RIGHT)) {
-      vec[0] = point[0] - t->tsnap.snapTarget[0];
+      vec[0] = point[0] - t->tsnap.snap_source[0];
     }
     if (border & (NODE_BOTTOM | NODE_TOP)) {
-      vec[1] = point[1] - t->tsnap.snapTarget[1];
+      vec[1] = point[1] - t->tsnap.snap_source[1];
     }
   }
   else if (t->spacetype == SPACE_SEQ) {
@@ -459,7 +459,7 @@ static void ApplySnapTranslation(TransInfo *t, float vec[3])
       }
     }
 
-    sub_v3_v3v3(vec, point, t->tsnap.snapTarget);
+    sub_v3_v3v3(vec, point, t->tsnap.snap_source);
   }
 }
 
@@ -499,7 +499,7 @@ static void applyTranslationValue(TransInfo *t, const float vec[3])
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
     float pivot_local[3];
     if (rotate_mode != TRANSLATE_ROTATE_OFF) {
-      copy_v3_v3(pivot_local, t->tsnap.snapTarget);
+      copy_v3_v3(pivot_local, t->tsnap.snap_source);
       /* The pivot has to be in local-space (see T49494) */
       if (tc->use_local_mat) {
         mul_m4_v3(tc->imat, pivot_local);
@@ -678,8 +678,8 @@ void initTranslation(TransInfo *t)
 
   t->transform = applyTranslation;
   t->transform_matrix = applyTranslationMatrix;
-  t->tsnap.applySnap = ApplySnapTranslation;
-  t->tsnap.distance = transform_snap_distance_len_squared_fn;
+  t->tsnap.snap_mode_apply_fn = ApplySnapTranslation;
+  t->tsnap.snap_mode_distance_fn = transform_snap_distance_len_squared_fn;
 
   initMouseInputMode(t, &t->mouse, INPUT_VECTOR);
 
diff --git a/source/blender/editors/transform/transform_mode_vert_slide.c b/source/blender/editors/transform/transform_mode_vert_slide.c
index e8813241809..3483f2b2bfa 100644
--- a/source/blender/editors/transform/transform_mode_vert_slide.c
+++ b/source/blender/editors/transform/transform_mode_vert_slide.c
@@ -532,7 +532,7 @@ static void vert_slide_snap_apply(TransInfo *t, float *value)
   }
 
   getSnapPoint(t, dvec);
-  sub_v3_v3(dvec, t->tsnap.snapTarget);
+  sub_v3_v3(dvec, t->tsnap.snap_source);
   if (t->tsnap.snapElem & (SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE_RAYCAST)) {
     float co_dir[3];
     sub_v3_v3v3(co_dir, co_curr_3d, co_orig_3d);
@@ -610,8 +610,8 @@ void initVertSlide_ex(TransInfo *t, bool use_even, bool flipped, bool use_clamp)
   t->mode = TFM_VERT_SLIDE;
   t->transform = applyVertSlide;
   t->handleEvent = handleEventVertSlide;
-  t->tsnap.applySnap = vert_slide_snap_apply;
-  t->tsnap.distance = transform_snap_distance_len_squared_fn;
+  t->tsnap.snap_mode_apply_fn = vert_slide_snap_apply;
+  t->tsnap.snap_mode_distance_fn = transform_snap_distance_len_squared_fn;
 
   {
     VertSlideParams *slp = MEM_callocN(sizeof(*slp), __func__);
diff --git a/source/blender/editors/transform/transform_ops.c b/source/blender/editors/transform/transform_ops.c
index 82791b2a9f5..0da3bf4d85f 100644
--- a/source/blender/editors/transform/transform_ops.c
+++ b/source/blender/editors/transform/transform_ops.c
@@ -421,11 +421,11 @@ static int transform_modal(bContext *C, wmOperator *op, const wmEvent *event)
 
   /* XXX, workaround: active needs to be calculated before transforming,
    * since we're not reading from 'td->center' in this case. see: T40241 */
-  if (t->tsnap.source_select == SCE_SNAP_SOURCE_ACTIVE) {
+  if (t->tsnap.source_operation == SCE_SNAP_SOURCE_ACTIVE) {
     /* In camera view, tsnap callback is not set
      * (see #initSnappingMode() in transform_snap.c, and T40348). */
-    if (t->tsnap.targetSnap && ((t->tsnap.status & TARGET_INIT) == 0)) {
-      t->tsnap.targetSnap(t);
+    if (t->tsnap.snap_source_fn && ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0)) {
+      t->tsnap.snap_source_fn(t);
     }
   }
 
diff --git a/source/blender/editors/transform/transform_snap.cc b/source/blender/editors/transform/transform_snap.cc
index 00ccf1ed632..2f5e1974d0b 100644
--- a/source/blender/editors/transform/transform_snap.cc
+++ b/source/blender/editors/transform/transform_snap.cc
@@ -61,16 +61,15 @@ static bool doForceIncrementSnap(const TransInfo *t);
 
 static void setSnappingCallback(TransInfo *t);
 
-/* static void CalcSnapGrid(TransInfo *t, float *vec); */
-static void snap_calc_view3d_fn(TransInfo *t, float *vec);
-static void snap_calc_uv_fn(TransInfo *t, float *vec);
-static void snap_calc_node_fn(TransInfo *t, float *vec);
-static void snap_calc_sequencer_fn(TransInfo *t, float *vec);
+static void snap_target_view3d_fn(TransInfo *t, float *vec);
+static void snap_target_uv_fn(TransInfo *t, float *vec);
+static void snap_target_node_fn(TransInfo *t, float *vec);
+static void snap_target_sequencer_fn(TransInfo *t, float *vec);
 
-static void TargetSnapMedian(TransInfo *t);
-static void TargetSnapCenter(TransInfo *t);
-static void TargetSnapClosest(TransInfo *t);
-static void TargetSnapActive(TransInfo *t);
+static void snap_source_median_fn(TransInfo *t);
+static void snap_source_center_fn(TransInfo *t);
+static void snap_source_closest_fn(TransInfo *t);
+static void snap_source_active_fn(TransInfo *t);
 
 /** \} */
 
@@ -78,7 +77,7 @@ static void TargetSnapActive(TransInfo *t);
 /** \name Implementations
  * \{ */
 
-static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetSelect snap_target_select);
+static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetOP snap_target_select);
 static NodeBorder snapNodeBorder(eSnapMode snap_node_mode);
 
 #if 0
@@ -115,8 +114,10 @@ static bool snap_use_backface_culling(const TransInfo *t)
 
 bool validSnap(const TransInfo *t)
 {
-  return (t->tsnap.status & (POINT_INIT | TARGET_INIT)) == (POINT_INIT | TARGET_INIT) ||
-         (t->tsnap.status & (MULTI_POINTS | TARGET_INIT)) == (MULTI_POINTS | TARGET_INIT);
+  return (t->tsnap.status & (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND)) ==
+             (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND) ||
+         (t->tsnap.status & (SNAP_MULTI_POINTS | SNAP_SOURCE_FOUND)) ==
+             (SNAP_MULTI_POINTS | SNAP_SOURCE_FOUND);
 }
 
 bool transform_snap_is_active(const TransInfo *t)
@@ -156,10 +157,10 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
     return;
   }
 
-  bool draw_target = (t->spacetype == SPACE_VIEW3D) && (t->tsnap.status & TARGET_INIT) &&
+  bool draw_source = (t->spacetype == SPACE_VIEW3D) && (t->tsnap.status & SNAP_SOURCE_FOUND) &&
                      (t->tsnap.mode & SCE_SNAP_MODE_EDGE_PERPENDICULAR);
 
-  if (!(draw_target || validSnap(t))) {
+  if (!(draw_source || validSnap(t))) {
     return;
   }
 
@@ -216,12 +217,12 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
       normal = t->tsnap.snapNormal;
     }
 
-    if (draw_target) {
-      loc_prev = t->tsnap.snapTarget;
+    if (draw_source) {
+      loc_prev = t->tsnap.snap_source;
     }
 
     if (validSnap(t)) {
-      loc_cur = t->tsnap.snapPoint;
+      loc_cur = t->tsnap.snap_target;
     }
 
     ED_view3d_cursor_snap_draw_util(
@@ -234,8 +235,8 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
 
     float x, y;
     const float snap_point[2] = {
-        t->tsnap.snapPoint[0] / t->aspect[0],
-        t->tsnap.snapPoint[1] / t->aspect[1],
+        t->tsnap.snap_target[0] / t->aspect[0],
+        t->tsnap.snap_target[1] / t->aspect[1],
     };
     UI_view2d_view_to_region_fl(&t->region->v2d, UNPACK2(snap_point), &x, &y);
     float radius = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE) * U.pixelsize;
@@ -274,11 +275,11 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
       ED_node_draw_snap(&region->v2d, p->co, size, NodeBorder(0), pos);
     }
 
-    if (t->tsnap.status & POINT_INIT) {
+    if (t->tsnap.status & SNAP_TARGET_FOUND) {
       immUniformColor4ubv(activeCol);
 
       ED_node_draw_snap(
-          &region->v2d, t->tsnap.snapPoint, size, NodeBorder(t->tsnap.snapNodeBorder), pos);
+          &region->v2d, t->tsnap.snap_target, size, NodeBorder(t->tsnap.snapNodeBorder), pos);
     }
 
     immUnbindProgram();
@@ -293,9 +294,9 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
     immUniformColor4ubv(col);
     float pixelx = BLI_rctf_size_x(&region->v2d.cur) / BLI_rcti_size_x(&region->v2d.mask);
     immRectf(pos,
-             t->tsnap.snapPoint[0] - pixelx,
+             t->tsnap.snap_target[0] - pixelx,
              region->v2d.cur.ymax,
-             t->tsnap.snapPoint[0] + pixelx,
+             t->tsnap.snap_target[0] + pixelx,
              region->v2d.cur.ymin);
     immUnbindProgram();
     GPU_blend(GPU_BLEND_NONE);
@@ -346,7 +347,7 @@ static bool applyFaceProject(TransInfo *t, TransDataContainer *tc, TransData *td
   }
 
   SnapObjectParams snap_object_params{};
-  snap_object_params.snap_target_select = t->tsnap.target_select;
+  snap_object_params.snap_target_select = t->tsnap.target_operation;
   snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
   snap_object_params.use_occlusion_test = false;
   snap_object_params.use_backface_culling = t->tsnap.use_backface_culling;
@@ -413,7 +414,7 @@ static void applyFaceNearest(TransInfo *t, TransDataContainer *tc, TransData *td
   }
 
   SnapObjectParams snap_object_params{};
-  snap_object_params.snap_target_select = t->tsnap.target_select;
+  snap_object_params.snap_target_select = t->tsnap.target_operation;
   snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
   snap_object_params.use_occlusion_test = false;
   snap_object_params.use_backface_culling = false;
@@ -525,9 +526,9 @@ void transform_snap_mixed_apply(TransInfo *t, float *vec)
   }
 
   if (t->tsnap.status & SNAP_FORCED) {
-    t->tsnap.targetSnap(t);
+    t->tsnap.snap_source_fn(t);
 
-    t->tsnap.applySnap(t, vec);
+    t->tsnap.snap_mode_apply_fn(t, vec);
   }
   else if (((t->tsnap.mode & ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) != 0) &&
            transform_snap_is_active(t)) {
@@ -536,18 +537,18 @@ void transform_snap_mixed_apply(TransInfo *t, float *vec)
     /* Time base quirky code to go around find-nearest slowness. */
     /* TODO: add exception for object mode, no need to slow it down then. */
     if (current - t->tsnap.last >= 0.01) {
-      if (t->tsnap.calcSnap) {
-        t->tsnap.calcSnap(t, vec);
+      if (t->tsnap.snap_target_fn) {
+        t->tsnap.snap_target_fn(t, vec);
       }
-      if (t->tsnap.targetSnap) {
-        t->tsnap.targetSnap(t);
+      if (t->tsnap.snap_source_fn) {
+        t->tsnap.snap_source_fn(t);
       }
 
       t->tsnap.last = current;
     }
 
     if (validSnap(t)) {
-      t->tsnap.applySnap(t, vec);
+      t->tsnap.snap_mode_apply_fn(t, vec);
     }
   }
 }
@@ -559,8 +560,8 @@ void resetSnapping(TransInfo *t)
   t->tsnap.align = false;
   t->tsnap.project = false;
   t->tsnap.mode = SCE_SNAP_MODE_NONE;
-  t->tsnap.target_select = SCE_SNAP_TARGET_ALL;
-  t->tsnap.source_select = SCE_SNAP_SOURCE_CLOSEST;
+  t->tsnap.target_operation = SCE_SNAP_TARGET_ALL;
+  t->tsnap.source_operation = SCE_SNAP_SOURCE_CLOSEST;
   t->tsnap.last = 0;
 
   t->tsnap.snapNormal[0] = 0;
@@ -682,15 +683,15 @@ static eSnapMode snap_mode_from_spacetype(TransInfo *t)
   return SCE_SNAP_MODE_INCREMENT;
 }
 
-static eSnapTargetSelect snap_target_select_from_spacetype(TransInfo *t)
+static eSnapTargetOP snap_target_select_from_spacetype(TransInfo *t)
 {
   BKE_view_layer_synced_ensure(t->scene, t->view_layer);
   Base *base_act = BKE_view_layer_active_base_get(t->view_layer);
 
-  eSnapTargetSelect ret = SCE_SNAP_TARGET_ALL;
+  eSnapTargetOP ret = SCE_SNAP_TARGET_ALL;
 
-  /* `t->tsnap.target_select` not initialized yet. */
-  BLI_assert(t->tsnap.target_select == SCE_SNAP_TARGET_ALL);
+  /* `t->tsnap.target_operation` not initialized yet. */
+  BLI_assert(t->tsnap.target_operation == SCE_SNAP_TARGET_ALL);
 
   if (ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE) && !(t->options & CTX_CAMERA)) {
     if (base_act && (base_act->object->mode & OB_MODE_PARTICLE_EDIT)) {
@@ -778,12 +779,12 @@ static void initSnappingMode(TransInfo *t)
 void initSnapping(TransInfo *t, wmOperator *op)
 {
   ToolSettings *ts = t->settings;
-  eSnapSourceSelect snap_source = eSnapSourceSelect(ts->snap_target);
+  eSnapSourceOP snap_source = eSnapSourceOP(ts->snap_target);
 
   resetSnapping(t);
   t->tsnap.mode = snap_mode_from_spacetype(t);
   t->tsnap.flag = snap_flag_from_spacetype(t);
-  t->tsnap.target_select = snap_target_select_from_spacetype(t);
+  t->tsnap.target_operation = snap_target_select_from_spacetype(t);
   t->tsnap.face_nearest_steps = max_ii(ts->snap_face_nearest_steps, 1);
 
   /* if snap property exists */
@@ -803,13 +804,13 @@ void initSnapping(TransInfo *t, wmOperator *op)
        * geometry is snapped). */
       if ((prop = RNA_struct_find_property(op->ptr, "snap_target")) &&
           RNA_property_is_set(op->ptr, prop)) {
-        snap_source = eSnapSourceSelect(RNA_property_enum_get(op->ptr, prop));
+        snap_source = eSnapSourceOP(RNA_property_enum_get(op->ptr, prop));
       }
 
       if ((prop = RNA_struct_find_property(op->ptr, "snap_point")) &&
           RNA_property_is_set(op->ptr, prop)) {
-        RNA_property_float_get_array(op->ptr, prop, t->tsnap.snapPoint);
-        t->tsnap.status |= SNAP_FORCED | POINT_INIT;
+        RNA_property_float_get_array(op->ptr, prop, t->tsnap.snap_target);
+        t->tsnap.status |= SNAP_FORCED | SNAP_TARGET_FOUND;
       }
 
       /* snap align only defined in specific cases */
@@ -828,28 +829,28 @@ void initSnapping(TransInfo *t, wmOperator *op)
       /* use_snap_self is misnamed and should be use_snap_active */
       if ((prop = RNA_struct_find_property(op->ptr, "use_snap_self")) &&
           RNA_property_is_set(op->ptr, prop)) {
-        SET_FLAG_FROM_TEST(t->tsnap.target_select,
+        SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                            !RNA_property_boolean_get(op->ptr, prop),
                            SCE_SNAP_TARGET_NOT_ACTIVE);
       }
 
       if ((prop = RNA_struct_find_property(op->ptr, "use_snap_edit")) &&
           RNA_property_is_set(op->ptr, prop)) {
-        SET_FLAG_FROM_TEST(t->tsnap.target_select,
+        SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                            !RNA_property_boolean_get(op->ptr, prop),
                            SCE_SNAP_TARGET_NOT_EDITED);
       }
 
       if ((prop = RNA_struct_find_property(op->ptr, "use_snap_nonedit")) &&
           RNA_property_is_set(op->ptr, prop)) {
-        SET_FLAG_FROM_TEST(t->tsnap.target_select,
+        SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                            !RNA_property_boolean_get(op->ptr, prop),
                            SCE_SNAP_TARGET_NOT_NONEDITED);
       }
 
       if ((prop = RNA_struct_find_property(op->ptr, "use_snap_selectable")) &&
           RNA_property_is_set(op->ptr, prop)) {
-        SET_FLAG_FROM_TEST(t->tsnap.target_select,
+        SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                            RNA_property_boolean_get(op->ptr, prop),
                            SCE_SNAP_TARGET_ONLY_SELECTABLE);
       }
@@ -864,21 +865,21 @@ void initSnapping(TransInfo *t, wmOperator *op)
     t->tsnap.align = ((t->tsnap.flag & SCE_SNAP_ROTATE) != 0);
     t->tsnap.project = ((t->tsnap.flag & SCE_SNAP_PROJECT) != 0);
     t->tsnap.peel = ((t->tsnap.flag & SCE_SNAP_PROJECT) != 0);
-    SET_FLAG_FROM_TEST(t->tsnap.target_select,
+    SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                        (ts->snap_flag & SCE_SNAP_NOT_TO_ACTIVE),
                        SCE_SNAP_TARGET_NOT_ACTIVE);
-    SET_FLAG_FROM_TEST(t->tsnap.target_select,
+    SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                        !(ts->snap_flag & SCE_SNAP_TO_INCLUDE_EDITED),
                        SCE_SNAP_TARGET_NOT_EDITED);
-    SET_FLAG_FROM_TEST(t->tsnap.target_select,
+    SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                        !(ts->snap_flag & SCE_SNAP_TO_INCLUDE_NONEDITED),
                        SCE_SNAP_TARGET_NOT_NONEDITED);
-    SET_FLAG_FROM_TEST(t->tsnap.target_select,
+    SET_FLAG_FROM_TEST(t->tsnap.target_operation,
                        (ts->snap_flag & SCE_SNAP_TO_ONLY_SELECTABLE),
                        SCE_SNAP_TARGET_ONLY_SELECTABLE);
   }
 
-  t->tsnap.source_select = snap_source;
+  t->tsnap.source_operation = snap_source;
 
   initSnappingMode(t);
 }
@@ -902,7 +903,7 @@ static void setSnappingCallback(TransInfo *t)
       /* Not with camera selected in camera view. */
       return;
     }
-    t->tsnap.calcSnap = snap_calc_view3d_fn;
+    t->tsnap.snap_target_fn = snap_target_view3d_fn;
   }
   else if (t->spacetype == SPACE_IMAGE) {
     SpaceImage *sima = static_cast<SpaceImage *>(t->area->spacedata.first);
@@ -912,14 +913,14 @@ static void setSnappingCallback(TransInfo *t)
     const bool is_uv_editor = sima->mode == SI_MODE_UV;
     const bool has_edit_object = obact && BKE_object_is_in_editmode(obact);
     if (is_uv_editor && has_edit_object) {
-      t->tsnap.calcSnap = snap_calc_uv_fn;
+      t->tsnap.snap_target_fn = snap_target_uv_fn;
     }
   }
   else if (t->spacetype == SPACE_NODE) {
-    t->tsnap.calcSnap = snap_calc_node_fn;
+    t->tsnap.snap_target_fn = snap_target_node_fn;
   }
   else if (t->spacetype == SPACE_SEQ) {
-    t->tsnap.calcSnap = snap_calc_sequencer_fn;
+    t->tsnap.snap_target_fn = snap_target_sequencer_fn;
     /* The target is calculated along with the snap point. */
     return;
   }
@@ -927,23 +928,23 @@ static void setSnappingCallback(TransInfo *t)
     return;
   }
 
-  switch (t->tsnap.source_select) {
+  switch (t->tsnap.source_operation) {
     case SCE_SNAP_SOURCE_CLOSEST:
-      t->tsnap.targetSnap = TargetSnapClosest;
+      t->tsnap.snap_source_fn = snap_source_closest_fn;
       break;
     case SCE_SNAP_SOURCE_CENTER:
       if (!ELEM(t->mode, TFM_ROTATION, TFM_RESIZE)) {
-        t->tsnap.targetSnap = TargetSnapCenter;
+        t->tsnap.snap_source_fn = snap_source_center_fn;
         break;
       }
       /* Can't do TARGET_CENTER with these modes,
        * use TARGET_MEDIAN instead. */
       ATTR_FALLTHROUGH;
     case SCE_SNAP_SOURCE_MEDIAN:
-      t->tsnap.targetSnap = TargetSnapMedian;
+      t->tsnap.snap_source_fn = snap_source_median_fn;
       break;
     case SCE_SNAP_SOURCE_ACTIVE:
-      t->tsnap.targetSnap = TargetSnapActive;
+      t->tsnap.snap_source_fn = snap_source_active_fn;
       break;
   }
 }
@@ -951,16 +952,16 @@ static void setSnappingCallback(TransInfo *t)
 void addSnapPoint(TransInfo *t)
 {
   /* Currently only 3D viewport works for snapping points. */
-  if (t->tsnap.status & POINT_INIT && t->spacetype == SPACE_VIEW3D) {
+  if (t->tsnap.status & SNAP_TARGET_FOUND && t->spacetype == SPACE_VIEW3D) {
     TransSnapPoint *p = MEM_cnew<TransSnapPoint>("SnapPoint");
 
     t->tsnap.selectedPoint = p;
 
-    copy_v3_v3(p->co, t->tsnap.snapPoint);
+    copy_v3_v3(p->co, t->tsnap.snap_target);
 
     BLI_addtail(&t->tsnap.points, p);
 
-    t->tsnap.status |= MULTI_POINTS;
+    t->tsnap.status |= SNAP_MULTI_POINTS;
   }
 }
 
@@ -968,7 +969,7 @@ eRedrawFlag updateSelectedSnapPoint(TransInfo *t)
 {
   eRedrawFlag status = TREDRAW_NOTHING;
 
-  if (t->tsnap.status & MULTI_POINTS) {
+  if (t->tsnap.status & SNAP_MULTI_POINTS) {
     TransSnapPoint *p, *closest_p = nullptr;
     float dist_min_sq = TRANSFORM_SNAP_MAX_PX;
     const float mval_fl[2] = {float(t->mval[0]), float(t->mval[1])};
@@ -1004,14 +1005,14 @@ eRedrawFlag updateSelectedSnapPoint(TransInfo *t)
 
 void removeSnapPoint(TransInfo *t)
 {
-  if (t->tsnap.status & MULTI_POINTS) {
+  if (t->tsnap.status & SNAP_MULTI_POINTS) {
     updateSelectedSnapPoint(t);
 
     if (t->tsnap.selectedPoint) {
       BLI_freelinkN(&t->tsnap.points, t->tsnap.selectedPoint);
 
       if (BLI_listbase_is_empty(&t->tsnap.points)) {
-        t->tsnap.status &= ~MULTI_POINTS;
+        t->tsnap.status &= ~SNAP_MULTI_POINTS;
       }
 
       t->tsnap.selectedPoint = nullptr;
@@ -1031,15 +1032,15 @@ void getSnapPoint(const TransInfo *t, float vec[3])
       add_v3_v3(vec, p->co);
     }
 
-    if (t->tsnap.status & POINT_INIT) {
-      add_v3_v3(vec, t->tsnap.snapPoint);
+    if (t->tsnap.status & SNAP_TARGET_FOUND) {
+      add_v3_v3(vec, t->tsnap.snap_target);
       total++;
     }
 
     mul_v3_fl(vec, 1.0f / total);
   }
   else {
-    copy_v3_v3(vec, t->tsnap.snapPoint);
+    copy_v3_v3(vec, t->tsnap.snap_target);
   }
 }
 
@@ -1049,7 +1050,7 @@ void getSnapPoint(const TransInfo *t, float vec[3])
 /** \name Calc Snap
  * \{ */
 
-static void snap_calc_view3d_fn(TransInfo *t, float * /*vec*/)
+static void snap_target_view3d_fn(TransInfo *t, float * /*vec*/)
 {
   BLI_assert(t->spacetype == SPACE_VIEW3D);
   float loc[3];
@@ -1077,19 +1078,19 @@ static void snap_calc_view3d_fn(TransInfo *t, float * /*vec*/)
   }
 
   if (found == true) {
-    copy_v3_v3(t->tsnap.snapPoint, loc);
+    copy_v3_v3(t->tsnap.snap_target, loc);
     copy_v3_v3(t->tsnap.snapNormal, no);
 
-    t->tsnap.status |= POINT_INIT;
+    t->tsnap.status |= SNAP_TARGET_FOUND;
   }
   else {
-    t->tsnap.status &= ~POINT_INIT;
+    t->tsnap.status &= ~SNAP_TARGET_FOUND;
   }
 
   t->tsnap.snapElem = snap_elem;
 }
 
-static void snap_calc_uv_fn(TransInfo *t, float * /*vec*/)
+static void snap_target_uv_fn(TransInfo *t, float * /*vec*/)
 {
   BLI_assert(t->spacetype == SPACE_IMAGE);
   if (t->tsnap.mode & SCE_SNAP_MODE_VERTEX) {
@@ -1103,22 +1104,22 @@ static void snap_calc_uv_fn(TransInfo *t, float * /*vec*/)
                                    objects,
                                    objects_len,
                                    t->mval,
-                                   t->tsnap.target_select & SCE_SNAP_TARGET_NOT_SELECTED,
+                                   t->tsnap.target_operation & SCE_SNAP_TARGET_NOT_SELECTED,
                                    &dist_sq,
-                                   t->tsnap.snapPoint)) {
-      t->tsnap.snapPoint[0] *= t->aspect[0];
-      t->tsnap.snapPoint[1] *= t->aspect[1];
+                                   t->tsnap.snap_target)) {
+      t->tsnap.snap_target[0] *= t->aspect[0];
+      t->tsnap.snap_target[1] *= t->aspect[1];
 
-      t->tsnap.status |= POINT_INIT;
+      t->tsnap.status |= SNAP_TARGET_FOUND;
     }
     else {
-      t->tsnap.status &= ~POINT_INIT;
+      t->tsnap.status &= ~SNAP_TARGET_FOUND;
     }
     MEM_freeN(objects);
   }
 }
 
-static void snap_calc_node_fn(TransInfo *t, float * /*vec*/)
+static void snap_target_node_fn(TransInfo *t, float * /*vec*/)
 {
   BLI_assert(t->spacetype == SPACE_NODE);
   if (t->tsnap.mode & (SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y)) {
@@ -1127,25 +1128,25 @@ static void snap_calc_node_fn(TransInfo *t, float * /*vec*/)
     char node_border;
 
     if (snapNodesTransform(t, t->mval, loc, &dist_px, &node_border)) {
-      copy_v2_v2(t->tsnap.snapPoint, loc);
+      copy_v2_v2(t->tsnap.snap_target, loc);
       t->tsnap.snapNodeBorder = node_border;
 
-      t->tsnap.status |= POINT_INIT;
+      t->tsnap.status |= SNAP_TARGET_FOUND;
     }
     else {
-      t->tsnap.status &= ~POINT_INIT;
+      t->tsnap.status &= ~SNAP_TARGET_FOUND;
     }
   }
 }
 
-static void snap_calc_sequencer_fn(TransInfo *t, float * /*vec*/)
+static void snap_target_sequencer_fn(TransInfo *t, float * /*vec*/)
 {
   BLI_assert(t->spacetype == SPACE_SEQ);
   if (transform_snap_sequencer_calc(t)) {
-    t->tsnap.status |= (POINT_INIT | TARGET_INIT);
+    t->tsnap.status |= (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
   }
   else {
-    t->tsnap.status &= ~(POINT_INIT | TARGET_INIT);
+    t->tsnap.status &= ~(SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
   }
 }
 
@@ -1198,62 +1199,62 @@ static void TargetSnapOffset(TransInfo *t, TransData *td)
     char border = t->tsnap.snapNodeBorder;
 
     if (border & NODE_LEFT) {
-      t->tsnap.snapTarget[0] -= 0.0f;
+      t->tsnap.snap_source[0] -= 0.0f;
     }
     if (border & NODE_RIGHT) {
-      t->tsnap.snapTarget[0] += BLI_rctf_size_x(&node->runtime->totr);
+      t->tsnap.snap_source[0] += BLI_rctf_size_x(&node->runtime->totr);
     }
     if (border & NODE_BOTTOM) {
-      t->tsnap.snapTarget[1] -= BLI_rctf_size_y(&node->runtime->totr);
+      t->tsnap.snap_source[1] -= BLI_rctf_size_y(&node->runtime->totr);
     }
     if (border & NODE_TOP) {
-      t->tsnap.snapTarget[1] += 0.0f;
+      t->tsnap.snap_source[1] += 0.0f;
     }
   }
 }
 
-static void TargetSnapCenter(TransInfo *t)
+static void snap_source_center_fn(TransInfo *t)
 {
   /* Only need to calculate once */
-  if ((t->tsnap.status & TARGET_INIT) == 0) {
-    copy_v3_v3(t->tsnap.snapTarget, t->center_global);
+  if ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0) {
+    copy_v3_v3(t->tsnap.snap_source, t->center_global);
     TargetSnapOffset(t, nullptr);
 
-    t->tsnap.status |= TARGET_INIT;
+    t->tsnap.status |= SNAP_SOURCE_FOUND;
   }
 }
 
-static void TargetSnapActive(TransInfo *t)
+static void snap_source_active_fn(TransInfo *t)
 {
   /* Only need to calculate once */
-  if ((t->tsnap.status & TARGET_INIT) == 0) {
-    if (calculateCenterActive(t, true, t->tsnap.snapTarget)) {
+  if ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0) {
+    if (calculateCenterActive(t, true, t->tsnap.snap_source)) {
       TargetSnapOffset(t, nullptr);
 
-      t->tsnap.status |= TARGET_INIT;
+      t->tsnap.status |= SNAP_SOURCE_FOUND;
     }
     /* No active, default to median */
     else {
-      t->tsnap.source_select = SCE_SNAP_SOURCE_MEDIAN;
-      t->tsnap.targetSnap = TargetSnapMedian;
-      TargetSnapMedian(t);
+      t->tsnap.source_operation = SCE_SNAP_SOURCE_MEDIAN;
+      t->tsnap.snap_source_fn = snap_source_median_fn;
+      snap_source_median_fn(t);
     }
   }
 }
 
-static void TargetSnapMedian(TransInfo *t)
+static void snap_source_median_fn(TransInfo *t)
 {
   /* Only need to calculate once. */
-  if ((t->tsnap.status & TARGET_INIT) == 0) {
-    tranform_snap_target_median_calc(t, t->tsnap.snapTarget);
-    t->tsnap.status |= TARGET_INIT;
+  if ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0) {
+    tranform_snap_target_median_calc(t, t->tsnap.snap_source);
+    t->tsnap.status |= SNAP_SOURCE_FOUND;
   }
 }
 
-static void TargetSnapClosest(TransInfo *t)
+static void snap_source_closest_fn(TransInfo *t)
 {
   /* Only valid if a snap point has been selected. */
-  if (t->tsnap.status & POINT_INIT) {
+  if (t->tsnap.status & SNAP_TARGET_FOUND) {
     float dist_closest = 0.0f;
     TransData *closest = nullptr;
 
@@ -1280,11 +1281,11 @@ static void TargetSnapClosest(TransInfo *t)
               copy_v3_v3(loc, bb->vec[j]);
               mul_m4_v3(td->ext->obmat, loc);
 
-              dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
+              dist = t->tsnap.snap_mode_distance_fn(t, loc, t->tsnap.snap_target);
 
               if ((dist != TRANSFORM_DIST_INVALID) &&
                   (closest == nullptr || fabsf(dist) < fabsf(dist_closest))) {
-                copy_v3_v3(t->tsnap.snapTarget, loc);
+                copy_v3_v3(t->tsnap.snap_source, loc);
                 closest = td;
                 dist_closest = dist;
               }
@@ -1297,11 +1298,11 @@ static void TargetSnapClosest(TransInfo *t)
 
             copy_v3_v3(loc, td->center);
 
-            dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
+            dist = t->tsnap.snap_mode_distance_fn(t, loc, t->tsnap.snap_target);
 
             if ((dist != TRANSFORM_DIST_INVALID) &&
                 (closest == nullptr || fabsf(dist) < fabsf(dist_closest))) {
-              copy_v3_v3(t->tsnap.snapTarget, loc);
+              copy_v3_v3(t->tsnap.snap_source, loc);
               closest = td;
             }
           }
@@ -1322,11 +1323,11 @@ static void TargetSnapClosest(TransInfo *t)
             mul_m4_v3(tc->mat, loc);
           }
 
-          dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
+          dist = t->tsnap.snap_mode_distance_fn(t, loc, t->tsnap.snap_target);
 
           if ((dist != TRANSFORM_DIST_INVALID) &&
               (closest == nullptr || fabsf(dist) < fabsf(dist_closest))) {
-            copy_v3_v3(t->tsnap.snapTarget, loc);
+            copy_v3_v3(t->tsnap.snap_source, loc);
             closest = td;
             dist_closest = dist;
           }
@@ -1336,7 +1337,7 @@ static void TargetSnapClosest(TransInfo *t)
 
     TargetSnapOffset(t, closest);
 
-    t->tsnap.status |= TARGET_INIT;
+    t->tsnap.status |= SNAP_SOURCE_FOUND;
   }
 }
 
@@ -1350,12 +1351,12 @@ eSnapMode snapObjectsTransform(
     TransInfo *t, const float mval[2], float *dist_px, float r_loc[3], float r_no[3])
 {
   SnapObjectParams snap_object_params{};
-  snap_object_params.snap_target_select = t->tsnap.target_select;
+  snap_object_params.snap_target_select = t->tsnap.target_operation;
   snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
   snap_object_params.use_occlusion_test = t->settings->snap_mode != SCE_SNAP_MODE_FACE_RAYCAST;
   snap_object_params.use_backface_culling = t->tsnap.use_backface_culling;
 
-  float *target = (t->tsnap.status & TARGET_INIT) ? t->tsnap.snapTarget : t->center_global;
+  float *target = (t->tsnap.status & SNAP_SOURCE_FOUND) ? t->tsnap.snap_source : t->center_global;
   return ED_transform_snap_object_project_view3d(t->tsnap.object_context,
                                                  t->depsgraph,
                                                  t->region,
@@ -1385,7 +1386,7 @@ bool peelObjectsTransform(TransInfo *t,
                           float *r_thickness)
 {
   SnapObjectParams snap_object_params{};
-  snap_object_params.snap_target_select = t->tsnap.target_select;
+  snap_object_params.snap_target_select = t->tsnap.target_operation;
   snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
 
   ListBase depths_peel = {nullptr};
@@ -1461,7 +1462,7 @@ bool peelObjectsTransform(TransInfo *t,
 /** \name snap Nodes
  * \{ */
 
-static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetSelect snap_target_select)
+static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetOP snap_target_select)
 {
   /* node is use for snapping only if a) snap mode matches and b) node is inside the view */
   return (((snap_target_select & SCE_SNAP_TARGET_NOT_SELECTED) && !(node->flag & NODE_SELECT)) ||
@@ -1546,7 +1547,7 @@ static bool snapNodes(ToolSettings *ts,
                       SpaceNode *snode,
                       ARegion *region,
                       const int mval[2],
-                      eSnapTargetSelect snap_target_select,
+                      eSnapTargetOP snap_target_select,
                       float r_loc[2],
                       float *r_dist_px,
                       char *r_node_border)
@@ -1573,7 +1574,7 @@ bool snapNodesTransform(
                    static_cast<SpaceNode *>(t->area->spacedata.first),
                    t->region,
                    mval,
-                   t->tsnap.target_select,
+                   t->tsnap.target_operation,
                    r_loc,
                    r_dist_px,
                    r_node_border);
diff --git a/source/blender/editors/transform/transform_snap_object.cc b/source/blender/editors/transform/transform_snap_object.cc
index d55de8909a5..39e0fa1fc16 100644
--- a/source/blender/editors/transform/transform_snap_object.cc
+++ b/source/blender/editors/transform/transform_snap_object.cc
@@ -404,7 +404,7 @@ using IterSnapObjsCallback = eSnapMode (*)(SnapObjectContext *sctx,
                                            void *data);
 
 static bool snap_object_is_snappable(const SnapObjectContext *sctx,
-                                     const eSnapTargetSelect snap_target_select,
+                                     const eSnapTargetOP snap_target_select,
                                      const Base *base_act,
                                      const Base *base)
 {
@@ -471,7 +471,7 @@ static eSnapMode iter_snap_objects(SnapObjectContext *sctx,
 
   Scene *scene = DEG_get_input_scene(sctx->runtime.depsgraph);
   ViewLayer *view_layer = DEG_get_input_view_layer(sctx->runtime.depsgraph);
-  const eSnapTargetSelect snap_target_select = params->snap_target_select;
+  const eSnapTargetOP snap_target_select = params->snap_target_select;
   BKE_view_layer_synced_ensure(scene, view_layer);
   Base *base_act = BKE_view_layer_active_base_get(view_layer);
 
diff --git a/source/blender/editors/transform/transform_snap_sequencer.c b/source/blender/editors/transform/transform_snap_sequencer.c
index 10a51750ed3..0fda2c64867 100644
--- a/source/blender/editors/transform/transform_snap_sequencer.c
+++ b/source/blender/editors/transform/transform_snap_sequencer.c
@@ -319,14 +319,14 @@ bool transform_snap_sequencer_calc(TransInfo *t)
     return false;
   }
 
-  t->tsnap.snapPoint[0] = best_target_frame;
-  t->tsnap.snapTarget[0] = best_source_frame;
+  t->tsnap.snap_target[0] = best_target_frame;
+  t->tsnap.snap_source[0] = best_source_frame;
   return true;
 }
 
 void transform_snap_sequencer_apply_translate(TransInfo *t, float *vec)
 {
-  *vec += t->tsnap.snapPoint[0] - t->tsnap.snapTarget[0];
+  *vec += t->tsnap.snap_target[0] - t->tsnap.snap_source[0];
 }
 
 static int transform_snap_sequencer_to_closest_strip_ex(TransInfo *t, int frame_1, int frame_2)
@@ -357,11 +357,11 @@ static int transform_snap_sequencer_to_closest_strip_ex(TransInfo *t, int frame_
 
   float snap_offset = 0;
   if (snap_success) {
-    t->tsnap.status |= (POINT_INIT | TARGET_INIT);
+    t->tsnap.status |= (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
     transform_snap_sequencer_apply_translate(t, &snap_offset);
   }
   else {
-    t->tsnap.status &= ~(POINT_INIT | TARGET_INIT);
+    t->tsnap.status &= ~(SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
   }
 
   return snap_offset;
@@ -382,7 +382,7 @@ bool ED_transform_snap_sequencer_to_closest_strip_calc(Scene *scene,
 
   t.tsnap.mode = SEQ_tool_settings_snap_mode_get(scene);
   *r_snap_distance = transform_snap_sequencer_to_closest_strip_ex(&t, frame_1, frame_2);
-  *r_snap_frame = t.tsnap.snapPoint[0];
+  *r_snap_frame = t.tsnap.snap_target[0];
   return validSnap(&t);
 }
 
@@ -393,8 +393,8 @@ void ED_draw_sequencer_snap_point(struct bContext *C, float snap_point)
   t.mode = TFM_SEQ_SLIDE;
   t.modifiers = MOD_SNAP;
   t.spacetype = SPACE_SEQ;
-  t.tsnap.status = (POINT_INIT | TARGET_INIT);
-  t.tsnap.snapPoint[0] = snap_point;
+  t.tsnap.status = (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
+  t.tsnap.snap_target[0] = snap_point;
 
   drawSnapping(C, &t);
 }
diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h
index a42fb09dbf7..ab16b3b986b 100644
--- a/source/blender/makesdna/DNA_scene_types.h
+++ b/source/blender/makesdna/DNA_scene_types.h
@@ -1618,7 +1618,7 @@ typedef struct ToolSettings {
   short snap_flag_node;
   short snap_flag_seq;
   short snap_uv_flag;
-  /** Default snap source, #eSnapSourceSelect. */
+  /** Default snap source, #eSnapSourceOP. */
   /**
    * TODO(@gfxcoder): Rename `snap_target` to `snap_source` to avoid previous ambiguity of
    * "target" (now, "source" is geometry to be moved and "target" is geometry to which moved
@@ -2244,7 +2244,7 @@ typedef enum eSnapFlag {
   SCE_SNAP_ABS_GRID = (1 << 5),
   SCE_SNAP_BACKFACE_CULLING = (1 << 6),
   SCE_SNAP_KEEP_ON_SAME_OBJECT = (1 << 7),
-  /** see #eSnapTargetSelect */
+  /** see #eSnapTargetOP */
   SCE_SNAP_TO_INCLUDE_EDITED = (1 << 8),
   SCE_SNAP_TO_INCLUDE_NONEDITED = (1 << 9),
   SCE_SNAP_TO_ONLY_SELECTABLE = (1 << 10),
@@ -2255,30 +2255,30 @@ typedef enum eSnapFlag {
 ENUM_OPERATORS(eSnapFlag, SCE_SNAP_BACKFACE_CULLING)
 #endif
 
-/** See #ToolSettings.snap_target (to be renamed `snap_source`) and #TransSnap.source_select */
-typedef enum eSnapSourceSelect {
+/** See #ToolSettings.snap_target (to be renamed `snap_source`) and #TransSnap.source_operation */
+typedef enum eSnapSourceOP {
   SCE_SNAP_SOURCE_CLOSEST = 0,
   SCE_SNAP_SOURCE_CENTER = 1,
   SCE_SNAP_SOURCE_MEDIAN = 2,
   SCE_SNAP_SOURCE_ACTIVE = 3,
-} eSnapSourceSelect;
+} eSnapSourceOP;
 
-ENUM_OPERATORS(eSnapSourceSelect, SCE_SNAP_SOURCE_ACTIVE)
+ENUM_OPERATORS(eSnapSourceOP, SCE_SNAP_SOURCE_ACTIVE)
 
 /**
- * #TransSnap.target_select and #ToolSettings.snap_flag
+ * #TransSnap.target_operation and #ToolSettings.snap_flag
  * (#SCE_SNAP_NOT_TO_ACTIVE, #SCE_SNAP_TO_INCLUDE_EDITED, #SCE_SNAP_TO_INCLUDE_NONEDITED,
  * #SCE_SNAP_TO_ONLY_SELECTABLE).
  */
-typedef enum eSnapTargetSelect {
+typedef enum eSnapTargetOP {
   SCE_SNAP_TARGET_ALL = 0,
   SCE_SNAP_TARGET_NOT_SELECTED = (1 << 0),
   SCE_SNAP_TARGET_NOT_ACTIVE = (1 << 1),
   SCE_SNAP_TARGET_NOT_EDITED = (1 << 2),
   SCE_SNAP_TARGET_ONLY_SELECTABLE = (1 << 3),
   SCE_SNAP_TARGET_NOT_NONEDITED = (1 << 4),
-} eSnapTargetSelect;
-ENUM_OPERATORS(eSnapTargetSelect, SCE_SNAP_TARGET_NOT_NONEDITED)
+} eSnapTargetOP;
+ENUM_OPERATORS(eSnapTargetOP, SCE_SNAP_TARGET_NOT_NONEDITED)
 
 /** #ToolSettings.snap_mode */
 typedef enum eSnapMode {