Cleanup: reorder report argument for pointer assignment
[blender.git] / source / blender / makesrna / intern / rna_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
18  * \ingroup RNA
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_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_ocean.h"
47 #include "BKE_smoke.h" /* For smokeModifier_free & smokeModifier_createType */
48
49 #include "RNA_access.h"
50 #include "RNA_define.h"
51 #include "RNA_enum_types.h"
52
53 #include "rna_internal.h"
54
55 #include "WM_api.h"
56 #include "WM_types.h"
57
58 const EnumPropertyItem rna_enum_object_modifier_type_items[] = {
59     {0, "", 0, N_("Modify"), ""},
60     {eModifierType_DataTransfer, "DATA_TRANSFER", ICON_MOD_DATA_TRANSFER, "Data Transfer", ""},
61     {eModifierType_MeshCache, "MESH_CACHE", ICON_MOD_MESHDEFORM, "Mesh Cache", ""},
62     {eModifierType_MeshSequenceCache,
63      "MESH_SEQUENCE_CACHE",
64      ICON_MOD_MESHDEFORM,
65      "Mesh Sequence Cache",
66      ""},
67     {eModifierType_NormalEdit, "NORMAL_EDIT", ICON_MOD_NORMALEDIT, "Normal Edit", ""},
68     {eModifierType_WeightedNormal, "WEIGHTED_NORMAL", ICON_MOD_NORMALEDIT, "Weighted Normal", ""},
69     {eModifierType_UVProject, "UV_PROJECT", ICON_MOD_UVPROJECT, "UV Project", ""},
70     {eModifierType_UVWarp, "UV_WARP", ICON_MOD_UVPROJECT, "UV Warp", ""},
71     {eModifierType_WeightVGEdit,
72      "VERTEX_WEIGHT_EDIT",
73      ICON_MOD_VERTEX_WEIGHT,
74      "Vertex Weight Edit",
75      ""},
76     {eModifierType_WeightVGMix,
77      "VERTEX_WEIGHT_MIX",
78      ICON_MOD_VERTEX_WEIGHT,
79      "Vertex Weight Mix",
80      ""},
81     {eModifierType_WeightVGProximity,
82      "VERTEX_WEIGHT_PROXIMITY",
83      ICON_MOD_VERTEX_WEIGHT,
84      "Vertex Weight Proximity",
85      ""},
86     {0, "", 0, N_("Generate"), ""},
87     {eModifierType_Array, "ARRAY", ICON_MOD_ARRAY, "Array", ""},
88     {eModifierType_Bevel, "BEVEL", ICON_MOD_BEVEL, "Bevel", ""},
89     {eModifierType_Boolean, "BOOLEAN", ICON_MOD_BOOLEAN, "Boolean", ""},
90     {eModifierType_Build, "BUILD", ICON_MOD_BUILD, "Build", ""},
91     {eModifierType_Decimate, "DECIMATE", ICON_MOD_DECIM, "Decimate", ""},
92     {eModifierType_EdgeSplit, "EDGE_SPLIT", ICON_MOD_EDGESPLIT, "Edge Split", ""},
93     {eModifierType_Mask, "MASK", ICON_MOD_MASK, "Mask", ""},
94     {eModifierType_Mirror, "MIRROR", ICON_MOD_MIRROR, "Mirror", ""},
95     {eModifierType_Multires, "MULTIRES", ICON_MOD_MULTIRES, "Multiresolution", ""},
96     {eModifierType_Remesh, "REMESH", ICON_MOD_REMESH, "Remesh", ""},
97     {eModifierType_Screw, "SCREW", ICON_MOD_SCREW, "Screw", ""},
98     {eModifierType_Skin, "SKIN", ICON_MOD_SKIN, "Skin", ""},
99     {eModifierType_Solidify, "SOLIDIFY", ICON_MOD_SOLIDIFY, "Solidify", ""},
100     {eModifierType_Subsurf, "SUBSURF", ICON_MOD_SUBSURF, "Subdivision Surface", ""},
101     {eModifierType_Triangulate, "TRIANGULATE", ICON_MOD_TRIANGULATE, "Triangulate", ""},
102     {eModifierType_Wireframe,
103      "WIREFRAME",
104      ICON_MOD_WIREFRAME,
105      "Wireframe",
106      "Generate a wireframe on the edges of a mesh"},
107     {0, "", 0, N_("Deform"), ""},
108     {eModifierType_Armature, "ARMATURE", ICON_MOD_ARMATURE, "Armature", ""},
109     {eModifierType_Cast, "CAST", ICON_MOD_CAST, "Cast", ""},
110     {eModifierType_Curve, "CURVE", ICON_MOD_CURVE, "Curve", ""},
111     {eModifierType_Displace, "DISPLACE", ICON_MOD_DISPLACE, "Displace", ""},
112     {eModifierType_Hook, "HOOK", ICON_HOOK, "Hook", ""},
113     {eModifierType_LaplacianDeform,
114      "LAPLACIANDEFORM",
115      ICON_MOD_MESHDEFORM,
116      "Laplacian Deform",
117      ""},
118     {eModifierType_Lattice, "LATTICE", ICON_MOD_LATTICE, "Lattice", ""},
119     {eModifierType_MeshDeform, "MESH_DEFORM", ICON_MOD_MESHDEFORM, "Mesh Deform", ""},
120     {eModifierType_Shrinkwrap, "SHRINKWRAP", ICON_MOD_SHRINKWRAP, "Shrinkwrap", ""},
121     {eModifierType_SimpleDeform, "SIMPLE_DEFORM", ICON_MOD_SIMPLEDEFORM, "Simple Deform", ""},
122     {eModifierType_Smooth, "SMOOTH", ICON_MOD_SMOOTH, "Smooth", ""},
123     {eModifierType_CorrectiveSmooth,
124      "CORRECTIVE_SMOOTH",
125      ICON_MOD_SMOOTH,
126      "Smooth Corrective",
127      ""},
128     {eModifierType_LaplacianSmooth, "LAPLACIANSMOOTH", ICON_MOD_SMOOTH, "Smooth Laplacian", ""},
129     {eModifierType_SurfaceDeform, "SURFACE_DEFORM", ICON_MOD_MESHDEFORM, "Surface Deform", ""},
130     {eModifierType_Warp, "WARP", ICON_MOD_WARP, "Warp", ""},
131     {eModifierType_Wave, "WAVE", ICON_MOD_WAVE, "Wave", ""},
132     {0, "", 0, N_("Simulate"), ""},
133     {eModifierType_Cloth, "CLOTH", ICON_MOD_CLOTH, "Cloth", ""},
134     {eModifierType_Collision, "COLLISION", ICON_MOD_PHYSICS, "Collision", ""},
135     {eModifierType_DynamicPaint, "DYNAMIC_PAINT", ICON_MOD_DYNAMICPAINT, "Dynamic Paint", ""},
136     {eModifierType_Explode, "EXPLODE", ICON_MOD_EXPLODE, "Explode", ""},
137     {eModifierType_Fluidsim, "FLUID_SIMULATION", ICON_MOD_FLUIDSIM, "Fluid Simulation", ""},
138     {eModifierType_Ocean, "OCEAN", ICON_MOD_OCEAN, "Ocean", ""},
139     {eModifierType_ParticleInstance,
140      "PARTICLE_INSTANCE",
141      ICON_MOD_PARTICLE_INSTANCE,
142      "Particle Instance",
143      ""},
144     {eModifierType_ParticleSystem, "PARTICLE_SYSTEM", ICON_MOD_PARTICLES, "Particle System", ""},
145     {eModifierType_Smoke, "SMOKE", ICON_MOD_SMOKE, "Smoke", ""},
146     {eModifierType_Softbody, "SOFT_BODY", ICON_MOD_SOFT, "Soft Body", ""},
147     {eModifierType_Surface, "SURFACE", ICON_MODIFIER, "Surface", ""},
148     {0, NULL, 0, NULL, NULL},
149 };
150
151 const EnumPropertyItem rna_enum_modifier_triangulate_quad_method_items[] = {
152     {MOD_TRIANGULATE_QUAD_BEAUTY,
153      "BEAUTY",
154      0,
155      "Beauty ",
156      "Split the quads in nice triangles, slower method"},
157     {MOD_TRIANGULATE_QUAD_FIXED,
158      "FIXED",
159      0,
160      "Fixed",
161      "Split the quads on the first and third vertices"},
162     {MOD_TRIANGULATE_QUAD_ALTERNATE,
163      "FIXED_ALTERNATE",
164      0,
165      "Fixed Alternate",
166      "Split the quads on the 2nd and 4th vertices"},
167     {MOD_TRIANGULATE_QUAD_SHORTEDGE,
168      "SHORTEST_DIAGONAL",
169      0,
170      "Shortest Diagonal",
171      "Split the quads based on the distance between the vertices"},
172     {0, NULL, 0, NULL, NULL},
173 };
174
175 const EnumPropertyItem rna_enum_modifier_triangulate_ngon_method_items[] = {
176     {MOD_TRIANGULATE_NGON_BEAUTY,
177      "BEAUTY",
178      0,
179      "Beauty",
180      "Arrange the new triangles evenly (slow)"},
181     {MOD_TRIANGULATE_NGON_EARCLIP,
182      "CLIP",
183      0,
184      "Clip",
185      "Split the polygons with an ear clipping algorithm"},
186     {0, NULL, 0, NULL, NULL},
187 };
188
189 const EnumPropertyItem rna_enum_modifier_shrinkwrap_mode_items[] = {
190     {MOD_SHRINKWRAP_ON_SURFACE,
191      "ON_SURFACE",
192      0,
193      "On Surface",
194      "The point is constrained to the surface of the target object, "
195      "with distance offset towards the original point location"},
196     {MOD_SHRINKWRAP_INSIDE,
197      "INSIDE",
198      0,
199      "Inside",
200      "The point is constrained to be inside the target object"},
201     {MOD_SHRINKWRAP_OUTSIDE,
202      "OUTSIDE",
203      0,
204      "Outside",
205      "The point is constrained to be outside the target object"},
206     {MOD_SHRINKWRAP_OUTSIDE_SURFACE,
207      "OUTSIDE_SURFACE",
208      0,
209      "Outside Surface",
210      "The point is constrained to the surface of the target object, "
211      "with distance offset always to the outside, towards or away from the original location"},
212     {MOD_SHRINKWRAP_ABOVE_SURFACE,
213      "ABOVE_SURFACE",
214      0,
215      "Above Surface",
216      "The point is constrained to the surface of the target object, "
217      "with distance offset applied exactly along the target normal"},
218     {0, NULL, 0, NULL, NULL},
219 };
220
221 #ifndef RNA_RUNTIME
222 /* use eWarp_Falloff_*** & eHook_Falloff_***, they're in sync */
223 static const EnumPropertyItem modifier_warp_falloff_items[] = {
224     {eWarp_Falloff_None, "NONE", 0, "No Falloff", ""},
225     {eWarp_Falloff_Curve, "CURVE", 0, "Curve", ""},
226     {eWarp_Falloff_Smooth, "SMOOTH", ICON_SMOOTHCURVE, "Smooth", ""},
227     {eWarp_Falloff_Sphere, "SPHERE", ICON_SPHERECURVE, "Sphere", ""},
228     {eWarp_Falloff_Root, "ROOT", ICON_ROOTCURVE, "Root", ""},
229     {eWarp_Falloff_InvSquare, "INVERSE_SQUARE", ICON_ROOTCURVE, "Inverse Square", ""},
230     {eWarp_Falloff_Sharp, "SHARP", ICON_SHARPCURVE, "Sharp", ""},
231     {eWarp_Falloff_Linear, "LINEAR", ICON_LINCURVE, "Linear", ""},
232     {eWarp_Falloff_Const, "CONSTANT", ICON_NOCURVE, "Constant", ""},
233     {0, NULL, 0, NULL, NULL},
234 };
235 #endif
236
237 /* ***** Data Transfer ***** */
238
239 const EnumPropertyItem rna_enum_dt_method_vertex_items[] = {
240     {MREMAP_MODE_TOPOLOGY, "TOPOLOGY", 0, "Topology", "Copy from identical topology meshes"},
241     {MREMAP_MODE_VERT_NEAREST, "NEAREST", 0, "Nearest vertex", "Copy from closest vertex"},
242     {MREMAP_MODE_VERT_EDGE_NEAREST,
243      "EDGE_NEAREST",
244      0,
245      "Nearest Edge Vertex",
246      "Copy from closest vertex of closest edge"},
247     {MREMAP_MODE_VERT_EDGEINTERP_NEAREST,
248      "EDGEINTERP_NEAREST",
249      0,
250      "Nearest Edge Interpolated",
251      "Copy from interpolated values of vertices from closest point on closest edge"},
252     {MREMAP_MODE_VERT_POLY_NEAREST,
253      "POLY_NEAREST",
254      0,
255      "Nearest Face Vertex",
256      "Copy from closest vertex of closest face"},
257     {MREMAP_MODE_VERT_POLYINTERP_NEAREST,
258      "POLYINTERP_NEAREST",
259      0,
260      "Nearest Face Interpolated",
261      "Copy from interpolated values of vertices from closest point on closest face"},
262     {MREMAP_MODE_VERT_POLYINTERP_VNORPROJ,
263      "POLYINTERP_VNORPROJ",
264      0,
265      "Projected Face Interpolated",
266      "Copy from interpolated values of vertices from point on closest face hit by "
267      "normal-projection"},
268     {0, NULL, 0, NULL, NULL},
269 };
270
271 const EnumPropertyItem rna_enum_dt_method_edge_items[] = {
272     {MREMAP_MODE_TOPOLOGY, "TOPOLOGY", 0, "Topology", "Copy from identical topology meshes"},
273     {MREMAP_MODE_EDGE_VERT_NEAREST,
274      "VERT_NEAREST",
275      0,
276      "Nearest Vertices",
277      "Copy from most similar edge (edge which vertices are the closest of destination edge's "
278      "ones)"},
279     {MREMAP_MODE_EDGE_NEAREST,
280      "NEAREST",
281      0,
282      "Nearest Edge",
283      "Copy from closest edge (using midpoints)"},
284     {MREMAP_MODE_EDGE_POLY_NEAREST,
285      "POLY_NEAREST",
286      0,
287      "Nearest Face Edge",
288      "Copy from closest edge of closest face (using midpoints)"},
289     {MREMAP_MODE_EDGE_EDGEINTERP_VNORPROJ,
290      "EDGEINTERP_VNORPROJ",
291      0,
292      "Projected Edge Interpolated",
293      "Interpolate all source edges hit by the projection of destination one along its own normal "
294      "(from vertices)"},
295     {0, NULL, 0, NULL, NULL},
296 };
297
298 const EnumPropertyItem rna_enum_dt_method_loop_items[] = {
299     {MREMAP_MODE_TOPOLOGY, "TOPOLOGY", 0, "Topology", "Copy from identical topology meshes"},
300     {MREMAP_MODE_LOOP_NEAREST_LOOPNOR,
301      "NEAREST_NORMAL",
302      0,
303      "Nearest Corner And Best Matching Normal",
304      "Copy from nearest corner which has the best matching normal"},
305     {MREMAP_MODE_LOOP_NEAREST_POLYNOR,
306      "NEAREST_POLYNOR",
307      0,
308      "Nearest Corner And Best Matching Face Normal",
309      "Copy from nearest corner which has the face with the best matching normal to destination "
310      "corner's face one"},
311     {MREMAP_MODE_LOOP_POLY_NEAREST,
312      "NEAREST_POLY",
313      0,
314      "Nearest Corner Of Nearest Face",
315      "Copy from nearest corner of nearest polygon"},
316     {MREMAP_MODE_LOOP_POLYINTERP_NEAREST,
317      "POLYINTERP_NEAREST",
318      0,
319      "Nearest Face Interpolated",
320      "Copy from interpolated corners of the nearest source polygon"},
321     {MREMAP_MODE_LOOP_POLYINTERP_LNORPROJ,
322      "POLYINTERP_LNORPROJ",
323      0,
324      "Projected Face Interpolated",
325      "Copy from interpolated corners of the source polygon hit by corner normal projection"},
326     {0, NULL, 0, NULL, NULL},
327 };
328
329 const EnumPropertyItem rna_enum_dt_method_poly_items[] = {
330     {MREMAP_MODE_TOPOLOGY, "TOPOLOGY", 0, "Topology", "Copy from identical topology meshes"},
331     {MREMAP_MODE_POLY_NEAREST,
332      "NEAREST",
333      0,
334      "Nearest Face",
335      "Copy from nearest polygon (using center points)"},
336     {MREMAP_MODE_POLY_NOR,
337      "NORMAL",
338      0,
339      "Best Normal-Matching",
340      "Copy from source polygon which normal is the closest to destination one"},
341     {MREMAP_MODE_POLY_POLYINTERP_PNORPROJ,
342      "POLYINTERP_PNORPROJ",
343      0,
344      "Projected Face Interpolated",
345      "Interpolate all source polygons intersected by the projection of destination one along its "
346      "own normal"},
347     {0, NULL, 0, NULL, NULL},
348 };
349
350 const EnumPropertyItem rna_enum_dt_mix_mode_items[] = {
351     {CDT_MIX_TRANSFER, "REPLACE", 0, "Replace", "Overwrite all elements' data"},
352     {CDT_MIX_REPLACE_ABOVE_THRESHOLD,
353      "ABOVE_THRESHOLD",
354      0,
355      "Above Threshold",
356      "Only replace destination elements where data is above given threshold (exact behavior "
357      "depends on data type)"},
358     {CDT_MIX_REPLACE_BELOW_THRESHOLD,
359      "BELOW_THRESHOLD",
360      0,
361      "Below Threshold",
362      "Only replace destination elements where data is below given threshold (exact behavior "
363      "depends on data type)"},
364     {CDT_MIX_MIX,
365      "MIX",
366      0,
367      "Mix",
368      "Mix source value into destination one, using given threshold as factor"},
369     {CDT_MIX_ADD,
370      "ADD",
371      0,
372      "Add",
373      "Add source value to destination one, using given threshold as factor"},
374     {CDT_MIX_SUB,
375      "SUB",
376      0,
377      "Subtract",
378      "Subtract source value to destination one, using given threshold as factor"},
379     {CDT_MIX_MUL,
380      "MUL",
381      0,
382      "Multiply",
383      "Multiply source value to destination one, using given threshold as factor"},
384     /* etc. etc. */
385     {0, NULL, 0, NULL, NULL},
386 };
387
388 const EnumPropertyItem rna_enum_dt_layers_select_src_items[] = {
389     {DT_LAYERS_ACTIVE_SRC, "ACTIVE", 0, "Active Layer", "Only transfer active data layer"},
390     {DT_LAYERS_ALL_SRC, "ALL", 0, "All Layers", "Transfer all data layers"},
391     {DT_LAYERS_VGROUP_SRC_BONE_SELECT,
392      "BONE_SELECT",
393      0,
394      "Selected Pose Bones",
395      "Transfer all vertex groups used by selected pose bones"},
396     {DT_LAYERS_VGROUP_SRC_BONE_DEFORM,
397      "BONE_DEFORM",
398      0,
399      "Deform Pose Bones",
400      "Transfer all vertex groups used by deform bones"},
401     {0, NULL, 0, NULL, NULL},
402 };
403
404 const EnumPropertyItem rna_enum_dt_layers_select_dst_items[] = {
405     {DT_LAYERS_ACTIVE_DST, "ACTIVE", 0, "Active Layer", "Affect active data layer of all targets"},
406     {DT_LAYERS_NAME_DST, "NAME", 0, "By Name", "Match target data layers to affect by name"},
407     {DT_LAYERS_INDEX_DST,
408      "INDEX",
409      0,
410      "By Order",
411      "Match target data layers to affect by order (indices)"},
412     {0, NULL, 0, NULL, NULL},
413 };
414
415 const EnumPropertyItem rna_enum_axis_xy_items[] = {
416     {0, "X", 0, "X", ""},
417     {1, "Y", 0, "Y", ""},
418     {0, NULL, 0, NULL, NULL},
419 };
420
421 const EnumPropertyItem rna_enum_axis_xyz_items[] = {
422     {0, "X", 0, "X", ""},
423     {1, "Y", 0, "Y", ""},
424     {2, "Z", 0, "Z", ""},
425     {0, NULL, 0, NULL, NULL},
426 };
427
428 const EnumPropertyItem rna_enum_axis_flag_xyz_items[] = {
429     {(1 << 0), "X", 0, "X", ""},
430     {(1 << 1), "Y", 0, "Y", ""},
431     {(1 << 2), "Z", 0, "Z", ""},
432     {0, NULL, 0, NULL, NULL},
433 };
434
435 #ifdef RNA_RUNTIME
436
437 #  include "DNA_particle_types.h"
438 #  include "DNA_curve_types.h"
439 #  include "DNA_smoke_types.h"
440
441 #  include "BKE_cachefile.h"
442 #  include "BKE_context.h"
443 #  include "BKE_mesh_runtime.h"
444 #  include "BKE_modifier.h"
445 #  include "BKE_object.h"
446 #  include "BKE_particle.h"
447
448 #  include "BLI_sort_utils.h"
449
450 #  include "DEG_depsgraph.h"
451 #  include "DEG_depsgraph_build.h"
452 #  include "DEG_depsgraph_query.h"
453
454 #  ifdef WITH_ALEMBIC
455 #    include "ABC_alembic.h"
456 #  endif
457
458 static void rna_UVProject_projectors_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
459 {
460   UVProjectModifierData *uvp = (UVProjectModifierData *)ptr->data;
461   rna_iterator_array_begin(
462       iter, (void *)uvp->projectors, sizeof(Object *), uvp->num_projectors, 0, NULL);
463 }
464
465 static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr)
466 {
467   ModifierData *md = (ModifierData *)ptr->data;
468
469   switch ((ModifierType)md->type) {
470     case eModifierType_Subsurf:
471       return &RNA_SubsurfModifier;
472     case eModifierType_Lattice:
473       return &RNA_LatticeModifier;
474     case eModifierType_Curve:
475       return &RNA_CurveModifier;
476     case eModifierType_Build:
477       return &RNA_BuildModifier;
478     case eModifierType_Mirror:
479       return &RNA_MirrorModifier;
480     case eModifierType_Decimate:
481       return &RNA_DecimateModifier;
482     case eModifierType_Wave:
483       return &RNA_WaveModifier;
484     case eModifierType_Armature:
485       return &RNA_ArmatureModifier;
486     case eModifierType_Hook:
487       return &RNA_HookModifier;
488     case eModifierType_Softbody:
489       return &RNA_SoftBodyModifier;
490     case eModifierType_Boolean:
491       return &RNA_BooleanModifier;
492     case eModifierType_Array:
493       return &RNA_ArrayModifier;
494     case eModifierType_EdgeSplit:
495       return &RNA_EdgeSplitModifier;
496     case eModifierType_Displace:
497       return &RNA_DisplaceModifier;
498     case eModifierType_UVProject:
499       return &RNA_UVProjectModifier;
500     case eModifierType_Smooth:
501       return &RNA_SmoothModifier;
502     case eModifierType_Cast:
503       return &RNA_CastModifier;
504     case eModifierType_MeshDeform:
505       return &RNA_MeshDeformModifier;
506     case eModifierType_ParticleSystem:
507       return &RNA_ParticleSystemModifier;
508     case eModifierType_ParticleInstance:
509       return &RNA_ParticleInstanceModifier;
510     case eModifierType_Explode:
511       return &RNA_ExplodeModifier;
512     case eModifierType_Cloth:
513       return &RNA_ClothModifier;
514     case eModifierType_Collision:
515       return &RNA_CollisionModifier;
516     case eModifierType_Bevel:
517       return &RNA_BevelModifier;
518     case eModifierType_Shrinkwrap:
519       return &RNA_ShrinkwrapModifier;
520     case eModifierType_Fluidsim:
521       return &RNA_FluidSimulationModifier;
522     case eModifierType_Mask:
523       return &RNA_MaskModifier;
524     case eModifierType_SimpleDeform:
525       return &RNA_SimpleDeformModifier;
526     case eModifierType_Multires:
527       return &RNA_MultiresModifier;
528     case eModifierType_Surface:
529       return &RNA_SurfaceModifier;
530     case eModifierType_Smoke:
531       return &RNA_SmokeModifier;
532     case eModifierType_Solidify:
533       return &RNA_SolidifyModifier;
534     case eModifierType_Screw:
535       return &RNA_ScrewModifier;
536     case eModifierType_Ocean:
537       return &RNA_OceanModifier;
538     case eModifierType_Warp:
539       return &RNA_WarpModifier;
540     case eModifierType_WeightVGEdit:
541       return &RNA_VertexWeightEditModifier;
542     case eModifierType_WeightVGMix:
543       return &RNA_VertexWeightMixModifier;
544     case eModifierType_WeightVGProximity:
545       return &RNA_VertexWeightProximityModifier;
546     case eModifierType_DynamicPaint:
547       return &RNA_DynamicPaintModifier;
548     case eModifierType_Remesh:
549       return &RNA_RemeshModifier;
550     case eModifierType_Skin:
551       return &RNA_SkinModifier;
552     case eModifierType_LaplacianSmooth:
553       return &RNA_LaplacianSmoothModifier;
554     case eModifierType_Triangulate:
555       return &RNA_TriangulateModifier;
556     case eModifierType_UVWarp:
557       return &RNA_UVWarpModifier;
558     case eModifierType_MeshCache:
559       return &RNA_MeshCacheModifier;
560     case eModifierType_LaplacianDeform:
561       return &RNA_LaplacianDeformModifier;
562     case eModifierType_Wireframe:
563       return &RNA_WireframeModifier;
564     case eModifierType_DataTransfer:
565       return &RNA_DataTransferModifier;
566     case eModifierType_NormalEdit:
567       return &RNA_NormalEditModifier;
568     case eModifierType_CorrectiveSmooth:
569       return &RNA_CorrectiveSmoothModifier;
570     case eModifierType_MeshSequenceCache:
571       return &RNA_MeshSequenceCacheModifier;
572     case eModifierType_SurfaceDeform:
573       return &RNA_SurfaceDeformModifier;
574     case eModifierType_WeightedNormal:
575       return &RNA_WeightedNormalModifier;
576     /* Default */
577     case eModifierType_None:
578     case eModifierType_ShapeKey:
579     case NUM_MODIFIER_TYPES:
580       return &RNA_Modifier;
581   }
582
583   return &RNA_Modifier;
584 }
585
586 static void rna_Modifier_name_set(PointerRNA *ptr, const char *value)
587 {
588   ModifierData *md = ptr->data;
589   char oldname[sizeof(md->name)];
590
591   /* make a copy of the old name first */
592   BLI_strncpy(oldname, md->name, sizeof(md->name));
593
594   /* copy the new name into the name slot */
595   BLI_strncpy_utf8(md->name, value, sizeof(md->name));
596
597   /* make sure the name is truly unique */
598   if (ptr->id.data) {
599     Object *ob = ptr->id.data;
600     modifier_unique_name(&ob->modifiers, md);
601   }
602
603   /* fix all the animation data which may link to this */
604   BKE_animdata_fix_paths_rename_all(NULL, "modifiers", oldname, md->name);
605 }
606
607 static char *rna_Modifier_path(PointerRNA *ptr)
608 {
609   ModifierData *md = ptr->data;
610   char name_esc[sizeof(md->name) * 2];
611
612   BLI_strescape(name_esc, md->name, sizeof(name_esc));
613   return BLI_sprintfN("modifiers[\"%s\"]", name_esc);
614 }
615
616 static void rna_Modifier_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
617 {
618   DEG_id_tag_update(ptr->id.data, ID_RECALC_GEOMETRY);
619   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER, ptr->id.data);
620 }
621
622 static void rna_Modifier_dependency_update(Main *bmain, Scene *scene, PointerRNA *ptr)
623 {
624   rna_Modifier_update(bmain, scene, ptr);
625   DEG_relations_tag_update(bmain);
626 }
627
628 /* Vertex Groups */
629
630 #  define RNA_MOD_VGROUP_NAME_SET(_type, _prop) \
631     static void rna_##_type##Modifier_##_prop##_set(PointerRNA *ptr, const char *value) \
632     { \
633       _type##ModifierData *tmd = (_type##ModifierData *)ptr->data; \
634       rna_object_vgroup_name_set(ptr, value, tmd->_prop, sizeof(tmd->_prop)); \
635     }
636
637 RNA_MOD_VGROUP_NAME_SET(Armature, defgrp_name);
638 RNA_MOD_VGROUP_NAME_SET(Bevel, defgrp_name);
639 RNA_MOD_VGROUP_NAME_SET(Cast, defgrp_name);
640 RNA_MOD_VGROUP_NAME_SET(Curve, name);
641 RNA_MOD_VGROUP_NAME_SET(DataTransfer, defgrp_name);
642 RNA_MOD_VGROUP_NAME_SET(Decimate, defgrp_name);
643 RNA_MOD_VGROUP_NAME_SET(CorrectiveSmooth, defgrp_name);
644 RNA_MOD_VGROUP_NAME_SET(Displace, defgrp_name);
645 RNA_MOD_VGROUP_NAME_SET(Hook, name);
646 RNA_MOD_VGROUP_NAME_SET(LaplacianDeform, anchor_grp_name);
647 RNA_MOD_VGROUP_NAME_SET(LaplacianSmooth, defgrp_name);
648 RNA_MOD_VGROUP_NAME_SET(Lattice, name);
649 RNA_MOD_VGROUP_NAME_SET(Mask, vgroup);
650 RNA_MOD_VGROUP_NAME_SET(MeshDeform, defgrp_name);
651 RNA_MOD_VGROUP_NAME_SET(NormalEdit, defgrp_name);
652 RNA_MOD_VGROUP_NAME_SET(Shrinkwrap, vgroup_name);
653 RNA_MOD_VGROUP_NAME_SET(SimpleDeform, vgroup_name);
654 RNA_MOD_VGROUP_NAME_SET(Smooth, defgrp_name);
655 RNA_MOD_VGROUP_NAME_SET(Solidify, defgrp_name);
656 RNA_MOD_VGROUP_NAME_SET(UVWarp, vgroup_name);
657 RNA_MOD_VGROUP_NAME_SET(Warp, defgrp_name);
658 RNA_MOD_VGROUP_NAME_SET(Wave, defgrp_name);
659 RNA_MOD_VGROUP_NAME_SET(WeightVGEdit, defgrp_name);
660 RNA_MOD_VGROUP_NAME_SET(WeightVGEdit, mask_defgrp_name);
661 RNA_MOD_VGROUP_NAME_SET(WeightVGMix, defgrp_name_a);
662 RNA_MOD_VGROUP_NAME_SET(WeightVGMix, defgrp_name_b);
663 RNA_MOD_VGROUP_NAME_SET(WeightVGMix, mask_defgrp_name);
664 RNA_MOD_VGROUP_NAME_SET(WeightVGProximity, defgrp_name);
665 RNA_MOD_VGROUP_NAME_SET(WeightVGProximity, mask_defgrp_name);
666 RNA_MOD_VGROUP_NAME_SET(WeightedNormal, defgrp_name);
667 RNA_MOD_VGROUP_NAME_SET(Wireframe, defgrp_name);
668
669 static void rna_ExplodeModifier_vgroup_get(PointerRNA *ptr, char *value)
670 {
671   ExplodeModifierData *emd = (ExplodeModifierData *)ptr->data;
672   rna_object_vgroup_name_index_get(ptr, value, emd->vgroup);
673 }
674
675 static int rna_ExplodeModifier_vgroup_length(PointerRNA *ptr)
676 {
677   ExplodeModifierData *emd = (ExplodeModifierData *)ptr->data;
678   return rna_object_vgroup_name_index_length(ptr, emd->vgroup);
679 }
680
681 static void rna_ExplodeModifier_vgroup_set(PointerRNA *ptr, const char *value)
682 {
683   ExplodeModifierData *emd = (ExplodeModifierData *)ptr->data;
684   rna_object_vgroup_name_index_set(ptr, value, &emd->vgroup);
685 }
686
687 #  undef RNA_MOD_VGROUP_NAME_SET
688
689 /* UV layers */
690
691 #  define RNA_MOD_UVLAYER_NAME_SET(_type, _prop) \
692     static void rna_##_type##Modifier_##_prop##_set(PointerRNA *ptr, const char *value) \
693     { \
694       _type##ModifierData *tmd = (_type##ModifierData *)ptr->data; \
695       rna_object_uvlayer_name_set(ptr, value, tmd->_prop, sizeof(tmd->_prop)); \
696     }
697
698 RNA_MOD_UVLAYER_NAME_SET(MappingInfo, uvlayer_name);
699 RNA_MOD_UVLAYER_NAME_SET(UVProject, uvlayer_name);
700 RNA_MOD_UVLAYER_NAME_SET(UVWarp, uvlayer_name);
701 RNA_MOD_UVLAYER_NAME_SET(WeightVGEdit, mask_tex_uvlayer_name);
702 RNA_MOD_UVLAYER_NAME_SET(WeightVGMix, mask_tex_uvlayer_name);
703 RNA_MOD_UVLAYER_NAME_SET(WeightVGProximity, mask_tex_uvlayer_name);
704
705 #  undef RNA_MOD_UVLAYER_NAME_SET
706
707 /* Objects */
708
709 static void modifier_object_set(Object *self, Object **ob_p, int type, PointerRNA value)
710 {
711   Object *ob = value.data;
712
713   if (!self || ob != self) {
714     if (!ob || type == OB_EMPTY || ob->type == type) {
715       id_lib_extern((ID *)ob);
716       *ob_p = ob;
717     }
718   }
719 }
720
721 #  define RNA_MOD_OBJECT_SET(_type, _prop, _obtype) \
722     static void rna_##_type##Modifier_##_prop##_set( \
723         PointerRNA *ptr, PointerRNA value, struct ReportList *UNUSED(reports)) \
724     { \
725       _type##ModifierData *tmd = (_type##ModifierData *)ptr->data; \
726       modifier_object_set(ptr->id.data, &tmd->_prop, _obtype, value); \
727     }
728
729 RNA_MOD_OBJECT_SET(Armature, object, OB_ARMATURE);
730 RNA_MOD_OBJECT_SET(Array, start_cap, OB_MESH);
731 RNA_MOD_OBJECT_SET(Array, end_cap, OB_MESH);
732 RNA_MOD_OBJECT_SET(Array, curve_ob, OB_CURVE);
733 RNA_MOD_OBJECT_SET(Boolean, object, OB_MESH);
734 RNA_MOD_OBJECT_SET(Cast, object, OB_EMPTY);
735 RNA_MOD_OBJECT_SET(Curve, object, OB_CURVE);
736 RNA_MOD_OBJECT_SET(DataTransfer, ob_source, OB_MESH);
737 RNA_MOD_OBJECT_SET(Lattice, object, OB_LATTICE);
738 RNA_MOD_OBJECT_SET(Mask, ob_arm, OB_ARMATURE);
739 RNA_MOD_OBJECT_SET(MeshDeform, object, OB_MESH);
740 RNA_MOD_OBJECT_SET(NormalEdit, target, OB_EMPTY);
741 RNA_MOD_OBJECT_SET(Shrinkwrap, target, OB_MESH);
742 RNA_MOD_OBJECT_SET(Shrinkwrap, auxTarget, OB_MESH);
743 RNA_MOD_OBJECT_SET(SurfaceDeform, target, OB_MESH);
744
745 static void rna_HookModifier_object_set(PointerRNA *ptr,
746                                         PointerRNA value,
747                                         struct ReportList *UNUSED(reports))
748 {
749   Object *owner = (Object *)ptr->id.data;
750   HookModifierData *hmd = ptr->data;
751   Object *ob = (Object *)value.data;
752
753   hmd->object = ob;
754   id_lib_extern((ID *)ob);
755   BKE_object_modifier_hook_reset(owner, hmd);
756 }
757
758 static void rna_HookModifier_subtarget_set(PointerRNA *ptr, const char *value)
759 {
760   Object *owner = (Object *)ptr->id.data;
761   HookModifierData *hmd = ptr->data;
762
763   BLI_strncpy(hmd->subtarget, value, sizeof(hmd->subtarget));
764   BKE_object_modifier_hook_reset(owner, hmd);
765 }
766
767 static int rna_HookModifier_vertex_indices_get_length(PointerRNA *ptr,
768                                                       int length[RNA_MAX_ARRAY_DIMENSION])
769 {
770   HookModifierData *hmd = ptr->data;
771   int totindex = hmd->indexar ? hmd->totindex : 0;
772   return (length[0] = totindex);
773 }
774
775 static void rna_HookModifier_vertex_indices_get(PointerRNA *ptr, int *values)
776 {
777   HookModifierData *hmd = ptr->data;
778   if (hmd->indexar != NULL) {
779     memcpy(values, hmd->indexar, sizeof(int) * hmd->totindex);
780   }
781 }
782
783 static void rna_HookModifier_vertex_indices_set(HookModifierData *hmd,
784                                                 ReportList *reports,
785                                                 int indices_len,
786                                                 int *indices)
787 {
788   if (indices_len == 0) {
789     MEM_SAFE_FREE(hmd->indexar);
790     hmd->totindex = 0;
791   }
792   else {
793     /* Reject negative indices. */
794     for (int i = 0; i < indices_len; i++) {
795       if (indices[i] < 0) {
796         BKE_reportf(reports, RPT_ERROR, "Negative vertex index in vertex_indices_set");
797         return;
798       }
799     }
800
801     /* Copy and sort the index array. */
802     size_t size = sizeof(int) * indices_len;
803     int *buffer = MEM_mallocN(size, "hook indexar");
804     memcpy(buffer, indices, size);
805
806     qsort(buffer, indices_len, sizeof(int), BLI_sortutil_cmp_int);
807
808     /* Reject duplicate indices. */
809     for (int i = 1; i < indices_len; i++) {
810       if (buffer[i] == buffer[i - 1]) {
811         BKE_reportf(reports, RPT_ERROR, "Duplicate index %d in vertex_indices_set", buffer[i]);
812         MEM_freeN(buffer);
813         return;
814       }
815     }
816
817     /* Success - save the new array. */
818     MEM_SAFE_FREE(hmd->indexar);
819     hmd->indexar = buffer;
820     hmd->totindex = indices_len;
821   }
822 }
823
824 static PointerRNA rna_UVProjector_object_get(PointerRNA *ptr)
825 {
826   Object **ob = (Object **)ptr->data;
827   return rna_pointer_inherit_refine(ptr, &RNA_Object, *ob);
828 }
829
830 static void rna_UVProjector_object_set(PointerRNA *ptr,
831                                        PointerRNA value,
832                                        struct ReportList *UNUSED(reports))
833 {
834   Object **ob_p = (Object **)ptr->data;
835   Object *ob = (Object *)value.data;
836   id_lib_extern((ID *)ob);
837   *ob_p = ob;
838 }
839
840 #  undef RNA_MOD_OBJECT_SET
841
842 /* Other rna callbacks */
843
844 static void rna_Smoke_set_type(Main *bmain, Scene *scene, PointerRNA *ptr)
845 {
846   SmokeModifierData *smd = (SmokeModifierData *)ptr->data;
847   Object *ob = (Object *)ptr->id.data;
848
849   /* nothing changed */
850   if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain)
851     return;
852
853   smokeModifier_free(smd);       /* XXX TODO: completely free all 3 pointers */
854   smokeModifier_createType(smd); /* create regarding of selected type */
855
856   switch (smd->type) {
857     case MOD_SMOKE_TYPE_DOMAIN:
858       ob->dt = OB_WIRE;
859       break;
860     case MOD_SMOKE_TYPE_FLOW:
861     case MOD_SMOKE_TYPE_COLL:
862     case 0:
863     default:
864       break;
865   }
866
867   /* update dependency since a domain - other type switch could have happened */
868   rna_Modifier_dependency_update(bmain, scene, ptr);
869 }
870
871 static void rna_MultiresModifier_type_set(PointerRNA *ptr, int value)
872 {
873   Object *ob = (Object *)ptr->id.data;
874   MultiresModifierData *mmd = (MultiresModifierData *)ptr->data;
875
876   multires_force_update(ob);
877   mmd->simple = value;
878 }
879
880 static void rna_MultiresModifier_level_range(
881     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
882 {
883   MultiresModifierData *mmd = (MultiresModifierData *)ptr->data;
884
885   *min = 0;
886   *max = max_ii(0, mmd->totlvl); /* intentionally _not_ -1 */
887 }
888
889 static bool rna_MultiresModifier_external_get(PointerRNA *ptr)
890 {
891   Object *ob = (Object *)ptr->id.data;
892   Mesh *me = ob->data;
893
894   return CustomData_external_test(&me->ldata, CD_MDISPS);
895 }
896
897 static void rna_MultiresModifier_filepath_get(PointerRNA *ptr, char *value)
898 {
899   Object *ob = (Object *)ptr->id.data;
900   CustomDataExternal *external = ((Mesh *)ob->data)->ldata.external;
901
902   BLI_strncpy(value, (external) ? external->filename : "", sizeof(external->filename));
903 }
904
905 static void rna_MultiresModifier_filepath_set(PointerRNA *ptr, const char *value)
906 {
907   Object *ob = (Object *)ptr->id.data;
908   CustomDataExternal *external = ((Mesh *)ob->data)->ldata.external;
909
910   if (external && !STREQ(external->filename, value)) {
911     BLI_strncpy(external->filename, value, sizeof(external->filename));
912     multires_force_external_reload(ob);
913   }
914 }
915
916 static int rna_MultiresModifier_filepath_length(PointerRNA *ptr)
917 {
918   Object *ob = (Object *)ptr->id.data;
919   CustomDataExternal *external = ((Mesh *)ob->data)->ldata.external;
920
921   return strlen((external) ? external->filename : "");
922 }
923
924 static int rna_ShrinkwrapModifier_face_cull_get(PointerRNA *ptr)
925 {
926   ShrinkwrapModifierData *swm = (ShrinkwrapModifierData *)ptr->data;
927   return swm->shrinkOpts & MOD_SHRINKWRAP_CULL_TARGET_MASK;
928 }
929
930 static void rna_ShrinkwrapModifier_face_cull_set(struct PointerRNA *ptr, int value)
931 {
932   ShrinkwrapModifierData *swm = (ShrinkwrapModifierData *)ptr->data;
933   swm->shrinkOpts = (swm->shrinkOpts & ~MOD_SHRINKWRAP_CULL_TARGET_MASK) | value;
934 }
935
936 static bool rna_MeshDeformModifier_is_bound_get(PointerRNA *ptr)
937 {
938   return (((MeshDeformModifierData *)ptr->data)->bindcagecos != NULL);
939 }
940
941 static PointerRNA rna_SoftBodyModifier_settings_get(PointerRNA *ptr)
942 {
943   Object *ob = (Object *)ptr->id.data;
944   return rna_pointer_inherit_refine(ptr, &RNA_SoftBodySettings, ob->soft);
945 }
946
947 static PointerRNA rna_SoftBodyModifier_point_cache_get(PointerRNA *ptr)
948 {
949   Object *ob = (Object *)ptr->id.data;
950   return rna_pointer_inherit_refine(ptr, &RNA_PointCache, ob->soft->shared->pointcache);
951 }
952
953 static PointerRNA rna_CollisionModifier_settings_get(PointerRNA *ptr)
954 {
955   Object *ob = (Object *)ptr->id.data;
956   return rna_pointer_inherit_refine(ptr, &RNA_CollisionSettings, ob->pd);
957 }
958
959 static void rna_UVProjectModifier_num_projectors_set(PointerRNA *ptr, int value)
960 {
961   UVProjectModifierData *md = (UVProjectModifierData *)ptr->data;
962   int a;
963
964   md->num_projectors = CLAMPIS(value, 1, MOD_UVPROJECT_MAXPROJECTORS);
965   for (a = md->num_projectors; a < MOD_UVPROJECT_MAXPROJECTORS; a++)
966     md->projectors[a] = NULL;
967 }
968
969 static void rna_OceanModifier_init_update(Main *bmain, Scene *scene, PointerRNA *ptr)
970 {
971   OceanModifierData *omd = (OceanModifierData *)ptr->data;
972
973   BKE_ocean_free_modifier_cache(omd);
974   rna_Modifier_update(bmain, scene, ptr);
975 }
976
977 static void rna_OceanModifier_ocean_chop_set(PointerRNA *ptr, float value)
978 {
979   OceanModifierData *omd = (OceanModifierData *)ptr->data;
980   float old_value = omd->chop_amount;
981
982   omd->chop_amount = value;
983
984   if ((old_value == 0.0f && value > 0.0f) || (old_value > 0.0f && value == 0.0f)) {
985     BKE_ocean_free_modifier_cache(omd);
986   }
987 }
988
989 static bool rna_LaplacianDeformModifier_is_bind_get(PointerRNA *ptr)
990 {
991   LaplacianDeformModifierData *lmd = (LaplacianDeformModifierData *)ptr->data;
992   return ((lmd->flag & MOD_LAPLACIANDEFORM_BIND) && (lmd->vertexco != NULL));
993 }
994
995 /* NOTE: Curve and array modifiers requires curve path to be evaluated,
996  * dependency graph will make sure that curve eval would create such a path,
997  * but if curve was already evaluated we might miss path.
998  *
999  * So what we do here is: if path was not calculated for target curve we
1000  * tag it for update.
1001  */
1002
1003 static void rna_CurveModifier_dependency_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1004 {
1005   CurveModifierData *cmd = (CurveModifierData *)ptr->data;
1006   rna_Modifier_update(bmain, scene, ptr);
1007   DEG_relations_tag_update(bmain);
1008   if (cmd->object != NULL) {
1009     Curve *curve = cmd->object->data;
1010     if ((curve->flag & CU_PATH) == 0) {
1011       DEG_id_tag_update(&curve->id, ID_RECALC_GEOMETRY);
1012     }
1013   }
1014 }
1015
1016 static void rna_ArrayModifier_dependency_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1017 {
1018   ArrayModifierData *amd = (ArrayModifierData *)ptr->data;
1019   rna_Modifier_update(bmain, scene, ptr);
1020   DEG_relations_tag_update(bmain);
1021   if (amd->curve_ob != NULL) {
1022     Curve *curve = amd->curve_ob->data;
1023     if ((curve->flag & CU_PATH) == 0) {
1024       DEG_id_tag_update(&curve->id, ID_RECALC_GEOMETRY);
1025     }
1026   }
1027 }
1028
1029 static void rna_DataTransferModifier_use_data_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1030 {
1031   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1032
1033   if (!(dtmd->flags & MOD_DATATRANSFER_USE_VERT)) {
1034     dtmd->data_types &= ~DT_TYPE_VERT_ALL;
1035   }
1036   if (!(dtmd->flags & MOD_DATATRANSFER_USE_EDGE)) {
1037     dtmd->data_types &= ~DT_TYPE_EDGE_ALL;
1038   }
1039   if (!(dtmd->flags & MOD_DATATRANSFER_USE_LOOP)) {
1040     dtmd->data_types &= ~DT_TYPE_LOOP_ALL;
1041   }
1042   if (!(dtmd->flags & MOD_DATATRANSFER_USE_POLY)) {
1043     dtmd->data_types &= ~DT_TYPE_POLY_ALL;
1044   }
1045
1046   rna_Modifier_dependency_update(bmain, scene, ptr);
1047 }
1048
1049 static void rna_DataTransferModifier_data_types_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1050 {
1051   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1052   const int item_types = BKE_object_data_transfer_get_dttypes_item_types(dtmd->data_types);
1053
1054   if (item_types & ME_VERT) {
1055     dtmd->flags |= MOD_DATATRANSFER_USE_VERT;
1056   }
1057   if (item_types & ME_EDGE) {
1058     dtmd->flags |= MOD_DATATRANSFER_USE_EDGE;
1059   }
1060   if (item_types & ME_LOOP) {
1061     dtmd->flags |= MOD_DATATRANSFER_USE_LOOP;
1062   }
1063   if (item_types & ME_POLY) {
1064     dtmd->flags |= MOD_DATATRANSFER_USE_POLY;
1065   }
1066
1067   rna_Modifier_dependency_update(bmain, scene, ptr);
1068 }
1069
1070 static void rna_DataTransferModifier_verts_data_types_set(struct PointerRNA *ptr, int value)
1071 {
1072   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1073
1074   dtmd->data_types &= ~DT_TYPE_VERT_ALL;
1075   dtmd->data_types |= value;
1076 }
1077
1078 static void rna_DataTransferModifier_edges_data_types_set(struct PointerRNA *ptr, int value)
1079 {
1080   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1081
1082   dtmd->data_types &= ~DT_TYPE_EDGE_ALL;
1083   dtmd->data_types |= value;
1084 }
1085
1086 static void rna_DataTransferModifier_loops_data_types_set(struct PointerRNA *ptr, int value)
1087 {
1088   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1089
1090   dtmd->data_types &= ~DT_TYPE_LOOP_ALL;
1091   dtmd->data_types |= value;
1092 }
1093
1094 static void rna_DataTransferModifier_polys_data_types_set(struct PointerRNA *ptr, int value)
1095 {
1096   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1097
1098   dtmd->data_types &= ~DT_TYPE_POLY_ALL;
1099   dtmd->data_types |= value;
1100 }
1101
1102 static const EnumPropertyItem *rna_DataTransferModifier_layers_select_src_itemf(bContext *C,
1103                                                                                 PointerRNA *ptr,
1104                                                                                 PropertyRNA *prop,
1105                                                                                 bool *r_free)
1106 {
1107   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1108   EnumPropertyItem *item = NULL, tmp_item = {0};
1109   int totitem = 0;
1110
1111   if (!C) { /* needed for docs and i18n tools */
1112     return rna_enum_dt_layers_select_src_items;
1113   }
1114
1115   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1116
1117   /* No active here! */
1118   RNA_enum_items_add_value(
1119       &item, &totitem, rna_enum_dt_layers_select_src_items, DT_LAYERS_ALL_SRC);
1120
1121   if (STREQ(RNA_property_identifier(prop), "layers_vgroup_select_src")) {
1122     Object *ob_src = dtmd->ob_source;
1123
1124 #  if 0 /* XXX Don't think we want this in modifier version... */
1125     if (BKE_object_pose_armature_get(ob_src)) {
1126       RNA_enum_items_add_value(
1127           &item, &totitem, rna_enum_dt_layers_select_src_items, DT_LAYERS_VGROUP_SRC_BONE_SELECT);
1128       RNA_enum_items_add_value(
1129           &item, &totitem, rna_enum_dt_layers_select_src_items, DT_LAYERS_VGROUP_SRC_BONE_DEFORM);
1130     }
1131 #  endif
1132
1133     if (ob_src) {
1134       bDeformGroup *dg;
1135       int i;
1136
1137       RNA_enum_item_add_separator(&item, &totitem);
1138
1139       for (i = 0, dg = ob_src->defbase.first; dg; i++, dg = dg->next) {
1140         tmp_item.value = i;
1141         tmp_item.identifier = tmp_item.name = dg->name;
1142         RNA_enum_item_add(&item, &totitem, &tmp_item);
1143       }
1144     }
1145   }
1146   else if (STREQ(RNA_property_identifier(prop), "layers_shapekey_select_src")) {
1147     /* TODO */
1148   }
1149   else if (STREQ(RNA_property_identifier(prop), "layers_uv_select_src")) {
1150     Object *ob_src = dtmd->ob_source;
1151
1152     if (ob_src) {
1153       Mesh *me_eval;
1154       int num_data, i;
1155
1156       Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
1157       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
1158
1159       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
1160       cddata_masks.lmask |= CD_MASK_MLOOPUV;
1161       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
1162       num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPUV);
1163
1164       RNA_enum_item_add_separator(&item, &totitem);
1165
1166       for (i = 0; i < num_data; i++) {
1167         tmp_item.value = i;
1168         tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(
1169             &me_eval->ldata, CD_MLOOPUV, i);
1170         RNA_enum_item_add(&item, &totitem, &tmp_item);
1171       }
1172     }
1173   }
1174   else if (STREQ(RNA_property_identifier(prop), "layers_vcol_select_src")) {
1175     Object *ob_src = dtmd->ob_source;
1176
1177     if (ob_src) {
1178       Mesh *me_eval;
1179       int num_data, i;
1180
1181       Scene *scene_eval = DEG_get_evaluated_scene(depsgraph);
1182       Object *ob_src_eval = DEG_get_evaluated_object(depsgraph, ob_src);
1183
1184       CustomData_MeshMasks cddata_masks = CD_MASK_BAREMESH;
1185       cddata_masks.lmask |= CD_MASK_MLOOPCOL;
1186       me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_src_eval, &cddata_masks);
1187       num_data = CustomData_number_of_layers(&me_eval->ldata, CD_MLOOPCOL);
1188
1189       RNA_enum_item_add_separator(&item, &totitem);
1190
1191       for (i = 0; i < num_data; i++) {
1192         tmp_item.value = i;
1193         tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(
1194             &me_eval->ldata, CD_MLOOPCOL, i);
1195         RNA_enum_item_add(&item, &totitem, &tmp_item);
1196       }
1197     }
1198   }
1199
1200   RNA_enum_item_end(&item, &totitem);
1201   *r_free = true;
1202
1203   return item;
1204 }
1205
1206 static const EnumPropertyItem *rna_DataTransferModifier_layers_select_dst_itemf(bContext *C,
1207                                                                                 PointerRNA *ptr,
1208                                                                                 PropertyRNA *prop,
1209                                                                                 bool *r_free)
1210 {
1211   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1212   EnumPropertyItem *item = NULL, tmp_item = {0};
1213   int totitem = 0;
1214
1215   if (!C) { /* needed for docs and i18n tools */
1216     return rna_enum_dt_layers_select_dst_items;
1217   }
1218
1219   /* No active here! */
1220   RNA_enum_items_add_value(
1221       &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_NAME_DST);
1222   RNA_enum_items_add_value(
1223       &item, &totitem, rna_enum_dt_layers_select_dst_items, DT_LAYERS_INDEX_DST);
1224
1225   if (STREQ(RNA_property_identifier(prop), "layers_vgroup_select_dst")) {
1226     /* Only list destination layers if we have a single source! */
1227     if (dtmd->layers_select_src[DT_MULTILAYER_INDEX_MDEFORMVERT] >= 0) {
1228       Object *ob_dst = CTX_data_active_object(C); /* XXX Is this OK? */
1229
1230       if (ob_dst) {
1231         bDeformGroup *dg;
1232         int i;
1233
1234         RNA_enum_item_add_separator(&item, &totitem);
1235
1236         for (i = 0, dg = ob_dst->defbase.first; dg; i++, dg = dg->next) {
1237           tmp_item.value = i;
1238           tmp_item.identifier = tmp_item.name = dg->name;
1239           RNA_enum_item_add(&item, &totitem, &tmp_item);
1240         }
1241       }
1242     }
1243   }
1244   else if (STREQ(RNA_property_identifier(prop), "layers_shapekey_select_dst")) {
1245     /* TODO */
1246   }
1247   else if (STREQ(RNA_property_identifier(prop), "layers_uv_select_dst")) {
1248     /* Only list destination layers if we have a single source! */
1249     if (dtmd->layers_select_src[DT_MULTILAYER_INDEX_UV] >= 0) {
1250       Object *ob_dst = CTX_data_active_object(C); /* XXX Is this OK? */
1251
1252       if (ob_dst && ob_dst->data) {
1253         Mesh *me_dst;
1254         CustomData *ldata;
1255         int num_data, i;
1256
1257         me_dst = ob_dst->data;
1258         ldata = &me_dst->ldata;
1259         num_data = CustomData_number_of_layers(ldata, CD_MLOOPUV);
1260
1261         RNA_enum_item_add_separator(&item, &totitem);
1262
1263         for (i = 0; i < num_data; i++) {
1264           tmp_item.value = i;
1265           tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(ldata, CD_MLOOPUV, i);
1266           RNA_enum_item_add(&item, &totitem, &tmp_item);
1267         }
1268       }
1269     }
1270   }
1271   else if (STREQ(RNA_property_identifier(prop), "layers_vcol_select_dst")) {
1272     /* Only list destination layers if we have a single source! */
1273     if (dtmd->layers_select_src[DT_MULTILAYER_INDEX_VCOL] >= 0) {
1274       Object *ob_dst = CTX_data_active_object(C); /* XXX Is this OK? */
1275
1276       if (ob_dst && ob_dst->data) {
1277         Mesh *me_dst;
1278         CustomData *ldata;
1279         int num_data, i;
1280
1281         me_dst = ob_dst->data;
1282         ldata = &me_dst->ldata;
1283         num_data = CustomData_number_of_layers(ldata, CD_MLOOPCOL);
1284
1285         RNA_enum_item_add_separator(&item, &totitem);
1286
1287         for (i = 0; i < num_data; i++) {
1288           tmp_item.value = i;
1289           tmp_item.identifier = tmp_item.name = CustomData_get_layer_name(ldata, CD_MLOOPCOL, i);
1290           RNA_enum_item_add(&item, &totitem, &tmp_item);
1291         }
1292       }
1293     }
1294   }
1295
1296   RNA_enum_item_end(&item, &totitem);
1297   *r_free = true;
1298
1299   return item;
1300 }
1301
1302 static const EnumPropertyItem *rna_DataTransferModifier_mix_mode_itemf(bContext *C,
1303                                                                        PointerRNA *ptr,
1304                                                                        PropertyRNA *UNUSED(prop),
1305                                                                        bool *r_free)
1306 {
1307   DataTransferModifierData *dtmd = (DataTransferModifierData *)ptr->data;
1308   EnumPropertyItem *item = NULL;
1309   int totitem = 0;
1310
1311   bool support_advanced_mixing, support_threshold;
1312
1313   if (!C) { /* needed for docs and i18n tools */
1314     return rna_enum_dt_mix_mode_items;
1315   }
1316
1317   RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_TRANSFER);
1318
1319   BKE_object_data_transfer_get_dttypes_capacity(
1320       dtmd->data_types, &support_advanced_mixing, &support_threshold);
1321
1322   if (support_threshold) {
1323     RNA_enum_items_add_value(
1324         &item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_REPLACE_ABOVE_THRESHOLD);
1325     RNA_enum_items_add_value(
1326         &item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_REPLACE_BELOW_THRESHOLD);
1327   }
1328
1329   if (support_advanced_mixing) {
1330     RNA_enum_item_add_separator(&item, &totitem);
1331     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_MIX);
1332     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_ADD);
1333     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_SUB);
1334     RNA_enum_items_add_value(&item, &totitem, rna_enum_dt_mix_mode_items, CDT_MIX_MUL);
1335   }
1336
1337   RNA_enum_item_end(&item, &totitem);
1338   *r_free = true;
1339
1340   return item;
1341 }
1342
1343 static void rna_CorrectiveSmoothModifier_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1344 {
1345   CorrectiveSmoothModifierData *csmd = (CorrectiveSmoothModifierData *)ptr->data;
1346
1347   MEM_SAFE_FREE(csmd->delta_cache);
1348
1349   rna_Modifier_update(bmain, scene, ptr);
1350 }
1351
1352 static void rna_CorrectiveSmoothModifier_rest_source_update(Main *bmain,
1353                                                             Scene *scene,
1354                                                             PointerRNA *ptr)
1355 {
1356   CorrectiveSmoothModifierData *csmd = (CorrectiveSmoothModifierData *)ptr->data;
1357
1358   if (csmd->rest_source != MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND) {
1359     MEM_SAFE_FREE(csmd->bind_coords);
1360     csmd->bind_coords_num = 0;
1361   }
1362
1363   rna_CorrectiveSmoothModifier_update(bmain, scene, ptr);
1364 }
1365
1366 static bool rna_CorrectiveSmoothModifier_is_bind_get(PointerRNA *ptr)
1367 {
1368   CorrectiveSmoothModifierData *csmd = (CorrectiveSmoothModifierData *)ptr->data;
1369   return (csmd->bind_coords != NULL);
1370 }
1371
1372 static bool rna_SurfaceDeformModifier_is_bound_get(PointerRNA *ptr)
1373 {
1374   return (((SurfaceDeformModifierData *)ptr->data)->verts != NULL);
1375 }
1376
1377 static bool rna_ParticleInstanceModifier_particle_system_poll(PointerRNA *ptr,
1378                                                               const PointerRNA value)
1379 {
1380   ParticleInstanceModifierData *psmd = ptr->data;
1381   ParticleSystem *psys = value.data;
1382
1383   if (!psmd->ob)
1384     return false;
1385
1386   /* make sure psys is in the object */
1387   return BLI_findindex(&psmd->ob->particlesystem, psys) != -1;
1388 }
1389
1390 static PointerRNA rna_ParticleInstanceModifier_particle_system_get(PointerRNA *ptr)
1391 {
1392   ParticleInstanceModifierData *psmd = ptr->data;
1393   ParticleSystem *psys;
1394   PointerRNA rptr;
1395
1396   if (!psmd->ob)
1397     return PointerRNA_NULL;
1398
1399   psys = BLI_findlink(&psmd->ob->particlesystem, psmd->psys - 1);
1400   RNA_pointer_create((ID *)psmd->ob, &RNA_ParticleSystem, psys, &rptr);
1401   return rptr;
1402 }
1403
1404 static void rna_ParticleInstanceModifier_particle_system_set(PointerRNA *ptr,
1405                                                              const PointerRNA value,
1406                                                              struct ReportList *UNUSED(reports))
1407 {
1408   ParticleInstanceModifierData *psmd = ptr->data;
1409
1410   if (!psmd->ob)
1411     return;
1412
1413   psmd->psys = BLI_findindex(&psmd->ob->particlesystem, value.data) + 1;
1414   CLAMP_MIN(psmd->psys, 1);
1415 }
1416
1417 #else
1418
1419 /* NOTE: *MUST* return subdivision_type property. */
1420 static PropertyRNA *rna_def_property_subdivision_common(StructRNA *srna, const char type[])
1421 {
1422   static const EnumPropertyItem prop_subdivision_type_items[] = {
1423       {SUBSURF_TYPE_CATMULL_CLARK, "CATMULL_CLARK", 0, "Catmull-Clark", ""},
1424       {SUBSURF_TYPE_SIMPLE, "SIMPLE", 0, "Simple", ""},
1425       {0, NULL, 0, NULL, NULL},
1426   };
1427
1428   static const EnumPropertyItem prop_uv_smooth_items[] = {
1429     {SUBSURF_UV_SMOOTH_NONE,
1430      "NONE",
1431      0,
1432      "Sharp",
1433      "UVs are not smoothed, boundaries are kept sharp"},
1434     {SUBSURF_UV_SMOOTH_PRESERVE_CORNERS,
1435      "PRESERVE_CORNERS",
1436      0,
1437      "Smooth, keep corners",
1438      "UVs are smoothed, corners on discontinuous boundary are kept sharp"},
1439 #  if 0
1440     {SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_AND_JUNCTIONS,
1441      "PRESERVE_CORNERS_AND_JUNCTIONS",
1442      0,
1443      "Smooth, keep corners+junctions",
1444      "UVs are smoothed, corners on discontinuous boundary and "
1445      "junctions of 3 or more regions are kept sharp"},
1446     {SUBSURF_UV_SMOOTH_PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE,
1447      "PRESERVE_CORNERS_JUNCTIONS_AND_CONCAVE",
1448      0,
1449      "Smooth, keep corners+junctions+concave",
1450      "UVs are smoothed, corners on discontinuous boundary, "
1451      "junctions of 3 or more regions and darts and concave corners are kept sharp"},
1452     {SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES,
1453      "PRESERVE_BOUNDARIES",
1454      0,
1455      "Smooth, keep corners",
1456      "UVs are smoothed, boundaries are kept sharp"},
1457     {SUBSURF_UV_SMOOTH_ALL,
1458      "PRESERVE_BOUNDARIES",
1459      0,
1460      "Smooth all",
1461      "UVs and boundaries are smoothed"},
1462 #  endif
1463     {0, NULL, 0, NULL, NULL},
1464   };
1465
1466   PropertyRNA *prop;
1467
1468   prop = RNA_def_property(srna, "uv_smooth", PROP_ENUM, PROP_NONE);
1469   RNA_def_property_enum_sdna(prop, NULL, "uv_smooth");
1470   RNA_def_property_enum_items(prop, prop_uv_smooth_items);
1471   RNA_def_property_ui_text(prop, "UV Smooth", "Controls how smoothing is applied to UVs");
1472   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1473
1474   prop = RNA_def_property(srna, "quality", PROP_INT, PROP_UNSIGNED);
1475   RNA_def_property_int_sdna(prop, NULL, "quality");
1476   RNA_def_property_range(prop, 1, 10);
1477   RNA_def_property_ui_range(prop, 1, 6, 1, -1);
1478   RNA_def_property_ui_text(
1479       prop, "Quality", "Accuracy of vertex positions, lower value is faster but less precise");
1480   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1481
1482   prop = RNA_def_property(srna, "subdivision_type", PROP_ENUM, PROP_NONE);
1483   RNA_def_property_enum_sdna(prop, NULL, type);
1484   RNA_def_property_enum_items(prop, prop_subdivision_type_items);
1485   RNA_def_property_ui_text(prop, "Subdivision Type", "Select type of subdivision algorithm");
1486   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1487
1488   return prop;
1489 }
1490
1491 static void rna_def_modifier_subsurf(BlenderRNA *brna)
1492 {
1493   StructRNA *srna;
1494   PropertyRNA *prop;
1495
1496   srna = RNA_def_struct(brna, "SubsurfModifier", "Modifier");
1497   RNA_def_struct_ui_text(srna, "Subsurf Modifier", "Subdivision surface modifier");
1498   RNA_def_struct_sdna(srna, "SubsurfModifierData");
1499   RNA_def_struct_ui_icon(srna, ICON_MOD_SUBSURF);
1500
1501   rna_def_property_subdivision_common(srna, "subdivType");
1502
1503   /* see CCGSUBSURF_LEVEL_MAX for max limit */
1504   prop = RNA_def_property(srna, "levels", PROP_INT, PROP_UNSIGNED);
1505   RNA_def_property_int_sdna(prop, NULL, "levels");
1506   RNA_def_property_range(prop, 0, 11);
1507   RNA_def_property_ui_range(prop, 0, 6, 1, -1);
1508   RNA_def_property_ui_text(prop, "Levels", "Number of subdivisions to perform");
1509   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1510
1511   prop = RNA_def_property(srna, "render_levels", PROP_INT, PROP_UNSIGNED);
1512   RNA_def_property_int_sdna(prop, NULL, "renderLevels");
1513   RNA_def_property_range(prop, 0, 11);
1514   RNA_def_property_ui_range(prop, 0, 6, 1, -1);
1515   RNA_def_property_ui_text(
1516       prop, "Render Levels", "Number of subdivisions to perform when rendering");
1517
1518   prop = RNA_def_property(srna, "show_only_control_edges", PROP_BOOLEAN, PROP_NONE);
1519   RNA_def_property_boolean_sdna(prop, NULL, "flags", eSubsurfModifierFlag_ControlEdges);
1520   RNA_def_property_ui_text(
1521       prop, "Optimal Display", "Skip drawing/rendering of interior subdivided edges");
1522   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1523
1524   prop = RNA_def_property(srna, "use_creases", PROP_BOOLEAN, PROP_NONE);
1525   RNA_def_property_boolean_sdna(prop, NULL, "flags", eSubsurfModifierFlag_UseCrease);
1526   RNA_def_property_ui_text(
1527       prop, "Use Creases", "Use mesh edge crease information to sharpen edges");
1528   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1529 }
1530
1531 static void rna_def_modifier_generic_map_info(StructRNA *srna)
1532 {
1533   static const EnumPropertyItem prop_texture_coordinates_items[] = {
1534       {MOD_DISP_MAP_LOCAL,
1535        "LOCAL",
1536        0,
1537        "Local",
1538        "Use the local coordinate system for the texture coordinates"},
1539       {MOD_DISP_MAP_GLOBAL,
1540        "GLOBAL",
1541        0,
1542        "Global",
1543        "Use the global coordinate system for the texture coordinates"},
1544       {MOD_DISP_MAP_OBJECT,
1545        "OBJECT",
1546        0,
1547        "Object",
1548        "Use the linked object's local coordinate system for the texture coordinates"},
1549       {MOD_DISP_MAP_UV, "UV", 0, "UV", "Use UV coordinates for the texture coordinates"},
1550       {0, NULL, 0, NULL, NULL},
1551   };
1552
1553   PropertyRNA *prop;
1554
1555   prop = RNA_def_property(srna, "texture", PROP_POINTER, PROP_NONE);
1556   RNA_def_property_ui_text(prop, "Texture", "");
1557   RNA_def_property_flag(prop, PROP_EDITABLE);
1558   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
1559
1560   prop = RNA_def_property(srna, "texture_coords", PROP_ENUM, PROP_NONE);
1561   RNA_def_property_enum_sdna(prop, NULL, "texmapping");
1562   RNA_def_property_enum_items(prop, prop_texture_coordinates_items);
1563   RNA_def_property_ui_text(prop, "Texture Coordinates", "");
1564   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
1565
1566   prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
1567   RNA_def_property_string_sdna(prop, NULL, "uvlayer_name");
1568   RNA_def_property_ui_text(prop, "UV Map", "UV map name");
1569   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MappingInfoModifier_uvlayer_name_set");
1570   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1571
1572   prop = RNA_def_property(srna, "texture_coords_object", PROP_POINTER, PROP_NONE);
1573   RNA_def_property_pointer_sdna(prop, NULL, "map_object");
1574   RNA_def_property_ui_text(
1575       prop, "Texture Coordinate Object", "Object to set the texture coordinates");
1576   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1577   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
1578 }
1579
1580 static void rna_def_modifier_warp(BlenderRNA *brna)
1581 {
1582   StructRNA *srna;
1583   PropertyRNA *prop;
1584
1585   srna = RNA_def_struct(brna, "WarpModifier", "Modifier");
1586   RNA_def_struct_ui_text(srna, "Warp Modifier", "Warp modifier");
1587   RNA_def_struct_sdna(srna, "WarpModifierData");
1588   RNA_def_struct_ui_icon(srna, ICON_MOD_WARP);
1589
1590   prop = RNA_def_property(srna, "object_from", PROP_POINTER, PROP_NONE);
1591   RNA_def_property_ui_text(prop, "From", "Object to transform from");
1592   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1593   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
1594
1595   prop = RNA_def_property(srna, "object_to", PROP_POINTER, PROP_NONE);
1596   RNA_def_property_ui_text(prop, "To", "Object to transform to");
1597   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1598   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
1599
1600   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
1601   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1602   RNA_def_property_ui_range(prop, -100, 100, 10, 2);
1603   RNA_def_property_ui_text(prop, "Strength", "");
1604   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1605
1606   prop = RNA_def_property(srna, "falloff_type", PROP_ENUM, PROP_NONE);
1607   RNA_def_property_enum_items(prop, modifier_warp_falloff_items);
1608   RNA_def_property_ui_text(prop, "Falloff Type", "");
1609   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
1610   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1611
1612   prop = RNA_def_property(srna, "falloff_radius", PROP_FLOAT, PROP_UNSIGNED | PROP_DISTANCE);
1613   RNA_def_property_ui_text(prop, "Radius", "Radius to apply");
1614   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1615
1616   prop = RNA_def_property(srna, "falloff_curve", PROP_POINTER, PROP_NONE);
1617   RNA_def_property_pointer_sdna(prop, NULL, "curfalloff");
1618   RNA_def_property_ui_text(prop, "Falloff Curve", "Custom falloff curve");
1619   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1620
1621   prop = RNA_def_property(srna, "use_volume_preserve", PROP_BOOLEAN, PROP_NONE);
1622   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WARP_VOLUME_PRESERVE);
1623   RNA_def_property_ui_text(prop, "Preserve Volume", "Preserve volume when rotations are used");
1624   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1625
1626   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
1627   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
1628   RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the deform");
1629   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_WarpModifier_defgrp_name_set");
1630   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1631
1632   rna_def_modifier_generic_map_info(srna);
1633 }
1634
1635 static void rna_def_modifier_multires(BlenderRNA *brna)
1636 {
1637   StructRNA *srna;
1638   PropertyRNA *prop;
1639
1640   srna = RNA_def_struct(brna, "MultiresModifier", "Modifier");
1641   RNA_def_struct_ui_text(srna, "Multires Modifier", "Multiresolution mesh modifier");
1642   RNA_def_struct_sdna(srna, "MultiresModifierData");
1643   RNA_def_struct_ui_icon(srna, ICON_MOD_MULTIRES);
1644
1645   prop = rna_def_property_subdivision_common(srna, "simple");
1646   RNA_def_property_enum_funcs(prop, NULL, "rna_MultiresModifier_type_set", NULL);
1647
1648   prop = RNA_def_property(srna, "levels", PROP_INT, PROP_UNSIGNED);
1649   RNA_def_property_int_sdna(prop, NULL, "lvl");
1650   RNA_def_property_ui_text(prop, "Levels", "Number of subdivisions to use in the viewport");
1651   RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MultiresModifier_level_range");
1652   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1653
1654   prop = RNA_def_property(srna, "sculpt_levels", PROP_INT, PROP_UNSIGNED);
1655   RNA_def_property_int_sdna(prop, NULL, "sculptlvl");
1656   RNA_def_property_ui_text(prop, "Sculpt Levels", "Number of subdivisions to use in sculpt mode");
1657   RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MultiresModifier_level_range");
1658   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1659
1660   prop = RNA_def_property(srna, "render_levels", PROP_INT, PROP_UNSIGNED);
1661   RNA_def_property_int_sdna(prop, NULL, "renderlvl");
1662   RNA_def_property_ui_text(prop, "Render Levels", "The subdivision level visible at render time");
1663   RNA_def_property_int_funcs(prop, NULL, NULL, "rna_MultiresModifier_level_range");
1664
1665   prop = RNA_def_property(srna, "total_levels", PROP_INT, PROP_UNSIGNED);
1666   RNA_def_property_int_sdna(prop, NULL, "totlvl");
1667   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1668   RNA_def_property_ui_text(
1669       prop, "Total Levels", "Number of subdivisions for which displacements are stored");
1670
1671   prop = RNA_def_property(srna, "is_external", PROP_BOOLEAN, PROP_NONE);
1672   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1673   RNA_def_property_boolean_funcs(prop, "rna_MultiresModifier_external_get", NULL);
1674   RNA_def_property_ui_text(
1675       prop, "External", "Store multires displacements outside the .blend file, to save memory");
1676
1677   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1678   RNA_def_property_string_funcs(prop,
1679                                 "rna_MultiresModifier_filepath_get",
1680                                 "rna_MultiresModifier_filepath_length",
1681                                 "rna_MultiresModifier_filepath_set");
1682   RNA_def_property_ui_text(prop, "File Path", "Path to external displacements file");
1683   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1684
1685   prop = RNA_def_property(srna, "show_only_control_edges", PROP_BOOLEAN, PROP_NONE);
1686   RNA_def_property_boolean_sdna(prop, NULL, "flags", eMultiresModifierFlag_ControlEdges);
1687   RNA_def_property_ui_text(
1688       prop, "Optimal Display", "Skip drawing/rendering of interior subdivided edges");
1689   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1690
1691   prop = RNA_def_property(srna, "use_creases", PROP_BOOLEAN, PROP_NONE);
1692   RNA_def_property_boolean_sdna(prop, NULL, "flags", eMultiresModifierFlag_UseCrease);
1693   RNA_def_property_ui_text(
1694       prop, "Use Creases", "Use mesh edge crease information to sharpen edges");
1695   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1696 }
1697
1698 static void rna_def_modifier_lattice(BlenderRNA *brna)
1699 {
1700   StructRNA *srna;
1701   PropertyRNA *prop;
1702
1703   srna = RNA_def_struct(brna, "LatticeModifier", "Modifier");
1704   RNA_def_struct_ui_text(srna, "Lattice Modifier", "Lattice deformation modifier");
1705   RNA_def_struct_sdna(srna, "LatticeModifierData");
1706   RNA_def_struct_ui_icon(srna, ICON_MOD_LATTICE);
1707
1708   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1709   RNA_def_property_ui_text(prop, "Object", "Lattice object to deform with");
1710   RNA_def_property_pointer_funcs(
1711       prop, NULL, "rna_LatticeModifier_object_set", NULL, "rna_Lattice_object_poll");
1712   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1713   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
1714
1715   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
1716   RNA_def_property_string_sdna(prop, NULL, "name");
1717   RNA_def_property_ui_text(
1718       prop,
1719       "Vertex Group",
1720       "Name of Vertex Group which determines influence of modifier per point");
1721   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_LatticeModifier_name_set");
1722   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1723
1724   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
1725   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1726   RNA_def_property_ui_range(prop, 0, 1, 10, 2);
1727   RNA_def_property_ui_text(prop, "Strength", "Strength of modifier effect");
1728   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1729 }
1730
1731 static void rna_def_modifier_curve(BlenderRNA *brna)
1732 {
1733   StructRNA *srna;
1734   PropertyRNA *prop;
1735
1736   static const EnumPropertyItem prop_deform_axis_items[] = {
1737       {MOD_CURVE_POSX, "POS_X", 0, "X", ""},
1738       {MOD_CURVE_POSY, "POS_Y", 0, "Y", ""},
1739       {MOD_CURVE_POSZ, "POS_Z", 0, "Z", ""},
1740       {MOD_CURVE_NEGX, "NEG_X", 0, "-X", ""},
1741       {MOD_CURVE_NEGY, "NEG_Y", 0, "-Y", ""},
1742       {MOD_CURVE_NEGZ, "NEG_Z", 0, "-Z", ""},
1743       {0, NULL, 0, NULL, NULL},
1744   };
1745
1746   srna = RNA_def_struct(brna, "CurveModifier", "Modifier");
1747   RNA_def_struct_ui_text(srna, "Curve Modifier", "Curve deformation modifier");
1748   RNA_def_struct_sdna(srna, "CurveModifierData");
1749   RNA_def_struct_ui_icon(srna, ICON_MOD_CURVE);
1750
1751   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
1752   RNA_def_property_ui_text(prop, "Object", "Curve object to deform with");
1753   RNA_def_property_pointer_funcs(
1754       prop, NULL, "rna_CurveModifier_object_set", NULL, "rna_Curve_object_poll");
1755   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1756   RNA_def_property_update(prop, 0, "rna_CurveModifier_dependency_update");
1757
1758   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
1759   RNA_def_property_string_sdna(prop, NULL, "name");
1760   RNA_def_property_ui_text(
1761       prop,
1762       "Vertex Group",
1763       "Name of Vertex Group which determines influence of modifier per point");
1764   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_CurveModifier_name_set");
1765   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1766
1767   prop = RNA_def_property(srna, "deform_axis", PROP_ENUM, PROP_NONE);
1768   RNA_def_property_enum_sdna(prop, NULL, "defaxis");
1769   RNA_def_property_enum_items(prop, prop_deform_axis_items);
1770   RNA_def_property_ui_text(prop, "Deform Axis", "The axis that the curve deforms along");
1771   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1772 }
1773
1774 static void rna_def_modifier_build(BlenderRNA *brna)
1775 {
1776   StructRNA *srna;
1777   PropertyRNA *prop;
1778
1779   srna = RNA_def_struct(brna, "BuildModifier", "Modifier");
1780   RNA_def_struct_ui_text(srna, "Build Modifier", "Build effect modifier");
1781   RNA_def_struct_sdna(srna, "BuildModifierData");
1782   RNA_def_struct_ui_icon(srna, ICON_MOD_BUILD);
1783
1784   prop = RNA_def_property(srna, "frame_start", PROP_FLOAT, PROP_TIME);
1785   RNA_def_property_float_sdna(prop, NULL, "start");
1786   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
1787   RNA_def_property_ui_text(prop, "Start", "Start frame of the effect");
1788   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1789
1790   prop = RNA_def_property(srna, "frame_duration", PROP_FLOAT, PROP_TIME);
1791   RNA_def_property_float_sdna(prop, NULL, "length");
1792   RNA_def_property_range(prop, 1, MAXFRAMEF);
1793   RNA_def_property_ui_text(prop, "Length", "Total time the build effect requires");
1794   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1795
1796   prop = RNA_def_property(srna, "use_reverse", PROP_BOOLEAN, PROP_NONE);
1797   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_BUILD_FLAG_REVERSE);
1798   RNA_def_property_ui_text(prop, "Reversed", "Deconstruct the mesh instead of building it");
1799   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1800
1801   prop = RNA_def_property(srna, "use_random_order", PROP_BOOLEAN, PROP_NONE);
1802   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_BUILD_FLAG_RANDOMIZE);
1803   RNA_def_property_ui_text(prop, "Randomize", "Randomize the faces or edges during build");
1804   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1805
1806   prop = RNA_def_property(srna, "seed", PROP_INT, PROP_NONE);
1807   RNA_def_property_range(prop, 1, MAXFRAMEF);
1808   RNA_def_property_ui_text(prop, "Seed", "Seed for random if used");
1809   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1810 }
1811
1812 static void rna_def_modifier_mirror(BlenderRNA *brna)
1813 {
1814   StructRNA *srna;
1815   PropertyRNA *prop;
1816
1817   srna = RNA_def_struct(brna, "MirrorModifier", "Modifier");
1818   RNA_def_struct_ui_text(srna, "Mirror Modifier", "Mirroring modifier");
1819   RNA_def_struct_sdna(srna, "MirrorModifierData");
1820   RNA_def_struct_ui_icon(srna, ICON_MOD_MIRROR);
1821
1822   prop = RNA_def_property(srna, "use_axis", PROP_BOOLEAN, PROP_NONE);
1823   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_AXIS_X);
1824   RNA_def_property_array(prop, 3);
1825   RNA_def_property_ui_text(prop, "Mirror Axis", "Enable axis mirror");
1826   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1827
1828   prop = RNA_def_property(srna, "use_bisect_axis", PROP_BOOLEAN, PROP_NONE);
1829   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_BISECT_AXIS_X);
1830   RNA_def_property_array(prop, 3);
1831   RNA_def_property_ui_text(prop, "Bisect Axis", "Cuts the mesh across the mirror plane");
1832   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1833
1834   prop = RNA_def_property(srna, "use_bisect_flip_axis", PROP_BOOLEAN, PROP_NONE);
1835   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_BISECT_FLIP_AXIS_X);
1836   RNA_def_property_array(prop, 3);
1837   RNA_def_property_ui_text(prop, "Bisect Flip Axis", "Flips the direction of the slice");
1838   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1839
1840   prop = RNA_def_property(srna, "use_clip", PROP_BOOLEAN, PROP_NONE);
1841   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_CLIPPING);
1842   RNA_def_property_ui_text(
1843       prop, "Clip", "Prevent vertices from going through the mirror during transform");
1844   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1845
1846   prop = RNA_def_property(srna, "use_mirror_vertex_groups", PROP_BOOLEAN, PROP_NONE);
1847   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_VGROUP);
1848   RNA_def_property_ui_text(prop, "Mirror Vertex Groups", "Mirror vertex groups (e.g. .R->.L)");
1849   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1850
1851   prop = RNA_def_property(srna, "use_mirror_merge", PROP_BOOLEAN, PROP_NONE);
1852   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", MOD_MIR_NO_MERGE);
1853   RNA_def_property_ui_text(prop, "Merge Vertices", "Merge vertices within the merge threshold");
1854   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1855
1856   prop = RNA_def_property(srna, "use_mirror_u", PROP_BOOLEAN, PROP_NONE);
1857   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_MIRROR_U);
1858   RNA_def_property_ui_text(
1859       prop, "Mirror U", "Mirror the U texture coordinate around the flip offset point");
1860   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1861
1862   prop = RNA_def_property(srna, "use_mirror_v", PROP_BOOLEAN, PROP_NONE);
1863   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_MIRROR_V);
1864   RNA_def_property_ui_text(
1865       prop, "Mirror V", "Mirror the V texture coordinate around the flip offset point");
1866   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1867
1868   prop = RNA_def_property(srna, "mirror_offset_u", PROP_FLOAT, PROP_FACTOR);
1869   RNA_def_property_float_sdna(prop, NULL, "uv_offset[0]");
1870   RNA_def_property_range(prop, -1, 1);
1871   RNA_def_property_ui_range(prop, -1, 1, 2, 4);
1872   RNA_def_property_ui_text(
1873       prop,
1874       "Flip U Offset",
1875       "Amount to offset mirrored UVs flipping point from the 0.5 on the U axis");
1876   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1877
1878   prop = RNA_def_property(srna, "mirror_offset_v", PROP_FLOAT, PROP_FACTOR);
1879   RNA_def_property_float_sdna(prop, NULL, "uv_offset[1]");
1880   RNA_def_property_range(prop, -1, 1);
1881   RNA_def_property_ui_range(prop, -1, 1, 2, 4);
1882   RNA_def_property_ui_text(
1883       prop,
1884       "Flip V Offset",
1885       "Amount to offset mirrored UVs flipping point from the 0.5 point on the V axis");
1886   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1887
1888   prop = RNA_def_property(srna, "offset_u", PROP_FLOAT, PROP_FACTOR);
1889   RNA_def_property_float_sdna(prop, NULL, "uv_offset_copy[0]");
1890   RNA_def_property_range(prop, -10000.0f, 10000.0f);
1891   RNA_def_property_ui_range(prop, -1, 1, 2, 4);
1892   RNA_def_property_ui_text(prop, "U Offset", "Mirrored UV offset on the U axis");
1893   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1894
1895   prop = RNA_def_property(srna, "offset_v", PROP_FLOAT, PROP_FACTOR);
1896   RNA_def_property_float_sdna(prop, NULL, "uv_offset_copy[1]");
1897   RNA_def_property_range(prop, -10000.0f, 10000.0f);
1898   RNA_def_property_ui_range(prop, -1, 1, 2, 4);
1899   RNA_def_property_ui_text(prop, "V Offset", "Mirrored UV offset on the V axis");
1900   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1901
1902   prop = RNA_def_property(srna, "merge_threshold", PROP_FLOAT, PROP_DISTANCE);
1903   RNA_def_property_float_sdna(prop, NULL, "tolerance");
1904   RNA_def_property_range(prop, 0, FLT_MAX);
1905   RNA_def_property_ui_range(prop, 0, 1, 0.01, 6);
1906   RNA_def_property_ui_text(
1907       prop, "Merge Limit", "Distance within which mirrored vertices are merged");
1908   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1909
1910   prop = RNA_def_property(srna, "mirror_object", PROP_POINTER, PROP_NONE);
1911   RNA_def_property_pointer_sdna(prop, NULL, "mirror_ob");
1912   RNA_def_property_ui_text(prop, "Mirror Object", "Object to use as mirror");
1913   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
1914   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
1915 }
1916
1917 static void rna_def_modifier_decimate(BlenderRNA *brna)
1918 {
1919   static const EnumPropertyItem modifier_decim_mode_items[] = {
1920       {MOD_DECIM_MODE_COLLAPSE, "COLLAPSE", 0, "Collapse", "Use edge collapsing"},
1921       {MOD_DECIM_MODE_UNSUBDIV, "UNSUBDIV", 0, "Un-Subdivide", "Use un-subdivide face reduction"},
1922       {MOD_DECIM_MODE_DISSOLVE,
1923        "DISSOLVE",
1924        0,
1925        "Planar",
1926        "Dissolve geometry to form planar polygons"},
1927       {0, NULL, 0, NULL, NULL},
1928   };
1929
1930   /* Note, keep in sync with operator 'MESH_OT_decimate' */
1931
1932   StructRNA *srna;
1933   PropertyRNA *prop;
1934
1935   srna = RNA_def_struct(brna, "DecimateModifier", "Modifier");
1936   RNA_def_struct_ui_text(srna, "Decimate Modifier", "Decimation modifier");
1937   RNA_def_struct_sdna(srna, "DecimateModifierData");
1938   RNA_def_struct_ui_icon(srna, ICON_MOD_DECIM);
1939
1940   prop = RNA_def_property(srna, "decimate_type", PROP_ENUM, PROP_NONE);
1941   RNA_def_property_enum_sdna(prop, NULL, "mode");
1942   RNA_def_property_enum_items(prop, modifier_decim_mode_items);
1943   RNA_def_property_ui_text(prop, "Mode", "");
1944   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1945
1946   /* (mode == MOD_DECIM_MODE_COLLAPSE) */
1947   prop = RNA_def_property(srna, "ratio", PROP_FLOAT, PROP_FACTOR);
1948   RNA_def_property_float_sdna(prop, NULL, "percent");
1949   RNA_def_property_range(prop, 0, 1);
1950   RNA_def_property_ui_range(prop, 0, 1, 1, 4);
1951   RNA_def_property_ui_text(prop, "Ratio", "Ratio of triangles to reduce to (collapse only)");
1952   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1953
1954   /* (mode == MOD_DECIM_MODE_UNSUBDIV) */
1955   prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_UNSIGNED);
1956   RNA_def_property_int_sdna(prop, NULL, "iter");
1957   RNA_def_property_range(prop, 0, SHRT_MAX);
1958   RNA_def_property_ui_range(prop, 0, 100, 1, -1);
1959   RNA_def_property_ui_text(
1960       prop, "Iterations", "Number of times reduce the geometry (unsubdivide only)");
1961   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1962
1963   /* (mode == MOD_DECIM_MODE_DISSOLVE) */
1964   prop = RNA_def_property(srna, "angle_limit", PROP_FLOAT, PROP_ANGLE);
1965   RNA_def_property_float_sdna(prop, NULL, "angle");
1966   RNA_def_property_range(prop, 0, DEG2RAD(180));
1967   RNA_def_property_ui_range(prop, 0, DEG2RAD(180), 10, 2);
1968   RNA_def_property_ui_text(prop, "Angle Limit", "Only dissolve angles below this (planar only)");
1969   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1970
1971   /* (mode == MOD_DECIM_MODE_COLLAPSE) */
1972   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
1973   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
1974   RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name (collapse only)");
1975   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_DecimateModifier_defgrp_name_set");
1976   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1977
1978   prop = RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
1979   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_DECIM_FLAG_INVERT_VGROUP);
1980   RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence (collapse only)");
1981   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1982
1983   prop = RNA_def_property(srna, "use_collapse_triangulate", PROP_BOOLEAN, PROP_NONE);
1984   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_DECIM_FLAG_TRIANGULATE);
1985   RNA_def_property_ui_text(
1986       prop, "Triangulate", "Keep triangulated faces resulting from decimation (collapse only)");
1987   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1988
1989   prop = RNA_def_property(srna, "use_symmetry", PROP_BOOLEAN, PROP_NONE);
1990   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_DECIM_FLAG_SYMMETRY);
1991   RNA_def_property_ui_text(prop, "Symmetry", "Maintain symmetry on an axis");
1992   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1993
1994   prop = RNA_def_property(srna, "symmetry_axis", PROP_ENUM, PROP_NONE);
1995   RNA_def_property_enum_sdna(prop, NULL, "symmetry_axis");
1996   RNA_def_property_enum_items(prop, rna_enum_axis_xyz_items);
1997   RNA_def_property_ui_text(prop, "Axis", "Axis of symmetry");
1998   RNA_def_property_update(prop, 0, "rna_Modifier_update");
1999
2000   prop = RNA_def_property(srna, "vertex_group_factor", PROP_FLOAT, PROP_FACTOR);
2001   RNA_def_property_float_sdna(prop, NULL, "defgrp_factor");
2002   RNA_def_property_range(prop, 0, 1000);
2003   RNA_def_property_ui_range(prop, 0, 10, 1, 4);
2004   RNA_def_property_ui_text(prop, "Factor", "Vertex group strength");
2005   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2006   /* end collapse-only option */
2007
2008   /* (mode == MOD_DECIM_MODE_DISSOLVE) */
2009   prop = RNA_def_property(srna, "use_dissolve_boundaries", PROP_BOOLEAN, PROP_NONE);
2010   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_DECIM_FLAG_ALL_BOUNDARY_VERTS);
2011   RNA_def_property_ui_text(
2012       prop, "All Boundaries", "Dissolve all vertices inbetween face boundaries (planar only)");
2013   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2014
2015   prop = RNA_def_property(srna, "delimit", PROP_ENUM, PROP_NONE);
2016   RNA_def_property_flag(prop, PROP_ENUM_FLAG); /* important to run before default set */
2017   RNA_def_property_enum_items(prop, rna_enum_mesh_delimit_mode_items);
2018   RNA_def_property_ui_text(prop, "Delimit", "Limit merging geometry");
2019   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2020
2021   /* end dissolve-only option */
2022
2023   /* all modes use this */
2024   prop = RNA_def_property(srna, "face_count", PROP_INT, PROP_NONE);
2025   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2026   RNA_def_property_ui_text(
2027       prop, "Face Count", "The current number of faces in the decimated mesh");
2028 }
2029
2030 static void rna_def_modifier_wave(BlenderRNA *brna)
2031 {
2032   StructRNA *srna;
2033   PropertyRNA *prop;
2034
2035   srna = RNA_def_struct(brna, "WaveModifier", "Modifier");
2036   RNA_def_struct_ui_text(srna, "Wave Modifier", "Wave effect modifier");
2037   RNA_def_struct_sdna(srna, "WaveModifierData");
2038   RNA_def_struct_ui_icon(srna, ICON_MOD_WAVE);
2039
2040   prop = RNA_def_property(srna, "use_x", PROP_BOOLEAN, PROP_NONE);
2041   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_X);
2042   RNA_def_property_ui_text(prop, "X", "X axis motion");
2043   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2044
2045   prop = RNA_def_property(srna, "use_y", PROP_BOOLEAN, PROP_NONE);
2046   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_Y);
2047   RNA_def_property_ui_text(prop, "Y", "Y axis motion");
2048   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2049
2050   prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
2051   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_CYCL);
2052   RNA_def_property_ui_text(prop, "Cyclic", "Cyclic wave effect");
2053   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2054
2055   prop = RNA_def_property(srna, "use_normal", PROP_BOOLEAN, PROP_NONE);
2056   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_NORM);
2057   RNA_def_property_ui_text(prop, "Normals", "Displace along normals");
2058   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2059
2060   prop = RNA_def_property(srna, "use_normal_x", PROP_BOOLEAN, PROP_NONE);
2061   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_NORM_X);
2062   RNA_def_property_ui_text(prop, "X Normal", "Enable displacement along the X normal");
2063   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2064
2065   prop = RNA_def_property(srna, "use_normal_y", PROP_BOOLEAN, PROP_NONE);
2066   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_NORM_Y);
2067   RNA_def_property_ui_text(prop, "Y Normal", "Enable displacement along the Y normal");
2068   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2069
2070   prop = RNA_def_property(srna, "use_normal_z", PROP_BOOLEAN, PROP_NONE);
2071   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_NORM_Z);
2072   RNA_def_property_ui_text(prop, "Z Normal", "Enable displacement along the Z normal");
2073   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2074
2075   prop = RNA_def_property(srna, "time_offset", PROP_FLOAT, PROP_TIME);
2076   RNA_def_property_float_sdna(prop, NULL, "timeoffs");
2077   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
2078   RNA_def_property_ui_text(
2079       prop,
2080       "Time Offset",
2081       "Either the starting frame (for positive speed) or ending frame (for negative speed.)");
2082   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2083
2084   prop = RNA_def_property(srna, "lifetime", PROP_FLOAT, PROP_TIME);
2085   RNA_def_property_float_sdna(prop, NULL, "lifetime");
2086   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
2087   RNA_def_property_ui_text(
2088       prop, "Lifetime", "Lifetime of the wave in frames, zero means infinite");
2089   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2090
2091   prop = RNA_def_property(srna, "damping_time", PROP_FLOAT, PROP_TIME);
2092   RNA_def_property_float_sdna(prop, NULL, "damp");
2093   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
2094   RNA_def_property_ui_text(
2095       prop, "Damping Time", "Number of frames in which the wave damps out after it dies");
2096   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2097
2098   prop = RNA_def_property(srna, "falloff_radius", PROP_FLOAT, PROP_DISTANCE);
2099   RNA_def_property_float_sdna(prop, NULL, "falloff");
2100   RNA_def_property_range(prop, 0, FLT_MAX);
2101   RNA_def_property_ui_range(prop, 0, 100, 100, 2);
2102   RNA_def_property_ui_text(prop, "Falloff Radius", "Distance after which it fades out");
2103   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2104
2105   prop = RNA_def_property(srna, "start_position_x", PROP_FLOAT, PROP_DISTANCE);
2106   RNA_def_property_float_sdna(prop, NULL, "startx");
2107   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2108   RNA_def_property_ui_range(prop, -100, 100, 100, 2);
2109   RNA_def_property_ui_text(prop, "Start Position X", "X coordinate of the start position");
2110   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2111
2112   prop = RNA_def_property(srna, "start_position_y", PROP_FLOAT, PROP_DISTANCE);
2113   RNA_def_property_float_sdna(prop, NULL, "starty");
2114   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2115   RNA_def_property_ui_range(prop, -100, 100, 100, 2);
2116   RNA_def_property_ui_text(prop, "Start Position Y", "Y coordinate of the start position");
2117   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2118
2119   prop = RNA_def_property(srna, "start_position_object", PROP_POINTER, PROP_NONE);
2120   RNA_def_property_pointer_sdna(prop, NULL, "objectcenter");
2121   RNA_def_property_ui_text(prop, "Start Position Object", "Object which defines the wave center");
2122   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2123   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2124
2125   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
2126   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
2127   RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name for modulating the wave");
2128   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_WaveModifier_defgrp_name_set");
2129   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2130
2131   prop = RNA_def_property(srna, "speed", PROP_FLOAT, PROP_NONE);
2132   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2133   RNA_def_property_ui_range(prop, -1, 1, 10, 2);
2134   RNA_def_property_ui_text(
2135       prop, "Speed", "Speed of the wave, towards the starting point when negative");
2136   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2137
2138   prop = RNA_def_property(srna, "height", PROP_FLOAT, PROP_DISTANCE);
2139   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2140   RNA_def_property_ui_range(prop, -2, 2, 10, 2);
2141   RNA_def_property_ui_text(prop, "Height", "Height of the wave");
2142   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2143
2144   prop = RNA_def_property(srna, "width", PROP_FLOAT, PROP_DISTANCE);
2145   RNA_def_property_range(prop, 0, FLT_MAX);
2146   RNA_def_property_ui_range(prop, 0, 5, 10, 2);
2147   RNA_def_property_ui_text(prop, "Width", "Distance between the waves");
2148   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2149
2150   prop = RNA_def_property(srna, "narrowness", PROP_FLOAT, PROP_DISTANCE);
2151   RNA_def_property_float_sdna(prop, NULL, "narrow");
2152   RNA_def_property_range(prop, 0, FLT_MAX);
2153   RNA_def_property_ui_range(prop, 0, 10, 10, 2);
2154   RNA_def_property_ui_text(
2155       prop,
2156       "Narrowness",
2157       "Distance between the top and the base of a wave, the higher the value, "
2158       "the more narrow the wave");
2159   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2160
2161   rna_def_modifier_generic_map_info(srna);
2162 }
2163
2164 static void rna_def_modifier_armature(BlenderRNA *brna)
2165 {
2166   StructRNA *srna;
2167   PropertyRNA *prop;
2168
2169   srna = RNA_def_struct(brna, "ArmatureModifier", "Modifier");
2170   RNA_def_struct_ui_text(srna, "Armature Modifier", "Armature deformation modifier");
2171   RNA_def_struct_sdna(srna, "ArmatureModifierData");
2172   RNA_def_struct_ui_icon(srna, ICON_MOD_ARMATURE);
2173
2174   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
2175   RNA_def_property_ui_text(prop, "Object", "Armature object to deform with");
2176   RNA_def_property_pointer_funcs(
2177       prop, NULL, "rna_ArmatureModifier_object_set", NULL, "rna_Armature_object_poll");
2178   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2179   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2180   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2181
2182   prop = RNA_def_property(srna, "use_bone_envelopes", PROP_BOOLEAN, PROP_NONE);
2183   RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_ENVELOPE);
2184   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2185   RNA_def_property_ui_text(prop, "Use Bone Envelopes", "Bind Bone envelopes to armature modifier");
2186   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2187
2188   prop = RNA_def_property(srna, "use_vertex_groups", PROP_BOOLEAN, PROP_NONE);
2189   RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_VGROUP);
2190   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2191   RNA_def_property_ui_text(prop, "Use Vertex Groups", "Bind vertex groups to armature modifier");
2192   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2193
2194   prop = RNA_def_property(srna, "use_deform_preserve_volume", PROP_BOOLEAN, PROP_NONE);
2195   RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_QUATERNION);
2196   RNA_def_property_ui_text(
2197       prop, "Preserve Volume", "Deform rotation interpolation with quaternions");
2198   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2199
2200   prop = RNA_def_property(srna, "use_multi_modifier", PROP_BOOLEAN, PROP_NONE);
2201   RNA_def_property_boolean_sdna(prop, NULL, "multi", 0);
2202   RNA_def_property_ui_text(
2203       prop,
2204       "Multi Modifier",
2205       "Use same input as previous modifier, and mix results using overall vgroup");
2206   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2207
2208   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
2209   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
2210   RNA_def_property_ui_text(
2211       prop,
2212       "Vertex Group",
2213       "Name of Vertex Group which determines influence of modifier per point");
2214   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ArmatureModifier_defgrp_name_set");
2215   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2216
2217   prop = RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
2218   RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_INVERT_VGROUP);
2219   RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence");
2220   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2221 }
2222
2223 static void rna_def_modifier_hook(BlenderRNA *brna)
2224 {
2225   StructRNA *srna;
2226   PropertyRNA *prop;
2227   FunctionRNA *func;
2228   PropertyRNA *parm;
2229
2230   srna = RNA_def_struct(brna, "HookModifier", "Modifier");
2231   RNA_def_struct_ui_text(
2232       srna, "Hook Modifier", "Hook modifier to modify the location of vertices");
2233   RNA_def_struct_sdna(srna, "HookModifierData");
2234   RNA_def_struct_ui_icon(srna, ICON_HOOK);
2235
2236   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
2237   RNA_def_property_float_sdna(prop, NULL, "force");
2238   RNA_def_property_range(prop, 0, 1);
2239   RNA_def_property_ui_text(prop, "Strength", "Relative force of the hook");
2240   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2241
2242   prop = RNA_def_property(srna, "falloff_type", PROP_ENUM, PROP_NONE);
2243   RNA_def_property_enum_items(prop, modifier_warp_falloff_items); /* share the enum */
2244   RNA_def_property_ui_text(prop, "Falloff Type", "");
2245   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_CURVE); /* Abusing id_curve :/ */
2246   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2247
2248   prop = RNA_def_property(srna, "falloff_radius", PROP_FLOAT, PROP_DISTANCE);
2249   RNA_def_property_float_sdna(prop, NULL, "falloff");
2250   RNA_def_property_range(prop, 0, FLT_MAX);
2251   RNA_def_property_ui_range(prop, 0, 100, 100, 2);
2252   RNA_def_property_ui_text(
2253       prop, "Radius", "If not zero, the distance from the hook where influence ends");
2254   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2255
2256   prop = RNA_def_property(srna, "falloff_curve", PROP_POINTER, PROP_NONE);
2257   RNA_def_property_pointer_sdna(prop, NULL, "curfalloff");
2258   RNA_def_property_ui_text(prop, "Falloff Curve", "Custom falloff curve");
2259   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2260
2261   prop = RNA_def_property(srna, "center", PROP_FLOAT, PROP_TRANSLATION);
2262   RNA_def_property_float_sdna(prop, NULL, "cent");
2263   RNA_def_property_ui_text(
2264       prop, "Hook Center", "Center of the hook, used for falloff and display");
2265   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2266
2267   prop = RNA_def_property(srna, "matrix_inverse", PROP_FLOAT, PROP_MATRIX);
2268   RNA_def_property_float_sdna(prop, NULL, "parentinv");
2269   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2270   RNA_def_property_ui_text(
2271       prop, "Matrix", "Reverse the transformation between this object and its target");
2272   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Modifier_update");
2273
2274   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
2275   RNA_def_property_ui_text(
2276       prop, "Object", "Parent Object for hook, also recalculates and clears offset");
2277   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2278   RNA_def_property_pointer_funcs(prop, NULL, "rna_HookModifier_object_set", NULL, NULL);
2279   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2280
2281   prop = RNA_def_property(srna, "subtarget", PROP_STRING, PROP_NONE);
2282   RNA_def_property_string_sdna(prop, NULL, "subtarget");
2283   RNA_def_property_ui_text(
2284       prop,
2285       "Sub-Target",
2286       "Name of Parent Bone for hook (if applicable), also recalculates and clears offset");
2287   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_HookModifier_subtarget_set");
2288   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2289
2290   prop = RNA_def_property(srna, "use_falloff_uniform", PROP_BOOLEAN, PROP_NONE);
2291   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_HOOK_UNIFORM_SPACE);
2292   RNA_def_property_ui_text(prop, "Uniform Falloff", "Compensate for non-uniform object scale");
2293   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2294
2295   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
2296   RNA_def_property_string_sdna(prop, NULL, "name");
2297   RNA_def_property_ui_text(
2298       prop,
2299       "Vertex Group",
2300       "Name of Vertex Group which determines influence of modifier per point");
2301   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_HookModifier_name_set");
2302   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2303
2304   prop = RNA_def_property(srna, "vertex_indices", PROP_INT, PROP_UNSIGNED);
2305   RNA_def_property_array(prop, RNA_MAX_ARRAY_LENGTH);
2306   RNA_def_property_flag(prop, PROP_DYNAMIC);
2307   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2308   RNA_def_property_dynamic_array_funcs(prop, "rna_HookModifier_vertex_indices_get_length");
2309   RNA_def_property_int_funcs(prop, "rna_HookModifier_vertex_indices_get", NULL, NULL);
2310   RNA_def_property_ui_text(prop,
2311                            "Vertex Indices",
2312                            "Indices of vertices bound to the modifier. For bezier curves, "
2313                            "handles count as additional vertices");
2314
2315   func = RNA_def_function(srna, "vertex_indices_set", "rna_HookModifier_vertex_indices_set");
2316   RNA_def_function_ui_description(
2317       func, "Validates and assigns the array of vertex indices bound to the modifier");
2318   RNA_def_function_flag(func, FUNC_USE_REPORTS);
2319   parm = RNA_def_int_array(
2320       func, "indices", 1, NULL, INT_MIN, INT_MAX, "", "Vertex Indices", 0, INT_MAX);
2321   RNA_def_property_array(parm, RNA_MAX_ARRAY_LENGTH);
2322   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
2323 }
2324
2325 static void rna_def_modifier_softbody(BlenderRNA *brna)
2326 {
2327   StructRNA *srna;
2328   PropertyRNA *prop;
2329
2330   srna = RNA_def_struct(brna, "SoftBodyModifier", "Modifier");
2331   RNA_def_struct_ui_text(srna, "Soft Body Modifier", "Soft body simulation modifier");
2332   RNA_def_struct_sdna(srna, "SoftbodyModifierData");
2333   RNA_def_struct_ui_icon(srna, ICON_MOD_SOFT);
2334
2335   prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
2336   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2337   RNA_def_property_struct_type(prop, "SoftBodySettings");
2338   RNA_def_property_pointer_funcs(prop, "rna_SoftBodyModifier_settings_get", NULL, NULL, NULL);
2339   RNA_def_property_ui_text(prop, "Soft Body Settings", "");
2340
2341   prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
2342   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2343   RNA_def_property_struct_type(prop, "PointCache");
2344   RNA_def_property_pointer_funcs(prop, "rna_SoftBodyModifier_point_cache_get", NULL, NULL, NULL);
2345   RNA_def_property_ui_text(prop, "Soft Body Point Cache", "");
2346 }
2347
2348 static void rna_def_modifier_boolean(BlenderRNA *brna)
2349 {
2350   StructRNA *srna;
2351   PropertyRNA *prop;
2352
2353   static const EnumPropertyItem prop_operation_items[] = {
2354       {eBooleanModifierOp_Intersect,
2355        "INTERSECT",
2356        0,
2357        "Intersect",
2358        "Keep the part of the mesh that intersects with the other selected object"},
2359       {eBooleanModifierOp_Union, "UNION", 0, "Union", "Combine two meshes in an additive way"},
2360       {eBooleanModifierOp_Difference,
2361        "DIFFERENCE",
2362        0,
2363        "Difference",
2364        "Combine two meshes in a subtractive way"},
2365       {0, NULL, 0, NULL, NULL},
2366   };
2367
2368   srna = RNA_def_struct(brna, "BooleanModifier", "Modifier");
2369   RNA_def_struct_ui_text(srna, "Boolean Modifier", "Boolean operations modifier");
2370   RNA_def_struct_sdna(srna, "BooleanModifierData");
2371   RNA_def_struct_ui_icon(srna, ICON_MOD_BOOLEAN);
2372
2373   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
2374   RNA_def_property_ui_text(prop, "Object", "Mesh object to use for Boolean operation");
2375   RNA_def_property_pointer_funcs(
2376       prop, NULL, "rna_BooleanModifier_object_set", NULL, "rna_Mesh_object_poll");
2377   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2378   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2379
2380   prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
2381   RNA_def_property_enum_items(prop, prop_operation_items);
2382   RNA_def_property_enum_default(prop, eBooleanModifierOp_Difference);
2383   RNA_def_property_ui_text(prop, "Operation", "");
2384   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2385
2386   prop = RNA_def_property(srna, "double_threshold", PROP_FLOAT, PROP_DISTANCE);
2387   RNA_def_property_float_sdna(prop, NULL, "double_threshold");
2388   RNA_def_property_range(prop, 0, 1.0f);
2389   RNA_def_property_ui_range(prop, 0, 1, 0.0001, 6);
2390   RNA_def_property_ui_text(
2391       prop, "Overlap Threshold", "Threshold for checking overlapping geometry");
2392   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2393
2394   /* BMesh debugging options, only used when G_DEBUG is set */
2395
2396   /* BMesh intersection options */
2397   static const EnumPropertyItem debug_items[] = {
2398       {eBooleanModifierBMeshFlag_BMesh_Separate, "SEPARATE", 0, "Separate", ""},
2399       {eBooleanModifierBMeshFlag_BMesh_NoDissolve, "NO_DISSOLVE", 0, "No Dissolve", ""},
2400       {eBooleanModifierBMeshFlag_BMesh_NoConnectRegions,
2401        "NO_CONNECT_REGIONS",
2402        0,
2403        "No Connect Regions",
2404        ""},
2405       {0, NULL, 0, NULL, NULL},
2406   };
2407
2408   prop = RNA_def_property(srna, "debug_options", PROP_ENUM, PROP_NONE);
2409   RNA_def_property_enum_items(prop, debug_items);
2410   RNA_def_property_enum_sdna(prop, NULL, "bm_flag");
2411   RNA_def_property_flag(prop, PROP_ENUM_FLAG);
2412   RNA_def_property_ui_text(prop, "Debug", "Debugging options, only when started with '-d'");
2413   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2414 }
2415
2416 static void rna_def_modifier_array(BlenderRNA *brna)
2417 {
2418   StructRNA *srna;
2419   PropertyRNA *prop;
2420
2421   static const EnumPropertyItem prop_fit_type_items[] = {
2422       {MOD_ARR_FIXEDCOUNT,
2423        "FIXED_COUNT",
2424        0,
2425        "Fixed Count",
2426        "Duplicate the object a certain number of times"},
2427       {MOD_ARR_FITLENGTH,
2428        "FIT_LENGTH",
2429        0,
2430        "Fit Length",
2431        "Duplicate the object as many times as fits in a certain length"},
2432       {MOD_ARR_FITCURVE, "FIT_CURVE", 0, "Fit Curve", "Fit the duplicated objects to a curve"},
2433       {0, NULL, 0, NULL, NULL},
2434   };
2435
2436   srna = RNA_def_struct(brna, "ArrayModifier", "Modifier");
2437   RNA_def_struct_ui_text(srna, "Array Modifier", "Array duplication modifier");
2438   RNA_def_struct_sdna(srna, "ArrayModifierData");
2439   RNA_def_struct_ui_icon(srna, ICON_MOD_ARRAY);
2440
2441   /* Length parameters */
2442   prop = RNA_def_property(srna, "fit_type", PROP_ENUM, PROP_NONE);
2443   RNA_def_property_enum_items(prop, prop_fit_type_items);
2444   RNA_def_property_ui_text(prop, "Fit Type", "Array length calculation method");
2445   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2446
2447   prop = RNA_def_property(srna, "count", PROP_INT, PROP_NONE);
2448   RNA_def_property_range(prop, 1, INT_MAX);
2449   RNA_def_property_ui_range(prop, 1, 1000, 1, -1);
2450   RNA_def_property_ui_text(prop, "Count", "Number of duplicates to make");
2451   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2452
2453   prop = RNA_def_property(srna, "fit_length", PROP_FLOAT, PROP_DISTANCE);
2454   RNA_def_property_float_sdna(prop, NULL, "length");
2455   RNA_def_property_range(prop, 0, INT_MAX);
2456   RNA_def_property_ui_range(prop, 0, 10000, 10, 2);
2457   RNA_def_property_ui_text(prop, "Length", "Length to fit array within");
2458   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2459
2460   prop = RNA_def_property(srna, "curve", PROP_POINTER, PROP_NONE);
2461   RNA_def_property_pointer_sdna(prop, NULL, "curve_ob");
2462   RNA_def_property_ui_text(prop, "Curve", "Curve object to fit array length to");
2463   RNA_def_property_pointer_funcs(
2464       prop, NULL, "rna_ArrayModifier_curve_ob_set", NULL, "rna_Curve_object_poll");
2465   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2466   RNA_def_property_update(prop, 0, "rna_ArrayModifier_dependency_update");
2467
2468   /* Offset parameters */
2469   prop = RNA_def_property(srna, "use_constant_offset", PROP_BOOLEAN, PROP_NONE);
2470   RNA_def_property_boolean_sdna(prop, NULL, "offset_type", MOD_ARR_OFF_CONST);
2471   RNA_def_property_ui_text(prop, "Constant Offset", "Add a constant offset");
2472   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2473
2474   prop = RNA_def_property(srna, "constant_offset_displace", PROP_FLOAT, PROP_TRANSLATION);
2475   RNA_def_property_float_sdna(prop, NULL, "offset");
2476   RNA_def_property_ui_text(
2477       prop, "Constant Offset Displacement", "Value for the distance between arrayed items");
2478   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
2479   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2480
2481   prop = RNA_def_property(srna, "use_relative_offset", PROP_BOOLEAN, PROP_NONE);
2482   RNA_def_property_boolean_sdna(prop, NULL, "offset_type", MOD_ARR_OFF_RELATIVE);
2483   RNA_def_property_ui_text(
2484       prop, "Relative Offset", "Add an offset relative to the object's bounding box");
2485   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2486
2487   /* PROP_TRANSLATION causes units to be used which we don't want */
2488   prop = RNA_def_property(srna, "relative_offset_displace", PROP_FLOAT, PROP_NONE);
2489   RNA_def_property_float_sdna(prop, NULL, "scale");
2490   RNA_def_property_ui_text(
2491       prop,
2492       "Relative Offset Displacement",
2493       "The size of the geometry will determine the distance between arrayed items");
2494   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2495
2496   /* Vertex merging parameters */
2497   prop = RNA_def_property(srna, "use_merge_vertices", PROP_BOOLEAN, PROP_NONE);
2498   RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_ARR_MERGE);
2499   RNA_def_property_ui_text(prop, "Merge Vertices", "Merge vertices in adjacent duplicates");
2500   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2501
2502   prop = RNA_def_property(srna, "use_merge_vertices_cap", PROP_BOOLEAN, PROP_NONE);
2503   RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_ARR_MERGEFINAL);
2504   RNA_def_property_ui_text(prop, "Merge Vertices", "Merge vertices in first and last duplicates");
2505   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2506
2507   prop = RNA_def_property(srna, "merge_threshold", PROP_FLOAT, PROP_DISTANCE);
2508   RNA_def_property_float_sdna(prop, NULL, "merge_dist");
2509   RNA_def_property_range(prop, 0, FLT_MAX);
2510   RNA_def_property_ui_range(prop, 0, 1, 1, 4);
2511   RNA_def_property_ui_text(prop, "Merge Distance", "Limit below which to merge vertices");
2512   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2513
2514   /* Offset object */
2515   prop = RNA_def_property(srna, "use_object_offset", PROP_BOOLEAN, PROP_NONE);
2516   RNA_def_property_boolean_sdna(prop, NULL, "offset_type", MOD_ARR_OFF_OBJ);
2517   RNA_def_property_ui_text(
2518       prop, "Object Offset", "Add another object's transformation to the total offset");
2519   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2520
2521   prop = RNA_def_property(srna, "offset_object", PROP_POINTER, PROP_NONE);
2522   RNA_def_property_pointer_sdna(prop, NULL, "offset_ob");
2523   RNA_def_property_ui_text(
2524       prop,
2525       "Object Offset",
2526       "Use the location and rotation of another object to determine the distance and "
2527       "rotational change between arrayed items");
2528   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2529   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2530
2531   /* Caps */
2532   prop = RNA_def_property(srna, "start_cap", PROP_POINTER, PROP_NONE);
2533   RNA_def_property_ui_text(prop, "Start Cap", "Mesh object to use as a start cap");
2534   RNA_def_property_pointer_funcs(
2535       prop, NULL, "rna_ArrayModifier_start_cap_set", NULL, "rna_Mesh_object_poll");
2536   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2537   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2538
2539   prop = RNA_def_property(srna, "end_cap", PROP_POINTER, PROP_NONE);
2540   RNA_def_property_ui_text(prop, "End Cap", "Mesh object to use as an end cap");
2541   RNA_def_property_pointer_funcs(
2542       prop, NULL, "rna_ArrayModifier_end_cap_set", NULL, "rna_Mesh_object_poll");
2543   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2544   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2545
2546   prop = RNA_def_property(srna, "offset_u", PROP_FLOAT, PROP_FACTOR);
2547   RNA_def_property_float_sdna(prop, NULL, "uv_offset[0]");
2548   RNA_def_property_range(prop, -1, 1);
2549   RNA_def_property_ui_range(prop, -1, 1, 2, 4);
2550   RNA_def_property_ui_text(prop, "U Offset", "Amount to offset array UVs on the U axis");
2551   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2552
2553   prop = RNA_def_property(srna, "offset_v", PROP_FLOAT, PROP_FACTOR);
2554   RNA_def_property_float_sdna(prop, NULL, "uv_offset[1]");
2555   RNA_def_property_range(prop, -1, 1);
2556   RNA_def_property_ui_range(prop, -1, 1, 2, 4);
2557   RNA_def_property_ui_text(prop, "V Offset", "Amount to offset array UVs on the V axis");
2558   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2559 }
2560
2561 static void rna_def_modifier_edgesplit(BlenderRNA *brna)
2562 {
2563   StructRNA *srna;
2564   PropertyRNA *prop;
2565
2566   srna = RNA_def_struct(brna, "EdgeSplitModifier", "Modifier");
2567   RNA_def_struct_ui_text(
2568       srna, "EdgeSplit Modifier", "Edge splitting modifier to create sharp edges");
2569   RNA_def_struct_sdna(srna, "EdgeSplitModifierData");
2570   RNA_def_struct_ui_icon(srna, ICON_MOD_EDGESPLIT);
2571
2572   prop = RNA_def_property(srna, "split_angle", PROP_FLOAT, PROP_ANGLE);
2573   RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
2574   RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 2);
2575   RNA_def_property_ui_text(prop, "Split Angle", "Angle above which to split edges");
2576   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2577
2578   prop = RNA_def_property(srna, "use_edge_angle", PROP_BOOLEAN, PROP_NONE);
2579   RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_EDGESPLIT_FROMANGLE);
2580   RNA_def_property_ui_text(prop, "Use Edge Angle", "Split edges with high angle between faces");
2581   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2582
2583   prop = RNA_def_property(srna, "use_edge_sharp", PROP_BOOLEAN, PROP_NONE);
2584   RNA_def_property_boolean_sdna(prop, NULL, "flags", MOD_EDGESPLIT_FROMFLAG);
2585   RNA_def_property_ui_text(prop, "Use Sharp Edges", "Split edges that are marked as sharp");
2586   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2587 }
2588
2589 static void rna_def_modifier_displace(BlenderRNA *brna)
2590 {
2591   StructRNA *srna;
2592   PropertyRNA *prop;
2593
2594   static const EnumPropertyItem prop_direction_items[] = {
2595       {MOD_DISP_DIR_X,
2596        "X",
2597        0,
2598        "X",
2599        "Use the texture's intensity value to displace in the X direction"},
2600       {MOD_DISP_DIR_Y,
2601        "Y",
2602        0,
2603        "Y",
2604        "Use the texture's intensity value to displace in the Y direction"},
2605       {MOD_DISP_DIR_Z,
2606        "Z",
2607        0,
2608        "Z",
2609        "Use the texture's intensity value to displace in the Z direction"},
2610       {MOD_DISP_DIR_NOR,
2611        "NORMAL",
2612        0,
2613        "Normal",
2614        "Use the texture's intensity value to displace along the vertex normal"},
2615       {MOD_DISP_DIR_CLNOR,
2616        "CUSTOM_NORMAL",
2617        0,
2618        "Custom Normal",
2619        "Use the texture's intensity value to displace along the (averaged) custom normal (falls "
2620        "back to vertex)"},
2621       {MOD_DISP_DIR_RGB_XYZ,
2622        "RGB_TO_XYZ",
2623        0,
2624        "RGB to XYZ",
2625        "Use the texture's RGB values to displace the mesh in the XYZ direction"},
2626       {0, NULL, 0, NULL, NULL},
2627   };
2628
2629   static const EnumPropertyItem prop_space_items[] = {
2630       {MOD_DISP_SPACE_LOCAL, "LOCAL", 0, "Local", "Direction is defined in local coordinates"},
2631       {MOD_DISP_SPACE_GLOBAL, "GLOBAL", 0, "Global", "Direction is defined in global coordinates"},
2632       {0, NULL, 0, NULL, NULL},
2633   };
2634
2635   srna = RNA_def_struct(brna, "DisplaceModifier", "Modifier");
2636   RNA_def_struct_ui_text(srna, "Displace Modifier", "Displacement modifier");
2637   RNA_def_struct_sdna(srna, "DisplaceModifierData");
2638   RNA_def_struct_ui_icon(srna, ICON_MOD_DISPLACE);
2639
2640   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
2641   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
2642   RNA_def_property_ui_text(
2643       prop,
2644       "Vertex Group",
2645       "Name of Vertex Group which determines influence of modifier per point");
2646   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_DisplaceModifier_defgrp_name_set");
2647   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2648
2649   prop = RNA_def_property(srna, "mid_level", PROP_FLOAT, PROP_FACTOR);
2650   RNA_def_property_float_sdna(prop, NULL, "midlevel");
2651   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2652   RNA_def_property_ui_range(prop, 0, 1, 10, 3);
2653   RNA_def_property_ui_text(prop, "Midlevel", "Material value that gives no displacement");
2654   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2655
2656   prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
2657   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2658   RNA_def_property_ui_range(prop, -100, 100, 10, 3);
2659   RNA_def_property_ui_text(prop, "Strength", "Amount to displace geometry");
2660   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2661
2662   prop = RNA_def_property(srna, "direction", PROP_ENUM, PROP_NONE);
2663   RNA_def_property_enum_items(prop, prop_direction_items);
2664   RNA_def_property_ui_text(prop, "Direction", "");
2665   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2666
2667   prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
2668   RNA_def_property_enum_items(prop, prop_space_items);
2669   RNA_def_property_ui_text(prop, "Space", "");
2670   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2671
2672   rna_def_modifier_generic_map_info(srna);
2673 }
2674
2675 static void rna_def_modifier_uvproject(BlenderRNA *brna)
2676 {
2677   StructRNA *srna;
2678   PropertyRNA *prop;
2679
2680   srna = RNA_def_struct(brna, "UVProjectModifier", "Modifier");
2681   RNA_def_struct_ui_text(
2682       srna, "UV Project Modifier", "UV projection modifier to set UVs from a projector");
2683   RNA_def_struct_sdna(srna, "UVProjectModifierData");
2684   RNA_def_struct_ui_icon(srna, ICON_MOD_UVPROJECT);
2685
2686   prop = RNA_def_property(srna, "uv_layer", PROP_STRING, PROP_NONE);
2687   RNA_def_property_string_sdna(prop, NULL, "uvlayer_name");
2688   RNA_def_property_ui_text(prop, "UV Map", "UV map name");
2689   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_UVProjectModifier_uvlayer_name_set");
2690   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2691
2692   prop = RNA_def_property(srna, "projector_count", PROP_INT, PROP_NONE);
2693   RNA_def_property_int_sdna(prop, NULL, "num_projectors");
2694   RNA_def_property_ui_text(prop, "Number of Projectors", "Number of projectors to use");
2695   RNA_def_property_int_funcs(prop, NULL, "rna_UVProjectModifier_num_projectors_set", NULL);
2696   RNA_def_property_range(prop, 1, MOD_UVPROJECT_MAXPROJECTORS);
2697   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2698
2699   prop = RNA_def_property(srna, "projectors", PROP_COLLECTION, PROP_NONE);
2700   RNA_def_property_struct_type(prop, "UVProjector");
2701   RNA_def_property_collection_funcs(prop,
2702                                     "rna_UVProject_projectors_begin",
2703                                     "rna_iterator_array_next",
2704                                     "rna_iterator_array_end",
2705                                     "rna_iterator_array_get",
2706                                     NULL,
2707                                     NULL,
2708                                     NULL,
2709                                     NULL);
2710   RNA_def_property_ui_text(prop, "Projectors", "");
2711
2712   prop = RNA_def_property(srna, "aspect_x", PROP_FLOAT, PROP_NONE);
2713   RNA_def_property_float_sdna(prop, NULL, "aspectx");
2714   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2715   RNA_def_property_range(prop, 1, FLT_MAX);
2716   RNA_def_property_ui_range(prop, 1, 1000, 1, 3);
2717   RNA_def_property_ui_text(prop, "Horizontal Aspect Ratio", "");
2718   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2719
2720   prop = RNA_def_property(srna, "aspect_y", PROP_FLOAT, PROP_NONE);
2721   RNA_def_property_float_sdna(prop, NULL, "aspecty");
2722   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2723   RNA_def_property_range(prop, 1, FLT_MAX);
2724   RNA_def_property_ui_range(prop, 1, 1000, 1, 3);
2725   RNA_def_property_ui_text(prop, "Vertical Aspect Ratio", "");
2726   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2727
2728   prop = RNA_def_property(srna, "scale_x", PROP_FLOAT, PROP_NONE);
2729   RNA_def_property_float_sdna(prop, NULL, "scalex");
2730   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2731   RNA_def_property_range(prop, 0, FLT_MAX);
2732   RNA_def_property_ui_range(prop, 0, 1000, 1, 3);
2733   RNA_def_property_ui_text(prop, "Horizontal Scale", "");
2734   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2735
2736   prop = RNA_def_property(srna, "scale_y", PROP_FLOAT, PROP_NONE);
2737   RNA_def_property_float_sdna(prop, NULL, "scaley");
2738   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2739   RNA_def_property_range(prop, 0, FLT_MAX);
2740   RNA_def_property_ui_range(prop, 0, 1000, 1, 3);
2741   RNA_def_property_ui_text(prop, "Vertical Scale", "");
2742   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2743
2744   srna = RNA_def_struct(brna, "UVProjector", NULL);
2745   RNA_def_struct_ui_text(srna, "UVProjector", "UV projector used by the UV project modifier");
2746
2747   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
2748   RNA_def_property_struct_type(prop, "Object");
2749   RNA_def_property_pointer_funcs(
2750       prop, "rna_UVProjector_object_get", "rna_UVProjector_object_set", NULL, NULL);
2751   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2752   RNA_def_property_ui_text(prop, "Object", "Object to use as projector transform");
2753   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2754 }
2755
2756 static void rna_def_modifier_smooth(BlenderRNA *brna)
2757 {
2758   StructRNA *srna;
2759   PropertyRNA *prop;
2760
2761   srna = RNA_def_struct(brna, "SmoothModifier", "Modifier");
2762   RNA_def_struct_ui_text(srna, "Smooth Modifier", "Smoothing effect modifier");
2763   RNA_def_struct_sdna(srna, "SmoothModifierData");
2764   RNA_def_struct_ui_icon(srna, ICON_MOD_SMOOTH);
2765
2766   prop = RNA_def_property(srna, "use_x", PROP_BOOLEAN, PROP_NONE);
2767   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_SMOOTH_X);
2768   RNA_def_property_ui_text(prop, "X", "Smooth object along X axis");
2769   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2770
2771   prop = RNA_def_property(srna, "use_y", PROP_BOOLEAN, PROP_NONE);
2772   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_SMOOTH_Y);
2773   RNA_def_property_ui_text(prop, "Y", "Smooth object along Y axis");
2774   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2775
2776   prop = RNA_def_property(srna, "use_z", PROP_BOOLEAN, PROP_NONE);
2777   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_SMOOTH_Z);
2778   RNA_def_property_ui_text(prop, "Z", "Smooth object along Z axis");
2779   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2780
2781   prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_FACTOR);
2782   RNA_def_property_float_sdna(prop, NULL, "fac");
2783   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2784   RNA_def_property_ui_range(prop, -10, 10, 1, 3);
2785   RNA_def_property_ui_text(prop, "Factor", "Strength of modifier effect");
2786   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2787
2788   prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
2789   RNA_def_property_int_sdna(prop, NULL, "repeat");
2790   RNA_def_property_ui_range(prop, 0, 30, 1, -1);
2791   RNA_def_property_ui_text(prop, "Repeat", "");
2792   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2793
2794   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
2795   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
2796   RNA_def_property_ui_text(
2797       prop,
2798       "Vertex Group",
2799       "Name of Vertex Group which determines influence of modifier per point");
2800   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SmoothModifier_defgrp_name_set");
2801   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2802 }
2803
2804 static void rna_def_modifier_correctivesmooth(BlenderRNA *brna)
2805 {
2806   StructRNA *srna;
2807   PropertyRNA *prop;
2808
2809   static const EnumPropertyItem modifier_smooth_type_items[] = {
2810       {MOD_CORRECTIVESMOOTH_SMOOTH_SIMPLE,
2811        "SIMPLE",
2812        0,
2813        "Simple",
2814        "Use the average of adjacent edge-vertices"},
2815       {MOD_CORRECTIVESMOOTH_SMOOTH_LENGTH_WEIGHT,
2816        "LENGTH_WEIGHTED",
2817        0,
2818        "Length Weight",
2819        "Use the average of adjacent edge-vertices weighted by their length"},
2820       {0, NULL, 0, NULL, NULL},
2821   };
2822
2823   static const EnumPropertyItem modifier_rest_source_items[] = {
2824       {MOD_CORRECTIVESMOOTH_RESTSOURCE_ORCO,
2825        "ORCO",
2826        0,
2827        "Original Coords",
2828        "Use base mesh vert coords as the rest position"},
2829       {MOD_CORRECTIVESMOOTH_RESTSOURCE_BIND,
2830        "BIND",
2831        0,
2832        "Bind Coords",
2833        "Use bind vert coords for rest position"},
2834       {0, NULL, 0, NULL, NULL},
2835   };
2836
2837   srna = RNA_def_struct(brna, "CorrectiveSmoothModifier", "Modifier");
2838   RNA_def_struct_ui_text(
2839       srna, "Corrective Smooth Modifier", "Correct distortion caused by deformation");
2840   RNA_def_struct_sdna(srna, "CorrectiveSmoothModifierData");
2841   RNA_def_struct_ui_icon(srna, ICON_MOD_SMOOTH);
2842
2843   prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_FACTOR);
2844   RNA_def_property_float_sdna(prop, NULL, "lambda");
2845   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2846   RNA_def_property_ui_range(prop, 0.0, 1.0, 5, 3);
2847   RNA_def_property_ui_text(prop, "Lambda Factor", "Smooth factor effect");
2848   RNA_def_property_update(prop, 0, "rna_CorrectiveSmoothModifier_update");
2849
2850   prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
2851   RNA_def_property_int_sdna(prop, NULL, "repeat");
2852   RNA_def_property_ui_range(prop, 0, 200, 1, -1);
2853   RNA_def_property_ui_text(prop, "Repeat", "");
2854   RNA_def_property_update(prop, 0, "rna_CorrectiveSmoothModifier_update");
2855
2856   prop = RNA_def_property(srna, "rest_source", PROP_ENUM, PROP_NONE);
2857   RNA_def_property_enum_sdna(prop, NULL, "rest_source");
2858   RNA_def_property_enum_items(prop, modifier_rest_source_items);
2859   RNA_def_property_ui_text(prop, "Rest Source", "Select the source of rest positions");
2860   RNA_def_property_update(prop, 0, "rna_CorrectiveSmoothModifier_rest_source_update");
2861
2862   prop = RNA_def_property(srna, "smooth_type", PROP_ENUM, PROP_NONE);
2863   RNA_def_property_enum_sdna(prop, NULL, "smooth_type");
2864   RNA_def_property_enum_items(prop, modifier_smooth_type_items);
2865   RNA_def_property_ui_text(prop, "Smooth Type", "Method used for smoothing");
2866   RNA_def_property_update(prop, 0, "rna_CorrectiveSmoothModifier_update");
2867
2868   prop = RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
2869   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CORRECTIVESMOOTH_INVERT_VGROUP);
2870   RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence");
2871   RNA_def_property_update(prop, 0, "rna_CorrectiveSmoothModifier_update");
2872
2873   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
2874   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
2875   RNA_def_property_ui_text(
2876       prop,
2877       "Vertex Group",
2878       "Name of Vertex Group which determines influence of modifier per point");
2879   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_CorrectiveSmoothModifier_defgrp_name_set");
2880   RNA_def_property_update(prop, 0, "rna_CorrectiveSmoothModifier_update");
2881
2882   prop = RNA_def_property(srna, "is_bind", PROP_BOOLEAN, PROP_NONE);
2883   RNA_def_property_ui_text(prop, "Bind current shape", "");
2884   RNA_def_property_boolean_funcs(prop, "rna_CorrectiveSmoothModifier_is_bind_get", NULL);
2885   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2886   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2887
2888   prop = RNA_def_property(srna, "use_only_smooth", PROP_BOOLEAN, PROP_NONE);
2889   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CORRECTIVESMOOTH_ONLY_SMOOTH);
2890   RNA_def_property_ui_text(
2891       prop, "Only Smooth", "Apply smoothing without reconstructing the surface");
2892   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2893
2894   prop = RNA_def_property(srna, "use_pin_boundary", PROP_BOOLEAN, PROP_NONE);
2895   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CORRECTIVESMOOTH_PIN_BOUNDARY);
2896   RNA_def_property_ui_text(
2897       prop, "Pin Boundaries", "Excludes boundary vertices from being smoothed");
2898   RNA_def_property_update(prop, 0, "rna_CorrectiveSmoothModifier_update");
2899 }
2900
2901 static void rna_def_modifier_laplaciansmooth(BlenderRNA *brna)
2902 {
2903   StructRNA *srna;
2904   PropertyRNA *prop;
2905
2906   srna = RNA_def_struct(brna, "LaplacianSmoothModifier", "Modifier");
2907   RNA_def_struct_ui_text(srna, "Laplacian Smooth Modifier", "Smoothing effect modifier");
2908   RNA_def_struct_sdna(srna, "LaplacianSmoothModifierData");
2909   RNA_def_struct_ui_icon(srna, ICON_MOD_SMOOTH);
2910
2911   prop = RNA_def_property(srna, "use_x", PROP_BOOLEAN, PROP_NONE);
2912   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_X);
2913   RNA_def_property_ui_text(prop, "X", "Smooth object along X axis");
2914   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2915
2916   prop = RNA_def_property(srna, "use_y", PROP_BOOLEAN, PROP_NONE);
2917   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_Y);
2918   RNA_def_property_ui_text(prop, "Y", "Smooth object along Y axis");
2919   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2920
2921   prop = RNA_def_property(srna, "use_z", PROP_BOOLEAN, PROP_NONE);
2922   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_Z);
2923   RNA_def_property_ui_text(prop, "Z", "Smooth object along Z axis");
2924   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2925
2926   prop = RNA_def_property(srna, "use_volume_preserve", PROP_BOOLEAN, PROP_NONE);
2927   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_PRESERVE_VOLUME);
2928   RNA_def_property_ui_text(prop, "Preserve Volume", "Apply volume preservation after smooth");
2929   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2930
2931   prop = RNA_def_property(srna, "use_normalized", PROP_BOOLEAN, PROP_NONE);
2932   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_LAPLACIANSMOOTH_NORMALIZED);
2933   RNA_def_property_ui_text(prop, "Normalized", "Improve and stabilize the enhanced shape");
2934   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2935
2936   prop = RNA_def_property(srna, "lambda_factor", PROP_FLOAT, PROP_NONE);
2937   RNA_def_property_float_sdna(prop, NULL, "lambda");
2938   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2939   RNA_def_property_ui_range(prop, -1000.0, 1000.0, 5, 3);
2940   RNA_def_property_ui_text(prop, "Lambda Factor", "Smooth factor effect");
2941   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2942
2943   prop = RNA_def_property(srna, "lambda_border", PROP_FLOAT, PROP_NONE);
2944   RNA_def_property_float_sdna(prop, NULL, "lambda_border");
2945   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
2946   RNA_def_property_ui_range(prop, -1000.0, 1000.0, 5, 3);
2947   RNA_def_property_ui_text(prop, "Lambda Border", "Lambda factor in border");
2948   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2949
2950   prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
2951   RNA_def_property_int_sdna(prop, NULL, "repeat");
2952   RNA_def_property_ui_range(prop, 0, 200, 1, -1);
2953   RNA_def_property_ui_text(prop, "Repeat", "");
2954   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2955
2956   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
2957   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
2958   RNA_def_property_ui_text(
2959       prop,
2960       "Vertex Group",
2961       "Name of Vertex Group which determines influence of modifier per point");
2962   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_LaplacianSmoothModifier_defgrp_name_set");
2963   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2964 }
2965
2966 static void rna_def_modifier_cast(BlenderRNA *brna)
2967 {
2968   StructRNA *srna;
2969   PropertyRNA *prop;
2970
2971   static const EnumPropertyItem prop_cast_type_items[] = {
2972       {MOD_CAST_TYPE_SPHERE, "SPHERE", 0, "Sphere", ""},
2973       {MOD_CAST_TYPE_CYLINDER, "CYLINDER", 0, "Cylinder", ""},
2974       {MOD_CAST_TYPE_CUBOID, "CUBOID", 0, "Cuboid", ""},
2975       {0, NULL, 0, NULL, NULL},
2976   };
2977
2978   srna = RNA_def_struct(brna, "CastModifier", "Modifier");
2979   RNA_def_struct_ui_text(srna, "Cast Modifier", "Modifier to cast to other shapes");
2980   RNA_def_struct_sdna(srna, "CastModifierData");
2981   RNA_def_struct_ui_icon(srna, ICON_MOD_CAST);
2982
2983   prop = RNA_def_property(srna, "cast_type", PROP_ENUM, PROP_NONE);
2984   RNA_def_property_enum_sdna(prop, NULL, "type");
2985   RNA_def_property_enum_items(prop, prop_cast_type_items);
2986   RNA_def_property_ui_text(prop, "Cast Type", "Target object shape");
2987   RNA_def_property_update(prop, 0, "rna_Modifier_update");
2988
2989   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
2990   RNA_def_property_ui_text(
2991       prop,
2992       "Object",
2993       "Control object: if available, its location determines the center of the effect");
2994   RNA_def_property_pointer_funcs(prop, NULL, "rna_CastModifier_object_set", NULL, NULL);
2995   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2996   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
2997
2998   prop = RNA_def_property(srna, "use_x", PROP_BOOLEAN, PROP_NONE);
2999   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_X);
3000   RNA_def_property_ui_text(prop, "X", "");
3001   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3002
3003   prop = RNA_def_property(srna, "use_y", PROP_BOOLEAN, PROP_NONE);
3004   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_Y);
3005   RNA_def_property_ui_text(prop, "Y", "");
3006   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3007
3008   prop = RNA_def_property(srna, "use_z", PROP_BOOLEAN, PROP_NONE);
3009   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_Z);
3010   RNA_def_property_ui_text(prop, "Z", "");
3011   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3012
3013   prop = RNA_def_property(srna, "use_radius_as_size", PROP_BOOLEAN, PROP_NONE);
3014   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_SIZE_FROM_RADIUS);
3015   RNA_def_property_ui_text(
3016       prop, "From Radius", "Use radius as size of projection shape (0 = auto)");
3017   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3018
3019   prop = RNA_def_property(srna, "use_transform", PROP_BOOLEAN, PROP_NONE);
3020   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_USE_OB_TRANSFORM);
3021   RNA_def_property_ui_text(
3022       prop, "Use transform", "Use object transform to control projection shape");
3023   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3024
3025   prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_FACTOR);
3026   RNA_def_property_float_sdna(prop, NULL, "fac");
3027   RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
3028   RNA_def_property_ui_range(prop, -10, 10, 5, 2);
3029   RNA_def_property_ui_text(prop, "Factor", "");
3030   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3031
3032   prop = RNA_def_property(srna, "radius", PROP_FLOAT, PROP_DISTANCE);
3033   RNA_def_property_range(prop, 0, FLT_MAX);
3034   RNA_def_property_ui_range(prop, 0, 100, 5, 2);
3035   RNA_def_property_ui_text(
3036       prop,
3037       "Radius",
3038       "Only deform vertices within this distance from the center of the effect "
3039       "(leave as 0 for infinite.)");
3040   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3041
3042   prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
3043   RNA_def_property_range(prop, 0, FLT_MAX);
3044   RNA_def_property_ui_range(prop, 0, 100, 5, 2);
3045   RNA_def_property_ui_text(prop, "Size", "Size of projection shape (leave as 0 for auto)");
3046   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3047
3048   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
3049   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
3050   RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name");
3051   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_CastModifier_defgrp_name_set");
3052   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3053 }
3054
3055 static void rna_def_modifier_meshdeform(BlenderRNA *brna)
3056 {
3057   StructRNA *srna;
3058   PropertyRNA *prop;
3059 #  if 0
3060   static const EnumPropertyItem prop_mode_items[] = {
3061       {0, "VOLUME", 0, "Volume", "Bind to volume inside cage mesh"},
3062       {1, "SURFACE", 0, "Surface", "Bind to surface of cage mesh"},
3063       {0, NULL, 0, NULL, NULL},
3064   };
3065 #  endif
3066
3067   srna = RNA_def_struct(brna, "MeshDeformModifier", "Modifier");
3068   RNA_def_struct_ui_text(
3069       srna, "MeshDeform Modifier", "Mesh deformation modifier to deform with other meshes");
3070   RNA_def_struct_sdna(srna, "MeshDeformModifierData");
3071   RNA_def_struct_ui_icon(srna, ICON_MOD_MESHDEFORM);
3072
3073   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
3074   RNA_def_property_ui_text(prop, "Object", "Mesh object to deform with");
3075   RNA_def_property_pointer_funcs(
3076       prop, NULL, "rna_MeshDeformModifier_object_set", NULL, "rna_Mesh_object_poll");
3077   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
3078   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
3079
3080   prop = RNA_def_property(srna, "is_bound", PROP_BOOLEAN, PROP_NONE);
3081   RNA_def_property_boolean_funcs(prop, "rna_MeshDeformModifier_is_bound_get", NULL);
3082   RNA_def_property_ui_text(prop, "Bound", "Whether geometry has been bound to control cage");
3083   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3084
3085   prop = RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
3086   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MDEF_INVERT_VGROUP);
3087   RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence");
3088   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3089
3090   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
3091   RNA_def_property_string_sdna(prop, NULL, "defgrp_name");
3092   RNA_def_property_ui_text(prop, "Vertex Group", "Vertex group name");
3093   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MeshDeformModifier_defgrp_name_set");
3094   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3095
3096   prop = RNA_def_property(srna, "precision", PROP_INT, PROP_NONE);
3097   RNA_def_property_int_sdna(prop, NULL, "gridsize");
3098   RNA_def_property_range(prop, 2, 10);
3099   RNA_def_property_ui_text(prop, "Precision", "The grid size for binding");
3100   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3101
3102   prop = RNA_def_property(srna, "use_dynamic_bind", PROP_BOOLEAN, PROP_NONE);
3103   RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MDEF_DYNAMIC_BIND);
3104   RNA_def_property_ui_text(prop,
3105                            "Dynamic",
3106                            "Recompute binding dynamically on top of other deformers "
3107                            "(slower and more memory consuming)");
3108   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3109
3110 #  if 0
3111   prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
3112   RNA_def_property_enum_items(prop, prop_mode_items);
3113   RNA_def_property_ui_text(prop, "Mode", "Method of binding vertices are bound to cage mesh");
3114   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3115 #  endif
3116 }
3117
3118 static void rna_def_modifier_particlesystem(BlenderRNA *brna)
3119 {
3120   StructRNA *srna;
3121   PropertyRNA *prop;
3122
3123   srna = RNA_def_struct(brna, "ParticleSystemModifier", "Modifier");
3124   RNA_def_struct_ui_text(srna, "ParticleSystem Modifier", "Particle system simulation modifier");
3125   RNA_def_struct_sdna(srna, "ParticleSystemModifierData");
3126   RNA_def_struct_ui_icon(srna, ICON_MOD_PARTICLES);
3127
3128   prop = RNA_def_property(srna, "particle_system", PROP_POINTER, PROP_NONE);
3129   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3130   RNA_def_property_pointer_sdna(prop, NULL, "psys");
3131   RNA_def_property_ui_text(prop, "Particle System", "Particle System that this modifier controls");
3132 }
3133
3134 static void rna_def_modifier_particleinstance(BlenderRNA *brna)
3135 {
3136   StructRNA *srna;
3137   PropertyRNA *prop;
3138
3139   static EnumPropertyItem particleinstance_space[] = {
3140       {eParticleInstanceSpace_Local,
3141        "LOCAL",
3142        0,
3143        "Local",
3144        "Use offset from the particle object in the instance object"},
3145       {eParticleInstanceSpace_World,
3146        "WORLD",
3147        0,
3148        "World",
3149        "Use world space offset in the instance object"},
3150       {0, NULL, 0, NULL, NULL},
3151   };
3152
3153   srna = RNA_def_struct(brna, "ParticleInstanceModifier", "Modifier");
3154   RNA_def_struct_ui_text(srna, "ParticleInstance Modifier", "Particle system instancing modifier");
3155   RNA_def_struct_sdna(srna, "ParticleInstanceModifierData");
3156   RNA_def_struct_ui_icon(srna, ICON_MOD_PARTICLES);
3157
3158   prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
3159   RNA_def_property_pointer_sdna(prop, NULL, "ob");
3160   RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Mesh_object_poll");
3161   RNA_def_property_ui_text(prop, "Object", "Object that has the particle system");
3162   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
3163   RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
3164
3165   prop = RNA_def_property(srna, "particle_system_index", PROP_INT, PROP_NONE);
3166   RNA_def_property_int_sdna(prop, NULL, "psys");
3167   RNA_def_property_range(prop, 1, SHRT_MAX);
3168   RNA_def_property_ui_text(prop, "Particle System Number", "");
3169   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3170
3171   prop = RNA_def_property(srna, "particle_system", PROP_POINTER, PROP_NONE);
3172   RNA_def_property_struct_type(prop, "ParticleSystem");
3173   RNA_def_property_pointer_funcs(prop,
3174                                  "rna_ParticleInstanceModifier_particle_system_get",
3175                                  "rna_ParticleInstanceModifier_particle_system_set",
3176                                  NULL,
3177                                  "rna_ParticleInstanceModifier_particle_system_poll");
3178   RNA_def_property_flag(prop, PROP_EDITABLE);
3179   RNA_def_property_ui_text(prop, "Particle System", "");
3180   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3181
3182   prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
3183   RNA_def_property_enum_sdna(prop, NULL, "axis");
3184   RNA_def_property_enum_items(prop, rna_enum_axis_xyz_items);
3185   RNA_def_property_ui_text(prop, "Axis", "Pole axis for rotation");
3186   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3187
3188   prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
3189   RNA_def_property_enum_sdna(prop, NULL, "space");
3190   RNA_def_property_enum_items(prop, particleinstance_space);
3191   RNA_def_property_ui_text(prop, "Space", "Space to use for copying mesh data");
3192   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3193
3194   prop = RNA_def_property(srna, "use_normal", PROP_BOOLEAN, PROP_NONE);
3195   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Parents);
3196   RNA_def_property_ui_text(prop, "Regular", "Create instances from normal particles");
3197   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3198
3199   prop = RNA_def_property(srna, "use_children", PROP_BOOLEAN, PROP_NONE);
3200   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Children);
3201   RNA_def_property_ui_text(prop, "Children", "Create instances from child particles");
3202   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_PARTICLESETTINGS);
3203   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3204
3205   prop = RNA_def_property(srna, "use_path", PROP_BOOLEAN, PROP_NONE);
3206   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Path);
3207   RNA_def_property_ui_text(prop, "Path", "Create instances along particle paths");
3208   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3209
3210   prop = RNA_def_property(srna, "show_unborn", PROP_BOOLEAN, PROP_NONE);
3211   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Unborn);
3212   RNA_def_property_ui_text(prop, "Unborn", "Show instances when particles are unborn");
3213   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3214
3215   prop = RNA_def_property(srna, "show_alive", PROP_BOOLEAN, PROP_NONE);
3216   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Alive);
3217   RNA_def_property_ui_text(prop, "Alive", "Show instances when particles are alive");
3218   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3219
3220   prop = RNA_def_property(srna, "show_dead", PROP_BOOLEAN, PROP_NONE);
3221   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Dead);
3222   RNA_def_property_ui_text(prop, "Dead", "Show instances when particles are dead");
3223   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3224
3225   prop = RNA_def_property(srna, "use_preserve_shape", PROP_BOOLEAN, PROP_NONE);
3226   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_KeepShape);
3227   RNA_def_property_ui_text(prop, "Keep Shape", "Don't stretch the object");
3228   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3229
3230   prop = RNA_def_property(srna, "use_size", PROP_BOOLEAN, PROP_NONE);
3231   RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_UseSize);
3232   RNA_def_property_ui_text(prop, "Size", "Use particle size to scale the instances");
3233   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3234
3235   prop = RNA_def_property(srna, "position", PROP_FLOAT, PROP_NONE);
3236   RNA_def_property_float_sdna(prop, NULL, "position");
3237   RNA_def_property_range(prop, 0.0, 1.0);
3238   RNA_def_property_ui_text(prop, "Position", "Position along path");
3239   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3240
3241   prop = RNA_def_property(srna, "random_position", PROP_FLOAT, PROP_NONE);
3242   RNA_def_property_float_sdna(prop, NULL, "random_position");
3243   RNA_def_property_range(prop, 0.0, 1.0);
3244   RNA_def_property_ui_text(prop, "Random Position", "Randomize position along path");
3245   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3246
3247   prop = RNA_def_property(srna, "rotation", PROP_FLOAT, PROP_FACTOR);
3248   RNA_def_property_float_sdna(prop, NULL, "rotation");
3249   RNA_def_property_range(prop, 0.0, 1.0);
3250   RNA_def_property_ui_text(prop, "Rotation", "Rotation around path");
3251   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3252
3253   prop = RNA_def_property(srna, "random_rotation", PROP_FLOAT, PROP_FACTOR);
3254   RNA_def_property_float_sdna(prop, NULL, "random_rotation");
3255   RNA_def_property_range(prop, 0.0, 1.0);
3256   RNA_def_property_ui_text(prop, "Random Rotation", "Randomize rotation around path");
3257   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3258
3259   prop = RNA_def_property(srna, "particle_amount", PROP_FLOAT, PROP_FACTOR);
3260   RNA_def_property_range(prop, 0.0, 1.0);
3261   RNA_def_property_ui_text(prop, "Particle Amount", "Amount of particles to use for instancing");
3262   RNA_def_property_float_default(prop, 1.0f);
3263   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3264
3265   prop = RNA_def_property(srna, "particle_offset", PROP_FLOAT, PROP_FACTOR);
3266   RNA_def_property_range(prop, 0.0, 1.0);
3267   RNA_def_property_ui_text(prop,
3268                            "Particle Offset",
3269                            "Relative offset of particles to use for instancing, to avoid overlap "
3270                            "of multiple instances");
3271   RNA_def_property_float_default(prop, 0.0f);
3272   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3273
3274   prop = RNA_def_property(srna, "index_layer_name", PROP_STRING, PROP_NONE);
3275   RNA_def_property_string_sdna(prop, NULL, "index_layer_name");
3276   RNA_def_property_ui_text(prop, "Index Layer Name", "Custom data layer name for the index");
3277   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3278
3279   prop = RNA_def_property(srna, "value_layer_name", PROP_STRING, PROP_NONE);
3280   RNA_def_property_string_sdna(prop, NULL, "value_layer_name");
3281   RNA_def_property_ui_text(
3282       prop, "Value Layer Name", "Custom data layer name for the randomized value");
3283   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3284 }
3285
3286 static void rna_def_modifier_explode(BlenderRNA *brna)
3287 {
3288   StructRNA *srna;
3289   PropertyRNA *prop;
3290
3291   srna = RNA_def_struct(brna, "ExplodeModifier", "Modifier");
3292   RNA_def_struct_ui_text(
3293       srna, "Explode Modifier", "Explosion effect modifier based on a particle system");
3294   RNA_def_struct_sdna(srna, "ExplodeModifierData");
3295   RNA_def_struct_ui_icon(srna, ICON_MOD_EXPLODE);
3296
3297   prop = RNA_def_property(srna, "vertex_group", PROP_STRING, PROP_NONE);
3298   RNA_def_property_string_funcs(prop,
3299                                 "rna_ExplodeModifier_vgroup_get",
3300                                 "rna_ExplodeModifier_vgroup_length",
3301                                 "rna_ExplodeModifier_vgroup_set");
3302   RNA_def_property_ui_text(prop, "Vertex Group", "");
3303
3304   prop = RNA_def_property(srna, "protect", PROP_FLOAT, PROP_NONE);
3305   RNA_def_property_range(prop, 0, 1);
3306   RNA_def_property_ui_text(prop, "Protect", "Clean vertex group edges");
3307   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3308
3309   prop = RNA_def_property(srna, "use_edge_cut", PROP_BOOLEAN, PROP_NONE);
3310   RNA_def_property_boolean_sdna(prop, NULL, "flag", eExplodeFlag_EdgeCut);
3311   RNA_def_property_ui_text(prop, "Cut Edges", "Cut face edges for nicer shrapnel");
3312   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3313
3314   prop = RNA_def_property(srna, "show_unborn", PROP_BOOLEAN, PROP_NONE);
3315   RNA_def_property_boolean_sdna(prop, NULL, "flag", eExplodeFlag_Unborn);
3316   RNA_def_property_ui_text(prop, "Unborn", "Show mesh when particles are unborn");
3317   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3318
3319   prop = RNA_def_property(srna, "show_alive", PROP_BOOLEAN, PROP_NONE);
3320   RNA_def_property_boolean_sdna(prop, NULL, "flag", eExplodeFlag_Alive);
3321   RNA_def_property_ui_text(prop, "Alive", "Show mesh when particles are alive");
3322   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3323
3324   prop = RNA_def_property(srna, "show_dead", PROP_BOOLEAN, PROP_NONE);
3325   RNA_def_property_boolean_sdna(prop, NULL, "flag", eExplodeFlag_Dead);
3326   RNA_def_property_ui_text(prop, "Dead", "Show mesh when particles are dead");
3327   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3328
3329   prop = RNA_def_property(srna, "use_size", PROP_BOOLEAN, PROP_NONE);
3330   RNA_def_property_boolean_sdna(prop, NULL, "flag", eExplodeFlag_PaSize);
3331   RNA_def_property_ui_text(prop, "Size", "Use particle size for the shrapnel");
3332   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3333
3334   prop = RNA_def_property(srna, "particle_uv", PROP_STRING, PROP_NONE);
3335   RNA_def_property_string_sdna(prop, NULL, "uvname");
3336   RNA_def_property_string_maxlength(prop, MAX_CUSTOMDATA_LAYER_NAME);
3337   RNA_def_property_ui_text(prop, "Particle UV", "UV map to change with particle age");
3338   RNA_def_property_update(prop, 0, "rna_Modifier_update");
3339 }
3340
3341 static void rna_def_modifier_cloth(BlenderRNA *brna)
3342 {
3343   StructRNA *srna;
3344   PropertyRNA *prop;
3345
3346   srna = RNA_def_struct(brna, "ClothModifier", "Modifier");
3347   RNA_def_struct_ui_text(srna, "Cloth Modifier", "Cloth simulation modifier");
3348   RNA_def_struct_sdna(srna, "ClothModifierData");
3349   RNA_def_struct_ui_icon(srna, ICON_MOD_CLOTH);
3350
3351   prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
3352   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3353   RNA_def_property_pointer_sdna(prop, NULL, "sim_parms");
3354   RNA_def_property_ui_text(prop, "Cloth Settings", "");
3355
3356   prop = RNA_def_property(srna, "collision_settings", PROP_POINTER, PROP_NONE);
3357   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3358   RNA_def_property_pointer_sdna(prop, NULL, "coll_parms");
3359   RNA_def_property_ui_text(prop, "Cloth Collision Settings", "");
3360
3361   prop = RNA_def_property(srna, "solver_result", PROP_POINTER, PROP_NONE);
3362   RNA_def_property_struct_type(prop, "ClothSolverResult");
3363   RNA_def_property_pointer_sdna(prop, NULL, "solver_result");
3364   RNA_def_property_ui_text(prop, "Solver Result", "");
3365
3366   prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
3367   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3368   RNA_def_property_ui_text(prop, "Point Cache", "");
3369
3370   prop = RNA_def_property(srna, "hair_grid_min", PROP_FLOAT, PROP_NONE);
3371   RNA_def_property_float_sdna(prop, NULL, "hair_grid_min");
3372   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3373   RNA_def_property_ui_text(prop, "Hair Grid Minimum", "");
3374
3375   prop = RNA_def_property(srna, "hair_grid_max", PROP_FLOAT, PROP_NONE);
3376   RNA_def_property_float_sdna(prop, NULL, "hair_grid_max");
3377   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3378   RNA_def_property_ui_text(prop, "Hair Grid Maximum", "");
3379
3380   prop = RNA_def_property(srna, "hair_grid_resolution", PROP_INT, PROP_NONE);
3381   RNA_def_property_int_sdna(prop, NULL, "hair_grid_res");
3382   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3383   RNA_def_property_ui_text(prop, "Hair Grid Resolution", "");
3384 }
3385
3386 static void rna_def_modifier_smoke(BlenderRNA *brna)
3387 {
3388   StructRNA *srna;
3389   PropertyRNA *prop;
3390
3391   static const EnumPropertyItem prop_smoke_type_items[] = {
3392       {0, "NONE", 0, "None", ""},
3393       {MOD_SMOKE_TYPE_DOMAIN, "DOMAIN", 0, "Domain", ""},
3394       {MOD_SMOKE_TYPE_FLOW, "FLOW", 0, "Flow", "Inflow/Outflow"},
3395       {MOD_SMOKE_TYPE_COLL, "COLLISION", 0, "Collision", ""},
3396       {0, NULL, 0, NULL, NULL},
3397   };
3398
3399   srna = RNA_def_struct(brna, "SmokeModifier", "Modifier");
3400   RNA_def_struct_ui_text(srna, "Smoke Modifier", "Smoke simulation modifier");
3401   RNA_def_struct_sdna(srna, "SmokeModifierData");
3402   RNA_def_struct_ui_icon(srna, ICON_MOD_SMOKE);
3403
3404   prop = RNA_def_property(srna, "domain_settings", PROP_POINTER, PROP_NONE);
3405   RNA_def_property_pointer_sdna(prop, NULL, "domain");
3406   RNA_def_property_ui_text(prop, "Domain Settings", "");
3407
3408   prop = RNA_def_property(srna, "flow_settings", PROP_POINTER, PROP_NONE);
3409   RNA_def_property_pointer_sdna(prop, NULL, "flow");
3410   RNA_def_property_ui_text(prop, "Flow Settings", "");
3411
3412   prop = RNA_def_property(srna, "coll_settings", PROP_POINTER, PROP_NONE);
3413   RNA_def_property_pointer_sdna(prop, NULL, "coll");
3414   RNA_def_property_ui_text(prop, "Collision Settings", "");
3415
3416   prop = RNA_def_property(srna, "smoke_type", PROP_ENUM, PROP_NONE);
3417   RNA_def_property_enum_sdna(prop, NULL, "type");
3418   RNA_def_property_enum_items(prop, prop_smoke_type_items);
3419   RNA_def_property_ui_text(prop, "Type", "");
3420   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3421   RNA_def_property_update(prop, 0, "rna_Smoke_set_type");
3422 }
3423
3424 static void rna_def_modifier_dynamic_paint(BlenderRNA *brna)
3425 {
3426   StructRNA *srna;
3427   PropertyRNA *prop;
3428
3429   srna = RNA_def_struct(brna, "DynamicPaintModifier", "Modifier");
3430   RNA_def_struct_ui_text(srna, "Dynamic Paint Modifier", "Dynamic Paint modifier");
3431   RNA_def_struct_sdna(srna, "DynamicPaintModifierData");
3432   RNA_def_struct_ui_icon(srna, ICON_MOD_DYNAMICPAINT);
3433
3434   prop = RNA_def_property(srna, "canvas_settings", PROP_POINTER, PROP_NONE);
3435   RNA_def_property_pointer_sdna(prop, NULL, "canvas");
3436   RNA_def_property_ui_text(prop, "Canvas Settings", "");
3437
3438   prop = RNA_def_property(srna, "brush_settings", PROP_POINTER, PROP_NONE);
3439   RNA_def_property_pointer_sdna(prop, NULL, "brush");
3440   RNA_def_property_ui_text(prop, "Brush Settings", "");
3441
3442   prop = RNA_def_property(srna, "ui_type", PROP_ENUM, PROP_NONE);
3443   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
3444   RNA_def_property_enum_sdna(prop, NULL, "type");
3445   RNA_def_property_enum_items(prop, rna_enum_prop_dynamicpaint_type_items);
3446   RNA_def_property_ui_text(prop, "Type", "");
3447 }
3448
3449 static void rna_def_modifier_collision(BlenderRNA *brna)
3450 {
3451   StructRNA *srna;
3452   PropertyRNA *prop;
3453
3454   srna = RNA_def_struct(brna, "CollisionModifier", "Modifier");
3455   RNA_def_struct_ui_text(srna,
3456                          "Collision Modifier",
3457                          "Collision modifier defining modifier stack position used for collision");
3458   RNA_def_struct_sdna(srna, "CollisionModifierData");
3459   RNA_def_struct_ui_icon(srna, ICON_MOD_PHYSICS);
3460
3461   prop = RNA_def_property(srna, "settings", PROP_POINTER, PROP_NONE);
3462   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3463   RNA_def_property_struct_type(prop, "CollisionSettings");
3464   RNA_def_property_pointer_funcs(prop, "rna_CollisionModifier_settings_get", NULL, NULL, NULL);
3465   RNA_def_property_ui_text(prop, "Settings", "");
3466 }
3467
3468 static void rna_def_modifier_bevel(BlenderRNA *brna)
3469 {
3470   StructRNA *srna;
3471   PropertyRNA *prop;
3472
3473   static const EnumPropertyItem prop_limit_method_items[] = {
3474       {0, "NONE", 0, "None", "Bevel the entire mesh by a constant amount"},
3475       {MOD_BEVEL_ANGLE,
3476        "ANGLE",
3477        0,
3478        "Angle",
3479        "Only bevel edges with sharp enough angles between faces"},
3480       {MOD_BEVEL_WEIGHT,
3481        "WEIGHT",
3482        0,
3483        "Weight",
3484        "Use bevel weights to determine how much bevel is applied in edge mode"},
3485       {MOD_BEVEL_VGROUP,
3486        "VGROUP",
3487        0,
3488        "Vertex Group",
3489        "Use vertex group weights to select whether vertex or edge is beveled"},
3490       {0, NULL, 0, NULL, NULL},
3491   };
3492
3493   static const EnumPropertyItem prop_val_type_items[] = {
3494       {MOD_BEVEL_AMT_OFFSET, "OFFSET", 0, "Offset", "Amount is offset of new edges from original"},
3495       {MOD_BEVEL_AMT_WIDTH, "WIDTH", 0, "Width", "Amount is width of new face"},
3496       {MOD_BEVEL_AMT_DEPTH,
3497        "DEPTH",
3498        0,
3499        "Depth",
3500        "Amount is perpendicular distance from original edge to bevel face"},
3501       {MOD_BEVEL_AMT_PERCENT,
3502        "PERCENT",
3503        0,
3504        "Percent",
3505        "Amount is percent of adjacent edge length"},
3506       {0, NULL, 0, NULL, NULL},
3507   };
3508
3509   static EnumPropertyItem prop_harden_normals_items[] = {
3510       {MOD_BEVEL_FACE_STRENGTH_NONE, "FSTR_NONE", 0, "None", "Do not set face strength"},
3511       {MOD_BEVEL_FACE_STRENGTH_NEW, "FSTR_NEW", 0, "New", "Set face strength on new faces only"},
3512       {MOD_BEVEL_FACE_STRENGTH_AFFECTED,
3513        "FSTR_AFFECTED",
3514        0,
3515        "Affected",
3516        "Set face strength on new and affected faces only"},
3517       {MOD_BEVEL_FACE_STRENGTH_ALL, "FSTR_ALL", 0, "All", "Set face strength on all faces"},
3518       {0, NULL, 0, NULL, NULL},
3519   };
3520
3521   static EnumPropertyItem prop_miter_items[] = {
3522       {MOD_BEVEL_MITER_SHARP, "MITER_SHARP", 0, "Sharp", "Default sharp miter"},
3523       {MOD_BEVEL_MITER_PATCH, "MITER_PATCH", 0, "Patch", "Miter with extra corner"},
3524       {MOD_BEVEL_MITER_ARC, "MITER_ARC", 0, "Arc", "Miter with curved arc"},
3525       {0, NULL, 0, NULL, NULL},
3526   };
3527
3528   srna = RNA_def_struct(brna, "BevelModifier", "Modifier");
3529   RNA_def_struct_ui_text(
3530       srna, "Bevel Modifier", "Bevel modifier to make edges and vertices more rounded");
3531   RNA_def_struct_sdna(srna, "BevelModifierData");
3532   RNA_def_struct_ui_icon(srna, ICON_MOD_BEVEL);
3533
3534   prop = RNA_def_property(srna, "width", PROP_FLOAT, PROP_DISTANCE);