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