Merge remote-tracking branch 'origin/master' into lineart-bvh

1 files changed, 171 insertions, 118 deletions

diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c
index bebef049718..05dcc612aae 100644
--- a/source/blender/editors/transform/transform_snap.c
+++ b/source/blender/editors/transform/transform_snap.c
@@ -41,9 +41,6 @@
 
 #include "RNA_access.h"
 
-#include "SEQ_sequencer.h"
-#include "SEQ_time.h"
-
 #include "WM_types.h"
 
 #include "ED_gizmo_library.h"
@@ -55,12 +52,18 @@
 #include "UI_resources.h"
 #include "UI_view2d.h"
 
+#include "SEQ_iterator.h"
+#include "SEQ_sequencer.h"
+#include "SEQ_time.h"
+
 #include "MEM_guardedalloc.h"
 
 #include "transform.h"
 #include "transform_convert.h"
 #include "transform_snap.h"
 
+static bool doForceIncrementSnap(const TransInfo *t);
+
 /* this should be passed as an arg for use in snap functions */
 #undef BASACT
 
@@ -73,7 +76,10 @@
 static void setSnappingCallback(TransInfo *t);
 
 /* static void CalcSnapGrid(TransInfo *t, float *vec); */
-static void CalcSnapGeometry(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 TargetSnapMedian(TransInfo *t);
 static void TargetSnapCenter(TransInfo *t);
@@ -133,6 +139,23 @@ bool activeSnap(const TransInfo *t)
          ((t->modifiers & (MOD_SNAP | MOD_SNAP_INVERT)) == MOD_SNAP_INVERT);
 }
 
+bool activeSnap_with_project(const TransInfo *t)
+{
+  if (!t->tsnap.project) {
+    return false;
+  }
+
+  if (!activeSnap(t) || (t->flag & T_NO_PROJECT)) {
+    return false;
+  }
+
+  if (doForceIncrementSnap(t)) {
+    return false;
+  }
+
+  return true;
+}
+
 bool transformModeUseSnap(const TransInfo *t)
 {
   ToolSettings *ts = t->settings;
@@ -145,10 +168,7 @@ bool transformModeUseSnap(const TransInfo *t)
   if (t->mode == TFM_RESIZE) {
     return (ts->snap_transform_mode_flag & SCE_SNAP_TRANSFORM_MODE_SCALE) != 0;
   }
-  if (t->mode == TFM_VERT_SLIDE) {
-    return true;
-  }
-  if (t->mode == TFM_EDGE_SLIDE) {
+  if (ELEM(t->mode, TFM_VERT_SLIDE, TFM_EDGE_SLIDE, TFM_SEQ_SLIDE)) {
     return true;
   }
 
@@ -276,6 +296,26 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
       GPU_blend(GPU_BLEND_NONE);
     }
   }
+  else if (t->spacetype == SPACE_SEQ) {
+    if (validSnap(t)) {
+      const ARegion *region = CTX_wm_region(C);
+      GPU_blend(GPU_BLEND_ALPHA);
+      uint pos = GPU_vertformat_attr_add(
+          immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
+      immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
+      UI_GetThemeColor3ubv(TH_SEQ_ACTIVE, col);
+      col[3] = 128;
+      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,
+               region->v2d.cur.ymax,
+               t->tsnap.snapPoint[0] + pixelx,
+               region->v2d.cur.ymin);
+      immUnbindProgram();
+      GPU_blend(GPU_BLEND_NONE);
+    }
+  }
 }
 
 eRedrawFlag handleSnapping(TransInfo *t, const wmEvent *event)
