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