Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / transform / transform_snap.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edtransform
22  */
23
24 #include <stdlib.h>
25 #include <math.h>
26 #include <float.h>
27 #include <stdio.h>
28
29 #include "PIL_time.h"
30
31 #include "DNA_scene_types.h"
32 #include "DNA_object_types.h"
33 #include "DNA_meshdata_types.h" /* Temporary, for snapping to other unselected meshes */
34 #include "DNA_node_types.h"
35 #include "DNA_space_types.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_view3d_types.h"
38 #include "DNA_windowmanager_types.h"
39
40 #include "BLI_math.h"
41 #include "BLI_blenlib.h"
42 #include "BLI_utildefines.h"
43
44 #include "GPU_immediate.h"
45 #include "GPU_state.h"
46
47 #include "BKE_layer.h"
48 #include "BKE_object.h"
49 #include "BKE_anim.h" /* for duplis */
50 #include "BKE_context.h"
51 #include "BKE_editmesh.h"
52 #include "BKE_sequencer.h"
53 #include "BKE_main.h"
54
55 #include "RNA_access.h"
56
57 #include "WM_types.h"
58
59 #include "ED_image.h"
60 #include "ED_node.h"
61 #include "ED_uvedit.h"
62 #include "ED_view3d.h"
63 #include "ED_transform_snap_object_context.h"
64
65 #include "DEG_depsgraph.h"
66
67 #include "UI_resources.h"
68 #include "UI_view2d.h"
69
70 #include "MEM_guardedalloc.h"
71
72 #include "transform.h"
73
74 /* this should be passed as an arg for use in snap functions */
75 #undef BASACT
76
77 /* use half of flt-max so we can scale up without an exception */
78
79 /********************* PROTOTYPES ***********************/
80
81 static void setSnappingCallback(TransInfo *t);
82
83 static void ApplySnapTranslation(TransInfo *t, float vec[3]);
84 static void ApplySnapRotation(TransInfo *t, float *vec);
85 static void ApplySnapResize(TransInfo *t, float vec[2]);
86
87 /* static void CalcSnapGrid(TransInfo *t, float *vec); */
88 static void CalcSnapGeometry(TransInfo *t, float *vec);
89
90 static void TargetSnapMedian(TransInfo *t);
91 static void TargetSnapCenter(TransInfo *t);
92 static void TargetSnapClosest(TransInfo *t);
93 static void TargetSnapActive(TransInfo *t);
94
95 static float RotationBetween(TransInfo *t, const float p1[3], const float p2[3]);
96 static float TranslationBetween(TransInfo *t, const float p1[3], const float p2[3]);
97 static float ResizeBetween(TransInfo *t, const float p1[3], const float p2[3]);
98
99 /****************** IMPLEMENTATIONS *********************/
100
101 static bool snapNodeTest(View2D *v2d, bNode *node, eSnapSelect snap_select);
102 static NodeBorder snapNodeBorder(int snap_node_mode);
103
104 #if 0
105 int BIF_snappingSupported(Object *obedit)
106 {
107   int status = 0;
108
109   /* only support object mesh, armature, curves */
110   if (obedit == NULL || ELEM(obedit->type, OB_MESH, OB_ARMATURE, OB_CURVE, OB_LATTICE, OB_MBALL)) {
111     status = 1;
112   }
113
114   return status;
115 }
116 #endif
117
118 bool validSnap(const TransInfo *t)
119 {
120   return (t->tsnap.status & (POINT_INIT | TARGET_INIT)) == (POINT_INIT | TARGET_INIT) ||
121          (t->tsnap.status & (MULTI_POINTS | TARGET_INIT)) == (MULTI_POINTS | TARGET_INIT);
122 }
123
124 bool activeSnap(const TransInfo *t)
125 {
126   return ((t->modifiers & (MOD_SNAP | MOD_SNAP_INVERT)) == MOD_SNAP) ||
127          ((t->modifiers & (MOD_SNAP | MOD_SNAP_INVERT)) == MOD_SNAP_INVERT);
128 }
129
130 bool transformModeUseSnap(const TransInfo *t)
131 {
132   ToolSettings *ts = t->settings;
133   if (t->mode == TFM_TRANSLATION) {
134     return (ts->snap_transform_mode_flag & SCE_SNAP_TRANSFORM_MODE_TRANSLATE) != 0;
135   }
136   if (t->mode == TFM_ROTATION) {
137     return (ts->snap_transform_mode_flag & SCE_SNAP_TRANSFORM_MODE_ROTATE) != 0;
138   }
139   if (t->mode == TFM_RESIZE) {
140     return (ts->snap_transform_mode_flag & SCE_SNAP_TRANSFORM_MODE_SCALE) != 0;
141   }
142
143   return false;
144 }
145
146 static bool doForceIncrementSnap(const TransInfo *t)
147 {
148   return !transformModeUseSnap(t);
149 }
150
151 void drawSnapping(const struct bContext *C, TransInfo *t)
152 {
153   unsigned char col[4], selectedCol[4], activeCol[4];
154
155   if (!activeSnap(t)) {
156     return;
157   }
158
159   UI_GetThemeColor3ubv(TH_TRANSFORM, col);
160   col[3] = 128;
161
162   UI_GetThemeColor3ubv(TH_SELECT, selectedCol);
163   selectedCol[3] = 128;
164
165   UI_GetThemeColor3ubv(TH_ACTIVE, activeCol);
166   activeCol[3] = 192;
167
168   if (t->spacetype == SPACE_VIEW3D) {
169     if (validSnap(t)) {
170       TransSnapPoint *p;
171       RegionView3D *rv3d = CTX_wm_region_view3d(C);
172       float imat[4][4];
173       float size;
174
175       GPU_depth_test(false);
176
177       size = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE);
178
179       invert_m4_m4(imat, rv3d->viewmat);
180
181       uint pos = GPU_vertformat_attr_add(
182           immVertexFormat(), "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
183
184       immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
185
186       for (p = t->tsnap.points.first; p; p = p->next) {
187         if (p == t->tsnap.selectedPoint) {
188           immUniformColor4ubv(selectedCol);
189         }
190         else {
191           immUniformColor4ubv(col);
192         }
193
194         imm_drawcircball(p->co, ED_view3d_pixel_size(rv3d, p->co) * size * 0.75f, imat, pos);
195       }
196
197       if (t->tsnap.status & POINT_INIT) {
198         immUniformColor4ubv(activeCol);
199
200         imm_drawcircball(
201             t->tsnap.snapPoint, ED_view3d_pixel_size(rv3d, t->tsnap.snapPoint) * size, imat, pos);
202       }
203
204       /* draw normal if needed */
205       if (usingSnappingNormal(t) && validSnappingNormal(t)) {
206         immUniformColor4ubv(activeCol);
207
208         immBegin(GPU_PRIM_LINES, 2);
209         immVertex3f(pos, t->tsnap.snapPoint[0], t->tsnap.snapPoint[1], t->tsnap.snapPoint[2]);
210         immVertex3f(pos,
211                     t->tsnap.snapPoint[0] + t->tsnap.snapNormal[0],
212                     t->tsnap.snapPoint[1] + t->tsnap.snapNormal[1],
213                     t->tsnap.snapPoint[2] + t->tsnap.snapNormal[2]);
214         immEnd();
215       }
216
217       immUnbindProgram();
218
219       GPU_depth_test(true);
220     }
221   }
222   else if (t->spacetype == SPACE_IMAGE) {
223     if (validSnap(t)) {
224       /* This will not draw, and Im nor sure why - campbell */
225       /* TODO: see 2.7x for non-working code */
226     }
227   }
228   else if (t->spacetype == SPACE_NODE) {
229     if (validSnap(t)) {
230       ARegion *ar = CTX_wm_region(C);
231       TransSnapPoint *p;
232       float size;
233
234       size = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE);
235
236       GPU_blend(true);
237
238       uint pos = GPU_vertformat_attr_add(
239           immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
240
241       immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
242
243       for (p = t->tsnap.points.first; p; p = p->next) {
244         if (p == t->tsnap.selectedPoint) {
245           immUniformColor4ubv(selectedCol);
246         }
247         else {
248           immUniformColor4ubv(col);
249         }
250
251         ED_node_draw_snap(&ar->v2d, p->co, size, 0, pos);
252       }
253
254       if (t->tsnap.status & POINT_INIT) {
255         immUniformColor4ubv(activeCol);
256
257         ED_node_draw_snap(&ar->v2d, t->tsnap.snapPoint, size, t->tsnap.snapNodeBorder, pos);
258       }
259
260       immUnbindProgram();
261
262       GPU_blend(false);
263     }
264   }
265 }
266
267 eRedrawFlag handleSnapping(TransInfo *t, const wmEvent *event)
268 {
269   eRedrawFlag status = TREDRAW_NOTHING;
270
271 #if 0  // XXX need a proper selector for all snap mode
272   if (BIF_snappingSupported(t->obedit) && event->type == TABKEY && event->shift) {
273     /* toggle snap and reinit */
274     t->settings->snap_flag ^= SCE_SNAP;
275     initSnapping(t, NULL);
276     status = TREDRAW_HARD;
277   }
278 #endif
279   if (event->type == MOUSEMOVE) {
280     status |= updateSelectedSnapPoint(t);
281   }
282
283   return status;
284 }
285
286 void applyProject(TransInfo *t)
287 {
288   /* XXX FLICKER IN OBJECT MODE */
289   if ((t->tsnap.project) && activeSnap(t) && (t->flag & T_NO_PROJECT) == 0) {
290     float tvec[3];
291     int i;
292
293     FOREACH_TRANS_DATA_CONTAINER (t, tc) {
294       TransData *td = tc->data;
295       for (i = 0; i < tc->data_len; i++, td++) {
296         float iloc[3], loc[3], no[3];
297         float mval_fl[2];
298
299         if (td->flag & TD_NOACTION) {
300           break;
301         }
302
303         if (td->flag & TD_SKIP) {
304           continue;
305         }
306
307         if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f)) {
308           continue;
309         }
310
311         copy_v3_v3(iloc, td->loc);
312         if (tc->use_local_mat) {
313           mul_m4_v3(tc->mat, iloc);
314         }
315         else if (t->flag & T_OBJECT) {
316           BKE_object_eval_transform_all(t->depsgraph, t->scene, td->ob);
317           copy_v3_v3(iloc, td->ob->obmat[3]);
318         }
319
320         if (ED_view3d_project_float_global(t->ar, iloc, mval_fl, V3D_PROJ_TEST_NOP) ==
321             V3D_PROJ_RET_OK) {
322           if (ED_transform_snap_object_project_view3d(
323                   t->tsnap.object_context,
324                   SCE_SNAP_MODE_FACE,
325                   &(const struct SnapObjectParams){
326                       .snap_select = t->tsnap.modeSelect,
327                       .use_object_edit_cage = (t->flag & T_EDIT) != 0,
328                       .use_occlusion_test = false,
329                   },
330                   mval_fl,
331                   0,
332                   loc,
333                   no)) {
334 #if 0
335             if (tc->use_local_mat) {
336               mul_m4_v3(tc->imat, loc);
337             }
338 #endif
339
340             sub_v3_v3v3(tvec, loc, iloc);
341
342             mul_m3_v3(td->smtx, tvec);
343
344             add_v3_v3(td->loc, tvec);
345
346             if (t->tsnap.align && (t->flag & T_OBJECT)) {
347               /* handle alignment as well */
348               const float *original_normal;
349               float mat[3][3];
350
351               /* In pose mode, we want to align normals with Y axis of bones... */
352               original_normal = td->axismtx[2];
353
354               rotation_between_vecs_to_mat3(mat, original_normal, no);
355
356               transform_data_ext_rotate(td, mat, true);
357
358               /* TODO support constraints for rotation too? see ElementRotation */
359             }
360           }
361         }
362
363         //XXX constraintTransLim(t, td);
364       }
365     }
366   }
367 }
368
369 void applyGridAbsolute(TransInfo *t)
370 {
371   float grid_size = 0.0f;
372   GearsType grid_action;
373   int i;
374
375   if (!(activeSnap(t) && (t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)))) {
376     return;
377   }
378
379   grid_action = BIG_GEARS;
380   if (t->modifiers & MOD_PRECISION) {
381     grid_action = SMALL_GEARS;
382   }
383
384   switch (grid_action) {
385     case NO_GEARS:
386       grid_size = t->snap_spatial[0];
387       break;
388     case BIG_GEARS:
389       grid_size = t->snap_spatial[1];
390       break;
391     case SMALL_GEARS:
392       grid_size = t->snap_spatial[2];
393       break;
394   }
395   /* early exit on unusable grid size */
396   if (grid_size == 0.0f) {
397     return;
398   }
399
400   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
401     TransData *td;
402
403     for (i = 0, td = tc->data; i < tc->data_len; i++, td++) {
404       float iloc[3], loc[3], tvec[3];
405
406       if (td->flag & TD_NOACTION) {
407         break;
408       }
409
410       if (td->flag & TD_SKIP) {
411         continue;
412       }
413
414       if ((t->flag & T_PROP_EDIT) && (td->factor == 0.0f)) {
415         continue;
416       }
417
418       copy_v3_v3(iloc, td->loc);
419       if (tc->use_local_mat) {
420         mul_m4_v3(tc->mat, iloc);
421       }
422       else if (t->flag & T_OBJECT) {
423         BKE_object_eval_transform_all(t->depsgraph, t->scene, td->ob);
424         copy_v3_v3(iloc, td->ob->obmat[3]);
425       }
426
427       mul_v3_v3fl(loc, iloc, 1.0f / grid_size);
428       loc[0] = roundf(loc[0]);
429       loc[1] = roundf(loc[1]);
430       loc[2] = roundf(loc[2]);
431       mul_v3_fl(loc, grid_size);
432
433       sub_v3_v3v3(tvec, loc, iloc);
434       mul_m3_v3(td->smtx, tvec);
435       add_v3_v3(td->loc, tvec);
436     }
437   }
438 }
439
440 void applySnapping(TransInfo *t, float *vec)
441 {
442   /* Each Trans Data already makes the snap to face */
443   if (doForceIncrementSnap(t) || (t->tsnap.project && t->tsnap.mode == SCE_SNAP_MODE_FACE)) {
444     return;
445   }
446
447   if (t->tsnap.status & SNAP_FORCED) {
448     t->tsnap.targetSnap(t);
449
450     t->tsnap.applySnap(t, vec);
451   }
452   else if (((t->tsnap.mode & ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) != 0) &&
453            activeSnap(t)) {
454     double current = PIL_check_seconds_timer();
455
456     // Time base quirky code to go around findnearest slowness
457     /* !TODO! add exception for object mode, no need to slow it down then */
458     if (current - t->tsnap.last >= 0.01) {
459       t->tsnap.calcSnap(t, vec);
460       t->tsnap.targetSnap(t);
461
462       t->tsnap.last = current;
463     }
464     if (validSnap(t)) {
465       t->tsnap.applySnap(t, vec);
466     }
467   }
468 }
469
470 void resetSnapping(TransInfo *t)
471 {
472   t->tsnap.status = 0;
473   t->tsnap.align = false;
474   t->tsnap.project = 0;
475   t->tsnap.mode = 0;
476   t->tsnap.modeSelect = 0;
477   t->tsnap.target = 0;
478   t->tsnap.last = 0;
479   t->tsnap.applySnap = NULL;
480
481   t->tsnap.snapNormal[0] = 0;
482   t->tsnap.snapNormal[1] = 0;
483   t->tsnap.snapNormal[2] = 0;
484
485   t->tsnap.snapNodeBorder = 0;
486 }
487
488 bool usingSnappingNormal(const TransInfo *t)
489 {
490   return t->tsnap.align;
491 }
492
493 bool validSnappingNormal(const TransInfo *t)
494 {
495   if (validSnap(t)) {
496     if (!is_zero_v3(t->tsnap.snapNormal)) {
497       return true;
498     }
499   }
500
501   return false;
502 }
503
504 static bool bm_edge_is_snap_target(BMEdge *e, void *UNUSED(user_data))
505 {
506   if (BM_elem_flag_test(e, BM_ELEM_SELECT | BM_ELEM_HIDDEN) ||
507       BM_elem_flag_test(e->v1, BM_ELEM_SELECT) || BM_elem_flag_test(e->v2, BM_ELEM_SELECT)) {
508     return false;
509   }
510
511   return true;
512 }
513
514 static bool bm_face_is_snap_target(BMFace *f, void *UNUSED(user_data))
515 {
516   if (BM_elem_flag_test(f, BM_ELEM_SELECT | BM_ELEM_HIDDEN)) {
517     return false;
518   }
519
520   BMLoop *l_iter, *l_first;
521   l_iter = l_first = BM_FACE_FIRST_LOOP(f);
522   do {
523     if (BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) {
524       return false;
525     }
526   } while ((l_iter = l_iter->next) != l_first);
527
528   return true;
529 }
530
531 static void initSnappingMode(TransInfo *t)
532 {
533   Main *bmain = CTX_data_main(t->context);
534   ToolSettings *ts = t->settings;
535   /* All obedit types will match. */
536   const int obedit_type = t->data_container->obedit ? t->data_container->obedit->type : -1;
537   ViewLayer *view_layer = t->view_layer;
538   Base *base_act = view_layer->basact;
539
540   if (t->spacetype == SPACE_NODE) {
541     /* force project off when not supported */
542     t->tsnap.project = 0;
543
544     t->tsnap.mode = ts->snap_node_mode;
545   }
546   else if (t->spacetype == SPACE_IMAGE) {
547     /* force project off when not supported */
548     t->tsnap.project = 0;
549
550     t->tsnap.mode = ts->snap_uv_mode;
551   }
552   else {
553     /* force project off when not supported */
554     if ((ts->snap_mode & SCE_SNAP_MODE_FACE) == 0) {
555       t->tsnap.project = 0;
556     }
557
558     t->tsnap.mode = ts->snap_mode;
559   }
560
561   if ((t->spacetype == SPACE_VIEW3D || t->spacetype == SPACE_IMAGE) && /* Only 3D view or UV */
562       (t->flag & T_CAMERA) == 0) /* Not with camera selected in camera view */
563   {
564     setSnappingCallback(t);
565
566     /* Edit mode */
567     if (t->tsnap.applySnap != NULL &&  // A snapping function actually exist
568         ((obedit_type != -1) &&
569          ELEM(obedit_type,
570               OB_MESH,
571               OB_ARMATURE,
572               OB_CURVE,
573               OB_LATTICE,
574               OB_MBALL)))  // Temporary limited to edit mode meshes, armature, curves, metaballs
575     {
576       /* Exclude editmesh if using proportional edit */
577       if ((obedit_type == OB_MESH) && (t->flag & T_PROP_EDIT)) {
578         t->tsnap.modeSelect = SNAP_NOT_ACTIVE;
579       }
580       else {
581         t->tsnap.modeSelect = t->tsnap.snap_self ? SNAP_ALL : SNAP_NOT_ACTIVE;
582       }
583     }
584     /* Particles edit mode*/
585     else if (t->tsnap.applySnap != NULL &&  // A snapping function actually exist
586              ((obedit_type == -1) && base_act && base_act->object &&
587               base_act->object->mode & OB_MODE_PARTICLE_EDIT)) {
588       t->tsnap.modeSelect = SNAP_ALL;
589     }
590     /* Object mode */
591     else if (t->tsnap.applySnap != NULL &&  // A snapping function actually exist
592              (obedit_type == -1))           // Object Mode
593     {
594       /* In "Edit Strokes" mode,
595        * snap tool can perform snap to selected or active objects (see T49632)
596        * TODO: perform self snap in gpencil_strokes */
597       t->tsnap.modeSelect = (((t->options & (CTX_GPENCIL_STROKES | CTX_CURSOR)) != 0) ?
598                                  SNAP_ALL :
599                                  SNAP_NOT_SELECTED);
600     }
601     else {
602       /* Grid if snap is not possible */
603       t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
604     }
605   }
606   else if (t->spacetype == SPACE_NODE) {
607     setSnappingCallback(t);
608
609     if (t->tsnap.applySnap != NULL) {
610       t->tsnap.modeSelect = SNAP_NOT_SELECTED;
611     }
612     else {
613       /* Grid if snap is not possible */
614       t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
615     }
616   }
617   else if (t->spacetype == SPACE_SEQ) {
618     /* We do our own snapping currently, so nothing here */
619     t->tsnap.mode = SCE_SNAP_MODE_GRID; /* Dummy, should we rather add a NOP mode? */
620   }
621   else {
622     /* Always grid outside of 3D view */
623     t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
624   }
625
626   if (t->spacetype == SPACE_VIEW3D) {
627     if (t->tsnap.object_context == NULL) {
628       t->tsnap.object_context = ED_transform_snap_object_context_create_view3d(
629           bmain, t->scene, t->depsgraph, 0, t->ar, t->view);
630
631       ED_transform_snap_object_context_set_editmesh_callbacks(
632           t->tsnap.object_context,
633           (bool (*)(BMVert *, void *))BM_elem_cb_check_hflag_disabled,
634           bm_edge_is_snap_target,
635           bm_face_is_snap_target,
636           POINTER_FROM_UINT((BM_ELEM_SELECT | BM_ELEM_HIDDEN)));
637     }
638   }
639 }
640
641 void initSnapping(TransInfo *t, wmOperator *op)
642 {
643   ToolSettings *ts = t->settings;
644   short snap_target = t->settings->snap_target;
645
646   resetSnapping(t);
647
648   /* if snap property exists */
649   if (op && RNA_struct_find_property(op->ptr, "snap") &&
650       RNA_struct_property_is_set(op->ptr, "snap")) {
651     if (RNA_boolean_get(op->ptr, "snap")) {
652       t->modifiers |= MOD_SNAP;
653
654       if (RNA_struct_property_is_set(op->ptr, "snap_target")) {
655         snap_target = RNA_enum_get(op->ptr, "snap_target");
656       }
657
658       if (RNA_struct_property_is_set(op->ptr, "snap_point")) {
659         RNA_float_get_array(op->ptr, "snap_point", t->tsnap.snapPoint);
660         t->tsnap.status |= SNAP_FORCED | POINT_INIT;
661       }
662
663       /* snap align only defined in specific cases */
664       if (RNA_struct_find_property(op->ptr, "snap_align")) {
665         t->tsnap.align = RNA_boolean_get(op->ptr, "snap_align");
666         RNA_float_get_array(op->ptr, "snap_normal", t->tsnap.snapNormal);
667         normalize_v3(t->tsnap.snapNormal);
668       }
669
670       if (RNA_struct_find_property(op->ptr, "use_snap_project")) {
671         t->tsnap.project = RNA_boolean_get(op->ptr, "use_snap_project");
672       }
673
674       if (RNA_struct_find_property(op->ptr, "use_snap_self")) {
675         t->tsnap.snap_self = RNA_boolean_get(op->ptr, "use_snap_self");
676       }
677     }
678   }
679   /* use scene defaults only when transform is modal */
680   else if (t->flag & T_MODAL) {
681     if (ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE, SPACE_NODE)) {
682       if (transformModeUseSnap(t) && (ts->snap_flag & SCE_SNAP)) {
683         t->modifiers |= MOD_SNAP;
684       }
685
686       t->tsnap.align = ((t->settings->snap_flag & SCE_SNAP_ROTATE) != 0);
687       t->tsnap.project = ((t->settings->snap_flag & SCE_SNAP_PROJECT) != 0);
688       t->tsnap.snap_self = !((t->settings->snap_flag & SCE_SNAP_NO_SELF) != 0);
689       t->tsnap.peel = ((t->settings->snap_flag & SCE_SNAP_PROJECT) != 0);
690     }
691
692     /* for now only 3d view (others can be added if we want) */
693     if (t->spacetype == SPACE_VIEW3D) {
694       t->tsnap.snap_spatial_grid = ((t->settings->snap_flag & SCE_SNAP_ABS_GRID) != 0);
695     }
696   }
697
698   t->tsnap.target = snap_target;
699
700   initSnappingMode(t);
701 }
702
703 void freeSnapping(TransInfo *t)
704 {
705   if (t->tsnap.object_context) {
706     ED_transform_snap_object_context_destroy(t->tsnap.object_context);
707     t->tsnap.object_context = NULL;
708   }
709 }
710
711 static void setSnappingCallback(TransInfo *t)
712 {
713   t->tsnap.calcSnap = CalcSnapGeometry;
714
715   switch (t->tsnap.target) {
716     case SCE_SNAP_TARGET_CLOSEST:
717       t->tsnap.targetSnap = TargetSnapClosest;
718       break;
719     case SCE_SNAP_TARGET_CENTER:
720       t->tsnap.targetSnap = TargetSnapCenter;
721       break;
722     case SCE_SNAP_TARGET_MEDIAN:
723       t->tsnap.targetSnap = TargetSnapMedian;
724       break;
725     case SCE_SNAP_TARGET_ACTIVE:
726       t->tsnap.targetSnap = TargetSnapActive;
727       break;
728   }
729
730   switch (t->mode) {
731     case TFM_TRANSLATION:
732       t->tsnap.applySnap = ApplySnapTranslation;
733       t->tsnap.distance = TranslationBetween;
734       break;
735     case TFM_ROTATION:
736       t->tsnap.applySnap = ApplySnapRotation;
737       t->tsnap.distance = RotationBetween;
738
739       // Can't do TARGET_CENTER with rotation, use TARGET_MEDIAN instead
740       if (t->tsnap.target == SCE_SNAP_TARGET_CENTER) {
741         t->tsnap.target = SCE_SNAP_TARGET_MEDIAN;
742         t->tsnap.targetSnap = TargetSnapMedian;
743       }
744       break;
745     case TFM_RESIZE:
746       t->tsnap.applySnap = ApplySnapResize;
747       t->tsnap.distance = ResizeBetween;
748
749       // Can't do TARGET_CENTER with resize, use TARGET_MEDIAN instead
750       if (t->tsnap.target == SCE_SNAP_TARGET_CENTER) {
751         t->tsnap.target = SCE_SNAP_TARGET_MEDIAN;
752         t->tsnap.targetSnap = TargetSnapMedian;
753       }
754       break;
755     default:
756       t->tsnap.applySnap = NULL;
757       break;
758   }
759 }
760
761 void addSnapPoint(TransInfo *t)
762 {
763   /* Currently only 3D viewport works for snapping points. */
764   if (t->tsnap.status & POINT_INIT && t->spacetype == SPACE_VIEW3D) {
765     TransSnapPoint *p = MEM_callocN(sizeof(TransSnapPoint), "SnapPoint");
766
767     t->tsnap.selectedPoint = p;
768
769     copy_v3_v3(p->co, t->tsnap.snapPoint);
770
771     BLI_addtail(&t->tsnap.points, p);
772
773     t->tsnap.status |= MULTI_POINTS;
774   }
775 }
776
777 eRedrawFlag updateSelectedSnapPoint(TransInfo *t)
778 {
779   eRedrawFlag status = TREDRAW_NOTHING;
780
781   if (t->tsnap.status & MULTI_POINTS) {
782     TransSnapPoint *p, *closest_p = NULL;
783     float dist_min_sq = TRANSFORM_SNAP_MAX_PX;
784     const float mval_fl[2] = {t->mval[0], t->mval[1]};
785     float screen_loc[2];
786
787     for (p = t->tsnap.points.first; p; p = p->next) {
788       float dist_sq;
789
790       if (ED_view3d_project_float_global(t->ar, p->co, screen_loc, V3D_PROJ_TEST_NOP) !=
791           V3D_PROJ_RET_OK) {
792         continue;
793       }
794
795       dist_sq = len_squared_v2v2(mval_fl, screen_loc);
796
797       if (dist_sq < dist_min_sq) {
798         closest_p = p;
799         dist_min_sq = dist_sq;
800       }
801     }
802
803     if (closest_p) {
804       if (t->tsnap.selectedPoint != closest_p) {
805         status = TREDRAW_HARD;
806       }
807
808       t->tsnap.selectedPoint = closest_p;
809     }
810   }
811
812   return status;
813 }
814
815 void removeSnapPoint(TransInfo *t)
816 {
817   if (t->tsnap.status & MULTI_POINTS) {
818     updateSelectedSnapPoint(t);
819
820     if (t->tsnap.selectedPoint) {
821       BLI_freelinkN(&t->tsnap.points, t->tsnap.selectedPoint);
822
823       if (BLI_listbase_is_empty(&t->tsnap.points)) {
824         t->tsnap.status &= ~MULTI_POINTS;
825       }
826
827       t->tsnap.selectedPoint = NULL;
828     }
829   }
830 }
831
832 void getSnapPoint(const TransInfo *t, float vec[3])
833 {
834   if (t->tsnap.points.first) {
835     TransSnapPoint *p;
836     int total = 0;
837
838     vec[0] = vec[1] = vec[2] = 0;
839
840     for (p = t->tsnap.points.first; p; p = p->next, total++) {
841       add_v3_v3(vec, p->co);
842     }
843
844     if (t->tsnap.status & POINT_INIT) {
845       add_v3_v3(vec, t->tsnap.snapPoint);
846       total++;
847     }
848
849     mul_v3_fl(vec, 1.0f / total);
850   }
851   else {
852     copy_v3_v3(vec, t->tsnap.snapPoint);
853   }
854 }
855
856 /********************** APPLY **************************/
857
858 static void ApplySnapTranslation(TransInfo *t, float vec[3])
859 {
860   float point[3];
861   getSnapPoint(t, point);
862
863   if (t->spacetype == SPACE_NODE) {
864     char border = t->tsnap.snapNodeBorder;
865     if (border & (NODE_LEFT | NODE_RIGHT)) {
866       vec[0] = point[0] - t->tsnap.snapTarget[0];
867     }
868     if (border & (NODE_BOTTOM | NODE_TOP)) {
869       vec[1] = point[1] - t->tsnap.snapTarget[1];
870     }
871   }
872   else {
873     if (t->spacetype == SPACE_VIEW3D) {
874       if (t->options & CTX_PAINT_CURVE) {
875         if (ED_view3d_project_float_global(t->ar, point, point, V3D_PROJ_TEST_NOP) !=
876             V3D_PROJ_RET_OK) {
877           zero_v3(point); /* no good answer here... */
878         }
879       }
880     }
881
882     sub_v3_v3v3(vec, point, t->tsnap.snapTarget);
883   }
884 }
885
886 static void ApplySnapRotation(TransInfo *t, float *value)
887 {
888   float point[3];
889   getSnapPoint(t, point);
890
891   float dist = RotationBetween(t, t->tsnap.snapTarget, point);
892   *value = dist;
893 }
894
895 static void ApplySnapResize(TransInfo *t, float vec[3])
896 {
897   float point[3];
898   getSnapPoint(t, point);
899
900   float dist = ResizeBetween(t, t->tsnap.snapTarget, point);
901   if (dist != TRANSFORM_DIST_INVALID) {
902     copy_v3_fl(vec, dist);
903   }
904 }
905
906 /********************** DISTANCE **************************/
907
908 static float TranslationBetween(TransInfo *UNUSED(t), const float p1[3], const float p2[3])
909 {
910   return len_squared_v3v3(p1, p2);
911 }
912
913 static float RotationBetween(TransInfo *t, const float p1[3], const float p2[3])
914 {
915   float angle, start[3], end[3];
916
917   sub_v3_v3v3(start, p1, t->center_global);
918   sub_v3_v3v3(end, p2, t->center_global);
919
920   // Angle around a constraint axis (error prone, will need debug)
921   if (t->con.applyRot != NULL && (t->con.mode & CON_APPLY)) {
922     float axis[3], tmp[3];
923
924     t->con.applyRot(t, NULL, NULL, axis, NULL);
925
926     project_v3_v3v3(tmp, end, axis);
927     sub_v3_v3v3(end, end, tmp);
928
929     project_v3_v3v3(tmp, start, axis);
930     sub_v3_v3v3(start, start, tmp);
931
932     normalize_v3(end);
933     normalize_v3(start);
934
935     cross_v3_v3v3(tmp, start, end);
936
937     if (dot_v3v3(tmp, axis) < 0.0f) {
938       angle = -acosf(dot_v3v3(start, end));
939     }
940     else {
941       angle = acosf(dot_v3v3(start, end));
942     }
943   }
944   else {
945     float mtx[3][3];
946
947     copy_m3_m4(mtx, t->viewmat);
948
949     mul_m3_v3(mtx, end);
950     mul_m3_v3(mtx, start);
951
952     angle = atan2f(start[1], start[0]) - atan2f(end[1], end[0]);
953   }
954
955   if (angle > (float)M_PI) {
956     angle = angle - 2 * (float)M_PI;
957   }
958   else if (angle < -((float)M_PI)) {
959     angle = 2.0f * (float)M_PI + angle;
960   }
961
962   return angle;
963 }
964
965 static float ResizeBetween(TransInfo *t, const float p1[3], const float p2[3])
966 {
967   float d1[3], d2[3], len_d1;
968
969   sub_v3_v3v3(d1, p1, t->center_global);
970   sub_v3_v3v3(d2, p2, t->center_global);
971
972   if (t->con.applyRot != NULL && (t->con.mode & CON_APPLY)) {
973     mul_m3_v3(t->con.pmtx, d1);
974     mul_m3_v3(t->con.pmtx, d2);
975   }
976
977   project_v3_v3v3(d1, d1, d2);
978
979   len_d1 = len_v3(d1);
980
981   /* Use 'invalid' dist when `center == p1` (after projecting),
982    * in this case scale will _never_ move the point in relation to the center,
983    * so it makes no sense to take it into account when scaling. see: T46503 */
984   return len_d1 != 0.0f ? len_v3(d2) / len_d1 : TRANSFORM_DIST_INVALID;
985 }
986
987 /********************** CALC **************************/
988
989 static void UNUSED_FUNCTION(CalcSnapGrid)(TransInfo *t, float *UNUSED(vec))
990 {
991   snapGridIncrementAction(t, t->tsnap.snapPoint, BIG_GEARS);
992 }
993
994 static void CalcSnapGeometry(TransInfo *t, float *UNUSED(vec))
995 {
996   if (t->spacetype == SPACE_VIEW3D) {
997     float loc[3];
998     float no[3];
999     float mval[2];
1000     bool found = false;
1001     float dist_px = SNAP_MIN_DISTANCE;  // Use a user defined value here
1002
1003     mval[0] = t->mval[0];
1004     mval[1] = t->mval[1];
1005
1006     if (t->tsnap.mode & (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE)) {
1007       zero_v3(no); /* objects won't set this */
1008       found = snapObjectsTransform(t, mval, &dist_px, loc, no);
1009     }
1010     if ((found == false) && (t->tsnap.mode & SCE_SNAP_MODE_VOLUME)) {
1011       found = peelObjectsTransform(
1012           t, mval, (t->settings->snap_flag & SCE_SNAP_PEEL_OBJECT) != 0, loc, no, NULL);
1013     }
1014
1015     if (found == true) {
1016       copy_v3_v3(t->tsnap.snapPoint, loc);
1017       copy_v3_v3(t->tsnap.snapNormal, no);
1018
1019       t->tsnap.status |= POINT_INIT;
1020     }
1021     else {
1022       t->tsnap.status &= ~POINT_INIT;
1023     }
1024   }
1025   else if (t->spacetype == SPACE_IMAGE && t->obedit_type == OB_MESH) {
1026     if (t->tsnap.mode & SCE_SNAP_MODE_VERTEX) {
1027       Image *ima = ED_space_image(t->sa->spacedata.first);
1028       float co[2];
1029
1030       UI_view2d_region_to_view(&t->ar->v2d, t->mval[0], t->mval[1], &co[0], &co[1]);
1031
1032       uint objects_len = 0;
1033       Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data_with_uvs(
1034           t->view_layer, NULL, &objects_len);
1035
1036       float dist_sq = FLT_MAX;
1037       if (ED_uvedit_nearest_uv_multi(
1038               t->scene, ima, objects, objects_len, co, &dist_sq, t->tsnap.snapPoint)) {
1039         t->tsnap.snapPoint[0] *= t->aspect[0];
1040         t->tsnap.snapPoint[1] *= t->aspect[1];
1041
1042         t->tsnap.status |= POINT_INIT;
1043       }
1044       else {
1045         t->tsnap.status &= ~POINT_INIT;
1046       }
1047       MEM_freeN(objects);
1048     }
1049   }
1050   else if (t->spacetype == SPACE_NODE) {
1051     if (t->tsnap.mode & (SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y)) {
1052       float loc[2];
1053       float dist_px = SNAP_MIN_DISTANCE;  // Use a user defined value here
1054       char node_border;
1055
1056       if (snapNodesTransform(t, t->mval, loc, &dist_px, &node_border)) {
1057         copy_v2_v2(t->tsnap.snapPoint, loc);
1058         t->tsnap.snapNodeBorder = node_border;
1059
1060         t->tsnap.status |= POINT_INIT;
1061       }
1062       else {
1063         t->tsnap.status &= ~POINT_INIT;
1064       }
1065     }
1066   }
1067 }
1068
1069 /********************** TARGET **************************/
1070
1071 static void TargetSnapOffset(TransInfo *t, TransData *td)
1072 {
1073   if (t->spacetype == SPACE_NODE && td != NULL) {
1074     bNode *node = td->extra;
1075     char border = t->tsnap.snapNodeBorder;
1076     float width = BLI_rctf_size_x(&node->totr);
1077     float height = BLI_rctf_size_y(&node->totr);
1078
1079 #ifdef USE_NODE_CENTER
1080     if (border & NODE_LEFT) {
1081       t->tsnap.snapTarget[0] -= 0.5f * width;
1082     }
1083     if (border & NODE_RIGHT) {
1084       t->tsnap.snapTarget[0] += 0.5f * width;
1085     }
1086     if (border & NODE_BOTTOM) {
1087       t->tsnap.snapTarget[1] -= 0.5f * height;
1088     }
1089     if (border & NODE_TOP) {
1090       t->tsnap.snapTarget[1] += 0.5f * height;
1091     }
1092 #else
1093     if (border & NODE_LEFT) {
1094       t->tsnap.snapTarget[0] -= 0.0f;
1095     }
1096     if (border & NODE_RIGHT) {
1097       t->tsnap.snapTarget[0] += width;
1098     }
1099     if (border & NODE_BOTTOM) {
1100       t->tsnap.snapTarget[1] -= height;
1101     }
1102     if (border & NODE_TOP) {
1103       t->tsnap.snapTarget[1] += 0.0f;
1104     }
1105 #endif
1106   }
1107 }
1108
1109 static void TargetSnapCenter(TransInfo *t)
1110 {
1111   /* Only need to calculate once */
1112   if ((t->tsnap.status & TARGET_INIT) == 0) {
1113     copy_v3_v3(t->tsnap.snapTarget, t->center_global);
1114     TargetSnapOffset(t, NULL);
1115
1116     t->tsnap.status |= TARGET_INIT;
1117   }
1118 }
1119
1120 static void TargetSnapActive(TransInfo *t)
1121 {
1122   /* Only need to calculate once */
1123   if ((t->tsnap.status & TARGET_INIT) == 0) {
1124     if (calculateCenterActive(t, true, t->tsnap.snapTarget)) {
1125       TargetSnapOffset(t, NULL);
1126
1127       t->tsnap.status |= TARGET_INIT;
1128     }
1129     /* No active, default to median */
1130     else {
1131       t->tsnap.target = SCE_SNAP_TARGET_MEDIAN;
1132       t->tsnap.targetSnap = TargetSnapMedian;
1133       TargetSnapMedian(t);
1134     }
1135   }
1136 }
1137
1138 static void TargetSnapMedian(TransInfo *t)
1139 {
1140   // Only need to calculate once
1141   if ((t->tsnap.status & TARGET_INIT) == 0) {
1142     int i_accum = 0;
1143
1144     t->tsnap.snapTarget[0] = 0;
1145     t->tsnap.snapTarget[1] = 0;
1146     t->tsnap.snapTarget[2] = 0;
1147
1148     FOREACH_TRANS_DATA_CONTAINER (t, tc) {
1149       TransData *td = tc->data;
1150       int i;
1151       float v[3];
1152       zero_v3(v);
1153
1154       for (i = 0; i < tc->data_len && td->flag & TD_SELECTED; i++, td++) {
1155         add_v3_v3(v, td->center);
1156       }
1157
1158       if (tc->use_local_mat) {
1159         mul_m4_v3(tc->mat, v);
1160       }
1161
1162       add_v3_v3(t->tsnap.snapTarget, v);
1163       i_accum += i;
1164     }
1165
1166     mul_v3_fl(t->tsnap.snapTarget, 1.0 / i_accum);
1167
1168     TargetSnapOffset(t, NULL);
1169
1170     t->tsnap.status |= TARGET_INIT;
1171   }
1172 }
1173
1174 static void TargetSnapClosest(TransInfo *t)
1175 {
1176   // Only valid if a snap point has been selected
1177   if (t->tsnap.status & POINT_INIT) {
1178     float dist_closest = 0.0f;
1179     TransData *closest = NULL;
1180
1181     /* Object mode */
1182     if (t->flag & T_OBJECT) {
1183       int i;
1184       FOREACH_TRANS_DATA_CONTAINER (t, tc) {
1185         TransData *td = tc->data;
1186         for (td = tc->data, i = 0; i < tc->data_len && td->flag & TD_SELECTED; i++, td++) {
1187           struct BoundBox *bb = BKE_object_boundbox_get(td->ob);
1188
1189           /* use boundbox if possible */
1190           if (bb) {
1191             int j;
1192
1193             for (j = 0; j < 8; j++) {
1194               float loc[3];
1195               float dist;
1196
1197               copy_v3_v3(loc, bb->vec[j]);
1198               mul_m4_v3(td->ext->obmat, loc);
1199
1200               dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
1201
1202               if ((dist != TRANSFORM_DIST_INVALID) &&
1203                   (closest == NULL || fabsf(dist) < fabsf(dist_closest))) {
1204                 copy_v3_v3(t->tsnap.snapTarget, loc);
1205                 closest = td;
1206                 dist_closest = dist;
1207               }
1208             }
1209           }
1210           /* use element center otherwise */
1211           else {
1212             float loc[3];
1213             float dist;
1214
1215             copy_v3_v3(loc, td->center);
1216
1217             dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
1218
1219             if ((dist != TRANSFORM_DIST_INVALID) &&
1220                 (closest == NULL || fabsf(dist) < fabsf(dist_closest))) {
1221               copy_v3_v3(t->tsnap.snapTarget, loc);
1222               closest = td;
1223             }
1224           }
1225         }
1226       }
1227     }
1228     else {
1229       FOREACH_TRANS_DATA_CONTAINER (t, tc) {
1230         TransData *td = tc->data;
1231         int i;
1232         for (i = 0; i < tc->data_len && td->flag & TD_SELECTED; i++, td++) {
1233           float loc[3];
1234           float dist;
1235
1236           copy_v3_v3(loc, td->center);
1237
1238           if (tc->use_local_mat) {
1239             mul_m4_v3(tc->mat, loc);
1240           }
1241
1242           dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
1243
1244           if ((dist != TRANSFORM_DIST_INVALID) &&
1245               (closest == NULL || fabsf(dist) < fabsf(dist_closest))) {
1246             copy_v3_v3(t->tsnap.snapTarget, loc);
1247             closest = td;
1248             dist_closest = dist;
1249           }
1250         }
1251       }
1252     }
1253
1254     TargetSnapOffset(t, closest);
1255
1256     t->tsnap.status |= TARGET_INIT;
1257   }
1258 }
1259
1260 bool snapObjectsTransform(
1261     TransInfo *t, const float mval[2], float *dist_px, float r_loc[3], float r_no[3])
1262 {
1263   return ED_transform_snap_object_project_view3d(
1264       t->tsnap.object_context,
1265       t->scene->toolsettings->snap_mode,
1266       &(const struct SnapObjectParams){
1267           .snap_select = t->tsnap.modeSelect,
1268           .use_object_edit_cage = (t->flag & T_EDIT) != 0,
1269           .use_occlusion_test = t->scene->toolsettings->snap_mode != SCE_SNAP_MODE_FACE,
1270       },
1271       mval,
1272       dist_px,
1273       r_loc,
1274       r_no);
1275 }
1276
1277 /******************** PEELING *********************************/
1278
1279 bool peelObjectsSnapContext(SnapObjectContext *sctx,
1280                             const float mval[2],
1281                             const struct SnapObjectParams *params,
1282                             const bool use_peel_object,
1283                             /* return args */
1284                             float r_loc[3],
1285                             float r_no[3],
1286                             float *r_thickness)
1287 {
1288   ListBase depths_peel = {0};
1289   ED_transform_snap_object_project_all_view3d_ex(sctx, params, mval, -1.0f, false, &depths_peel);
1290
1291   if (!BLI_listbase_is_empty(&depths_peel)) {
1292     /* At the moment we only use the hits of the first object */
1293     struct SnapObjectHitDepth *hit_min = depths_peel.first;
1294     for (struct SnapObjectHitDepth *iter = hit_min->next; iter; iter = iter->next) {
1295       if (iter->depth < hit_min->depth) {
1296         hit_min = iter;
1297       }
1298     }
1299     struct SnapObjectHitDepth *hit_max = NULL;
1300
1301     if (use_peel_object) {
1302       /* if peeling objects, take the first and last from each object */
1303       hit_max = hit_min;
1304       for (struct SnapObjectHitDepth *iter = depths_peel.first; iter; iter = iter->next) {
1305         if ((iter->depth > hit_max->depth) && (iter->ob_uuid == hit_min->ob_uuid)) {
1306           hit_max = iter;
1307         }
1308       }
1309     }
1310     else {
1311       /* otherwise, pair first with second and so on */
1312       for (struct SnapObjectHitDepth *iter = depths_peel.first; iter; iter = iter->next) {
1313         if ((iter != hit_min) && (iter->ob_uuid == hit_min->ob_uuid)) {
1314           if (hit_max == NULL) {
1315             hit_max = iter;
1316           }
1317           else if (iter->depth < hit_max->depth) {
1318             hit_max = iter;
1319           }
1320         }
1321       }
1322       /* in this case has only one hit. treat as raycast */
1323       if (hit_max == NULL) {
1324         hit_max = hit_min;
1325       }
1326     }
1327
1328     mid_v3_v3v3(r_loc, hit_min->co, hit_max->co);
1329
1330     if (r_thickness) {
1331       *r_thickness = hit_max->depth - hit_min->depth;
1332     }
1333
1334     /* XXX, is there a correct normal in this case ???, for now just z up */
1335     r_no[0] = 0.0;
1336     r_no[1] = 0.0;
1337     r_no[2] = 1.0;
1338
1339     BLI_freelistN(&depths_peel);
1340     return true;
1341   }
1342   return false;
1343 }
1344
1345 bool peelObjectsTransform(TransInfo *t,
1346                           const float mval[2],
1347                           const bool use_peel_object,
1348                           /* return args */
1349                           float r_loc[3],
1350                           float r_no[3],
1351                           float *r_thickness)
1352 {
1353   return peelObjectsSnapContext(t->tsnap.object_context,
1354                                 mval,
1355                                 &(const struct SnapObjectParams){
1356                                     .snap_select = t->tsnap.modeSelect,
1357                                     .use_object_edit_cage = (t->flag & T_EDIT) != 0,
1358                                 },
1359                                 use_peel_object,
1360                                 r_loc,
1361                                 r_no,
1362                                 r_thickness);
1363 }
1364
1365 /******************** NODES ***********************************/
1366
1367 static bool snapNodeTest(View2D *v2d, bNode *node, eSnapSelect snap_select)
1368 {
1369   /* node is use for snapping only if a) snap mode matches and b) node is inside the view */
1370   return ((snap_select == SNAP_NOT_SELECTED && !(node->flag & NODE_SELECT)) ||
1371           (snap_select == SNAP_ALL && !(node->flag & NODE_ACTIVE))) &&
1372          (node->totr.xmin < v2d->cur.xmax && node->totr.xmax > v2d->cur.xmin &&
1373           node->totr.ymin < v2d->cur.ymax && node->totr.ymax > v2d->cur.ymin);
1374 }
1375
1376 static NodeBorder snapNodeBorder(int snap_node_mode)
1377 {
1378   NodeBorder flag = 0;
1379   if (snap_node_mode & SCE_SNAP_MODE_NODE_X) {
1380     flag |= NODE_LEFT | NODE_RIGHT;
1381   }
1382   if (snap_node_mode & SCE_SNAP_MODE_NODE_Y) {
1383     flag |= NODE_TOP | NODE_BOTTOM;
1384   }
1385   return flag;
1386 }
1387
1388 static bool snapNode(ToolSettings *ts,
1389                      SpaceNode *UNUSED(snode),
1390                      ARegion *ar,
1391                      bNode *node,
1392                      const int mval[2],
1393                      float r_loc[2],
1394                      float *r_dist_px,
1395                      char *r_node_border)
1396 {
1397   View2D *v2d = &ar->v2d;
1398   NodeBorder border = snapNodeBorder(ts->snap_node_mode);
1399   bool retval = false;
1400   rcti totr;
1401   int new_dist;
1402
1403   UI_view2d_view_to_region_rcti(v2d, &node->totr, &totr);
1404
1405   if (border & NODE_LEFT) {
1406     new_dist = abs(totr.xmin - mval[0]);
1407     if (new_dist < *r_dist_px) {
1408       UI_view2d_region_to_view(v2d, totr.xmin, mval[1], &r_loc[0], &r_loc[1]);
1409       *r_dist_px = new_dist;
1410       *r_node_border = NODE_LEFT;
1411       retval = true;
1412     }
1413   }
1414
1415   if (border & NODE_RIGHT) {
1416     new_dist = abs(totr.xmax - mval[0]);
1417     if (new_dist < *r_dist_px) {
1418       UI_view2d_region_to_view(v2d, totr.xmax, mval[1], &r_loc[0], &r_loc[1]);
1419       *r_dist_px = new_dist;
1420       *r_node_border = NODE_RIGHT;
1421       retval = true;
1422     }
1423   }
1424
1425   if (border & NODE_BOTTOM) {
1426     new_dist = abs(totr.ymin - mval[1]);
1427     if (new_dist < *r_dist_px) {
1428       UI_view2d_region_to_view(v2d, mval[0], totr.ymin, &r_loc[0], &r_loc[1]);
1429       *r_dist_px = new_dist;
1430       *r_node_border = NODE_BOTTOM;
1431       retval = true;
1432     }
1433   }
1434
1435   if (border & NODE_TOP) {
1436     new_dist = abs(totr.ymax - mval[1]);
1437     if (new_dist < *r_dist_px) {
1438       UI_view2d_region_to_view(v2d, mval[0], totr.ymax, &r_loc[0], &r_loc[1]);
1439       *r_dist_px = new_dist;
1440       *r_node_border = NODE_TOP;
1441       retval = true;
1442     }
1443   }
1444
1445   return retval;
1446 }
1447
1448 static bool snapNodes(ToolSettings *ts,
1449                       SpaceNode *snode,
1450                       ARegion *ar,
1451                       const int mval[2],
1452                       eSnapSelect snap_select,
1453                       float r_loc[2],
1454                       float *r_dist_px,
1455                       char *r_node_border)
1456 {
1457   bNodeTree *ntree = snode->edittree;
1458   bNode *node;
1459   bool retval = false;
1460
1461   *r_node_border = 0;
1462
1463   for (node = ntree->nodes.first; node; node = node->next) {
1464     if (snapNodeTest(&ar->v2d, node, snap_select)) {
1465       retval |= snapNode(ts, snode, ar, node, mval, r_loc, r_dist_px, r_node_border);
1466     }
1467   }
1468
1469   return retval;
1470 }
1471
1472 bool snapNodesTransform(
1473     TransInfo *t, const int mval[2], float r_loc[2], float *r_dist_px, char *r_node_border)
1474 {
1475   return snapNodes(t->settings,
1476                    t->sa->spacedata.first,
1477                    t->ar,
1478                    mval,
1479                    t->tsnap.modeSelect,
1480                    r_loc,
1481                    r_dist_px,
1482                    r_node_border);
1483 }
1484
1485 /*================================================================*/
1486
1487 static void applyGridIncrement(
1488     TransInfo *t, float *val, int max_index, const float fac[3], GearsType action);
1489
1490 void snapGridIncrementAction(TransInfo *t, float *val, GearsType action)
1491 {
1492   float fac[3];
1493
1494   fac[NO_GEARS] = t->snap[0];
1495   fac[BIG_GEARS] = t->snap[1];
1496   fac[SMALL_GEARS] = t->snap[2];
1497
1498   applyGridIncrement(t, val, t->idx_max, fac, action);
1499 }
1500
1501 void snapGridIncrement(TransInfo *t, float *val)
1502 {
1503   GearsType action;
1504
1505   /* only do something if using absolute or incremental grid snapping
1506    * and there is no valid snap point */
1507   if ((!(t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) || validSnap(t)) &&
1508       !doForceIncrementSnap(t)) {
1509     return;
1510   }
1511
1512   action = activeSnap(t) ? BIG_GEARS : NO_GEARS;
1513
1514   if (action == BIG_GEARS && (t->modifiers & MOD_PRECISION)) {
1515     action = SMALL_GEARS;
1516   }
1517
1518   snapGridIncrementAction(t, val, action);
1519 }
1520
1521 void snapSequenceBounds(TransInfo *t, const int mval[2])
1522 {
1523   float xmouse, ymouse;
1524   int frame;
1525   int mframe;
1526   TransSeq *ts = TRANS_DATA_CONTAINER_FIRST_SINGLE(t)->custom.type.data;
1527   /* reuse increment, strictly speaking could be another snap mode, but leave as is */
1528   if (!(t->modifiers & MOD_SNAP_INVERT)) {
1529     return;
1530   }
1531
1532   /* convert to frame range */
1533   UI_view2d_region_to_view(&t->ar->v2d, mval[0], mval[1], &xmouse, &ymouse);
1534   mframe = round_fl_to_int(xmouse);
1535   /* now find the closest sequence */
1536   frame = BKE_sequencer_find_next_prev_edit(t->scene, mframe, SEQ_SIDE_BOTH, true, false, true);
1537
1538   if (!ts->snap_left) {
1539     frame = frame - (ts->max - ts->min);
1540   }
1541
1542   t->values[0] = frame - ts->min;
1543 }
1544
1545 static void applyGridIncrement(
1546     TransInfo *t, float *val, int max_index, const float fac[3], GearsType action)
1547 {
1548   float asp_local[3] = {1, 1, 1};
1549   const bool use_aspect = ELEM(t->mode, TFM_TRANSLATION);
1550   const float *asp = use_aspect ? t->aspect : asp_local;
1551   int i;
1552
1553   BLI_assert((t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) ||
1554              doForceIncrementSnap(t));
1555   BLI_assert(max_index <= 2);
1556
1557   /* Early bailing out if no need to snap */
1558   if (fac[action] == 0.0f) {
1559     return;
1560   }
1561
1562   if (use_aspect) {
1563     /* custom aspect for fcurve */
1564     if (t->spacetype == SPACE_GRAPH) {
1565       View2D *v2d = &t->ar->v2d;
1566       View2DGrid *grid;
1567       SpaceGraph *sipo = t->sa->spacedata.first;
1568       int unity = V2D_UNIT_VALUES;
1569       int unitx = (sipo->flag & SIPO_DRAWTIME) ? V2D_UNIT_SECONDS : V2D_UNIT_FRAMESCALE;
1570
1571       /* grid */
1572       grid = UI_view2d_grid_calc(t->scene,
1573                                  v2d,
1574                                  unitx,
1575                                  V2D_GRID_NOCLAMP,
1576                                  unity,
1577                                  V2D_GRID_NOCLAMP,
1578                                  t->ar->winx,
1579                                  t->ar->winy);
1580
1581       UI_view2d_grid_size(grid, &asp_local[0], &asp_local[1]);
1582       UI_view2d_grid_free(grid);
1583
1584       asp = asp_local;
1585     }
1586   }
1587
1588   /* absolute snapping on grid based on global center */
1589   if ((t->tsnap.snap_spatial_grid) && (t->mode == TFM_TRANSLATION)) {
1590     const float *center_global = t->center_global;
1591     bool use_local_axis = false;
1592
1593     /* use a fallback for cursor selection,
1594      * this isn't useful as a global center for absolute grid snapping
1595      * since its not based on the position of the selection. */
1596     if (t->around == V3D_AROUND_CURSOR) {
1597       const TransCenterData *cd = transformCenter_from_type(t, V3D_AROUND_CENTER_MEDIAN);
1598       center_global = cd->global;
1599     }
1600
1601     if (t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2)) {
1602       use_local_axis = true;
1603     }
1604
1605     for (i = 0; i <= max_index; i++) {
1606       /* do not let unconstrained axis jump to absolute grid increments */
1607       if (!(t->con.mode & CON_APPLY) || t->con.mode & (CON_AXIS0 << i)) {
1608         const float iter_fac = fac[action] * asp[i];
1609
1610         if (use_local_axis) {
1611           float local_axis[3];
1612           float pos_on_axis[3];
1613
1614           copy_v3_v3(local_axis, t->con.mtx[i]);
1615           copy_v3_v3(pos_on_axis, t->con.mtx[i]);
1616
1617           /* amount of movement on axis from initial pos */
1618           mul_v3_fl(pos_on_axis, val[i]);
1619
1620           /* actual global position on axis */
1621           add_v3_v3(pos_on_axis, center_global);
1622
1623           float min_dist = INFINITY;
1624           for (int j = 0; j < 3; j++) {
1625             if (fabs(local_axis[j]) < 0.01f) {
1626               /* Ignore very small (normalized) axis changes */
1627               continue;
1628             }
1629
1630             /* closest point on grid */
1631             float grid_p = iter_fac * roundf(pos_on_axis[j] / iter_fac);
1632             float dist_p = fabs((grid_p - pos_on_axis[j]) / local_axis[j]);
1633
1634             /* The amount of distance needed to travel along the
1635              * local axis to snap to the closest grid point */
1636             /* in the global j axis direction */
1637             float move_dist = (grid_p - center_global[j]) / local_axis[j];
1638
1639             if (dist_p < min_dist) {
1640               min_dist = dist_p;
1641               val[i] = move_dist;
1642             }
1643           }
1644         }
1645         else {
1646           val[i] = iter_fac * roundf((val[i] + center_global[i]) / iter_fac) - center_global[i];
1647         }
1648       }
1649     }
1650   }
1651   else {
1652     /* relative snapping in fixed increments */
1653     for (i = 0; i <= max_index; i++) {
1654       const float iter_fac = fac[action] * asp[i];
1655       val[i] = iter_fac * roundf(val[i] / iter_fac);
1656     }
1657   }
1658 }