503ad2f28d9ac6111ea5c0da5759f9b5a22a9e84
[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         struct bGPDframe *derived_array;/* runtime data created by modifiers */
240         int icon_id;                    /* id for dynamic icon used to show annotation color preview for layer */
241         int batch_index;                /* batch used for dupli instances */
242         int len_derived;                /* len of the derived array */
243         char pad_[4];
244 } bGPDlayer_Runtime;
245
246 /* Grease-Pencil Annotations - 'Layer' */
247 typedef struct bGPDlayer {
248         struct bGPDlayer *next, *prev;
249
250         ListBase frames;                /* list of annotations to display for frames (bGPDframe list) */
251         bGPDframe *actframe;    /* active frame (should be the frame that is currently being displayed) */
252
253         short flag;                             /* settings for layer */
254         short onion_flag;               /* Per-layer onion-skinning flags (eGPDlayer_OnionFlag) */
255
256         float color[4];                 /* Color for strokes in layers. Used for annotations, and for ruler (which uses GPencil internally) */
257         float fill[4];                  /* Fill color for strokes in layers. Not used anymore (was only for) */
258
259         char info[128];                 /* name/reference info for this layer (i.e. "director's comments, 12/3")
260                                                          * needs to be kept unique, as it's used as the layer identifier */
261
262         short thickness;                /* thickness to apply to strokes (Annotations) */
263         short pass_index;       /* used to filter groups of layers in modifiers */
264
265         struct Object *parent;  /* parent object */
266         float inverse[4][4];    /* inverse matrix (only used if parented) */
267         char parsubstr[64];     /* String describing subobject info, MAX_ID_NAME-2 */
268         short partype;
269
270         short line_change;      /* Thickness adjustment */
271         float tintcolor[4];     /* Color used to tint layer, alpha value is used as factor */
272         float opacity;          /* Opacity of the layer */
273         char viewlayername[64]; /* Name of the layer used to filter render output */
274
275         bGPDlayer_Runtime runtime;
276 } bGPDlayer;
277
278 /* bGPDlayer->flag */
279 typedef enum eGPDlayer_Flag {
280         /* don't display layer */
281         GP_LAYER_HIDE                   = (1 << 0),
282         /* protected from further editing */
283         GP_LAYER_LOCKED                 = (1 << 1),
284         /* layer is 'active' layer being edited */
285         GP_LAYER_ACTIVE                 = (1 << 2),
286         /* draw points of stroke for debugging purposes */
287         GP_LAYER_DRAWDEBUG              = (1 << 3),
288         /* for editing in Action Editor */
289         GP_LAYER_SELECT                 = (1 << 5),
290         /* current frame for layer can't be changed */
291         GP_LAYER_FRAMELOCK              = (1 << 6),
292         /* don't render xray (which is default) */
293         GP_LAYER_NO_XRAY                = (1 << 7),
294         /* "volumetric" strokes */
295         GP_LAYER_VOLUMETRIC             = (1 << 10),
296         /* Unlock color */
297         GP_LAYER_UNLOCK_COLOR   = (1 << 12),
298 } eGPDlayer_Flag;
299
300 /* bGPDlayer->onion_flag */
301 typedef enum eGPDlayer_OnionFlag {
302         /* do onion skinning */
303         GP_LAYER_ONIONSKIN = (1 << 0),
304 } eGPDlayer_OnionFlag;
305
306 /* ***************************************** */
307 /* GP Datablock */
308
309 /* Runtime temp data for bGPdata */
310 typedef struct bGPdata_Runtime {
311         struct ARegion *ar;         /* last region where drawing was originated */
312         void *sbuffer;                          /* stroke buffer (can hold GP_STROKE_BUFFER_MAX) */
313
314         /* GP Object drawing */
315         float scolor[4];            /* buffer stroke color */
316         float sfill[4];             /* buffer fill color */
317         short mode;                 /* settings for color */
318         short bstroke_style;        /* buffer style for drawing strokes (used to select shader type) */
319         short bfill_style;          /* buffer style for filling areas (used to select shader type) */
320
321         /* Stroke Buffer data (only used during paint-session)
322          * - buffer must be initialized before use, but freed after
323          *   whole paint operation is over
324          */
325         short sbuffer_size;                     /* number of elements currently in cache */
326         short sbuffer_sflag;            /* flags for stroke that cache represents */
327         char pad_[6];
328 } bGPdata_Runtime;
329
330 /* grid configuration */
331 typedef struct bGPgrid {
332         float color[3];
333         float scale[2];
334         float offset[2];
335         char _pad1[4];
336
337         int   lines;
338         char pad_[4];
339 } bGPgrid;
340
341 /* Grease-Pencil Annotations - 'DataBlock' */
342 typedef struct bGPdata {
343         ID id;                                  /* Grease Pencil data is a datablock */
344         struct AnimData *adt;   /* animation data - for animating draw settings */
345
346         /* Grease-Pencil data */
347         ListBase layers;                /* bGPDlayers */
348         int flag;                               /* settings for this datablock */
349
350         short xray_mode;            /* xray mode for strokes (eGP_DepthOrdering) */
351         char pad_1[2];
352
353         /* Palettes */
354         ListBase palettes DNA_DEPRECATED;    /* list of bGPDpalette's   - Deprecated (2.78 - 2.79 only) */
355
356         /* 3D Viewport/Appearance Settings */
357         float pixfactor;            /* factor to define pixel size conversion */
358         float line_color[4];        /* color for edit line */
359
360         /* Onion skinning */
361         float onion_factor;         /* onion alpha factor change */
362         int onion_mode;             /* onion skinning range (eGP_OnionModes) */
363         int onion_flag;             /* onion skinning flags (eGPD_OnionFlag) */
364         short gstep;                        /* Ghosts Before: max number of ghost frames to show between active frame and the one before it (0 = only the ghost itself) */
365         short gstep_next;                   /* Ghosts After:  max number of ghost frames to show after active frame and the following it    (0 = only the ghost itself) */
366
367         float gcolor_prev[3];       /* optional color for ghosts before the active frame */
368         float gcolor_next[3];       /* optional color for ghosts after the active frame */
369
370         float zdepth_offset;        /* offset for drawing over surfaces to keep strokes on top */
371         struct Material **mat;      /* materials array */
372         short totcol;               /* total materials */
373
374         /* stats */
375         short totlayer;
376         short totframe;
377         char pad_2[6];
378         int   totstroke;
379         int   totpoint;
380         char pad_3[4];
381         bGPgrid grid;
382
383         bGPdata_Runtime runtime;
384 } bGPdata;
385
386 /* bGPdata->flag */
387 /* NOTE: A few flags have been deprecated since early 2.5,
388  *       since they have been made redundant by interaction
389  *       changes made during the porting process.
390  */
391 typedef enum eGPdata_Flag {
392         /* datablock is used for "annotations"
393          * NOTE: This flag used to be used in 2.4x, but should hardly ever have been set.
394          *       We can use this freely now, as all GP datablocks from pre-2.8 will get
395          *       set on file load (as many old use cases are for "annotations" only)
396          */
397         GP_DATA_ANNOTATIONS = (1 << 0),
398
399         /* show debugging info in viewport (i.e. status print) */
400         GP_DATA_DISPINFO        = (1 << 1),
401         /* in Action Editor, show as expanded channel */
402         GP_DATA_EXPAND          = (1 << 2),
403
404         /* is the block overriding all clicks? */
405         /* GP_DATA_EDITPAINT = (1 << 3), */
406
407 /* ------------------------------------------------ DEPRECATED */
408         /* new strokes are added in viewport space */
409         GP_DATA_VIEWALIGN       = (1 << 4),
410
411         /* Project into the screen's Z values */
412         GP_DATA_DEPTH_VIEW      = (1 << 5),
413         GP_DATA_DEPTH_STROKE = (1 << 6),
414
415         GP_DATA_DEPTH_STROKE_ENDPOINTS = (1 << 7),
416 /* ------------------------------------------------ DEPRECATED */
417
418         /* Stroke Editing Mode - Toggle to enable alternative keymap for easier editing of stroke points */
419         GP_DATA_STROKE_EDITMODE = (1 << 8),
420
421         /* Main flag to switch onion skinning on/off */
422         GP_DATA_SHOW_ONIONSKINS = (1 << 9),
423         /* Draw a green and red point to indicate start and end of the stroke */
424         GP_DATA_SHOW_DIRECTION = (1 << 10),
425
426         /* Batch drawing cache need to be recalculated */
427         GP_DATA_CACHE_IS_DIRTY = (1 << 11),
428
429         /* Stroke Paint Mode - Toggle paint mode */
430         GP_DATA_STROKE_PAINTMODE = (1 << 12),
431         /* Stroke Editing Mode - Toggle sculpt mode */
432         GP_DATA_STROKE_SCULPTMODE = (1 << 13),
433         /* Stroke Editing Mode - Toggle weight paint mode */
434         GP_DATA_STROKE_WEIGHTMODE = (1 << 14),
435
436         /* keep stroke thickness unchanged when zoom change */
437         GP_DATA_STROKE_KEEPTHICKNESS = (1 << 15),
438
439         /* Allow edit several frames at the same time */
440         GP_DATA_STROKE_MULTIEDIT = (1 << 16),
441
442         /* Force fill recalc if use deformation modifiers.
443          * this is required if the stroke is deformed and the triangulation data is
444          * not valid.
445          */
446         GP_DATA_STROKE_FORCE_RECALC = (1 << 17),
447         /* Special mode drawing polygons */
448         GP_DATA_STROKE_POLYGON = (1 << 18),
449         /* Use adaptative UV scales */
450         GP_DATA_UV_ADAPTATIVE = (1 << 19),
451         /* Autolock not active layers */
452         GP_DATA_AUTOLOCK_LAYERS = (1 << 20),
453 } eGPdata_Flag;
454
455 /* gpd->onion_flag */
456 typedef enum eGPD_OnionFlag {
457         /* use custom color for ghosts before current frame */
458         GP_ONION_GHOST_PREVCOL = (1 << 0),
459         /* use custom color for ghosts after current frame */
460         GP_ONION_GHOST_NEXTCOL = (1 << 1),
461         /* always show onion skins (i.e. even during renders/animation playback) */
462         GP_ONION_GHOST_ALWAYS = (1 << 2),
463         /* use fade color in onion skin */
464         GP_ONION_FADE = (1 << 3),
465         /* Loop showing first frame after last frame */
466         GP_ONION_LOOP = (1 << 4),
467 } eGPD_OnionFlag;
468
469 /* gpd->onion_mode */
470 typedef enum eGP_OnionModes {
471         GP_ONION_MODE_ABSOLUTE = 0,
472         GP_ONION_MODE_RELATIVE = 1,
473         GP_ONION_MODE_SELECTED = 2,
474 } eGP_OnionModes;
475
476 /* xray modes (Depth Ordering) */
477 typedef enum eGP_DepthOrdering {
478         GP_XRAY_FRONT = 0,
479         GP_XRAY_3DSPACE = 1,
480         GP_XRAY_BACK  = 2
481 } eGP_DepthOrdering;
482
483 /* ***************************************** */
484 /* Mode Checking Macros */
485
486 /* Check if 'multiedit sessions' is enabled */
487 #define GPENCIL_MULTIEDIT_SESSIONS_ON(gpd) \
488         ((gpd) && (gpd->flag & \
489                    (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)) && \
490          (gpd->flag & GP_DATA_STROKE_MULTIEDIT))
491
492 /* Macros to check grease pencil modes */
493 #define GPENCIL_ANY_MODE(gpd) \
494         ((gpd) && (gpd->flag & \
495                    (GP_DATA_STROKE_PAINTMODE | GP_DATA_STROKE_EDITMODE | \
496                     GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
497 #define GPENCIL_EDIT_MODE(gpd) \
498         ((gpd) && (gpd->flag & GP_DATA_STROKE_EDITMODE))
499 #define GPENCIL_ANY_EDIT_MODE(gpd) \
500         ((gpd) && (gpd->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
501 #define GPENCIL_PAINT_MODE(gpd) \
502         ((gpd) && (gpd->flag & (GP_DATA_STROKE_PAINTMODE)))
503 #define GPENCIL_SCULPT_OR_WEIGHT_MODE(gpd) \
504         ((gpd) && (gpd->flag & (GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
505 #define GPENCIL_NONE_EDIT_MODE(gpd) \
506         ((gpd) && ((gpd->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)) == 0))
507 #define GPENCIL_LAZY_MODE(brush, shift) \
508         (((brush) && ((brush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) && (shift == 0))) || \
509          (((brush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) == 0) && (shift == 1)))
510
511 #endif /*  __DNA_GPENCIL_TYPES_H__ */