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