Tool System: don't unlink tools when changing workspaces
[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
18  * \ingroup DNA
19  */
20
21 #ifndef __DNA_GPENCIL_MODIFIER_TYPES_H__
22 #define __DNA_GPENCIL_MODIFIER_TYPES_H__
23
24 #include "DNA_defs.h"
25 #include "DNA_listBase.h"
26
27 /* WARNING ALERT! TYPEDEF VALUES ARE WRITTEN IN FILES! SO DO NOT CHANGE!
28  * (ONLY ADD NEW ITEMS AT THE END)
29  */
30
31 struct RNG;
32
33 typedef enum GpencilModifierType {
34   eGpencilModifierType_None = 0,
35   eGpencilModifierType_Noise = 1,
36   eGpencilModifierType_Subdiv = 2,
37   eGpencilModifierType_Thick = 3,
38   eGpencilModifierType_Tint = 4,
39   eGpencilModifierType_Array = 5,
40   eGpencilModifierType_Build = 6,
41   eGpencilModifierType_Opacity = 7,
42   eGpencilModifierType_Color = 8,
43   eGpencilModifierType_Lattice = 9,
44   eGpencilModifierType_Simplify = 10,
45   eGpencilModifierType_Smooth = 11,
46   eGpencilModifierType_Hook = 12,
47   eGpencilModifierType_Offset = 13,
48   eGpencilModifierType_Mirror = 14,
49   eGpencilModifierType_Armature = 15,
50   eGpencilModifierType_Time = 16,
51   NUM_GREASEPENCIL_MODIFIER_TYPES,
52 } GpencilModifierType;
53
54 typedef enum GpencilModifierMode {
55   eGpencilModifierMode_Realtime = (1 << 0),
56   eGpencilModifierMode_Render = (1 << 1),
57   eGpencilModifierMode_Editmode = (1 << 2),
58   eGpencilModifierMode_Expanded = (1 << 3),
59 } GpencilModifierMode;
60
61 typedef enum {
62   /* This modifier has been inserted in local override, and hence can be fully edited. */
63   eGpencilModifierFlag_OverrideLibrary_Local = (1 << 0),
64 } GpencilModifierFlag;
65
66 typedef struct GpencilModifierData {
67   struct GpencilModifierData *next, *prev;
68
69   int type, mode;
70   int stackindex;
71   short flag;
72   short _pad;
73   /** MAX_NAME. */
74   char name[64];
75
76   char *error;
77 } GpencilModifierData;
78
79 typedef struct NoiseGpencilModifierData {
80   GpencilModifierData modifier;
81   /** Layer name. */
82   char layername[64];
83   /** Optional vertexgroup name, MAX_VGROUP_NAME. */
84   char vgname[64];
85   /** Custom index for passes. */
86   int pass_index;
87   /** Several flags. */
88   int flag;
89   /** Factor of noise. */
90   float factor;
91   /** How many frames before recalculate randoms. */
92   int step;
93   /** Last gp frame used. */
94   int gp_frame;
95   /** Last scene frame used. */
96   int scene_frame;
97   /** Random values. */
98   float vrand1, vrand2;
99   struct RNG *rng;
100   /** Custom index for passes. */
101   int layer_pass;
102   char _pad[4];
103 } NoiseGpencilModifierData;
104
105 typedef enum eNoiseGpencil_Flag {
106   GP_NOISE_USE_RANDOM = (1 << 0),
107   GP_NOISE_MOD_LOCATION = (1 << 1),
108   GP_NOISE_MOD_STRENGTH = (1 << 2),
109   GP_NOISE_MOD_THICKNESS = (1 << 3),
110   GP_NOISE_FULL_STROKE = (1 << 4),
111   GP_NOISE_MOVE_EXTREME = (1 << 5),
112   GP_NOISE_INVERT_LAYER = (1 << 6),
113   GP_NOISE_INVERT_PASS = (1 << 7),
114   GP_NOISE_INVERT_VGROUP = (1 << 8),
115   GP_NOISE_MOD_UV = (1 << 9),
116   GP_NOISE_INVERT_LAYERPASS = (1 << 10),
117 } eNoiseGpencil_Flag;
118
119 typedef struct SubdivGpencilModifierData {
120   GpencilModifierData modifier;
121   /** Layer name. */
122   char layername[64];
123   /** Custom index for passes. */
124   int pass_index;
125   /** Flags. */
126   int flag;
127   /** Factor of subdivision. */
128   int level;
129   /** Custom index for passes. */
130   int layer_pass;
131 } SubdivGpencilModifierData;
132
133 typedef enum eSubdivGpencil_Flag {
134   GP_SUBDIV_SIMPLE = (1 << 0),
135   GP_SUBDIV_INVERT_LAYER = (1 << 1),
136   GP_SUBDIV_INVERT_PASS = (1 << 2),
137   GP_SUBDIV_INVERT_LAYERPASS = (1 << 3),
138 } eSubdivGpencil_Flag;
139
140 typedef struct ThickGpencilModifierData {
141   GpencilModifierData modifier;
142   /** Layer name. */
143   char layername[64];
144   /** Optional vertexgroup name, MAX_VGROUP_NAME. */
145   char vgname[64];
146   /** Custom index for passes. */
147   int pass_index;
148   /** Flags. */
149   int flag;
150   /** Thickness change. */
151   int thickness;
152   /** Custom index for passes. */
153   int layer_pass;
154   struct CurveMapping *curve_thickness;
155 } ThickGpencilModifierData;
156
157 typedef enum eThickGpencil_Flag {
158   GP_THICK_INVERT_LAYER = (1 << 0),
159   GP_THICK_INVERT_PASS = (1 << 1),
160   GP_THICK_INVERT_VGROUP = (1 << 2),
161   GP_THICK_CUSTOM_CURVE = (1 << 3),
162   GP_THICK_NORMALIZE = (1 << 4),
163   GP_THICK_INVERT_LAYERPASS = (1 << 5),
164 } eThickGpencil_Flag;
165
166 typedef struct TimeGpencilModifierData {
167   GpencilModifierData modifier;
168   /** Layer name. */
169   char layername[64];
170   /** Custom index for passes. */
171   int layer_pass;
172   /** Flags. */
173   int flag;
174   int offset;
175   /** Animation scale. */
176   float frame_scale;
177   int mode;
178   /** Start and end frame for custom range. */
179   int sfra, efra;
180   char _pad[4];
181 } TimeGpencilModifierData;
182
183 typedef enum eTimeGpencil_Flag {
184   GP_TIME_INVERT_LAYER = (1 << 0),
185   GP_TIME_KEEP_LOOP = (1 << 1),
186   GP_TIME_INVERT_LAYERPASS = (1 << 2),
187   GP_TIME_CUSTOM_RANGE = (1 << 3),
188 } eTimeGpencil_Flag;
189
190 typedef enum eTimeGpencil_Mode {
191   GP_TIME_MODE_NORMAL = 0,
192   GP_TIME_MODE_REVERSE = 1,
193   GP_TIME_MODE_FIX = 2,
194 } eTimeGpencil_Mode;
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__ */