Cleanup: reorder report argument for pointer assignment
[blender.git] / source / blender / makesrna / intern / rna_object.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 <stdio.h>
22 #include <stdlib.h>
23
24 #include "DNA_action_types.h"
25 #include "DNA_brush_types.h"
26 #include "DNA_collection_types.h"
27 #include "DNA_customdata_types.h"
28 #include "DNA_material_types.h"
29 #include "DNA_mesh_types.h"
30 #include "DNA_object_force_types.h"
31 #include "DNA_object_types.h"
32 #include "DNA_scene_types.h"
33 #include "DNA_meta_types.h"
34 #include "DNA_workspace_types.h"
35 #include "DNA_gpencil_modifier_types.h"
36 #include "DNA_shader_fx_types.h"
37
38 #include "BLI_utildefines.h"
39
40 #include "BLT_translation.h"
41
42 #include "BKE_camera.h"
43 #include "BKE_collection.h"
44 #include "BKE_paint.h"
45 #include "BKE_editlattice.h"
46 #include "BKE_editmesh.h"
47 #include "BKE_layer.h"
48 #include "BKE_object_deform.h"
49 #include "BKE_object_facemap.h"
50
51 #include "RNA_access.h"
52 #include "RNA_define.h"
53 #include "RNA_enum_types.h"
54
55 #include "rna_internal.h"
56
57 #include "BLI_sys_types.h" /* needed for intptr_t used in ED_mesh.h */
58 #include "ED_mesh.h"
59
60 #include "WM_api.h"
61 #include "WM_types.h"
62
63 const EnumPropertyItem rna_enum_object_mode_items[] = {
64     {OB_MODE_OBJECT, "OBJECT", ICON_OBJECT_DATAMODE, "Object Mode", ""},
65     {OB_MODE_EDIT, "EDIT", ICON_EDITMODE_HLT, "Edit Mode", ""},
66     {OB_MODE_POSE, "POSE", ICON_POSE_HLT, "Pose Mode", ""},
67     {OB_MODE_SCULPT, "SCULPT", ICON_SCULPTMODE_HLT, "Sculpt Mode", ""},
68     {OB_MODE_VERTEX_PAINT, "VERTEX_PAINT", ICON_VPAINT_HLT, "Vertex Paint", ""},
69     {OB_MODE_WEIGHT_PAINT, "WEIGHT_PAINT", ICON_WPAINT_HLT, "Weight Paint", ""},
70     {OB_MODE_TEXTURE_PAINT, "TEXTURE_PAINT", ICON_TPAINT_HLT, "Texture Paint", ""},
71     {OB_MODE_PARTICLE_EDIT, "PARTICLE_EDIT", ICON_PARTICLEMODE, "Particle Edit", ""},
72     {OB_MODE_EDIT_GPENCIL,
73      "EDIT_GPENCIL",
74      ICON_EDITMODE_HLT,
75      "Edit Mode",
76      "Edit Grease Pencil Strokes"},
77     {OB_MODE_SCULPT_GPENCIL,
78      "SCULPT_GPENCIL",
79      ICON_SCULPTMODE_HLT,
80      "Sculpt Mode",
81      "Sculpt Grease Pencil Strokes"},
82     {OB_MODE_PAINT_GPENCIL,
83      "PAINT_GPENCIL",
84      ICON_GREASEPENCIL,
85      "Draw",
86      "Paint Grease Pencil Strokes"},
87     {OB_MODE_WEIGHT_GPENCIL,
88      "WEIGHT_GPENCIL",
89      ICON_WPAINT_HLT,
90      "Weight Paint",
91      "Grease Pencil Weight Paint Strokes"},
92     {0, NULL, 0, NULL, NULL},
93 };
94
95 /* Same as above, but with names that distinguish grease pencil. */
96 const EnumPropertyItem rna_enum_workspace_object_mode_items[] = {
97     {OB_MODE_OBJECT, "OBJECT", ICON_OBJECT_DATAMODE, "Object Mode", ""},
98     {OB_MODE_EDIT, "EDIT", ICON_EDITMODE_HLT, "Edit Mode", ""},
99     {OB_MODE_POSE, "POSE", ICON_POSE_HLT, "Pose Mode", ""},
100     {OB_MODE_SCULPT, "SCULPT", ICON_SCULPTMODE_HLT, "Sculpt Mode", ""},
101     {OB_MODE_VERTEX_PAINT, "VERTEX_PAINT", ICON_VPAINT_HLT, "Vertex Paint", ""},
102     {OB_MODE_WEIGHT_PAINT, "WEIGHT_PAINT", ICON_WPAINT_HLT, "Weight Paint", ""},
103     {OB_MODE_TEXTURE_PAINT, "TEXTURE_PAINT", ICON_TPAINT_HLT, "Texture Paint", ""},
104     {OB_MODE_PARTICLE_EDIT, "PARTICLE_EDIT", ICON_PARTICLEMODE, "Particle Edit", ""},
105     {OB_MODE_EDIT_GPENCIL,
106      "EDIT_GPENCIL",
107      ICON_EDITMODE_HLT,
108      "Grease Pencil Edit Mode",
109      "Edit Grease Pencil Strokes"},
110     {OB_MODE_SCULPT_GPENCIL,
111      "SCULPT_GPENCIL",
112      ICON_SCULPTMODE_HLT,
113      "Grease Pencil Sculpt Mode",
114      "Sculpt Grease Pencil Strokes"},
115     {OB_MODE_PAINT_GPENCIL,
116      "PAINT_GPENCIL",
117      ICON_GREASEPENCIL,
118      "Grease Pencil Draw",
119      "Paint Grease Pencil Strokes"},
120     {OB_MODE_WEIGHT_GPENCIL,
121      "WEIGHT_GPENCIL",
122      ICON_WPAINT_HLT,
123      "Grease Pencil Weight Paint",
124      "Grease Pencil Weight Paint Strokes"},
125     {0, NULL, 0, NULL, NULL},
126 };
127
128 const EnumPropertyItem rna_enum_object_empty_drawtype_items[] = {
129     {OB_PLAINAXES, "PLAIN_AXES", ICON_EMPTY_AXIS, "Plain Axes", ""},
130     {OB_ARROWS, "ARROWS", ICON_EMPTY_ARROWS, "Arrows", ""},
131     {OB_SINGLE_ARROW, "SINGLE_ARROW", ICON_EMPTY_SINGLE_ARROW, "Single Arrow", ""},
132     {OB_CIRCLE, "CIRCLE", ICON_MESH_CIRCLE, "Circle", ""},
133     {OB_CUBE, "CUBE", ICON_CUBE, "Cube", ""},
134     {OB_EMPTY_SPHERE, "SPHERE", ICON_SPHERE, "Sphere", ""},
135     {OB_EMPTY_CONE, "CONE", ICON_CONE, "Cone", ""},
136     {OB_EMPTY_IMAGE, "IMAGE", ICON_FILE_IMAGE, "Image", ""},
137     {0, NULL, 0, NULL, NULL},
138 };
139
140 static const EnumPropertyItem rna_enum_object_empty_image_depth_items[] = {
141     {OB_EMPTY_IMAGE_DEPTH_DEFAULT, "DEFAULT", 0, "Default", ""},
142     {OB_EMPTY_IMAGE_DEPTH_FRONT, "FRONT", 0, "Front", ""},
143     {OB_EMPTY_IMAGE_DEPTH_BACK, "BACK", 0, "Back", ""},
144     {0, NULL, 0, NULL, NULL},
145 };
146
147 const EnumPropertyItem rna_enum_object_gpencil_type_items[] = {
148     {GP_EMPTY, "EMPTY", ICON_EMPTY_AXIS, "Blank", "Create an empty grease pencil object"},
149     {GP_STROKE, "STROKE", ICON_STROKE, "Stroke", "Create a simple stroke with basic colors"},
150     {GP_MONKEY, "MONKEY", ICON_MONKEY, "Monkey", "Construct a Suzanne grease pencil object"},
151     {0, NULL, 0, NULL, NULL}};
152
153 static const EnumPropertyItem parent_type_items[] = {
154     {PAROBJECT, "OBJECT", 0, "Object", "The object is parented to an object"},
155     {PARSKEL, "ARMATURE", 0, "Armature", ""},
156     /* PARSKEL reuse will give issues. */
157     {PARSKEL, "LATTICE", 0, "Lattice", "The object is parented to a lattice"},
158     {PARVERT1, "VERTEX", 0, "Vertex", "The object is parented to a vertex"},
159     {PARVERT3, "VERTEX_3", 0, "3 Vertices", ""},
160     {PARBONE, "BONE", 0, "Bone", "The object is parented to a bone"},
161     {0, NULL, 0, NULL, NULL},
162 };
163
164 #define INSTANCE_ITEMS_SHARED \
165   {0, "NONE", 0, "None", ""}, \
166       {OB_DUPLIVERTS, "VERTS", 0, "Verts", "Instantiate child objects on all vertices"}, \
167   { \
168     OB_DUPLIFACES, "FACES", 0, "Faces", "Instantiate child objects on all faces" \
169   }
170
171 #define INSTANCE_ITEM_COLLECTION \
172   { \
173     OB_DUPLICOLLECTION, "COLLECTION", 0, "Collection", "Enable collection instancing" \
174   }
175 static const EnumPropertyItem instance_items[] = {
176     INSTANCE_ITEMS_SHARED,
177     INSTANCE_ITEM_COLLECTION,
178     {0, NULL, 0, NULL, NULL},
179 };
180 #ifdef RNA_RUNTIME
181 static EnumPropertyItem instance_items_nogroup[] = {
182     INSTANCE_ITEMS_SHARED,
183     {0, NULL, 0, NULL, NULL},
184 };
185 #endif
186 #undef INSTANCE_ITEMS_SHARED
187 #undef INSTANCE_ITEM_COLLECTION
188
189 const EnumPropertyItem rna_enum_metaelem_type_items[] = {
190     {MB_BALL, "BALL", ICON_META_BALL, "Ball", ""},
191     {MB_TUBE, "CAPSULE", ICON_META_CAPSULE, "Capsule", ""},
192     {MB_PLANE, "PLANE", ICON_META_PLANE, "Plane", ""},
193     /* NOTE: typo at original definition! */
194     {MB_ELIPSOID, "ELLIPSOID", ICON_META_ELLIPSOID, "Ellipsoid", ""},
195     {MB_CUBE, "CUBE", ICON_META_CUBE, "Cube", ""},
196     {0, NULL, 0, NULL, NULL},
197 };
198
199 /* used for 2 enums */
200 #define OBTYPE_CU_CURVE \
201   { \
202     OB_CURVE, "CURVE", 0, "Curve", "" \
203   }
204 #define OBTYPE_CU_SURF \
205   { \
206     OB_SURF, "SURFACE", 0, "Surface", "" \
207   }
208 #define OBTYPE_CU_FONT \
209   { \
210     OB_FONT, "FONT", 0, "Font", "" \
211   }
212
213 const EnumPropertyItem rna_enum_object_type_items[] = {
214     {OB_MESH, "MESH", 0, "Mesh", ""},
215     OBTYPE_CU_CURVE,
216     OBTYPE_CU_SURF,
217     {OB_MBALL, "META", 0, "Meta", ""},
218     OBTYPE_CU_FONT,
219     {0, "", 0, NULL, NULL},
220     {OB_ARMATURE, "ARMATURE", 0, "Armature", ""},
221     {OB_LATTICE, "LATTICE", 0, "Lattice", ""},
222     {OB_EMPTY, "EMPTY", 0, "Empty", ""},
223     {OB_GPENCIL, "GPENCIL", 0, "GPencil", ""},
224     {0, "", 0, NULL, NULL},
225     {OB_CAMERA, "CAMERA", 0, "Camera", ""},
226     {OB_LAMP, "LIGHT", 0, "Light", ""},
227     {OB_SPEAKER, "SPEAKER", 0, "Speaker", ""},
228     {OB_LIGHTPROBE, "LIGHT_PROBE", 0, "Probe", ""},
229     {0, NULL, 0, NULL, NULL},
230 };
231
232 const EnumPropertyItem rna_enum_object_type_curve_items[] = {
233     OBTYPE_CU_CURVE,
234     OBTYPE_CU_SURF,
235     OBTYPE_CU_FONT,
236     {0, NULL, 0, NULL, NULL},
237 };
238
239 const EnumPropertyItem rna_enum_object_rotation_mode_items[] = {
240     {ROT_MODE_QUAT, "QUATERNION", 0, "Quaternion (WXYZ)", "No Gimbal Lock"},
241     {ROT_MODE_XYZ, "XYZ", 0, "XYZ Euler", "XYZ Rotation Order - prone to Gimbal Lock (default)"},
242     {ROT_MODE_XZY, "XZY", 0, "XZY Euler", "XZY Rotation Order - prone to Gimbal Lock"},
243     {ROT_MODE_YXZ, "YXZ", 0, "YXZ Euler", "YXZ Rotation Order - prone to Gimbal Lock"},
244     {ROT_MODE_YZX, "YZX", 0, "YZX Euler", "YZX Rotation Order - prone to Gimbal Lock"},
245     {ROT_MODE_ZXY, "ZXY", 0, "ZXY Euler", "ZXY Rotation Order - prone to Gimbal Lock"},
246     {ROT_MODE_ZYX, "ZYX", 0, "ZYX Euler", "ZYX Rotation Order - prone to Gimbal Lock"},
247     {ROT_MODE_AXISANGLE,
248      "AXIS_ANGLE",
249      0,
250      "Axis Angle",
251      "Axis Angle (W+XYZ), defines a rotation around some axis defined by 3D-Vector"},
252     {0, NULL, 0, NULL, NULL},
253 };
254
255 const EnumPropertyItem rna_enum_object_axis_items[] = {
256     {OB_POSX, "POS_X", 0, "+X", ""},
257     {OB_POSY, "POS_Y", 0, "+Y", ""},
258     {OB_POSZ, "POS_Z", 0, "+Z", ""},
259     {OB_NEGX, "NEG_X", 0, "-X", ""},
260     {OB_NEGY, "NEG_Y", 0, "-Y", ""},
261     {OB_NEGZ, "NEG_Z", 0, "-Z", ""},
262     {0, NULL, 0, NULL, NULL},
263 };
264
265 #ifdef RNA_RUNTIME
266
267 #  include "BLI_math.h"
268
269 #  include "DNA_key_types.h"
270 #  include "DNA_constraint_types.h"
271 #  include "DNA_gpencil_types.h"
272 #  include "DNA_ID.h"
273 #  include "DNA_lattice_types.h"
274 #  include "DNA_node_types.h"
275
276 #  include "BKE_armature.h"
277 #  include "BKE_brush.h"
278 #  include "BKE_constraint.h"
279 #  include "BKE_context.h"
280 #  include "BKE_curve.h"
281 #  include "BKE_effect.h"
282 #  include "BKE_global.h"
283 #  include "BKE_key.h"
284 #  include "BKE_object.h"
285 #  include "BKE_material.h"
286 #  include "BKE_mesh.h"
287 #  include "BKE_modifier.h"
288 #  include "BKE_particle.h"
289 #  include "BKE_scene.h"
290 #  include "BKE_deform.h"
291
292 #  include "DEG_depsgraph.h"
293 #  include "DEG_depsgraph_build.h"
294
295 #  include "ED_object.h"
296 #  include "ED_particle.h"
297 #  include "ED_curve.h"
298 #  include "ED_lattice.h"
299
300 static void rna_Object_internal_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
301 {
302   DEG_id_tag_update(ptr->id.data, ID_RECALC_TRANSFORM);
303 }
304
305 static void rna_Object_internal_update_draw(Main *UNUSED(bmain),
306                                             Scene *UNUSED(scene),
307                                             PointerRNA *ptr)
308 {
309   DEG_id_tag_update(ptr->id.data, ID_RECALC_TRANSFORM);
310   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ptr->id.data);
311 }
312
313 static void rna_Object_matrix_world_update(Main *bmain, Scene *scene, PointerRNA *ptr)
314 {
315   /* don't use compat so we get predictable rotation */
316   BKE_object_apply_mat4(ptr->id.data, ((Object *)ptr->id.data)->obmat, false, true);
317   rna_Object_internal_update(bmain, scene, ptr);
318 }
319
320 static void rna_Object_hide_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
321 {
322   Object *ob = ptr->id.data;
323   BKE_main_collection_sync_remap(bmain);
324   DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
325   DEG_relations_tag_update(bmain);
326   WM_main_add_notifier(NC_OBJECT | ND_DRAW, &ob->id);
327 }
328
329 static void rna_MaterialIndex_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
330 {
331   Object *ob = (Object *)ptr->id.data;
332   if (ob && ob->type == OB_GPENCIL) {
333     /* notifying material property in topbar */
334     WM_main_add_notifier(NC_SPACE | ND_SPACE_VIEW3D, NULL);
335   }
336 }
337
338 static void rna_Object_matrix_local_get(PointerRNA *ptr, float values[16])
339 {
340   Object *ob = ptr->id.data;
341   BKE_object_matrix_local_get(ob, (float(*)[4])values);
342 }
343
344 static void rna_Object_matrix_local_set(PointerRNA *ptr, const float values[16])
345 {
346   Object *ob = ptr->id.data;
347   float local_mat[4][4];
348
349   /* Localspace matrix is truly relative to the parent,
350    * but parameters stored in object are relative to parentinv matrix.
351    * Undo the parent inverse part before applying it as local matrix. */
352   if (ob->parent) {
353     float invmat[4][4];
354     invert_m4_m4(invmat, ob->parentinv);
355     mul_m4_m4m4(local_mat, invmat, (float(*)[4])values);
356   }
357   else {
358     copy_m4_m4(local_mat, (float(*)[4])values);
359   }
360
361   /* Don't use compat so we get predictable rotation, and do not use parenting either,
362    * because it's a local matrix! */
363   BKE_object_apply_mat4(ob, local_mat, false, false);
364 }
365
366 static void rna_Object_matrix_basis_get(PointerRNA *ptr, float values[16])
367 {
368   Object *ob = ptr->id.data;
369   BKE_object_to_mat4(ob, (float(*)[4])values);
370 }
371
372 static void rna_Object_matrix_basis_set(PointerRNA *ptr, const float values[16])
373 {
374   Object *ob = ptr->id.data;
375   BKE_object_apply_mat4(ob, (float(*)[4])values, false, false);
376 }
377
378 void rna_Object_internal_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
379 {
380   DEG_id_tag_update(ptr->id.data, ID_RECALC_GEOMETRY);
381   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ptr->id.data);
382 }
383
384 void rna_Object_internal_update_data_dependency(Main *bmain, Scene *scene, PointerRNA *ptr)
385 {
386   DEG_relations_tag_update(bmain);
387   rna_Object_internal_update_data(bmain, scene, ptr);
388 }
389
390 static void rna_Object_active_shape_update(bContext *C, PointerRNA *ptr)
391 {
392   Object *ob = ptr->id.data;
393   Main *bmain = CTX_data_main(C);
394   Scene *scene = CTX_data_scene(C);
395
396   if (CTX_data_edit_object(C) == ob) {
397     /* exit/enter editmode to get new shape */
398     switch (ob->type) {
399       case OB_MESH:
400         EDBM_mesh_load(bmain, ob);
401         EDBM_mesh_make(ob, scene->toolsettings->selectmode, true);
402
403         DEG_id_tag_update(ob->data, 0);
404
405         EDBM_mesh_normals_update(((Mesh *)ob->data)->edit_mesh);
406         BKE_editmesh_tessface_calc(((Mesh *)ob->data)->edit_mesh);
407         break;
408       case OB_CURVE:
409       case OB_SURF:
410         ED_curve_editnurb_load(bmain, ob);
411         ED_curve_editnurb_make(ob);
412         break;
413       case OB_LATTICE:
414         BKE_editlattice_load(ob);
415         BKE_editlattice_make(ob);
416         break;
417     }
418   }
419
420   rna_Object_internal_update_data(bmain, scene, ptr);
421 }
422
423 static void rna_Object_dependency_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
424 {
425   DEG_id_tag_update(ptr->id.data, ID_RECALC_TRANSFORM);
426   DEG_relations_tag_update(bmain);
427   WM_main_add_notifier(NC_OBJECT | ND_PARENT, ptr->id.data);
428 }
429
430 static void rna_Object_data_set(PointerRNA *ptr, PointerRNA value, struct ReportList *reports)
431 {
432   Object *ob = (Object *)ptr->data;
433   ID *id = value.data;
434
435   if (ob->mode & OB_MODE_EDIT) {
436     return;
437   }
438
439   /* assigning NULL only for empties */
440   if ((id == NULL) && (ob->type != OB_EMPTY)) {
441     return;
442   }
443
444   if ((id->tag & LIB_TAG_NO_MAIN) != (ob->id.tag & LIB_TAG_NO_MAIN)) {
445     BKE_report(reports,
446                RPT_ERROR,
447                "Can only assign evaluated data to to evaluated object, or original data to "
448                "original object");
449     return;
450   }
451
452   if (ob->type == OB_EMPTY) {
453     if (ob->data) {
454       id_us_min((ID *)ob->data);
455       ob->data = NULL;
456     }
457
458     if (!id || GS(id->name) == ID_IM) {
459       id_us_plus(id);
460       ob->data = id;
461     }
462   }
463   else if (ob->type == OB_MESH) {
464     BKE_mesh_assign_object(G_MAIN, ob, (Mesh *)id);
465   }
466   else {
467     if (ob->data) {
468       id_us_min((ID *)ob->data);
469     }
470
471     /* no need to type-check here ID. this is done in the _typef() function */
472     BLI_assert(OB_DATA_SUPPORT_ID(GS(id->name)));
473     id_us_plus(id);
474
475     ob->data = id;
476     test_object_materials(G_MAIN, ob, id);
477
478     if (GS(id->name) == ID_CU) {
479       BKE_curve_type_test(ob);
480     }
481     else if (ob->type == OB_ARMATURE) {
482       BKE_pose_rebuild(G_MAIN, ob, ob->data, true);
483     }
484   }
485 }
486
487 static StructRNA *rna_Object_data_typef(PointerRNA *ptr)
488 {
489   Object *ob = (Object *)ptr->data;
490
491   /* keep in sync with OB_DATA_SUPPORT_ID() macro */
492   switch (ob->type) {
493     case OB_EMPTY:
494       return &RNA_Image;
495     case OB_MESH:
496       return &RNA_Mesh;
497     case OB_CURVE:
498       return &RNA_Curve;
499     case OB_SURF:
500       return &RNA_Curve;
501     case OB_FONT:
502       return &RNA_Curve;
503     case OB_MBALL:
504       return &RNA_MetaBall;
505     case OB_LAMP:
506       return &RNA_Light;
507     case OB_CAMERA:
508       return &RNA_Camera;
509     case OB_LATTICE:
510       return &RNA_Lattice;
511     case OB_ARMATURE:
512       return &RNA_Armature;
513     case OB_SPEAKER:
514       return &RNA_Speaker;
515     case OB_LIGHTPROBE:
516       return &RNA_LightProbe;
517     case OB_GPENCIL:
518       return &RNA_GreasePencil;
519     default:
520       return &RNA_ID;
521   }
522 }
523
524 static bool rna_Object_data_poll(PointerRNA *ptr, const PointerRNA value)
525 {
526   Object *ob = (Object *)ptr->data;
527
528   if (ob->type == OB_GPENCIL) {
529     /* GP Object - Don't allow using "Annotation" GP datablocks here */
530     bGPdata *gpd = value.data;
531     return (gpd->flag & GP_DATA_ANNOTATIONS) == 0;
532   }
533
534   return true;
535 }
536
537 static void rna_Object_parent_set(PointerRNA *ptr,
538                                   PointerRNA value,
539                                   struct ReportList *UNUSED(reports))
540 {
541   Object *ob = (Object *)ptr->data;
542   Object *par = (Object *)value.data;
543
544   {
545     ED_object_parent(ob, par, ob->partype, ob->parsubstr);
546   }
547 }
548
549 static void rna_Object_parent_type_set(PointerRNA *ptr, int value)
550 {
551   Object *ob = (Object *)ptr->data;
552
553   ED_object_parent(ob, ob->parent, value, ob->parsubstr);
554 }
555
556 static const EnumPropertyItem *rna_Object_parent_type_itemf(bContext *UNUSED(C),
557                                                             PointerRNA *ptr,
558                                                             PropertyRNA *UNUSED(prop),
559                                                             bool *r_free)
560 {
561   Object *ob = (Object *)ptr->data;
562   EnumPropertyItem *item = NULL;
563   int totitem = 0;
564
565   RNA_enum_items_add_value(&item, &totitem, parent_type_items, PAROBJECT);
566
567   if (ob->parent) {
568     Object *par = ob->parent;
569
570     if (par->type == OB_LATTICE) {
571       /* special hack: prevents this overriding others */
572       RNA_enum_items_add_value(&item, &totitem, &parent_type_items[2], PARSKEL);
573     }
574     else if (par->type == OB_ARMATURE) {
575       /* special hack: prevents this being overridden */
576       RNA_enum_items_add_value(&item, &totitem, &parent_type_items[1], PARSKEL);
577       RNA_enum_items_add_value(&item, &totitem, parent_type_items, PARBONE);
578     }
579
580     if (OB_TYPE_SUPPORT_PARVERT(par->type)) {
581       RNA_enum_items_add_value(&item, &totitem, parent_type_items, PARVERT1);
582       RNA_enum_items_add_value(&item, &totitem, parent_type_items, PARVERT3);
583     }
584   }
585
586   RNA_enum_item_end(&item, &totitem);
587   *r_free = true;
588
589   return item;
590 }
591
592 static void rna_Object_empty_display_type_set(PointerRNA *ptr, int value)
593 {
594   Object *ob = (Object *)ptr->data;
595
596   BKE_object_empty_draw_type_set(ob, value);
597 }
598
599 static void rna_Object_parent_bone_set(PointerRNA *ptr, const char *value)
600 {
601   Object *ob = (Object *)ptr->data;
602
603   ED_object_parent(ob, ob->parent, ob->partype, value);
604 }
605
606 static const EnumPropertyItem *rna_Object_instance_type_itemf(bContext *UNUSED(C),
607                                                               PointerRNA *ptr,
608                                                               PropertyRNA *UNUSED(prop),
609                                                               bool *UNUSED(r_free))
610 {
611   Object *ob = (Object *)ptr->data;
612   const EnumPropertyItem *item;
613
614   if (ob->type == OB_EMPTY) {
615     item = instance_items;
616   }
617   else {
618     item = instance_items_nogroup;
619   }
620
621   return item;
622 }
623
624 static void rna_Object_dup_collection_set(PointerRNA *ptr,
625                                           PointerRNA value,
626                                           struct ReportList *UNUSED(reports))
627 {
628   Object *ob = (Object *)ptr->data;
629   Collection *grp = (Collection *)value.data;
630
631   /* must not let this be set if the object belongs in this group already,
632    * thus causing a cycle/infinite-recursion leading to crashes on load [#25298]
633    */
634   if (BKE_collection_has_object_recursive(grp, ob) == 0) {
635     if (ob->type == OB_EMPTY) {
636       id_us_min(&ob->instance_collection->id);
637       ob->instance_collection = grp;
638       id_us_plus(&ob->instance_collection->id);
639     }
640     else {
641       BKE_report(NULL, RPT_ERROR, "Only empty objects support group instances");
642     }
643   }
644   else {
645     BKE_report(NULL,
646                RPT_ERROR,
647                "Cannot set instance-collection as object belongs in group being instanced, thus "
648                "causing a cycle");
649   }
650 }
651
652 static void rna_VertexGroup_name_set(PointerRNA *ptr, const char *value)
653 {
654   Object *ob = (Object *)ptr->id.data;
655   bDeformGroup *dg = (bDeformGroup *)ptr->data;
656   BLI_strncpy_utf8(dg->name, value, sizeof(dg->name));
657   defgroup_unique_name(dg, ob);
658 }
659
660 static int rna_VertexGroup_index_get(PointerRNA *ptr)
661 {
662   Object *ob = (Object *)ptr->id.data;
663
664   return BLI_findindex(&ob->defbase, ptr->data);
665 }
666
667 static PointerRNA rna_Object_active_vertex_group_get(PointerRNA *ptr)
668 {
669   Object *ob = (Object *)ptr->id.data;
670   return rna_pointer_inherit_refine(
671       ptr, &RNA_VertexGroup, BLI_findlink(&ob->defbase, ob->actdef - 1));
672 }
673
674 static int rna_Object_active_vertex_group_index_get(PointerRNA *ptr)
675 {
676   Object *ob = (Object *)ptr->id.data;
677   return ob->actdef - 1;
678 }
679
680 static void rna_Object_active_vertex_group_index_set(PointerRNA *ptr, int value)
681 {
682   Object *ob = (Object *)ptr->id.data;
683   ob->actdef = value + 1;
684 }
685
686 static void rna_Object_active_vertex_group_index_range(
687     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
688 {
689   Object *ob = (Object *)ptr->id.data;
690
691   *min = 0;
692   *max = max_ii(0, BLI_listbase_count(&ob->defbase) - 1);
693 }
694
695 void rna_object_vgroup_name_index_get(PointerRNA *ptr, char *value, int index)
696 {
697   Object *ob = (Object *)ptr->id.data;
698   bDeformGroup *dg;
699
700   dg = BLI_findlink(&ob->defbase, index - 1);
701
702   if (dg)
703     BLI_strncpy(value, dg->name, sizeof(dg->name));
704   else
705     value[0] = '\0';
706 }
707
708 int rna_object_vgroup_name_index_length(PointerRNA *ptr, int index)
709 {
710   Object *ob = (Object *)ptr->id.data;
711   bDeformGroup *dg;
712
713   dg = BLI_findlink(&ob->defbase, index - 1);
714   return (dg) ? strlen(dg->name) : 0;
715 }
716
717 void rna_object_vgroup_name_index_set(PointerRNA *ptr, const char *value, short *index)
718 {
719   Object *ob = (Object *)ptr->id.data;
720   *index = defgroup_name_index(ob, value) + 1;
721 }
722
723 void rna_object_vgroup_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
724 {
725   Object *ob = (Object *)ptr->id.data;
726   bDeformGroup *dg = defgroup_find_name(ob, value);
727   if (dg) {
728     /* No need for BLI_strncpy_utf8, since this matches an existing group. */
729     BLI_strncpy(result, value, maxlen);
730     return;
731   }
732
733   result[0] = '\0';
734 }
735
736 static void rna_FaceMap_name_set(PointerRNA *ptr, const char *value)
737 {
738   Object *ob = (Object *)ptr->id.data;
739   bFaceMap *fmap = (bFaceMap *)ptr->data;
740   BLI_strncpy_utf8(fmap->name, value, sizeof(fmap->name));
741   BKE_object_facemap_unique_name(ob, fmap);
742 }
743
744 static int rna_FaceMap_index_get(PointerRNA *ptr)
745 {
746   Object *ob = (Object *)ptr->id.data;
747
748   return BLI_findindex(&ob->fmaps, ptr->data);
749 }
750
751 static PointerRNA rna_Object_active_face_map_get(PointerRNA *ptr)
752 {
753   Object *ob = (Object *)ptr->id.data;
754   return rna_pointer_inherit_refine(ptr, &RNA_FaceMap, BLI_findlink(&ob->fmaps, ob->actfmap - 1));
755 }
756
757 static int rna_Object_active_face_map_index_get(PointerRNA *ptr)
758 {
759   Object *ob = (Object *)ptr->id.data;
760   return ob->actfmap - 1;
761 }
762
763 static void rna_Object_active_face_map_index_set(PointerRNA *ptr, int value)
764 {
765   Object *ob = (Object *)ptr->id.data;
766   ob->actfmap = value + 1;
767 }
768
769 static void rna_Object_active_face_map_index_range(
770     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
771 {
772   Object *ob = (Object *)ptr->id.data;
773
774   *min = 0;
775   *max = max_ii(0, BLI_listbase_count(&ob->fmaps) - 1);
776 }
777
778 void rna_object_BKE_object_facemap_name_index_get(PointerRNA *ptr, char *value, int index)
779 {
780   Object *ob = (Object *)ptr->id.data;
781   bFaceMap *fmap;
782
783   fmap = BLI_findlink(&ob->fmaps, index - 1);
784
785   if (fmap)
786     BLI_strncpy(value, fmap->name, sizeof(fmap->name));
787   else
788     value[0] = '\0';
789 }
790
791 int rna_object_BKE_object_facemap_name_index_length(PointerRNA *ptr, int index)
792 {
793   Object *ob = (Object *)ptr->id.data;
794   bFaceMap *fmap;
795
796   fmap = BLI_findlink(&ob->fmaps, index - 1);
797   return (fmap) ? strlen(fmap->name) : 0;
798 }
799
800 void rna_object_BKE_object_facemap_name_index_set(PointerRNA *ptr, const char *value, short *index)
801 {
802   Object *ob = (Object *)ptr->id.data;
803   *index = BKE_object_facemap_name_index(ob, value) + 1;
804 }
805
806 void rna_object_fmap_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
807 {
808   Object *ob = (Object *)ptr->id.data;
809   bFaceMap *fmap = BKE_object_facemap_find_name(ob, value);
810   if (fmap) {
811     /* No need for BLI_strncpy_utf8, since this matches an existing group. */
812     BLI_strncpy(result, value, maxlen);
813     return;
814   }
815
816   result[0] = '\0';
817 }
818
819 void rna_object_uvlayer_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
820 {
821   Object *ob = (Object *)ptr->id.data;
822   Mesh *me;
823   CustomDataLayer *layer;
824   int a;
825
826   if (ob->type == OB_MESH && ob->data) {
827     me = (Mesh *)ob->data;
828
829     for (a = 0; a < me->ldata.totlayer; a++) {
830       layer = &me->ldata.layers[a];
831
832       if (layer->type == CD_MLOOPUV && STREQ(layer->name, value)) {
833         BLI_strncpy(result, value, maxlen);
834         return;
835       }
836     }
837   }
838
839   result[0] = '\0';
840 }
841
842 void rna_object_vcollayer_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
843 {
844   Object *ob = (Object *)ptr->id.data;
845   Mesh *me;
846   CustomDataLayer *layer;
847   int a;
848
849   if (ob->type == OB_MESH && ob->data) {
850     me = (Mesh *)ob->data;
851
852     for (a = 0; a < me->fdata.totlayer; a++) {
853       layer = &me->fdata.layers[a];
854
855       if (layer->type == CD_MCOL && STREQ(layer->name, value)) {
856         BLI_strncpy(result, value, maxlen);
857         return;
858       }
859     }
860   }
861
862   result[0] = '\0';
863 }
864
865 static int rna_Object_active_material_index_get(PointerRNA *ptr)
866 {
867   Object *ob = (Object *)ptr->id.data;
868   return MAX2(ob->actcol - 1, 0);
869 }
870
871 static void rna_Object_active_material_index_set(PointerRNA *ptr, int value)
872 {
873   Object *ob = (Object *)ptr->id.data;
874   ob->actcol = value + 1;
875
876   if (ob->type == OB_MESH) {
877     Mesh *me = ob->data;
878
879     if (me->edit_mesh)
880       me->edit_mesh->mat_nr = value;
881   }
882 }
883
884 static void rna_Object_active_material_index_range(
885     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
886 {
887   Object *ob = (Object *)ptr->id.data;
888   *min = 0;
889   *max = max_ii(ob->totcol - 1, 0);
890 }
891
892 /* returns active base material */
893 static PointerRNA rna_Object_active_material_get(PointerRNA *ptr)
894 {
895   Object *ob = (Object *)ptr->id.data;
896   Material *ma;
897
898   ma = (ob->totcol) ? give_current_material(ob, ob->actcol) : NULL;
899   return rna_pointer_inherit_refine(ptr, &RNA_Material, ma);
900 }
901
902 static void rna_Object_active_material_set(PointerRNA *ptr,
903                                            PointerRNA value,
904                                            struct ReportList *UNUSED(reports))
905 {
906   Object *ob = (Object *)ptr->id.data;
907
908   DEG_id_tag_update(value.data, 0);
909   BLI_assert(BKE_id_is_in_global_main(&ob->id));
910   BLI_assert(BKE_id_is_in_global_main(value.data));
911   assign_material(G_MAIN, ob, value.data, ob->actcol, BKE_MAT_ASSIGN_EXISTING);
912
913   if (ob && ob->type == OB_GPENCIL) {
914     /* notifying material property in topbar */
915     WM_main_add_notifier(NC_SPACE | ND_SPACE_VIEW3D, NULL);
916   }
917 }
918
919 static int rna_Object_active_material_editable(PointerRNA *ptr, const char **UNUSED(r_info))
920 {
921   Object *ob = (Object *)ptr->id.data;
922   bool is_editable;
923
924   if ((ob->matbits == NULL) || (ob->actcol == 0) || ob->matbits[ob->actcol - 1]) {
925     is_editable = !ID_IS_LINKED(ob);
926   }
927   else {
928     is_editable = ob->data ? !ID_IS_LINKED(ob->data) : false;
929   }
930
931   return is_editable ? PROP_EDITABLE : 0;
932 }
933
934 static void rna_Object_active_particle_system_index_range(
935     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
936 {
937   Object *ob = (Object *)ptr->id.data;
938   *min = 0;
939   *max = max_ii(0, BLI_listbase_count(&ob->particlesystem) - 1);
940 }
941
942 static int rna_Object_active_particle_system_index_get(PointerRNA *ptr)
943 {
944   Object *ob = (Object *)ptr->id.data;
945   return psys_get_current_num(ob);
946 }
947
948 static void rna_Object_active_particle_system_index_set(PointerRNA *ptr, int value)
949 {
950   Object *ob = (Object *)ptr->id.data;
951   psys_set_current_num(ob, value);
952 }
953
954 static void rna_Object_particle_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
955 {
956   /* TODO: Disabled for now, because bContext is not available. */
957 #  if 0
958   Object *ob = (Object *)ptr->id.data;
959   PE_current_changed(NULL, scene, ob);
960 #  else
961   (void)scene;
962   (void)ptr;
963 #  endif
964 }
965
966 /* rotation - axis-angle */
967 static void rna_Object_rotation_axis_angle_get(PointerRNA *ptr, float *value)
968 {
969   Object *ob = ptr->data;
970
971   /* for now, assume that rotation mode is axis-angle */
972   value[0] = ob->rotAngle;
973   copy_v3_v3(&value[1], ob->rotAxis);
974 }
975
976 /* rotation - axis-angle */
977 static void rna_Object_rotation_axis_angle_set(PointerRNA *ptr, const float *value)
978 {
979   Object *ob = ptr->data;
980
981   /* for now, assume that rotation mode is axis-angle */
982   ob->rotAngle = value[0];
983   copy_v3_v3(ob->rotAxis, &value[1]);
984
985   /* TODO: validate axis? */
986 }
987
988 static void rna_Object_rotation_mode_set(PointerRNA *ptr, int value)
989 {
990   Object *ob = ptr->data;
991
992   /* use API Method for conversions... */
993   BKE_rotMode_change_values(
994       ob->quat, ob->rot, ob->rotAxis, &ob->rotAngle, ob->rotmode, (short)value);
995
996   /* finally, set the new rotation type */
997   ob->rotmode = value;
998 }
999
1000 static void rna_Object_dimensions_get(PointerRNA *ptr, float *value)
1001 {
1002   Object *ob = ptr->data;
1003   BKE_object_dimensions_get(ob, value);
1004 }
1005
1006 static void rna_Object_dimensions_set(PointerRNA *ptr, const float *value)
1007 {
1008   Object *ob = ptr->data;
1009   BKE_object_dimensions_set(ob, value, 0);
1010 }
1011
1012 static int rna_Object_location_editable(PointerRNA *ptr, int index)
1013 {
1014   Object *ob = (Object *)ptr->data;
1015
1016   /* only if the axis in question is locked, not editable... */
1017   if ((index == 0) && (ob->protectflag & OB_LOCK_LOCX))
1018     return 0;
1019   else if ((index == 1) && (ob->protectflag & OB_LOCK_LOCY))
1020     return 0;
1021   else if ((index == 2) && (ob->protectflag & OB_LOCK_LOCZ))
1022     return 0;
1023   else
1024     return PROP_EDITABLE;
1025 }
1026
1027 static int rna_Object_scale_editable(PointerRNA *ptr, int index)
1028 {
1029   Object *ob = (Object *)ptr->data;
1030
1031   /* only if the axis in question is locked, not editable... */
1032   if ((index == 0) && (ob->protectflag & OB_LOCK_SCALEX))
1033     return 0;
1034   else if ((index == 1) && (ob->protectflag & OB_LOCK_SCALEY))
1035     return 0;
1036   else if ((index == 2) && (ob->protectflag & OB_LOCK_SCALEZ))
1037     return 0;
1038   else
1039     return PROP_EDITABLE;
1040 }
1041
1042 static int rna_Object_rotation_euler_editable(PointerRNA *ptr, int index)
1043 {
1044   Object *ob = (Object *)ptr->data;
1045
1046   /* only if the axis in question is locked, not editable... */
1047   if ((index == 0) && (ob->protectflag & OB_LOCK_ROTX))
1048     return 0;
1049   else if ((index == 1) && (ob->protectflag & OB_LOCK_ROTY))
1050     return 0;
1051   else if ((index == 2) && (ob->protectflag & OB_LOCK_ROTZ))
1052     return 0;
1053   else
1054     return PROP_EDITABLE;
1055 }
1056
1057 static int rna_Object_rotation_4d_editable(PointerRNA *ptr, int index)
1058 {
1059   Object *ob = (Object *)ptr->data;
1060
1061   /* only consider locks if locking components individually... */
1062   if (ob->protectflag & OB_LOCK_ROT4D) {
1063     /* only if the axis in question is locked, not editable... */
1064     if ((index == 0) && (ob->protectflag & OB_LOCK_ROTW))
1065       return 0;
1066     else if ((index == 1) && (ob->protectflag & OB_LOCK_ROTX))
1067       return 0;
1068     else if ((index == 2) && (ob->protectflag & OB_LOCK_ROTY))
1069       return 0;
1070     else if ((index == 3) && (ob->protectflag & OB_LOCK_ROTZ))
1071       return 0;
1072   }
1073
1074   return PROP_EDITABLE;
1075 }
1076
1077 static int rna_MaterialSlot_material_editable(PointerRNA *ptr, const char **UNUSED(r_info))
1078 {
1079   Object *ob = (Object *)ptr->id.data;
1080   const int index = (Material **)ptr->data - ob->mat;
1081   bool is_editable;
1082
1083   if ((ob->matbits == NULL) || ob->matbits[index]) {
1084     is_editable = !ID_IS_LINKED(ob);
1085   }
1086   else {
1087     is_editable = ob->data ? !ID_IS_LINKED(ob->data) : false;
1088   }
1089
1090   return is_editable ? PROP_EDITABLE : 0;
1091 }
1092
1093 static PointerRNA rna_MaterialSlot_material_get(PointerRNA *ptr)
1094 {
1095   Object *ob = (Object *)ptr->id.data;
1096   Material *ma;
1097   const int index = (Material **)ptr->data - ob->mat;
1098
1099   ma = give_current_material(ob, index + 1);
1100   return rna_pointer_inherit_refine(ptr, &RNA_Material, ma);
1101 }
1102
1103 static void rna_MaterialSlot_material_set(PointerRNA *ptr,
1104                                           PointerRNA value,
1105                                           struct ReportList *UNUSED(reports))
1106 {
1107   Object *ob = (Object *)ptr->id.data;
1108   int index = (Material **)ptr->data - ob->mat;
1109
1110   BLI_assert(BKE_id_is_in_global_main(&ob->id));
1111   BLI_assert(BKE_id_is_in_global_main(value.data));
1112   assign_material(G_MAIN, ob, value.data, index + 1, BKE_MAT_ASSIGN_EXISTING);
1113 }
1114
1115 static bool rna_MaterialSlot_material_poll(PointerRNA *ptr, PointerRNA value)
1116 {
1117   Object *ob = (Object *)ptr->id.data;
1118   Material *ma = (Material *)value.data;
1119
1120   if (ob->type == OB_GPENCIL) {
1121     /* GP Materials only */
1122     return (ma->gp_style != NULL);
1123   }
1124   else {
1125     /* Everything except GP materials */
1126     return (ma->gp_style == NULL);
1127   }
1128 }
1129
1130 static int rna_MaterialSlot_link_get(PointerRNA *ptr)
1131 {
1132   Object *ob = (Object *)ptr->id.data;
1133   int index = (Material **)ptr->data - ob->mat;
1134
1135   return ob->matbits[index] != 0;
1136 }
1137
1138 static void rna_MaterialSlot_link_set(PointerRNA *ptr, int value)
1139 {
1140   Object *ob = (Object *)ptr->id.data;
1141   int index = (Material **)ptr->data - ob->mat;
1142
1143   if (value) {
1144     ob->matbits[index] = 1;
1145     /* ob->colbits |= (1 << index); */ /* DEPRECATED */
1146   }
1147   else {
1148     ob->matbits[index] = 0;
1149     /* ob->colbits &= ~(1 << index); */ /* DEPRECATED */
1150   }
1151 }
1152
1153 static int rna_MaterialSlot_name_length(PointerRNA *ptr)
1154 {
1155   Object *ob = (Object *)ptr->id.data;
1156   Material *ma;
1157   int index = (Material **)ptr->data - ob->mat;
1158
1159   ma = give_current_material(ob, index + 1);
1160
1161   if (ma)
1162     return strlen(ma->id.name + 2);
1163
1164   return 0;
1165 }
1166
1167 static void rna_MaterialSlot_name_get(PointerRNA *ptr, char *str)
1168 {
1169   Object *ob = (Object *)ptr->id.data;
1170   Material *ma;
1171   int index = (Material **)ptr->data - ob->mat;
1172
1173   ma = give_current_material(ob, index + 1);
1174
1175   if (ma)
1176     strcpy(str, ma->id.name + 2);
1177   else
1178     str[0] = '\0';
1179 }
1180
1181 static void rna_MaterialSlot_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1182 {
1183   rna_Object_internal_update(bmain, scene, ptr);
1184
1185   WM_main_add_notifier(NC_OBJECT | ND_OB_SHADING, ptr->id.data);
1186   WM_main_add_notifier(NC_MATERIAL | ND_SHADING_LINKS, NULL);
1187   DEG_relations_tag_update(bmain);
1188 }
1189
1190 static char *rna_MaterialSlot_path(PointerRNA *ptr)
1191 {
1192   Object *ob = (Object *)ptr->id.data;
1193   int index = (Material **)ptr->data - ob->mat;
1194
1195   return BLI_sprintfN("material_slots[%d]", index);
1196 }
1197
1198 static PointerRNA rna_Object_display_get(PointerRNA *ptr)
1199 {
1200   return rna_pointer_inherit_refine(ptr, &RNA_ObjectDisplay, ptr->data);
1201 }
1202
1203 static char *rna_ObjectDisplay_path(PointerRNA *UNUSED(ptr))
1204 {
1205   return BLI_strdup("display");
1206 }
1207
1208 static PointerRNA rna_Object_active_particle_system_get(PointerRNA *ptr)
1209 {
1210   Object *ob = (Object *)ptr->id.data;
1211   ParticleSystem *psys = psys_get_current(ob);
1212   return rna_pointer_inherit_refine(ptr, &RNA_ParticleSystem, psys);
1213 }
1214
1215 static void rna_Object_active_shape_key_index_range(
1216     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
1217 {
1218   Object *ob = (Object *)ptr->id.data;
1219   Key *key = BKE_key_from_object(ob);
1220
1221   *min = 0;
1222   if (key) {
1223     *max = BLI_listbase_count(&key->block) - 1;
1224     if (*max < 0)
1225       *max = 0;
1226   }
1227   else {
1228     *max = 0;
1229   }
1230 }
1231
1232 static int rna_Object_active_shape_key_index_get(PointerRNA *ptr)
1233 {
1234   Object *ob = (Object *)ptr->id.data;
1235
1236   return MAX2(ob->shapenr - 1, 0);
1237 }
1238
1239 static void rna_Object_active_shape_key_index_set(PointerRNA *ptr, int value)
1240 {
1241   Object *ob = (Object *)ptr->id.data;
1242
1243   ob->shapenr = value + 1;
1244 }
1245
1246 static PointerRNA rna_Object_active_shape_key_get(PointerRNA *ptr)
1247 {
1248   Object *ob = (Object *)ptr->id.data;
1249   Key *key = BKE_key_from_object(ob);
1250   KeyBlock *kb;
1251   PointerRNA keyptr;
1252
1253   if (key == NULL)
1254     return PointerRNA_NULL;
1255
1256   kb = BLI_findlink(&key->block, ob->shapenr - 1);
1257   RNA_pointer_create((ID *)key, &RNA_ShapeKey, kb, &keyptr);
1258   return keyptr;
1259 }
1260
1261 static PointerRNA rna_Object_field_get(PointerRNA *ptr)
1262 {
1263   Object *ob = (Object *)ptr->id.data;
1264
1265   /* weak */
1266   if (!ob->pd)
1267     ob->pd = BKE_partdeflect_new(0);
1268
1269   return rna_pointer_inherit_refine(ptr, &RNA_FieldSettings, ob->pd);
1270 }
1271
1272 static PointerRNA rna_Object_collision_get(PointerRNA *ptr)
1273 {
1274   Object *ob = (Object *)ptr->id.data;
1275
1276   if (ob->type != OB_MESH)
1277     return PointerRNA_NULL;
1278
1279   /* weak */
1280   if (!ob->pd)
1281     ob->pd = BKE_partdeflect_new(0);
1282
1283   return rna_pointer_inherit_refine(ptr, &RNA_CollisionSettings, ob->pd);
1284 }
1285
1286 static PointerRNA rna_Object_active_constraint_get(PointerRNA *ptr)
1287 {
1288   Object *ob = (Object *)ptr->id.data;
1289   bConstraint *con = BKE_constraints_active_get(&ob->constraints);
1290   return rna_pointer_inherit_refine(ptr, &RNA_Constraint, con);
1291 }
1292
1293 static void rna_Object_active_constraint_set(PointerRNA *ptr,
1294                                              PointerRNA value,
1295                                              struct ReportList *UNUSED(reports))
1296 {
1297   Object *ob = (Object *)ptr->id.data;
1298   BKE_constraints_active_set(&ob->constraints, (bConstraint *)value.data);
1299 }
1300
1301 static bConstraint *rna_Object_constraints_new(Object *object, Main *bmain, int type)
1302 {
1303   bConstraint *new_con = BKE_constraint_add_for_object(object, NULL, type);
1304
1305   ED_object_constraint_tag_update(bmain, object, new_con);
1306   WM_main_add_notifier(NC_OBJECT | ND_CONSTRAINT | NA_ADDED, object);
1307
1308   return new_con;
1309 }
1310
1311 static void rna_Object_constraints_remove(Object *object,
1312                                           Main *bmain,
1313                                           ReportList *reports,
1314                                           PointerRNA *con_ptr)
1315 {
1316   bConstraint *con = con_ptr->data;
1317   if (BLI_findindex(&object->constraints, con) == -1) {
1318     BKE_reportf(reports,
1319                 RPT_ERROR,
1320                 "Constraint '%s' not found in object '%s'",
1321                 con->name,
1322                 object->id.name + 2);
1323     return;
1324   }
1325
1326   BKE_constraint_remove(&object->constraints, con);
1327   RNA_POINTER_INVALIDATE(con_ptr);
1328
1329   ED_object_constraint_update(bmain, object);
1330   ED_object_constraint_set_active(object, NULL);
1331   WM_main_add_notifier(NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, object);
1332 }
1333
1334 static void rna_Object_constraints_clear(Object *object, Main *bmain)
1335 {
1336   BKE_constraints_free(&object->constraints);
1337
1338   ED_object_constraint_update(bmain, object);
1339   ED_object_constraint_set_active(object, NULL);
1340
1341   WM_main_add_notifier(NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, object);
1342 }
1343
1344 bool rna_Object_constraints_override_apply(Main *UNUSED(bmain),
1345                                            PointerRNA *ptr_dst,
1346                                            PointerRNA *ptr_src,
1347                                            PointerRNA *UNUSED(ptr_storage),
1348                                            PropertyRNA *UNUSED(prop_dst),
1349                                            PropertyRNA *UNUSED(prop_src),
1350                                            PropertyRNA *UNUSED(prop_storage),
1351                                            const int UNUSED(len_dst),
1352                                            const int UNUSED(len_src),
1353                                            const int UNUSED(len_storage),
1354                                            PointerRNA *UNUSED(ptr_item_dst),
1355                                            PointerRNA *UNUSED(ptr_item_src),
1356                                            PointerRNA *UNUSED(ptr_item_storage),
1357                                            IDOverrideStaticPropertyOperation *opop)
1358 {
1359   BLI_assert(opop->operation == IDOVERRIDESTATIC_OP_INSERT_AFTER &&
1360              "Unsupported RNA override operation on constraints collection");
1361
1362   Object *ob_dst = (Object *)ptr_dst->id.data;
1363   Object *ob_src = (Object *)ptr_src->id.data;
1364
1365   /* Remember that insertion operations are defined and stored in correct order, which means that
1366    * even if we insert several items in a row, we alays insert first one, then second one, etc.
1367    * So we should always find 'anchor' constraint in both _src *and* _dst> */
1368   bConstraint *con_anchor = NULL;
1369   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1370     con_anchor = BLI_findstring(
1371         &ob_dst->constraints, opop->subitem_local_name, offsetof(bConstraint, name));
1372   }
1373   if (con_anchor == NULL && opop->subitem_local_index >= 0) {
1374     con_anchor = BLI_findlink(&ob_dst->constraints, opop->subitem_local_index);
1375   }
1376   /* Otherwise we just insert in first position. */
1377
1378   bConstraint *con_src = NULL;
1379   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1380     con_src = BLI_findstring(
1381         &ob_src->constraints, opop->subitem_local_name, offsetof(bConstraint, name));
1382   }
1383   if (con_src == NULL && opop->subitem_local_index >= 0) {
1384     con_src = BLI_findlink(&ob_src->constraints, opop->subitem_local_index);
1385   }
1386   con_src = con_src ? con_src->next : ob_src->constraints.first;
1387
1388   BLI_assert(con_src != NULL);
1389
1390   bConstraint *con_dst = BKE_constraint_duplicate_ex(con_src, 0, true);
1391
1392   /* This handles NULL anchor as expected by adding at head of list. */
1393   BLI_insertlinkafter(&ob_dst->constraints, con_anchor, con_dst);
1394
1395   /* This should actually *not* be needed in typical cases.
1396    * However, if overridden source was edited, we *may* have some new conflicting names. */
1397   BKE_constraint_unique_name(con_dst, &ob_dst->constraints);
1398
1399   //  printf("%s: We inserted a constraint...\n", __func__);
1400   return true;
1401 }
1402
1403 static ModifierData *rna_Object_modifier_new(
1404     Object *object, bContext *C, ReportList *reports, const char *name, int type)
1405 {
1406   return ED_object_modifier_add(reports, CTX_data_main(C), CTX_data_scene(C), object, name, type);
1407 }
1408
1409 static void rna_Object_modifier_remove(Object *object,
1410                                        bContext *C,
1411                                        ReportList *reports,
1412                                        PointerRNA *md_ptr)
1413 {
1414   ModifierData *md = md_ptr->data;
1415   if (ED_object_modifier_remove(reports, CTX_data_main(C), object, md) == false) {
1416     /* error is already set */
1417     return;
1418   }
1419
1420   RNA_POINTER_INVALIDATE(md_ptr);
1421
1422   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1423 }
1424
1425 static void rna_Object_modifier_clear(Object *object, bContext *C)
1426 {
1427   ED_object_modifier_clear(CTX_data_main(C), object);
1428
1429   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1430 }
1431
1432 bool rna_Object_modifiers_override_apply(Main *UNUSED(bmain),
1433                                          PointerRNA *ptr_dst,
1434                                          PointerRNA *ptr_src,
1435                                          PointerRNA *UNUSED(ptr_storage),
1436                                          PropertyRNA *UNUSED(prop_dst),
1437                                          PropertyRNA *UNUSED(prop_src),
1438                                          PropertyRNA *UNUSED(prop_storage),
1439                                          const int UNUSED(len_dst),
1440                                          const int UNUSED(len_src),
1441                                          const int UNUSED(len_storage),
1442                                          PointerRNA *UNUSED(ptr_item_dst),
1443                                          PointerRNA *UNUSED(ptr_item_src),
1444                                          PointerRNA *UNUSED(ptr_item_storage),
1445                                          IDOverrideStaticPropertyOperation *opop)
1446 {
1447   BLI_assert(opop->operation == IDOVERRIDESTATIC_OP_INSERT_AFTER &&
1448              "Unsupported RNA override operation on modifiers collection");
1449
1450   Object *ob_dst = (Object *)ptr_dst->id.data;
1451   Object *ob_src = (Object *)ptr_src->id.data;
1452
1453   /* Remember that insertion operations are defined and stored in correct order, which means that
1454    * even if we insert several items in a row, we alays insert first one, then second one, etc.
1455    * So we should always find 'anchor' constraint in both _src *and* _dst> */
1456   ModifierData *mod_anchor = NULL;
1457   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1458     mod_anchor = BLI_findstring(
1459         &ob_dst->modifiers, opop->subitem_local_name, offsetof(ModifierData, name));
1460   }
1461   if (mod_anchor == NULL && opop->subitem_local_index >= 0) {
1462     mod_anchor = BLI_findlink(&ob_dst->modifiers, opop->subitem_local_index);
1463   }
1464   /* Otherwise we just insert in first position. */
1465
1466   ModifierData *mod_src = NULL;
1467   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1468     mod_src = BLI_findstring(
1469         &ob_src->modifiers, opop->subitem_local_name, offsetof(ModifierData, name));
1470   }
1471   if (mod_src == NULL && opop->subitem_local_index >= 0) {
1472     mod_src = BLI_findlink(&ob_src->modifiers, opop->subitem_local_index);
1473   }
1474   mod_src = mod_src ? mod_src->next : ob_src->modifiers.first;
1475
1476   BLI_assert(mod_src != NULL);
1477
1478   ModifierData *mod_dst = modifier_new(mod_src->type);
1479   modifier_copyData(mod_src, mod_dst);
1480
1481   /* This handles NULL anchor as expected by adding at head of list. */
1482   BLI_insertlinkafter(&ob_dst->modifiers, mod_anchor, mod_dst);
1483
1484   /* This should actually *not* be needed in typical cases.
1485    * However, if overridden source was edited,
1486    * we *may* have some new conflicting names. */
1487   modifier_unique_name(&ob_dst->modifiers, mod_dst);
1488
1489   //  printf("%s: We inserted a modifier...\n", __func__);
1490   return true;
1491 }
1492
1493 static GpencilModifierData *rna_Object_greasepencil_modifier_new(
1494     Object *object, bContext *C, ReportList *reports, const char *name, int type)
1495 {
1496   return ED_object_gpencil_modifier_add(
1497       reports, CTX_data_main(C), CTX_data_scene(C), object, name, type);
1498 }
1499
1500 static void rna_Object_greasepencil_modifier_remove(Object *object,
1501                                                     bContext *C,
1502                                                     ReportList *reports,
1503                                                     PointerRNA *gmd_ptr)
1504 {
1505   GpencilModifierData *gmd = gmd_ptr->data;
1506   if (ED_object_gpencil_modifier_remove(reports, CTX_data_main(C), object, gmd) == false) {
1507     /* error is already set */
1508     return;
1509   }
1510
1511   RNA_POINTER_INVALIDATE(gmd_ptr);
1512
1513   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1514 }
1515
1516 static void rna_Object_greasepencil_modifier_clear(Object *object, bContext *C)
1517 {
1518   ED_object_gpencil_modifier_clear(CTX_data_main(C), object);
1519   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1520 }
1521
1522 /* shader fx */
1523 static ShaderFxData *rna_Object_shaderfx_new(
1524     Object *object, bContext *C, ReportList *reports, const char *name, int type)
1525 {
1526   return ED_object_shaderfx_add(reports, CTX_data_main(C), CTX_data_scene(C), object, name, type);
1527 }
1528
1529 static void rna_Object_shaderfx_remove(Object *object,
1530                                        bContext *C,
1531                                        ReportList *reports,
1532                                        PointerRNA *gmd_ptr)
1533 {
1534   ShaderFxData *gmd = gmd_ptr->data;
1535   if (ED_object_shaderfx_remove(reports, CTX_data_main(C), object, gmd) == false) {
1536     /* error is already set */
1537     return;
1538   }
1539
1540   RNA_POINTER_INVALIDATE(gmd_ptr);
1541
1542   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1543 }
1544
1545 static void rna_Object_shaderfx_clear(Object *object, bContext *C)
1546 {
1547   ED_object_shaderfx_clear(CTX_data_main(C), object);
1548   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1549 }
1550
1551 static void rna_Object_boundbox_get(PointerRNA *ptr, float *values)
1552 {
1553   Object *ob = (Object *)ptr->id.data;
1554   BoundBox *bb = BKE_object_boundbox_get(ob);
1555   if (bb) {
1556     memcpy(values, bb->vec, sizeof(bb->vec));
1557   }
1558   else {
1559     copy_vn_fl(values, sizeof(bb->vec) / sizeof(float), 0.0f);
1560   }
1561 }
1562
1563 static bDeformGroup *rna_Object_vgroup_new(Object *ob, Main *bmain, const char *name)
1564 {
1565   bDeformGroup *defgroup = BKE_object_defgroup_add_name(ob, name);
1566
1567   DEG_relations_tag_update(bmain);
1568   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1569
1570   return defgroup;
1571 }
1572
1573 static void rna_Object_vgroup_remove(Object *ob,
1574                                      Main *bmain,
1575                                      ReportList *reports,
1576                                      PointerRNA *defgroup_ptr)
1577 {
1578   bDeformGroup *defgroup = defgroup_ptr->data;
1579   if (BLI_findindex(&ob->defbase, defgroup) == -1) {
1580     BKE_reportf(reports,
1581                 RPT_ERROR,
1582                 "DeformGroup '%s' not in object '%s'",
1583                 defgroup->name,
1584                 ob->id.name + 2);
1585     return;
1586   }
1587
1588   BKE_object_defgroup_remove(ob, defgroup);
1589   RNA_POINTER_INVALIDATE(defgroup_ptr);
1590
1591   DEG_relations_tag_update(bmain);
1592   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1593 }
1594
1595 static void rna_Object_vgroup_clear(Object *ob, Main *bmain)
1596 {
1597   BKE_object_defgroup_remove_all(ob);
1598
1599   DEG_relations_tag_update(bmain);
1600   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1601 }
1602
1603 static void rna_VertexGroup_vertex_add(ID *id,
1604                                        bDeformGroup *def,
1605                                        ReportList *reports,
1606                                        int index_len,
1607                                        int *index,
1608                                        float weight,
1609                                        int assignmode)
1610 {
1611   Object *ob = (Object *)id;
1612
1613   if (BKE_object_is_in_editmode_vgroup(ob)) {
1614     BKE_report(
1615         reports, RPT_ERROR, "VertexGroup.add(): cannot be called while object is in edit mode");
1616     return;
1617   }
1618
1619   while (index_len--)
1620     ED_vgroup_vert_add(
1621         ob, def, *index++, weight, assignmode); /* XXX, not efficient calling within loop*/
1622
1623   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1624   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1625 }
1626
1627 static void rna_VertexGroup_vertex_remove(
1628     ID *id, bDeformGroup *dg, ReportList *reports, int index_len, int *index)
1629 {
1630   Object *ob = (Object *)id;
1631
1632   if (BKE_object_is_in_editmode_vgroup(ob)) {
1633     BKE_report(
1634         reports, RPT_ERROR, "VertexGroup.remove(): cannot be called while object is in edit mode");
1635     return;
1636   }
1637
1638   while (index_len--)
1639     ED_vgroup_vert_remove(ob, dg, *index++);
1640
1641   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1642   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1643 }
1644
1645 static float rna_VertexGroup_weight(ID *id, bDeformGroup *dg, ReportList *reports, int index)
1646 {
1647   float weight = ED_vgroup_vert_weight((Object *)id, dg, index);
1648
1649   if (weight < 0) {
1650     BKE_report(reports, RPT_ERROR, "Vertex not in group");
1651   }
1652   return weight;
1653 }
1654
1655 static bFaceMap *rna_Object_fmap_new(Object *ob, const char *name)
1656 {
1657   bFaceMap *fmap = BKE_object_facemap_add_name(ob, name);
1658
1659   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1660
1661   return fmap;
1662 }
1663
1664 static void rna_Object_fmap_remove(Object *ob, ReportList *reports, PointerRNA *fmap_ptr)
1665 {
1666   bFaceMap *fmap = fmap_ptr->data;
1667   if (BLI_findindex(&ob->fmaps, fmap) == -1) {
1668     BKE_reportf(
1669         reports, RPT_ERROR, "FaceMap '%s' not in object '%s'", fmap->name, ob->id.name + 2);
1670     return;
1671   }
1672
1673   BKE_object_facemap_remove(ob, fmap);
1674   RNA_POINTER_INVALIDATE(fmap_ptr);
1675
1676   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1677 }
1678
1679 static void rna_Object_fmap_clear(Object *ob)
1680 {
1681   BKE_object_facemap_clear(ob);
1682
1683   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1684 }
1685
1686 static void rna_FaceMap_face_add(
1687     ID *id, bFaceMap *fmap, ReportList *reports, int index_len, int *index)
1688 {
1689   Object *ob = (Object *)id;
1690
1691   if (BKE_object_is_in_editmode(ob)) {
1692     BKE_report(reports, RPT_ERROR, "FaceMap.add(): cannot be called while object is in edit mode");
1693     return;
1694   }
1695
1696   while (index_len--)
1697     ED_object_facemap_face_add(ob, fmap, *index++);
1698
1699   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1700 }
1701
1702 static void rna_FaceMap_face_remove(
1703     ID *id, bFaceMap *fmap, ReportList *reports, int index_len, int *index)
1704 {
1705   Object *ob = (Object *)id;
1706
1707   if (BKE_object_is_in_editmode(ob)) {
1708     BKE_report(reports, RPT_ERROR, "FaceMap.add(): cannot be called while object is in edit mode");
1709     return;
1710   }
1711
1712   while (index_len--)
1713     ED_object_facemap_face_remove(ob, fmap, *index++);
1714
1715   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1716 }
1717
1718 /* generic poll functions */
1719 bool rna_Lattice_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1720 {
1721   return ((Object *)value.id.data)->type == OB_LATTICE;
1722 }
1723
1724 bool rna_Curve_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1725 {
1726   return ((Object *)value.id.data)->type == OB_CURVE;
1727 }
1728
1729 bool rna_Armature_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1730 {
1731   return ((Object *)value.id.data)->type == OB_ARMATURE;
1732 }
1733
1734 bool rna_Mesh_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1735 {
1736   return ((Object *)value.id.data)->type == OB_MESH;
1737 }
1738
1739 bool rna_Camera_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1740 {
1741   return ((Object *)value.id.data)->type == OB_CAMERA;
1742 }
1743
1744 bool rna_Light_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1745 {
1746   return ((Object *)value.id.data)->type == OB_LAMP;
1747 }
1748
1749 bool rna_GPencil_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1750 {
1751   return ((Object *)value.id.data)->type == OB_GPENCIL;
1752 }
1753
1754 int rna_Object_use_dynamic_topology_sculpting_get(PointerRNA *ptr)
1755 {
1756   SculptSession *ss = ((Object *)ptr->id.data)->sculpt;
1757   return (ss && ss->bm);
1758 }
1759
1760 #else
1761
1762 static void rna_def_vertex_group(BlenderRNA *brna)
1763 {
1764   StructRNA *srna;
1765   PropertyRNA *prop;
1766   FunctionRNA *func;
1767   PropertyRNA *parm;
1768
1769   static const EnumPropertyItem assign_mode_items[] = {
1770       {WEIGHT_REPLACE, "REPLACE", 0, "Replace", "Replace"},
1771       {WEIGHT_ADD, "ADD", 0, "Add", "Add"},
1772       {WEIGHT_SUBTRACT, "SUBTRACT", 0, "Subtract", "Subtract"},
1773       {0, NULL, 0, NULL, NULL},
1774   };
1775
1776   srna = RNA_def_struct(brna, "VertexGroup", NULL);
1777   RNA_def_struct_sdna(srna, "bDeformGroup");
1778   RNA_def_struct_ui_text(
1779       srna, "Vertex Group", "Group of vertices, used for armature deform and other purposes");
1780   RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
1781
1782   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1783   RNA_def_property_ui_text(prop, "Name", "Vertex group name");
1784   RNA_def_struct_name_property(srna, prop);
1785   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_VertexGroup_name_set");
1786   /* update data because modifiers may use [#24761] */
1787   RNA_def_property_update(
1788       prop, NC_GEOM | ND_DATA | NA_RENAME, "rna_Object_internal_update_data_dependency");
1789
1790   prop = RNA_def_property(srna, "lock_weight", PROP_BOOLEAN, PROP_NONE);
1791   RNA_def_property_ui_text(prop, "", "Maintain the relative weights for the group");
1792   RNA_def_property_boolean_sdna(prop, NULL, "flag", 0);
1793   /* update data because modifiers may use [#24761] */
1794   RNA_def_property_update(prop, NC_GEOM | ND_DATA | NA_RENAME, "rna_Object_internal_update_data");
1795
1796   prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1797   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1798   RNA_def_property_int_funcs(prop, "rna_VertexGroup_index_get", NULL, NULL);
1799   RNA_def_property_ui_text(prop, "Index", "Index number of the vertex group");
1800
1801   func = RNA_def_function(srna, "add", "rna_VertexGroup_vertex_add");
1802   RNA_def_function_ui_description(func, "Add vertices to the group");
1803   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1804   /* TODO, see how array size of 0 works, this shouldnt be used */
1805   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1806   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1807   parm = RNA_def_float(func, "weight", 0, 0.0f, 1.0f, "", "Vertex weight", 0.0f, 1.0f);
1808   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1809   parm = RNA_def_enum(func, "type", assign_mode_items, 0, "", "Vertex assign mode");
1810   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1811
1812   func = RNA_def_function(srna, "remove", "rna_VertexGroup_vertex_remove");
1813   RNA_def_function_ui_description(func, "Remove a vertex from the group");
1814   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1815   /* TODO, see how array size of 0 works, this shouldnt be used */
1816   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1817   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1818
1819   func = RNA_def_function(srna, "weight", "rna_VertexGroup_weight");
1820   RNA_def_function_ui_description(func, "Get a vertex weight from the group");
1821   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1822   parm = RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "The index of the vertex", 0, INT_MAX);
1823   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1824   parm = RNA_def_float(func, "weight", 0, 0.0f, 1.0f, "", "Vertex weight", 0.0f, 1.0f);
1825   RNA_def_function_return(func, parm);
1826 }
1827
1828 static void rna_def_face_map(BlenderRNA *brna)
1829 {
1830   StructRNA *srna;
1831   PropertyRNA *prop;
1832
1833   FunctionRNA *func;
1834   PropertyRNA *parm;
1835
1836   srna = RNA_def_struct(brna, "FaceMap", NULL);
1837   RNA_def_struct_sdna(srna, "bFaceMap");
1838   RNA_def_struct_ui_text(
1839       srna, "Face Map", "Group of faces, each face can only be part of one map");
1840   RNA_def_struct_ui_icon(srna, ICON_MOD_TRIANGULATE);
1841
1842   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1843   RNA_def_property_ui_text(prop, "Name", "Face map name");
1844   RNA_def_struct_name_property(srna, prop);
1845   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_FaceMap_name_set");
1846   /* update data because modifiers may use [#24761] */
1847   RNA_def_property_update(prop, NC_GEOM | ND_DATA | NA_RENAME, "rna_Object_internal_update_data");
1848
1849   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1850   RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1851   RNA_def_property_ui_text(prop, "Select", "Face-map selection state (for tools to use)");
1852   /* important not to use a notifier here, creates a feedback loop! */
1853
1854   prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1855   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1856   RNA_def_property_int_funcs(prop, "rna_FaceMap_index_get", NULL, NULL);
1857   RNA_def_property_ui_text(prop, "Index", "Index number of the face map");
1858
1859   func = RNA_def_function(srna, "add", "rna_FaceMap_face_add");
1860   RNA_def_function_ui_description(func, "Add vertices to the group");
1861   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1862   /* TODO, see how array size of 0 works, this shouldnt be used */
1863   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1864   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1865
1866   func = RNA_def_function(srna, "remove", "rna_FaceMap_face_remove");
1867   RNA_def_function_ui_description(func, "Remove a vertex from the group");
1868   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1869   /* TODO, see how array size of 0 works, this shouldnt be used */
1870   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1871   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1872 }
1873
1874 static void rna_def_material_slot(BlenderRNA *brna)
1875 {
1876   StructRNA *srna;
1877   PropertyRNA *prop;
1878
1879   static const EnumPropertyItem link_items[] = {
1880       {1, "OBJECT", 0, "Object", ""},
1881       {0, "DATA", 0, "Data", ""},
1882       {0, NULL, 0, NULL, NULL},
1883   };
1884
1885   /* NOTE: there is no MaterialSlot equivalent in DNA, so the internal
1886    * pointer data points to ob->mat + index, and we manually implement
1887    * get/set for the properties. */
1888
1889   srna = RNA_def_struct(brna, "MaterialSlot", NULL);
1890   RNA_def_struct_ui_text(srna, "Material Slot", "Material slot in an object");
1891   RNA_def_struct_ui_icon(srna, ICON_MATERIAL_DATA);
1892
1893   /* WARNING! Order is crucial for override to work properly here... :/
1894    * 'link' must come before material pointer,
1895    * since it defines where (in object or obdata) that one is set! */
1896   prop = RNA_def_property(srna, "link", PROP_ENUM, PROP_NONE);
1897   RNA_def_property_enum_items(prop, link_items);
1898   RNA_def_property_enum_funcs(
1899       prop, "rna_MaterialSlot_link_get", "rna_MaterialSlot_link_set", NULL);
1900   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
1901   RNA_def_property_ui_text(prop, "Link", "Link material to object or the object's data");
1902   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_MaterialSlot_update");
1903
1904   prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
1905   RNA_def_property_struct_type(prop, "Material");
1906   RNA_def_property_flag(prop, PROP_EDITABLE);
1907   RNA_def_property_editable_func(prop, "rna_MaterialSlot_material_editable");
1908   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
1909   RNA_def_property_pointer_funcs(prop,
1910                                  "rna_MaterialSlot_material_get",
1911                                  "rna_MaterialSlot_material_set",
1912                                  NULL,
1913                                  "rna_MaterialSlot_material_poll");
1914   RNA_def_property_ui_text(prop, "Material", "Material data-block used by this material slot");
1915   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_MaterialSlot_update");
1916
1917   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1918   RNA_def_property_string_funcs(
1919       prop, "rna_MaterialSlot_name_get", "rna_MaterialSlot_name_length", NULL);
1920   RNA_def_property_ui_text(prop, "Name", "Material slot name");
1921   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1922   RNA_def_struct_name_property(srna, prop);
1923
1924   RNA_def_struct_path_func(srna, "rna_MaterialSlot_path");
1925 }
1926
1927 static void rna_def_object_constraints(BlenderRNA *brna, PropertyRNA *cprop)
1928 {
1929   StructRNA *srna;
1930   PropertyRNA *prop;
1931
1932   FunctionRNA *func;
1933   PropertyRNA *parm;
1934
1935   RNA_def_property_srna(cprop, "ObjectConstraints");
1936   srna = RNA_def_struct(brna, "ObjectConstraints", NULL);
1937   RNA_def_struct_sdna(srna, "Object");
1938   RNA_def_struct_ui_text(srna, "Object Constraints", "Collection of object constraints");
1939
1940   /* Collection active property */
1941   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1942   RNA_def_property_struct_type(prop, "Constraint");
1943   RNA_def_property_pointer_funcs(
1944       prop, "rna_Object_active_constraint_get", "rna_Object_active_constraint_set", NULL, NULL);
1945   RNA_def_property_flag(prop, PROP_EDITABLE);
1946   RNA_def_property_ui_text(prop, "Active Constraint", "Active Object constraint");
1947
1948   /* Constraint collection */
1949   func = RNA_def_function(srna, "new", "rna_Object_constraints_new");
1950   RNA_def_function_ui_description(func, "Add a new constraint to this object");
1951   RNA_def_function_flag(func, FUNC_USE_MAIN);
1952   /* object to add */
1953   parm = RNA_def_enum(
1954       func, "type", rna_enum_constraint_type_items, 1, "", "Constraint type to add");
1955   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1956   /* return type */
1957   parm = RNA_def_pointer(func, "constraint", "Constraint", "", "New constraint");
1958   RNA_def_function_return(func, parm);
1959
1960   func = RNA_def_function(srna, "remove", "rna_Object_constraints_remove");
1961   RNA_def_function_ui_description(func, "Remove a constraint from this object");
1962   RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS);
1963   /* constraint to remove */
1964   parm = RNA_def_pointer(func, "constraint", "Constraint", "", "Removed constraint");
1965   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1966   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1967
1968   func = RNA_def_function(srna, "clear", "rna_Object_constraints_clear");
1969   RNA_def_function_flag(func, FUNC_USE_MAIN);
1970   RNA_def_function_ui_description(func, "Remove all constraint from this object");
1971 }
1972
1973 /* object.modifiers */
1974 static void rna_def_object_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
1975 {
1976   StructRNA *srna;
1977
1978   FunctionRNA *func;
1979   PropertyRNA *parm;
1980
1981   RNA_def_property_srna(cprop, "ObjectModifiers");
1982   srna = RNA_def_struct(brna, "ObjectModifiers", NULL);
1983   RNA_def_struct_sdna(srna, "Object");
1984   RNA_def_struct_ui_text(srna, "Object Modifiers", "Collection of object modifiers");
1985
1986 #  if 0
1987   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1988   RNA_def_property_struct_type(prop, "EditBone");
1989   RNA_def_property_pointer_sdna(prop, NULL, "act_edbone");
1990   RNA_def_property_flag(prop, PROP_EDITABLE);
1991   RNA_def_property_ui_text(prop, "Active EditBone", "Armatures active edit bone");
1992   /*RNA_def_property_update(prop, 0, "rna_Armature_act_editbone_update"); */
1993   RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_edit_bone_set", NULL, NULL);
1994
1995   /* todo, redraw */
1996 /*      RNA_def_property_collection_active(prop, prop_act); */
1997 #  endif
1998
1999   /* add modifier */
2000   func = RNA_def_function(srna, "new", "rna_Object_modifier_new");
2001   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2002   RNA_def_function_ui_description(func, "Add a new modifier");
2003   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the modifier");
2004   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2005   /* modifier to add */
2006   parm = RNA_def_enum(
2007       func, "type", rna_enum_object_modifier_type_items, 1, "", "Modifier type to add");
2008   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2009   /* return type */
2010   parm = RNA_def_pointer(func, "modifier", "Modifier", "", "Newly created modifier");
2011   RNA_def_function_return(func, parm);
2012
2013   /* remove modifier */
2014   func = RNA_def_function(srna, "remove", "rna_Object_modifier_remove");
2015   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2016   RNA_def_function_ui_description(func, "Remove an existing modifier from the object");
2017   /* modifier to remove */
2018   parm = RNA_def_pointer(func, "modifier", "Modifier", "", "Modifier to remove");
2019   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2020   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2021
2022   /* clear all modifiers */
2023   func = RNA_def_function(srna, "clear", "rna_Object_modifier_clear");
2024   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2025   RNA_def_function_ui_description(func, "Remove all modifiers from the object");
2026 }
2027
2028 /* object.grease_pencil_modifiers */
2029 static void rna_def_object_grease_pencil_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
2030 {
2031   StructRNA *srna;
2032
2033   FunctionRNA *func;
2034   PropertyRNA *parm;
2035
2036   RNA_def_property_srna(cprop, "ObjectGpencilModifiers");
2037   srna = RNA_def_struct(brna, "ObjectGpencilModifiers", NULL);
2038   RNA_def_struct_sdna(srna, "Object");
2039   RNA_def_struct_ui_text(
2040       srna, "Object Grease Pencil Modifiers", "Collection of object grease pencil modifiers");
2041
2042   /* add greasepencil modifier */
2043   func = RNA_def_function(srna, "new", "rna_Object_greasepencil_modifier_new");
2044   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2045   RNA_def_function_ui_description(func, "Add a new greasepencil_modifier");
2046   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the greasepencil_modifier");
2047   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2048   /* greasepencil_modifier to add */
2049   parm = RNA_def_enum(func,
2050                       "type",
2051                       rna_enum_object_greasepencil_modifier_type_items,
2052                       1,
2053                       "",
2054                       "Modifier type to add");
2055   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2056   /* return type */
2057   parm = RNA_def_pointer(
2058       func, "greasepencil_modifier", "GpencilModifier", "", "Newly created modifier");
2059   RNA_def_function_return(func, parm);
2060
2061   /* remove greasepencil_modifier */
2062   func = RNA_def_function(srna, "remove", "rna_Object_greasepencil_modifier_remove");
2063   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2064   RNA_def_function_ui_description(func,
2065                                   "Remove an existing greasepencil_modifier from the object");
2066   /* greasepencil_modifier to remove */
2067   parm = RNA_def_pointer(
2068       func, "greasepencil_modifier", "GpencilModifier", "", "Modifier to remove");
2069   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2070   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2071
2072   /* clear all greasepencil modifiers */
2073   func = RNA_def_function(srna, "clear", "rna_Object_greasepencil_modifier_clear");
2074   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2075   RNA_def_function_ui_description(func, "Remove all grease pencil modifiers from the object");
2076 }
2077
2078 /* object.shaderfxs */
2079 static void rna_def_object_shaderfxs(BlenderRNA *brna, PropertyRNA *cprop)
2080 {
2081   StructRNA *srna;
2082
2083   FunctionRNA *func;
2084   PropertyRNA *parm;
2085
2086   RNA_def_property_srna(cprop, "ObjectShaderFx");
2087   srna = RNA_def_struct(brna, "ObjectShaderFx", NULL);
2088   RNA_def_struct_sdna(srna, "Object");
2089   RNA_def_struct_ui_text(srna, "Object Shader Effects", "Collection of object effects");
2090
2091   /* add shader_fx */
2092   func = RNA_def_function(srna, "new", "rna_Object_shaderfx_new");
2093   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2094   RNA_def_function_ui_description(func, "Add a new shader fx");
2095   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the effect");
2096   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2097   /* shader to add */
2098   parm = RNA_def_enum(
2099       func, "type", rna_enum_object_shaderfx_type_items, 1, "", "Effect type to add");
2100   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2101   /* return type */
2102   parm = RNA_def_pointer(func, "shader_fx", "ShaderFx", "", "Newly created effect");
2103   RNA_def_function_return(func, parm);
2104
2105   /* remove shader_fx */
2106   func = RNA_def_function(srna, "remove", "rna_Object_shaderfx_remove");
2107   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2108   RNA_def_function_ui_description(func, "Remove an existing effect from the object");
2109   /* shader to remove */
2110   parm = RNA_def_pointer(func, "shader_fx", "ShaderFx", "", "Effect to remove");
2111   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2112   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2113
2114   /* clear all shader fx */
2115   func = RNA_def_function(srna, "clear", "rna_Object_shaderfx_clear");
2116   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2117   RNA_def_function_ui_description(func, "Remove all effects from the object");
2118 }
2119
2120 /* object.particle_systems */
2121 static void rna_def_object_particle_systems(BlenderRNA *brna, PropertyRNA *cprop)
2122 {
2123   StructRNA *srna;
2124
2125   PropertyRNA *prop;
2126
2127   /* FunctionRNA *func; */
2128   /* PropertyRNA *parm; */
2129
2130   RNA_def_property_srna(cprop, "ParticleSystems");
2131   srna = RNA_def_struct(brna, "ParticleSystems", NULL);
2132   RNA_def_struct_sdna(srna, "Object");
2133   RNA_def_struct_ui_text(srna, "Particle Systems", "Collection of particle systems");
2134
2135   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2136   RNA_def_property_struct_type(prop, "ParticleSystem");
2137   RNA_def_property_pointer_funcs(prop, "rna_Object_active_particle_system_get", NULL, NULL, NULL);
2138   RNA_def_property_ui_text(
2139       prop, "Active Particle System", "Active particle system being displayed");
2140   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2141
2142   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2143   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2144   RNA_def_property_int_funcs(prop,
2145                              "rna_Object_active_particle_system_index_get",
2146                              "rna_Object_active_particle_system_index_set",
2147                              "rna_Object_active_particle_system_index_range");
2148   RNA_def_property_ui_text(
2149       prop, "Active Particle System Index", "Index of active particle system slot");
2150   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_particle_update");
2151 }
2152
2153 /* object.vertex_groups */
2154 static void rna_def_object_vertex_groups(BlenderRNA *brna, PropertyRNA *cprop)
2155 {
2156   StructRNA *srna;
2157
2158   PropertyRNA *prop;
2159
2160   FunctionRNA *func;
2161   PropertyRNA *parm;
2162
2163   RNA_def_property_srna(cprop, "VertexGroups");
2164   srna = RNA_def_struct(brna, "VertexGroups", NULL);
2165   RNA_def_struct_sdna(srna, "Object");
2166   RNA_def_struct_ui_text(srna, "Vertex Groups", "Collection of vertex groups");
2167
2168   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2169   RNA_def_property_struct_type(prop, "VertexGroup");
2170   RNA_def_property_pointer_funcs(prop,
2171                                  "rna_Object_active_vertex_group_get",
2172                                  "rna_Object_active_vertex_group_set",
2173                                  NULL,
2174                                  NULL);
2175   RNA_def_property_ui_text(prop, "Active Vertex Group", "Vertex groups of the object");
2176   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2177
2178   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2179   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2180   RNA_def_property_int_sdna(prop, NULL, "actdef");
2181   RNA_def_property_int_funcs(prop,
2182                              "rna_Object_active_vertex_group_index_get",
2183                              "rna_Object_active_vertex_group_index_set",
2184                              "rna_Object_active_vertex_group_index_range");
2185   RNA_def_property_ui_text(
2186       prop, "Active Vertex Group Index", "Active index in vertex group array");
2187   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2188
2189   /* vertex groups */ /* add_vertex_group */
2190   func = RNA_def_function(srna, "new", "rna_Object_vgroup_new");
2191   RNA_def_function_flag(func, FUNC_USE_MAIN);
2192   RNA_def_function_ui_description(func, "Add vertex group to object");
2193   RNA_def_string(func, "name", "Group", 0, "", "Vertex group name"); /* optional */
2194   parm = RNA_def_pointer(func, "group", "VertexGroup", "", "New vertex group");
2195   RNA_def_function_return(func, parm);
2196
2197   func = RNA_def_function(srna, "remove", "rna_Object_vgroup_remove");
2198   RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS);
2199   RNA_def_function_ui_description(func, "Delete vertex group from object");
2200   parm = RNA_def_pointer(func, "group", "VertexGroup", "", "Vertex group to remove");
2201   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2202   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2203
2204   func = RNA_def_function(srna, "clear", "rna_Object_vgroup_clear");
2205   RNA_def_function_flag(func, FUNC_USE_MAIN);
2206   RNA_def_function_ui_description(func, "Delete all vertex groups from object");
2207 }
2208
2209 /* object.face_maps */
2210 static void rna_def_object_face_maps(BlenderRNA *brna, PropertyRNA *cprop)
2211 {
2212   StructRNA *srna;
2213
2214   PropertyRNA *prop;
2215
2216   FunctionRNA *func;
2217   PropertyRNA *parm;
2218
2219   RNA_def_property_srna(cprop, "FaceMaps");
2220   srna = RNA_def_struct(brna, "FaceMaps", NULL);
2221   RNA_def_struct_sdna(srna, "Object");
2222   RNA_def_struct_ui_text(srna, "Face Maps", "Collection of face maps");
2223
2224   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2225   RNA_def_property_struct_type(prop, "FaceMap");
2226   RNA_def_property_pointer_funcs(
2227       prop, "rna_Object_active_face_map_get", "rna_Object_active_face_map_set", NULL, NULL);
2228   RNA_def_property_ui_text(prop, "Active Face Map", "Face maps of the object");
2229   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2230
2231   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2232   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2233   RNA_def_property_int_sdna(prop, NULL, "actfmap");
2234   RNA_def_property_int_funcs(prop,
2235                              "rna_Object_active_face_map_index_get",
2236                              "rna_Object_active_face_map_index_set",
2237                              "rna_Object_active_face_map_index_range");
2238   RNA_def_property_ui_text(prop, "Active Face Map Index", "Active index in face map array");
2239   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2240
2241   /* face maps */ /* add_face_map */
2242   func = RNA_def_function(srna, "new", "rna_Object_fmap_new");
2243   RNA_def_function_ui_description(func, "Add face map to object");
2244   RNA_def_string(func, "name", "Map", 0, "", "face map name"); /* optional */
2245   parm = RNA_def_pointer(func, "fmap", "FaceMap", "", "New face map");
2246   RNA_def_function_return(func, parm);
2247
2248   func = RNA_def_function(srna, "remove", "rna_Object_fmap_remove");
2249   RNA_def_function_flag(func, FUNC_USE_REPORTS);
2250   RNA_def_function_ui_description(func, "Delete vertex group from object");
2251   parm = RNA_def_pointer(func, "group", "FaceMap", "", "Face map to remove");
2252   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2253   RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
2254
2255   func = RNA_def_function(srna, "clear", "rna_Object_fmap_clear");
2256   RNA_def_function_ui_description(func, "Delete all vertex groups from object");
2257 }
2258
2259 static void rna_def_object_display(BlenderRNA *brna)
2260 {
2261   StructRNA *srna;
2262   PropertyRNA *prop;
2263
2264   srna = RNA_def_struct(brna, "ObjectDisplay", NULL);
2265   RNA_def_struct_ui_text(srna, "Object Display", "Object display settings for 3d viewport");
2266   RNA_def_struct_sdna(srna, "Object");
2267   RNA_def_struct_nested(brna, srna, "Object");
2268   RNA_def_struct_path_func(srna, "rna_ObjectDisplay_path");
2269
2270   prop = RNA_def_property(srna, "show_shadows", PROP_BOOLEAN, PROP_NONE);
2271   RNA_def_property_boolean_negative_sdna(prop, NULL, "dtx", OB_DRAW_NO_SHADOW_CAST);
2272   RNA_def_property_boolean_default(prop, true);
2273   RNA_def_property_ui_text(prop, "Shadow", "Object cast shadows in the 3d viewport");
2274   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2275 }
2276
2277 static void rna_def_object(BlenderRNA *brna)
2278 {
2279   StructRNA *srna;
2280   PropertyRNA *prop;
2281
2282   static const EnumPropertyItem up_items[] = {
2283       {OB_POSX, "X", 0, "X", ""},
2284       {OB_POSY, "Y", 0, "Y", ""},
2285       {OB_POSZ, "Z", 0, "Z", ""},
2286       {0, NULL, 0, NULL, NULL},
2287   };
2288
2289   static const EnumPropertyItem drawtype_items[] = {
2290       {OB_BOUNDBOX, "BOUNDS", 0, "Bounds", "Display the bounds of the object"},
2291       {OB_WIRE, "WIRE", 0, "Wire", "Display the object as a wireframe"},
2292       {OB_SOLID,
2293        "SOLID",
2294        0,
2295        "Solid",
2296        "Display the object as a solid (if solid drawing is enabled in the viewport)"},
2297       {OB_TEXTURE,
2298        "TEXTURED",
2299        0,
2300        "Textured",
2301        "Display the object with textures (if textures are enabled in the viewport)"},
2302       {0, NULL, 0, NULL, NULL},
2303   };
2304
2305   static const EnumPropertyItem boundtype_items[] = {
2306       {OB_BOUND_BOX, "BOX", 0, "Box", "Display bounds as box"},
2307       {OB_BOUND_SPHERE, "SPHERE", 0, "Sphere", "Display bounds as sphere"},
2308       {OB_BOUND_CYLINDER, "CYLINDER", 0, "Cylinder", "Display bounds as cylinder"},
2309       {OB_BOUND_CONE, "CONE", 0, "Cone", "Display bounds as cone"},
2310       {OB_BOUND_CAPSULE, "CAPSULE", 0, "Capsule", "Display bounds as capsule"},
2311       {0, NULL, 0, NULL, NULL},
2312   };
2313
2314   static int boundbox_dimsize[] = {8, 3};
2315
2316   srna = RNA_def_struct(brna, "Object", "ID");
2317   RNA_def_struct_ui_text(srna, "Object", "Object data-block defining an object in a scene");
2318   RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
2319   RNA_def_struct_ui_icon(srna, ICON_OBJECT_DATA);
2320
2321   prop = RNA_def_property(srna, "data", PROP_POINTER, PROP_NONE);
2322   RNA_def_property_struct_type(prop, "ID");
2323   RNA_def_property_pointer_funcs(
2324       prop, NULL, "rna_Object_data_set", "rna_Object_data_typef", "rna_Object_data_poll");
2325   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
2326   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2327   RNA_def_property_ui_text(prop, "Data", "Object data");
2328   RNA_def_property_update(prop, 0, "rna_Object_internal_update_data");
2329
2330   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2331   RNA_def_property_enum_sdna(prop, NULL, "type");
2332   RNA_def_property_enum_items(prop, rna_enum_object_type_items);
2333   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2334   RNA_def_property_ui_text(prop, "Type", "Type of Object");
2335   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ID);
2336
2337   prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
2338   RNA_def_property_enum_sdna(prop, NULL, "mode");
2339   RNA_def_property_enum_items(prop, rna_enum_object_mode_items);
2340   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2341   RNA_def_property_ui_text(prop, "Mode", "Object interaction mode");
2342
2343   /* for data access */
2344   prop = RNA_def_property(srna, "bound_box", PROP_FLOAT, PROP_NONE);
2345   RNA_def_property_multi_array(prop, 2, boundbox_dimsize);
2346   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2347   RNA_def_property_float_funcs(prop, "rna_Object_boundbox_get", NULL, NULL);
2348   RNA_def_property_ui_text(
2349       prop,
2350       "Bounding Box",
2351       "Object's bounding box in object-space coordinates, all values are -1.0 when "
2352       "not available");
2353
2354   /* parent */
2355   prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
2356   RNA_def_property_pointer_funcs(prop, NULL, "rna_Object_parent_set", NULL, NULL);
2357   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2358   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2359   RNA_def_property_ui_text(prop, "Parent", "Parent Object");
2360   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2361
2362   prop = RNA_def_property(srna, "parent_type", PROP_ENUM, PROP_NONE);
2363   RNA_def_property_enum_bitflag_sdna(prop, NULL, "partype");
2364   RNA_def_property_enum_items(prop, parent_type_items);
2365   RNA_def_property_enum_funcs(
2366       prop, NULL, "rna_Object_parent_type_set", "rna_Object_parent_type_itemf");
2367   RNA_def_property_ui_text(prop, "Parent Type", "Type of parent relation");
2368   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2369
2370   prop = RNA_def_property(srna, "parent_vertices", PROP_INT, PROP_UNSIGNED);
2371   RNA_def_property_int_sdna(prop, NULL, "par1");
2372   RNA_def_property_array(prop, 3);
2373   RNA_def_property_ui_text(
2374       prop, "Parent Vertices", "Indices of vertices in case of a vertex parenting relation");
2375   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2376
2377   prop = RNA_def_property(srna, "parent_bone", PROP_STRING, PROP_NONE);
2378   RNA_def_property_string_sdna(prop, NULL, "parsubstr");
2379   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Object_parent_bone_set");
2380   RNA_def_property_ui_text(
2381       prop, "Parent Bone", "Name of parent bone in case of a bone parenting relation");
2382   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2383
2384   /* Track and Up flags */
2385   /* XXX: these have been saved here for a bit longer (after old track was removed),
2386    *      since some other tools still refer to this */
2387   prop = RNA_def_property(srna, "track_axis", PROP_ENUM, PROP_NONE);
2388   RNA_def_property_enum_sdna(prop, NULL, "trackflag");
2389   RNA_def_property_enum_items(prop, rna_enum_object_axis_items);
2390   RNA_def_property_ui_text(
2391       prop,
2392       "Track Axis",
2393       "Axis that points in 'forward' direction (applies to InstanceFrame when "
2394       "parent 'Follow' is enabled)");
2395   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2396
2397   prop = RNA_def_property(srna, "up_axis", PROP_ENUM, PROP_NONE);
2398   RNA_def_property_enum_sdna(prop, NULL, "upflag");
2399   RNA_def_property_enum_items(prop, up_items);
2400   RNA_def_property_ui_text(
2401       prop,
2402       "Up Axis",
2403       "Axis that points in the upward direction (applies to InstanceFrame when "
2404       "parent 'Follow' is enabled)");
2405   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2406
2407   /* proxy */
2408   prop = RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
2409   RNA_def_property_ui_text(prop, "Proxy", "Library object this proxy object controls");
2410
2411   prop = RNA_def_property(srna, "proxy_collection", PROP_POINTER, PROP_NONE);
2412   RNA_def_property_pointer_sdna(prop, NULL, "proxy_group");
2413   RNA_def_property_ui_text(
2414       prop, "Proxy Collection", "Library collection duplicator object this proxy object controls");
2415
2416   /* materials */
2417   prop = RNA_def_property(srna, "material_slots", PROP_COLLECTION, PROP_NONE);
2418   RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
2419   RNA_def_property_struct_type(prop, "MaterialSlot");
2420   RNA_def_property_override_flag(prop,
2421                                  PROPOVERRIDE_OVERRIDABLE_STATIC | PROPOVERRIDE_NO_PROP_NAME);
2422   /* don't dereference pointer! */
2423   RNA_def_property_collection_funcs(
2424       prop, NULL, NULL, NULL, "rna_iterator_array_get", NULL, NULL, NULL, NULL);
2425   RNA_def_property_ui_text(prop, "Material Slots", "Material slots in the object");
2426
2427   prop = RNA_def_property(srna, "active_material", PROP_POINTER, PROP_NONE);
2428   RNA_def_property_struct_type(prop, "Material");
2429   RNA_def_property_pointer_funcs(prop,
2430                                  "rna_Object_active_material_get",
2431                                  "rna_Object_active_material_set",
2432                                  NULL,
2433                                  "rna_MaterialSlot_material_poll");
2434   RNA_def_property_flag(prop, PROP_EDITABLE);
2435   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2436   RNA_def_property_editable_func(prop, "rna_Object_active_material_editable");
2437   RNA_def_property_ui_text(prop, "Active Material", "Active material being displayed");
2438   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_MaterialSlot_update");
2439
2440   prop = RNA_def_property(srna, "active_material_index", PROP_INT, PROP_UNSIGNED);
2441   RNA_def_property_int_sdna(prop, NULL, "actcol");
2442   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2443   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2444   RNA_def_property_int_funcs(prop,
2445                              "rna_Object_active_material_index_get",
2446                              "rna_Object_active_material_index_set",
2447                              "rna_Object_active_material_index_range");
2448   RNA_def_property_ui_text(prop, "Active Material Index", "Index of active material slot");
2449   RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, "rna_MaterialIndex_update");
2450
2451   /* transform */
2452   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
2453   RNA_def_property_float_sdna(prop, NULL, "loc");
2454   RNA_def_property_editable_array_func(prop, "rna_Object_location_editable");
2455   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2456   RNA_def_property_ui_text(prop, "Location", "Location of the object");
2457   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
2458   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2459
2460   prop = RNA_def_property(srna, "rotation_quaternion", PROP_FLOAT, PROP_QUATERNION);
2461   RNA_def_property_float_sdna(prop, NULL, "quat");
2462   RNA_def_property_editable_array_func(prop, "rna_Object_rotation_4d_editable");
2463   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2464   RNA_def_property_float_array_default(prop, rna_default_quaternion);
2465   RNA_def_property_ui_text(prop, "Quaternion Rotation", "Rotation in Quaternions");
2466   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2467
2468   /* XXX: for axis-angle, it would have been nice to have 2 separate fields for UI purposes, but
2469    * having a single one is better for Keyframing and other property-management situations...
2470    */
2471   prop = RNA_def_property(srna, "rotation_axis_angle", PROP_FLOAT, PROP_AXISANGLE);
2472   RNA_def_property_array(prop, 4);
2473   RNA_def_property_float_funcs(
2474       prop, "rna_Object_rotation_axis_angle_get", "rna_Object_rotation_axis_angle_set", NULL);
2475   RNA_def_property_editable_array_func(prop, "rna_Object_rotation_4d_editable");
2476   RNA_def_property_float_array_default(prop, rna_default_axis_angle);
2477   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2478   RNA_def_property_ui_text(
2479       prop, "Axis-Angle Rotation", "Angle of Rotation for Axis-Angle rotation representation");
2480   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2481
2482   prop = RNA_def_property(srna, "rotation_euler", PROP_FLOAT, PROP_EULER);
2483   RNA_def_property_float_sdna(prop, NULL, "rot");
2484   RNA_def_property_editable_array_func(prop, "rna_Object_rotation_euler_editable");
2485   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2486   RNA_def_property_ui_text(prop, "Euler Rotation", "Rotation in Eulers");
2487   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2488
2489   prop = RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
2490   RNA_def_property_enum_sdna(prop, NULL, "rotmode");
2491   RNA_def_property_enum_items(prop, rna_enum_object_rotation_mode_items);
2492   RNA_def_property_enum_funcs(prop, NULL, "rna_Object_rotation_mode_set", NULL);
2493   RNA_def_property_ui_text(prop, "Rotation Mode", "");
2494   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2495
2496   prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
2497   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2498   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2499   RNA_def_property_editable_array_func(prop, "rna_Object_scale_editable");
2500   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 3);
2501   RNA_def_property_float_array_default(prop, rna_default_scale_3d);
2502   RNA_def_property_ui_text(prop, "Scale", "Scaling of the object");
2503   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2504
2505   prop = RNA_def_property(srna, "dimensions", PROP_FLOAT, PROP_XYZ_LENGTH);
2506   RNA_def_property_array(prop, 3);
2507   /* Only as convinient helper for py API, and conflicts with animating scale. */
2508   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2509   RNA_def_property_float_funcs(
2510       prop, "rna_Object_dimensions_get", "rna_Object_dimensions_set", NULL);
2511   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
2512   RNA_def_property_ui_text(
2513       prop,
2514       "Dimensions",
2515       "Absolute bounding box dimensions of the object (WARNING: assigning to it or "
2516       "its members mutiple consecutive times will not work correctly, "
2517       "as this needs up-to-date evaluated data)");
2518   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2519
2520   /* delta transforms */
2521   prop = RNA_def_property(srna, "delta_location", PROP_FLOAT, PROP_TRANSLATION);
2522   RNA_def_property_float_sdna(prop, NULL, "dloc");
2523   RNA_def_property_ui_text(
2524       prop, "Delta Location", "Extra translation added to the location of the object");
2525   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
2526   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2527
2528   prop = RNA_def_property(srna, "delta_rotation_euler", PROP_FLOAT, PROP_EULER);
2529   RNA_def_property_float_sdna(prop, NULL, "drot");
2530   RNA_def_property_ui_text(
2531       prop,
2532       "Delta Rotation (Euler)",
2533       "Extra rotation added to the rotation of the object (when using Euler rotations)");
2534   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2535
2536   prop = RNA_def_property(srna, "delta_rotation_quaternion", PROP_FLOAT, PROP_QUATERNION);
2537   RNA_def_property_float_sdna(prop, NULL, "dquat");
2538   RNA_def_property_float_array_default(prop, rna_default_quaternion);
2539   RNA_def_property_ui_text(
2540       prop,
2541       "Delta Rotation (Quaternion)",
2542       "Extra rotation added to the rotation of the object (when using Quaternion rotations)");
2543   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2544
2545 #  if 0 /* XXX not supported well yet... */
2546   prop = RNA_def_property(srna, "delta_rotation_axis_angle", PROP_FLOAT, PROP_AXISANGLE);
2547   /* FIXME: this is not a single field any more! (drotAxis and drotAngle) */
2548   RNA_def_property_float_sdna(prop, NULL, "dquat");
2549   RNA_def_property_float_array_default(prop, rna_default_axis_angle);
2550   RNA_def_property_ui_text(
2551       prop,
2552       "Delta Rotation (Axis Angle)",
2553       "Extra rotation added to the rotation of the object (when using Axis-Angle rotations)");
2554   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2555 #  endif
2556
2557   prop = RNA_def_property(srna, "delta_scale", PROP_FLOAT, PROP_XYZ);
2558   RNA_def_property_float_sdna(prop, NULL, "dscale");
2559   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2560   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 3);
2561   RNA_def_property_float_array_default(prop, rna_default_scale_3d);
2562   RNA_def_property_ui_text(prop, "Delta Scale", "Extra scaling added to the scale of the object");
2563   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2564
2565   /* transform locks */
2566   prop = RNA_def_property(srna, "lock_location", PROP_BOOLEAN, PROP_NONE);
2567   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_LOCX);
2568   RNA_def_property_array(prop, 3);
2569   RNA_def_property_ui_text(prop, "Lock Location", "Lock editing of location in the interface");
2570   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2571   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2572
2573   prop = RNA_def_property(srna, "lock_rotation", PROP_BOOLEAN, PROP_NONE);
2574   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTX);
2575   RNA_def_property_array(prop, 3);
2576   RNA_def_property_ui_text(prop, "Lock Rotation", "Lock editing of rotation in the interface");
2577   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2578   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2579
2580   /* XXX this is sub-optimal - it really should be included above,
2581    *     but due to technical reasons we can't do this! */
2582   prop = RNA_def_property(srna, "lock_rotation_w", PROP_BOOLEAN, PROP_NONE);
2583   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTW);
2584   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2585   RNA_def_property_ui_text(
2586       prop,
2587       "Lock Rotation (4D Angle)",
2588       "Lock editing of 'angle' component of four-component rotations in the interface");
2589   /* XXX this needs a better name */
2590   prop = RNA_def_property(srna, "lock_rotations_4d", PROP_BOOLEAN, PROP_NONE);
2591   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROT4D);
2592   RNA_def_property_ui_text(
2593       prop,
2594       "Lock Rotations (4D)",
2595       "Lock editing of four component rotations by components (instead of as Eulers)");
2596
2597   prop = RNA_def_property(srna, "lock_scale", PROP_BOOLEAN, PROP_NONE);
2598   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_SCALEX);
2599   RNA_def_property_array(prop, 3);
2600   RNA_def_property_ui_text(prop, "Lock Scale", "Lock editing of scale in the interface");
2601   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2602   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2603
2604   /* matrix */
2605   prop = RNA_def_property(srna, "matrix_world", PROP_FLOAT, PROP_MATRIX);
2606   RNA_def_property_float_sdna(prop, NULL, "obmat");
2607   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2608   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2609   RNA_def_property_ui_text(prop, "Matrix World", "Worldspace transformation matrix");
2610   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_matrix_world_update");
2611
2612   prop = RNA_def_property(srna, "matrix_local", PROP_FLOAT, PROP_MATRIX);
2613   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2614   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2615   RNA_def_property_ui_text(
2616       prop,
2617       "Local Matrix",
2618       "Parent relative transformation matrix - "
2619       "WARNING: Only takes into account 'Object' parenting, so e.g. in case of bone parenting "
2620       "you get a matrix relative to the Armature object, not to the actual parent bone");
2621   RNA_def_property_float_funcs(
2622       prop, "rna_Object_matrix_local_get", "rna_Object_matrix_local_set", NULL);
2623   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2624
2625   prop = RNA_def_property(srna, "matrix_basis", PROP_FLOAT, PROP_MATRIX);
2626   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2627   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2628   RNA_def_property_ui_text(prop,
2629                            "Input Matrix",
2630                            "Matrix access to location, rotation and scale (including deltas), "
2631                            "before constraints and parenting are applied");
2632   RNA_def_property_float_funcs(
2633       prop, "rna_Object_matrix_basis_get", "rna_Object_matrix_basis_set", NULL);
2634   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2635
2636   /*parent_inverse*/
2637   prop = RNA_def_property(srna, "matrix_parent_inverse", PROP_FLOAT, PROP_MATRIX);
2638   RNA_def_property_float_sdna(prop, NULL, "parentinv");
2639   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2640   RNA_def_property_ui_text(
2641       prop, "Matrix", "Inverse of object's parent matrix at time of parenting");
2642   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2643
2644   /* modifiers */
2645   prop = RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
2646   RNA_def_property_struct_type(prop, "Modifier");
2647   RNA_def_property_ui_text(
2648       prop, "Modifiers", "Modifiers affecting the geometric data of the object");
2649   RNA_def_property_override_funcs(prop, NULL, NULL, "rna_Object_modifiers_override_apply");
2650   RNA_def_property_override_flag(prop,
2651                                  PROPOVERRIDE_OVERRIDABLE_STATIC | PROPOVERRIDE_STATIC_INSERTION);
2652   rna_def_object_modifiers(brna, prop);
2653
2654   /* Grease Pencil modifiers. */
2655   prop = RNA_def_property(srna, "grease_pencil_modifiers", PROP_COLLECTION, PROP_NONE);
2656   RNA_def_property_collection_sdna(prop, NULL, "greasepencil_modifiers", NULL);
2657   RNA_def_property_struct_type(prop, "GpencilModifier");
2658   RNA_def_property_ui_text(
2659       prop, "Grease Pencil Modifiers", "Modifiers affecting the data of the grease pencil object");
2660   rna_def_object_grease_pencil_modifiers(brna, prop);
2661
2662   /* Shader FX. */
2663   prop = RNA_def_property(srna, "shader_effects", PROP_COLLECTION, PROP_NONE);
2664   RNA_def_property_collection_sdna(prop, NULL, "shader_fx", NULL);
2665   RNA_def_property_struct_type(prop, "ShaderFx");
2666   RNA_def_property_ui_text(prop, "Shader Effects", "Effects affecting display of object");
2667   rna_def_object_shaderfxs(brna, prop);
2668
2669   /* constraints */
2670   prop = RNA_def_property(srna, "constraints", PROP_COLLECTION, PROP_NONE);
2671   RNA_def_property_struct_type(prop, "Constraint");
2672   RNA_def_property_override_flag(prop,
2673                                  PROPOVERRIDE_OVERRIDABLE_STATIC | PROPOVERRIDE_STATIC_INSERTION);
2674   RNA_def_property_ui_text(
2675       prop, "Constraints", "Constraints affecting the transformation of the object");
2676   RNA_def_property_override_funcs(prop, NULL, NULL, "rna_Object_constraints_override_apply");
2677 #  if 0
2678   RNA_def_property_collection_funcs(
2679       prop, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "constraints__add", "constraints__remove");
2680 #  endif
2681   rna_def_object_constraints(brna, prop);
2682
2683   /* vertex groups */
2684   prop = RNA_def_property(srna, "vertex_groups", PROP_COLLECTION, PROP_NONE);
2685   RNA_def_property_collection_sdna(prop, NULL, "defbase", NULL);
2686   RNA_def_property_struct_type(prop, "VertexGroup");
2687   RNA_def_property_ui_text(prop, "Vertex Groups", "Vertex groups of the object");
2688   rna_def_object_vertex_groups(brna, prop);
2689
2690   /* face maps */
2691   prop = RNA_def_property(srna, "face_maps", PROP_COLLECTION, PROP_NONE);
2692   RNA_def_property_collection_sdna(prop, NULL, "fmaps", NULL);
2693   RNA_def_property_struct_type(prop, "FaceMap");
2694   RNA_def_property_ui_text(prop, "Face Maps", "Maps of faces of the object");
2695   rna_def_object_face_maps(brna, prop);
2696
2697   /* empty */
2698   prop = RNA_def_property(srna, "empty_display_type", PROP_ENUM, PROP_NONE);
2699   RNA_def_property_enum_sdna(prop, NULL, "empty_drawtype");
2700   RNA_def_property_enum_items(prop, rna_enum_object_empty_drawtype_items);
2701   RNA_def_property_enum_funcs(prop, NULL, "rna_Object_empty_display_type_set", NULL);
2702   RNA_def_property_ui_text(prop, "Empty Display Type", "Viewport display style for empties");
2703   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2704
2705   prop = RNA_def_property(srna, "empty_display_size", PROP_FLOAT, PROP_DISTANCE);
2706   RNA_def_property_float_sdna(prop, NULL, "empty_drawsize");
2707   RNA_def_property_range(prop, 0.0001f, 1000.0f);
2708   RNA_def_property_ui_range(prop, 0.01, 100, 1, 2);
2709   RNA_def_property_ui_text(
2710       prop, "Empty Display Size", "Size of display for empties in the viewport");
2711   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2712
2713   prop = RNA_def_property(srna, "empty_image_offset", PROP_FLOAT, PROP_NONE);
2714   RNA_def_property_float_sdna(prop, NULL, "ima_ofs");
2715   RNA_def_property_ui_text(prop, "Origin Offset", "Origin offset distance");
2716   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 0.1f, 2);
2717   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2718
2719   prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
2720   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2721   RNA_def_property_pointer_sdna(prop, NULL, "iuser");
2722   RNA_def_property_ui_text(
2723       prop,
2724       "Image User",
2725       "Parameters defining which layer, pass and frame of the image is displayed");
2726   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2727
2728   prop = RNA_def_property(srna, "empty_image_depth", PROP_ENUM, PROP_NONE);
2729   RNA_def_property_enum_items(prop, rna_enum_object_empty_image_depth_items);
2730   RNA_def_property_ui_text(
2731       prop, "Empty Image Depth", "Determine which other objects will occlude the image");
2732   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2733
2734   prop = RNA_def_property(srna, "show_empty_image_perspective", PROP_BOOLEAN, PROP_NONE);
2735   RNA_def_property_boolean_negative_sdna(
2736       prop, NULL, "empty_image_visibility_flag", OB_EMPTY_IMAGE_HIDE_PERSPECTIVE);
2737   RNA_def_property_ui_text(
2738       prop, "Display in Perspective Mode", "Display image in perspective mode");
2739   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2740
2741   prop = RNA_def_property(srna, "show_empty_image_orthographic", PROP_BOOLEAN, PROP_NONE);
2742   RNA_def_property_boolean_negative_sdna(
2743       prop, NULL, "empty_image_visibility_flag", OB_EMPTY_IMAGE_HIDE_ORTHOGRAPHIC);
2744   RNA_def_property_ui_text(
2745       prop, "Display in Orthographic Mode", "Display image in orthographic mode");
2746   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2747
2748   prop = RNA_def_property(srna, "use_empty_image_alpha", PROP_BOOLEAN, PROP_NONE);
2749   RNA_def_property_boolean_sdna(prop, NULL, "empty_image_flag", OB_EMPTY_IMAGE_USE_ALPHA_BLEND);
2750   RNA_def_property_ui_text(
2751       prop,
2752       "Use Alpha",
2753       "Use alpha blending instead of alpha test (can produce sorting artifacts)");
2754   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2755
2756   static EnumPropertyItem prop_empty_image_side_items[] = {
2757       {0, "DOUBLE_SIDED", 0, "Both", ""},
2758       {OB_EMPTY_IMAGE_HIDE_BACK, "FRONT", 0, "Front", ""},
2759       {OB_EMPTY_IMAGE_HIDE_FRONT, "BACK", 0, "Back", ""},
2760       {0, NULL, 0, NULL, NULL},
2761   };
2762   prop = RNA_def_property(srna, "empty_image_side", PROP_ENUM, PROP_NONE);
2763   RNA_def_property_enum_bitflag_sdna(prop, NULL, "empty_image_visibility_flag");
2764   RNA_def_property_enum_items(prop, prop_empty_image_side_items);
2765   RNA_def_property_ui_text(prop, "Empty Image Side", "Show front/back side");
2766   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2767
2768   /* render */
2769   prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
2770   RNA_def_property_int_sdna(prop, NULL, "index");
2771   RNA_def_property_ui_text(
2772       prop, "Pass Index", "Index number for the \"Object Index\" render pass");
2773   RNA_def_property_update(prop, NC_OBJECT, "rna_Object_internal_update_draw");
2774
2775   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
2776   RNA_def_property_ui_text(
2777       prop, "Color", "Object color and alpha, used when faces have the ObColor mode enabled");
2778   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2779
2780   /* physics */
2781   prop = RNA_def_property(srna, "field", PROP_POINTER, PROP_NONE);
2782   RNA_def_property_pointer_sdna(prop, NULL, "pd");
2783   RNA_def_property_struct_type(prop, "FieldSettings");
2784   RNA_def_property_pointer_funcs(prop, "rna_Object_field_get", NULL, NULL, NULL);
2785   RNA_def_property_ui_text(
2786       prop, "Field Settings", "Settings for using the object as a field in physics simulation");
2787
2788   prop = RNA_def_property(srna, "collision", PROP_POINTER, PROP_NONE);
2789   RNA_def_property_pointer_sdna(prop, NULL, "pd");
2790   RNA_def_property_struct_type(prop, "CollisionSettings");
2791   RNA_def_property_pointer_funcs(prop, "rna_Object_collision_get", NULL, NULL, NULL);
2792   RNA_def_property_ui_text(prop,
2793                            "Collision Settings",
2794                            "Settings for using the object as a collider in physics simulation");
2795
2796   prop = RNA_def_property(srna, "soft_body", PROP_POINTER, PROP_NONE);
2797   RNA_def_property_pointer_sdna(prop, NULL, "soft");
2798   RNA_def_property_struct_type(prop, "SoftBodySettings");
2799   RNA_def_property_ui_text(prop, "Soft Body Settings", "Settings for soft body simulation");
2800
2801   prop = RNA_def_property(srna, "particle_systems", PROP_COLLECTION, PROP_NONE);
2802   RNA_def_property_collection_sdna(prop, NULL, "particlesystem", NULL);
2803   RNA_def_property_struct_type(prop, "ParticleSystem");
2804   RNA_def_property_ui_text(prop, "Particle Systems", "Particle systems emitted from the object");
2805   rna_def_object_particle_systems(brna, prop);
2806
2807   prop = RNA_def_property(srna, "rigid_body", PROP_POINTER, PROP_NONE);
2808   RNA_def_property_pointer_sdna(prop, NULL, "rigidbody_object");
2809   RNA_def_property_struct_type(prop, "RigidBodyObject");
2810   RNA_def_property_ui_text(prop, "Rigid Body Settings", "Settings for rigid body simulation");
2811
2812   prop = RNA_def_property(srna, "rigid_body_constraint", PROP_POINTER, PROP_NONE);
2813   RNA_def_property_pointer_sdna(prop, NULL, "rigidbody_constraint");
2814   RNA_def_property_struct_type(prop, "RigidBodyConstraint");
2815   RNA_def_property_ui_text(prop, "Rigid Body Constraint", "Constraint constraining rigid bodies");
2816
2817   /* restrict */
2818   prop = RNA_def_property(srna, "hide_viewport", PROP_BOOLEAN, PROP_NONE);
2819   RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", OB_RESTRICT_VIEWPORT);
2820   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2821   RNA_def_property_ui_text(prop, "Disable in Viewports", "Globally disable in viewports");
2822   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_hide_update");
2823
2824   prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
2825   RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", OB_RESTRICT_SELECT);
2826   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2827   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2828   RNA_def_property_ui_text(prop, "Disable Selection", "Disable selection in viewport");
2829   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_hide_update");
2830
2831   prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
2832   RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", OB_RESTRICT_RENDER);
2833   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2834   RNA_def_property_ui_text(prop, "Disable in Renders", "Globally disable in renders");
2835   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_hide_update");
2836
2837   prop = RNA_def_property(srna, "show_instancer_for_render", PROP_BOOLEAN, PROP_NONE);
2838   RNA_def_property_boolean_sdna(prop, NULL, "duplicator_visibility_flag", OB_DUPLI_FLAG_RENDER);
2839   RNA_def_property_ui_text(prop, "Render Instancer", "Make instancer visible when rendering");
2840
2841   prop = RNA_def_property(srna, "show_instancer_for_viewport", PROP_BOOLEAN, PROP_NONE);
2842   RNA_def_property_boolean_sdna(prop, NULL, "duplicator_visibility_flag", OB_DUPLI_FLAG_VIEWPORT);
2843   RNA_def_property_ui_text(prop, "Display Instancer", "Make instancer visible in the viewport");
2844
2845   /* anim */
2846   rna_def_animdata_common(srna);
2847
2848   rna_def_animviz_common(srna);
2849   rna_def_motionpath_common(srna);
2850
2851   /* instancing */
2852   prop = RNA_def_property(srna, "instance_type", PROP_ENUM, PROP_NONE);
2853   RNA_def_property_enum_bitflag_sdna(prop, NULL, "transflag");
2854   RNA_def_property_enum_items(prop, instance_items);
2855   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Object_instance_type_itemf");
2856   RNA_def_property_ui_text(prop, "Instance Type", "If not None, object instancing method to use");
2857   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2858
2859   prop = RNA_def_property(srna, "use_instance_vertices_rotation", PROP_BOOLEAN, PROP_NONE);
2860   RNA_def_property_boolean_sdna(prop, NULL, "transflag", OB_DUPLIROT);
2861   RNA_def_property_ui_text(
2862       prop, "Orient with Normals", "Rotate instance according to vertex normal");
2863   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2864
2865   prop = RNA_def_property(srna, "use_instance_faces_scale", PROP_BOOLEAN, PROP_NONE);
2866   RNA_def_property_boolean_sdna(prop, NULL, "transflag", OB_DUPLIFACES_SCALE);
2867   RNA_def_property_ui_text(prop, "Scale to Face Sizes", "Scale instance based on face size");
2868   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2869
2870   prop = RNA_def_property(srna, "instance_faces_scale", PROP_FLOAT, PROP_NONE);
2871   RNA_def_property_float_sdna(prop, NULL, "instance_faces_scale");
2872   RNA_def_property_range(prop, 0.001f, 10000.0f);
2873   RNA_def_property_ui_text(prop, "Instance Faces Scale", "Scale the face instance objects");
2874   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2875
2876   prop = RNA_def_property(srna, "instance_collection", PROP_POINTER, PROP_NONE);
2877   RNA_def_property_struct_type(prop, "Collection");
2878   RNA_def_property_pointer_sdna(prop, NULL, "instance_collection");
2879   RNA_def_property_flag(prop, PROP_EDITABLE);
2880   RNA_def_property_pointer_funcs(prop, NULL, "rna_Object_dup_collection_set", NULL, NULL);
2881   RNA_def_property_ui_text(prop, "Instance Collection", "Instance an existing collection");
2882   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2883
2884   prop = RNA_def_property(srna, "is_instancer", PROP_BOOLEAN, PROP_NONE);
2885   RNA_def_property_boolean_sdna(prop, NULL, "transflag", OB_DUPLI);
2886   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2887
2888   /* drawing */
2889   prop = RNA_def_property(srna, "display_type", PROP_ENUM, PROP_NONE);
2890   RNA_def_property_enum_sdna(prop, NULL, "dt");
2891   RNA_def_property_enum_items(prop, drawtype_items);
2892   RNA_def_property_ui_text(prop, "Display As", "How to display object in viewport");
2893   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2894
2895   prop = RNA_def_property(srna, "show_bounds", PROP_BOOLEAN, PROP_NONE);
2896   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWBOUNDOX);
2897   RNA_def_property_ui_text(prop, "Display Bounds", "Display the object's bounds");
2898   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2899
2900   prop = RNA_def_property(srna, "display_bounds_type", PROP_ENUM, PROP_NONE);
2901   RNA_def_property_enum_sdna(prop, NULL, "boundtype");
2902   RNA_def_property_enum_items(prop, boundtype_items);
2903   RNA_def_property_ui_text(prop, "Display Bounds Type", "Object boundary display type");
2904   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2905
2906   prop = RNA_def_property(srna, "show_name", PROP_BOOLEAN, PROP_NONE);
2907   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWNAME);
2908   RNA_def_property_ui_text(prop, "Display Name", "Display the object's name");
2909   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2910
2911   prop = RNA_def_property(srna, "show_axis", PROP_BOOLEAN, PROP_NONE);
2912   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_AXIS);
2913   RNA_def_property_ui_text(prop, "Display Axes", "Display the object's origin and axes");
2914   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2915
2916   prop = RNA_def_property(srna, "show_texture_space", PROP_BOOLEAN, PROP_NONE);
2917   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_TEXSPACE);
2918   RNA_def_property_ui_text(prop, "Display Texture Space", "Display the object's texture space");
2919   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2920
2921   prop = RNA_def_property(srna, "show_wire", PROP_BOOLEAN, PROP_NONE);
2922   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWWIRE);
2923   RNA_def_property_ui_text(prop, "Display Wire", "Add the object's wireframe over solid drawing");
2924   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2925
2926   prop = RNA_def_property(srna, "show_all_edges", PROP_BOOLEAN, PROP_NONE);
2927   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAW_ALL_EDGES);
2928   RNA_def_property_ui_text(prop, "Display All Edges", "Display all edges for mesh objects");
2929   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2930
2931   prop = RNA_def_property(srna, "show_transparent", PROP_BOOLEAN, PROP_NONE);
2932   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWTRANSP);
2933   RNA_def_property_ui_text(
2934       prop, "Display Transparent", "Display material transparency in the object");
2935   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2936
2937   prop = RNA_def_property(srna, "show_in_front", PROP_BOOLEAN, PROP_NONE);
2938   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWXRAY);
2939   RNA_def_property_ui_text(prop, "In Front", "Make the object draw in front of others");
2940   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2941
2942   /* pose */
2943   prop = RNA_def_property(srna, "pose_library", PROP_POINTER, PROP_NONE);
2944   RNA_def_property_pointer_sdna(prop, NULL, "poselib");
2945   RNA_def_property_struct_type(prop, "Action");
2946   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
2947   RNA_def_property_ui_text(prop, "Pose Library", "Action used as a pose library for armatures");
2948
2949   prop = RNA_def_property(srna, "pose", PROP_POINTER, PROP_NONE);
2950   RNA_def_property_pointer_sdna(prop, NULL, "pose");
2951   RNA_def_property_struct_type(prop, "Pose");
2952   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
2953   RNA_def_property_ui_text(prop, "Pose", "Current pose for armatures");
2954
2955   /* shape keys */
2956   prop = RNA_def_property(srna, "show_only_shape_key", PROP_BOOLEAN, PROP_NONE);
2957   RNA_def_property_boolean_sdna(prop, NULL, "shapeflag", OB_SHAPE_LOCK);
2958   RNA_def_property_ui_text(
2959       prop, "Shape Key Lock", "Always show the current Shape for this Object");
2960   RNA_def_property_ui_icon(prop, ICON_UNPINNED, 1);
2961   RNA_def_property_update(prop, 0, "rna_Object_internal_update_data");
2962
2963   prop = RNA_def_property(srna, "use_shape_key_edit_mode", PROP_BOOLEAN, PROP_NONE);
2964   RNA_def_property_boolean_sdna(prop, NULL, "shapeflag", OB_SHAPE_EDIT_MODE);
2965   RNA_def_property_ui_text(
2966       prop, "Shape Key Edit Mode", "Apply shape keys in edit mode (for Meshes only)");
2967   RNA_def_property_ui_icon(prop, ICON_EDITMODE_HLT, 0);
2968   RNA_def_property_update(prop, 0, "rna_Object_internal_update_data");
2969
2970   prop = RNA_def_property(srna, "active_shape_key", PROP_POINTER, PROP_NONE);
2971   RNA_def_property_struct_type(prop, "ShapeKey");
2972   RNA_def_property_pointer_funcs(prop, "rna_Object_active_shape_key_get", NULL, NULL, NULL);
2973   RNA_def_property_ui_text(prop, "Active Shape Key", "Current shape key");
2974
2975   prop = RNA_def_property(srna, "active_shape_key_index", PROP_INT, PROP_NONE);
2976   RNA_def_property_int_sdna(prop, NULL, "shapenr");
2977   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
2978   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* XXX this is really unpredictable... */
2979   RNA_def_property_int_funcs(prop,
2980                              "rna_Object_active_shape_key_index_get",
2981                              "rna_Object_active_shape_key_index_set",
2982                              "rna_Object_active_shape_key_index_range");
2983   RNA_def_property_ui_text(prop, "Active Shape Key Index", "Current shape key index");
2984   RNA_def_property_update(prop, 0, "rna_Object_active_shape_update");
2985
2986   /* sculpt */
2987   prop = RNA_def_property(srna, "use_dynamic_topology_sculpting", PROP_BOOLEAN, PROP_NONE);
2988   RNA_def_property_boolean_funcs(prop, "rna_Object_use_dynamic_topology_sculpting_get", NULL);
2989   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2990   RNA_def_property_ui_text(prop, "Dynamic Topology Sculpting", NULL);
2991
2992   /* Base Settings */
2993   prop = RNA_def_property(srna, "is_from_instancer", PROP_BOOLEAN, PROP_NONE);
2994   RNA_def_property_boolean_sdna(prop, NULL, "base_flag", BASE_FROM_DUPLI);
2995   RNA_def_property_ui_text(prop, "Base from Instancer", "Object comes from a instancer");
2996   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2997
2998   prop = RNA_def_property(srna, "is_from_set", PROP_BOOLEAN, PROP_NONE);
2999   RNA_def_property_boolean_sdna(prop, NULL, "base_flag", BASE_FROM_SET);
3000   RNA_def_property_ui_text(prop, "Base from Set", "Object comes from a background set");
3001   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3002
3003   /* Object Display */
3004   prop = RNA_def_property(srna, "display", PROP_POINTER, PROP_NONE);
3005   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3006   RNA_def_property_struct_type(prop, "ObjectDisplay");
3007   RNA_def_property_pointer_funcs(prop, "rna_Object_display_get", NULL, NULL, NULL);
3008   RNA_def_property_ui_text(prop, "Object Display", "Object display settings for 3d viewport");
3009
3010   RNA_api_object(srna);
3011 }
3012
3013 void RNA_def_object(BlenderRNA *brna)
3014 {
3015   rna_def_object(brna);
3016
3017   RNA_define_animate_sdna(false);
3018   rna_def_vertex_group(brna);
3019   rna_def_face_map(brna);
3020   rna_def_material_slot(brna);
3021   rna_def_object_display(brna);
3022   RNA_define_animate_sdna(true);
3023 }
3024
3025 #endif