GP: Refactor drawing engine to single VBO
[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         bGPDlayer_Runtime runtime;
273 } bGPDlayer;
274
275 /* bGPDlayer->flag */
276 typedef enum eGPDlayer_Flag {
277         /* don't display layer */
278         GP_LAYER_HIDE                   = (1 << 0),
279         /* protected from further editing */
280         GP_LAYER_LOCKED                 = (1 << 1),
281         /* layer is 'active' layer being edited */
282         GP_LAYER_ACTIVE                 = (1 << 2),
283         /* draw points of stroke for debugging purposes */
284         GP_LAYER_DRAWDEBUG              = (1 << 3),
285         /* for editing in Action Editor */
286         GP_LAYER_SELECT                 = (1 << 5),
287         /* current frame for layer can't be changed */
288         GP_LAYER_FRAMELOCK              = (1 << 6),
289         /* don't render xray (which is default) */
290         GP_LAYER_NO_XRAY                = (1 << 7),
291         /* "volumetric" strokes */
292         GP_LAYER_VOLUMETRIC             = (1 << 10),
293         /* Unlock color */
294         GP_LAYER_UNLOCK_COLOR   = (1 << 12),
295 } eGPDlayer_Flag;
296
297 /* bGPDlayer->onion_flag */
298 typedef enum eGPDlayer_OnionFlag {
299         /* do onion skinning */
300         GP_LAYER_ONIONSKIN = (1 << 0),
301 } eGPDlayer_OnionFlag;
302
303 /* ***************************************** */
304 /* GP Datablock */
305
306 /* Runtime temp data for bGPdata */
307 typedef struct bGPdata_Runtime {
308         struct ARegion *ar;         /* last region where drawing was originated */
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         float offset[2];
332         char _pad1[4];
333
334         int   lines;
335         char pad_[4];
336 } bGPgrid;
337
338 /* Grease-Pencil Annotations - 'DataBlock' */
339 typedef struct bGPdata {
340         ID id;                                  /* Grease Pencil data is a datablock */
341         struct AnimData *adt;   /* animation data - for animating draw settings */
342
343         /* Grease-Pencil data */
344         ListBase layers;                /* bGPDlayers */
345         int flag;                               /* settings for this datablock */
346
347         short xray_mode;            /* xray mode for strokes (eGP_DepthOrdering) */
348         char pad_1[2];
349
350         /* Palettes */
351         ListBase palettes DNA_DEPRECATED;    /* list of bGPDpalette's   - Deprecated (2.78 - 2.79 only) */
352
353         /* 3D Viewport/Appearance Settings */
354         float pixfactor;            /* factor to define pixel size conversion */
355         float line_color[4];        /* color for edit line */
356
357         /* Onion skinning */
358         float onion_factor;         /* onion alpha factor change */
359         int onion_mode;             /* onion skinning range (eGP_OnionModes) */
360         int onion_flag;             /* onion skinning flags (eGPD_OnionFlag) */
361         short gstep;                        /* Ghosts Before: max number of ghost frames to show between active frame and the one before it (0 = only the ghost itself) */
362         short gstep_next;                   /* Ghosts After:  max number of ghost frames to show after active frame and the following it    (0 = only the ghost itself) */
363
364         float gcolor_prev[3];       /* optional color for ghosts before the active frame */
365         float gcolor_next[3];       /* optional color for ghosts after the active frame */
366
367         float zdepth_offset;        /* offset for drawing over surfaces to keep strokes on top */
368         struct Material **mat;      /* materials array */
369         short totcol;               /* total materials */
370
371         /* stats */
372         short totlayer;
373         short totframe;
374         char pad_2[6];
375         int   totstroke;
376         int   totpoint;
377         char pad_3[4];
378         bGPgrid grid;
379
380         bGPdata_Runtime runtime;
381 } bGPdata;
382
383 /* bGPdata->flag */
384 /* NOTE: A few flags have been deprecated since early 2.5,
385  *       since they have been made redundant by interaction
386  *       changes made during the porting process.
387  */
388 typedef enum eGPdata_Flag {
389         /* datablock is used for "annotations"
390          * NOTE: This flag used to be used in 2.4x, but should hardly ever have been set.
391          *       We can use this freely now, as all GP datablocks from pre-2.8 will get
392          *       set on file load (as many old use cases are for "annotations" only)
393          */
394         GP_DATA_ANNOTATIONS = (1 << 0),
395
396         /* show debugging info in viewport (i.e. status print) */
397         GP_DATA_DISPINFO        = (1 << 1),
398         /* in Action Editor, show as expanded channel */
399         GP_DATA_EXPAND          = (1 << 2),
400
401         /* is the block overriding all clicks? */
402         /* GP_DATA_EDITPAINT = (1 << 3), */
403
404 /* ------------------------------------------------ DEPRECATED */
405         /* new strokes are added in viewport space */
406         GP_DATA_VIEWALIGN       = (1 << 4),
407
408         /* Project into the screen's Z values */
409         GP_DATA_DEPTH_VIEW      = (1 << 5),
410         GP_DATA_DEPTH_STROKE = (1 << 6),
411
412         GP_DATA_DEPTH_STROKE_ENDPOINTS = (1 << 7),
413 /* ------------------------------------------------ DEPRECATED */
414
415         /* Stroke Editing Mode - Toggle to enable alternative keymap for easier editing of stroke points */
416         GP_DATA_STROKE_EDITMODE = (1 << 8),
417
418         /* Main flag to switch onion skinning on/off */
419         GP_DATA_SHOW_ONIONSKINS = (1 << 9),
420         /* Draw a green and red point to indicate start and end of the stroke */
421         GP_DATA_SHOW_DIRECTION = (1 << 10),
422
423         /* Batch drawing cache need to be recalculated */
424         GP_DATA_CACHE_IS_DIRTY = (1 << 11),
425
426         /* Stroke Paint Mode - Toggle paint mode */
427         GP_DATA_STROKE_PAINTMODE = (1 << 12),
428         /* Stroke Editing Mode - Toggle sculpt mode */
429         GP_DATA_STROKE_SCULPTMODE = (1 << 13),
430         /* Stroke Editing Mode - Toggle weight paint mode */
431         GP_DATA_STROKE_WEIGHTMODE = (1 << 14),
432
433         /* keep stroke thickness unchanged when zoom change */
434         GP_DATA_STROKE_KEEPTHICKNESS = (1 << 15),
435
436         /* Allow edit several frames at the same time */
437         GP_DATA_STROKE_MULTIEDIT = (1 << 16),
438
439         /* Force fill recalc if use deformation modifiers.
440          * this is required if the stroke is deformed and the triangulation data is
441          * not valid.
442          */
443         GP_DATA_STROKE_FORCE_RECALC = (1 << 17),
444         /* Special mode drawing polygons */
445         GP_DATA_STROKE_POLYGON = (1 << 18),
446         /* Use adaptative UV scales */
447         GP_DATA_UV_ADAPTATIVE = (1 << 19),
448         /* Autolock not active layers */
449         GP_DATA_AUTOLOCK_LAYERS = (1 << 20),
450 } eGPdata_Flag;
451
452 /* gpd->onion_flag */
453 typedef enum eGPD_OnionFlag {
454         /* use custom color for ghosts before current frame */
455         GP_ONION_GHOST_PREVCOL = (1 << 0),
456         /* use custom color for ghosts after current frame */
457         GP_ONION_GHOST_NEXTCOL = (1 << 1),
458         /* always show onion skins (i.e. even during renders/animation playback) */
459         GP_ONION_GHOST_ALWAYS = (1 << 2),
460         /* use fade color in onion skin */
461         GP_ONION_FADE = (1 << 3),
462         /* Loop showing first frame after last frame */
463         GP_ONION_LOOP = (1 << 4),
464 } eGPD_OnionFlag;
465
466 /* gpd->onion_mode */
467 typedef enum eGP_OnionModes {
468         GP_ONION_MODE_ABSOLUTE = 0,
469         GP_ONION_MODE_RELATIVE = 1,
470         GP_ONION_MODE_SELECTED = 2,
471 } eGP_OnionModes;
472
473 /* xray modes (Depth Ordering) */
474 typedef enum eGP_DepthOrdering {
475         GP_XRAY_FRONT = 0,
476         GP_XRAY_3DSPACE = 1,
477         GP_XRAY_BACK  = 2
478 } eGP_DepthOrdering;
479
480 /* ***************************************** */
481 /* Mode Checking Macros */
482
483 /* Check if 'multiedit sessions' is enabled */
484 #define GPENCIL_MULTIEDIT_SESSIONS_ON(gpd) \
485         ((gpd) && (gpd->flag & \
486                    (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)) && \
487          (gpd->flag & GP_DATA_STROKE_MULTIEDIT))
488
489 /* Macros to check grease pencil modes */
490 #define GPENCIL_ANY_MODE(gpd) \
491         ((gpd) && (gpd->flag & \
492                    (GP_DATA_STROKE_PAINTMODE | GP_DATA_STROKE_EDITMODE | \
493                     GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
494 #define GPENCIL_EDIT_MODE(gpd) \
495         ((gpd) && (gpd->flag & GP_DATA_STROKE_EDITMODE))
496 #define GPENCIL_ANY_EDIT_MODE(gpd) \
497         ((gpd) && (gpd->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
498 #define GPENCIL_PAINT_MODE(gpd) \
499         ((gpd) && (gpd->flag & (GP_DATA_STROKE_PAINTMODE)))
500 #define GPENCIL_SCULPT_OR_WEIGHT_MODE(gpd) \
501         ((gpd) && (gpd->flag & (GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)))
502 #define GPENCIL_NONE_EDIT_MODE(gpd) \
503         ((gpd) && ((gpd->flag & (GP_DATA_STROKE_EDITMODE | GP_DATA_STROKE_SCULPTMODE | GP_DATA_STROKE_WEIGHTMODE)) == 0))
504 #define GPENCIL_LAZY_MODE(brush, shift) \
505         (((brush) && ((brush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) && (shift == 0))) || \
506          (((brush->gpencil_settings->flag & GP_BRUSH_STABILIZE_MOUSE) == 0) && (shift == 1)))
507
508 #endif /*  __DNA_GPENCIL_TYPES_H__ */