032cf01c57d89e9d40ed7ea98c8720a8afd9a1a0
[blender.git] / source / blender / makesrna / intern / rna_gpencil_modifier.c
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 blender/makesrna/intern/rna_gpencil_modifier.c
22  *  \ingroup RNA
23  */
24
25
26 #include <float.h>
27 #include <limits.h>
28 #include <stdlib.h>
29
30 #include "DNA_armature_types.h"
31 #include "DNA_cachefile_types.h"
32 #include "DNA_mesh_types.h"
33 #include "DNA_gpencil_modifier_types.h"
34 #include "DNA_object_types.h"
35 #include "DNA_object_force_types.h"
36 #include "DNA_scene_types.h"
37
38 #include "MEM_guardedalloc.h"
39
40 #include "BLI_math.h"
41
42 #include "BLT_translation.h"
43
44 #include "BKE_animsys.h"
45 #include "BKE_data_transfer.h"
46 #include "BKE_dynamicpaint.h"
47 #include "BKE_effect.h"
48 #include "BKE_mesh_mapping.h"
49 #include "BKE_mesh_remap.h"
50 #include "BKE_multires.h"
51 #include "BKE_smoke.h" /* For smokeModifier_free & smokeModifier_createType */
52
53 #include "RNA_access.h"
54 #include "RNA_define.h"
55 #include "RNA_enum_types.h"
56
57 #include "rna_internal.h"
58
59 #include "WM_api.h"
60 #include "WM_types.h"
61
62 const EnumPropertyItem rna_enum_object_greasepencil_modifier_type_items[] = {
63         {0, "", 0, N_("Generate"), "" },
64         {eGpencilModifierType_Instance, "GP_INSTANCE", ICON_MOD_ARRAY, "Instance", "Create grid of duplicate instances"},
65         {eGpencilModifierType_Build, "GP_BUILD", ICON_MOD_BUILD, "Build", "Create duplication of strokes"},
66         {eGpencilModifierType_Mirror, "GP_MIRROR", ICON_MOD_MIRROR, "Mirror", "Duplicate strokes like a mirror"},
67         {eGpencilModifierType_Simplify, "GP_SIMPLIFY", ICON_MOD_DECIM, "Simplify", "Simplify stroke reducing number of points"},
68         {eGpencilModifierType_Subdiv, "GP_SUBDIV", ICON_MOD_SUBSURF, "Subdivide", "Subdivide stroke adding more control points"},
69         {0, "", 0, N_("Deform"), "" },
70         {eGpencilModifierType_Armature, "GP_ARMATURE", ICON_MOD_ARMATURE, "Armature", "Deform stroke points using armature object"},
71         {eGpencilModifierType_Hook, "GP_HOOK", ICON_HOOK, "Hook", "Deform stroke points using objects"},
72         {eGpencilModifierType_Lattice, "GP_LATTICE", ICON_MOD_LATTICE, "Lattice", "Deform strokes using lattice"},
73         {eGpencilModifierType_Noise, "GP_NOISE", ICON_RNDCURVE, "Noise", "Add noise to strokes"},
74         {eGpencilModifierType_Offset, "GP_OFFSET", ICON_MOD_DISPLACE, "Offset", "Change stroke location, rotation or scale"},
75         {eGpencilModifierType_Smooth, "GP_SMOOTH", ICON_MOD_SMOOTH, "Smooth", "Smooth stroke"},
76         {eGpencilModifierType_Thick, "GP_THICK", ICON_MAN_ROT, "Thickness", "Change stroke thickness"},
77         {eGpencilModifierType_Time, "GP_TIME", ICON_MOD_DISPLACE, "Time", "Offset keyframes"},
78         {0, "", 0, N_("Color"), "" },
79         {eGpencilModifierType_Color, "GP_COLOR", ICON_GROUP_VCOL, "Hue/Saturation", "Apply changes to stroke colors"},
80         {eGpencilModifierType_Opacity, "GP_OPACITY", ICON_MOD_MASK, "Opacity", "Opacity of the strokes"},
81         {eGpencilModifierType_Tint, "GP_TINT", ICON_COLOR, "Tint", "Tint strokes with new color"},
82         {0, NULL, 0, NULL, NULL}
83 };
84
85 #ifndef RNA_RUNTIME
86 static const EnumPropertyItem modifier_modify_color_items[] = {
87         { GP_MODIFY_COLOR_BOTH, "BOTH", 0, "Both", "Modify fill and stroke colors" },
88         { GP_MODIFY_COLOR_STROKE, "STROKE", 0, "Stroke", "Modify stroke color only" },
89         { GP_MODIFY_COLOR_FILL, "FILL", 0, "Fill", "Modify fill color only" },
90         { 0, NULL, 0, NULL, NULL }
91 };
92
93 static const EnumPropertyItem modifier_gphook_falloff_items[] = {
94         { eGPHook_Falloff_None,    "NONE", 0, "No Falloff", "" },
95         { eGPHook_Falloff_Curve,   "CURVE", 0, "Curve", "" },
96         { eGPHook_Falloff_Smooth,  "SMOOTH", ICON_SMOOTHCURVE, "Smooth", "" },
97         { eGPHook_Falloff_Sphere,  "SPHERE", ICON_SPHERECURVE, "Sphere", "" },
98         { eGPHook_Falloff_Root,    "ROOT", ICON_ROOTCURVE, "Root", "" },
99         { eGPHook_Falloff_InvSquare, "INVERSE_SQUARE", ICON_ROOTCURVE, "Inverse Square", "" },
100         { eGPHook_Falloff_Sharp,   "SHARP", ICON_SHARPCURVE, "Sharp", "" },
101         { eGPHook_Falloff_Linear,  "LINEAR", ICON_LINCURVE, "Linear", "" },
102         { eGPHook_Falloff_Const,   "CONSTANT", ICON_NOCURVE, "Constant", "" },
103         { 0, NULL, 0, NULL, NULL }
104 };
105
106 static const EnumPropertyItem rna_enum_gpencil_lockshift_items[] = {
107         { GP_LOCKAXIS_X, "GP_LOCKAXIS_X", 0, "X", "Use X axis" },
108         { GP_LOCKAXIS_Y, "GP_LOCKAXIS_Y", 0, "Y", "Use Y axis" },
109         { GP_LOCKAXIS_Z, "GP_LOCKAXIS_Z", 0, "Z", "Use Z axis" },
110         { 0, NULL, 0, NULL, NULL }
111 };
112
113 #endif
114
115 #ifdef RNA_RUNTIME
116
117 #include "DNA_particle_types.h"
118 #include "DNA_curve_types.h"
119 #include "DNA_smoke_types.h"
120
121 #include "BKE_cachefile.h"
122 #include "BKE_context.h"
123 #include "BKE_library.h"
124 #include "BKE_gpencil_modifier.h"
125 #include "BKE_object.h"
126 #include "BKE_gpencil.h"
127
128 #include "DEG_depsgraph.h"
129 #include "DEG_depsgraph_build.h"
130
131 static StructRNA *rna_GpencilModifier_refine(struct PointerRNA *ptr)
132 {
133         GpencilModifierData *md = (GpencilModifierData *)ptr->data;
134
135         switch ((GpencilModifierType)md->type) {
136                 case eGpencilModifierType_Noise:
137                         return &RNA_NoiseGpencilModifier;
138                 case eGpencilModifierType_Subdiv:
139                         return &RNA_SubdivGpencilModifier;
140                 case eGpencilModifierType_Simplify:
141                         return &RNA_SimplifyGpencilModifier;
142                 case eGpencilModifierType_Thick:
143                         return &RNA_ThickGpencilModifier;
144                 case eGpencilModifierType_Tint:
145                         return &RNA_TintGpencilModifier;
146                 case eGpencilModifierType_Time:
147                         return &RNA_TimeGpencilModifier;
148                 case eGpencilModifierType_Color:
149                         return &RNA_ColorGpencilModifier;
150                 case eGpencilModifierType_Instance:
151                         return &RNA_InstanceGpencilModifier;
152                 case eGpencilModifierType_Build:
153                         return &RNA_BuildGpencilModifier;
154                 case eGpencilModifierType_Opacity:
155                         return &RNA_OpacityGpencilModifier;
156                 case eGpencilModifierType_Lattice:
157                         return &RNA_LatticeGpencilModifier;
158                 case eGpencilModifierType_Mirror:
159                         return &RNA_MirrorGpencilModifier;
160                 case eGpencilModifierType_Smooth:
161                         return &RNA_SmoothGpencilModifier;
162                 case eGpencilModifierType_Hook:
163                         return &RNA_HookGpencilModifier;
164                 case eGpencilModifierType_Offset:
165                         return &RNA_OffsetGpencilModifier;
166                 case eGpencilModifierType_Armature:
167                         return &RNA_ArmatureGpencilModifier;
168                         /* Default */
169                 case eGpencilModifierType_None:
170                 case NUM_GREASEPENCIL_MODIFIER_TYPES:
171                         return &RNA_GpencilModifier;
172         }
173
174         return &RNA_GpencilModifier;
175 }
176
177 static void rna_GpencilModifier_name_set(PointerRNA *ptr, const char *value)
178 {
179         GpencilModifierData *gmd = ptr->data;
180         char oldname[sizeof(gmd->name)];
181
182         /* make a copy of the old name first */
183         BLI_strncpy(oldname, gmd->name, sizeof(gmd->name));
184
185         /* copy the new name into the name slot */
186         BLI_strncpy_utf8(gmd->name, value, sizeof(gmd->name));
187
188         /* make sure the name is truly unique */
189         if (ptr->id.data) {
190                 Object *ob = ptr->id.data;
191                 BKE_gpencil_modifier_unique_name(&ob->greasepencil_modifiers, gmd);
192         }
193
194         /* fix all the animation data which may link to this */
195         BKE_animdata_fix_paths_rename_all(NULL, "grease_pencil_modifiers", oldname, gmd->name);
196 }
197
198 static char *rna_GpencilModifier_path(PointerRNA *ptr)
199 {
200         GpencilModifierData *gmd = ptr->data;
201         char name_esc[sizeof(gmd->name) * 2];
202
203         BLI_strescape(name_esc, gmd->name, sizeof(name_esc));
204         return BLI_sprintfN("grease_pencil_modifiers[\"%s\"]", name_esc);
205 }
206
207 static void rna_GpencilModifier_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
208 {
209         DEG_id_tag_update(ptr->id.data, OB_RECALC_DATA);
210         WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ptr->id.data);
211 }
212
213 static void rna_GpencilModifier_dependency_update(Main *bmain, Scene *scene, PointerRNA *ptr)
214 {
215         rna_GpencilModifier_update(bmain, scene, ptr);
216         DEG_relations_tag_update(bmain);
217 }
218
219 /* Vertex Groups */
220
221 #define RNA_GP_MOD_VGROUP_NAME_SET(_type, _prop)                                               \
222 static void rna_##_type##GpencilModifier_##_prop##_set(PointerRNA *ptr, const char *value)         \
223 {                                                                                           \
224         _type##GpencilModifierData *tmd = (_type##GpencilModifierData *)ptr->data;                            \
225         rna_object_vgroup_name_set(ptr, value, tmd->_prop, sizeof(tmd->_prop));                 \
226 }
227
228 RNA_GP_MOD_VGROUP_NAME_SET(Noise, vgname);
229 RNA_GP_MOD_VGROUP_NAME_SET(Thick, vgname);
230 RNA_GP_MOD_VGROUP_NAME_SET(Opacity, vgname);
231 RNA_GP_MOD_VGROUP_NAME_SET(Lattice, vgname);
232 RNA_GP_MOD_VGROUP_NAME_SET(Smooth, vgname);
233 RNA_GP_MOD_VGROUP_NAME_SET(Hook, vgname);
234 RNA_GP_MOD_VGROUP_NAME_SET(Offset, vgname);
235 RNA_GP_MOD_VGROUP_NAME_SET(Armature, vgname);
236
237 #undef RNA_GP_MOD_VGROUP_NAME_SET
238
239 /* Objects */
240
241 static void greasepencil_modifier_object_set(Object *self, Object **ob_p, int type, PointerRNA value)
242 {
243         Object *ob = value.data;
244
245         if (!self || ob != self) {
246                 if (!ob || type == OB_EMPTY || ob->type == type) {
247                         id_lib_extern((ID *)ob);
248                         *ob_p = ob;
249                 }
250         }
251 }
252
253 #define RNA_GP_MOD_OBJECT_SET(_type, _prop, _obtype)                                           \
254 static void rna_##_type##GpencilModifier_##_prop##_set(PointerRNA *ptr, PointerRNA value)          \
255 {                                                                                           \
256         _type##GpencilModifierData *tmd = (_type##GpencilModifierData *)ptr->data;                            \
257         greasepencil_modifier_object_set(ptr->id.data, &tmd->_prop, _obtype, value);                         \
258 }
259
260 RNA_GP_MOD_OBJECT_SET(Armature, object, OB_ARMATURE);
261 RNA_GP_MOD_OBJECT_SET(Lattice, object, OB_LATTICE);
262 RNA_GP_MOD_OBJECT_SET(Mirror, object, OB_EMPTY);
263
264 #undef RNA_GP_MOD_OBJECT_SET
265
266 static void rna_HookGpencilModifier_object_set(PointerRNA *ptr, PointerRNA value)
267 {
268         HookGpencilModifierData *hmd = ptr->data;
269         Object *ob = (Object *)value.data;
270
271         hmd->object = ob;
272         id_lib_extern((ID *)ob);
273         BKE_object_modifier_gpencil_hook_reset(ob, hmd);
274 }
275
276 #else
277
278 static void rna_def_modifier_gpencilnoise(BlenderRNA *brna)
279 {
280         StructRNA *srna;
281         PropertyRNA *prop;
282
283         srna = RNA_def_struct(brna, "NoiseGpencilModifier", "GpencilModifier");
284         RNA_def_struct_ui_text(srna, "Noise Modifier", "Noise effect modifier");
285         RNA_def_struct_sdna(srna, "NoiseGpencilModifierData");
286         RNA_def_struct_ui_icon(srna, ICON_RNDCURVE);
287
288         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
289         RNA_def_property_string_sdna(prop, NULL, "layername");
290         RNA_def_property_ui_text(prop, "Layer", "Layer name");
291         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
292
293         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
294         RNA_def_property_string_sdna(prop, NULL, "vgname");
295         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
296         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_NoiseGpencilModifier_vgname_set");
297         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
298
299         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
300         RNA_def_property_float_sdna(prop, NULL, "factor");
301         RNA_def_property_range(prop, 0, 30.0);
302         RNA_def_property_ui_text(prop, "Factor", "Amount of noise to apply");
303         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
304
305         prop = RNA_def_property(srna, "random", PROP_BOOLEAN, PROP_NONE);
306         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_USE_RANDOM);
307         RNA_def_property_ui_text(prop, "Random", "Use random values");
308         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
309
310         prop = RNA_def_property(srna, "use_edit_position", PROP_BOOLEAN, PROP_NONE);
311         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_MOD_LOCATION);
312         RNA_def_property_ui_text(prop, "Affect Position", "The modifier affects the position of the point");
313         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
314
315         prop = RNA_def_property(srna, "use_edit_strength", PROP_BOOLEAN, PROP_NONE);
316         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_MOD_STRENGTH);
317         RNA_def_property_ui_text(prop, "Affect Strength", "The modifier affects the color strength of the point");
318         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
319
320         prop = RNA_def_property(srna, "use_edit_thickness", PROP_BOOLEAN, PROP_NONE);
321         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_MOD_THICKNESS);
322         RNA_def_property_ui_text(prop, "Affect Thickness", "The modifier affects the thickness of the point");
323         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
324
325         prop = RNA_def_property(srna, "use_edit_uv", PROP_BOOLEAN, PROP_NONE);
326         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_MOD_UV);
327         RNA_def_property_ui_text(prop, "Affect UV", "The modifier affects the UV rotation factor of the point");
328         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
329
330         prop = RNA_def_property(srna, "full_stroke", PROP_BOOLEAN, PROP_NONE);
331         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_FULL_STROKE);
332         RNA_def_property_ui_text(prop, "Full Stroke", "The noise moves the stroke as a whole, not point by point");
333         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
334
335         prop = RNA_def_property(srna, "move_extreme", PROP_BOOLEAN, PROP_NONE);
336         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_MOVE_EXTREME);
337         RNA_def_property_ui_text(prop, "Move Extremes", "The noise moves the stroke extreme points");
338         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
339
340         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
341         RNA_def_property_int_sdna(prop, NULL, "pass_index");
342         RNA_def_property_range(prop, 0, 100);
343         RNA_def_property_ui_text(prop, "Pass", "Pass index");
344         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
345
346         prop = RNA_def_property(srna, "step", PROP_INT, PROP_NONE);
347         RNA_def_property_int_sdna(prop, NULL, "step");
348         RNA_def_property_range(prop, 1, 100);
349         RNA_def_property_ui_text(prop, "Step", "Number of frames before recalculate random values again");
350         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
351
352         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
353         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_INVERT_LAYER);
354         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
355         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
356
357         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
358         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_INVERT_PASS);
359         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
360         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
361
362         prop = RNA_def_property(srna, "invert_vertex", PROP_BOOLEAN, PROP_NONE);
363         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_NOISE_INVERT_VGROUP);
364         RNA_def_property_ui_text(prop, "Inverse VertexGroup", "Inverse filter");
365         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
366 }
367
368 static void rna_def_modifier_gpencilsmooth(BlenderRNA *brna)
369 {
370         StructRNA *srna;
371         PropertyRNA *prop;
372
373         srna = RNA_def_struct(brna, "SmoothGpencilModifier", "GpencilModifier");
374         RNA_def_struct_ui_text(srna, "Smooth Modifier", "Smooth effect modifier");
375         RNA_def_struct_sdna(srna, "SmoothGpencilModifierData");
376         RNA_def_struct_ui_icon(srna, ICON_MOD_SMOOTH);
377
378         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
379         RNA_def_property_string_sdna(prop, NULL, "layername");
380         RNA_def_property_ui_text(prop, "Layer", "Layer name");
381         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
382
383         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
384         RNA_def_property_string_sdna(prop, NULL, "vgname");
385         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
386         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SmoothGpencilModifier_vgname_set");
387         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
388
389         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
390         RNA_def_property_float_sdna(prop, NULL, "factor");
391         RNA_def_property_range(prop, 0, 2);
392         RNA_def_property_ui_text(prop, "Factor", "Amount of smooth to apply");
393         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
394
395         prop = RNA_def_property(srna, "use_edit_position", PROP_BOOLEAN, PROP_NONE);
396         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SMOOTH_MOD_LOCATION);
397         RNA_def_property_ui_text(prop, "Affect Position", "The modifier affects the position of the point");
398         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
399
400         prop = RNA_def_property(srna, "use_edit_strength", PROP_BOOLEAN, PROP_NONE);
401         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SMOOTH_MOD_STRENGTH);
402         RNA_def_property_ui_text(prop, "Affect Strength", "The modifier affects the color strength of the point");
403         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
404
405         prop = RNA_def_property(srna, "use_edit_thickness", PROP_BOOLEAN, PROP_NONE);
406         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SMOOTH_MOD_THICKNESS);
407         RNA_def_property_ui_text(prop, "Affect Thickness", "The modifier affects the thickness of the point");
408         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
409
410         prop = RNA_def_property(srna, "use_edit_uv", PROP_BOOLEAN, PROP_NONE);
411         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SMOOTH_MOD_UV);
412         RNA_def_property_ui_text(prop, "Affect UV", "The modifier affects the UV rotation factor of the point");
413         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
414
415         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
416         RNA_def_property_int_sdna(prop, NULL, "pass_index");
417         RNA_def_property_range(prop, 0, 100);
418         RNA_def_property_ui_text(prop, "Pass", "Pass index");
419         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
420
421         prop = RNA_def_property(srna, "step", PROP_INT, PROP_NONE);
422         RNA_def_property_int_sdna(prop, NULL, "step");
423         RNA_def_property_range(prop, 1, 10);
424         RNA_def_property_ui_text(prop, "Step", "Number of times to apply smooth (high numbers can reduce fps)");
425         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
426
427         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
428         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SMOOTH_INVERT_LAYER);
429         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
430         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
431
432         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
433         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SMOOTH_INVERT_PASS);
434         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
435         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
436
437         prop = RNA_def_property(srna, "invert_vertex", PROP_BOOLEAN, PROP_NONE);
438         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SMOOTH_INVERT_VGROUP);
439         RNA_def_property_ui_text(prop, "Inverse VertexGroup", "Inverse filter");
440         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
441 }
442
443 static void rna_def_modifier_gpencilsubdiv(BlenderRNA *brna)
444 {
445         StructRNA *srna;
446         PropertyRNA *prop;
447
448         srna = RNA_def_struct(brna, "SubdivGpencilModifier", "GpencilModifier");
449         RNA_def_struct_ui_text(srna, "Subdivision Modifier", "Subdivide Stroke modifier");
450         RNA_def_struct_sdna(srna, "SubdivGpencilModifierData");
451         RNA_def_struct_ui_icon(srna, ICON_MOD_SUBSURF);
452
453         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
454         RNA_def_property_string_sdna(prop, NULL, "layername");
455         RNA_def_property_ui_text(prop, "Layer", "Layer name");
456         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
457
458         prop = RNA_def_property(srna, "level", PROP_INT, PROP_NONE);
459         RNA_def_property_int_sdna(prop, NULL, "level");
460         RNA_def_property_range(prop, 0, 5);
461         RNA_def_property_ui_text(prop, "Level", "Number of subdivisions");
462         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
463
464         prop = RNA_def_property(srna, "simple", PROP_BOOLEAN, PROP_NONE);
465         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SUBDIV_SIMPLE);
466         RNA_def_property_ui_text(prop, "Simple", "The modifier only add control points");
467         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
468
469         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
470         RNA_def_property_int_sdna(prop, NULL, "pass_index");
471         RNA_def_property_range(prop, 0, 100);
472         RNA_def_property_ui_text(prop, "Pass", "Pass index");
473         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
474
475         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
476         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SUBDIV_INVERT_LAYER);
477         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
478         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
479
480         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
481         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SUBDIV_INVERT_PASS);
482         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
483         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
484 }
485
486 static void rna_def_modifier_gpencilsimplify(BlenderRNA *brna)
487 {
488         StructRNA *srna;
489         PropertyRNA *prop;
490
491         static EnumPropertyItem prop_gpencil_simplify_mode_items[] = {
492                 { GP_SIMPLIFY_FIXED, "FIXED", ICON_IPO_CONSTANT, "Fixed",
493                 "Delete alternative vertices in the stroke, except extrems" },
494                 { GP_SIMPLIFY_ADAPTATIVE, "ADAPTATIVE", ICON_IPO_EASE_IN_OUT, "Adaptative",
495                 "Use a RDP algorithm to simplify" },
496                 { 0, NULL, 0, NULL, NULL }
497         };
498
499         srna = RNA_def_struct(brna, "SimplifyGpencilModifier", "GpencilModifier");
500         RNA_def_struct_ui_text(srna, "Simplify Modifier", "Simplify Stroke modifier");
501         RNA_def_struct_sdna(srna, "SimplifyGpencilModifierData");
502         RNA_def_struct_ui_icon(srna, ICON_MOD_DECIM);
503
504         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
505         RNA_def_property_string_sdna(prop, NULL, "layername");
506         RNA_def_property_ui_text(prop, "Layer", "Layer name");
507         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
508
509         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
510         RNA_def_property_float_sdna(prop, NULL, "factor");
511         RNA_def_property_range(prop, 0, 100.0);
512         RNA_def_property_ui_range(prop, 0, 100.0, 1.0f, 3);
513         RNA_def_property_ui_text(prop, "Factor", "Factor of Simplify");
514         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
515
516         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
517         RNA_def_property_int_sdna(prop, NULL, "pass_index");
518         RNA_def_property_range(prop, 0, 100);
519         RNA_def_property_ui_text(prop, "Pass", "Pass index");
520         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
521
522         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
523         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SIMPLIFY_INVERT_LAYER);
524         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
525         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
526
527         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
528         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SIMPLIFY_INVERT_PASS);
529         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
530         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
531
532         /* Mode */
533         prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
534         RNA_def_property_enum_items(prop, prop_gpencil_simplify_mode_items);
535         RNA_def_property_ui_text(prop, "Mode", "How simplify the stroke");
536         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
537
538         prop = RNA_def_property(srna, "step", PROP_INT, PROP_NONE);
539         RNA_def_property_int_sdna(prop, NULL, "step");
540         RNA_def_property_range(prop, 1, 50);
541         RNA_def_property_ui_text(prop, "Iterations", "Number of times to apply simplify");
542         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
543 }
544
545 static void rna_def_modifier_gpencilthick(BlenderRNA *brna)
546 {
547         StructRNA *srna;
548         PropertyRNA *prop;
549
550         srna = RNA_def_struct(brna, "ThickGpencilModifier", "GpencilModifier");
551         RNA_def_struct_ui_text(srna, "Thick Modifier", "Subdivide and Smooth Stroke modifier");
552         RNA_def_struct_sdna(srna, "ThickGpencilModifierData");
553         RNA_def_struct_ui_icon(srna, ICON_MAN_ROT);
554
555         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
556         RNA_def_property_string_sdna(prop, NULL, "layername");
557         RNA_def_property_ui_text(prop, "Layer", "Layer name");
558         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
559
560         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
561         RNA_def_property_string_sdna(prop, NULL, "vgname");
562         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
563         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ThickGpencilModifier_vgname_set");
564         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
565
566         prop = RNA_def_property(srna, "thickness", PROP_INT, PROP_NONE);
567         RNA_def_property_int_sdna(prop, NULL, "thickness");
568         RNA_def_property_range(prop, -100, 500);
569         RNA_def_property_ui_text(prop, "Thickness", "Factor of thickness change");
570         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
571
572         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
573         RNA_def_property_int_sdna(prop, NULL, "pass_index");
574         RNA_def_property_range(prop, 0, 100);
575         RNA_def_property_ui_text(prop, "Pass", "Pass index");
576         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
577
578         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
579         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_THICK_INVERT_LAYER);
580         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
581         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
582
583         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
584         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_THICK_INVERT_PASS);
585         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
586         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
587
588         prop = RNA_def_property(srna, "invert_vertex", PROP_BOOLEAN, PROP_NONE);
589         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_THICK_INVERT_VGROUP);
590         RNA_def_property_ui_text(prop, "Inverse VertexGroup", "Inverse filter");
591         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
592
593         prop = RNA_def_property(srna, "use_custom_curve", PROP_BOOLEAN, PROP_NONE);
594         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_THICK_CUSTOM_CURVE);
595         RNA_def_property_ui_text(prop, "Custom Curve", "Use a custom curve to define thickness changes");
596         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
597
598         prop = RNA_def_property(srna, "normalize_thickness", PROP_BOOLEAN, PROP_NONE);
599         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_THICK_NORMALIZE);
600         RNA_def_property_ui_text(prop, "Normalize", "Normalize the full stroke to modifier thickness");
601         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
602
603         prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
604         RNA_def_property_pointer_sdna(prop, NULL, "curve_thickness");
605         RNA_def_property_ui_text(prop, "Curve", "Custom Thickness Curve");
606         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
607 }
608
609 static void rna_def_modifier_gpenciloffset(BlenderRNA *brna)
610 {
611         StructRNA *srna;
612         PropertyRNA *prop;
613
614         srna = RNA_def_struct(brna, "OffsetGpencilModifier", "GpencilModifier");
615         RNA_def_struct_ui_text(srna, "Offset Modifier", "Offset Stroke modifier");
616         RNA_def_struct_sdna(srna, "OffsetGpencilModifierData");
617         RNA_def_struct_ui_icon(srna, ICON_MOD_DISPLACE);
618
619         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
620         RNA_def_property_string_sdna(prop, NULL, "layername");
621         RNA_def_property_ui_text(prop, "Layer", "Layer name");
622         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
623
624         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
625         RNA_def_property_string_sdna(prop, NULL, "vgname");
626         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
627         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_OffsetGpencilModifier_vgname_set");
628         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
629
630         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
631         RNA_def_property_int_sdna(prop, NULL, "pass_index");
632         RNA_def_property_range(prop, 0, 100);
633         RNA_def_property_ui_text(prop, "Pass", "Pass index");
634         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
635
636         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
637         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_OFFSET_INVERT_LAYER);
638         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
639         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
640
641         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
642         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_OFFSET_INVERT_PASS);
643         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
644         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
645
646         prop = RNA_def_property(srna, "invert_vertex", PROP_BOOLEAN, PROP_NONE);
647         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_OFFSET_INVERT_VGROUP);
648         RNA_def_property_ui_text(prop, "Inverse VertexGroup", "Inverse filter");
649         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
650
651         prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
652         RNA_def_property_float_sdna(prop, NULL, "loc");
653         RNA_def_property_ui_text(prop, "Location", "Values for change location");
654         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
655         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
656
657         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
658         RNA_def_property_float_sdna(prop, NULL, "rot");
659         RNA_def_property_ui_text(prop, "Rotation", "Values for changes in rotation");
660         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
661         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
662
663         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
664         RNA_def_property_float_sdna(prop, NULL, "scale");
665         RNA_def_property_ui_text(prop, "Scale", "Values for changes in scale");
666         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
667         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
668 }
669
670 static void rna_def_modifier_gpenciltint(BlenderRNA *brna)
671 {
672         StructRNA *srna;
673         PropertyRNA *prop;
674
675         srna = RNA_def_struct(brna, "TintGpencilModifier", "GpencilModifier");
676         RNA_def_struct_ui_text(srna, "Tint Modifier", "Tint Stroke Color modifier");
677         RNA_def_struct_sdna(srna, "TintGpencilModifierData");
678         RNA_def_struct_ui_icon(srna, ICON_COLOR);
679
680         prop = RNA_def_property(srna, "modify_color", PROP_ENUM, PROP_NONE);
681         RNA_def_property_enum_items(prop, modifier_modify_color_items);  /* share the enum */
682         RNA_def_property_ui_text(prop, "Mode", "Set what colors of the stroke are affected");
683         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
684
685         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
686         RNA_def_property_string_sdna(prop, NULL, "layername");
687         RNA_def_property_ui_text(prop, "Layer", "Layer name");
688         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
689
690         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
691         RNA_def_property_range(prop, 0.0, 1.0);
692         RNA_def_property_float_sdna(prop, NULL, "rgb");
693         RNA_def_property_array(prop, 3);
694         RNA_def_property_ui_text(prop, "Color", "Color used for tinting");
695         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
696
697         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
698         RNA_def_property_float_sdna(prop, NULL, "factor");
699         RNA_def_property_ui_range(prop, 0, 2.0, 0.1, 3);
700         RNA_def_property_ui_text(prop, "Factor", "Factor for mixing color");
701         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
702
703         prop = RNA_def_property(srna, "create_materials", PROP_BOOLEAN, PROP_NONE);
704         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TINT_CREATE_COLORS);
705         RNA_def_property_ui_text(prop, "Create Materials", "When apply modifier, create new material");
706         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
707
708         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
709         RNA_def_property_int_sdna(prop, NULL, "pass_index");
710         RNA_def_property_range(prop, 0, 100);
711         RNA_def_property_ui_text(prop, "Pass", "Pass index");
712         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
713
714         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
715         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TINT_INVERT_LAYER);
716         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
717         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
718
719         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
720         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TINT_INVERT_PASS);
721         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
722         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
723 }
724
725 static void rna_def_modifier_gpenciltime(BlenderRNA *brna)
726 {
727         StructRNA *srna;
728         PropertyRNA *prop;
729
730         srna = RNA_def_struct(brna, "TimeGpencilModifier", "GpencilModifier");
731         RNA_def_struct_ui_text(srna, "Time Modifier", "Time modifier");
732         RNA_def_struct_sdna(srna, "TimeGpencilModifierData");
733         RNA_def_struct_ui_icon(srna, ICON_MOD_DISPLACE);
734
735         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
736         RNA_def_property_string_sdna(prop, NULL, "layername");
737         RNA_def_property_ui_text(prop, "Layer", "Layer name");
738         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
739
740         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
741         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TIME_INVERT_LAYER);
742         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
743         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
744
745         prop = RNA_def_property(srna, "offset", PROP_INT, PROP_NONE);
746         RNA_def_property_int_sdna(prop, NULL, "offset");
747         RNA_def_property_range(prop, -INT_MAX, INT_MAX);
748         RNA_def_property_ui_text(prop, "Offset",
749                         "Number of frames to offset original keyframe number");
750         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
751
752         prop = RNA_def_property(srna, "use_keep_loop", PROP_BOOLEAN, PROP_NONE);
753         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TIME_KEEP_LOOP);
754         RNA_def_property_ui_text(prop, "Keep Loop",
755                 "Retiming end frames and move to start of animation to keep loop");
756         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
757 }
758
759 static void rna_def_modifier_gpencilcolor(BlenderRNA *brna)
760 {
761         StructRNA *srna;
762         PropertyRNA *prop;
763
764         srna = RNA_def_struct(brna, "ColorGpencilModifier", "GpencilModifier");
765         RNA_def_struct_ui_text(srna, "Hue/Saturation Modifier", "Change Hue/Saturation modifier");
766         RNA_def_struct_sdna(srna, "ColorGpencilModifierData");
767         RNA_def_struct_ui_icon(srna, ICON_GROUP_VCOL);
768
769         prop = RNA_def_property(srna, "modify_color", PROP_ENUM, PROP_NONE);
770         RNA_def_property_enum_items(prop, modifier_modify_color_items);  /* share the enum */
771         RNA_def_property_ui_text(prop, "Mode", "Set what colors of the stroke are affected");
772         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
773
774         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
775         RNA_def_property_string_sdna(prop, NULL, "layername");
776         RNA_def_property_ui_text(prop, "Layer", "Layer name");
777         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
778
779         prop = RNA_def_property(srna, "hue", PROP_FLOAT, PROP_NONE);
780         RNA_def_property_range(prop, 0.0, 2.0);
781         RNA_def_property_ui_range(prop, 0.0, 2.0, 0.1, 3);
782         RNA_def_property_float_sdna(prop, NULL, "hsv[0]");
783         RNA_def_property_ui_text(prop, "Hue", "Color Hue");
784         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
785
786         prop = RNA_def_property(srna, "saturation", PROP_FLOAT, PROP_NONE);
787         RNA_def_property_range(prop, 0.0, 2.0);
788         RNA_def_property_ui_range(prop, 0.0, 2.0, 0.1, 3);
789         RNA_def_property_float_sdna(prop, NULL, "hsv[1]");
790         RNA_def_property_ui_text(prop, "Saturation", "Color Saturation");
791         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
792
793         prop = RNA_def_property(srna, "value", PROP_FLOAT, PROP_NONE);
794         RNA_def_property_range(prop, 0.0, 2.0);
795         RNA_def_property_ui_range(prop, 0.0, 2.0, 0.1, 3);
796         RNA_def_property_float_sdna(prop, NULL, "hsv[2]");
797         RNA_def_property_ui_text(prop, "Value", "Color Value");
798         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
799
800         prop = RNA_def_property(srna, "create_materials", PROP_BOOLEAN, PROP_NONE);
801         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_COLOR_CREATE_COLORS);
802         RNA_def_property_ui_text(prop, "Create Materials", "When apply modifier, create new material");
803         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
804
805         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
806         RNA_def_property_int_sdna(prop, NULL, "pass_index");
807         RNA_def_property_range(prop, 0, 100);
808         RNA_def_property_ui_text(prop, "Pass", "Pass index");
809         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
810
811         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
812         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_COLOR_INVERT_LAYER);
813         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
814         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
815
816         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
817         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_COLOR_INVERT_PASS);
818         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
819         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
820 }
821
822 static void rna_def_modifier_gpencilopacity(BlenderRNA *brna)
823 {
824         StructRNA *srna;
825         PropertyRNA *prop;
826
827         srna = RNA_def_struct(brna, "OpacityGpencilModifier", "GpencilModifier");
828         RNA_def_struct_ui_text(srna, "Opacity Modifier", "Opacity of Strokes modifier");
829         RNA_def_struct_sdna(srna, "OpacityGpencilModifierData");
830         RNA_def_struct_ui_icon(srna, ICON_MOD_MASK);
831
832         prop = RNA_def_property(srna, "modify_color", PROP_ENUM, PROP_NONE);
833         RNA_def_property_enum_items(prop, modifier_modify_color_items);  /* share the enum */
834         RNA_def_property_ui_text(prop, "Mode", "Set what colors of the stroke are affected");
835         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
836
837         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
838         RNA_def_property_string_sdna(prop, NULL, "layername");
839         RNA_def_property_ui_text(prop, "Layer", "Layer name");
840         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
841
842         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
843         RNA_def_property_string_sdna(prop, NULL, "vgname");
844         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
845         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_OpacityGpencilModifier_vgname_set");
846         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
847
848         prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
849         RNA_def_property_float_sdna(prop, NULL, "factor");
850         RNA_def_property_ui_range(prop, 0, 2.0, 0.1, 3);
851         RNA_def_property_ui_text(prop, "Factor", "Factor of Opacity");
852         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
853
854         prop = RNA_def_property(srna, "create_materials", PROP_BOOLEAN, PROP_NONE);
855         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_OPACITY_CREATE_COLORS);
856         RNA_def_property_ui_text(prop, "Create Materials", "When apply modifier, create new material");
857         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
858
859         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
860         RNA_def_property_int_sdna(prop, NULL, "pass_index");
861         RNA_def_property_range(prop, 0, 100);
862         RNA_def_property_ui_text(prop, "Pass", "Pass index");
863         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
864
865         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
866         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_OPACITY_INVERT_LAYER);
867         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
868         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
869
870         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
871         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_OPACITY_INVERT_PASS);
872         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
873         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
874
875         prop = RNA_def_property(srna, "invert_vertex", PROP_BOOLEAN, PROP_NONE);
876         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_OPACITY_INVERT_VGROUP);
877         RNA_def_property_ui_text(prop, "Inverse VertexGroup", "Inverse filter");
878         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
879 }
880
881 static void rna_def_modifier_gpencilinstance(BlenderRNA *brna)
882 {
883         StructRNA *srna;
884         PropertyRNA *prop;
885
886         srna = RNA_def_struct(brna, "InstanceGpencilModifier", "GpencilModifier");
887         RNA_def_struct_ui_text(srna, "Instance Modifier", "Create grid of duplicate instances");
888         RNA_def_struct_sdna(srna, "InstanceGpencilModifierData");
889         RNA_def_struct_ui_icon(srna, ICON_MOD_ARRAY);
890
891         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
892         RNA_def_property_string_sdna(prop, NULL, "layername");
893         RNA_def_property_ui_text(prop, "Layer", "Layer name");
894         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
895
896         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
897         RNA_def_property_int_sdna(prop, NULL, "pass_index");
898         RNA_def_property_range(prop, 0, 100);
899         RNA_def_property_ui_text(prop, "Pass", "Pass index");
900         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
901
902         prop = RNA_def_property(srna, "count", PROP_INT, PROP_XYZ);
903         RNA_def_property_range(prop, 1, INT_MAX);
904         RNA_def_property_ui_range(prop, 1, 20, 1, -1);
905         RNA_def_property_ui_text(prop, "Count", "Number of items");
906         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
907
908         /* Offset parameters */
909         prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_TRANSLATION);
910         RNA_def_property_float_sdna(prop, NULL, "offset");
911         RNA_def_property_ui_text(prop, "Offset", "Value for the distance between items");
912         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
913         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
914
915         prop = RNA_def_property(srna, "shift", PROP_FLOAT, PROP_TRANSLATION);
916         RNA_def_property_float_sdna(prop, NULL, "shift");
917         RNA_def_property_ui_text(prop, "Shift", "Shiftness value");
918         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
919         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
920
921         prop = RNA_def_property(srna, "lock_axis", PROP_ENUM, PROP_NONE);
922         RNA_def_property_enum_sdna(prop, NULL, "lock_axis");
923         RNA_def_property_enum_items(prop, rna_enum_gpencil_lockshift_items);
924         //RNA_def_property_flag(prop, PROP_ENUM_FLAG);
925         RNA_def_property_ui_text(prop, "Axis", "");
926         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
927
928         prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_EULER);
929         RNA_def_property_float_sdna(prop, NULL, "rot");
930         RNA_def_property_ui_text(prop, "Rotation", "Value for changes in rotation");
931         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
932         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
933
934         prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
935         RNA_def_property_float_sdna(prop, NULL, "scale");
936         RNA_def_property_ui_text(prop, "Scale", "Value for changes in scale");
937         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
938         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
939
940         prop = RNA_def_property(srna, "random_rot", PROP_BOOLEAN, PROP_NONE);
941         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_INSTANCE_RANDOM_ROT);
942         RNA_def_property_ui_text(prop, "Random Rotation", "Use random factors for rotation");
943         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
944
945         prop = RNA_def_property(srna, "rot_factor", PROP_FLOAT, PROP_NONE);
946         RNA_def_property_float_sdna(prop, NULL, "rnd_rot");
947         RNA_def_property_ui_text(prop, "Rotation Factor", "Random factor for rotation");
948         RNA_def_property_range(prop, -10.0, 10.0);
949         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
950
951         prop = RNA_def_property(srna, "random_scale", PROP_BOOLEAN, PROP_NONE);
952         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_INSTANCE_RANDOM_SIZE);
953         RNA_def_property_ui_text(prop, "Random Scale", "Use random factors for scale");
954         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
955
956         prop = RNA_def_property(srna, "scale_factor", PROP_FLOAT, PROP_NONE);
957         RNA_def_property_float_sdna(prop, NULL, "rnd_size");
958         RNA_def_property_ui_text(prop, "Scale Factor", "Random factor for scale");
959         RNA_def_property_range(prop, -10.0, 10.0);
960         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
961
962         prop = RNA_def_property(srna, "replace_material", PROP_INT, PROP_NONE);
963         RNA_def_property_int_sdna(prop, NULL, "mat_rpl");
964         RNA_def_property_range(prop, 0, INT_MAX);
965         RNA_def_property_ui_text(prop, "Material", "Index of the material used for generated strokes (0 keep original material)");
966         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
967
968         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
969         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_INSTANCE_INVERT_LAYER);
970         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
971         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
972
973         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
974         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_INSTANCE_INVERT_PASS);
975         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
976         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
977
978         prop = RNA_def_property(srna, "keep_on_top", PROP_BOOLEAN, PROP_NONE);
979         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_INSTANCE_KEEP_ONTOP);
980         RNA_def_property_ui_text(prop, "Keep On Top",
981                 "Keep the original stroke in front of new instances (only affect by layer)");
982         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
983 }
984
985 static void rna_def_modifier_gpencilbuild(BlenderRNA *brna)
986 {
987         static EnumPropertyItem prop_gpencil_build_mode_items[] = {
988                 {GP_BUILD_MODE_SEQUENTIAL, "SEQUENTIAL", ICON_PARTICLE_POINT, "Sequential",
989                  "Strokes appear/disappear one after the other, but only a single one changes at a time"},
990                 {GP_BUILD_MODE_CONCURRENT, "CONCURRENT", ICON_PARTICLE_TIP, "Concurrent",
991                  "Multiple strokes appear/disappear at once"},
992                 {0, NULL, 0, NULL, NULL}
993         };
994
995         static EnumPropertyItem prop_gpencil_build_transition_items[] = {
996                 {GP_BUILD_TRANSITION_GROW, "GROW", 0, "Grow",
997                  "Show points in the order they occur in each stroke "
998                  "(e.g. for animating lines being drawn)"},
999                 {GP_BUILD_TRANSITION_SHRINK, "SHRINK", 0, "Shrink",
1000                  "Hide points from the end of each stroke to the start "
1001                  "(e.g. for animating lines being erased)"},
1002                 {GP_BUILD_TRANSITION_FADE, "FADE", 0, "Fade",
1003                  "Hide points in the order they occur in each stroke "
1004                  "(e.g. for animating ink fading or vanishing after getting drawn)"},
1005                 {0, NULL, 0, NULL, NULL}
1006         };
1007
1008         static EnumPropertyItem prop_gpencil_build_time_align_items[] = {
1009                 {GP_BUILD_TIMEALIGN_START, "START", 0, "Align Start",
1010                  "All strokes start at same time (i.e. short strokes finish earlier)"},
1011                 {GP_BUILD_TIMEALIGN_END, "END", 0, "Align End",
1012                  "All strokes end at same time (i.e. short strokes start later)"},
1013                 {0, NULL, 0, NULL, NULL}
1014         };
1015
1016         StructRNA *srna;
1017         PropertyRNA *prop;
1018
1019         srna = RNA_def_struct(brna, "BuildGpencilModifier", "GpencilModifier");
1020         RNA_def_struct_ui_text(srna, "Build Modifier", "Animate strokes appearing and disappearing");
1021         RNA_def_struct_sdna(srna, "BuildGpencilModifierData");
1022         RNA_def_struct_ui_icon(srna, ICON_MOD_BUILD);
1023
1024         /* Mode */
1025         prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
1026         RNA_def_property_enum_items(prop, prop_gpencil_build_mode_items);
1027         RNA_def_property_ui_text(prop, "Mode", "How many strokes are being animated at a time");
1028         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1029
1030         /* Direction */
1031         prop = RNA_def_property(srna, "transition", PROP_ENUM, PROP_NONE);
1032         RNA_def_property_enum_items(prop, prop_gpencil_build_transition_items);
1033         RNA_def_property_ui_text(prop, "Transition", "How are strokes animated (i.e. are they appearing or disappearing)");
1034         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1035
1036
1037         /* Transition Onset Delay + Length */
1038         prop = RNA_def_property(srna, "start_delay", PROP_FLOAT, PROP_NONE);
1039         RNA_def_property_float_sdna(prop, NULL, "start_delay");
1040         RNA_def_property_ui_text(prop, "Start Delay", "Number of frames after each GP keyframe before the modifier has any effect");
1041         RNA_def_property_range(prop, 0, MAXFRAMEF);
1042         RNA_def_property_ui_range(prop, 0, 200, 1, -1);
1043         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1044
1045         prop = RNA_def_property(srna, "length", PROP_FLOAT, PROP_NONE);
1046         RNA_def_property_float_sdna(prop, NULL, "length");
1047         RNA_def_property_ui_text(prop, "Length",
1048                                  "Maximum number of frames that the build effect can run for "
1049                                  "(unless another GP keyframe occurs before this time has elapsed)");
1050         RNA_def_property_range(prop, 1, MAXFRAMEF);
1051         RNA_def_property_ui_range(prop, 1, 1000, 1, -1);
1052         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1053
1054
1055         /* Concurrent Mode Settings */
1056         prop = RNA_def_property(srna, "concurrent_time_alignment", PROP_ENUM, PROP_NONE);
1057         RNA_def_property_enum_sdna(prop, NULL, "time_alignment");
1058         RNA_def_property_enum_items(prop, prop_gpencil_build_time_align_items);
1059         RNA_def_property_ui_text(prop, "Time Alignment", "When should strokes start to appear/disappear");
1060         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1061
1062
1063
1064         /* Time Limits */
1065         prop = RNA_def_property(srna, "use_restrict_frame_range", PROP_BOOLEAN, PROP_NONE);
1066         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BUILD_RESTRICT_TIME);
1067         RNA_def_property_ui_text(prop, "Restrict Frame Range", "Only modify strokes during the specified frame range");
1068         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1069
1070         prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_NONE);
1071         RNA_def_property_float_sdna(prop, NULL, "start_frame");
1072         RNA_def_property_ui_text(prop, "Start Frame", "Start Frame (when Restrict Frame Range is enabled)");
1073         RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
1074         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1075
1076         prop = RNA_def_property(srna, "frame_end", PROP_FLOAT, PROP_NONE);
1077         RNA_def_property_float_sdna(prop, NULL, "end_frame");
1078         RNA_def_property_ui_text(prop, "End Frame", "End Frame (when Restrict Frame Range is enabled)");
1079         RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
1080         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1081
1082
1083         /* Filters - Layer */
1084         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
1085         RNA_def_property_string_sdna(prop, NULL, "layername");
1086         RNA_def_property_ui_text(prop, "Layer", "Layer name");
1087         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1088
1089         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
1090         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BUILD_INVERT_LAYER);
1091         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
1092         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1093
1094         /* Filters - Pass Index */
1095 #if 0
1096         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
1097         RNA_def_property_int_sdna(prop, NULL, "pass_index");
1098         RNA_def_property_range(prop, 0, 100);
1099         RNA_def_property_ui_text(prop, "Pass", "Pass index");
1100         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1101
1102         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
1103         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BUILD_INVERT_PASS);
1104         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
1105         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1106 #endif
1107 }
1108
1109 static void rna_def_modifier_gpencillattice(BlenderRNA *brna)
1110 {
1111         StructRNA *srna;
1112         PropertyRNA *prop;
1113
1114         srna = RNA_def_struct(brna, "LatticeGpencilModifier", "GpencilModifier");
1115         RNA_def_struct_ui_text(srna, "Lattice Modifier", "Change stroke using lattice to deform modifier");
1116         RNA_def_struct_sdna(srna, "LatticeGpencilModifierData");
1117         RNA_def_struct_ui_icon(srna, ICON_MOD_LATTICE);
1118
1119         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
1120         RNA_def_property_string_sdna(prop, NULL, "layername");
1121         RNA_def_property_ui_text(prop, "Layer", "Layer name");
1122         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1123
1124         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
1125         RNA_def_property_string_sdna(prop, NULL, "vgname");
1126         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
1127         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_LatticeGpencilModifier_vgname_set");
1128         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1129
1130         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
1131         RNA_def_property_int_sdna(prop, NULL, "pass_index");
1132         RNA_def_property_range(prop, 0, 100);
1133         RNA_def_property_ui_text(prop, "Pass", "Pass index");
1134         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1135
1136         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
1137         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LATTICE_INVERT_LAYER);
1138         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
1139         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1140
1141         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
1142         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LATTICE_INVERT_PASS);
1143         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
1144         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1145
1146         prop = RNA_def_property(srna, "invert_vertex", PROP_BOOLEAN, PROP_NONE);
1147         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LATTICE_INVERT_VGROUP);
1148         RNA_def_property_ui_text(prop, "Inverse VertexGroup", "Inverse filter");
1149         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1150
1151         prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1152         RNA_def_property_ui_text(prop, "Object", "Lattice object to deform with");
1153         RNA_def_property_pointer_funcs(prop, NULL, "rna_LatticeGpencilModifier_object_set", NULL, "rna_Lattice_object_poll");
1154         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1155         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1156
1157         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
1158         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1159         RNA_def_property_ui_range(prop, 0, 1, 10, 2);
1160         RNA_def_property_ui_text(prop, "Strength", "Strength of modifier effect");
1161         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1162 }
1163
1164 static void rna_def_modifier_gpencilmirror(BlenderRNA *brna)
1165 {
1166         StructRNA *srna;
1167         PropertyRNA *prop;
1168
1169         srna = RNA_def_struct(brna, "MirrorGpencilModifier", "GpencilModifier");
1170         RNA_def_struct_ui_text(srna, "Mirror Modifier", "Change stroke using lattice to deform modifier");
1171         RNA_def_struct_sdna(srna, "MirrorGpencilModifierData");
1172         RNA_def_struct_ui_icon(srna, ICON_MOD_MIRROR);
1173
1174         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
1175         RNA_def_property_string_sdna(prop, NULL, "layername");
1176         RNA_def_property_ui_text(prop, "Layer", "Layer name");
1177         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1178
1179         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
1180         RNA_def_property_int_sdna(prop, NULL, "pass_index");
1181         RNA_def_property_range(prop, 0, 100);
1182         RNA_def_property_ui_text(prop, "Pass", "Pass index");
1183         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1184
1185         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
1186         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_MIRROR_INVERT_LAYER);
1187         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
1188         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1189
1190         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
1191         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_MIRROR_INVERT_PASS);
1192         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
1193         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1194
1195         prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1196         RNA_def_property_ui_text(prop, "Object", "Object used as center");
1197         RNA_def_property_pointer_funcs(prop, NULL, "rna_MirrorGpencilModifier_object_set", NULL, NULL);
1198         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1199         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1200
1201         prop = RNA_def_property(srna, "clip", PROP_BOOLEAN, PROP_NONE);
1202         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_MIRROR_CLIPPING);
1203         RNA_def_property_ui_text(prop, "Clip", "Clip points");
1204         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1205
1206         prop = RNA_def_property(srna, "x_axis", PROP_BOOLEAN, PROP_NONE);
1207         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_MIRROR_AXIS_X);
1208         RNA_def_property_ui_text(prop, "X", "Mirror this axis");
1209         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1210
1211         prop = RNA_def_property(srna, "y_axis", PROP_BOOLEAN, PROP_NONE);
1212         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_MIRROR_AXIS_Y);
1213         RNA_def_property_ui_text(prop, "Y", "Mirror this axis");
1214         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1215
1216         prop = RNA_def_property(srna, "z_axis", PROP_BOOLEAN, PROP_NONE);
1217         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_MIRROR_AXIS_Z);
1218         RNA_def_property_ui_text(prop, "Z", "Mirror this axis");
1219         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1220 }
1221
1222 static void rna_def_modifier_gpencilhook(BlenderRNA *brna)
1223 {
1224         StructRNA *srna;
1225         PropertyRNA *prop;
1226
1227         srna = RNA_def_struct(brna, "HookGpencilModifier", "GpencilModifier");
1228         RNA_def_struct_ui_text(srna, "Hook Modifier", "Hook modifier to modify the location of stroke points");
1229         RNA_def_struct_sdna(srna, "HookGpencilModifierData");
1230         RNA_def_struct_ui_icon(srna, ICON_HOOK);
1231
1232         prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1233         RNA_def_property_ui_text(prop, "Object", "Parent Object for hook, also recalculates and clears offset");
1234         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1235         RNA_def_property_pointer_funcs(prop, NULL, "rna_HookGpencilModifier_object_set", NULL, NULL);
1236         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1237
1238         prop = RNA_def_property(srna, "subtarget", PROP_STRING, PROP_NONE);
1239         RNA_def_property_string_sdna(prop, NULL, "subtarget");
1240         RNA_def_property_ui_text(prop, "Sub-Target",
1241                 "Name of Parent Bone for hook (if applicable), also recalculates and clears offset");
1242         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1243
1244         prop = RNA_def_property(srna, "layer", PROP_STRING, PROP_NONE);
1245         RNA_def_property_string_sdna(prop, NULL, "layername");
1246         RNA_def_property_ui_text(prop, "Layer", "Layer name");
1247         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1248
1249         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
1250         RNA_def_property_string_sdna(prop, NULL, "vgname");
1251         RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
1252         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_HookGpencilModifier_vgname_set");
1253         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1254
1255         prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_NONE);
1256         RNA_def_property_int_sdna(prop, NULL, "pass_index");
1257         RNA_def_property_range(prop, 0, 100);
1258         RNA_def_property_ui_text(prop, "Pass", "Pass index");
1259         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1260
1261         prop = RNA_def_property(srna, "invert_layers", PROP_BOOLEAN, PROP_NONE);
1262         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_HOOK_INVERT_LAYER);
1263         RNA_def_property_ui_text(prop, "Inverse Layers", "Inverse filter");
1264         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1265
1266         prop = RNA_def_property(srna, "invert_pass", PROP_BOOLEAN, PROP_NONE);
1267         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_HOOK_INVERT_PASS);
1268         RNA_def_property_ui_text(prop, "Inverse Pass", "Inverse filter");
1269         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1270
1271         prop = RNA_def_property(srna, "invert_vertex", PROP_BOOLEAN, PROP_NONE);
1272         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_HOOK_INVERT_VGROUP);
1273         RNA_def_property_ui_text(prop, "Inverse VertexGroup", "Inverse filter");
1274         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1275
1276         prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
1277         RNA_def_property_float_sdna(prop, NULL, "force");
1278         RNA_def_property_range(prop, 0, 1);
1279         RNA_def_property_ui_text(prop, "Strength", "Relative force of the hook");
1280         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1281
1282         prop = RNA_def_property(srna, "falloff_type", PROP_ENUM, PROP_NONE);
1283         RNA_def_property_enum_items(prop, modifier_gphook_falloff_items);  /* share the enum */
1284         RNA_def_property_ui_text(prop, "Falloff Type", "");
1285         RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
1286         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1287
1288         prop = RNA_def_property(srna, "falloff_radius", PROP_FLOAT, PROP_DISTANCE);
1289         RNA_def_property_float_sdna(prop, NULL, "falloff");
1290         RNA_def_property_range(prop, 0, FLT_MAX);
1291         RNA_def_property_ui_range(prop, 0, 100, 100, 2);
1292         RNA_def_property_ui_text(prop, "Radius", "If not zero, the distance from the hook where influence ends");
1293         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1294
1295         prop = RNA_def_property(srna, "falloff_curve", PROP_POINTER, PROP_NONE);
1296         RNA_def_property_pointer_sdna(prop, NULL, "curfalloff");
1297         RNA_def_property_ui_text(prop, "Falloff Curve", "Custom Lamp Falloff Curve");
1298         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1299
1300         prop = RNA_def_property(srna, "center", PROP_FLOAT, PROP_NONE);
1301         RNA_def_property_float_sdna(prop, NULL, "cent");
1302         RNA_def_property_ui_text(prop, "Hook Center", "");
1303         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1304
1305         prop = RNA_def_property(srna, "matrix_inverse", PROP_FLOAT, PROP_MATRIX);
1306         RNA_def_property_float_sdna(prop, NULL, "parentinv");
1307         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1308         RNA_def_property_ui_text(prop, "Matrix", "Reverse the transformation between this object and its target");
1309         RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_GpencilModifier_update");
1310
1311         prop = RNA_def_property(srna, "use_falloff_uniform", PROP_BOOLEAN, PROP_NONE);
1312         RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_HOOK_UNIFORM_SPACE);
1313         RNA_def_property_ui_text(prop, "Uniform Falloff", "Compensate for non-uniform object scale");
1314         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1315 }
1316
1317 static void rna_def_modifier_gpencilarmature(BlenderRNA *brna)
1318 {
1319         StructRNA *srna;
1320         PropertyRNA *prop;
1321
1322         srna = RNA_def_struct(brna, "ArmatureGpencilModifier", "GpencilModifier");
1323         RNA_def_struct_ui_text(srna, "Armature Modifier", "Change stroke using armature to deform modifier");
1324         RNA_def_struct_sdna(srna, "ArmatureGpencilModifierData");
1325         RNA_def_struct_ui_icon(srna, ICON_MOD_ARMATURE);
1326
1327         prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1328         RNA_def_property_ui_text(prop, "Object", "Armature object to deform with");
1329         RNA_def_property_pointer_funcs(prop, NULL, "rna_ArmatureGpencilModifier_object_set", NULL, "rna_Armature_object_poll");
1330         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1331         RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
1332         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1333
1334         prop = RNA_def_property(srna, "use_bone_envelopes", PROP_BOOLEAN, PROP_NONE);
1335         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_ENVELOPE);
1336         RNA_def_property_ui_text(prop, "Use Bone Envelopes", "Bind Bone envelopes to armature modifier");
1337         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1338
1339         prop = RNA_def_property(srna, "use_vertex_groups", PROP_BOOLEAN, PROP_NONE);
1340         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_VGROUP);
1341         RNA_def_property_ui_text(prop, "Use Vertex Groups", "Bind vertex groups to armature modifier");
1342         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1343
1344         prop = RNA_def_property(srna, "use_deform_preserve_volume", PROP_BOOLEAN, PROP_NONE);
1345         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_QUATERNION);
1346         RNA_def_property_ui_text(prop, "Preserve Volume", "Deform rotation interpolation with quaternions");
1347         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1348
1349 #if 0 /* GPXX keep disabled now */
1350         prop = RNA_def_property(srna, "use_multi_modifier", PROP_BOOLEAN, PROP_NONE);
1351         RNA_def_property_boolean_sdna(prop, NULL, "multi", 0);
1352         RNA_def_property_ui_text(prop, "Multi Modifier",
1353                 "Use same input as previous modifier, and mix results using overall vgroup");
1354         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1355 #endif
1356
1357         prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
1358         RNA_def_property_string_sdna(prop, NULL, "vgname");
1359         RNA_def_property_ui_text(prop, "Vertex Group",
1360                 "Name of Vertex Group which determines influence of modifier per point");
1361         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ArmatureGpencilModifier_vgname_set");
1362         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1363
1364         prop = RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
1365         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_INVERT_VGROUP);
1366         RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence");
1367         RNA_def_property_update(prop, 0, "rna_GpencilModifier_dependency_update");
1368 }
1369
1370 void RNA_def_greasepencil_modifier(BlenderRNA *brna)
1371 {
1372         StructRNA *srna;
1373         PropertyRNA *prop;
1374
1375         /* data */
1376         srna = RNA_def_struct(brna, "GpencilModifier", NULL);
1377         RNA_def_struct_ui_text(srna, "GpencilModifier", "Modifier affecting the grease pencil object");
1378         RNA_def_struct_refine_func(srna, "rna_GpencilModifier_refine");
1379         RNA_def_struct_path_func(srna, "rna_GpencilModifier_path");
1380         RNA_def_struct_sdna(srna, "GpencilModifierData");
1381
1382         /* strings */
1383         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1384         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GpencilModifier_name_set");
1385         RNA_def_property_ui_text(prop, "Name", "Modifier name");
1386         RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER | NA_RENAME, NULL);
1387         RNA_def_struct_name_property(srna, prop);
1388
1389         /* enums */
1390         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1391         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1392         RNA_def_property_enum_sdna(prop, NULL, "type");
1393         RNA_def_property_enum_items(prop, rna_enum_object_greasepencil_modifier_type_items);
1394         RNA_def_property_ui_text(prop, "Type", "");
1395
1396         /* flags */
1397         prop = RNA_def_property(srna, "show_viewport", PROP_BOOLEAN, PROP_NONE);
1398         RNA_def_property_boolean_sdna(prop, NULL, "mode", eGpencilModifierMode_Realtime);
1399         RNA_def_property_ui_text(prop, "Realtime", "Display modifier in viewport");
1400         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1401         RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
1402         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1403         RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 0);
1404
1405         prop = RNA_def_property(srna, "show_render", PROP_BOOLEAN, PROP_NONE);
1406         RNA_def_property_boolean_sdna(prop, NULL, "mode", eGpencilModifierMode_Render);
1407         RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
1408         RNA_def_property_ui_text(prop, "Render", "Use modifier during render");
1409         RNA_def_property_ui_icon(prop, ICON_SCENE, 0);
1410         RNA_def_property_update(prop, NC_OBJECT | ND_MODIFIER, NULL);
1411
1412         prop = RNA_def_property(srna, "show_in_editmode", PROP_BOOLEAN, PROP_NONE);
1413         RNA_def_property_boolean_sdna(prop, NULL, "mode", eGpencilModifierMode_Editmode);
1414         RNA_def_property_ui_text(prop, "Edit Mode", "Display modifier in Edit mode");
1415         RNA_def_property_update(prop, 0, "rna_GpencilModifier_update");
1416         RNA_def_property_ui_icon(prop, ICON_EDITMODE_HLT, 0);
1417
1418         prop = RNA_def_property(srna, "show_expanded", PROP_BOOLEAN, PROP_NONE);
1419         RNA_def_property_boolean_sdna(prop, NULL, "mode", eGpencilModifierMode_Expanded);
1420         RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
1421         RNA_def_property_ui_text(prop, "Expanded", "Set modifier expanded in the user interface");
1422         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
1423
1424         /* types */
1425         rna_def_modifier_gpencilnoise(brna);
1426         rna_def_modifier_gpencilsmooth(brna);
1427         rna_def_modifier_gpencilsubdiv(brna);
1428         rna_def_modifier_gpencilsimplify(brna);
1429         rna_def_modifier_gpencilthick(brna);
1430         rna_def_modifier_gpenciloffset(brna);
1431         rna_def_modifier_gpenciltint(brna);
1432         rna_def_modifier_gpenciltime(brna);
1433         rna_def_modifier_gpencilcolor(brna);
1434         rna_def_modifier_gpencilinstance(brna);
1435         rna_def_modifier_gpencilbuild(brna);
1436         rna_def_modifier_gpencilopacity(brna);
1437         rna_def_modifier_gpencillattice(brna);
1438         rna_def_modifier_gpencilmirror(brna);
1439         rna_def_modifier_gpencilhook(brna);
1440         rna_def_modifier_gpencilarmature(brna);
1441 }
1442
1443 #endif