GP: Cleanup pad to _pad
[blender.git] / source / blender / makesdna / DNA_gpencil_modifier_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  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file DNA_gpencil_modifier_types.h
22  *  \ingroup DNA
23  */
24
25 #ifndef __DNA_GPENCIL_MODIFIER_TYPES_H__
26 #define __DNA_GPENCIL_MODIFIER_TYPES_H__
27
28 #include "DNA_defs.h"
29 #include "DNA_listBase.h"
30
31 /* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE!
32  * (ONLY ADD NEW ITEMS AT THE END)
33  */
34
35 struct RNG;
36
37 typedef enum GpencilModifierType {
38         eGpencilModifierType_None      = 0,
39         eGpencilModifierType_Noise     = 1,
40         eGpencilModifierType_Subdiv    = 2,
41         eGpencilModifierType_Thick     = 3,
42         eGpencilModifierType_Tint      = 4,
43         eGpencilModifierType_Array     = 5,
44         eGpencilModifierType_Build     = 6,
45         eGpencilModifierType_Opacity   = 7,
46         eGpencilModifierType_Color     = 8,
47         eGpencilModifierType_Lattice   = 9,
48         eGpencilModifierType_Simplify  = 10,
49         eGpencilModifierType_Smooth    = 11,
50         eGpencilModifierType_Hook      = 12,
51         eGpencilModifierType_Offset    = 13,
52         eGpencilModifierType_Mirror    = 14,
53         eGpencilModifierType_Armature  = 15,
54         eGpencilModifierType_Time      = 16,
55         NUM_GREASEPENCIL_MODIFIER_TYPES
56 } GpencilModifierType;
57
58 typedef enum GpencilModifierMode {
59         eGpencilModifierMode_Realtime          = (1 << 0),
60         eGpencilModifierMode_Render            = (1 << 1),
61         eGpencilModifierMode_Editmode          = (1 << 2),
62         eGpencilModifierMode_Expanded          = (1 << 3),
63 } GpencilModifierMode;
64
65 typedef enum {
66         /* This modifier has been inserted in local override, and hence can be fully edited. */
67         eGpencilModifierFlag_StaticOverride_Local = (1 << 0),
68 } GpencilModifierFlag;
69
70 typedef struct GpencilModifierData {
71         struct GpencilModifierData *next, *prev;
72
73         int type, mode;
74         int stackindex;
75         short flag;
76         short _pad;
77         char name[64];  /* MAX_NAME */
78
79         char *error;
80 } GpencilModifierData;
81
82 typedef struct NoiseGpencilModifierData {
83         GpencilModifierData modifier;
84         char layername[64];          /* layer name */
85         char vgname[64];             /* optional vertexgroup name, MAX_VGROUP_NAME */
86         int pass_index;               /* custom index for passes */
87         int flag;                    /* several flags */
88         float factor;                /* factor of noise */
89         int step;                    /* how many frames before recalculate randoms */
90         int gp_frame;                /* last gp frame used */
91         int scene_frame;             /* last scene frame used */
92         float vrand1, vrand2;        /* random values */
93         struct RNG *rng;
94         int layer_pass;              /* custom index for passes */
95         char _pad[4];
96 } NoiseGpencilModifierData;
97
98 typedef enum eNoiseGpencil_Flag {
99         GP_NOISE_USE_RANDOM     = (1 << 0),
100         GP_NOISE_MOD_LOCATION   = (1 << 1),
101         GP_NOISE_MOD_STRENGTH   = (1 << 2),
102         GP_NOISE_MOD_THICKNESS  = (1 << 3),
103         GP_NOISE_FULL_STROKE    = (1 << 4),
104         GP_NOISE_MOVE_EXTREME   = (1 << 5),
105         GP_NOISE_INVERT_LAYER   = (1 << 6),
106         GP_NOISE_INVERT_PASS    = (1 << 7),
107         GP_NOISE_INVERT_VGROUP  = (1 << 8),
108         GP_NOISE_MOD_UV         = (1 << 9),
109         GP_NOISE_INVERT_LAYERPASS = (1 << 10),
110 } eNoiseGpencil_Flag;
111
112 typedef struct SubdivGpencilModifierData {
113         GpencilModifierData modifier;
114         char layername[64];          /* layer name */
115         int pass_index;               /* custom index for passes */
116         int flag;                    /* flags */
117         int level;                   /* factor of subdivision */
118         int layer_pass;              /* custom index for passes */
119 } SubdivGpencilModifierData;
120
121 typedef enum eSubdivGpencil_Flag {
122         GP_SUBDIV_SIMPLE        = (1 << 0),
123         GP_SUBDIV_INVERT_LAYER  = (1 << 1),
124         GP_SUBDIV_INVERT_PASS   = (1 << 2),
125         GP_SUBDIV_INVERT_LAYERPASS = (1 << 3),
126 } eSubdivGpencil_Flag;
127
128 typedef struct ThickGpencilModifierData {
129         GpencilModifierData modifier;
130         char layername[64];          /* layer name */
131         char vgname[64];             /* optional vertexgroup name, MAX_VGROUP_NAME */
132         int pass_index;               /* custom index for passes */
133         int flag;                    /* flags */
134         int thickness;               /* Thickness change */
135         int layer_pass;              /* custom index for passes */
136         struct CurveMapping *curve_thickness;
137 } ThickGpencilModifierData;
138
139 typedef enum eThickGpencil_Flag {
140         GP_THICK_INVERT_LAYER   = (1 << 0),
141         GP_THICK_INVERT_PASS    = (1 << 1),
142         GP_THICK_INVERT_VGROUP  = (1 << 2),
143         GP_THICK_CUSTOM_CURVE   = (1 << 3),
144         GP_THICK_NORMALIZE      = (1 << 4),
145         GP_THICK_INVERT_LAYERPASS = (1 << 5),
146 } eThickGpencil_Flag;
147
148 typedef struct TimeGpencilModifierData {
149         GpencilModifierData modifier;
150         char layername[64];          /* layer name */
151         int layer_pass;               /* custom index for passes */
152         int flag;                    /* flags */
153         int offset;
154         float frame_scale;           /* animation scale */
155         int mode;
156         int sfra, efra;             /* start and end frame for custom range */
157         char _pad[4];
158 } TimeGpencilModifierData;
159
160 typedef enum eTimeGpencil_Flag {
161         GP_TIME_INVERT_LAYER      = (1 << 0),
162         GP_TIME_KEEP_LOOP         = (1 << 1),
163         GP_TIME_INVERT_LAYERPASS  = (1 << 2),
164         GP_TIME_CUSTOM_RANGE      = (1 << 3),
165 } eTimeGpencil_Flag;
166
167 typedef enum eTimeGpencil_Mode {
168         GP_TIME_MODE_NORMAL  = 0,
169         GP_TIME_MODE_REVERSE = 1,
170         GP_TIME_MODE_FIX     = 2
171 } eTimeGpencil_Mode;
172
173
174 typedef enum eModifyColorGpencil_Flag {
175         GP_MODIFY_COLOR_BOTH = 0,
176         GP_MODIFY_COLOR_STROKE = 1,
177         GP_MODIFY_COLOR_FILL = 2
178 } eModifyColorGpencil_Flag;
179
180 typedef struct TintGpencilModifierData {
181         GpencilModifierData modifier;
182         char layername[64];          /* layer name */
183         int pass_index;               /* custom index for passes */
184         int flag;                    /* flags */
185         float rgb[3];                /* Tint color */
186         float factor;                /* Mix factor */
187         char modify_color;           /* modify stroke, fill or both */
188         char _pad[7];
189         int layer_pass;              /* custom index for passes */
190         char _pad1[4];
191 } TintGpencilModifierData;
192
193 typedef enum eTintGpencil_Flag {
194         GP_TINT_CREATE_COLORS  = (1 << 0),
195         GP_TINT_INVERT_LAYER   = (1 << 1),
196         GP_TINT_INVERT_PASS    = (1 << 2),
197         GP_TINT_INVERT_LAYERPASS = (1 << 3),
198 } eTintGpencil_Flag;
199
200 typedef struct ColorGpencilModifierData {
201         GpencilModifierData modifier;
202         char layername[64];          /* layer name */
203         int pass_index;               /* custom index for passes */
204         int flag;                    /* flags */
205         float hsv[3];                /* hsv factors */
206         char modify_color;           /* modify stroke, fill or both */
207         char _pad[3];
208         int layer_pass;              /* custom index for passes */
209         char _pad1[4];
210 } ColorGpencilModifierData;
211
212 typedef enum eColorGpencil_Flag {
213         GP_COLOR_CREATE_COLORS  = (1 << 0),
214         GP_COLOR_INVERT_LAYER   = (1 << 1),
215         GP_COLOR_INVERT_PASS    = (1 << 2),
216         GP_COLOR_INVERT_LAYERPASS = (1 << 3),
217 } eColorGpencil_Flag;
218
219 typedef struct OpacityGpencilModifierData {
220         GpencilModifierData modifier;
221         char layername[64];          /* layer name */
222         char vgname[64];             /* optional vertexgroup name, MAX_VGROUP_NAME */
223         int pass_index;               /* custom index for passes */
224         int flag;                    /* flags */
225         float factor;                /* Main Opacity factor */
226         char modify_color;                    /* modify stroke, fill or both */
227         char _pad[3];
228         int layer_pass;              /* custom index for passes */
229         char _pad1[4];
230 } OpacityGpencilModifierData;
231
232 typedef enum eOpacityGpencil_Flag {
233         GP_OPACITY_INVERT_LAYER  = (1 << 0),
234         GP_OPACITY_INVERT_PASS   = (1 << 1),
235         GP_OPACITY_INVERT_VGROUP = (1 << 2),
236         GP_OPACITY_CREATE_COLORS = (1 << 3),
237         GP_OPACITY_INVERT_LAYERPASS = (1 << 4),
238 } eOpacityGpencil_Flag;
239
240 typedef struct ArrayGpencilModifierData {
241         GpencilModifierData modifier;
242         struct Object *object;
243         int count;                   /* number of elements in array */
244         int flag;                    /* several flags */
245         float offset[3];             /* Location increments */
246         float shift[3];              /* shift increment */
247         float rnd_size;              /* random size factor */
248         float rnd_rot;               /* random size factor */
249         float rot[3];                /* Rotation changes */
250         float scale[3];              /* Scale changes */
251         float rnd[20];               /* (first element is the index) random values */
252         char _pad[4];
253
254         int pass_index;              /* custom index for passes */
255         char layername[64];          /* layer name */
256         int mat_rpl;                 /* material replace (0 keep default) */
257         int layer_pass;              /* custom index for passes */
258 } ArrayGpencilModifierData;
259
260 typedef enum eArrayGpencil_Flag {
261         GP_ARRAY_RANDOM_SIZE   = (1 << 0),
262         GP_ARRAY_RANDOM_ROT    = (1 << 1),
263         GP_ARRAY_INVERT_LAYER  = (1 << 2),
264         GP_ARRAY_INVERT_PASS   = (1 << 3),
265         GP_ARRAY_KEEP_ONTOP    = (1 << 4),
266         GP_ARRAY_INVERT_LAYERPASS = (1 << 5),
267 } eArrayGpencil_Flag;
268
269 typedef struct BuildGpencilModifierData {
270         GpencilModifierData modifier;
271
272         char layername[64];   /* if set, restrict modifier to operating on this layer */
273         int pass_index;
274
275         int layer_pass;       /* custom index for passes */
276
277         float start_frame;    /* If GP_BUILD_RESTRICT_TIME is set, the defines the frame range where GP frames are considered */
278         float end_frame;
279
280         float start_delay;    /* For each pair of gp keys, number of frames before strokes start appearing */
281         float length;         /* For each pair of gp keys, number of frames that build effect must be completed within */
282
283         short flag;           /* (eGpencilBuild_Flag) Options for controlling modifier behavior */
284
285         short mode;           /* (eGpencilBuild_Mode) How are strokes ordered */
286         short transition;     /* (eGpencilBuild_Transition) In what order do stroke points appear/disappear */
287
288         short time_alignment; /* (eGpencilBuild_TimeAlignment) For the "Concurrent" mode, when should "shorter" strips start/end */
289 } BuildGpencilModifierData;
290
291 typedef enum eBuildGpencil_Mode {
292         /* Strokes are shown one by one until all have appeared */
293         GP_BUILD_MODE_SEQUENTIAL = 0,
294         /* All strokes start at the same time */
295         GP_BUILD_MODE_CONCURRENT = 1,
296 } eBuildGpencil_Mode;
297
298 typedef enum eBuildGpencil_Transition {
299         /* Show in forward order */
300         GP_BUILD_TRANSITION_GROW    = 0,
301         /* Hide in reverse order */
302         GP_BUILD_TRANSITION_SHRINK  = 1,
303         /* Hide in forward order */
304         GP_BUILD_TRANSITION_FADE    = 2,
305 } eBuildGpencil_Transition;
306
307 typedef enum eBuildGpencil_TimeAlignment {
308         /* All strokes start at same time */
309         GP_BUILD_TIMEALIGN_START = 0,
310         /* All strokes end at same time */
311         GP_BUILD_TIMEALIGN_END   = 1,
312
313         /* TODO: Random Offsets, Stretch-to-Fill */
314 } eBuildGpencil_TimeAlignment;
315
316 typedef enum eBuildGpencil_Flag {
317         /* Restrict modifier to particular layer/passes? */
318         GP_BUILD_INVERT_LAYER  = (1 << 0),
319         GP_BUILD_INVERT_PASS   = (1 << 1),
320
321         /* Restrict modifier to only operating between the nominated frames */
322         GP_BUILD_RESTRICT_TIME  = (1 << 2),
323         GP_BUILD_INVERT_LAYERPASS = (1 << 3),
324 } eBuildGpencil_Flag;
325
326 typedef struct LatticeGpencilModifierData {
327         GpencilModifierData modifier;
328         struct Object *object;
329         char layername[64];          /* layer name */
330         char vgname[64];             /* optional vertexgroup name, MAX_VGROUP_NAME */
331         int pass_index;               /* custom index for passes */
332         int flag;                    /* flags */
333         float strength;
334         int layer_pass;              /* custom index for passes */
335         void *cache_data; /* runtime only (LatticeDeformData) */
336 } LatticeGpencilModifierData;
337
338 typedef enum eLatticeGpencil_Flag {
339         GP_LATTICE_INVERT_LAYER  = (1 << 0),
340         GP_LATTICE_INVERT_PASS   = (1 << 1),
341         GP_LATTICE_INVERT_VGROUP = (1 << 2),
342         GP_LATTICE_INVERT_LAYERPASS = (1 << 3),
343 } eLatticeGpencil_Flag;
344
345 typedef struct MirrorGpencilModifierData {
346         GpencilModifierData modifier;
347         struct Object *object;
348         char layername[64];          /* layer name */
349         int pass_index;              /* custom index for passes */
350         int flag;                    /* flags */
351         int layer_pass;              /* custom index for passes */
352         char _pad[4];
353 } MirrorGpencilModifierData;
354
355 typedef enum eMirrorGpencil_Flag {
356         GP_MIRROR_INVERT_LAYER  = (1 << 0),
357         GP_MIRROR_INVERT_PASS   = (1 << 1),
358         GP_MIRROR_CLIPPING      = (1 << 2),
359         GP_MIRROR_AXIS_X        = (1 << 3),
360         GP_MIRROR_AXIS_Y        = (1 << 4),
361         GP_MIRROR_AXIS_Z        = (1 << 5),
362         GP_MIRROR_INVERT_LAYERPASS = (1 << 6),
363 } eMirrorGpencil_Flag;
364
365 typedef struct HookGpencilModifierData {
366         GpencilModifierData modifier;
367
368         struct Object *object;
369         char subtarget[64];     /* optional name of bone target, MAX_ID_NAME-2 */
370         char layername[64];     /* layer name */
371         char vgname[64];        /* optional vertexgroup name, MAX_VGROUP_NAME */
372         int pass_index;         /* custom index for passes */
373         int layer_pass;              /* custom index for passes */
374         char _pad[4];
375
376         int flag;
377         char falloff_type;      /* use enums from WarpGpencilModifier (exact same functionality) */
378         char _pad1[3];
379         float parentinv[4][4];  /* matrix making current transform unmodified */
380         float cent[3];          /* visualization of hook */
381         float falloff;          /* if not zero, falloff is distance where influence zero */
382         float force;
383         struct CurveMapping *curfalloff;
384 } HookGpencilModifierData;
385
386 typedef enum eHookGpencil_Flag {
387         GP_HOOK_INVERT_LAYER  = (1 << 0),
388         GP_HOOK_INVERT_PASS   = (1 << 1),
389         GP_HOOK_INVERT_VGROUP = (1 << 2),
390         GP_HOOK_UNIFORM_SPACE = (1 << 3),
391         GP_HOOK_INVERT_LAYERPASS = (1 << 4),
392 } eHookGpencil_Flag;
393
394 typedef enum eHookGpencil_Falloff {
395         eGPHook_Falloff_None = 0,
396         eGPHook_Falloff_Curve = 1,
397         eGPHook_Falloff_Sharp = 2,
398         eGPHook_Falloff_Smooth = 3,
399         eGPHook_Falloff_Root = 4,
400         eGPHook_Falloff_Linear = 5,
401         eGPHook_Falloff_Const = 6,
402         eGPHook_Falloff_Sphere = 7,
403         eGPHook_Falloff_InvSquare = 8,
404 } eHookGpencil_Falloff;
405
406 typedef struct SimplifyGpencilModifierData {
407         GpencilModifierData modifier;
408         char layername[64];          /* layer name */
409         int pass_index;               /* custom index for passes */
410         int flag;                    /* flags */
411         float factor;                /* factor of simplify */
412         short mode;                  /* type of simplify */
413         short step;                  /* every n vertex to keep */
414         int layer_pass;              /* custom index for passes */
415         char _pad[4];
416 } SimplifyGpencilModifierData;
417
418 typedef enum eSimplifyGpencil_Flag {
419         GP_SIMPLIFY_INVERT_LAYER = (1 << 0),
420         GP_SIMPLIFY_INVERT_PASS  = (1 << 1),
421         GP_SIMPLIFY_INVERT_LAYERPASS = (1 << 2),
422 } eSimplifyGpencil_Flag;
423
424 typedef enum eSimplifyGpencil_Mode {
425         /* Keep only one vertex every n vertices */
426         GP_SIMPLIFY_FIXED = 0,
427         /* Use RDP algorithm */
428         GP_SIMPLIFY_ADAPTIVE = 1,
429 } eSimplifyGpencil_Mode;
430
431 typedef struct OffsetGpencilModifierData {
432         GpencilModifierData modifier;
433         char layername[64];          /* layer name */
434         char vgname[64];             /* optional vertexgroup name, MAX_VGROUP_NAME */
435         int pass_index;               /* custom index for passes */
436         int flag;                    /* flags */
437         float loc[3];
438         float rot[3];
439         float scale[3];
440         int layer_pass;              /* custom index for passes */
441 } OffsetGpencilModifierData;
442
443 typedef enum eOffsetGpencil_Flag {
444         GP_OFFSET_INVERT_LAYER  = (1 << 0),
445         GP_OFFSET_INVERT_PASS   = (1 << 1),
446         GP_OFFSET_INVERT_VGROUP = (1 << 2),
447         GP_OFFSET_INVERT_LAYERPASS = (1 << 3),
448 } eOffsetGpencil_Flag;
449
450 typedef struct SmoothGpencilModifierData {
451         GpencilModifierData modifier;
452         char layername[64];          /* layer name */
453         char vgname[64];             /* optional vertexgroup name, MAX_VGROUP_NAME */
454         int pass_index;              /* custom index for passes */
455         int flag;                    /* several flags */
456         float factor;                /* factor of noise */
457         int step;                    /* how many times apply smooth */
458         int layer_pass;              /* custom index for passes */
459         char _pad[4];
460 } SmoothGpencilModifierData;
461
462 typedef enum eSmoothGpencil_Flag {
463         GP_SMOOTH_MOD_LOCATION  = (1 << 0),
464         GP_SMOOTH_MOD_STRENGTH  = (1 << 1),
465         GP_SMOOTH_MOD_THICKNESS = (1 << 2),
466         GP_SMOOTH_INVERT_LAYER  = (1 << 3),
467         GP_SMOOTH_INVERT_PASS   = (1 << 4),
468         GP_SMOOTH_INVERT_VGROUP = (1 << 5),
469         GP_SMOOTH_MOD_UV         = (1 << 6),
470         GP_SMOOTH_INVERT_LAYERPASS = (1 << 7),
471 } eSmoothGpencil_Flag;
472
473 typedef struct ArmatureGpencilModifierData {
474         GpencilModifierData modifier;
475         short deformflag, multi;  /* deformflag replaces armature->deformflag */
476         int _pad;
477         struct Object *object;
478         float *prevCos;           /* stored input of previous modifier, for vertexgroup blending */
479         char vgname[64];         /* MAX_VGROUP_NAME */
480
481 } ArmatureGpencilModifierData;
482
483 #endif  /* __DNA_GPENCIL_MODIFIER_TYPES_H__ */