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