Merge branch '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 AnimData;
38 struct CurveMapping;
39
40 /* Grease-Pencil Annotations - 'Stroke Point'
41  *      -> Coordinates may either be 2d or 3d depending on settings at the time
42  *      -> Coordinates of point on stroke, in proportions of window size
43  *         This assumes that the bottom-left corner is (0,0)
44  */
45 typedef struct bGPDspoint {
46         float x, y, z;                  /* co-ordinates of point (usually 2d, but can be 3d as well) */
47         float pressure;                 /* pressure of input device (from 0 to 1) at this point */
48         float strength;                 /* color strength (used for alpha factor) */
49         float time;                             /* seconds since start of stroke */
50         int flag;                               /* additional options (NOTE: can shrink this field down later if needed) */
51 } bGPDspoint;
52
53 /* bGPDspoint->flag */
54 typedef enum eGPDspoint_Flag {
55         /* stroke point is selected (for editing) */
56         GP_SPOINT_SELECT        = (1 << 0),
57         
58         /* stroke point is tagged (for some editing operation) */
59         GP_SPOINT_TAG       = (1 << 1),
60 } eGPSPoint_Flag;
61
62 /* Grease-Pencil Annotations - 'Triangle'
63  *      -> A triangle contains the index of three vertices for filling the stroke
64  *         This is only used if high quality fill is enabled
65  */
66 typedef struct bGPDtriangle {
67         int v1, v2, v3;         /* indices for tesselated triangle used for GP Fill */
68 } bGPDtriangle;
69
70 /* GP brush (used for new strokes) */
71 typedef struct bGPDbrush {
72         struct bGPDbrush *next, *prev;
73
74         char info[64];            /* Brush name. Must be unique. */
75         short thickness;          /* thickness to apply to strokes */
76         short flag;
77         float draw_smoothfac;     /* amount of smoothing to apply to newly created strokes */
78         short draw_smoothlvl;     /* number of times to apply smooth factor to new strokes */
79         short sublevel;           /* number of times to subdivide new strokes */
80
81         float draw_sensitivity;   /* amount of sensivity to apply to newly created strokes */
82         float draw_strength;      /* amount of alpha strength to apply to newly created strokes */
83         float draw_jitter;        /* amount of jitter to apply to newly created strokes */
84         float draw_angle;         /* angle when the brush has full thickness */
85         float draw_angle_factor;  /* factor to apply when angle change (only 90 degrees) */
86         float draw_random_press;  /* factor of randomness for sensitivity and strength */
87         float draw_random_sub;    /* factor of randomness for subdivision */
88         struct CurveMapping *cur_sensitivity;
89         struct CurveMapping *cur_strength;
90         struct CurveMapping *cur_jitter;
91 } bGPDbrush;
92
93 /* bGPDbrush->flag */
94 typedef enum eGPDbrush_Flag {
95         /* brush is active */
96         GP_BRUSH_ACTIVE = (1 << 0),
97         /* brush use pressure */
98         GP_BRUSH_USE_PRESSURE = (1 << 1),
99         /* brush use pressure for alpha factor */
100         GP_BRUSH_USE_STENGTH_PRESSURE = (1 << 2),
101         /* brush use pressure for alpha factor */
102         GP_BRUSH_USE_JITTER_PRESSURE = (1 << 3),
103         /* brush use random for pressure */
104         GP_BRUSH_USE_RANDOM_PRESSURE = (1 << 4),
105         /* brush use random for strength */
106         GP_BRUSH_USE_RANDOM_STRENGTH = (1 << 5)
107 } eGPDbrush_Flag;
108
109 /* color of palettes */
110 typedef struct bGPDpalettecolor {
111         struct bGPDpalettecolor *next, *prev;
112         char info[64];           /* Color name. Must be unique. */
113         float color[4];
114         float fill[4];           /* color that should be used for drawing "fills" for strokes */
115         short flag;              /* settings for palette color */
116         char  pad[6];            /* padding for compiler alignment error */
117 } bGPDpalettecolor;
118
119 /* bGPDpalettecolor->flag */
120 typedef enum eGPDpalettecolor_Flag {
121         /* color is active */
122         PC_COLOR_ACTIVE = (1 << 0),
123         /* don't display color */
124         PC_COLOR_HIDE = (1 << 1),
125         /* protected from further editing */
126         PC_COLOR_LOCKED = (1 << 2),
127         /* do onion skinning */
128         PC_COLOR_ONIONSKIN = (1 << 3),
129         /* "volumetric" strokes */
130         PC_COLOR_VOLUMETRIC = (1 << 4),
131         /* Use High quality fill */
132         PC_COLOR_HQ_FILL = (1 << 5)
133 } eGPDpalettecolor_Flag;
134
135 /* palette of colors */
136 typedef struct bGPDpalette {
137         struct bGPDpalette *next, *prev;
138
139         /* pointer to individual colours */
140         ListBase colors;
141         char info[64];          /* Palette name. Must be unique. */
142
143         short flag;
144         char pad[6];            /* padding for compiler alignment error */
145 } bGPDpalette;
146
147 /* bGPDpalette->flag */
148 typedef enum eGPDpalette_Flag {
149         /* palette is active */
150         PL_PALETTE_ACTIVE = (1 << 0)
151 } eGPDpalette_Flag;
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;/* tesselated 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         /* The pointer to color is only used during drawing, but not saved 
170          * colorname is the join with the palette, but when draw, the pointer is update if the value is NULL
171          * to speed up the drawing
172          */
173         char colorname[128];    /* color name */
174         bGPDpalettecolor *palcolor; /* current palette color */
175         /* temporary layer name only used during copy/paste to put the stroke in the original layer */
176         char tmp_layerinfo[128];
177 } bGPDstroke;
178
179 /* bGPDstroke->flag */
180 typedef enum eGPDstroke_Flag {
181         /* stroke is in 3d-space */
182         GP_STROKE_3DSPACE               = (1 << 0),
183         /* stroke is in 2d-space */
184         GP_STROKE_2DSPACE               = (1 << 1),
185         /* stroke is in 2d-space (but with special 'image' scaling) */
186         GP_STROKE_2DIMAGE               = (1 << 2),
187         /* stroke is selected */
188         GP_STROKE_SELECT                = (1 << 3),
189         /* Recalculate triangulation for high quality fill (when true, force a new recalc) */
190         GP_STROKE_RECALC_CACHES = (1 << 4),
191         /* Recalculate the color pointer using the name as index (true force a new recalc) */
192         GP_STROKE_RECALC_COLOR = (1 << 5),
193         /* Flag used to indicate that stroke is closed and draw edge between last and first point */
194         GP_STROKE_CYCLIC = (1 << 7),
195         /* only for use with stroke-buffer (while drawing eraser) */
196         GP_STROKE_ERASER                = (1 << 15)
197 } eGPDstroke_Flag;
198
199 /* Grease-Pencil Annotations - 'Frame'
200  *      -> Acts as storage for the 'image' formed by strokes
201  */
202 typedef struct bGPDframe {
203         struct bGPDframe *next, *prev;
204         
205         ListBase strokes;       /* list of the simplified 'strokes' that make up the frame's data */
206         
207         int framenum;           /* frame number of this frame */
208         
209         short flag;                     /* temp settings */
210         short key_type;         /* keyframe type (eBezTriple_KeyframeType) */
211 } bGPDframe;
212
213 /* bGPDframe->flag */
214 typedef enum eGPDframe_Flag {
215         /* frame is being painted on */
216         GP_FRAME_PAINT          = (1 << 0),
217         /* for editing in Action Editor */
218         GP_FRAME_SELECT         = (1 << 1)
219 } eGPDframe_Flag;
220
221 /* Grease-Pencil Annotations - 'Layer' */
222 typedef struct bGPDlayer {
223         struct bGPDlayer *next, *prev;
224         
225         ListBase frames;                /* list of annotations to display for frames (bGPDframe list) */
226         bGPDframe *actframe;    /* active frame (should be the frame that is currently being displayed) */
227         
228         short flag;                             /* settings for layer */
229         short thickness;                /* current thickness to apply to strokes */
230         
231         short gstep;                    /* Ghosts Before: max number of ghost frames to show between active frame and the one before it (0 = only the ghost itself) */
232         short gstep_next;               /* Ghosts After:  max number of ghost frames to show after active frame and the following it    (0 = only the ghost itself) */
233         
234         float gcolor_prev[3];   /* optional color for ghosts before the active frame */
235         float gcolor_next[3];   /* optional color for ghosts after the active frame */
236         
237         float color[4];                 /* Color for strokes in layers (replaced by palettecolor). Only used for ruler (which uses GPencil internally) */
238         float fill[4];                  /* Fill color for strokes in layers.  Not used and replaced by palettecolor fill */
239         
240         char info[128];                 /* optional reference info about this layer (i.e. "director's comments, 12/3")
241                                                          * this is used for the name of the layer  too and kept unique. */
242         
243         struct Object *parent;  /* parent object */
244         float inverse[4][4];    /* inverse matrix (only used if parented) */
245         char parsubstr[64];     /* String describing subobject info, MAX_ID_NAME-2 */
246         short partype, pad;
247         
248         float tintcolor[4];     /* Color used to tint layer, alpha value is used as factor */
249         float opacity;          /* Opacity of the layer */
250 } bGPDlayer;
251
252 /* bGPDlayer->flag */
253 typedef enum eGPDlayer_Flag {
254         /* don't display layer */
255         GP_LAYER_HIDE                   = (1 << 0),
256         /* protected from further editing */
257         GP_LAYER_LOCKED                 = (1 << 1),
258         /* layer is 'active' layer being edited */
259         GP_LAYER_ACTIVE                 = (1 << 2),
260         /* draw points of stroke for debugging purposes */
261         GP_LAYER_DRAWDEBUG              = (1 << 3),
262         /* do onion skinning */
263         GP_LAYER_ONIONSKIN              = (1 << 4),
264         /* for editing in Action Editor */
265         GP_LAYER_SELECT                 = (1 << 5),
266         /* current frame for layer can't be changed */
267         GP_LAYER_FRAMELOCK              = (1 << 6),
268         /* don't render xray (which is default) */
269         GP_LAYER_NO_XRAY                = (1 << 7),
270         /* use custom color for ghosts before current frame */
271         GP_LAYER_GHOST_PREVCOL  = (1 << 8),
272         /* use custom color for ghosts after current frame */
273         GP_LAYER_GHOST_NEXTCOL  = (1 << 9),
274         /* "volumetric" strokes */
275         GP_LAYER_VOLUMETRIC             = (1 << 10),
276         /* Use high quality fill (instead of buggy legacy OpenGL Fill) */
277         GP_LAYER_HQ_FILL        = (1 << 11),
278         /* Unlock color */
279         GP_LAYER_UNLOCK_COLOR   = (1 << 12),
280         /* always show onion skins (i.e. even during renders/animation playback) */
281         GP_LAYER_GHOST_ALWAYS   = (1 << 13),
282 } eGPDlayer_Flag;
283
284 /* Grease-Pencil Annotations - 'DataBlock' */
285 typedef struct bGPdata {
286         ID id;                                  /* Grease Pencil data is a datablock */
287         struct AnimData *adt;   /* animation data - for animating draw settings */
288         
289         /* saved Grease-Pencil data */
290         ListBase layers;                /* bGPDlayers */
291         int flag;                               /* settings for this datablock */
292
293         /* not-saved stroke buffer data (only used during paint-session) 
294          *      - buffer must be initialized before use, but freed after 
295          *        whole paint operation is over
296          */
297         short sbuffer_size;                     /* number of elements currently in cache */
298         short sbuffer_sflag;            /* flags for stroke that cache represents */
299         void *sbuffer;                          /* stroke buffer (can hold GP_STROKE_BUFFER_MAX) */
300         float scolor[4];            /* buffer color using palettes */
301         float sfill[4];             /* buffer fill color */
302         char  pad[6];               /* padding for compiler alignment error */
303         short sflag;                /* settings for palette color */
304
305         /* saved palettes */
306         ListBase palettes;
307 } bGPdata;
308
309 /* bGPdata->flag */
310 /* NOTE: A few flags have been deprecated since early 2.5,
311  *       since they have been made redundant by interaction
312  *       changes made during the porting process.
313  */
314 typedef enum eGPdata_Flag {
315         /* don't allow painting to occur at all */
316         /* GP_DATA_LMBPLOCK  = (1 << 0), */
317         
318         /* show debugging info in viewport (i.e. status print) */
319         GP_DATA_DISPINFO        = (1 << 1),
320         /* in Action Editor, show as expanded channel */
321         GP_DATA_EXPAND          = (1 << 2),
322         
323         /* is the block overriding all clicks? */
324         /* GP_DATA_EDITPAINT = (1 << 3), */
325         
326 /* ------------------------------------------------ DEPRECATED */
327         /* new strokes are added in viewport space */
328         GP_DATA_VIEWALIGN       = (1 << 4),
329         
330         /* Project into the screen's Z values */
331         GP_DATA_DEPTH_VIEW      = (1 << 5),
332         GP_DATA_DEPTH_STROKE = (1 << 6),
333
334         GP_DATA_DEPTH_STROKE_ENDPOINTS = (1 << 7),
335 /* ------------------------------------------------ DEPRECATED */
336         
337         /* Stroke Editing Mode - Toggle to enable alternative keymap for easier editing of stroke points */
338         GP_DATA_STROKE_EDITMODE = (1 << 8),
339         
340         /* Convenience/cache flag to make it easier to quickly toggle onion skinning on/off */
341         GP_DATA_SHOW_ONIONSKINS = (1 << 9),
342         /* Draw a green and red point to indicate start and end of the stroke */
343         GP_DATA_SHOW_DIRECTION = (1 << 10)
344 } eGPdata_Flag;
345
346 #endif /*  __DNA_GPENCIL_TYPES_H__ */