GPencil: Fix usability problem with curve control points apart
[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 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 collection 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   }
705   else {
706     value[0] = '\0';
707   }
708 }
709
710 int rna_object_vgroup_name_index_length(PointerRNA *ptr, int index)
711 {
712   Object *ob = (Object *)ptr->id.data;
713   bDeformGroup *dg;
714
715   dg = BLI_findlink(&ob->defbase, index - 1);
716   return (dg) ? strlen(dg->name) : 0;
717 }
718
719 void rna_object_vgroup_name_index_set(PointerRNA *ptr, const char *value, short *index)
720 {
721   Object *ob = (Object *)ptr->id.data;
722   *index = defgroup_name_index(ob, value) + 1;
723 }
724
725 void rna_object_vgroup_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
726 {
727   Object *ob = (Object *)ptr->id.data;
728   bDeformGroup *dg = defgroup_find_name(ob, value);
729   if (dg) {
730     /* No need for BLI_strncpy_utf8, since this matches an existing group. */
731     BLI_strncpy(result, value, maxlen);
732     return;
733   }
734
735   result[0] = '\0';
736 }
737
738 static void rna_FaceMap_name_set(PointerRNA *ptr, const char *value)
739 {
740   Object *ob = (Object *)ptr->id.data;
741   bFaceMap *fmap = (bFaceMap *)ptr->data;
742   BLI_strncpy_utf8(fmap->name, value, sizeof(fmap->name));
743   BKE_object_facemap_unique_name(ob, fmap);
744 }
745
746 static int rna_FaceMap_index_get(PointerRNA *ptr)
747 {
748   Object *ob = (Object *)ptr->id.data;
749
750   return BLI_findindex(&ob->fmaps, ptr->data);
751 }
752
753 static PointerRNA rna_Object_active_face_map_get(PointerRNA *ptr)
754 {
755   Object *ob = (Object *)ptr->id.data;
756   return rna_pointer_inherit_refine(ptr, &RNA_FaceMap, BLI_findlink(&ob->fmaps, ob->actfmap - 1));
757 }
758
759 static int rna_Object_active_face_map_index_get(PointerRNA *ptr)
760 {
761   Object *ob = (Object *)ptr->id.data;
762   return ob->actfmap - 1;
763 }
764
765 static void rna_Object_active_face_map_index_set(PointerRNA *ptr, int value)
766 {
767   Object *ob = (Object *)ptr->id.data;
768   ob->actfmap = value + 1;
769 }
770
771 static void rna_Object_active_face_map_index_range(
772     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
773 {
774   Object *ob = (Object *)ptr->id.data;
775
776   *min = 0;
777   *max = max_ii(0, BLI_listbase_count(&ob->fmaps) - 1);
778 }
779
780 void rna_object_BKE_object_facemap_name_index_get(PointerRNA *ptr, char *value, int index)
781 {
782   Object *ob = (Object *)ptr->id.data;
783   bFaceMap *fmap;
784
785   fmap = BLI_findlink(&ob->fmaps, index - 1);
786
787   if (fmap) {
788     BLI_strncpy(value, fmap->name, sizeof(fmap->name));
789   }
790   else {
791     value[0] = '\0';
792   }
793 }
794
795 int rna_object_BKE_object_facemap_name_index_length(PointerRNA *ptr, int index)
796 {
797   Object *ob = (Object *)ptr->id.data;
798   bFaceMap *fmap;
799
800   fmap = BLI_findlink(&ob->fmaps, index - 1);
801   return (fmap) ? strlen(fmap->name) : 0;
802 }
803
804 void rna_object_BKE_object_facemap_name_index_set(PointerRNA *ptr, const char *value, short *index)
805 {
806   Object *ob = (Object *)ptr->id.data;
807   *index = BKE_object_facemap_name_index(ob, value) + 1;
808 }
809
810 void rna_object_fmap_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
811 {
812   Object *ob = (Object *)ptr->id.data;
813   bFaceMap *fmap = BKE_object_facemap_find_name(ob, value);
814   if (fmap) {
815     /* No need for BLI_strncpy_utf8, since this matches an existing group. */
816     BLI_strncpy(result, value, maxlen);
817     return;
818   }
819
820   result[0] = '\0';
821 }
822
823 void rna_object_uvlayer_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
824 {
825   Object *ob = (Object *)ptr->id.data;
826   Mesh *me;
827   CustomDataLayer *layer;
828   int a;
829
830   if (ob->type == OB_MESH && ob->data) {
831     me = (Mesh *)ob->data;
832
833     for (a = 0; a < me->ldata.totlayer; a++) {
834       layer = &me->ldata.layers[a];
835
836       if (layer->type == CD_MLOOPUV && STREQ(layer->name, value)) {
837         BLI_strncpy(result, value, maxlen);
838         return;
839       }
840     }
841   }
842
843   result[0] = '\0';
844 }
845
846 void rna_object_vcollayer_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
847 {
848   Object *ob = (Object *)ptr->id.data;
849   Mesh *me;
850   CustomDataLayer *layer;
851   int a;
852
853   if (ob->type == OB_MESH && ob->data) {
854     me = (Mesh *)ob->data;
855
856     for (a = 0; a < me->fdata.totlayer; a++) {
857       layer = &me->fdata.layers[a];
858
859       if (layer->type == CD_MCOL && STREQ(layer->name, value)) {
860         BLI_strncpy(result, value, maxlen);
861         return;
862       }
863     }
864   }
865
866   result[0] = '\0';
867 }
868
869 static int rna_Object_active_material_index_get(PointerRNA *ptr)
870 {
871   Object *ob = (Object *)ptr->id.data;
872   return MAX2(ob->actcol - 1, 0);
873 }
874
875 static void rna_Object_active_material_index_set(PointerRNA *ptr, int value)
876 {
877   Object *ob = (Object *)ptr->id.data;
878   ob->actcol = value + 1;
879
880   if (ob->type == OB_MESH) {
881     Mesh *me = ob->data;
882
883     if (me->edit_mesh) {
884       me->edit_mesh->mat_nr = value;
885     }
886   }
887 }
888
889 static void rna_Object_active_material_index_range(
890     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
891 {
892   Object *ob = (Object *)ptr->id.data;
893   *min = 0;
894   *max = max_ii(ob->totcol - 1, 0);
895 }
896
897 /* returns active base material */
898 static PointerRNA rna_Object_active_material_get(PointerRNA *ptr)
899 {
900   Object *ob = (Object *)ptr->id.data;
901   Material *ma;
902
903   ma = (ob->totcol) ? give_current_material(ob, ob->actcol) : NULL;
904   return rna_pointer_inherit_refine(ptr, &RNA_Material, ma);
905 }
906
907 static void rna_Object_active_material_set(PointerRNA *ptr,
908                                            PointerRNA value,
909                                            struct ReportList *UNUSED(reports))
910 {
911   Object *ob = (Object *)ptr->id.data;
912
913   DEG_id_tag_update(value.data, 0);
914   BLI_assert(BKE_id_is_in_global_main(&ob->id));
915   BLI_assert(BKE_id_is_in_global_main(value.data));
916   assign_material(G_MAIN, ob, value.data, ob->actcol, BKE_MAT_ASSIGN_EXISTING);
917
918   if (ob && ob->type == OB_GPENCIL) {
919     /* notifying material property in topbar */
920     WM_main_add_notifier(NC_SPACE | ND_SPACE_VIEW3D, NULL);
921   }
922 }
923
924 static int rna_Object_active_material_editable(PointerRNA *ptr, const char **UNUSED(r_info))
925 {
926   Object *ob = (Object *)ptr->id.data;
927   bool is_editable;
928
929   if ((ob->matbits == NULL) || (ob->actcol == 0) || ob->matbits[ob->actcol - 1]) {
930     is_editable = !ID_IS_LINKED(ob);
931   }
932   else {
933     is_editable = ob->data ? !ID_IS_LINKED(ob->data) : false;
934   }
935
936   return is_editable ? PROP_EDITABLE : 0;
937 }
938
939 static void rna_Object_active_particle_system_index_range(
940     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
941 {
942   Object *ob = (Object *)ptr->id.data;
943   *min = 0;
944   *max = max_ii(0, BLI_listbase_count(&ob->particlesystem) - 1);
945 }
946
947 static int rna_Object_active_particle_system_index_get(PointerRNA *ptr)
948 {
949   Object *ob = (Object *)ptr->id.data;
950   return psys_get_current_num(ob);
951 }
952
953 static void rna_Object_active_particle_system_index_set(PointerRNA *ptr, int value)
954 {
955   Object *ob = (Object *)ptr->id.data;
956   psys_set_current_num(ob, value);
957 }
958
959 static void rna_Object_particle_update(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
960 {
961   /* TODO: Disabled for now, because bContext is not available. */
962 #  if 0
963   Object *ob = (Object *)ptr->id.data;
964   PE_current_changed(NULL, scene, ob);
965 #  else
966   (void)scene;
967   (void)ptr;
968 #  endif
969 }
970
971 /* rotation - axis-angle */
972 static void rna_Object_rotation_axis_angle_get(PointerRNA *ptr, float *value)
973 {
974   Object *ob = ptr->data;
975
976   /* for now, assume that rotation mode is axis-angle */
977   value[0] = ob->rotAngle;
978   copy_v3_v3(&value[1], ob->rotAxis);
979 }
980
981 /* rotation - axis-angle */
982 static void rna_Object_rotation_axis_angle_set(PointerRNA *ptr, const float *value)
983 {
984   Object *ob = ptr->data;
985
986   /* for now, assume that rotation mode is axis-angle */
987   ob->rotAngle = value[0];
988   copy_v3_v3(ob->rotAxis, &value[1]);
989
990   /* TODO: validate axis? */
991 }
992
993 static void rna_Object_rotation_mode_set(PointerRNA *ptr, int value)
994 {
995   Object *ob = ptr->data;
996
997   /* use API Method for conversions... */
998   BKE_rotMode_change_values(
999       ob->quat, ob->rot, ob->rotAxis, &ob->rotAngle, ob->rotmode, (short)value);
1000
1001   /* finally, set the new rotation type */
1002   ob->rotmode = value;
1003 }
1004
1005 static void rna_Object_dimensions_get(PointerRNA *ptr, float *value)
1006 {
1007   Object *ob = ptr->data;
1008   BKE_object_dimensions_get(ob, value);
1009 }
1010
1011 static void rna_Object_dimensions_set(PointerRNA *ptr, const float *value)
1012 {
1013   Object *ob = ptr->data;
1014   BKE_object_dimensions_set(ob, value, 0);
1015 }
1016
1017 static int rna_Object_location_editable(PointerRNA *ptr, int index)
1018 {
1019   Object *ob = (Object *)ptr->data;
1020
1021   /* only if the axis in question is locked, not editable... */
1022   if ((index == 0) && (ob->protectflag & OB_LOCK_LOCX)) {
1023     return 0;
1024   }
1025   else if ((index == 1) && (ob->protectflag & OB_LOCK_LOCY)) {
1026     return 0;
1027   }
1028   else if ((index == 2) && (ob->protectflag & OB_LOCK_LOCZ)) {
1029     return 0;
1030   }
1031   else {
1032     return PROP_EDITABLE;
1033   }
1034 }
1035
1036 static int rna_Object_scale_editable(PointerRNA *ptr, int index)
1037 {
1038   Object *ob = (Object *)ptr->data;
1039
1040   /* only if the axis in question is locked, not editable... */
1041   if ((index == 0) && (ob->protectflag & OB_LOCK_SCALEX)) {
1042     return 0;
1043   }
1044   else if ((index == 1) && (ob->protectflag & OB_LOCK_SCALEY)) {
1045     return 0;
1046   }
1047   else if ((index == 2) && (ob->protectflag & OB_LOCK_SCALEZ)) {
1048     return 0;
1049   }
1050   else {
1051     return PROP_EDITABLE;
1052   }
1053 }
1054
1055 static int rna_Object_rotation_euler_editable(PointerRNA *ptr, int index)
1056 {
1057   Object *ob = (Object *)ptr->data;
1058
1059   /* only if the axis in question is locked, not editable... */
1060   if ((index == 0) && (ob->protectflag & OB_LOCK_ROTX)) {
1061     return 0;
1062   }
1063   else if ((index == 1) && (ob->protectflag & OB_LOCK_ROTY)) {
1064     return 0;
1065   }
1066   else if ((index == 2) && (ob->protectflag & OB_LOCK_ROTZ)) {
1067     return 0;
1068   }
1069   else {
1070     return PROP_EDITABLE;
1071   }
1072 }
1073
1074 static int rna_Object_rotation_4d_editable(PointerRNA *ptr, int index)
1075 {
1076   Object *ob = (Object *)ptr->data;
1077
1078   /* only consider locks if locking components individually... */
1079   if (ob->protectflag & OB_LOCK_ROT4D) {
1080     /* only if the axis in question is locked, not editable... */
1081     if ((index == 0) && (ob->protectflag & OB_LOCK_ROTW)) {
1082       return 0;
1083     }
1084     else if ((index == 1) && (ob->protectflag & OB_LOCK_ROTX)) {
1085       return 0;
1086     }
1087     else if ((index == 2) && (ob->protectflag & OB_LOCK_ROTY)) {
1088       return 0;
1089     }
1090     else if ((index == 3) && (ob->protectflag & OB_LOCK_ROTZ)) {
1091       return 0;
1092     }
1093   }
1094
1095   return PROP_EDITABLE;
1096 }
1097
1098 static int rna_MaterialSlot_material_editable(PointerRNA *ptr, const char **UNUSED(r_info))
1099 {
1100   Object *ob = (Object *)ptr->id.data;
1101   const int index = (Material **)ptr->data - ob->mat;
1102   bool is_editable;
1103
1104   if ((ob->matbits == NULL) || ob->matbits[index]) {
1105     is_editable = !ID_IS_LINKED(ob);
1106   }
1107   else {
1108     is_editable = ob->data ? !ID_IS_LINKED(ob->data) : false;
1109   }
1110
1111   return is_editable ? PROP_EDITABLE : 0;
1112 }
1113
1114 static PointerRNA rna_MaterialSlot_material_get(PointerRNA *ptr)
1115 {
1116   Object *ob = (Object *)ptr->id.data;
1117   Material *ma;
1118   const int index = (Material **)ptr->data - ob->mat;
1119
1120   ma = give_current_material(ob, index + 1);
1121   return rna_pointer_inherit_refine(ptr, &RNA_Material, ma);
1122 }
1123
1124 static void rna_MaterialSlot_material_set(PointerRNA *ptr,
1125                                           PointerRNA value,
1126                                           struct ReportList *UNUSED(reports))
1127 {
1128   Object *ob = (Object *)ptr->id.data;
1129   int index = (Material **)ptr->data - ob->mat;
1130
1131   BLI_assert(BKE_id_is_in_global_main(&ob->id));
1132   BLI_assert(BKE_id_is_in_global_main(value.data));
1133   assign_material(G_MAIN, ob, value.data, index + 1, BKE_MAT_ASSIGN_EXISTING);
1134 }
1135
1136 static bool rna_MaterialSlot_material_poll(PointerRNA *ptr, PointerRNA value)
1137 {
1138   Object *ob = (Object *)ptr->id.data;
1139   Material *ma = (Material *)value.data;
1140
1141   if (ob->type == OB_GPENCIL) {
1142     /* GP Materials only */
1143     return (ma->gp_style != NULL);
1144   }
1145   else {
1146     /* Everything except GP materials */
1147     return (ma->gp_style == NULL);
1148   }
1149 }
1150
1151 static int rna_MaterialSlot_link_get(PointerRNA *ptr)
1152 {
1153   Object *ob = (Object *)ptr->id.data;
1154   int index = (Material **)ptr->data - ob->mat;
1155
1156   return ob->matbits[index] != 0;
1157 }
1158
1159 static void rna_MaterialSlot_link_set(PointerRNA *ptr, int value)
1160 {
1161   Object *ob = (Object *)ptr->id.data;
1162   int index = (Material **)ptr->data - ob->mat;
1163
1164   if (value) {
1165     ob->matbits[index] = 1;
1166     /* ob->colbits |= (1 << index); */ /* DEPRECATED */
1167   }
1168   else {
1169     ob->matbits[index] = 0;
1170     /* ob->colbits &= ~(1 << index); */ /* DEPRECATED */
1171   }
1172 }
1173
1174 static int rna_MaterialSlot_name_length(PointerRNA *ptr)
1175 {
1176   Object *ob = (Object *)ptr->id.data;
1177   Material *ma;
1178   int index = (Material **)ptr->data - ob->mat;
1179
1180   ma = give_current_material(ob, index + 1);
1181
1182   if (ma) {
1183     return strlen(ma->id.name + 2);
1184   }
1185
1186   return 0;
1187 }
1188
1189 static void rna_MaterialSlot_name_get(PointerRNA *ptr, char *str)
1190 {
1191   Object *ob = (Object *)ptr->id.data;
1192   Material *ma;
1193   int index = (Material **)ptr->data - ob->mat;
1194
1195   ma = give_current_material(ob, index + 1);
1196
1197   if (ma) {
1198     strcpy(str, ma->id.name + 2);
1199   }
1200   else {
1201     str[0] = '\0';
1202   }
1203 }
1204
1205 static void rna_MaterialSlot_update(Main *bmain, Scene *scene, PointerRNA *ptr)
1206 {
1207   rna_Object_internal_update(bmain, scene, ptr);
1208
1209   WM_main_add_notifier(NC_OBJECT | ND_OB_SHADING, ptr->id.data);
1210   WM_main_add_notifier(NC_MATERIAL | ND_SHADING_LINKS, NULL);
1211   DEG_relations_tag_update(bmain);
1212 }
1213
1214 static char *rna_MaterialSlot_path(PointerRNA *ptr)
1215 {
1216   Object *ob = (Object *)ptr->id.data;
1217   int index = (Material **)ptr->data - ob->mat;
1218
1219   return BLI_sprintfN("material_slots[%d]", index);
1220 }
1221
1222 static PointerRNA rna_Object_display_get(PointerRNA *ptr)
1223 {
1224   return rna_pointer_inherit_refine(ptr, &RNA_ObjectDisplay, ptr->data);
1225 }
1226
1227 static char *rna_ObjectDisplay_path(PointerRNA *UNUSED(ptr))
1228 {
1229   return BLI_strdup("display");
1230 }
1231
1232 static PointerRNA rna_Object_active_particle_system_get(PointerRNA *ptr)
1233 {
1234   Object *ob = (Object *)ptr->id.data;
1235   ParticleSystem *psys = psys_get_current(ob);
1236   return rna_pointer_inherit_refine(ptr, &RNA_ParticleSystem, psys);
1237 }
1238
1239 static void rna_Object_active_shape_key_index_range(
1240     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
1241 {
1242   Object *ob = (Object *)ptr->id.data;
1243   Key *key = BKE_key_from_object(ob);
1244
1245   *min = 0;
1246   if (key) {
1247     *max = BLI_listbase_count(&key->block) - 1;
1248     if (*max < 0) {
1249       *max = 0;
1250     }
1251   }
1252   else {
1253     *max = 0;
1254   }
1255 }
1256
1257 static int rna_Object_active_shape_key_index_get(PointerRNA *ptr)
1258 {
1259   Object *ob = (Object *)ptr->id.data;
1260
1261   return MAX2(ob->shapenr - 1, 0);
1262 }
1263
1264 static void rna_Object_active_shape_key_index_set(PointerRNA *ptr, int value)
1265 {
1266   Object *ob = (Object *)ptr->id.data;
1267
1268   ob->shapenr = value + 1;
1269 }
1270
1271 static PointerRNA rna_Object_active_shape_key_get(PointerRNA *ptr)
1272 {
1273   Object *ob = (Object *)ptr->id.data;
1274   Key *key = BKE_key_from_object(ob);
1275   KeyBlock *kb;
1276   PointerRNA keyptr;
1277
1278   if (key == NULL) {
1279     return PointerRNA_NULL;
1280   }
1281
1282   kb = BLI_findlink(&key->block, ob->shapenr - 1);
1283   RNA_pointer_create((ID *)key, &RNA_ShapeKey, kb, &keyptr);
1284   return keyptr;
1285 }
1286
1287 static PointerRNA rna_Object_field_get(PointerRNA *ptr)
1288 {
1289   Object *ob = (Object *)ptr->id.data;
1290
1291   /* weak */
1292   if (!ob->pd) {
1293     ob->pd = BKE_partdeflect_new(0);
1294   }
1295
1296   return rna_pointer_inherit_refine(ptr, &RNA_FieldSettings, ob->pd);
1297 }
1298
1299 static PointerRNA rna_Object_collision_get(PointerRNA *ptr)
1300 {
1301   Object *ob = (Object *)ptr->id.data;
1302
1303   if (ob->type != OB_MESH) {
1304     return PointerRNA_NULL;
1305   }
1306
1307   /* weak */
1308   if (!ob->pd) {
1309     ob->pd = BKE_partdeflect_new(0);
1310   }
1311
1312   return rna_pointer_inherit_refine(ptr, &RNA_CollisionSettings, ob->pd);
1313 }
1314
1315 static PointerRNA rna_Object_active_constraint_get(PointerRNA *ptr)
1316 {
1317   Object *ob = (Object *)ptr->id.data;
1318   bConstraint *con = BKE_constraints_active_get(&ob->constraints);
1319   return rna_pointer_inherit_refine(ptr, &RNA_Constraint, con);
1320 }
1321
1322 static void rna_Object_active_constraint_set(PointerRNA *ptr,
1323                                              PointerRNA value,
1324                                              struct ReportList *UNUSED(reports))
1325 {
1326   Object *ob = (Object *)ptr->id.data;
1327   BKE_constraints_active_set(&ob->constraints, (bConstraint *)value.data);
1328 }
1329
1330 static bConstraint *rna_Object_constraints_new(Object *object, Main *bmain, int type)
1331 {
1332   bConstraint *new_con = BKE_constraint_add_for_object(object, NULL, type);
1333
1334   ED_object_constraint_tag_update(bmain, object, new_con);
1335   WM_main_add_notifier(NC_OBJECT | ND_CONSTRAINT | NA_ADDED, object);
1336
1337   return new_con;
1338 }
1339
1340 static void rna_Object_constraints_remove(Object *object,
1341                                           Main *bmain,
1342                                           ReportList *reports,
1343                                           PointerRNA *con_ptr)
1344 {
1345   bConstraint *con = con_ptr->data;
1346   if (BLI_findindex(&object->constraints, con) == -1) {
1347     BKE_reportf(reports,
1348                 RPT_ERROR,
1349                 "Constraint '%s' not found in object '%s'",
1350                 con->name,
1351                 object->id.name + 2);
1352     return;
1353   }
1354
1355   BKE_constraint_remove(&object->constraints, con);
1356   RNA_POINTER_INVALIDATE(con_ptr);
1357
1358   ED_object_constraint_update(bmain, object);
1359   ED_object_constraint_set_active(object, NULL);
1360   WM_main_add_notifier(NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, object);
1361 }
1362
1363 static void rna_Object_constraints_clear(Object *object, Main *bmain)
1364 {
1365   BKE_constraints_free(&object->constraints);
1366
1367   ED_object_constraint_update(bmain, object);
1368   ED_object_constraint_set_active(object, NULL);
1369
1370   WM_main_add_notifier(NC_OBJECT | ND_CONSTRAINT | NA_REMOVED, object);
1371 }
1372
1373 bool rna_Object_constraints_override_apply(Main *UNUSED(bmain),
1374                                            PointerRNA *ptr_dst,
1375                                            PointerRNA *ptr_src,
1376                                            PointerRNA *UNUSED(ptr_storage),
1377                                            PropertyRNA *UNUSED(prop_dst),
1378                                            PropertyRNA *UNUSED(prop_src),
1379                                            PropertyRNA *UNUSED(prop_storage),
1380                                            const int UNUSED(len_dst),
1381                                            const int UNUSED(len_src),
1382                                            const int UNUSED(len_storage),
1383                                            PointerRNA *UNUSED(ptr_item_dst),
1384                                            PointerRNA *UNUSED(ptr_item_src),
1385                                            PointerRNA *UNUSED(ptr_item_storage),
1386                                            IDOverrideLibraryPropertyOperation *opop)
1387 {
1388   BLI_assert(opop->operation == IDOVERRIDE_LIBRARY_OP_INSERT_AFTER &&
1389              "Unsupported RNA override operation on constraints collection");
1390
1391   Object *ob_dst = (Object *)ptr_dst->id.data;
1392   Object *ob_src = (Object *)ptr_src->id.data;
1393
1394   /* Remember that insertion operations are defined and stored in correct order, which means that
1395    * even if we insert several items in a row, we alays insert first one, then second one, etc.
1396    * So we should always find 'anchor' constraint in both _src *and* _dst> */
1397   bConstraint *con_anchor = NULL;
1398   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1399     con_anchor = BLI_findstring(
1400         &ob_dst->constraints, opop->subitem_local_name, offsetof(bConstraint, name));
1401   }
1402   if (con_anchor == NULL && opop->subitem_local_index >= 0) {
1403     con_anchor = BLI_findlink(&ob_dst->constraints, opop->subitem_local_index);
1404   }
1405   /* Otherwise we just insert in first position. */
1406
1407   bConstraint *con_src = NULL;
1408   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1409     con_src = BLI_findstring(
1410         &ob_src->constraints, opop->subitem_local_name, offsetof(bConstraint, name));
1411   }
1412   if (con_src == NULL && opop->subitem_local_index >= 0) {
1413     con_src = BLI_findlink(&ob_src->constraints, opop->subitem_local_index);
1414   }
1415   con_src = con_src ? con_src->next : ob_src->constraints.first;
1416
1417   BLI_assert(con_src != NULL);
1418
1419   bConstraint *con_dst = BKE_constraint_duplicate_ex(con_src, 0, true);
1420
1421   /* This handles NULL anchor as expected by adding at head of list. */
1422   BLI_insertlinkafter(&ob_dst->constraints, con_anchor, con_dst);
1423
1424   /* This should actually *not* be needed in typical cases.
1425    * However, if overridden source was edited, we *may* have some new conflicting names. */
1426   BKE_constraint_unique_name(con_dst, &ob_dst->constraints);
1427
1428   //  printf("%s: We inserted a constraint...\n", __func__);
1429   return true;
1430 }
1431
1432 static ModifierData *rna_Object_modifier_new(
1433     Object *object, bContext *C, ReportList *reports, const char *name, int type)
1434 {
1435   return ED_object_modifier_add(reports, CTX_data_main(C), CTX_data_scene(C), object, name, type);
1436 }
1437
1438 static void rna_Object_modifier_remove(Object *object,
1439                                        bContext *C,
1440                                        ReportList *reports,
1441                                        PointerRNA *md_ptr)
1442 {
1443   ModifierData *md = md_ptr->data;
1444   if (ED_object_modifier_remove(reports, CTX_data_main(C), object, md) == false) {
1445     /* error is already set */
1446     return;
1447   }
1448
1449   RNA_POINTER_INVALIDATE(md_ptr);
1450
1451   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1452 }
1453
1454 static void rna_Object_modifier_clear(Object *object, bContext *C)
1455 {
1456   ED_object_modifier_clear(CTX_data_main(C), object);
1457
1458   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1459 }
1460
1461 bool rna_Object_modifiers_override_apply(Main *UNUSED(bmain),
1462                                          PointerRNA *ptr_dst,
1463                                          PointerRNA *ptr_src,
1464                                          PointerRNA *UNUSED(ptr_storage),
1465                                          PropertyRNA *UNUSED(prop_dst),
1466                                          PropertyRNA *UNUSED(prop_src),
1467                                          PropertyRNA *UNUSED(prop_storage),
1468                                          const int UNUSED(len_dst),
1469                                          const int UNUSED(len_src),
1470                                          const int UNUSED(len_storage),
1471                                          PointerRNA *UNUSED(ptr_item_dst),
1472                                          PointerRNA *UNUSED(ptr_item_src),
1473                                          PointerRNA *UNUSED(ptr_item_storage),
1474                                          IDOverrideLibraryPropertyOperation *opop)
1475 {
1476   BLI_assert(opop->operation == IDOVERRIDE_LIBRARY_OP_INSERT_AFTER &&
1477              "Unsupported RNA override operation on modifiers collection");
1478
1479   Object *ob_dst = (Object *)ptr_dst->id.data;
1480   Object *ob_src = (Object *)ptr_src->id.data;
1481
1482   /* Remember that insertion operations are defined and stored in correct order, which means that
1483    * even if we insert several items in a row, we alays insert first one, then second one, etc.
1484    * So we should always find 'anchor' constraint in both _src *and* _dst> */
1485   ModifierData *mod_anchor = NULL;
1486   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1487     mod_anchor = BLI_findstring(
1488         &ob_dst->modifiers, opop->subitem_local_name, offsetof(ModifierData, name));
1489   }
1490   if (mod_anchor == NULL && opop->subitem_local_index >= 0) {
1491     mod_anchor = BLI_findlink(&ob_dst->modifiers, opop->subitem_local_index);
1492   }
1493   /* Otherwise we just insert in first position. */
1494
1495   ModifierData *mod_src = NULL;
1496   if (opop->subitem_local_name && opop->subitem_local_name[0]) {
1497     mod_src = BLI_findstring(
1498         &ob_src->modifiers, opop->subitem_local_name, offsetof(ModifierData, name));
1499   }
1500   if (mod_src == NULL && opop->subitem_local_index >= 0) {
1501     mod_src = BLI_findlink(&ob_src->modifiers, opop->subitem_local_index);
1502   }
1503   mod_src = mod_src ? mod_src->next : ob_src->modifiers.first;
1504
1505   BLI_assert(mod_src != NULL);
1506
1507   ModifierData *mod_dst = modifier_new(mod_src->type);
1508   modifier_copyData(mod_src, mod_dst);
1509
1510   /* This handles NULL anchor as expected by adding at head of list. */
1511   BLI_insertlinkafter(&ob_dst->modifiers, mod_anchor, mod_dst);
1512
1513   /* This should actually *not* be needed in typical cases.
1514    * However, if overridden source was edited,
1515    * we *may* have some new conflicting names. */
1516   modifier_unique_name(&ob_dst->modifiers, mod_dst);
1517
1518   //  printf("%s: We inserted a modifier...\n", __func__);
1519   return true;
1520 }
1521
1522 static GpencilModifierData *rna_Object_greasepencil_modifier_new(
1523     Object *object, bContext *C, ReportList *reports, const char *name, int type)
1524 {
1525   return ED_object_gpencil_modifier_add(
1526       reports, CTX_data_main(C), CTX_data_scene(C), object, name, type);
1527 }
1528
1529 static void rna_Object_greasepencil_modifier_remove(Object *object,
1530                                                     bContext *C,
1531                                                     ReportList *reports,
1532                                                     PointerRNA *gmd_ptr)
1533 {
1534   GpencilModifierData *gmd = gmd_ptr->data;
1535   if (ED_object_gpencil_modifier_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_greasepencil_modifier_clear(Object *object, bContext *C)
1546 {
1547   ED_object_gpencil_modifier_clear(CTX_data_main(C), object);
1548   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1549 }
1550
1551 /* shader fx */
1552 static ShaderFxData *rna_Object_shaderfx_new(
1553     Object *object, bContext *C, ReportList *reports, const char *name, int type)
1554 {
1555   return ED_object_shaderfx_add(reports, CTX_data_main(C), CTX_data_scene(C), object, name, type);
1556 }
1557
1558 static void rna_Object_shaderfx_remove(Object *object,
1559                                        bContext *C,
1560                                        ReportList *reports,
1561                                        PointerRNA *gmd_ptr)
1562 {
1563   ShaderFxData *gmd = gmd_ptr->data;
1564   if (ED_object_shaderfx_remove(reports, CTX_data_main(C), object, gmd) == false) {
1565     /* error is already set */
1566     return;
1567   }
1568
1569   RNA_POINTER_INVALIDATE(gmd_ptr);
1570
1571   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1572 }
1573
1574 static void rna_Object_shaderfx_clear(Object *object, bContext *C)
1575 {
1576   ED_object_shaderfx_clear(CTX_data_main(C), object);
1577   WM_main_add_notifier(NC_OBJECT | ND_MODIFIER | NA_REMOVED, object);
1578 }
1579
1580 static void rna_Object_boundbox_get(PointerRNA *ptr, float *values)
1581 {
1582   Object *ob = (Object *)ptr->id.data;
1583   BoundBox *bb = BKE_object_boundbox_get(ob);
1584   if (bb) {
1585     memcpy(values, bb->vec, sizeof(bb->vec));
1586   }
1587   else {
1588     copy_vn_fl(values, sizeof(bb->vec) / sizeof(float), 0.0f);
1589   }
1590 }
1591
1592 static bDeformGroup *rna_Object_vgroup_new(Object *ob, Main *bmain, const char *name)
1593 {
1594   bDeformGroup *defgroup = BKE_object_defgroup_add_name(ob, name);
1595
1596   DEG_relations_tag_update(bmain);
1597   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1598
1599   return defgroup;
1600 }
1601
1602 static void rna_Object_vgroup_remove(Object *ob,
1603                                      Main *bmain,
1604                                      ReportList *reports,
1605                                      PointerRNA *defgroup_ptr)
1606 {
1607   bDeformGroup *defgroup = defgroup_ptr->data;
1608   if (BLI_findindex(&ob->defbase, defgroup) == -1) {
1609     BKE_reportf(reports,
1610                 RPT_ERROR,
1611                 "DeformGroup '%s' not in object '%s'",
1612                 defgroup->name,
1613                 ob->id.name + 2);
1614     return;
1615   }
1616
1617   BKE_object_defgroup_remove(ob, defgroup);
1618   RNA_POINTER_INVALIDATE(defgroup_ptr);
1619
1620   DEG_relations_tag_update(bmain);
1621   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1622 }
1623
1624 static void rna_Object_vgroup_clear(Object *ob, Main *bmain)
1625 {
1626   BKE_object_defgroup_remove_all(ob);
1627
1628   DEG_relations_tag_update(bmain);
1629   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1630 }
1631
1632 static void rna_VertexGroup_vertex_add(ID *id,
1633                                        bDeformGroup *def,
1634                                        ReportList *reports,
1635                                        int index_len,
1636                                        int *index,
1637                                        float weight,
1638                                        int assignmode)
1639 {
1640   Object *ob = (Object *)id;
1641
1642   if (BKE_object_is_in_editmode_vgroup(ob)) {
1643     BKE_report(
1644         reports, RPT_ERROR, "VertexGroup.add(): cannot be called while object is in edit mode");
1645     return;
1646   }
1647
1648   while (index_len--) {
1649     ED_vgroup_vert_add(
1650         ob, def, *index++, weight, assignmode); /* XXX, not efficient calling within loop*/
1651   }
1652
1653   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1654   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1655 }
1656
1657 static void rna_VertexGroup_vertex_remove(
1658     ID *id, bDeformGroup *dg, ReportList *reports, int index_len, int *index)
1659 {
1660   Object *ob = (Object *)id;
1661
1662   if (BKE_object_is_in_editmode_vgroup(ob)) {
1663     BKE_report(
1664         reports, RPT_ERROR, "VertexGroup.remove(): cannot be called while object is in edit mode");
1665     return;
1666   }
1667
1668   while (index_len--) {
1669     ED_vgroup_vert_remove(ob, dg, *index++);
1670   }
1671
1672   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
1673   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1674 }
1675
1676 static float rna_VertexGroup_weight(ID *id, bDeformGroup *dg, ReportList *reports, int index)
1677 {
1678   float weight = ED_vgroup_vert_weight((Object *)id, dg, index);
1679
1680   if (weight < 0) {
1681     BKE_report(reports, RPT_ERROR, "Vertex not in group");
1682   }
1683   return weight;
1684 }
1685
1686 static bFaceMap *rna_Object_fmap_new(Object *ob, const char *name)
1687 {
1688   bFaceMap *fmap = BKE_object_facemap_add_name(ob, name);
1689
1690   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1691
1692   return fmap;
1693 }
1694
1695 static void rna_Object_fmap_remove(Object *ob, ReportList *reports, PointerRNA *fmap_ptr)
1696 {
1697   bFaceMap *fmap = fmap_ptr->data;
1698   if (BLI_findindex(&ob->fmaps, fmap) == -1) {
1699     BKE_reportf(
1700         reports, RPT_ERROR, "FaceMap '%s' not in object '%s'", fmap->name, ob->id.name + 2);
1701     return;
1702   }
1703
1704   BKE_object_facemap_remove(ob, fmap);
1705   RNA_POINTER_INVALIDATE(fmap_ptr);
1706
1707   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1708 }
1709
1710 static void rna_Object_fmap_clear(Object *ob)
1711 {
1712   BKE_object_facemap_clear(ob);
1713
1714   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
1715 }
1716
1717 static void rna_FaceMap_face_add(
1718     ID *id, bFaceMap *fmap, ReportList *reports, int index_len, int *index)
1719 {
1720   Object *ob = (Object *)id;
1721
1722   if (BKE_object_is_in_editmode(ob)) {
1723     BKE_report(reports, RPT_ERROR, "FaceMap.add(): cannot be called while object is in edit mode");
1724     return;
1725   }
1726
1727   while (index_len--) {
1728     ED_object_facemap_face_add(ob, fmap, *index++);
1729   }
1730
1731   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1732 }
1733
1734 static void rna_FaceMap_face_remove(
1735     ID *id, bFaceMap *fmap, ReportList *reports, int index_len, int *index)
1736 {
1737   Object *ob = (Object *)id;
1738
1739   if (BKE_object_is_in_editmode(ob)) {
1740     BKE_report(reports, RPT_ERROR, "FaceMap.add(): cannot be called while object is in edit mode");
1741     return;
1742   }
1743
1744   while (index_len--) {
1745     ED_object_facemap_face_remove(ob, fmap, *index++);
1746   }
1747
1748   WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
1749 }
1750
1751 /* generic poll functions */
1752 bool rna_Lattice_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1753 {
1754   return ((Object *)value.id.data)->type == OB_LATTICE;
1755 }
1756
1757 bool rna_Curve_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1758 {
1759   return ((Object *)value.id.data)->type == OB_CURVE;
1760 }
1761
1762 bool rna_Armature_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1763 {
1764   return ((Object *)value.id.data)->type == OB_ARMATURE;
1765 }
1766
1767 bool rna_Mesh_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1768 {
1769   return ((Object *)value.id.data)->type == OB_MESH;
1770 }
1771
1772 bool rna_Camera_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1773 {
1774   return ((Object *)value.id.data)->type == OB_CAMERA;
1775 }
1776
1777 bool rna_Light_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1778 {
1779   return ((Object *)value.id.data)->type == OB_LAMP;
1780 }
1781
1782 bool rna_GPencil_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
1783 {
1784   return ((Object *)value.id.data)->type == OB_GPENCIL;
1785 }
1786
1787 int rna_Object_use_dynamic_topology_sculpting_get(PointerRNA *ptr)
1788 {
1789   SculptSession *ss = ((Object *)ptr->id.data)->sculpt;
1790   return (ss && ss->bm);
1791 }
1792
1793 #else
1794
1795 static void rna_def_vertex_group(BlenderRNA *brna)
1796 {
1797   StructRNA *srna;
1798   PropertyRNA *prop;
1799   FunctionRNA *func;
1800   PropertyRNA *parm;
1801
1802   static const EnumPropertyItem assign_mode_items[] = {
1803       {WEIGHT_REPLACE, "REPLACE", 0, "Replace", "Replace"},
1804       {WEIGHT_ADD, "ADD", 0, "Add", "Add"},
1805       {WEIGHT_SUBTRACT, "SUBTRACT", 0, "Subtract", "Subtract"},
1806       {0, NULL, 0, NULL, NULL},
1807   };
1808
1809   srna = RNA_def_struct(brna, "VertexGroup", NULL);
1810   RNA_def_struct_sdna(srna, "bDeformGroup");
1811   RNA_def_struct_ui_text(
1812       srna, "Vertex Group", "Group of vertices, used for armature deform and other purposes");
1813   RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);
1814
1815   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1816   RNA_def_property_ui_text(prop, "Name", "Vertex group name");
1817   RNA_def_struct_name_property(srna, prop);
1818   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_VertexGroup_name_set");
1819   /* update data because modifiers may use [#24761] */
1820   RNA_def_property_update(
1821       prop, NC_GEOM | ND_DATA | NA_RENAME, "rna_Object_internal_update_data_dependency");
1822
1823   prop = RNA_def_property(srna, "lock_weight", PROP_BOOLEAN, PROP_NONE);
1824   RNA_def_property_ui_text(prop, "", "Maintain the relative weights for the group");
1825   RNA_def_property_boolean_sdna(prop, NULL, "flag", 0);
1826   /* update data because modifiers may use [#24761] */
1827   RNA_def_property_update(prop, NC_GEOM | ND_DATA | NA_RENAME, "rna_Object_internal_update_data");
1828
1829   prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1830   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1831   RNA_def_property_int_funcs(prop, "rna_VertexGroup_index_get", NULL, NULL);
1832   RNA_def_property_ui_text(prop, "Index", "Index number of the vertex group");
1833
1834   func = RNA_def_function(srna, "add", "rna_VertexGroup_vertex_add");
1835   RNA_def_function_ui_description(func, "Add vertices to the group");
1836   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1837   /* TODO, see how array size of 0 works, this shouldnt be used */
1838   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1839   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1840   parm = RNA_def_float(func, "weight", 0, 0.0f, 1.0f, "", "Vertex weight", 0.0f, 1.0f);
1841   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1842   parm = RNA_def_enum(func, "type", assign_mode_items, 0, "", "Vertex assign mode");
1843   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1844
1845   func = RNA_def_function(srna, "remove", "rna_VertexGroup_vertex_remove");
1846   RNA_def_function_ui_description(func, "Remove a vertex from the group");
1847   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1848   /* TODO, see how array size of 0 works, this shouldnt be used */
1849   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1850   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1851
1852   func = RNA_def_function(srna, "weight", "rna_VertexGroup_weight");
1853   RNA_def_function_ui_description(func, "Get a vertex weight from the group");
1854   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1855   parm = RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "The index of the vertex", 0, INT_MAX);
1856   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1857   parm = RNA_def_float(func, "weight", 0, 0.0f, 1.0f, "", "Vertex weight", 0.0f, 1.0f);
1858   RNA_def_function_return(func, parm);
1859 }
1860
1861 static void rna_def_face_map(BlenderRNA *brna)
1862 {
1863   StructRNA *srna;
1864   PropertyRNA *prop;
1865
1866   FunctionRNA *func;
1867   PropertyRNA *parm;
1868
1869   srna = RNA_def_struct(brna, "FaceMap", NULL);
1870   RNA_def_struct_sdna(srna, "bFaceMap");
1871   RNA_def_struct_ui_text(
1872       srna, "Face Map", "Group of faces, each face can only be part of one map");
1873   RNA_def_struct_ui_icon(srna, ICON_MOD_TRIANGULATE);
1874
1875   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1876   RNA_def_property_ui_text(prop, "Name", "Face map name");
1877   RNA_def_struct_name_property(srna, prop);
1878   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_FaceMap_name_set");
1879   /* update data because modifiers may use [#24761] */
1880   RNA_def_property_update(prop, NC_GEOM | ND_DATA | NA_RENAME, "rna_Object_internal_update_data");
1881
1882   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1883   RNA_def_property_boolean_sdna(prop, NULL, "flag", SELECT);
1884   RNA_def_property_ui_text(prop, "Select", "Face-map selection state (for tools to use)");
1885   /* important not to use a notifier here, creates a feedback loop! */
1886
1887   prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
1888   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1889   RNA_def_property_int_funcs(prop, "rna_FaceMap_index_get", NULL, NULL);
1890   RNA_def_property_ui_text(prop, "Index", "Index number of the face map");
1891
1892   func = RNA_def_function(srna, "add", "rna_FaceMap_face_add");
1893   RNA_def_function_ui_description(func, "Add vertices to the group");
1894   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1895   /* TODO, see how array size of 0 works, this shouldnt be used */
1896   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1897   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1898
1899   func = RNA_def_function(srna, "remove", "rna_FaceMap_face_remove");
1900   RNA_def_function_ui_description(func, "Remove a vertex from the group");
1901   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
1902   /* TODO, see how array size of 0 works, this shouldnt be used */
1903   parm = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
1904   RNA_def_parameter_flags(parm, PROP_DYNAMIC, PARM_REQUIRED);
1905 }
1906
1907 static void rna_def_material_slot(BlenderRNA *brna)
1908 {
1909   StructRNA *srna;
1910   PropertyRNA *prop;
1911
1912   static const EnumPropertyItem link_items[] = {
1913       {1, "OBJECT", 0, "Object", ""},
1914       {0, "DATA", 0, "Data", ""},
1915       {0, NULL, 0, NULL, NULL},
1916   };
1917
1918   /* NOTE: there is no MaterialSlot equivalent in DNA, so the internal
1919    * pointer data points to ob->mat + index, and we manually implement
1920    * get/set for the properties. */
1921
1922   srna = RNA_def_struct(brna, "MaterialSlot", NULL);
1923   RNA_def_struct_ui_text(srna, "Material Slot", "Material slot in an object");
1924   RNA_def_struct_ui_icon(srna, ICON_MATERIAL_DATA);
1925
1926   /* WARNING! Order is crucial for override to work properly here... :/
1927    * 'link' must come before material pointer,
1928    * since it defines where (in object or obdata) that one is set! */
1929   prop = RNA_def_property(srna, "link", PROP_ENUM, PROP_NONE);
1930   RNA_def_property_enum_items(prop, link_items);
1931   RNA_def_property_enum_funcs(
1932       prop, "rna_MaterialSlot_link_get", "rna_MaterialSlot_link_set", NULL);
1933   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1934   RNA_def_property_ui_text(prop, "Link", "Link material to object or the object's data");
1935   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_MaterialSlot_update");
1936
1937   prop = RNA_def_property(srna, "material", PROP_POINTER, PROP_NONE);
1938   RNA_def_property_struct_type(prop, "Material");
1939   RNA_def_property_flag(prop, PROP_EDITABLE);
1940   RNA_def_property_editable_func(prop, "rna_MaterialSlot_material_editable");
1941   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1942   RNA_def_property_pointer_funcs(prop,
1943                                  "rna_MaterialSlot_material_get",
1944                                  "rna_MaterialSlot_material_set",
1945                                  NULL,
1946                                  "rna_MaterialSlot_material_poll");
1947   RNA_def_property_ui_text(prop, "Material", "Material data-block used by this material slot");
1948   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_MaterialSlot_update");
1949
1950   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
1951   RNA_def_property_string_funcs(
1952       prop, "rna_MaterialSlot_name_get", "rna_MaterialSlot_name_length", NULL);
1953   RNA_def_property_ui_text(prop, "Name", "Material slot name");
1954   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1955   RNA_def_struct_name_property(srna, prop);
1956
1957   RNA_def_struct_path_func(srna, "rna_MaterialSlot_path");
1958 }
1959
1960 static void rna_def_object_constraints(BlenderRNA *brna, PropertyRNA *cprop)
1961 {
1962   StructRNA *srna;
1963   PropertyRNA *prop;
1964
1965   FunctionRNA *func;
1966   PropertyRNA *parm;
1967
1968   RNA_def_property_srna(cprop, "ObjectConstraints");
1969   srna = RNA_def_struct(brna, "ObjectConstraints", NULL);
1970   RNA_def_struct_sdna(srna, "Object");
1971   RNA_def_struct_ui_text(srna, "Object Constraints", "Collection of object constraints");
1972
1973   /* Collection active property */
1974   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1975   RNA_def_property_struct_type(prop, "Constraint");
1976   RNA_def_property_pointer_funcs(
1977       prop, "rna_Object_active_constraint_get", "rna_Object_active_constraint_set", NULL, NULL);
1978   RNA_def_property_flag(prop, PROP_EDITABLE);
1979   RNA_def_property_ui_text(prop, "Active Constraint", "Active Object constraint");
1980
1981   /* Constraint collection */
1982   func = RNA_def_function(srna, "new", "rna_Object_constraints_new");
1983   RNA_def_function_ui_description(func, "Add a new constraint to this object");
1984   RNA_def_function_flag(func, FUNC_USE_MAIN);
1985   /* object to add */
1986   parm = RNA_def_enum(
1987       func, "type", rna_enum_constraint_type_items, 1, "", "Constraint type to add");
1988   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1989   /* return type */
1990   parm = RNA_def_pointer(func, "constraint", "Constraint", "", "New constraint");
1991   RNA_def_function_return(func, parm);
1992
1993   func = RNA_def_function(srna, "remove", "rna_Object_constraints_remove");
1994   RNA_def_function_ui_description(func, "Remove a constraint from this object");
1995   RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS);
1996   /* constraint to remove */
1997   parm = RNA_def_pointer(func, "constraint", "Constraint", "", "Removed constraint");
1998   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1999   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2000
2001   func = RNA_def_function(srna, "clear", "rna_Object_constraints_clear");
2002   RNA_def_function_flag(func, FUNC_USE_MAIN);
2003   RNA_def_function_ui_description(func, "Remove all constraint from this object");
2004 }
2005
2006 /* object.modifiers */
2007 static void rna_def_object_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
2008 {
2009   StructRNA *srna;
2010
2011   FunctionRNA *func;
2012   PropertyRNA *parm;
2013
2014   RNA_def_property_srna(cprop, "ObjectModifiers");
2015   srna = RNA_def_struct(brna, "ObjectModifiers", NULL);
2016   RNA_def_struct_sdna(srna, "Object");
2017   RNA_def_struct_ui_text(srna, "Object Modifiers", "Collection of object modifiers");
2018
2019 #  if 0
2020   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2021   RNA_def_property_struct_type(prop, "EditBone");
2022   RNA_def_property_pointer_sdna(prop, NULL, "act_edbone");
2023   RNA_def_property_flag(prop, PROP_EDITABLE);
2024   RNA_def_property_ui_text(prop, "Active EditBone", "Armatures active edit bone");
2025   /*RNA_def_property_update(prop, 0, "rna_Armature_act_editbone_update"); */
2026   RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_edit_bone_set", NULL, NULL);
2027
2028   /* todo, redraw */
2029 /*      RNA_def_property_collection_active(prop, prop_act); */
2030 #  endif
2031
2032   /* add modifier */
2033   func = RNA_def_function(srna, "new", "rna_Object_modifier_new");
2034   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2035   RNA_def_function_ui_description(func, "Add a new modifier");
2036   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the modifier");
2037   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2038   /* modifier to add */
2039   parm = RNA_def_enum(
2040       func, "type", rna_enum_object_modifier_type_items, 1, "", "Modifier type to add");
2041   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2042   /* return type */
2043   parm = RNA_def_pointer(func, "modifier", "Modifier", "", "Newly created modifier");
2044   RNA_def_function_return(func, parm);
2045
2046   /* remove modifier */
2047   func = RNA_def_function(srna, "remove", "rna_Object_modifier_remove");
2048   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2049   RNA_def_function_ui_description(func, "Remove an existing modifier from the object");
2050   /* modifier to remove */
2051   parm = RNA_def_pointer(func, "modifier", "Modifier", "", "Modifier to remove");
2052   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2053   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2054
2055   /* clear all modifiers */
2056   func = RNA_def_function(srna, "clear", "rna_Object_modifier_clear");
2057   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2058   RNA_def_function_ui_description(func, "Remove all modifiers from the object");
2059 }
2060
2061 /* object.grease_pencil_modifiers */
2062 static void rna_def_object_grease_pencil_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
2063 {
2064   StructRNA *srna;
2065
2066   FunctionRNA *func;
2067   PropertyRNA *parm;
2068
2069   RNA_def_property_srna(cprop, "ObjectGpencilModifiers");
2070   srna = RNA_def_struct(brna, "ObjectGpencilModifiers", NULL);
2071   RNA_def_struct_sdna(srna, "Object");
2072   RNA_def_struct_ui_text(
2073       srna, "Object Grease Pencil Modifiers", "Collection of object grease pencil modifiers");
2074
2075   /* add greasepencil modifier */
2076   func = RNA_def_function(srna, "new", "rna_Object_greasepencil_modifier_new");
2077   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2078   RNA_def_function_ui_description(func, "Add a new greasepencil_modifier");
2079   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the greasepencil_modifier");
2080   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2081   /* greasepencil_modifier to add */
2082   parm = RNA_def_enum(func,
2083                       "type",
2084                       rna_enum_object_greasepencil_modifier_type_items,
2085                       1,
2086                       "",
2087                       "Modifier type to add");
2088   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2089   /* return type */
2090   parm = RNA_def_pointer(
2091       func, "greasepencil_modifier", "GpencilModifier", "", "Newly created modifier");
2092   RNA_def_function_return(func, parm);
2093
2094   /* remove greasepencil_modifier */
2095   func = RNA_def_function(srna, "remove", "rna_Object_greasepencil_modifier_remove");
2096   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2097   RNA_def_function_ui_description(func,
2098                                   "Remove an existing greasepencil_modifier from the object");
2099   /* greasepencil_modifier to remove */
2100   parm = RNA_def_pointer(
2101       func, "greasepencil_modifier", "GpencilModifier", "", "Modifier to remove");
2102   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2103   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2104
2105   /* clear all greasepencil modifiers */
2106   func = RNA_def_function(srna, "clear", "rna_Object_greasepencil_modifier_clear");
2107   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2108   RNA_def_function_ui_description(func, "Remove all grease pencil modifiers from the object");
2109 }
2110
2111 /* object.shaderfxs */
2112 static void rna_def_object_shaderfxs(BlenderRNA *brna, PropertyRNA *cprop)
2113 {
2114   StructRNA *srna;
2115
2116   FunctionRNA *func;
2117   PropertyRNA *parm;
2118
2119   RNA_def_property_srna(cprop, "ObjectShaderFx");
2120   srna = RNA_def_struct(brna, "ObjectShaderFx", NULL);
2121   RNA_def_struct_sdna(srna, "Object");
2122   RNA_def_struct_ui_text(srna, "Object Shader Effects", "Collection of object effects");
2123
2124   /* add shader_fx */
2125   func = RNA_def_function(srna, "new", "rna_Object_shaderfx_new");
2126   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2127   RNA_def_function_ui_description(func, "Add a new shader fx");
2128   parm = RNA_def_string(func, "name", "Name", 0, "", "New name for the effect");
2129   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2130   /* shader to add */
2131   parm = RNA_def_enum(
2132       func, "type", rna_enum_object_shaderfx_type_items, 1, "", "Effect type to add");
2133   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
2134   /* return type */
2135   parm = RNA_def_pointer(func, "shader_fx", "ShaderFx", "", "Newly created effect");
2136   RNA_def_function_return(func, parm);
2137
2138   /* remove shader_fx */
2139   func = RNA_def_function(srna, "remove", "rna_Object_shaderfx_remove");
2140   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
2141   RNA_def_function_ui_description(func, "Remove an existing effect from the object");
2142   /* shader to remove */
2143   parm = RNA_def_pointer(func, "shader_fx", "ShaderFx", "", "Effect to remove");
2144   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2145   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2146
2147   /* clear all shader fx */
2148   func = RNA_def_function(srna, "clear", "rna_Object_shaderfx_clear");
2149   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
2150   RNA_def_function_ui_description(func, "Remove all effects from the object");
2151 }
2152
2153 /* object.particle_systems */
2154 static void rna_def_object_particle_systems(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, "ParticleSystems");
2164   srna = RNA_def_struct(brna, "ParticleSystems", NULL);
2165   RNA_def_struct_sdna(srna, "Object");
2166   RNA_def_struct_ui_text(srna, "Particle Systems", "Collection of particle systems");
2167
2168   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2169   RNA_def_property_struct_type(prop, "ParticleSystem");
2170   RNA_def_property_pointer_funcs(prop, "rna_Object_active_particle_system_get", NULL, NULL, NULL);
2171   RNA_def_property_ui_text(
2172       prop, "Active Particle System", "Active particle system being displayed");
2173   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2174
2175   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2176   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2177   RNA_def_property_int_funcs(prop,
2178                              "rna_Object_active_particle_system_index_get",
2179                              "rna_Object_active_particle_system_index_set",
2180                              "rna_Object_active_particle_system_index_range");
2181   RNA_def_property_ui_text(
2182       prop, "Active Particle System Index", "Index of active particle system slot");
2183   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_particle_update");
2184 }
2185
2186 /* object.vertex_groups */
2187 static void rna_def_object_vertex_groups(BlenderRNA *brna, PropertyRNA *cprop)
2188 {
2189   StructRNA *srna;
2190
2191   PropertyRNA *prop;
2192
2193   FunctionRNA *func;
2194   PropertyRNA *parm;
2195
2196   RNA_def_property_srna(cprop, "VertexGroups");
2197   srna = RNA_def_struct(brna, "VertexGroups", NULL);
2198   RNA_def_struct_sdna(srna, "Object");
2199   RNA_def_struct_ui_text(srna, "Vertex Groups", "Collection of vertex groups");
2200
2201   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2202   RNA_def_property_struct_type(prop, "VertexGroup");
2203   RNA_def_property_pointer_funcs(prop,
2204                                  "rna_Object_active_vertex_group_get",
2205                                  "rna_Object_active_vertex_group_set",
2206                                  NULL,
2207                                  NULL);
2208   RNA_def_property_ui_text(prop, "Active Vertex Group", "Vertex groups of the object");
2209   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2210
2211   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2212   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2213   RNA_def_property_int_sdna(prop, NULL, "actdef");
2214   RNA_def_property_int_funcs(prop,
2215                              "rna_Object_active_vertex_group_index_get",
2216                              "rna_Object_active_vertex_group_index_set",
2217                              "rna_Object_active_vertex_group_index_range");
2218   RNA_def_property_ui_text(
2219       prop, "Active Vertex Group Index", "Active index in vertex group array");
2220   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2221
2222   /* vertex groups */ /* add_vertex_group */
2223   func = RNA_def_function(srna, "new", "rna_Object_vgroup_new");
2224   RNA_def_function_flag(func, FUNC_USE_MAIN);
2225   RNA_def_function_ui_description(func, "Add vertex group to object");
2226   RNA_def_string(func, "name", "Group", 0, "", "Vertex group name"); /* optional */
2227   parm = RNA_def_pointer(func, "group", "VertexGroup", "", "New vertex group");
2228   RNA_def_function_return(func, parm);
2229
2230   func = RNA_def_function(srna, "remove", "rna_Object_vgroup_remove");
2231   RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS);
2232   RNA_def_function_ui_description(func, "Delete vertex group from object");
2233   parm = RNA_def_pointer(func, "group", "VertexGroup", "", "Vertex group to remove");
2234   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2235   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
2236
2237   func = RNA_def_function(srna, "clear", "rna_Object_vgroup_clear");
2238   RNA_def_function_flag(func, FUNC_USE_MAIN);
2239   RNA_def_function_ui_description(func, "Delete all vertex groups from object");
2240 }
2241
2242 /* object.face_maps */
2243 static void rna_def_object_face_maps(BlenderRNA *brna, PropertyRNA *cprop)
2244 {
2245   StructRNA *srna;
2246
2247   PropertyRNA *prop;
2248
2249   FunctionRNA *func;
2250   PropertyRNA *parm;
2251
2252   RNA_def_property_srna(cprop, "FaceMaps");
2253   srna = RNA_def_struct(brna, "FaceMaps", NULL);
2254   RNA_def_struct_sdna(srna, "Object");
2255   RNA_def_struct_ui_text(srna, "Face Maps", "Collection of face maps");
2256
2257   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
2258   RNA_def_property_struct_type(prop, "FaceMap");
2259   RNA_def_property_pointer_funcs(
2260       prop, "rna_Object_active_face_map_get", "rna_Object_active_face_map_set", NULL, NULL);
2261   RNA_def_property_ui_text(prop, "Active Face Map", "Face maps of the object");
2262   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2263
2264   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
2265   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2266   RNA_def_property_int_sdna(prop, NULL, "actfmap");
2267   RNA_def_property_int_funcs(prop,
2268                              "rna_Object_active_face_map_index_get",
2269                              "rna_Object_active_face_map_index_set",
2270                              "rna_Object_active_face_map_index_range");
2271   RNA_def_property_ui_text(prop, "Active Face Map Index", "Active index in face map array");
2272   RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
2273
2274   /* face maps */ /* add_face_map */
2275   func = RNA_def_function(srna, "new", "rna_Object_fmap_new");
2276   RNA_def_function_ui_description(func, "Add face map to object");
2277   RNA_def_string(func, "name", "Map", 0, "", "face map name"); /* optional */
2278   parm = RNA_def_pointer(func, "fmap", "FaceMap", "", "New face map");
2279   RNA_def_function_return(func, parm);
2280
2281   func = RNA_def_function(srna, "remove", "rna_Object_fmap_remove");
2282   RNA_def_function_flag(func, FUNC_USE_REPORTS);
2283   RNA_def_function_ui_description(func, "Delete vertex group from object");
2284   parm = RNA_def_pointer(func, "group", "FaceMap", "", "Face map to remove");
2285   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
2286   RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
2287
2288   func = RNA_def_function(srna, "clear", "rna_Object_fmap_clear");
2289   RNA_def_function_ui_description(func, "Delete all vertex groups from object");
2290 }
2291
2292 static void rna_def_object_display(BlenderRNA *brna)
2293 {
2294   StructRNA *srna;
2295   PropertyRNA *prop;
2296
2297   srna = RNA_def_struct(brna, "ObjectDisplay", NULL);
2298   RNA_def_struct_ui_text(srna, "Object Display", "Object display settings for 3d viewport");
2299   RNA_def_struct_sdna(srna, "Object");
2300   RNA_def_struct_nested(brna, srna, "Object");
2301   RNA_def_struct_path_func(srna, "rna_ObjectDisplay_path");
2302
2303   prop = RNA_def_property(srna, "show_shadows", PROP_BOOLEAN, PROP_NONE);
2304   RNA_def_property_boolean_negative_sdna(prop, NULL, "dtx", OB_DRAW_NO_SHADOW_CAST);
2305   RNA_def_property_boolean_default(prop, true);
2306   RNA_def_property_ui_text(prop, "Shadow", "Object cast shadows in the 3d viewport");
2307   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2308 }
2309
2310 static void rna_def_object(BlenderRNA *brna)
2311 {
2312   StructRNA *srna;
2313   PropertyRNA *prop;
2314
2315   static const EnumPropertyItem up_items[] = {
2316       {OB_POSX, "X", 0, "X", ""},
2317       {OB_POSY, "Y", 0, "Y", ""},
2318       {OB_POSZ, "Z", 0, "Z", ""},
2319       {0, NULL, 0, NULL, NULL},
2320   };
2321
2322   static const EnumPropertyItem drawtype_items[] = {
2323       {OB_BOUNDBOX, "BOUNDS", 0, "Bounds", "Display the bounds of the object"},
2324       {OB_WIRE, "WIRE", 0, "Wire", "Display the object as a wireframe"},
2325       {OB_SOLID,
2326        "SOLID",
2327        0,
2328        "Solid",
2329        "Display the object as a solid (if solid drawing is enabled in the viewport)"},
2330       {OB_TEXTURE,
2331        "TEXTURED",
2332        0,
2333        "Textured",
2334        "Display the object with textures (if textures are enabled in the viewport)"},
2335       {0, NULL, 0, NULL, NULL},
2336   };
2337
2338   static const EnumPropertyItem boundtype_items[] = {
2339       {OB_BOUND_BOX, "BOX", 0, "Box", "Display bounds as box"},
2340       {OB_BOUND_SPHERE, "SPHERE", 0, "Sphere", "Display bounds as sphere"},
2341       {OB_BOUND_CYLINDER, "CYLINDER", 0, "Cylinder", "Display bounds as cylinder"},
2342       {OB_BOUND_CONE, "CONE", 0, "Cone", "Display bounds as cone"},
2343       {OB_BOUND_CAPSULE, "CAPSULE", 0, "Capsule", "Display bounds as capsule"},
2344       {0, NULL, 0, NULL, NULL},
2345   };
2346
2347   static int boundbox_dimsize[] = {8, 3};
2348
2349   srna = RNA_def_struct(brna, "Object", "ID");
2350   RNA_def_struct_ui_text(srna, "Object", "Object data-block defining an object in a scene");
2351   RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
2352   RNA_def_struct_ui_icon(srna, ICON_OBJECT_DATA);
2353
2354   prop = RNA_def_property(srna, "data", PROP_POINTER, PROP_NONE);
2355   RNA_def_property_struct_type(prop, "ID");
2356   RNA_def_property_pointer_funcs(
2357       prop, NULL, "rna_Object_data_set", "rna_Object_data_typef", "rna_Object_data_poll");
2358   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
2359   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2360   RNA_def_property_ui_text(prop, "Data", "Object data");
2361   RNA_def_property_update(prop, 0, "rna_Object_internal_update_data_dependency");
2362
2363   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
2364   RNA_def_property_enum_sdna(prop, NULL, "type");
2365   RNA_def_property_enum_items(prop, rna_enum_object_type_items);
2366   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2367   RNA_def_property_ui_text(prop, "Type", "Type of Object");
2368   RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_ID_ID);
2369
2370   prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
2371   RNA_def_property_enum_sdna(prop, NULL, "mode");
2372   RNA_def_property_enum_items(prop, rna_enum_object_mode_items);
2373   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2374   RNA_def_property_ui_text(prop, "Mode", "Object interaction mode");
2375
2376   /* for data access */
2377   prop = RNA_def_property(srna, "bound_box", PROP_FLOAT, PROP_NONE);
2378   RNA_def_property_multi_array(prop, 2, boundbox_dimsize);
2379   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2380   RNA_def_property_float_funcs(prop, "rna_Object_boundbox_get", NULL, NULL);
2381   RNA_def_property_ui_text(
2382       prop,
2383       "Bounding Box",
2384       "Object's bounding box in object-space coordinates, all values are -1.0 when "
2385       "not available");
2386
2387   /* parent */
2388   prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
2389   RNA_def_property_pointer_funcs(prop, NULL, "rna_Object_parent_set", NULL, NULL);
2390   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
2391   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2392   RNA_def_property_ui_text(prop, "Parent", "Parent Object");
2393   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2394
2395   prop = RNA_def_property(srna, "parent_type", PROP_ENUM, PROP_NONE);
2396   RNA_def_property_enum_bitflag_sdna(prop, NULL, "partype");
2397   RNA_def_property_enum_items(prop, parent_type_items);
2398   RNA_def_property_enum_funcs(
2399       prop, NULL, "rna_Object_parent_type_set", "rna_Object_parent_type_itemf");
2400   RNA_def_property_ui_text(prop, "Parent Type", "Type of parent relation");
2401   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2402
2403   prop = RNA_def_property(srna, "parent_vertices", PROP_INT, PROP_UNSIGNED);
2404   RNA_def_property_int_sdna(prop, NULL, "par1");
2405   RNA_def_property_array(prop, 3);
2406   RNA_def_property_ui_text(
2407       prop, "Parent Vertices", "Indices of vertices in case of a vertex parenting relation");
2408   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2409
2410   prop = RNA_def_property(srna, "parent_bone", PROP_STRING, PROP_NONE);
2411   RNA_def_property_string_sdna(prop, NULL, "parsubstr");
2412   RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Object_parent_bone_set");
2413   RNA_def_property_ui_text(
2414       prop, "Parent Bone", "Name of parent bone in case of a bone parenting relation");
2415   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2416
2417   /* Track and Up flags */
2418   /* XXX: these have been saved here for a bit longer (after old track was removed),
2419    *      since some other tools still refer to this */
2420   prop = RNA_def_property(srna, "track_axis", PROP_ENUM, PROP_NONE);
2421   RNA_def_property_enum_sdna(prop, NULL, "trackflag");
2422   RNA_def_property_enum_items(prop, rna_enum_object_axis_items);
2423   RNA_def_property_ui_text(
2424       prop,
2425       "Track Axis",
2426       "Axis that points in 'forward' direction (applies to InstanceFrame when "
2427       "parent 'Follow' is enabled)");
2428   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2429
2430   prop = RNA_def_property(srna, "up_axis", PROP_ENUM, PROP_NONE);
2431   RNA_def_property_enum_sdna(prop, NULL, "upflag");
2432   RNA_def_property_enum_items(prop, up_items);
2433   RNA_def_property_ui_text(
2434       prop,
2435       "Up Axis",
2436       "Axis that points in the upward direction (applies to InstanceFrame when "
2437       "parent 'Follow' is enabled)");
2438   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2439
2440   /* proxy */
2441   prop = RNA_def_property(srna, "proxy", PROP_POINTER, PROP_NONE);
2442   RNA_def_property_ui_text(prop, "Proxy", "Library object this proxy object controls");
2443
2444   prop = RNA_def_property(srna, "proxy_collection", PROP_POINTER, PROP_NONE);
2445   RNA_def_property_pointer_sdna(prop, NULL, "proxy_group");
2446   RNA_def_property_ui_text(
2447       prop, "Proxy Collection", "Library collection duplicator object this proxy object controls");
2448
2449   /* materials */
2450   prop = RNA_def_property(srna, "material_slots", PROP_COLLECTION, PROP_NONE);
2451   RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
2452   RNA_def_property_struct_type(prop, "MaterialSlot");
2453   RNA_def_property_override_flag(prop,
2454                                  PROPOVERRIDE_OVERRIDABLE_LIBRARY | PROPOVERRIDE_NO_PROP_NAME);
2455   /* don't dereference pointer! */
2456   RNA_def_property_collection_funcs(
2457       prop, NULL, NULL, NULL, "rna_iterator_array_get", NULL, NULL, NULL, NULL);
2458   RNA_def_property_ui_text(prop, "Material Slots", "Material slots in the object");
2459
2460   prop = RNA_def_property(srna, "active_material", PROP_POINTER, PROP_NONE);
2461   RNA_def_property_struct_type(prop, "Material");
2462   RNA_def_property_pointer_funcs(prop,
2463                                  "rna_Object_active_material_get",
2464                                  "rna_Object_active_material_set",
2465                                  NULL,
2466                                  "rna_MaterialSlot_material_poll");
2467   RNA_def_property_flag(prop, PROP_EDITABLE);
2468   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2469   RNA_def_property_editable_func(prop, "rna_Object_active_material_editable");
2470   RNA_def_property_ui_text(prop, "Active Material", "Active material being displayed");
2471   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_MaterialSlot_update");
2472
2473   prop = RNA_def_property(srna, "active_material_index", PROP_INT, PROP_UNSIGNED);
2474   RNA_def_property_int_sdna(prop, NULL, "actcol");
2475   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2476   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2477   RNA_def_property_int_funcs(prop,
2478                              "rna_Object_active_material_index_get",
2479                              "rna_Object_active_material_index_set",
2480                              "rna_Object_active_material_index_range");
2481   RNA_def_property_ui_text(prop, "Active Material Index", "Index of active material slot");
2482   RNA_def_property_update(prop, NC_MATERIAL | ND_SHADING_LINKS, "rna_MaterialIndex_update");
2483
2484   /* transform */
2485   prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
2486   RNA_def_property_float_sdna(prop, NULL, "loc");
2487   RNA_def_property_editable_array_func(prop, "rna_Object_location_editable");
2488   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2489   RNA_def_property_ui_text(prop, "Location", "Location of the object");
2490   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
2491   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2492
2493   prop = RNA_def_property(srna, "rotation_quaternion", PROP_FLOAT, PROP_QUATERNION);
2494   RNA_def_property_float_sdna(prop, NULL, "quat");
2495   RNA_def_property_editable_array_func(prop, "rna_Object_rotation_4d_editable");
2496   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2497   RNA_def_property_float_array_default(prop, rna_default_quaternion);
2498   RNA_def_property_ui_text(prop, "Quaternion Rotation", "Rotation in Quaternions");
2499   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2500
2501   /* XXX: for axis-angle, it would have been nice to have 2 separate fields for UI purposes, but
2502    * having a single one is better for Keyframing and other property-management situations...
2503    */
2504   prop = RNA_def_property(srna, "rotation_axis_angle", PROP_FLOAT, PROP_AXISANGLE);
2505   RNA_def_property_array(prop, 4);
2506   RNA_def_property_float_funcs(
2507       prop, "rna_Object_rotation_axis_angle_get", "rna_Object_rotation_axis_angle_set", NULL);
2508   RNA_def_property_editable_array_func(prop, "rna_Object_rotation_4d_editable");
2509   RNA_def_property_float_array_default(prop, rna_default_axis_angle);
2510   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2511   RNA_def_property_ui_text(
2512       prop, "Axis-Angle Rotation", "Angle of Rotation for Axis-Angle rotation representation");
2513   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2514
2515   prop = RNA_def_property(srna, "rotation_euler", PROP_FLOAT, PROP_EULER);
2516   RNA_def_property_float_sdna(prop, NULL, "rot");
2517   RNA_def_property_editable_array_func(prop, "rna_Object_rotation_euler_editable");
2518   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2519   RNA_def_property_ui_text(prop, "Euler Rotation", "Rotation in Eulers");
2520   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2521
2522   prop = RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
2523   RNA_def_property_enum_sdna(prop, NULL, "rotmode");
2524   RNA_def_property_enum_items(prop, rna_enum_object_rotation_mode_items);
2525   RNA_def_property_enum_funcs(prop, NULL, "rna_Object_rotation_mode_set", NULL);
2526   RNA_def_property_ui_text(prop, "Rotation Mode", "");
2527   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2528
2529   prop = RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
2530   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2531   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2532   RNA_def_property_editable_array_func(prop, "rna_Object_scale_editable");
2533   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 3);
2534   RNA_def_property_float_array_default(prop, rna_default_scale_3d);
2535   RNA_def_property_ui_text(prop, "Scale", "Scaling of the object");
2536   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2537
2538   prop = RNA_def_property(srna, "dimensions", PROP_FLOAT, PROP_XYZ_LENGTH);
2539   RNA_def_property_array(prop, 3);
2540   /* Only as convinient helper for py API, and conflicts with animating scale. */
2541   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2542   RNA_def_property_float_funcs(
2543       prop, "rna_Object_dimensions_get", "rna_Object_dimensions_set", NULL);
2544   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
2545   RNA_def_property_ui_text(
2546       prop,
2547       "Dimensions",
2548       "Absolute bounding box dimensions of the object (WARNING: assigning to it or "
2549       "its members mutiple consecutive times will not work correctly, "
2550       "as this needs up-to-date evaluated data)");
2551   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2552
2553   /* delta transforms */
2554   prop = RNA_def_property(srna, "delta_location", PROP_FLOAT, PROP_TRANSLATION);
2555   RNA_def_property_float_sdna(prop, NULL, "dloc");
2556   RNA_def_property_ui_text(
2557       prop, "Delta Location", "Extra translation added to the location of the object");
2558   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
2559   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2560
2561   prop = RNA_def_property(srna, "delta_rotation_euler", PROP_FLOAT, PROP_EULER);
2562   RNA_def_property_float_sdna(prop, NULL, "drot");
2563   RNA_def_property_ui_text(
2564       prop,
2565       "Delta Rotation (Euler)",
2566       "Extra rotation added to the rotation of the object (when using Euler rotations)");
2567   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2568
2569   prop = RNA_def_property(srna, "delta_rotation_quaternion", PROP_FLOAT, PROP_QUATERNION);
2570   RNA_def_property_float_sdna(prop, NULL, "dquat");
2571   RNA_def_property_float_array_default(prop, rna_default_quaternion);
2572   RNA_def_property_ui_text(
2573       prop,
2574       "Delta Rotation (Quaternion)",
2575       "Extra rotation added to the rotation of the object (when using Quaternion rotations)");
2576   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2577
2578 #  if 0 /* XXX not supported well yet... */
2579   prop = RNA_def_property(srna, "delta_rotation_axis_angle", PROP_FLOAT, PROP_AXISANGLE);
2580   /* FIXME: this is not a single field any more! (drotAxis and drotAngle) */
2581   RNA_def_property_float_sdna(prop, NULL, "dquat");
2582   RNA_def_property_float_array_default(prop, rna_default_axis_angle);
2583   RNA_def_property_ui_text(
2584       prop,
2585       "Delta Rotation (Axis Angle)",
2586       "Extra rotation added to the rotation of the object (when using Axis-Angle rotations)");
2587   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2588 #  endif
2589
2590   prop = RNA_def_property(srna, "delta_scale", PROP_FLOAT, PROP_XYZ);
2591   RNA_def_property_float_sdna(prop, NULL, "dscale");
2592   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
2593   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, 3);
2594   RNA_def_property_float_array_default(prop, rna_default_scale_3d);
2595   RNA_def_property_ui_text(prop, "Delta Scale", "Extra scaling added to the scale of the object");
2596   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2597
2598   /* transform locks */
2599   prop = RNA_def_property(srna, "lock_location", PROP_BOOLEAN, PROP_NONE);
2600   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_LOCX);
2601   RNA_def_property_array(prop, 3);
2602   RNA_def_property_ui_text(prop, "Lock Location", "Lock editing of location in the interface");
2603   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2604   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2605
2606   prop = RNA_def_property(srna, "lock_rotation", PROP_BOOLEAN, PROP_NONE);
2607   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTX);
2608   RNA_def_property_array(prop, 3);
2609   RNA_def_property_ui_text(prop, "Lock Rotation", "Lock editing of rotation in the interface");
2610   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2611   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2612
2613   /* XXX this is sub-optimal - it really should be included above,
2614    *     but due to technical reasons we can't do this! */
2615   prop = RNA_def_property(srna, "lock_rotation_w", PROP_BOOLEAN, PROP_NONE);
2616   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTW);
2617   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2618   RNA_def_property_ui_text(
2619       prop,
2620       "Lock Rotation (4D Angle)",
2621       "Lock editing of 'angle' component of four-component rotations in the interface");
2622   /* XXX this needs a better name */
2623   prop = RNA_def_property(srna, "lock_rotations_4d", PROP_BOOLEAN, PROP_NONE);
2624   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROT4D);
2625   RNA_def_property_ui_text(
2626       prop,
2627       "Lock Rotations (4D)",
2628       "Lock editing of four component rotations by components (instead of as Eulers)");
2629
2630   prop = RNA_def_property(srna, "lock_scale", PROP_BOOLEAN, PROP_NONE);
2631   RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_SCALEX);
2632   RNA_def_property_array(prop, 3);
2633   RNA_def_property_ui_text(prop, "Lock Scale", "Lock editing of scale in the interface");
2634   RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
2635   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2636
2637   /* matrix */
2638   prop = RNA_def_property(srna, "matrix_world", PROP_FLOAT, PROP_MATRIX);
2639   RNA_def_property_float_sdna(prop, NULL, "obmat");
2640   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2641   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2642   RNA_def_property_ui_text(prop, "Matrix World", "Worldspace transformation matrix");
2643   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_matrix_world_update");
2644
2645   prop = RNA_def_property(srna, "matrix_local", PROP_FLOAT, PROP_MATRIX);
2646   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2647   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2648   RNA_def_property_ui_text(
2649       prop,
2650       "Local Matrix",
2651       "Parent relative transformation matrix - "
2652       "WARNING: Only takes into account 'Object' parenting, so e.g. in case of bone parenting "
2653       "you get a matrix relative to the Armature object, not to the actual parent bone");
2654   RNA_def_property_float_funcs(
2655       prop, "rna_Object_matrix_local_get", "rna_Object_matrix_local_set", NULL);
2656   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2657
2658   prop = RNA_def_property(srna, "matrix_basis", PROP_FLOAT, PROP_MATRIX);
2659   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2660   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2661   RNA_def_property_ui_text(prop,
2662                            "Input Matrix",
2663                            "Matrix access to location, rotation and scale (including deltas), "
2664                            "before constraints and parenting are applied");
2665   RNA_def_property_float_funcs(
2666       prop, "rna_Object_matrix_basis_get", "rna_Object_matrix_basis_set", NULL);
2667   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2668
2669   /*parent_inverse*/
2670   prop = RNA_def_property(srna, "matrix_parent_inverse", PROP_FLOAT, PROP_MATRIX);
2671   RNA_def_property_float_sdna(prop, NULL, "parentinv");
2672   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
2673   RNA_def_property_ui_text(
2674       prop, "Matrix", "Inverse of object's parent matrix at time of parenting");
2675   RNA_def_property_update(prop, NC_OBJECT | ND_TRANSFORM, "rna_Object_internal_update");
2676
2677   /* modifiers */
2678   prop = RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
2679   RNA_def_property_struct_type(prop, "Modifier");
2680   RNA_def_property_ui_text(
2681       prop, "Modifiers", "Modifiers affecting the geometric data of the object");
2682   RNA_def_property_override_funcs(prop, NULL, NULL, "rna_Object_modifiers_override_apply");
2683   RNA_def_property_override_flag(
2684       prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY | PROPOVERRIDE_LIBRARY_INSERTION);
2685   rna_def_object_modifiers(brna, prop);
2686
2687   /* Grease Pencil modifiers. */
2688   prop = RNA_def_property(srna, "grease_pencil_modifiers", PROP_COLLECTION, PROP_NONE);
2689   RNA_def_property_collection_sdna(prop, NULL, "greasepencil_modifiers", NULL);
2690   RNA_def_property_struct_type(prop, "GpencilModifier");
2691   RNA_def_property_ui_text(
2692       prop, "Grease Pencil Modifiers", "Modifiers affecting the data of the grease pencil object");
2693   rna_def_object_grease_pencil_modifiers(brna, prop);
2694
2695   /* Shader FX. */
2696   prop = RNA_def_property(srna, "shader_effects", PROP_COLLECTION, PROP_NONE);
2697   RNA_def_property_collection_sdna(prop, NULL, "shader_fx", NULL);
2698   RNA_def_property_struct_type(prop, "ShaderFx");
2699   RNA_def_property_ui_text(prop, "Shader Effects", "Effects affecting display of object");
2700   rna_def_object_shaderfxs(brna, prop);
2701
2702   /* constraints */
2703   prop = RNA_def_property(srna, "constraints", PROP_COLLECTION, PROP_NONE);
2704   RNA_def_property_struct_type(prop, "Constraint");
2705   RNA_def_property_override_flag(
2706       prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY | PROPOVERRIDE_LIBRARY_INSERTION);
2707   RNA_def_property_ui_text(
2708       prop, "Constraints", "Constraints affecting the transformation of the object");
2709   RNA_def_property_override_funcs(prop, NULL, NULL, "rna_Object_constraints_override_apply");
2710 #  if 0
2711   RNA_def_property_collection_funcs(
2712       prop, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "constraints__add", "constraints__remove");
2713 #  endif
2714   rna_def_object_constraints(brna, prop);
2715
2716   /* vertex groups */
2717   prop = RNA_def_property(srna, "vertex_groups", PROP_COLLECTION, PROP_NONE);
2718   RNA_def_property_collection_sdna(prop, NULL, "defbase", NULL);
2719   RNA_def_property_struct_type(prop, "VertexGroup");
2720   RNA_def_property_ui_text(prop, "Vertex Groups", "Vertex groups of the object");
2721   rna_def_object_vertex_groups(brna, prop);
2722
2723   /* face maps */
2724   prop = RNA_def_property(srna, "face_maps", PROP_COLLECTION, PROP_NONE);
2725   RNA_def_property_collection_sdna(prop, NULL, "fmaps", NULL);
2726   RNA_def_property_struct_type(prop, "FaceMap");
2727   RNA_def_property_ui_text(prop, "Face Maps", "Maps of faces of the object");
2728   rna_def_object_face_maps(brna, prop);
2729
2730   /* empty */
2731   prop = RNA_def_property(srna, "empty_display_type", PROP_ENUM, PROP_NONE);
2732   RNA_def_property_enum_sdna(prop, NULL, "empty_drawtype");
2733   RNA_def_property_enum_items(prop, rna_enum_object_empty_drawtype_items);
2734   RNA_def_property_enum_funcs(prop, NULL, "rna_Object_empty_display_type_set", NULL);
2735   RNA_def_property_ui_text(prop, "Empty Display Type", "Viewport display style for empties");
2736   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2737
2738   prop = RNA_def_property(srna, "empty_display_size", PROP_FLOAT, PROP_DISTANCE);
2739   RNA_def_property_float_sdna(prop, NULL, "empty_drawsize");
2740   RNA_def_property_range(prop, 0.0001f, 1000.0f);
2741   RNA_def_property_ui_range(prop, 0.01, 100, 1, 2);
2742   RNA_def_property_ui_text(
2743       prop, "Empty Display Size", "Size of display for empties in the viewport");
2744   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2745
2746   prop = RNA_def_property(srna, "empty_image_offset", PROP_FLOAT, PROP_NONE);
2747   RNA_def_property_float_sdna(prop, NULL, "ima_ofs");
2748   RNA_def_property_ui_text(prop, "Origin Offset", "Origin offset distance");
2749   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 0.1f, 2);
2750   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2751
2752   prop = RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NONE);
2753   RNA_def_property_flag(prop, PROP_NEVER_NULL);
2754   RNA_def_property_pointer_sdna(prop, NULL, "iuser");
2755   RNA_def_property_ui_text(
2756       prop,
2757       "Image User",
2758       "Parameters defining which layer, pass and frame of the image is displayed");
2759   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2760
2761   prop = RNA_def_property(srna, "empty_image_depth", PROP_ENUM, PROP_NONE);
2762   RNA_def_property_enum_items(prop, rna_enum_object_empty_image_depth_items);
2763   RNA_def_property_ui_text(
2764       prop, "Empty Image Depth", "Determine which other objects will occlude the image");
2765   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2766
2767   prop = RNA_def_property(srna, "show_empty_image_perspective", PROP_BOOLEAN, PROP_NONE);
2768   RNA_def_property_boolean_negative_sdna(
2769       prop, NULL, "empty_image_visibility_flag", OB_EMPTY_IMAGE_HIDE_PERSPECTIVE);
2770   RNA_def_property_ui_text(
2771       prop, "Display in Perspective Mode", "Display image in perspective mode");
2772   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2773
2774   prop = RNA_def_property(srna, "show_empty_image_orthographic", PROP_BOOLEAN, PROP_NONE);
2775   RNA_def_property_boolean_negative_sdna(
2776       prop, NULL, "empty_image_visibility_flag", OB_EMPTY_IMAGE_HIDE_ORTHOGRAPHIC);
2777   RNA_def_property_ui_text(
2778       prop, "Display in Orthographic Mode", "Display image in orthographic mode");
2779   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2780
2781   prop = RNA_def_property(srna, "use_empty_image_alpha", PROP_BOOLEAN, PROP_NONE);
2782   RNA_def_property_boolean_sdna(prop, NULL, "empty_image_flag", OB_EMPTY_IMAGE_USE_ALPHA_BLEND);
2783   RNA_def_property_ui_text(
2784       prop,
2785       "Use Alpha",
2786       "Use alpha blending instead of alpha test (can produce sorting artifacts)");
2787   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2788
2789   static EnumPropertyItem prop_empty_image_side_items[] = {
2790       {0, "DOUBLE_SIDED", 0, "Both", ""},
2791       {OB_EMPTY_IMAGE_HIDE_BACK, "FRONT", 0, "Front", ""},
2792       {OB_EMPTY_IMAGE_HIDE_FRONT, "BACK", 0, "Back", ""},
2793       {0, NULL, 0, NULL, NULL},
2794   };
2795   prop = RNA_def_property(srna, "empty_image_side", PROP_ENUM, PROP_NONE);
2796   RNA_def_property_enum_bitflag_sdna(prop, NULL, "empty_image_visibility_flag");
2797   RNA_def_property_enum_items(prop, prop_empty_image_side_items);
2798   RNA_def_property_ui_text(prop, "Empty Image Side", "Show front/back side");
2799   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2800
2801   /* render */
2802   prop = RNA_def_property(srna, "pass_index", PROP_INT, PROP_UNSIGNED);
2803   RNA_def_property_int_sdna(prop, NULL, "index");
2804   RNA_def_property_ui_text(
2805       prop, "Pass Index", "Index number for the \"Object Index\" render pass");
2806   RNA_def_property_update(prop, NC_OBJECT, "rna_Object_internal_update_draw");
2807
2808   prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
2809   RNA_def_property_ui_text(
2810       prop, "Color", "Object color and alpha, used when faces have the ObColor mode enabled");
2811   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2812
2813   /* physics */
2814   prop = RNA_def_property(srna, "field", PROP_POINTER, PROP_NONE);
2815   RNA_def_property_pointer_sdna(prop, NULL, "pd");
2816   RNA_def_property_struct_type(prop, "FieldSettings");
2817   RNA_def_property_pointer_funcs(prop, "rna_Object_field_get", NULL, NULL, NULL);
2818   RNA_def_property_ui_text(
2819       prop, "Field Settings", "Settings for using the object as a field in physics simulation");
2820
2821   prop = RNA_def_property(srna, "collision", PROP_POINTER, PROP_NONE);
2822   RNA_def_property_pointer_sdna(prop, NULL, "pd");
2823   RNA_def_property_struct_type(prop, "CollisionSettings");
2824   RNA_def_property_pointer_funcs(prop, "rna_Object_collision_get", NULL, NULL, NULL);
2825   RNA_def_property_ui_text(prop,
2826                            "Collision Settings",
2827                            "Settings for using the object as a collider in physics simulation");
2828
2829   prop = RNA_def_property(srna, "soft_body", PROP_POINTER, PROP_NONE);
2830   RNA_def_property_pointer_sdna(prop, NULL, "soft");
2831   RNA_def_property_struct_type(prop, "SoftBodySettings");
2832   RNA_def_property_ui_text(prop, "Soft Body Settings", "Settings for soft body simulation");
2833
2834   prop = RNA_def_property(srna, "particle_systems", PROP_COLLECTION, PROP_NONE);
2835   RNA_def_property_collection_sdna(prop, NULL, "particlesystem", NULL);
2836   RNA_def_property_struct_type(prop, "ParticleSystem");
2837   RNA_def_property_ui_text(prop, "Particle Systems", "Particle systems emitted from the object");
2838   rna_def_object_particle_systems(brna, prop);
2839
2840   prop = RNA_def_property(srna, "rigid_body", PROP_POINTER, PROP_NONE);
2841   RNA_def_property_pointer_sdna(prop, NULL, "rigidbody_object");
2842   RNA_def_property_struct_type(prop, "RigidBodyObject");
2843   RNA_def_property_ui_text(prop, "Rigid Body Settings", "Settings for rigid body simulation");
2844
2845   prop = RNA_def_property(srna, "rigid_body_constraint", PROP_POINTER, PROP_NONE);
2846   RNA_def_property_pointer_sdna(prop, NULL, "rigidbody_constraint");
2847   RNA_def_property_struct_type(prop, "RigidBodyConstraint");
2848   RNA_def_property_ui_text(prop, "Rigid Body Constraint", "Constraint constraining rigid bodies");
2849
2850   /* restrict */
2851   prop = RNA_def_property(srna, "hide_viewport", PROP_BOOLEAN, PROP_NONE);
2852   RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", OB_RESTRICT_VIEWPORT);
2853   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2854   RNA_def_property_ui_text(prop, "Disable in Viewports", "Globally disable in viewports");
2855   RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, -1);
2856   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_hide_update");
2857
2858   prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
2859   RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", OB_RESTRICT_SELECT);
2860   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
2861   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2862   RNA_def_property_ui_text(prop, "Disable Selection", "Disable selection in viewport");
2863   RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, -1);
2864   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_hide_update");
2865
2866   prop = RNA_def_property(srna, "hide_render", PROP_BOOLEAN, PROP_NONE);
2867   RNA_def_property_boolean_sdna(prop, NULL, "restrictflag", OB_RESTRICT_RENDER);
2868   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2869   RNA_def_property_ui_text(prop, "Disable in Renders", "Globally disable in renders");
2870   RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, -1);
2871   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_hide_update");
2872
2873   prop = RNA_def_property(srna, "show_instancer_for_render", PROP_BOOLEAN, PROP_NONE);
2874   RNA_def_property_boolean_sdna(prop, NULL, "duplicator_visibility_flag", OB_DUPLI_FLAG_RENDER);
2875   RNA_def_property_ui_text(prop, "Render Instancer", "Make instancer visible when rendering");
2876
2877   prop = RNA_def_property(srna, "show_instancer_for_viewport", PROP_BOOLEAN, PROP_NONE);
2878   RNA_def_property_boolean_sdna(prop, NULL, "duplicator_visibility_flag", OB_DUPLI_FLAG_VIEWPORT);
2879   RNA_def_property_ui_text(prop, "Display Instancer", "Make instancer visible in the viewport");
2880
2881   /* anim */
2882   rna_def_animdata_common(srna);
2883
2884   rna_def_animviz_common(srna);
2885   rna_def_motionpath_common(srna);
2886
2887   /* instancing */
2888   prop = RNA_def_property(srna, "instance_type", PROP_ENUM, PROP_NONE);
2889   RNA_def_property_enum_bitflag_sdna(prop, NULL, "transflag");
2890   RNA_def_property_enum_items(prop, instance_items);
2891   RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Object_instance_type_itemf");
2892   RNA_def_property_ui_text(prop, "Instance Type", "If not None, object instancing method to use");
2893   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2894
2895   prop = RNA_def_property(srna, "use_instance_vertices_rotation", PROP_BOOLEAN, PROP_NONE);
2896   RNA_def_property_boolean_sdna(prop, NULL, "transflag", OB_DUPLIROT);
2897   RNA_def_property_ui_text(
2898       prop, "Orient with Normals", "Rotate instance according to vertex normal");
2899   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2900
2901   prop = RNA_def_property(srna, "use_instance_faces_scale", PROP_BOOLEAN, PROP_NONE);
2902   RNA_def_property_boolean_sdna(prop, NULL, "transflag", OB_DUPLIFACES_SCALE);
2903   RNA_def_property_ui_text(prop, "Scale to Face Sizes", "Scale instance based on face size");
2904   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2905
2906   prop = RNA_def_property(srna, "instance_faces_scale", PROP_FLOAT, PROP_NONE);
2907   RNA_def_property_float_sdna(prop, NULL, "instance_faces_scale");
2908   RNA_def_property_range(prop, 0.001f, 10000.0f);
2909   RNA_def_property_ui_text(prop, "Instance Faces Scale", "Scale the face instance objects");
2910   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2911
2912   prop = RNA_def_property(srna, "instance_collection", PROP_POINTER, PROP_NONE);
2913   RNA_def_property_struct_type(prop, "Collection");
2914   RNA_def_property_pointer_sdna(prop, NULL, "instance_collection");
2915   RNA_def_property_flag(prop, PROP_EDITABLE);
2916   RNA_def_property_pointer_funcs(prop, NULL, "rna_Object_dup_collection_set", NULL, NULL);
2917   RNA_def_property_ui_text(prop, "Instance Collection", "Instance an existing collection");
2918   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_dependency_update");
2919
2920   prop = RNA_def_property(srna, "is_instancer", PROP_BOOLEAN, PROP_NONE);
2921   RNA_def_property_boolean_sdna(prop, NULL, "transflag", OB_DUPLI);
2922   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
2923
2924   /* drawing */
2925   prop = RNA_def_property(srna, "display_type", PROP_ENUM, PROP_NONE);
2926   RNA_def_property_enum_sdna(prop, NULL, "dt");
2927   RNA_def_property_enum_items(prop, drawtype_items);
2928   RNA_def_property_ui_text(prop, "Display As", "How to display object in viewport");
2929   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_Object_internal_update");
2930
2931   prop = RNA_def_property(srna, "show_bounds", PROP_BOOLEAN, PROP_NONE);
2932   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWBOUNDOX);
2933   RNA_def_property_ui_text(prop, "Display Bounds", "Display the object's bounds");
2934   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2935
2936   prop = RNA_def_property(srna, "display_bounds_type", PROP_ENUM, PROP_NONE);
2937   RNA_def_property_enum_sdna(prop, NULL, "boundtype");
2938   RNA_def_property_enum_items(prop, boundtype_items);
2939   RNA_def_property_ui_text(prop, "Display Bounds Type", "Object boundary display type");
2940   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2941
2942   prop = RNA_def_property(srna, "show_name", PROP_BOOLEAN, PROP_NONE);
2943   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWNAME);
2944   RNA_def_property_ui_text(prop, "Display Name", "Display the object's name");
2945   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2946
2947   prop = RNA_def_property(srna, "show_axis", PROP_BOOLEAN, PROP_NONE);
2948   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_AXIS);
2949   RNA_def_property_ui_text(prop, "Display Axes", "Display the object's origin and axes");
2950   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2951
2952   prop = RNA_def_property(srna, "show_texture_space", PROP_BOOLEAN, PROP_NONE);
2953   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_TEXSPACE);
2954   RNA_def_property_ui_text(prop, "Display Texture Space", "Display the object's texture space");
2955   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2956
2957   prop = RNA_def_property(srna, "show_wire", PROP_BOOLEAN, PROP_NONE);
2958   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWWIRE);
2959   RNA_def_property_ui_text(prop, "Display Wire", "Add the object's wireframe over solid drawing");
2960   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2961
2962   prop = RNA_def_property(srna, "show_all_edges", PROP_BOOLEAN, PROP_NONE);
2963   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAW_ALL_EDGES);
2964   RNA_def_property_ui_text(prop, "Display All Edges", "Display all edges for mesh objects");
2965   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2966
2967   prop = RNA_def_property(srna, "show_transparent", PROP_BOOLEAN, PROP_NONE);
2968   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWTRANSP);
2969   RNA_def_property_ui_text(
2970       prop, "Display Transparent", "Display material transparency in the object");
2971   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2972
2973   prop = RNA_def_property(srna, "show_in_front", PROP_BOOLEAN, PROP_NONE);
2974   RNA_def_property_boolean_sdna(prop, NULL, "dtx", OB_DRAWXRAY);
2975   RNA_def_property_ui_text(prop, "In Front", "Make the object draw in front of others");
2976   RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, NULL);
2977
2978   /* pose */
2979   prop = RNA_def_property(srna, "pose_library", PROP_POINTER, PROP_NONE);
2980   RNA_def_property_pointer_sdna(prop, NULL, "poselib");
2981   RNA_def_property_struct_type(prop, "Action");
2982   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
2983   RNA_def_property_ui_text(prop, "Pose Library", "Action used as a pose library for armatures");
2984
2985   prop = RNA_def_property(srna, "pose", PROP_POINTER, PROP_NONE);
2986   RNA_def_property_pointer_sdna(prop, NULL, "pose");
2987   RNA_def_property_struct_type(prop, "Pose");
2988   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
2989   RNA_def_property_ui_text(prop, "Pose", "Current pose for armatures");
2990
2991   /* shape keys */
2992   prop = RNA_def_property(srna, "show_only_shape_key", PROP_BOOLEAN, PROP_NONE);
2993   RNA_def_property_boolean_sdna(prop, NULL, "shapeflag", OB_SHAPE_LOCK);
2994   RNA_def_property_ui_text(
2995       prop, "Shape Key Lock", "Always show the current Shape for this Object");
2996   RNA_def_property_ui_icon(prop, ICON_UNPINNED, 1);
2997   RNA_def_property_update(prop, 0, "rna_Object_internal_update_data");
2998
2999   prop = RNA_def_property(srna, "use_shape_key_edit_mode", PROP_BOOLEAN, PROP_NONE);
3000   RNA_def_property_boolean_sdna(prop, NULL, "shapeflag", OB_SHAPE_EDIT_MODE);
3001   RNA_def_property_ui_text(
3002       prop, "Shape Key Edit Mode", "Apply shape keys in edit mode (for Meshes only)");
3003   RNA_def_property_ui_icon(prop, ICON_EDITMODE_HLT, 0);
3004   RNA_def_property_update(prop, 0, "rna_Object_internal_update_data");
3005
3006   prop = RNA_def_property(srna, "active_shape_key", PROP_POINTER, PROP_NONE);
3007   RNA_def_property_struct_type(prop, "ShapeKey");
3008   RNA_def_property_pointer_funcs(prop, "rna_Object_active_shape_key_get", NULL, NULL, NULL);
3009   RNA_def_property_ui_text(prop, "Active Shape Key", "Current shape key");
3010
3011   prop = RNA_def_property(srna, "active_shape_key_index", PROP_INT, PROP_NONE);
3012   RNA_def_property_int_sdna(prop, NULL, "shapenr");
3013   RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
3014   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* XXX this is really unpredictable... */
3015   RNA_def_property_int_funcs(prop,
3016                              "rna_Object_active_shape_key_index_get",
3017                              "rna_Object_active_shape_key_index_set",
3018                              "rna_Object_active_shape_key_index_range");
3019   RNA_def_property_ui_text(prop, "Active Shape Key Index", "Current shape key index");
3020   RNA_def_property_update(prop, 0, "rna_Object_active_shape_update");
3021
3022   /* sculpt */
3023   prop = RNA_def_property(srna, "use_dynamic_topology_sculpting", PROP_BOOLEAN, PROP_NONE);
3024   RNA_def_property_boolean_funcs(prop, "rna_Object_use_dynamic_topology_sculpting_get", NULL);
3025   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3026   RNA_def_property_ui_text(prop, "Dynamic Topology Sculpting", NULL);
3027
3028   /* Base Settings */
3029   prop = RNA_def_property(srna, "is_from_instancer", PROP_BOOLEAN, PROP_NONE);
3030   RNA_def_property_boolean_sdna(prop, NULL, "base_flag", BASE_FROM_DUPLI);
3031   RNA_def_property_ui_text(prop, "Base from Instancer", "Object comes from a instancer");
3032   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3033
3034   prop = RNA_def_property(srna, "is_from_set", PROP_BOOLEAN, PROP_NONE);
3035   RNA_def_property_boolean_sdna(prop, NULL, "base_flag", BASE_FROM_SET);
3036   RNA_def_property_ui_text(prop, "Base from Set", "Object comes from a background set");
3037   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
3038
3039   /* Object Display */
3040   prop = RNA_def_property(srna, "display", PROP_POINTER, PROP_NONE);
3041   RNA_def_property_flag(prop, PROP_NEVER_NULL);
3042   RNA_def_property_struct_type(prop, "ObjectDisplay");
3043   RNA_def_property_pointer_funcs(prop, "rna_Object_display_get", NULL, NULL, NULL);
3044   RNA_def_property_ui_text(prop, "Object Display", "Object display settings for 3d viewport");
3045
3046   RNA_api_object(srna);
3047 }
3048
3049 void RNA_def_object(BlenderRNA *brna)
3050 {
3051   rna_def_object(brna);
3052
3053   RNA_define_animate_sdna(false);
3054   rna_def_vertex_group(brna);
3055   rna_def_face_map(brna);
3056   rna_def_material_slot(brna);
3057   rna_def_object_display(brna);
3058   RNA_define_animate_sdna(true);
3059 }
3060
3061 #endif