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