@@ -299,15 +339,7 @@ eRedrawFlag handleSnapping(TransInfo *t, const wmEvent *event)
 
 void applyProject(TransInfo *t)
 {
-  if (!t->tsnap.project) {
-    return;
-  }
-
-  if (!activeSnap(t) || (t->flag & T_NO_PROJECT)) {
-    return;
-  }
-
-  if (doForceIncrementSnap(t)) {
+  if (!activeSnap_with_project(t)) {
     return;
   }
 
@@ -465,10 +497,13 @@ void applySnapping(TransInfo *t, float *vec)
     /* TODO: add exception for object mode, no need to slow it down then. */
     if (current - t->tsnap.last >= 0.01) {
       t->tsnap.calcSnap(t, vec);
-      t->tsnap.targetSnap(t);
-
-      t->tsnap.last = current;
+      if (t->tsnap.targetSnap) {
+        t->tsnap.targetSnap(t);
+      }
     }
+
+    t->tsnap.last = current;
+
     if (validSnap(t)) {
       t->tsnap.applySnap(t, vec);
     }
@@ -556,6 +591,9 @@ static void initSnappingMode(TransInfo *t)
 
     t->tsnap.mode = ts->snap_uv_mode;
   }
+  else if (t->spacetype == SPACE_SEQ) {
+    t->tsnap.mode = SEQ_tool_settings_snap_mode_get(t->scene);
+  }
   else {
     /* force project off when not supported */
     if ((ts->snap_mode & SCE_SNAP_MODE_FACE) == 0) {
@@ -615,16 +653,12 @@ static void initSnappingMode(TransInfo *t)
       t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
     }
   }
-  else if (t->spacetype == SPACE_NODE) {
+  else if (ELEM(t->spacetype, SPACE_NODE, SPACE_SEQ)) {
     setSnappingCallback(t);
     t->tsnap.modeSelect = SNAP_NOT_SELECTED;
   }
-  else if (t->spacetype == SPACE_SEQ) {
-    /* We do our own snapping currently, so nothing here */
-    t->tsnap.mode = SCE_SNAP_MODE_GRID; /* Dummy, should we rather add a NOP mode? */
-  }
   else {
-    /* Always increment outside of 3D view */
+    /* Fallback. */
     t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
   }
 
@@ -645,6 +679,11 @@ static void initSnappingMode(TransInfo *t)
       }
     }
   }
+  else if (t->spacetype == SPACE_SEQ) {
+    if (t->tsnap.seq_context == NULL) {
+      t->tsnap.seq_context = transform_snap_sequencer_data_alloc(t);
+    }
+  }
 }
 
 void initSnapping(TransInfo *t, wmOperator *op)
@@ -697,6 +736,9 @@ void initSnapping(TransInfo *t, wmOperator *op)
       t->tsnap.snap_self = !((t->settings->snap_flag & SCE_SNAP_NO_SELF) != 0);
       t->tsnap.peel = ((t->settings->snap_flag & SCE_SNAP_PROJECT) != 0);
     }
+    else if ((t->spacetype == SPACE_SEQ) && (ts->snap_flag & SCE_SNAP_SEQ)) {
+      t->modifiers |= MOD_SNAP;
+    }
   }
 
   t->tsnap.target = snap_target;
