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