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