@@ -706,7 +748,11 @@ void initSnapping(TransInfo *t, wmOperator *op)
 
 void freeSnapping(TransInfo *t)
 {
-  if (t->tsnap.object_context) {
+  if ((t->spacetype == SPACE_SEQ) && t->tsnap.seq_context) {
+    transform_snap_sequencer_data_free(t->tsnap.seq_context);
+    t->tsnap.seq_context = NULL;
+  }
+  else if (t->tsnap.object_context) {
     ED_transform_snap_object_context_destroy(t->tsnap.object_context);
     t->tsnap.object_context = NULL;
   }
@@ -714,7 +760,20 @@ void freeSnapping(TransInfo *t)
 
 static void setSnappingCallback(TransInfo *t)
 {
-  t->tsnap.calcSnap = CalcSnapGeometry;
+  if (t->spacetype == SPACE_VIEW3D) {
+    t->tsnap.calcSnap = snap_calc_view3d_fn;
+  }
+  else if (t->spacetype == SPACE_IMAGE && t->obedit_type == OB_MESH) {
+    t->tsnap.calcSnap = snap_calc_uv_fn;
+  }
+  else if (t->spacetype == SPACE_NODE) {
+    t->tsnap.calcSnap = snap_calc_node_fn;
+  }
+  else if (t->spacetype == SPACE_SEQ) {
+    t->tsnap.calcSnap = snap_calc_sequencer_fn;
+    /* The target is calculated along with the snap point. */
+    return;
+  }
 
   switch (t->tsnap.target) {
     case SCE_SNAP_TARGET_CLOSEST:
@@ -835,89 +894,105 @@ void getSnapPoint(const TransInfo *t, float vec[3])
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Calc Snap (Generic)
+/** \name Calc Snap
  * \{ */
 
-static void CalcSnapGeometry(TransInfo *t, float *UNUSED(vec))
+static void snap_calc_view3d_fn(TransInfo *t, float *UNUSED(vec))
 {
-  if (t->spacetype == SPACE_VIEW3D) {
-    float loc[3];
-    float no[3];
-    float mval[2];
-    bool found = false;
-    short snap_elem = 0;
-    float dist_px = SNAP_MIN_DISTANCE; /* Use a user defined value here. */
+  BLI_assert(t->spacetype == SPACE_VIEW3D);
+  float loc[3];
+  float no[3];
+  float mval[2];
+  bool found = false;
+  short snap_elem = 0;
+  float dist_px = SNAP_MIN_DISTANCE; /* Use a user defined value here. */
+
+  mval[0] = t->mval[0];
+  mval[1] = t->mval[1];
+
+  if (t->tsnap.mode & (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE |
+                       SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR)) {
+    zero_v3(no); /* objects won't set this */
+    snap_elem = snapObjectsTransform(t, mval, &dist_px, loc, no);
+    found = snap_elem != 0;
+  }
+  if ((found == false) && (t->tsnap.mode & SCE_SNAP_MODE_VOLUME)) {
+    found = peelObjectsTransform(
+        t, mval, (t->settings->snap_flag & SCE_SNAP_PEEL_OBJECT) != 0, loc, no, NULL);
+
+    if (found) {
+      snap_elem = SCE_SNAP_MODE_VOLUME;
+    }
+  }
 
-    mval[0] = t->mval[0];
-    mval[1] = t->mval[1];
+  if (found == true) {
+    copy_v3_v3(t->tsnap.snapPoint, loc);
+    copy_v3_v3(t->tsnap.snapNormal, no);
 
-    if (t->tsnap.mode & (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE |
-                         SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR)) {
-      zero_v3(no); /* objects won't set this */
-      snap_elem = snapObjectsTransform(t, mval, &dist_px, loc, no);
-      found = snap_elem != 0;
-    }
-    if ((found == false) && (t->tsnap.mode & SCE_SNAP_MODE_VOLUME)) {
-      found = peelObjectsTransform(
-          t, mval, (t->settings->snap_flag & SCE_SNAP_PEEL_OBJECT) != 0, loc, no, NULL);
+    t->tsnap.status |= POINT_INIT;
+  }
+  else {
+    t->tsnap.status &= ~POINT_INIT;
+  }
 
-      if (found) {
-        snap_elem = SCE_SNAP_MODE_VOLUME;
-      }
-    }
+  t->tsnap.snapElem = (char)snap_elem;
+}
 
-    if (found == true) {
-      copy_v3_v3(t->tsnap.snapPoint, loc);
-      copy_v3_v3(t->tsnap.snapNormal, no);
+static void snap_calc_uv_fn(TransInfo *t, float *UNUSED(vec))
+{
+  BLI_assert(t->spacetype == SPACE_IMAGE && t->obedit_type == OB_MESH);
+  if (t->tsnap.mode & SCE_SNAP_MODE_VERTEX) {
+    float co[2];
+
+    UI_view2d_region_to_view(&t->region->v2d, t->mval[0], t->mval[1], &co[0], &co[1]);
+
+    uint objects_len = 0;
+    Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data_with_uvs(
+        t->view_layer, NULL, &objects_len);
+
+    float dist_sq = FLT_MAX;
+    if (ED_uvedit_nearest_uv_multi(
+            t->scene, objects, objects_len, co, &dist_sq, t->tsnap.snapPoint)) {
+      t->tsnap.snapPoint[0] *= t->aspect[0];
+      t->tsnap.snapPoint[1] *= t->aspect[1];
 
       t->tsnap.status |= POINT_INIT;
     }
     else {
       t->tsnap.status &= ~POINT_INIT;
     }
-
-    t->tsnap.snapElem = (char)snap_elem;
+    MEM_freeN(objects);
   }
-  else if (t->spacetype == SPACE_IMAGE && t->obedit_type == OB_MESH) {
-    if (t->tsnap.mode & SCE_SNAP_MODE_VERTEX) {
-      float co[2];
-
-      UI_view2d_region_to_view(&t->region->v2d, t->mval[0], t->mval[1], &co[0], &co[1]);
+}
 
-      uint objects_len = 0;
-      Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data_with_uvs(
-          t->view_layer, NULL, &objects_len);
+static void snap_calc_node_fn(TransInfo *t, float *UNUSED(vec))
+{
+  BLI_assert(t->spacetype == SPACE_NODE);
+  if (t->tsnap.mode & (SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y)) {
+    float loc[2];
+    float dist_px = SNAP_MIN_DISTANCE; /* Use a user defined value here. */
+    char node_border;
 
-      float dist_sq = FLT_MAX;
-      if (ED_uvedit_nearest_uv_multi(
-              t->scene, objects, objects_len, co, &dist_sq, t->tsnap.snapPoint)) {
-        t->tsnap.snapPoint[0] *= t->aspect[0];
-        t->tsnap.snapPoint[1] *= t->aspect[1];
+    if (snapNodesTransform(t, t->mval, loc, &dist_px, &node_border)) {
+      copy_v2_v2(t->tsnap.snapPoint, loc);
+      t->tsnap.snapNodeBorder = node_border;
 
-        t->tsnap.status |= POINT_INIT;
-      }
-      else {
-        t->tsnap.status &= ~POINT_INIT;
-      }
-      MEM_freeN(objects);
+      t->tsnap.status |= POINT_INIT;
+    }
+    else {
+      t->tsnap.status &= ~POINT_INIT;
     }
   }
-  else if (t->spacetype == SPACE_NODE) {
-    if (t->tsnap.mode & (SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y)) {
-      float loc[2];
-      float dist_px = SNAP_MIN_DISTANCE; /* Use a user defined value here. */
-      char node_border;
-
-      if (snapNodesTransform(t, t->mval, loc, &dist_px, &node_border)) {
-        copy_v2_v2(t->tsnap.snapPoint, loc);
-        t->tsnap.snapNodeBorder = node_border;
+}
 
-        t->tsnap.status |= POINT_INIT;
-      }
-      else {
-        t->tsnap.status &= ~POINT_INIT;
-      }
-    }
+static void snap_calc_sequencer_fn(TransInfo *t, float *UNUSED(vec))
+{
+  BLI_assert(t->spacetype == SPACE_SEQ);
+  if (transform_snap_sequencer_calc(t)) {
+    t->tsnap.status |= (POINT_INIT | TARGET_INIT);
+  }
+  else {
+    t->tsnap.status &= ~(POINT_INIT | TARGET_INIT);
   }
 }
 
@@ -1430,28 +1505,6 @@ void snapFrameTransform(TransInfo *t,
   *r_val = (float)val;
 }
 
-/*================================================================*/
-
-void snapSequenceBounds(TransInfo *t, const int mval[2])
-{
-  /* Reuse increment, strictly speaking could be another snap mode, but leave as is. */
-  if (!(t->modifiers & MOD_SNAP_INVERT)) {
-    return;
-  }
-
-  /* Convert to frame range. */
-  float xmouse, ymouse;
-  UI_view2d_region_to_view(&t->region->v2d, mval[0], mval[1], &xmouse, &ymouse);
-  const int frame_curr = round_fl_to_int(xmouse);
-
-  /* Now find the closest sequence. */
-  const int frame_near = SEQ_time_find_next_prev_edit(
-      t->scene, frame_curr, SEQ_SIDE_BOTH, true, false, true);
-
-  const int frame_snap = transform_convert_sequencer_get_snap_bound(t);
-  t->values[0] = frame_near - frame_snap;
-}
-
 static void snap_grid_apply(
     TransInfo *t, const int max_index, const float grid_dist, const float loc[3], float r_out[3])
 {
@@ -1506,7 +1559,7 @@ bool transform_snap_grid(TransInfo *t, float *val)
   return true;
 }
 
-static void snap_increment_apply_ex(TransInfo *UNUSED(t),
+static void snap_increment_apply_ex(const TransInfo *UNUSED(t),
                                     const int max_index,
                                     const float increment_val,
                                     const float aspect[3],
@@ -1520,8 +1573,8 @@ static void snap_increment_apply_ex(TransInfo *UNUSED(t),
   }
 }
 
-static void snap_increment_apply(TransInfo *t,
-                                 int max_index,
+static void snap_increment_apply(const TransInfo *t,
+                                 const int max_index,
                                  const float increment_dist,
                                  float *r_val)
 {
@@ -1553,7 +1606,7 @@ static void snap_increment_apply(TransInfo *t,
   snap_increment_apply_ex(t, max_index, increment_dist, asp, r_val, r_val);
 }
 
-bool transform_snap_increment_ex(TransInfo *t, bool use_local_space, float *r_val)
+bool transform_snap_increment_ex(const TransInfo *t, bool use_local_space, float *r_val)
 {
   if (!activeSnap(t)) {
     return false;
@@ -1584,7 +1637,7 @@ bool transform_snap_increment_ex(TransInfo *t, bool use_local_space, float *r_va
   return true;
 }
 
-bool transform_snap_increment(TransInfo *t, float *r_val)
+bool transform_snap_increment(const TransInfo *t, float *r_val)
 {
   return transform_snap_increment_ex(t, false, r_val);
 }