source/blender/makesrna/intern/rna_gpencil_modifier.c

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