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