Calculate epsilon values for interp_weights_poly to improve accuracy
[blender.git] / source / blender / makesdna / DNA_gpencil_types.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) 2008, Blender Foundation.
17  * This is a new part of Blender
18  */
19
20 /** \file
21  * \ingroup DNA
22  */
23
24 #ifndef __DNA_GPENCIL_TYPES_H__
25 #define __DNA_GPENCIL_TYPES_H__
26
27 #include "DNA_ID.h"
28 #include "DNA_brush_types.h"
29 #include "DNA_listBase.h"
30
31 struct AnimData;
32 struct MDeformVert;
33
34 #define GP_DEFAULT_PIX_FACTOR 1.0f
35 #define GP_DEFAULT_GRID_LINES 4
36 #define GP_MAX_INPUT_SAMPLES 10
37
38 #define GP_MATERIAL_BUFFER_LEN 256
39
40 /* ***************************************** */
41 /* GP Stroke Points */
42
43 /* 'Control Point' data for primitives and curves */
44 typedef struct bGPDcontrolpoint {
45   /** X and y coordinates of control point. */
46   float x, y, z;
47   /** Point color. */
48   float color[4];
49   /** Radius. */
50   int size;
51 } bGPDcontrolpoint;
52
53 typedef struct bGPDspoint_Runtime {
54   /** Original point (used to dereference evaluated data) */
55   struct bGPDspoint *pt_orig;
56   /** Original index array position */
57   int idx_orig;
58   char _pad0[4];
59 } bGPDspoint_Runtime;
60
61 /* Grease-Pencil Annotations - 'Stroke Point'
62  * -> Coordinates may either be 2d or 3d depending on settings at the time
63  * -> Coordinates of point on stroke, in proportions of window size
64  *    This assumes that the bottom-left corner is (0,0)
65  */
66 typedef struct bGPDspoint {
67   /** Co-ordinates of point (usually 2d, but can be 3d as well). */
68   float x, y, z;
69   /** Pressure of input device (from 0 to 1) at this point. */
70   float pressure;
71   /** Color strength (used for alpha factor). */
72   float strength;
73   /** Seconds since start of stroke. */
74   float time;
75   /** Additional options. */
76   int flag;
77
78   /** Factor of uv along the stroke. */
79   float uv_fac;
80   /** Uv rotation for dot mode. */
81   float uv_rot;
82   /** Uv for fill mode */
83   float uv_fill[2];
84
85   /** Vertex Color RGBA (A=mix factor). */
86   float vert_color[4];
87
88   /** Runtime data */
89   char _pad2[4];
90
91   bGPDspoint_Runtime runtime;
92 } bGPDspoint;
93
94 /* bGPDspoint->flag */
95 typedef enum eGPDspoint_Flag {
96   /* stroke point is selected (for editing) */
97   GP_SPOINT_SELECT = (1 << 0),
98
99   /* stroke point is tagged (for some editing operation) */
100   GP_SPOINT_TAG = (1 << 1),
101   /* stroke point is temp tagged (for some editing operation) */
102   GP_SPOINT_TEMP_TAG = (1 << 2),
103 } eGPSPoint_Flag;
104
105 /* ***************************************** */
106 /* GP Fill - Triangle Tessellation Data */
107
108 /* Grease-Pencil Annotations - 'Triangle'
109  * -> A triangle contains the index of three vertices for filling the stroke
110  *    This is only used if high quality fill is enabled
111  */
112 typedef struct bGPDtriangle {
113   /* indices for tessellated triangle used for GP Fill */
114   unsigned int verts[3];
115 } bGPDtriangle;
116
117 /* ***************************************** */
118
119 /* ***************************************** */
120 /* GP Palettes (Deprecated - 2.78 - 2.79 only) */
121
122 /* color of palettes */
123 typedef struct bGPDpalettecolor {
124   struct bGPDpalettecolor *next, *prev;
125   /** Color name. Must be unique. */
126   char info[64];
127   float color[4];
128   /** Color that should be used for drawing "fills" for strokes. */
129   float fill[4];
130   /** Settings for palette color. */
131   short flag;
132   /** Padding for compiler alignment error. */
133   char _pad[6];
134 } bGPDpalettecolor;
135
136 /* bGPDpalettecolor->flag */
137 typedef enum eGPDpalettecolor_Flag {
138   /* color is active */
139   /* PC_COLOR_ACTIVE = (1 << 0), */ /* UNUSED */
140   /* don't display color */
141   PC_COLOR_HIDE = (1 << 1),
142   /* protected from further editing */
143   PC_COLOR_LOCKED = (1 << 2),
144   /* do onion skinning */
145   PC_COLOR_ONIONSKIN = (1 << 3),
146   /* "volumetric" strokes */
147   PC_COLOR_VOLUMETRIC = (1 << 4),
148 } eGPDpalettecolor_Flag;
149
150 /* palette of colors */
151 typedef struct bGPDpalette {
152   struct bGPDpalette *next, *prev;
153
154   /** Pointer to individual colors. */
155   ListBase colors;
156   /** Palette name. Must be unique. */
157   char info[64];
158
159   short flag;
160   char _pad[6];
161 } bGPDpalette;
162
163 /* bGPDpalette->flag */
164 typedef enum eGPDpalette_Flag {
165   /* palette is active */
166   PL_PALETTE_ACTIVE = (1 << 0),
167 } eGPDpalette_Flag;
168
169 /* ***************************************** */
170 /* GP Strokes */
171
172 /* Runtime temp data for bGPDstroke */
173 typedef struct bGPDstroke_Runtime {
174   /** temporary layer name only used during copy/paste to put the stroke in the original layer */
175   char tmp_layerinfo[128];
176
177   /** Runtime falloff factor (only for transform). */
178   float multi_frame_falloff;
179
180   /** Vertex offset in the vbo where this stroke starts. */
181   int stroke_start;
182   /** Triangle offset in the ibo where this fill starts. */
183   int fill_start;
184   int _pad[1];
185
186   /** Original stroke (used to dereference evaluated data) */
187   struct bGPDstroke *gps_orig;
188   void *_pad2;
189 } bGPDstroke_Runtime;
190
191 /* Grease-Pencil Annotations - 'Stroke'
192  * -> A stroke represents a (simplified version) of the curve
193  *    drawn by the user in one 'mouse-down'->'mouse-up' operation
194  */
195 typedef struct bGPDstroke {
196   struct bGPDstroke *next, *prev;
197
198   /** Array of data-points for stroke. */
199   bGPDspoint *points;
200   /** Tessellated triangles for GP Fill. */
201   bGPDtriangle *triangles;
202   /** Number of data-points in array. */
203   int totpoints;
204   /** Number of triangles in array. */
205   int tot_triangles;
206
207   /** Thickness of stroke. */
208   short thickness;
209   /** Various settings about this stroke. */
210   short flag, _pad[2];
211
212   /** Init time of stroke. */
213   double inittime;
214
215   /** Color name. */
216   char colorname[128] DNA_DEPRECATED;
217
218   /** Material index. */
219   int mat_nr;
220   /** Caps mode for each stroke extreme */
221   short caps[2];
222
223   /** gradient control along y for color */
224   float hardeness;
225   /** factor xy of shape for dots gradients */
226   float aspect_ratio[2];
227
228   /** Factor of opacity for Fill color (used by opacity modifier). */
229   float fill_opacity_fac;
230
231   /** Min of the bound box used to speedup painting operators. */
232   float boundbox_min[3];
233   /** Max of the bound box used to speedup painting operators. */
234   float boundbox_max[3];
235
236   /** UV rotation */
237   float uv_rotation;
238   /** UV translation (X and Y axis) */
239   float uv_translation[2];
240   float uv_scale;
241
242   /** Vertex weight data. */
243   struct MDeformVert *dvert;
244   void *_pad3;
245
246   /** Vertex Color for Fill (one for all stroke, A=mix factor). */
247   float vert_color_fill[4];
248
249   bGPDstroke_Runtime runtime;
250 } bGPDstroke;
251
252 /* bGPDstroke->flag */
253 typedef enum eGPDstroke_Flag {
254   /* stroke is in 3d-space */
255   GP_STROKE_3DSPACE = (1 << 0),
256   /* stroke is in 2d-space */
257   GP_STROKE_2DSPACE = (1 << 1),
258   /* stroke is in 2d-space (but with special 'image' scaling) */
259   GP_STROKE_2DIMAGE = (1 << 2),
260   /* stroke is selected */
261   GP_STROKE_SELECT = (1 << 3),
262   /* Flag used to indicate that stroke is closed and draw edge between last and first point */
263   GP_STROKE_CYCLIC = (1 << 7),
264   /* Flag used to indicate that stroke is used for fill close and must use
265    * fill color for stroke and no fill area */
266   GP_STROKE_NOFILL = (1 << 8),
267   /* only for use with stroke-buffer (while drawing arrows) */
268   GP_STROKE_USE_ARROW_START = (1 << 12),
269   /* only for use with stroke-buffer (while drawing arrows) */
270   GP_STROKE_USE_ARROW_END = (1 << 13),
271   /* Tag for update geometry */
272   GP_STROKE_TAG = (1 << 14),
273   /* only for use with stroke-buffer (while drawing eraser) */
274   GP_STROKE_ERASER = (1 << 15),
275 } eGPDstroke_Flag;
276
277 /* bGPDstroke->caps */
278 typedef enum eGPDstroke_Caps {
279   /* type of extreme */
280   GP_STROKE_CAP_ROUND = 0,
281   GP_STROKE_CAP_FLAT = 1,
282
283   /* Keeo last. */
284   GP_STROKE_CAP_MAX,
285 } GPDstroke_Caps;
286
287 /* Arrows ----------------------- */
288
289 /* bGPDataRuntime.arrowstyle */
290 typedef enum eGPDstroke_Arrowstyle {
291   GP_STROKE_ARROWSTYLE_NONE = 0,
292   GP_STROKE_ARROWSTYLE_SEGMENT = 2,
293   GP_STROKE_ARROWSTYLE_OPEN = 3,
294   GP_STROKE_ARROWSTYLE_CLOSED = 4,
295   GP_STROKE_ARROWSTYLE_SQUARE = 6,
296 } eGPDstroke_Arrowstyle;
297
298 /* ***************************************** */
299 /* GP Frame */
300
301 /* Runtime temp data for bGPDframe */
302 typedef struct bGPDframe_Runtime {
303   /** Index of this frame in the listbase of frames. */
304   int frameid;
305   /** Onion offset from active frame. 0 if not onion. INT_MAX to bypass frame. */
306   int onion_id;
307
308   /** Original frame (used to dereference evaluated data) */
309   struct bGPDframe *gpf_orig;
310 } bGPDframe_Runtime;
311
312 /* Grease-Pencil Annotations - 'Frame'
313  * -> Acts as storage for the 'image' formed by strokes
314  */
315 typedef struct bGPDframe {
316   struct bGPDframe *next, *prev;
317
318   /** List of the simplified 'strokes' that make up the frame's data. */
319   ListBase strokes;
320
321   /** Frame number of this frame. */
322   int framenum;
323
324   /** Temp settings. */
325   short flag;
326   /** Keyframe type (eBezTriple_KeyframeType). */
327   short key_type;
328
329   bGPDframe_Runtime runtime;
330 } bGPDframe;
331
332 /* bGPDframe->flag */
333 typedef enum eGPDframe_Flag {
334   /* frame is being painted on */
335   GP_FRAME_PAINT = (1 << 0),
336   /* for editing in Action Editor */
337   GP_FRAME_SELECT = (1 << 1),
338 } eGPDframe_Flag;
339
340 /* ***************************************** */
341 /* GP Layer */
342
343 /* List of masking layers. */
344 typedef struct bGPDlayer_Mask {
345   struct bGPDlayer_Mask *next, *prev;
346   char name[128];
347   short flag;
348   /** Index for sorting. Only valid while sorting algorithm is running. */
349   short sort_index;
350   char _pad[4];
351 } bGPDlayer_Mask;
352
353 /* bGPDlayer_Mask->flag */
354 typedef enum ebGPDlayer_Mask_Flag {
355   /* Mask is hidden. */
356   GP_MASK_HIDE = (1 << 0),
357   /* Mask is inverted. */
358   GP_MASK_INVERT = (1 << 1),
359 } ebGPDlayer_Mask_Flag;
360
361 /* Runtime temp data for bGPDlayer */
362 typedef struct bGPDlayer_Runtime {
363   /** Id for dynamic icon used to show annotation color preview for layer. */
364   int icon_id;
365   char _pad[4];
366   /** Original layer (used to dereference evaluated data) */
367   struct bGPDlayer *gpl_orig;
368 } bGPDlayer_Runtime;
369
370 /* Grease-Pencil Annotations - 'Layer' */
371 typedef struct bGPDlayer {
372   struct bGPDlayer *next, *prev;
373
374   /** List of annotations to display for frames (bGPDframe list). */
375   ListBase frames;
376   /** Active frame (should be the frame that is currently being displayed). */
377   bGPDframe *actframe;
378
379   /** Settings for layer. */
380   short flag;
381   /** Per-layer onion-skinning flags (eGPDlayer_OnionFlag). */
382   short onion_flag;
383
384   /** Color for strokes in layers. Used for annotations, and for ruler
385    * (which uses GPencil internally). */
386   float color[4];
387   /** Fill color for strokes in layers. Not used anymore (was only for). */
388   float fill[4];
389
390   /** Name/reference info for this layer (i.e. "director's comments, 12/.3")
391    * needs to be kept unique, as it's used as the layer identifier */
392   char info[128];
393
394   /** Thickness to apply to strokes (Annotations). */
395   short thickness;
396   /** Used to filter groups of layers in modifiers. */
397   short pass_index;
398
399   /** Parent object. */
400   struct Object *parent;
401   /** Inverse matrix (only used if parented). */
402   float inverse[4][4];
403   /** String describing subobject info, MAX_ID_NAME-2. */
404   char parsubstr[64];
405   short partype;
406
407   /** Thickness adjustment. */
408   short line_change;
409   /** Color used to tint layer, alpha value is used as factor. */
410   float tintcolor[4];
411   /** Opacity of the layer. */
412   float opacity;
413   /** Name of the layer used to filter render output. */
414   char viewlayername[64];
415
416   /** Blend modes. */
417   int blend_mode;
418   /** Vertex Paint opacity by Layer. */
419   float vertex_paint_opacity;
420
421   /* annotation onion skin */
422   /**
423    * Ghosts Before: max number of ghost frames to show between
424    * active frame and the one before it (0 = only the ghost itself).
425    */
426   short gstep;
427   /**
428    * Ghosts After: max number of ghost frames to show after
429    * active frame and the following it    (0 = only the ghost itself).
430    */
431   short gstep_next;
432
433   /** Color for ghosts before the active frame. */
434   float gcolor_prev[3];
435   /** Color for ghosts after the active frame. */
436   float gcolor_next[3];
437   char _pad1[4];
438
439   /** Mask list (bGPDlayer_Mask). */
440   ListBase mask_layers;
441   /** Current Mask index (noted base 1). */
442   int act_mask;
443   char _pad2[4];
444
445   bGPDlayer_Runtime runtime;
446 } bGPDlayer;
447
448 /* bGPDlayer->flag */
449 typedef enum eGPDlayer_Flag {
450   /* don't display layer */
451   GP_LAYER_HIDE = (1 << 0),
452   /* protected from further editing */
453   GP_LAYER_LOCKED = (1 << 1),
454   /* layer is 'active' layer being edited */
455   GP_LAYER_ACTIVE = (1 << 2),
456   /* draw points of stroke for debugging purposes */
457   GP_LAYER_DRAWDEBUG = (1 << 3),
458   /* Flag used to display in Paint mode only layers with keyframe */
459   GP_LAYER_SOLO_MODE = (1 << 4),
460   /* for editing in Action Editor */
461   GP_LAYER_SELECT = (1 << 5),
462   /* current frame for layer can't be changed */
463   GP_LAYER_FRAMELOCK = (1 << 6),
464   /* don't render xray (which is default) */
465   GP_LAYER_NO_XRAY = (1 << 7),
466   /* "volumetric" strokes */
467   GP_LAYER_VOLUMETRIC = (1 << 10),
468   /* Use Scene lights */
469   GP_LAYER_USE_LIGHTS = (1 << 11),
470   /* Unlock color */
471   GP_LAYER_UNLOCK_COLOR = (1 << 12),
472   /* Mask Layer */
473   GP_LAYER_USE_MASK = (1 << 13), /*TODO: DEPRECATED */
474   /* Ruler Layer */
475   GP_LAYER_IS_RULER = (1 << 14),
476 } eGPDlayer_Flag;
477
478 /* bGPDlayer->onion_flag */
479 typedef enum eGPDlayer_OnionFlag {
480   /* do onion skinning */
481   GP_LAYER_ONIONSKIN = (1 << 0),
482 } eGPDlayer_OnionFlag;
483
484 /* layer blend_mode */
485 typedef enum eGPLayerBlendModes {
486   eGplBlendMode_Regular = 0,
487   eGplBlendMode_HardLight = 1,
488   eGplBlendMode_Add = 2,
489   eGplBlendMode_Subtract = 3,
490   eGplBlendMode_Multiply = 4,
491   eGplBlendMode_Divide = 5,
492 } eGPLayerBlendModes;
493
494 /* ***************************************** */
495 /* GP Datablock */
496
497 /* Runtime temp data for bGPdata */
498 typedef struct bGPdata_Runtime {
499   /** Stroke buffer. */
500   void *sbuffer;
501   /** Temp batches cleared after drawing. */
502   struct GPUBatch *sbuffer_stroke_batch;
503   struct GPUBatch *sbuffer_fill_batch;
504   /** Temp stroke used for drawing. */
505   struct bGPDstroke *sbuffer_gps;
506
507   char _pad[2];
508   /** Material index of the stroke. */
509   short matid;
510
511   /* Stroke Buffer data (only used during paint-session)
512    * - buffer must be initialized before use, but freed after
513    *   whole paint operation is over
514    */
515   /** Flags for stroke that cache represents. */
516   short sbuffer_sflag;
517   char _pad1[2];
518   /** Number of elements currently used in cache. */
519   int sbuffer_used;
520   /** Number of total elements available in cache. */
521   int sbuffer_size;
522
523   /** Vertex Color applied to Fill (while drawing). */
524   float vert_color_fill[4];
525
526   /** Arrow points for stroke corners **/
527   float arrow_start[8];
528   float arrow_end[8];
529   /* Arrow style for each corner */
530   int arrow_start_style;
531   int arrow_end_style;
532
533   /** Number of control-points for stroke. */
534   int tot_cp_points;
535   char _pad2[4];
536   /** Array of control-points for stroke. */
537   bGPDcontrolpoint *cp_points;
538   /** Brush pointer */
539   Brush *sbuffer_brush;
540   struct GpencilBatchCache *gpencil_cache;
541 } bGPdata_Runtime;
542
543 /* grid configuration */
544 typedef struct bGPgrid {
545   float color[3];
546   float scale[2];
547   float offset[2];
548   char _pad1[4];
549
550   int lines;
551   char _pad[4];
552 } bGPgrid;
553
554 /* Grease-Pencil Annotations - 'DataBlock' */
555 typedef struct bGPdata {
556   /** Grease Pencil data is a data-block. */
557   ID id;
558   /** Animation data - for animating draw settings. */
559   struct AnimData *adt;
560
561   /* Grease-Pencil data */
562   /** bGPDlayer. */
563   ListBase layers;
564   /** Settings for this data-block. */
565   int flag;
566   char _pad1[4];
567
568   /* Palettes */
569   /** List of bGPDpalette's   - Deprecated (2.78 - 2.79 only). */
570   ListBase palettes DNA_DEPRECATED;
571
572   /* 3D Viewport/Appearance Settings */
573   /** Factor to define pixel size conversion. */
574   float pixfactor;
575   /** Color for edit line. */
576   float line_color[4];
577
578   /* Onion skinning */
579   /** Onion alpha factor change. */
580   float onion_factor;
581   /** Onion skinning range (eGP_OnionModes). */
582   int onion_mode;
583   /** Onion skinning flags (eGPD_OnionFlag). */
584   int onion_flag;
585   /**
586    * Ghosts Before: max number of ghost frames to show between
587    * active frame and the one before it (0 = only the ghost itself).
588    */
589   short gstep;
590   /** Ghosts After: max number of ghost frames to show after
591    * active frame and the following it (0 = only the ghost itself).
592    */
593   short gstep_next;
594
595   /** Optional color for ghosts before the active frame. */
596   float gcolor_prev[3];
597   /** Optional color for ghosts after the active frame. */
598   float gcolor_next[3];
599
600   /** Offset for drawing over surfaces to keep strokes on top. */
601   float zdepth_offset;
602   /** Materials array. */
603   struct Material **mat;
604   /** Total materials. */
605   short totcol;
606
607   /* stats */
608   short totlayer;
609   short totframe;
610   char _pad2[6];
611   int totstroke;
612   int totpoint;
613
614   /** Draw mode for strokes (eGP_DrawMode). */
615   short draw_mode;
616   /** Keyframe type for onion filter  (eBezTriple_KeyframeType plus All option) */
617   short onion_keytype;
618
619   bGPgrid grid;
620
621   bGPdata_Runtime runtime;
622 } bGPdata;
623
624 /* bGPdata->flag */
625 /* NOTE: A few flags have been deprecated since early 2.5,
626  *       since they have been made redundant by interaction
627  *       changes made during the porting process.
628  */
629 typedef enum eGPdata_Flag {
630   /* data-block is used for "annotations"
631    * NOTE: This flag used to be used in 2.4x, but should hardly ever have been set.
632    *       We can use this freely now, as all GP data-blocks from pre-2.8 will get
633    *       set on file load (as many old use cases are for "annotations" only)
634    */
635   GP_DATA_ANNOTATIONS = (1 << 0),
636
637   /* show debugging info in viewport (i.e. status print) */
638   GP_DATA_DISPINFO = (1 << 1),
639   /* in Action Editor, show as expanded channel */
640   GP_DATA_EXPAND = (1 << 2),
641
642   /* is the block overriding all clicks? */
643   /* GP_DATA_EDITPAINT = (1 << 3), */
644
645   /* ------------------------------------------------ DEPRECATED */
646   /* new strokes are added in viewport space */
647   GP_DATA_VIEWALIGN = (1 << 4),
648
649   /* Project into the screen's Z values */
650   GP_DATA_DEPTH_VIEW = (1 << 5),
651   GP_DATA_DEPTH_STROKE = (1 << 6),
652
653   GP_DATA_DEPTH_STROKE_ENDPOINTS = (1 << 7),
654   /* ------------------------------------------------ DEPRECATED */
655
656   /* Stroke Editing Mode - Toggle to enable alternative keymap
657    * for easier editing of stroke points */
658   GP_DATA_STROKE_EDITMODE = (1 << 8),
659
660   /* Main flag to switch onion skinning on/off */
661   GP_DATA_SHOW_ONIONSKINS = (1 << 9),
662
663   /* Batch drawing cache need to be recalculated */
664   GP_DATA_CACHE_IS_DIRTY = (1 << 11),
665
666   /* Stroke Paint Mode - Toggle paint mode */
667   GP_DATA_STROKE_PAINTMODE = (1 << 12),
668   /* Stroke Editing Mode - Toggle sculpt mode */
669   GP_DATA_STROKE_SCULPTMODE = (1 << 13),
670   /* Stroke Editing Mode - Toggle weight paint mode */
671   GP_DATA_STROKE_WEIGHTMODE = (1 << 14),
672
673   /* keep stroke thickness unchanged when zoom change */
674   GP_DATA_STROKE_KEEPTHICKNESS = (1 << 15),
675
676   /* Allow edit several frames at the same time */
677   GP_DATA_STROKE_MULTIEDIT = (1 << 16),
678
679   /* Vertex Paint Mode - Toggle paint mode */
680   GP_DATA_STROKE_VERTEXMODE = (1 << 18),
681
682   /* Autolock not active layers */
683   GP_DATA_AUTOLOCK_LAYERS = (1 << 20),
684 } eGPdata_Flag;
685
686 /* gpd->onion_flag */
687 typedef enum eGPD_OnionFlag {
688   /* use custom color for ghosts before current frame */
689   GP_ONION_GHOST_PREVCOL = (1 << 0),
690   /* use custom color for ghosts after current frame */
691   GP_ONION_GHOST_NEXTCOL = (1 << 1),
692   /* always show onion skins (i.e. even during renders/animation playback) */
693   GP_ONION_GHOST_ALWAYS = (1 << 2),
694   /* use fade color in onion skin */
695   GP_ONION_FADE = (1 << 3),
696   /* Loop showing first frame after last frame */
697   GP_ONION_LOOP = (1 << 4),
698 } eGPD_OnionFlag;
699
700 /* gpd->onion_mode */
701 typedef enum eGP_OnionModes {
702   GP_ONION_MODE_ABSOLUTE = 0,
703   GP_ONION_MODE_RELATIVE = 1,
704   GP_ONION_MODE_SELECTED = 2,
705 } eGP_OnionModes;
706
707 /* xray modes (Depth Ordering) */
708 typedef enum eGP_DepthOrdering {
709   GP_XRAY_FRONT = 0,
710   GP_XRAY_3DSPACE = 1,
711 } eGP_DepthOrdering;
712
713 /* draw modes (Use 2D or 3D position) */
714 typedef enum eGP_DrawMode {
715   GP_DRAWMODE_2D = 0,
716   GP_DRAWMODE_3D = 1,
717 } eGP_DrawMode;
718
719 /* ***************************************** */
720 /* Mode Checking Macros */
721
722 /* Check if 'multiedit sessions' is enabled */
723 #define GPENCIL_MULTIEDIT_SESSIONS_ON(gpd) \
724   ((gpd) && \
725    ((gpd)->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | \
726                    GP_DATA_STROKE_WEIGHTMODE | GP_DATA_STROKE_VERTEXMODE)) && \
727    ((gpd)->flag & GP_DATA_STROKE_MULTIEDIT))
728
729 /* Macros to check grease pencil modes */
730 #define GPENCIL_ANY_MODE(gpd) \
731   ((gpd) && ((gpd)->flag & \
732              (GP_DATA_STROKE_PAINTMODE | GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | \
733               GP_DATA_STROKE_WEIGHTMODE | GP_DATA_STROKE_VERTEXMODE)))
734 #define GPENCIL_EDIT_MODE(gpd) ((gpd) && ((gpd)->flag & GP_DATA_STROKE_EDITMODE))
735 #define GPENCIL_ANY_EDIT_MODE(gpd) \
736   ((gpd) && ((gpd)->flag & \
737              (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
738 #define GPENCIL_PAINT_MODE(gpd) ((gpd) && (gpd->flag & (GP_DATA_STROKE_PAINTMODE)))
739 #define GPENCIL_SCULPT_MODE(gpd) ((gpd) && (gpd->flag & GP_DATA_STROKE_SCULPTMODE))
740 #define GPENCIL_WEIGHT_MODE(gpd) ((gpd) && (gpd->flag & GP_DATA_STROKE_WEIGHTMODE))
741 #define GPENCIL_VERTEX_MODE(gpd) ((gpd) && (gpd->flag & (GP_DATA_STROKE_VERTEXMODE)))
742 #define GPENCIL_SCULPT_OR_WEIGHT_MODE(gpd) \
743   ((gpd) && ((gpd)->flag & (GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
744 #define GPENCIL_NONE_EDIT_MODE(gpd) \
745   ((gpd) && (((gpd)->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | \
746                              GP_DATA_STROKE_WEIGHTMODE | GP_DATA_STROKE_VERTEXMODE)) == 0))
747 #define GPENCIL_LAZY_MODE(brush, shift) \
748   (((brush) && \
749     (((brush)->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) && ((shift) == 0))) || \
750    ((((brush)->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) == 0) && ((shift) == 1)))
751
752 #define GPENCIL_ANY_SCULPT_MASK(flag) \
753   ((flag & (GP_SCULPT_MASK_SELECTMODE_POINT | GP_SCULPT_MASK_SELECTMODE_STROKE | \
754             GP_SCULPT_MASK_SELECTMODE_SEGMENT)))
755
756 #define GPENCIL_ANY_VERTEX_MASK(flag) \
757   ((flag & (GP_VERTEX_MASK_SELECTMODE_POINT | GP_VERTEX_MASK_SELECTMODE_STROKE | \
758             GP_VERTEX_MASK_SELECTMODE_SEGMENT)))
759
760 #endif /*  __DNA_GPENCIL_TYPES_H__ */