GP: Cleanup pad to _pad
[blender.git] / source / blender / makesdna / DNA_gpencil_types.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2008, Blender Foundation.
19  * This is a new part of Blender
20  *
21  * Contributor(s): Joshua Leung, Antonio Vazquez
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file DNA_gpencil_types.h
27  *  \ingroup DNA
28  */
29
30 #ifndef __DNA_GPENCIL_TYPES_H__
31 #define __DNA_GPENCIL_TYPES_H__
32
33 #include "DNA_listBase.h"
34 #include "DNA_ID.h"
35 #include "DNA_brush_types.h"
36
37 struct ARegion;
38 struct AnimData;
39 struct CurveMapping;
40 struct GHash;
41 struct MDeformVert;
42
43 #define GP_OBGPENCIL_DEFAULT_SIZE  0.2f
44 #define GP_DEFAULT_PIX_FACTOR 1.0f
45 #define GP_DEFAULT_GRID_LINES 4
46 #define GP_MAX_INPUT_SAMPLES 10
47
48 /* ***************************************** */
49 /* GP Stroke Points */
50
51 /* 'Control Point' data for primitives and curves */
52 typedef struct bGPDcontrolpoint {
53         float x, y, z;          /* x and y coordinates of control point */
54         float color[4];         /* point color */
55         int size;               /* radius */
56 } bGPDcontrolpoint;
57
58 /* Grease-Pencil Annotations - 'Stroke Point'
59  * -> Coordinates may either be 2d or 3d depending on settings at the time
60  * -> Coordinates of point on stroke, in proportions of window size
61  *    This assumes that the bottom-left corner is (0,0)
62  */
63 typedef struct bGPDspoint {
64         float x, y, z;                  /* co-ordinates of point (usually 2d, but can be 3d as well) */
65         float pressure;                 /* pressure of input device (from 0 to 1) at this point */
66         float strength;                 /* color strength (used for alpha factor) */
67         float time;                             /* seconds since start of stroke */
68         int flag;                               /* additional options */
69
70         float uv_fac;           /* factor of uv along the stroke */
71         float uv_rot;           /* uv rotation for dot mode */
72 } bGPDspoint;
73
74 /* bGPDspoint->flag */
75 typedef enum eGPDspoint_Flag {
76         /* stroke point is selected (for editing) */
77         GP_SPOINT_SELECT        = (1 << 0),
78
79         /* stroke point is tagged (for some editing operation) */
80         GP_SPOINT_TAG       = (1 << 1),
81         /* stroke point is temp tagged (for some editing operation) */
82         GP_SPOINT_TEMP_TAG  = (1 << 2),
83 } eGPSPoint_Flag;
84
85 /* ***************************************** */
86 /* GP Fill - Triangle Tessellation Data */
87
88 /* Grease-Pencil Annotations - 'Triangle'
89  * -> A triangle contains the index of three vertices for filling the stroke
90  *    This is only used if high quality fill is enabled
91  */
92 typedef struct bGPDtriangle {
93         /* indices for tessellated triangle used for GP Fill */
94         unsigned int verts[3];
95         /* texture coordinates for verts */
96         float uv[3][2];
97 } bGPDtriangle;
98
99 /* ***************************************** */
100
101 /* ***************************************** */
102 /* GP Palettes (Deprecated - 2.78 - 2.79 only) */
103
104 /* color of palettes */
105 typedef struct bGPDpalettecolor {
106         struct bGPDpalettecolor *next, *prev;
107         char info[64];           /* Color name. Must be unique. */
108         float color[4];
109         float fill[4];           /* color that should be used for drawing "fills" for strokes */
110         short flag;              /* settings for palette color */
111         char  _pad[6];           /* padding for compiler alignment error */
112 } bGPDpalettecolor;
113
114 /* bGPDpalettecolor->flag */
115 typedef enum eGPDpalettecolor_Flag {
116         /* color is active */
117         PC_COLOR_ACTIVE = (1 << 0),
118         /* don't display color */
119         PC_COLOR_HIDE = (1 << 1),
120         /* protected from further editing */
121         PC_COLOR_LOCKED = (1 << 2),
122         /* do onion skinning */
123         PC_COLOR_ONIONSKIN = (1 << 3),
124         /* "volumetric" strokes */
125         PC_COLOR_VOLUMETRIC = (1 << 4)
126 } eGPDpalettecolor_Flag;
127
128 /* palette of colors */
129 typedef struct bGPDpalette {
130         struct bGPDpalette *next, *prev;
131
132         /* pointer to individual colours */
133         ListBase colors;
134         char info[64];          /* Palette name. Must be unique. */
135
136         short flag;
137         char _pad[6];           /* padding for compiler alignment error */
138 } bGPDpalette;
139
140 /* bGPDpalette->flag */
141 typedef enum eGPDpalette_Flag {
142         /* palette is active */
143         PL_PALETTE_ACTIVE = (1 << 0)
144 } eGPDpalette_Flag;
145
146 /* ***************************************** */
147 /* GP Strokes */
148
149 /* Runtime temp data for bGPDstroke */
150 typedef struct bGPDstroke_Runtime {
151         /* runtime final colors (result of original colors and modifiers) */
152         float tmp_stroke_rgba[4];
153         float tmp_fill_rgba[4];
154
155         /* temporary layer name only used during copy/paste to put the stroke in the original layer */
156         char tmp_layerinfo[128];
157
158         float multi_frame_falloff; /* runtime falloff factor (only for transform) */
159 } bGPDstroke_Runtime;
160
161 /* Grease-Pencil Annotations - 'Stroke'
162  * -> A stroke represents a (simplified version) of the curve
163  *    drawn by the user in one 'mousedown'->'mouseup' operation
164  */
165 typedef struct bGPDstroke {
166         struct bGPDstroke *next, *prev;
167
168         bGPDspoint *points;             /* array of data-points for stroke */
169         bGPDtriangle *triangles;/* tessellated triangles for GP Fill */
170         int totpoints;          /* number of data-points in array */
171         int tot_triangles;      /* number of triangles in array */
172
173         short thickness;        /* thickness of stroke */
174         short flag, _pad[2];    /* various settings about this stroke */
175
176         double inittime;                /* Init time of stroke */
177
178         char colorname[128] DNA_DEPRECATED;    /* color name */
179
180         int mat_nr;             /* material index */
181         char _pad1[4];
182
183         struct MDeformVert *dvert;    /* vertex weight data */
184
185         bGPDstroke_Runtime runtime;
186         char _pad2[4];
187 } bGPDstroke;
188
189 /* bGPDstroke->flag */
190 typedef enum eGPDstroke_Flag {
191         /* stroke is in 3d-space */
192         GP_STROKE_3DSPACE               = (1 << 0),
193         /* stroke is in 2d-space */
194         GP_STROKE_2DSPACE               = (1 << 1),
195         /* stroke is in 2d-space (but with special 'image' scaling) */
196         GP_STROKE_2DIMAGE               = (1 << 2),
197         /* stroke is selected */
198         GP_STROKE_SELECT                = (1 << 3),
199         /* Recalculate geometry data (triangulation, UVs, Bound Box,... (when true, force a new recalc) */
200         GP_STROKE_RECALC_GEOMETRY = (1 << 4),
201         /* Flag used to indicate that stroke is closed and draw edge between last and first point */
202         GP_STROKE_CYCLIC = (1 << 7),
203         /* Flag used to indicate that stroke is used for fill close and must use fill color for stroke and no fill area */
204         GP_STROKE_NOFILL = (1 << 8),
205         /* only for use with stroke-buffer (while drawing eraser) */
206         GP_STROKE_ERASER                = (1 << 15)
207 } eGPDstroke_Flag;
208
209 /* ***************************************** */
210 /* GP Frame */
211
212 /* Runtime temp data for bGPDframe */
213 typedef struct bGPDframe_Runtime {
214         float viewmatrix[4][4];     /* parent matrix for drawing */
215 } bGPDframe_Runtime;
216
217 /* Grease-Pencil Annotations - 'Frame'
218  * -> Acts as storage for the 'image' formed by strokes
219  */
220 typedef struct bGPDframe {
221         struct bGPDframe *next, *prev;
222
223         ListBase strokes;       /* list of the simplified 'strokes' that make up the frame's data */
224
225         int framenum;           /* frame number of this frame */
226
227         short flag;                     /* temp settings */
228         short key_type;         /* keyframe type (eBezTriple_KeyframeType) */
229
230         bGPDframe_Runtime runtime;
231 } bGPDframe;
232
233 /* bGPDframe->flag */
234 typedef enum eGPDframe_Flag {
235         /* frame is being painted on */
236         GP_FRAME_PAINT          = (1 << 0),
237         /* for editing in Action Editor */
238         GP_FRAME_SELECT         = (1 << 1)
239 } eGPDframe_Flag;
240
241 /* ***************************************** */
242 /* GP Layer */
243
244 /* Runtime temp data for bGPDlayer */
245 typedef struct bGPDlayer_Runtime {
246         int icon_id;                    /* id for dynamic icon used to show annotation color preview for layer */
247         char _pad[4];
248 } bGPDlayer_Runtime;
249
250 /* Grease-Pencil Annotations - 'Layer' */
251 typedef struct bGPDlayer {
252         struct bGPDlayer *next, *prev;
253
254         ListBase frames;                /* list of annotations to display for frames (bGPDframe list) */
255         bGPDframe *actframe;    /* active frame (should be the frame that is currently being displayed) */
256
257         short flag;                             /* settings for layer */
258         short onion_flag;               /* Per-layer onion-skinning flags (eGPDlayer_OnionFlag) */
259
260         float color[4];                 /* Color for strokes in layers. Used for annotations, and for ruler (which uses GPencil internally) */
261         float fill[4];                  /* Fill color for strokes in layers. Not used anymore (was only for) */
262
263         char info[128];                 /* name/reference info for this layer (i.e. "director's comments, 12/3")
264                                                          * needs to be kept unique, as it's used as the layer identifier */
265
266         short thickness;                /* thickness to apply to strokes (Annotations) */
267         short pass_index;       /* used to filter groups of layers in modifiers */
268
269         struct Object *parent;  /* parent object */
270         float inverse[4][4];    /* inverse matrix (only used if parented) */
271         char parsubstr[64];     /* String describing subobject info, MAX_ID_NAME-2 */
272         short partype;
273
274         short line_change;      /* Thickness adjustment */
275         float tintcolor[4];     /* Color used to tint layer, alpha value is used as factor */
276         float opacity;          /* Opacity of the layer */
277         char viewlayername[64]; /* Name of the layer used to filter render output */
278
279         int blend_mode;         /* blend modes */
280         char _pad[4];
281
282         /* annotation onion skin */
283         short gstep;                    /* Ghosts Before: max number of ghost frames to show between active frame and the one before it (0 = only the ghost itself) */
284         short gstep_next;               /* Ghosts After:  max number of ghost frames to show after active frame and the following it    (0 = only the ghost itself) */
285
286         float gcolor_prev[3];   /* color for ghosts before the active frame */
287         float gcolor_next[3];   /* color for ghosts after the active frame */
288         char _pad1[4];
289
290         bGPDlayer_Runtime runtime;
291 } bGPDlayer;
292
293 /* bGPDlayer->flag */
294 typedef enum eGPDlayer_Flag {
295         /* don't display layer */
296         GP_LAYER_HIDE                   = (1 << 0),
297         /* protected from further editing */
298         GP_LAYER_LOCKED                 = (1 << 1),
299         /* layer is 'active' layer being edited */
300         GP_LAYER_ACTIVE                 = (1 << 2),
301         /* draw points of stroke for debugging purposes */
302         GP_LAYER_DRAWDEBUG              = (1 << 3),
303         /* for editing in Action Editor */
304         GP_LAYER_SELECT                 = (1 << 5),
305         /* current frame for layer can't be changed */
306         GP_LAYER_FRAMELOCK              = (1 << 6),
307         /* don't render xray (which is default) */
308         GP_LAYER_NO_XRAY                = (1 << 7),
309         /* "volumetric" strokes */
310         GP_LAYER_VOLUMETRIC             = (1 << 10),
311         /* Unlock color */
312         GP_LAYER_UNLOCK_COLOR   = (1 << 12),
313         /* Mask Layer */
314         GP_LAYER_USE_MASK = (1 << 13),
315 } eGPDlayer_Flag;
316
317 /* bGPDlayer->onion_flag */
318 typedef enum eGPDlayer_OnionFlag {
319         /* do onion skinning */
320         GP_LAYER_ONIONSKIN = (1 << 0),
321 } eGPDlayer_OnionFlag;
322
323 /* layer blend_mode */
324 typedef enum eGPLayerBlendModes {
325         eGplBlendMode_Normal = 0,
326         eGplBlendMode_Overlay = 1,
327         eGplBlendMode_Add = 2,
328         eGplBlendMode_Subtract = 3,
329         eGplBlendMode_Multiply = 4,
330         eGplBlendMode_Divide = 5,
331 } eGPLayerBlendModes;
332
333 /* ***************************************** */
334 /* GP Datablock */
335
336 /* Runtime temp data for bGPdata */
337 typedef struct bGPdata_Runtime {
338         struct ARegion *ar;         /* last region where drawing was originated */
339         void *sbuffer;                          /* stroke buffer (can hold GP_STROKE_BUFFER_MAX) */
340
341         /* GP Object drawing */
342         float scolor[4];            /* buffer stroke color */
343         float sfill[4];             /* buffer fill color */
344         short mode;                 /* settings for color */
345         short bstroke_style;        /* buffer style for drawing strokes (used to select shader type) */
346         short bfill_style;          /* buffer style for filling areas (used to select shader type) */
347
348         /* Stroke Buffer data (only used during paint-session)
349          * - buffer must be initialized before use, but freed after
350          *   whole paint operation is over
351          */
352         short sbuffer_size;                     /* number of elements currently in cache */
353         short sbuffer_sflag;            /* flags for stroke that cache represents */
354         char _pad[6];
355
356         int tot_cp_points;                 /* number of control-points for stroke */
357         char _pad1_[4];
358         bGPDcontrolpoint *cp_points;       /* array of control-points for stroke */
359 } bGPdata_Runtime;
360
361 /* grid configuration */
362 typedef struct bGPgrid {
363         float color[3];
364         float scale[2];
365         float offset[2];
366         char _pad1[4];
367
368         int   lines;
369         char _pad[4];
370 } bGPgrid;
371
372 /* Grease-Pencil Annotations - 'DataBlock' */
373 typedef struct bGPdata {
374         ID id;                                  /* Grease Pencil data is a datablock */
375         struct AnimData *adt;   /* animation data - for animating draw settings */
376
377         /* Grease-Pencil data */
378         ListBase layers;                /* bGPDlayers */
379         int flag;                               /* settings for this datablock */
380
381         short xray_mode;            /* xray mode for strokes (eGP_DepthOrdering) */
382         char _pad1[2];
383
384         /* Palettes */
385         ListBase palettes DNA_DEPRECATED;    /* list of bGPDpalette's   - Deprecated (2.78 - 2.79 only) */
386
387         /* 3D Viewport/Appearance Settings */
388         float pixfactor;            /* factor to define pixel size conversion */
389         float line_color[4];        /* color for edit line */
390
391         /* Onion skinning */
392         float onion_factor;         /* onion alpha factor change */
393         int onion_mode;             /* onion skinning range (eGP_OnionModes) */
394         int onion_flag;             /* onion skinning flags (eGPD_OnionFlag) */
395         short gstep;                        /* Ghosts Before: max number of ghost frames to show between active frame and the one before it (0 = only the ghost itself) */
396         short gstep_next;                   /* Ghosts After:  max number of ghost frames to show after active frame and the following it    (0 = only the ghost itself) */
397
398         float gcolor_prev[3];       /* optional color for ghosts before the active frame */
399         float gcolor_next[3];       /* optional color for ghosts after the active frame */
400
401         float zdepth_offset;        /* offset for drawing over surfaces to keep strokes on top */
402         struct Material **mat;      /* materials array */
403         short totcol;               /* total materials */
404
405         /* stats */
406         short totlayer;
407         short totframe;
408         char _pad2[6];
409         int   totstroke;
410         int   totpoint;
411         char _pad3[4];
412         bGPgrid grid;
413
414         bGPdata_Runtime runtime;
415 } bGPdata;
416
417 /* bGPdata->flag */
418 /* NOTE: A few flags have been deprecated since early 2.5,
419  *       since they have been made redundant by interaction
420  *       changes made during the porting process.
421  */
422 typedef enum eGPdata_Flag {
423         /* datablock is used for "annotations"
424          * NOTE: This flag used to be used in 2.4x, but should hardly ever have been set.
425          *       We can use this freely now, as all GP datablocks from pre-2.8 will get
426          *       set on file load (as many old use cases are for "annotations" only)
427          */
428         GP_DATA_ANNOTATIONS = (1 << 0),
429
430         /* show debugging info in viewport (i.e. status print) */
431         GP_DATA_DISPINFO        = (1 << 1),
432         /* in Action Editor, show as expanded channel */
433         GP_DATA_EXPAND          = (1 << 2),
434
435         /* is the block overriding all clicks? */
436         /* GP_DATA_EDITPAINT = (1 << 3), */
437
438 /* ------------------------------------------------ DEPRECATED */
439         /* new strokes are added in viewport space */
440         GP_DATA_VIEWALIGN       = (1 << 4),
441
442         /* Project into the screen's Z values */
443         GP_DATA_DEPTH_VIEW      = (1 << 5),
444         GP_DATA_DEPTH_STROKE = (1 << 6),
445
446         GP_DATA_DEPTH_STROKE_ENDPOINTS = (1 << 7),
447 /* ------------------------------------------------ DEPRECATED */
448
449         /* Stroke Editing Mode - Toggle to enable alternative keymap for easier editing of stroke points */
450         GP_DATA_STROKE_EDITMODE = (1 << 8),
451
452         /* Main flag to switch onion skinning on/off */
453         GP_DATA_SHOW_ONIONSKINS = (1 << 9),
454         /* Draw a green and red point to indicate start and end of the stroke */
455         GP_DATA_SHOW_DIRECTION = (1 << 10),
456
457         /* Batch drawing cache need to be recalculated */
458         GP_DATA_CACHE_IS_DIRTY = (1 << 11),
459
460         /* Stroke Paint Mode - Toggle paint mode */
461         GP_DATA_STROKE_PAINTMODE = (1 << 12),
462         /* Stroke Editing Mode - Toggle sculpt mode */
463         GP_DATA_STROKE_SCULPTMODE = (1 << 13),
464         /* Stroke Editing Mode - Toggle weight paint mode */
465         GP_DATA_STROKE_WEIGHTMODE = (1 << 14),
466
467         /* keep stroke thickness unchanged when zoom change */
468         GP_DATA_STROKE_KEEPTHICKNESS = (1 << 15),
469
470         /* Allow edit several frames at the same time */
471         GP_DATA_STROKE_MULTIEDIT = (1 << 16),
472
473         /* Force fill recalc if use deformation modifiers.
474          * this is required if the stroke is deformed and the triangulation data is
475          * not valid.
476          */
477         GP_DATA_STROKE_FORCE_RECALC = (1 << 17),
478         /* Special mode drawing polygons */
479         GP_DATA_STROKE_POLYGON = (1 << 18),
480         /* Use adaptive UV scales */
481         GP_DATA_UV_ADAPTIVE = (1 << 19),
482         /* Autolock not active layers */
483         GP_DATA_AUTOLOCK_LAYERS = (1 << 20),
484         /* Internal flag for python update */
485         GP_DATA_PYTHON_UPDATED = (1 << 21),
486 } eGPdata_Flag;
487
488 /* gpd->onion_flag */
489 typedef enum eGPD_OnionFlag {
490         /* use custom color for ghosts before current frame */
491         GP_ONION_GHOST_PREVCOL = (1 << 0),
492         /* use custom color for ghosts after current frame */
493         GP_ONION_GHOST_NEXTCOL = (1 << 1),
494         /* always show onion skins (i.e. even during renders/animation playback) */
495         GP_ONION_GHOST_ALWAYS = (1 << 2),
496         /* use fade color in onion skin */
497         GP_ONION_FADE = (1 << 3),
498         /* Loop showing first frame after last frame */
499         GP_ONION_LOOP = (1 << 4),
500 } eGPD_OnionFlag;
501
502 /* gpd->onion_mode */
503 typedef enum eGP_OnionModes {
504         GP_ONION_MODE_ABSOLUTE = 0,
505         GP_ONION_MODE_RELATIVE = 1,
506         GP_ONION_MODE_SELECTED = 2,
507 } eGP_OnionModes;
508
509 /* xray modes (Depth Ordering) */
510 typedef enum eGP_DepthOrdering {
511         GP_XRAY_FRONT = 0,
512         GP_XRAY_3DSPACE = 1,
513         GP_XRAY_BACK  = 2
514 } eGP_DepthOrdering;
515
516 /* ***************************************** */
517 /* Mode Checking Macros */
518
519 /* Check if 'multiedit sessions' is enabled */
520 #define GPENCIL_MULTIEDIT_SESSIONS_ON(gpd) \
521         ((gpd) && (gpd->flag & \
522                    (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)) && \
523          (gpd->flag & GP_DATA_STROKE_MULTIEDIT))
524
525 /* Macros to check grease pencil modes */
526 #define GPENCIL_ANY_MODE(gpd) \
527         ((gpd) && (gpd->flag & \
528                    (GP_DATA_STROKE_PAINTMODE | GP_DATA_STROKE_EDITMODE | \
529                     GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
530 #define GPENCIL_EDIT_MODE(gpd) \
531         ((gpd) && (gpd->flag & GP_DATA_STROKE_EDITMODE))
532 #define GPENCIL_ANY_EDIT_MODE(gpd) \
533         ((gpd) && (gpd->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
534 #define GPENCIL_PAINT_MODE(gpd) \
535         ((gpd) && (gpd->flag & (GP_DATA_STROKE_PAINTMODE)))
536 #define GPENCIL_SCULPT_OR_WEIGHT_MODE(gpd) \
537         ((gpd) && (gpd->flag & (GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
538 #define GPENCIL_NONE_EDIT_MODE(gpd) \
539         ((gpd) && ((gpd->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)) == 0))
540 #define GPENCIL_LAZY_MODE(brush, shift) \
541         (((brush) && ((brush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) && (shift == 0))) || \
542          (((brush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) == 0) && (shift == 1)))
543
544 #endif /*  __DNA_GPENCIL_TYPES_H__ */