Fix T61536: can't snap vertex to another vertex in edit mode using curves
[blender.git] / source / blender / editors / transform / transform.h
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 \ingroup edtransform
21  */
22
23
24 #ifndef __TRANSFORM_H__
25 #define __TRANSFORM_H__
26
27 #include "ED_transform.h"
28 #include "ED_numinput.h"
29 #include "ED_view3d.h"
30
31 #include "RE_engine.h"
32
33 #include "DNA_listBase.h"
34
35 #include "DEG_depsgraph.h"
36
37 /* ************************** Types ***************************** */
38
39 struct ARegion;
40 struct Depsgraph;
41 struct EditBone;
42 struct NumInput;
43 struct Object;
44 struct RNG;
45 struct RenderEngineType;
46 struct ReportList;
47 struct Scene;
48 struct ScrArea;
49 struct SnapObjectContext;
50 struct TransData;
51 struct TransDataContainer;
52 struct TransInfo;
53 struct TransSnap;
54 struct TransformOrientation;
55 struct View3D;
56 struct ViewLayer;
57 struct bConstraint;
58 struct bContext;
59 struct wmEvent;
60 struct wmKeyConfig;
61 struct wmKeyMap;
62 struct wmTimer;
63
64 #include "DNA_object_enums.h"
65
66 /* transinfo->redraw */
67 typedef enum {
68         TREDRAW_NOTHING   = 0,
69         TREDRAW_HARD      = 1,
70         TREDRAW_SOFT      = 2,
71 } eRedrawFlag;
72
73 typedef struct TransSnapPoint {
74         struct TransSnapPoint *next, *prev;
75         float co[3];
76 } TransSnapPoint;
77
78 typedef struct TransSnap {
79         short   mode;
80         short   target;
81         short   modePoint;
82         short   modeSelect;
83         bool    align;
84         bool    project;
85         bool    snap_self;
86         bool    peel;
87         bool    snap_spatial_grid;
88         short   status;
89         /** snapping from this point (in global-space). */
90         float   snapPoint[3];
91         /** to this point (in global-space). */
92         float   snapTarget[3];
93         float   snapNormal[3];
94         char    snapNodeBorder;
95         ListBase points;
96         TransSnapPoint  *selectedPoint;
97         double  last;
98         void  (*applySnap)(struct TransInfo *, float *);
99         void  (*calcSnap)(struct TransInfo *, float *);
100         void  (*targetSnap)(struct TransInfo *);
101         /**
102          * Get the transform distance between two points (used by Closest snap)
103          *
104          * \note Return value can be anything,
105          * where the smallest absolute value defines whats closest.
106          */
107         float  (*distance)(struct TransInfo *t, const float p1[3], const float p2[3]);
108
109         /**
110          * Re-usable snap context data.
111          */
112         struct SnapObjectContext *object_context;
113 } TransSnap;
114
115 typedef struct TransCon {
116         short orientation;
117         /** Description of the Constraint for header_print. */
118         char  text[50];
119         /** Matrix of the Constraint space. */
120         float mtx[3][3];
121         /** Inverse Matrix of the Constraint space. */
122         float imtx[3][3];
123         /** Projection Constraint Matrix (same as imtx with some axis == 0). */
124         float pmtx[3][3];
125         /** Initial mouse value for visual calculation
126          * the one in TransInfo is not guarantee to stay the same (Rotates change it). */
127         int   imval[2];
128         /** Mode flags of the Constraint. */
129         int   mode;
130         void  (*drawExtra)(struct TransInfo *t);
131
132         /* Note: if 'tc' is NULL, 'td' must also be NULL.
133          * For constraints that needs to draw differently from the other
134          * uses this instead of the generic draw function. */
135
136         /** Apply function pointer for linear vectorial transformation
137          * The last three parameters are pointers to the in/out/printable vectors. */
138         void  (*applyVec)(struct TransInfo *t, struct TransDataContainer *tc, struct TransData *td, const float in[3], float out[3], float pvec[3]);
139         /** Apply function pointer for size transformation. */
140         void  (*applySize)(struct TransInfo *t, struct TransDataContainer *tc, struct TransData *td, float smat[3][3]);
141         /** Apply function pointer for rotation transformation */
142         void  (*applyRot)(struct TransInfo *t, struct TransDataContainer *tc, struct TransData *td, float vec[3], float *angle);
143 } TransCon;
144
145 typedef struct TransDataExtension {
146         /** Initial object drot. */
147         float drot[3];
148         // /* Initial object drotAngle,    TODO: not yet implemented */
149         // float drotAngle;
150         // /* Initial object drotAxis, TODO: not yet implemented */
151         // float drotAxis[3];
152         /** Initial object dquat. */
153         float dquat[4];
154         /** Initial object dscale. */
155         float dscale[3];
156         /** Rotation of the data to transform. */
157         float *rot;
158         /** Initial rotation. */
159         float  irot[3];
160         /** Rotation quaternion of the data to transform. */
161         float *quat;
162         /** Initial rotation quaternion. */
163         float  iquat[4];
164         /** Rotation angle of the data to transform. */
165         float *rotAngle;
166         /** Initial rotation angle. */
167         float  irotAngle;
168         /** Rotation axis of the data to transform. */
169         float *rotAxis;
170         /** Initial rotation axis. */
171         float  irotAxis[4];
172         /** Size of the data to transform. */
173         float *size;
174         /** Initial size. */
175         float  isize[3];
176         /** Object matrix. */
177         float  obmat[4][4];
178         /** Use instead of td->smtx,
179          * It is the same but without the 'bone->bone_mat', see TD_PBONE_LOCAL_MTX_C. */
180         float  l_smtx[3][3];
181         /** The rotscale matrix of pose bone, to allow using snap-align in translation mode,
182          * when td->mtx is the loc pose bone matrix (and hence can't be used to apply
183          * rotation in some cases, namely when a bone is in "NoLocal" or "Hinge" mode)... */
184         float  r_mtx[3][3];
185         /** Inverse of previous one. */
186         float  r_smtx[3][3];
187         /** rotation mode, as defined in eRotationModes (DNA_action_types.h). */
188         int    rotOrder;
189         /** Original object transformation used for rigid bodies. */
190         float oloc[3], orot[3], oquat[4], orotAxis[3], orotAngle;
191 } TransDataExtension;
192
193 typedef struct TransData2D {
194         /** Location of data used to transform (x,y,0). */
195         float loc[3];
196         /** Pointer to real 2d location of data. */
197         float *loc2d;
198
199         /** Pointer to handle locations, if handles aren't being moved independently. */
200         float *h1, *h2;
201         float ih1[2], ih2[2];
202 } TransData2D;
203
204 /* we need to store 2 handles for each transdata in case the other handle wasn't selected */
205 typedef struct TransDataCurveHandleFlags {
206         char ih1, ih2;
207         char *h1, *h2;
208 } TransDataCurveHandleFlags;
209
210 /* for sequencer transform */
211 typedef struct TransDataSeq {
212         struct Sequence *seq;
213         /** A copy of seq->flag that may be modified for nested strips. */
214         int flag;
215         /** Use this so we can have transform data at the strips start,
216          * but apply correctly to the start frame. */
217         int start_offset;
218         /** one of SELECT, SEQ_LEFTSEL and SEQ_RIGHTSEL. */
219         short sel_flag;
220
221 } TransDataSeq;
222
223 typedef struct TransSeq {
224         TransDataSeq *tdseq;
225         int min;
226         int max;
227         bool snap_left;
228 } TransSeq;
229
230 /* for NLA transform (stored in td->extra pointer) */
231 typedef struct TransDataNla {
232         /** ID-block NLA-data is attached to. */
233         ID *id;
234
235         /** Original NLA-Track that the strip belongs to. */
236         struct NlaTrack *oldTrack;
237         /** Current NLA-Track that the strip belongs to. */
238         struct NlaTrack *nlt;
239
240         /** NLA-strip this data represents. */
241         struct NlaStrip *strip;
242
243         /* dummy values for transform to write in - must have 3 elements... */
244         /** start handle. */
245         float h1[3];
246         /** end handle. */
247         float h2[3];
248
249         /** index of track that strip is currently in. */
250         int trackIndex;
251         /** handle-index: 0 for dummy entry, -1 for start, 1 for end, 2 for both ends. */
252         int handle;
253 } TransDataNla;
254
255 struct GHash;
256 struct LinkNode;
257
258 /* header of TransDataEdgeSlideVert, TransDataEdgeSlideEdge */
259 typedef struct TransDataGenericSlideVert {
260         struct BMVert *v;
261         struct LinkNode **cd_loop_groups;
262         float co_orig_3d[3];
263 } TransDataGenericSlideVert;
264
265 typedef struct TransDataEdgeSlideVert {
266         /* TransDataGenericSlideVert */
267         struct BMVert *v;
268         struct LinkNode **cd_loop_groups;
269         float v_co_orig[3];
270         /* end generic */
271
272         float edge_len;
273
274         struct BMVert *v_side[2];
275
276         /* add origvert.co to get the original locations */
277         float dir_side[2][3];
278
279         int loop_nr;
280 } TransDataEdgeSlideVert;
281
282
283 /* store original data so we can correct UV's and similar when sliding */
284 typedef struct SlideOrigData {
285         /* flag that is set when origfaces is initialized */
286         bool use_origfaces;
287         int cd_loop_mdisp_offset;
288
289         /** map {BMVert: TransDataGenericSlideVert} */
290         struct GHash    *origverts;
291         struct GHash    *origfaces;
292         struct BMesh *bm_origfaces;
293
294         struct MemArena *arena;
295         /** Number of math BMLoop layers. */
296         int  layer_math_map_num;
297         /** Array size of 'layer_math_map_num'
298          * maps TransDataVertSlideVert.cd_group index to absolute CustomData layer index */
299         int *layer_math_map;
300
301         /** Array of slide vert data especially for mirror verts. */
302         TransDataGenericSlideVert *sv_mirror;
303         int totsv_mirror;
304 } SlideOrigData;
305
306 typedef struct EdgeSlideData {
307         TransDataEdgeSlideVert *sv;
308         int totsv;
309
310         int mval_start[2], mval_end[2];
311         struct BMEditMesh *em;
312
313         SlideOrigData orig_data;
314
315
316         int curr_sv_index;
317
318         /** when un-clamped - use this index: #TransDataEdgeSlideVert.dir_side */
319         int curr_side_unclamp;
320 } EdgeSlideData;
321
322 typedef struct EdgeSlideParams {
323         float perc;
324
325         bool use_even;
326         bool flipped;
327 } EdgeSlideParams;
328
329 typedef struct TransDataVertSlideVert {
330         /* TransDataGenericSlideVert */
331         struct BMVert *v;
332         struct LinkNode **cd_loop_groups;
333         float   co_orig_3d[3];
334         /* end generic */
335
336         float (*co_link_orig_3d)[3];
337         int     co_link_tot;
338         int     co_link_curr;
339 } TransDataVertSlideVert;
340
341 typedef struct VertSlideData {
342         TransDataVertSlideVert *sv;
343         int totsv;
344
345         struct BMEditMesh *em;
346
347         SlideOrigData orig_data;
348
349         int curr_sv_index;
350
351         /* result of ED_view3d_ob_project_mat_get */
352         float proj_mat[4][4];
353 } VertSlideData;
354
355 typedef struct VertSlideParams {
356         float perc;
357
358         bool use_even;
359         bool flipped;
360 } VertSlideParams;
361
362 typedef struct BoneInitData {
363         struct EditBone *bone;
364         float tail[3];
365         float rad_tail;
366         float roll;
367         float head[3];
368         float dist;
369         float xwidth;
370         float zwidth;
371 } BoneInitData;
372
373 typedef struct TransData {
374         /** Distance needed to affect element (for Proportionnal Editing). */
375         float  dist;
376         /** Distance to the nearest element (for Proportionnal Editing). */
377         float  rdist;
378         /** Factor of the transformation (for Proportionnal Editing). */
379         float  factor;
380         /** Location of the data to transform. */
381         float *loc;
382         /** Initial location. */
383         float  iloc[3];
384         /** Value pointer for special transforms. */
385         float *val;
386         /** Old value. */
387         float  ival;
388         /** Individual data center. */
389         float  center[3];
390         /** Transformation matrix from data space to global space. */
391         float  mtx[3][3];
392         /** Transformation matrix from global space to data space. */
393         float  smtx[3][3];
394         /** Axis orientation matrix of the data. */
395         float  axismtx[3][3];
396         struct Object *ob;
397         /** For objects/bones, the first constraint in its constraint stack. */
398         struct bConstraint *con;
399         /** For objects, poses. 1 single malloc per TransInfo! */
400         TransDataExtension *ext;
401         /** for curves, stores handle flags for modification/cancel. */
402         TransDataCurveHandleFlags *hdata;
403         /**
404          * Extra data (mirrored element pointer, in editmode mesh to BMVert)
405          * (editbone for roll fixing) (...).
406          */
407         void  *extra;
408         /** Various flags. */
409         int  flag;
410         /** If set, copy of Object or PoseChannel protection. */
411         short  protectflag;
412 } TransData;
413
414 typedef struct MouseInput {
415         void    (*apply)(struct TransInfo *t, struct MouseInput *mi, const double mval[2], float output[3]);
416         void    (*post)(struct TransInfo *t, float values[3]);
417
418         /** Initial mouse position. */
419         int     imval[2];
420         bool    precision;
421         float   precision_factor;
422         float   center[2];
423         float   factor;
424         /** Additional data, if needed by the particular function. */
425         void *data;
426
427         /**
428          * Use virtual cursor, which takes precision into account
429          * keeping track of the cursors 'virtual' location,
430          * to avoid jumping values when its toggled.
431          *
432          * This works well for scaling drag motion,
433          * but not for rotating around a point (rotaton needs its own custom accumulator)
434          */
435         bool use_virtual_mval;
436         struct {
437                 double prev[2];
438                 double accum[2];
439         } virtual_mval;
440 } MouseInput;
441
442 typedef struct TransCustomData {
443         void       *data;
444         void      (*free_cb)(struct TransInfo *, struct TransDataContainer *tc, struct TransCustomData *custom_data);
445         unsigned int use_free : 1;
446 } TransCustomData;
447
448 typedef struct TransCenterData {
449         float global[3];
450         unsigned int is_set : 1;
451 } TransCenterData;
452
453 /**
454  * Rule of thumb for choosing between mode/type:
455  * - If transform mode uses the data, assign to `mode`
456  *   (typically in transform.c).
457  * - If conversion uses the data as an extension to the #TransData, assign to `type`
458  *   (typically in transform_conversion.c).
459  */
460 typedef struct TransCustomDataContainer {
461         /** Owned by the mode (grab, scale, bend... ).*/
462         union {
463                 TransCustomData mode, first_elem;
464         };
465         TransCustomData type;
466 } TransCustomDataContainer;
467 #define TRANS_CUSTOM_DATA_ELEM_MAX (sizeof(TransCustomDataContainer) / sizeof(TransCustomData))
468
469 typedef struct TransDataContainer {
470         /**
471          * Use for cases we care about the active, eg: active vert of active mesh.
472          * if set this will _always_ be the first item in the array.
473          */
474         bool is_active;
475
476         /** Transformed data (array). */
477         TransData *data;
478         /** Total number of transformed data. */
479         int data_len;
480
481         /** Transformed data extension (array). */
482         TransDataExtension *data_ext;
483         /** Transformed data for 2d (array). */
484         TransData2D *data_2d;
485
486         struct Object *obedit;
487
488         /**
489          * Use when #T_LOCAL_MATRIX is set.
490          * Typically: 'obedit->obmat' or 'poseobj->obmat', but may be used elsewhere too.
491          */
492         bool use_local_mat;
493         float  mat[4][4];
494         float imat[4][4];
495         /** 3x3 copies of matrices above. */
496         float  mat3[3][3];
497         float imat3[3][3];
498
499         /** Normalized 'mat3' */
500         float  mat3_unit[3][3];
501
502         /** if 't->flag & T_POSE', this denotes pose object */
503         struct Object *poseobj;
504
505         /** Center of transformation (in local-space), Calculated from #TransInfo.center_global. */
506         float center_local[3];
507
508         /**
509          * Mirror option
510          */
511         struct {
512                 /* Currently for mesh X mirror only. */
513                 int axis_flag;
514                 /** Set to -1.0f or 1.0 when use_mirror is set. */
515                 float sign;
516         } mirror;
517
518         TransCustomDataContainer custom;
519 } TransDataContainer;
520
521 typedef struct TransInfo {
522         TransDataContainer *data_container;
523         int                 data_container_len;
524         /** Combine length of all #TransDataContainer.data_len
525          * Use to check if nothing is selected or if we have a single selection. */
526         int data_len_all;
527
528         /** Current mode. */
529         int         mode;
530         /** Generic flags for special behaviors. */
531         int             flag;
532         /** Special modifiers, by function, not key. */
533         int                     modifiers;
534         /** Current state (running, canceled. */
535         short           state;
536         /** Current context/options for transform. */
537         int         options;
538         /** Init value for some transformations (and rotation angle). */
539         float       val;
540         void      (*transform)(struct TransInfo *, const int[2]);
541         /** Transform function pointer. */
542         eRedrawFlag (*handleEvent)(struct TransInfo *, const struct wmEvent *);
543                                                                 /* event handler function pointer  RETURN 1 if redraw is needed */
544         /** transformed constraint. */
545         TransCon    con;
546         TransSnap       tsnap;
547         /** numerical input. */
548         NumInput    num;
549         /** mouse input. */
550         MouseInput      mouse;
551         /** redraw flag. */
552         eRedrawFlag redraw;
553         /** proportional circle radius. */
554         float           prop_size;
555         /** proportional falloff text. */
556         char            proptext[20];
557         /**
558          * Spaces using non 1:1 aspect, (uv's, f-curve, movie-clip... etc)
559          * use for conversion and snapping.
560          */
561         float       aspect[3];
562         /** center of transformation (in global-space) */
563         float       center_global[3];
564         /** center in screen coordinates. */
565         float       center2d[2];
566         /* Lazy initialize center data for when we need other center values.
567          * V3D_AROUND_ACTIVE + 1 (static assert checks this) */
568         TransCenterData center_cache[5];
569         /** maximum index on the input vector. */
570         short       idx_max;
571         /** Snapping Gears. */
572         float           snap[3];
573         /** Spatial snapping gears(even when rotating, scaling... etc). */
574         float           snap_spatial[3];
575         /** Mouse side of the cfra, 'L', 'R' or 'B' */
576         char            frame_side;
577
578         /** copy from G.vd, prevents feedback. */
579         float           viewmat[4][4];
580         /** and to make sure we don't have to. */
581         float           viewinv[4][4];
582         /** access G.vd from other space types. */
583         float           persmat[4][4];
584         float           persinv[4][4];
585         short           persp;
586         short           around;
587         /** spacetype where transforming is. */
588         char            spacetype;
589         /** Choice of custom cursor with or without a help line from the gizmo to the mouse position. */
590         char            helpline;
591         /** Avoid looking inside TransDataContainer obedit. */
592         short           obedit_type;
593
594         /** translation, to show for widget. */
595         float           vec[3];
596         /** rot/rescale, to show for widget. */
597         float           mat[3][3];
598
599         /** orientation matrix of the current space. */
600         float           spacemtx[3][3];
601         /** name of the current space, MAX_NAME. */
602         char            spacename[64];
603
604         /*************** NEW STUFF *********************/
605         /** event type used to launch transform. */
606         short           launch_event;
607
608         struct {
609                 short           user;
610                 /* Used when user is global. */
611                 short           user_alt;
612                 short           index;
613                 short           *types[2];
614                 /* this gets used when custom_orientation is V3D_ORIENT_CUSTOM */
615                 TransformOrientation *custom;
616         } orientation;
617         /** backup from view3d, to restore on end. */
618         short           gizmo_flag;
619
620         short           prop_mode;
621
622         float           values[4];
623         /** Offset applied ontop of modal input. */
624         float           values_modal_offset[4];
625         float           auto_values[4];
626         float           axis[3];
627         /** TransCon can change 'axis', store the original value here. */
628         float           axis_orig[3];
629         float           axis_ortho[3];
630
631         /** remove elements if operator is canceled. */
632         bool            remove_on_cancel;
633
634         void            *view;
635         /** Only valid (non null) during an operator called function. */
636         struct bContext *context;
637         struct ScrArea  *sa;
638         struct ARegion  *ar;
639         struct Depsgraph *depsgraph;
640         struct Scene    *scene;
641         struct ViewLayer *view_layer;
642         struct ToolSettings *settings;
643         struct wmTimer *animtimer;
644         /** so we can do lookups for header text. */
645         struct wmKeyMap *keymap;
646         /** assign from the operator, or can be NULL. */
647         struct ReportList *reports;
648         /** current mouse position. */
649         int         mval[2];
650         /** use for 3d view. */
651         float       zfac;
652         void            *draw_handle_apply;
653         void            *draw_handle_view;
654         void            *draw_handle_pixel;
655         void            *draw_handle_cursor;
656
657         /** Currently only used for random curve of proportional editing. */
658         struct RNG *rng;
659
660         /** Typically for mode settings. */
661         TransCustomDataContainer custom;
662 } TransInfo;
663
664
665 /* ******************** Macros & Prototypes *********************** */
666
667 /* transinfo->state */
668 enum {
669         TRANS_STARTING =  0,
670         TRANS_RUNNING =   1,
671         TRANS_CONFIRM =   2,
672         TRANS_CANCEL =    3,
673 };
674
675 /* transinfo->flag */
676 enum {
677         T_OBJECT =        1 << 0,
678         /** \note We could remove 'T_EDIT' and use 'obedit_type', for now ensure they're in sync. */
679         T_EDIT =          1 << 1,
680         T_POSE =          1 << 2,
681         T_TEXTURE =       1 << 3,
682         /** Transforming the camera while in camera view. */
683         T_CAMERA =        1 << 4,
684         /** Transforming the 3D cursor. */
685         T_CURSOR =        1 << 5,
686         /** Transform points, having no rotation/scale. */
687         T_POINTS =        1 << 6,
688         /**
689          * Apply matrix #TransDataContainer.matrix, this avoids having to have duplicate check all over
690          * that happen to apply to spesiifc modes (edit & pose for eg). */
691         T_LOCAL_MATRIX =  1 << 7,
692
693     /** restrictions flags */
694         T_NO_CONSTRAINT =     1 << 8,
695         T_NULL_ONE =          1 << 9,
696         T_NO_ZERO =           1 << 10,
697         T_ALL_RESTRICTIONS =  T_NO_CONSTRAINT | T_NULL_ONE | T_NO_ZERO,
698
699         T_PROP_EDIT =         1 << 11,
700         T_PROP_CONNECTED =    1 << 12,
701         T_PROP_PROJECTED =    1 << 13,
702         T_PROP_EDIT_ALL =     T_PROP_EDIT | T_PROP_CONNECTED | T_PROP_PROJECTED,
703
704         T_V3D_ALIGN =         1 << 14,
705     /** For 2d views like uv or fcurve. */
706         T_2D_EDIT =           1 << 15,
707         T_CLIP_UV =           1 << 16,
708
709     /** Auto-ik is on. */
710         T_AUTOIK =            1 << 18,
711
712         /** Don't use mirror even if the data-block option is set. */
713         T_NO_MIRROR =         1 << 19,
714
715         T_AUTOVALUES =        1 << 20,
716
717     /** To specify if we save back settings at the end. */
718         T_MODAL =             1 << 21,
719
720     /** No retopo. */
721         T_NO_PROJECT =        1 << 22,
722
723         T_RELEASE_CONFIRM =   1 << 23,
724
725     /** Alternative transformation. used to add offset to tracking markers. */
726         T_ALT_TRANSFORM =     1 << 24,
727
728     /** #TransInfo.center has been set, don't change it. */
729         T_OVERRIDE_CENTER =   1 << 25,
730
731         T_MODAL_CURSOR_SET =  1 << 26,
732
733         T_CLNOR_REBUILD =     1 << 27,
734 };
735
736 /** #TransInfo.modifiers */
737 enum {
738         MOD_CONSTRAINT_SELECT =   1 << 0,
739         MOD_PRECISION =           1 << 1,
740         MOD_SNAP =                1 << 2,
741         MOD_SNAP_INVERT =         1 << 3,
742         MOD_CONSTRAINT_PLANE =    1 << 4,
743 };
744
745 /* use node center for transform instead of upper-left corner.
746  * disabled since it makes absolute snapping not work so nicely
747  */
748 // #define USE_NODE_CENTER
749
750
751 /* ******************************************************************************** */
752
753 /* transinfo->helpline */
754 enum {
755         HLP_NONE =        0,
756         HLP_SPRING =      1,
757         HLP_ANGLE =       2,
758         HLP_HARROW =      3,
759         HLP_VARROW =      4,
760         HLP_CARROW =      5,
761         HLP_TRACKBALL =   6,
762 };
763
764 /* transinfo->con->mode */
765 enum {
766         CON_APPLY =       1 << 0,
767         CON_AXIS0 =       1 << 1,
768         CON_AXIS1 =       1 << 2,
769         CON_AXIS2 =       1 << 3,
770         CON_SELECT =      1 << 4,
771         /** Does not reorient vector to face viewport when on. */
772         CON_NOFLIP =      1 << 5,
773         CON_USER =        1 << 6,
774 };
775
776 /* transdata->flag */
777 enum {
778         TD_SELECTED =         1 << 0,
779         TD_NOACTION =         1 << 2,
780         TD_USEQUAT =          1 << 3,
781         TD_NOTCONNECTED =     1 << 4,
782         /** Used for scaling of #MetaElem.rad */
783         TD_SINGLESIZE =       1 << 5,
784         /** Scale relative to individual element center */
785         TD_INDIVIDUAL_SCALE = 1 << 8,
786         TD_NOCENTER =         1 << 9,
787         /** #TransData.ext abused for particle key timing. */
788         TD_NO_EXT =           1 << 10,
789         /** don't transform this data */
790         TD_SKIP =             1 << 11,
791         /** if this is a bez triple, we need to restore the handles,
792          * if this is set #TransData.hdata needs freeing */
793         TD_BEZTRIPLE =        1 << 12,
794         /** when this is set, don't apply translation changes to this element */
795         TD_NO_LOC =           1 << 13,
796         /** for Graph Editor autosnap, indicates that point should not undergo autosnapping */
797         TD_NOTIMESNAP =       1 << 14,
798         /** for Graph Editor - curves that can only have int-values need their keyframes tagged with this */
799         TD_INTVALUES =        1 << 15,
800         /** For editmode mirror, clamp to x = 0 */
801         TD_MIRROR_EDGE =      1 << 16,
802         /** For fcurve handles, move them along with their keyframes */
803         TD_MOVEHANDLE1 =      1 << 17,
804         TD_MOVEHANDLE2 =      1 << 18,
805         /** Exceptional case with pose bone rotating when a parent bone has 'Local Location'
806          * option enabled and rotating also transforms it. */
807         TD_PBONE_LOCAL_MTX_P = 1 << 19,
808         /** Same as above but for a child bone. */
809         TD_PBONE_LOCAL_MTX_C = 1 << 20,
810 };
811
812 /* transsnap->status */
813 enum {
814         SNAP_FORCED =     1 << 0,
815         TARGET_INIT =     1 << 1,
816         POINT_INIT =      1 << 2,
817         MULTI_POINTS =    1 << 3,
818 };
819
820 /* Hard min/max for proportional size. */
821 #define T_PROP_SIZE_MIN 1e-6f
822 #define T_PROP_SIZE_MAX 1e12f
823
824 bool initTransform(struct bContext *C, struct TransInfo *t, struct wmOperator *op, const struct wmEvent *event, int mode);
825 void saveTransform(struct bContext *C, struct TransInfo *t, struct wmOperator *op);
826 int  transformEvent(TransInfo *t, const struct wmEvent *event);
827 void transformApply(struct bContext *C, TransInfo *t);
828 int  transformEnd(struct bContext *C, TransInfo *t);
829
830 void setTransformViewMatrices(TransInfo *t);
831 void setTransformViewAspect(TransInfo *t, float r_aspect[3]);
832 void convertViewVec(TransInfo *t, float r_vec[3], double dx, double dy);
833 void projectIntViewEx(TransInfo *t, const float vec[3], int adr[2], const eV3DProjTest flag);
834 void projectIntView(TransInfo *t, const float vec[3], int adr[2]);
835 void projectFloatViewEx(TransInfo *t, const float vec[3], float adr[2], const eV3DProjTest flag);
836 void projectFloatView(TransInfo *t, const float vec[3], float adr[2]);
837
838 void applyAspectRatio(TransInfo *t, float vec[2]);
839 void removeAspectRatio(TransInfo *t, float vec[2]);
840
841 void drawPropCircle(const struct bContext *C, TransInfo *t);
842
843 struct wmKeyMap *transform_modal_keymap(struct wmKeyConfig *keyconf);
844
845
846 /*********************** transform_conversions.c ********** */
847 struct ListBase;
848
849 void flushTransIntFrameActionData(TransInfo *t);
850 void flushTransGraphData(TransInfo *t);
851 void remake_graph_transdata(TransInfo *t, struct ListBase *anim_data);
852 void flushTransUVs(TransInfo *t);
853 void flushTransParticles(TransInfo *t);
854 bool clipUVTransform(TransInfo *t, float vec[2], const bool resize);
855 void clipUVData(TransInfo *t);
856 void flushTransNodes(TransInfo *t);
857 void flushTransSeq(TransInfo *t);
858 void flushTransTracking(TransInfo *t);
859 void flushTransMasking(TransInfo *t);
860 void flushTransPaintCurve(TransInfo *t);
861 void restoreBones(TransDataContainer *tc);
862
863 /*********************** transform_gizmo.c ********** */
864
865 #define GIZMO_AXIS_LINE_WIDTH 2.0f
866
867 /* return 0 when no gimbal for selection */
868 bool gimbal_axis(struct Object *ob, float gmat[3][3]);
869 void drawDial3d(const TransInfo *t);
870
871 /*********************** TransData Creation and General Handling *********** */
872 void createTransData(struct bContext *C, TransInfo *t);
873 void sort_trans_data_dist(TransInfo *t);
874 void special_aftertrans_update(struct bContext *C, TransInfo *t);
875 int  special_transform_moving(TransInfo *t);
876
877 void transform_autoik_update(TransInfo *t, short mode);
878 bool transdata_check_local_islands(TransInfo *t, short around);
879
880 int count_set_pose_transflags(struct Object *ob, const int mode, const short around, bool has_translate_rotate[2]);
881
882 /* Auto-keyframe applied after transform, returns true if motion paths need to be updated. */
883 void autokeyframe_object(
884         struct bContext *C, struct Scene *scene, struct ViewLayer *view_layer, struct Object *ob, int tmode);
885 void autokeyframe_pose(
886         struct bContext *C, struct Scene *scene, struct Object *ob, int tmode, short targetless_ik);
887
888 /* Test if we need to update motion paths for a given object. */
889 bool motionpath_need_update_object(struct Scene *scene, struct Object *ob);
890 bool motionpath_need_update_pose(struct Scene *scene, struct Object *ob);
891
892 /*********************** Constraints *****************************/
893
894 void drawConstraint(TransInfo *t);
895
896 void getConstraintMatrix(TransInfo *t);
897 void setConstraint(TransInfo *t, float space[3][3], int mode, const char text[]);
898 void setAxisMatrixConstraint(TransInfo *t, int mode, const char text[]);
899 void setLocalConstraint(TransInfo *t, int mode, const char text[]);
900 void setUserConstraint(TransInfo *t, short orientation, int mode, const char text[]);
901
902 void constraintNumInput(TransInfo *t, float vec[3]);
903
904 bool isLockConstraint(TransInfo *t);
905 int  getConstraintSpaceDimension(TransInfo *t);
906 char constraintModeToChar(TransInfo *t);
907
908 void startConstraint(TransInfo *t);
909 void stopConstraint(TransInfo *t);
910
911 void initSelectConstraint(TransInfo *t, float mtx[3][3]);
912 void selectConstraint(TransInfo *t);
913 void postSelectConstraint(TransInfo *t);
914
915 void setNearestAxis(TransInfo *t);
916
917 /*********************** Snapping ********************************/
918
919 typedef enum {
920         NO_GEARS        = 0,
921         BIG_GEARS       = 1,
922         SMALL_GEARS     = 2,
923 } GearsType;
924
925 bool transformModeUseSnap(const TransInfo *t);
926
927 void snapGridIncrement(TransInfo *t, float *val);
928 void snapGridIncrementAction(TransInfo *t, float *val, GearsType action);
929
930 void snapSequenceBounds(TransInfo *t, const int mval[2]);
931
932 bool activeSnap(const TransInfo *t);
933 bool validSnap(const TransInfo *t);
934
935 void initSnapping(struct TransInfo *t, struct wmOperator *op);
936 void freeSnapping(struct TransInfo *t);
937 void applyProject(TransInfo *t);
938 void applyGridAbsolute(TransInfo *t);
939 void applySnapping(TransInfo *t, float *vec);
940 void resetSnapping(TransInfo *t);
941 eRedrawFlag handleSnapping(TransInfo *t, const struct wmEvent *event);
942 void drawSnapping(const struct bContext *C, TransInfo *t);
943 bool usingSnappingNormal(const TransInfo *t);
944 bool validSnappingNormal(const TransInfo *t);
945
946 void getSnapPoint(const TransInfo *t, float vec[3]);
947 void addSnapPoint(TransInfo *t);
948 eRedrawFlag updateSelectedSnapPoint(TransInfo *t);
949 void removeSnapPoint(TransInfo *t);
950
951 /********************** Mouse Input ******************************/
952
953 typedef enum {
954         INPUT_NONE,
955         INPUT_VECTOR,
956         INPUT_SPRING,
957         INPUT_SPRING_FLIP,
958         INPUT_SPRING_DELTA,
959         INPUT_ANGLE,
960         INPUT_ANGLE_SPRING,
961         INPUT_TRACKBALL,
962         INPUT_HORIZONTAL_RATIO,
963         INPUT_HORIZONTAL_ABSOLUTE,
964         INPUT_VERTICAL_RATIO,
965         INPUT_VERTICAL_ABSOLUTE,
966         INPUT_CUSTOM_RATIO,
967         INPUT_CUSTOM_RATIO_FLIP,
968 } MouseInputMode;
969
970 void initMouseInput(TransInfo *t, MouseInput *mi, const float center[2], const int mval[2], const bool precision);
971 void initMouseInputMode(TransInfo *t, MouseInput *mi, MouseInputMode mode);
972 eRedrawFlag handleMouseInput(struct TransInfo *t, struct MouseInput *mi, const struct wmEvent *event);
973 void applyMouseInput(struct TransInfo *t, struct MouseInput *mi, const int mval[2], float output[3]);
974
975 void setCustomPoints(TransInfo *t, MouseInput *mi, const int start[2], const int end[2]);
976 void setCustomPointsFromDirection(TransInfo *t, MouseInput *mi, const float dir[2]);
977 void setInputPostFct(MouseInput *mi, void       (*post)(struct TransInfo *t, float values[3]));
978
979 /*********************** Generics ********************************/
980
981 void initTransDataContainers_FromObjectData(TransInfo *t, struct Object *obact, struct Object **objects, uint objects_len);
982 void initTransInfo(struct bContext *C, TransInfo *t, struct wmOperator *op, const struct wmEvent *event);
983 void freeTransCustomDataForMode(TransInfo *t);
984 void postTrans(struct bContext *C, TransInfo *t);
985 void resetTransModal(TransInfo *t);
986 void resetTransRestrictions(TransInfo *t);
987
988 void drawLine(TransInfo *t, const float center[3], const float dir[3], char axis, short options);
989
990 /* DRAWLINE options flags */
991 #define DRAWLIGHT       1
992
993 void applyTransObjects(TransInfo *t);
994 void restoreTransObjects(TransInfo *t);
995 void recalcData(TransInfo *t);
996
997 void calculateCenter2D(TransInfo *t);
998 void calculateCenterLocal(TransInfo *t, const float center_global[3]);
999
1000 const TransCenterData *transformCenter_from_type(TransInfo *t, int around);
1001 void calculateCenter(TransInfo *t);
1002
1003 /* API functions for getting center points */
1004 void calculateCenterBound(TransInfo *t, float r_center[3]);
1005 void calculateCenterMedian(TransInfo *t, float r_center[3]);
1006 void calculateCenterCursor(TransInfo *t, float r_center[3]);
1007 void calculateCenterCursor2D(TransInfo *t, float r_center[2]);
1008 void calculateCenterCursorGraph2D(TransInfo *t, float r_center[2]);
1009 bool calculateCenterActive(TransInfo *t, bool select_only, float r_center[3]);
1010
1011 void calculatePropRatio(TransInfo *t);
1012
1013 void getViewVector(const TransInfo *t, const float coord[3], float vec[3]);
1014
1015 void transform_data_ext_rotate(TransData *td, float mat[3][3], bool use_drot);
1016
1017 /*********************** Transform Orientations ******************************/
1018
1019 void initTransformOrientation(struct bContext *C, TransInfo *t);
1020
1021 /* Those two fill in mat and return non-zero on success */
1022 bool createSpaceNormal(float mat[3][3], const float normal[3]);
1023 bool createSpaceNormalTangent(float mat[3][3], const float normal[3], const float tangent[3]);
1024
1025 struct TransformOrientation *addMatrixSpace(struct bContext *C, float mat[3][3],
1026                                             const char *name, const bool overwrite);
1027 bool applyTransformOrientation(const struct TransformOrientation *ts, float r_mat[3][3], char r_name[64]);
1028
1029 enum {
1030         ORIENTATION_NONE =    0,
1031         ORIENTATION_NORMAL =  1,
1032         ORIENTATION_VERT =    2,
1033         ORIENTATION_EDGE =    3,
1034         ORIENTATION_FACE =    4,
1035 };
1036 #define ORIENTATION_USE_PLANE(ty) \
1037         ELEM(ty, ORIENTATION_NORMAL, ORIENTATION_EDGE, ORIENTATION_FACE)
1038
1039 int getTransformOrientation_ex(const struct bContext *C, float normal[3], float plane[3], const short around);
1040 int getTransformOrientation(const struct bContext *C, float normal[3], float plane[3]);
1041
1042 void freeCustomNormalArray(TransInfo *t, TransDataContainer *tc, TransCustomData *custom_data);
1043
1044 void freeEdgeSlideTempFaces(EdgeSlideData *sld);
1045 void freeEdgeSlideVerts(TransInfo *t, TransDataContainer *tc, TransCustomData *custom_data);
1046 void projectEdgeSlideData(TransInfo *t, bool is_final);
1047
1048 void freeVertSlideTempFaces(VertSlideData *sld);
1049 void freeVertSlideVerts(TransInfo *t, TransDataContainer *tc, TransCustomData *custom_data);
1050 void projectVertSlideData(TransInfo *t, bool is_final);
1051
1052
1053 /* TODO. transform_query.c */
1054 bool checkUseAxisMatrix(TransInfo *t);
1055
1056 #define TRANSFORM_SNAP_MAX_PX 100.0f
1057 #define TRANSFORM_DIST_INVALID -FLT_MAX
1058
1059 /* Temp macros. */
1060
1061 #define TRANS_DATA_CONTAINER_FIRST_OK(t) (&(t)->data_container[0])
1062 /* For cases we _know_ there is only one handle. */
1063 #define TRANS_DATA_CONTAINER_FIRST_SINGLE(t) (BLI_assert((t)->data_container_len == 1), (&(t)->data_container[0]))
1064
1065 #define FOREACH_TRANS_DATA_CONTAINER(t, th) \
1066         for (TransDataContainer *tc = t->data_container, *tc_end = t->data_container + t->data_container_len; \
1067              th != tc_end; \
1068              th++)
1069
1070 #define FOREACH_TRANS_DATA_CONTAINER_INDEX(t, th, i) \
1071         for (TransDataContainer *tc = ((i = 0), t->data_container), *tc_end = t->data_container + t->data_container_len; \
1072              th != tc_end; \
1073              th++, i++)
1074
1075 #endif