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