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