5f41bf68572e1ceb66d1a1dce86bbfa46759174c
[blender.git] / source / blender / makesrna / intern / rna_object_api.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2009 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup RNA
22  */
23
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <time.h>
28
29 #include "BLI_utildefines.h"
30 #include "BLI_kdopbvh.h"
31
32 #include "RNA_define.h"
33
34 #include "DNA_constraint_types.h"
35 #include "DNA_layer_types.h"
36 #include "DNA_modifier_types.h"
37 #include "DNA_object_types.h"
38
39 #include "BKE_layer.h"
40
41 #include "DEG_depsgraph.h"
42
43 #include "rna_internal.h" /* own include */
44
45 static const EnumPropertyItem space_items[] = {
46     {CONSTRAINT_SPACE_WORLD, "WORLD", 0, "World Space", "The most global space in Blender"},
47     {CONSTRAINT_SPACE_POSE,
48      "POSE",
49      0,
50      "Pose Space",
51      "The pose space of a bone (its armature's object space)"},
52     {CONSTRAINT_SPACE_PARLOCAL,
53      "LOCAL_WITH_PARENT",
54      0,
55      "Local With Parent",
56      "The rest pose local space of a bone (thus matrix includes parent transforms)"},
57     {CONSTRAINT_SPACE_LOCAL, "LOCAL", 0, "Local Space", "The local space of an object/bone"},
58     {0, NULL, 0, NULL, NULL},
59 };
60
61 #ifdef RNA_RUNTIME
62
63 #  include "BLI_math.h"
64
65 #  include "BKE_anim.h"
66 #  include "BKE_bvhutils.h"
67 #  include "BKE_constraint.h"
68 #  include "BKE_context.h"
69 #  include "BKE_customdata.h"
70 #  include "BKE_font.h"
71 #  include "BKE_global.h"
72 #  include "BKE_main.h"
73 #  include "BKE_mesh.h"
74 #  include "BKE_mball.h"
75 #  include "BKE_modifier.h"
76 #  include "BKE_object.h"
77 #  include "BKE_report.h"
78
79 #  include "ED_object.h"
80 #  include "ED_screen.h"
81
82 #  include "DNA_curve_types.h"
83 #  include "DNA_mesh_types.h"
84 #  include "DNA_meshdata_types.h"
85 #  include "DNA_scene_types.h"
86 #  include "DNA_view3d_types.h"
87
88 #  include "DEG_depsgraph_query.h"
89
90 #  include "MEM_guardedalloc.h"
91
92 static void rna_Object_select_set(
93     Object *ob, bContext *C, ReportList *reports, bool select, ViewLayer *view_layer)
94 {
95   if (view_layer == NULL) {
96     view_layer = CTX_data_view_layer(C);
97   }
98   Base *base = BKE_view_layer_base_find(view_layer, ob);
99
100   if (!base) {
101     BKE_reportf(reports,
102                 RPT_ERROR,
103                 "Object '%s' not in View Layer '%s'!",
104                 ob->id.name + 2,
105                 view_layer->name);
106     return;
107   }
108
109   ED_object_base_select(base, select ? BA_SELECT : BA_DESELECT);
110
111   Scene *scene = CTX_data_scene(C);
112   DEG_id_tag_update(&scene->id, ID_RECALC_SELECT);
113   WM_main_add_notifier(NC_SCENE | ND_OB_SELECT, scene);
114 }
115
116 static bool rna_Object_select_get(Object *ob,
117                                   bContext *C,
118                                   ReportList *reports,
119                                   ViewLayer *view_layer)
120 {
121   if (view_layer == NULL) {
122     view_layer = CTX_data_view_layer(C);
123   }
124   Base *base = BKE_view_layer_base_find(view_layer, ob);
125
126   if (!base) {
127     BKE_reportf(reports,
128                 RPT_ERROR,
129                 "Object '%s' not in View Layer '%s'!",
130                 ob->id.name + 2,
131                 view_layer->name);
132     return false;
133   }
134
135   return ((base->flag & BASE_SELECTED) != 0);
136 }
137
138 static void rna_Object_hide_set(
139     Object *ob, bContext *C, ReportList *reports, bool hide, ViewLayer *view_layer)
140 {
141   if (view_layer == NULL) {
142     view_layer = CTX_data_view_layer(C);
143   }
144   Base *base = BKE_view_layer_base_find(view_layer, ob);
145
146   if (!base) {
147     BKE_reportf(reports,
148                 RPT_ERROR,
149                 "Object '%s' not in View Layer '%s'!",
150                 ob->id.name + 2,
151                 view_layer->name);
152     return;
153   }
154
155   if (hide) {
156     base->flag |= BASE_HIDDEN;
157   }
158   else {
159     base->flag &= ~BASE_HIDDEN;
160   }
161
162   Scene *scene = CTX_data_scene(C);
163   BKE_layer_collection_sync(scene, view_layer);
164   DEG_id_tag_update(&scene->id, ID_RECALC_BASE_FLAGS);
165   WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
166 }
167
168 static bool rna_Object_hide_get(Object *ob,
169                                 bContext *C,
170                                 ReportList *reports,
171                                 ViewLayer *view_layer)
172 {
173   if (view_layer == NULL) {
174     view_layer = CTX_data_view_layer(C);
175   }
176   Base *base = BKE_view_layer_base_find(view_layer, ob);
177
178   if (!base) {
179     BKE_reportf(reports,
180                 RPT_ERROR,
181                 "Object '%s' not in View Layer '%s'!",
182                 ob->id.name + 2,
183                 view_layer->name);
184     return false;
185   }
186
187   return ((base->flag & BASE_HIDDEN) != 0);
188 }
189
190 static bool rna_Object_visible_get(
191     Object *ob, bContext *C, ReportList *reports, ViewLayer *view_layer, View3D *v3d)
192 {
193   if (view_layer == NULL) {
194     view_layer = CTX_data_view_layer(C);
195   }
196   if (v3d == NULL) {
197     v3d = CTX_wm_view3d(C);
198   }
199   Base *base = BKE_view_layer_base_find(view_layer, ob);
200
201   if (!base) {
202     BKE_reportf(reports,
203                 RPT_ERROR,
204                 "Object '%s' not in View Layer '%s'!",
205                 ob->id.name + 2,
206                 view_layer->name);
207     return false;
208   }
209
210   return BASE_VISIBLE(v3d, base);
211 }
212
213 static bool rna_Object_holdout_get(Object *ob,
214                                    bContext *C,
215                                    ReportList *reports,
216                                    ViewLayer *view_layer)
217 {
218   if (view_layer == NULL) {
219     view_layer = CTX_data_view_layer(C);
220   }
221   Base *base = BKE_view_layer_base_find(view_layer, ob);
222
223   if (!base) {
224     BKE_reportf(reports,
225                 RPT_ERROR,
226                 "Object '%s' not in View Layer '%s'!",
227                 ob->id.name + 2,
228                 view_layer->name);
229     return false;
230   }
231
232   return ((base->flag & BASE_HOLDOUT) != 0);
233 }
234
235 static bool rna_Object_indirect_only_get(Object *ob,
236                                          bContext *C,
237                                          ReportList *reports,
238                                          ViewLayer *view_layer)
239 {
240   if (view_layer == NULL) {
241     view_layer = CTX_data_view_layer(C);
242   }
243   Base *base = BKE_view_layer_base_find(view_layer, ob);
244
245   if (!base) {
246     BKE_reportf(reports,
247                 RPT_ERROR,
248                 "Object '%s' not in View Layer '%s'!",
249                 ob->id.name + 2,
250                 view_layer->name);
251     return false;
252   }
253
254   return ((base->flag & BASE_INDIRECT_ONLY) != 0);
255 }
256
257 static Base *rna_Object_local_view_property_helper(
258     bScreen *sc, View3D *v3d, Object *ob, ReportList *reports, Scene **r_scene)
259 {
260   if (v3d->localvd == NULL) {
261     BKE_report(reports, RPT_ERROR, "Viewport not in local view");
262     return NULL;
263   }
264
265   wmWindow *win = ED_screen_window_find(sc, G_MAIN->wm.first);
266   ViewLayer *view_layer = WM_window_get_active_view_layer(win);
267   Base *base = BKE_view_layer_base_find(view_layer, ob);
268   if (base == NULL) {
269     BKE_reportf(
270         reports, RPT_WARNING, "Object %s not in view layer %s", ob->id.name + 2, view_layer->name);
271   }
272   if (r_scene) {
273     *r_scene = win->scene;
274   }
275   return base;
276 }
277
278 static bool rna_Object_local_view_get(Object *ob, ReportList *reports, PointerRNA *v3d_ptr)
279 {
280   bScreen *sc = v3d_ptr->id.data;
281   View3D *v3d = v3d_ptr->data;
282   Base *base = rna_Object_local_view_property_helper(sc, v3d, ob, reports, NULL);
283   if (base == NULL) {
284     return false; /* Error reported. */
285   }
286   return (base->local_view_bits & v3d->local_view_uuid) != 0;
287 }
288
289 static void rna_Object_local_view_set(Object *ob,
290                                       ReportList *reports,
291                                       PointerRNA *v3d_ptr,
292                                       bool state)
293 {
294   bScreen *sc = v3d_ptr->id.data;
295   View3D *v3d = v3d_ptr->data;
296   Scene *scene;
297   Base *base = rna_Object_local_view_property_helper(sc, v3d, ob, reports, &scene);
298   if (base == NULL) {
299     return; /* Error reported. */
300   }
301   const short local_view_bits_prev = base->local_view_bits;
302   SET_FLAG_FROM_TEST(base->local_view_bits, state, v3d->local_view_uuid);
303   if (local_view_bits_prev != base->local_view_bits) {
304     DEG_id_tag_update(&scene->id, ID_RECALC_BASE_FLAGS);
305     ScrArea *sa = ED_screen_area_find_with_spacedata(sc, (SpaceLink *)v3d, true);
306     if (sa) {
307       ED_area_tag_redraw(sa);
308     }
309   }
310 }
311
312 /* Convert a given matrix from a space to another (using the object and/or a bone as reference). */
313 static void rna_Object_mat_convert_space(Object *ob,
314                                          ReportList *reports,
315                                          bPoseChannel *pchan,
316                                          float *mat,
317                                          float *mat_ret,
318                                          int from,
319                                          int to)
320 {
321   copy_m4_m4((float(*)[4])mat_ret, (float(*)[4])mat);
322
323   /* Error in case of invalid from/to values when pchan is NULL */
324   if (pchan == NULL) {
325     if (ELEM(from, CONSTRAINT_SPACE_POSE, CONSTRAINT_SPACE_PARLOCAL)) {
326       const char *identifier = NULL;
327       RNA_enum_identifier(space_items, from, &identifier);
328       BKE_reportf(reports,
329                   RPT_ERROR,
330                   "'from_space' '%s' is invalid when no pose bone is given!",
331                   identifier);
332       return;
333     }
334     if (ELEM(to, CONSTRAINT_SPACE_POSE, CONSTRAINT_SPACE_PARLOCAL)) {
335       const char *identifier = NULL;
336       RNA_enum_identifier(space_items, to, &identifier);
337       BKE_reportf(reports,
338                   RPT_ERROR,
339                   "'to_space' '%s' is invalid when no pose bone is given!",
340                   identifier);
341       return;
342     }
343   }
344
345   BKE_constraint_mat_convertspace(ob, pchan, (float(*)[4])mat_ret, from, to, false);
346 }
347
348 static void rna_Object_calc_matrix_camera(Object *ob,
349                                           Depsgraph *depsgraph,
350                                           float mat_ret[16],
351                                           int width,
352                                           int height,
353                                           float scalex,
354                                           float scaley)
355 {
356   const Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
357   CameraParams params;
358
359   /* setup parameters */
360   BKE_camera_params_init(&params);
361   BKE_camera_params_from_object(&params, ob_eval);
362
363   /* compute matrix, viewplane, .. */
364   BKE_camera_params_compute_viewplane(&params, width, height, scalex, scaley);
365   BKE_camera_params_compute_matrix(&params);
366
367   copy_m4_m4((float(*)[4])mat_ret, params.winmat);
368 }
369
370 static void rna_Object_camera_fit_coords(
371     Object *ob, Depsgraph *depsgraph, int num_cos, float *cos, float co_ret[3], float *scale_ret)
372 {
373   BKE_camera_view_frame_fit_to_coords(
374       depsgraph, (const float(*)[3])cos, num_cos / 3, ob, co_ret, scale_ret);
375 }
376
377 /* copied from Mesh_getFromObject and adapted to RNA interface */
378 /* settings: 0 - preview, 1 - render */
379 static Mesh *rna_Object_to_mesh(Object *ob,
380                                 bContext *C,
381                                 ReportList *reports,
382                                 Depsgraph *depsgraph,
383                                 bool apply_modifiers,
384                                 bool calc_undeformed)
385 {
386   Main *bmain = CTX_data_main(C);
387
388   return rna_Main_meshes_new_from_object(
389       bmain, reports, depsgraph, ob, apply_modifiers, calc_undeformed);
390 }
391
392 static PointerRNA rna_Object_shape_key_add(
393     Object *ob, bContext *C, ReportList *reports, const char *name, bool from_mix)
394 {
395   Main *bmain = CTX_data_main(C);
396   KeyBlock *kb = NULL;
397
398   if ((kb = BKE_object_shapekey_insert(bmain, ob, name, from_mix))) {
399     PointerRNA keyptr;
400
401     RNA_pointer_create((ID *)ob->data, &RNA_ShapeKey, kb, &keyptr);
402     WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
403
404     return keyptr;
405   }
406   else {
407     BKE_reportf(reports, RPT_ERROR, "Object '%s' does not support shapes", ob->id.name + 2);
408     return PointerRNA_NULL;
409   }
410 }
411
412 static void rna_Object_shape_key_remove(Object *ob,
413                                         Main *bmain,
414                                         ReportList *reports,
415                                         PointerRNA *kb_ptr)
416 {
417   KeyBlock *kb = kb_ptr->data;
418   Key *key = BKE_key_from_object(ob);
419
420   if ((key == NULL) || BLI_findindex(&key->block, kb) == -1) {
421     BKE_report(reports, RPT_ERROR, "ShapeKey not found");
422     return;
423   }
424
425   if (!BKE_object_shapekey_remove(bmain, ob, kb)) {
426     BKE_report(reports, RPT_ERROR, "Could not remove ShapeKey");
427     return;
428   }
429
430   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
431   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
432
433   RNA_POINTER_INVALIDATE(kb_ptr);
434 }
435
436 static void rna_Object_shape_key_clear(Object *ob, Main *bmain)
437 {
438   BKE_object_shapekey_free(bmain, ob);
439
440   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
441   WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
442 }
443
444 #  if 0
445 static void rna_Mesh_assign_verts_to_group(
446     Object *ob, bDeformGroup *group, int *indices, int totindex, float weight, int assignmode)
447 {
448   if (ob->type != OB_MESH) {
449     BKE_report(reports, RPT_ERROR, "Object should be of mesh type");
450     return;
451   }
452
453   Mesh *me = (Mesh *)ob->data;
454   int group_index = BLI_findlink(&ob->defbase, group);
455   if (group_index == -1) {
456     BKE_report(reports, RPT_ERROR, "No vertex groups assigned to mesh");
457     return;
458   }
459
460   if (assignmode != WEIGHT_REPLACE && assignmode != WEIGHT_ADD && assignmode != WEIGHT_SUBTRACT) {
461     BKE_report(reports, RPT_ERROR, "Bad assignment mode");
462     return;
463   }
464
465   /* makes a set of dVerts corresponding to the mVerts */
466   if (!me->dvert)
467     create_dverts(&me->id);
468
469   /* loop list adding verts to group  */
470   for (i = 0; i < totindex; i++) {
471     if (i < 0 || i >= me->totvert) {
472       BKE_report(reports, RPT_ERROR, "Bad vertex index in list");
473       return;
474     }
475
476     add_vert_defnr(ob, group_index, i, weight, assignmode);
477   }
478 }
479 #  endif
480
481 /* don't call inside a loop */
482 static int mesh_looptri_to_poly_index(Mesh *me_eval, const MLoopTri *lt)
483 {
484   const int *index_mp_to_orig = CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX);
485   return index_mp_to_orig ? index_mp_to_orig[lt->poly] : lt->poly;
486 }
487
488 static Object *eval_object_ensure(Object *ob,
489                                   bContext *C,
490                                   ReportList *reports,
491                                   PointerRNA *rnaptr_depsgraph)
492 {
493   if (ob->runtime.mesh_eval == NULL) {
494     Object *ob_orig = ob;
495     Depsgraph *depsgraph = rnaptr_depsgraph != NULL ? rnaptr_depsgraph->data : NULL;
496     if (depsgraph == NULL) {
497       depsgraph = CTX_data_depsgraph(C);
498     }
499     if (depsgraph != NULL) {
500       ob = DEG_get_evaluated_object(depsgraph, ob);
501     }
502     if (ob == NULL || ob->runtime.mesh_eval == NULL) {
503       BKE_reportf(
504           reports, RPT_ERROR, "Object '%s' has no evaluated mesh data", ob_orig->id.name + 2);
505       return NULL;
506     }
507   }
508   return ob;
509 }
510
511 static void rna_Object_ray_cast(Object *ob,
512                                 bContext *C,
513                                 ReportList *reports,
514                                 float origin[3],
515                                 float direction[3],
516                                 float distance,
517                                 PointerRNA *rnaptr_depsgraph,
518                                 bool *r_success,
519                                 float r_location[3],
520                                 float r_normal[3],
521                                 int *r_index)
522 {
523   bool success = false;
524
525   if (ob->runtime.mesh_eval == NULL &&
526       (ob = eval_object_ensure(ob, C, reports, rnaptr_depsgraph)) == NULL) {
527     return;
528   }
529
530   /* Test BoundBox first (efficiency) */
531   BoundBox *bb = BKE_object_boundbox_get(ob);
532   float distmin;
533   normalize_v3(
534       direction); /* Needed for valid distance check from isect_ray_aabb_v3_simple() call. */
535   if (!bb ||
536       (isect_ray_aabb_v3_simple(origin, direction, bb->vec[0], bb->vec[6], &distmin, NULL) &&
537        distmin <= distance)) {
538     BVHTreeFromMesh treeData = {NULL};
539
540     /* No need to managing allocation or freeing of the BVH data.
541      * This is generated and freed as needed. */
542     BKE_bvhtree_from_mesh_get(&treeData, ob->runtime.mesh_eval, BVHTREE_FROM_LOOPTRI, 4);
543
544     /* may fail if the mesh has no faces, in that case the ray-cast misses */
545     if (treeData.tree != NULL) {
546       BVHTreeRayHit hit;
547
548       hit.index = -1;
549       hit.dist = distance;
550
551       if (BLI_bvhtree_ray_cast(treeData.tree,
552                                origin,
553                                direction,
554                                0.0f,
555                                &hit,
556                                treeData.raycast_callback,
557                                &treeData) != -1) {
558         if (hit.dist <= distance) {
559           *r_success = success = true;
560
561           copy_v3_v3(r_location, hit.co);
562           copy_v3_v3(r_normal, hit.no);
563           *r_index = mesh_looptri_to_poly_index(ob->runtime.mesh_eval,
564                                                 &treeData.looptri[hit.index]);
565         }
566       }
567
568       free_bvhtree_from_mesh(&treeData);
569     }
570   }
571   if (success == false) {
572     *r_success = false;
573
574     zero_v3(r_location);
575     zero_v3(r_normal);
576     *r_index = -1;
577   }
578 }
579
580 static void rna_Object_closest_point_on_mesh(Object *ob,
581                                              bContext *C,
582                                              ReportList *reports,
583                                              float origin[3],
584                                              float distance,
585                                              PointerRNA *rnaptr_depsgraph,
586                                              bool *r_success,
587                                              float r_location[3],
588                                              float r_normal[3],
589                                              int *r_index)
590 {
591   BVHTreeFromMesh treeData = {NULL};
592
593   if (ob->runtime.mesh_eval == NULL &&
594       (ob = eval_object_ensure(ob, C, reports, rnaptr_depsgraph)) == NULL) {
595     return;
596   }
597
598   /* No need to managing allocation or freeing of the BVH data.
599    * this is generated and freed as needed. */
600   BKE_bvhtree_from_mesh_get(&treeData, ob->runtime.mesh_eval, BVHTREE_FROM_LOOPTRI, 4);
601
602   if (treeData.tree == NULL) {
603     BKE_reportf(reports,
604                 RPT_ERROR,
605                 "Object '%s' could not create internal data for finding nearest point",
606                 ob->id.name + 2);
607     return;
608   }
609   else {
610     BVHTreeNearest nearest;
611
612     nearest.index = -1;
613     nearest.dist_sq = distance * distance;
614
615     if (BLI_bvhtree_find_nearest(
616             treeData.tree, origin, &nearest, treeData.nearest_callback, &treeData) != -1) {
617       *r_success = true;
618
619       copy_v3_v3(r_location, nearest.co);
620       copy_v3_v3(r_normal, nearest.no);
621       *r_index = mesh_looptri_to_poly_index(ob->runtime.mesh_eval,
622                                             &treeData.looptri[nearest.index]);
623
624       goto finally;
625     }
626   }
627
628   *r_success = false;
629
630   zero_v3(r_location);
631   zero_v3(r_normal);
632   *r_index = -1;
633
634 finally:
635   free_bvhtree_from_mesh(&treeData);
636 }
637
638 static bool rna_Object_is_modified(Object *ob, Scene *scene, int settings)
639 {
640   return BKE_object_is_modified(scene, ob) & settings;
641 }
642
643 static bool rna_Object_is_deform_modified(Object *ob, Scene *scene, int settings)
644 {
645   return BKE_object_is_deform_modified(scene, ob) & settings;
646 }
647
648 #  ifndef NDEBUG
649
650 #    include "BKE_mesh_runtime.h"
651
652 void rna_Object_me_eval_info(
653     struct Object *ob, bContext *C, int type, PointerRNA *rnaptr_depsgraph, char *result)
654 {
655   Mesh *me_eval = NULL;
656   char *ret = NULL;
657
658   result[0] = '\0';
659
660   switch (type) {
661     case 1:
662     case 2:
663       if (ob->runtime.mesh_eval == NULL &&
664           (ob = eval_object_ensure(ob, C, NULL, rnaptr_depsgraph)) == NULL) {
665         return;
666       }
667   }
668
669   switch (type) {
670     case 0:
671       if (ob->type == OB_MESH) {
672         me_eval = ob->data;
673       }
674       break;
675     case 1:
676       me_eval = ob->runtime.mesh_deform_eval;
677       break;
678     case 2:
679       me_eval = ob->runtime.mesh_eval;
680       break;
681   }
682
683   if (me_eval) {
684     ret = BKE_mesh_runtime_debug_info(me_eval);
685     if (ret) {
686       strcpy(result, ret);
687       MEM_freeN(ret);
688     }
689   }
690 }
691 #  endif /* NDEBUG */
692
693 static bool rna_Object_update_from_editmode(Object *ob, Main *bmain)
694 {
695   /* fail gracefully if we aren't in edit-mode. */
696   return ED_object_editmode_load(bmain, ob);
697 }
698 #else /* RNA_RUNTIME */
699
700 void RNA_api_object(StructRNA *srna)
701 {
702   FunctionRNA *func;
703   PropertyRNA *parm;
704
705   static const EnumPropertyItem mesh_type_items[] = {
706       {eModifierMode_Realtime, "PREVIEW", 0, "Preview", "Apply modifier preview settings"},
707       {eModifierMode_Render, "RENDER", 0, "Render", "Apply modifier render settings"},
708       {0, NULL, 0, NULL, NULL},
709   };
710
711 #  ifndef NDEBUG
712   static const EnumPropertyItem mesh_dm_info_items[] = {
713       {0, "SOURCE", 0, "Source", "Source mesh"},
714       {1, "DEFORM", 0, "Deform", "Objects deform mesh"},
715       {2, "FINAL", 0, "Final", "Objects final mesh"},
716       {0, NULL, 0, NULL, NULL},
717   };
718 #  endif
719
720   /* Special wrapper to access the base selection value */
721   func = RNA_def_function(srna, "select_get", "rna_Object_select_get");
722   RNA_def_function_ui_description(
723       func, "Test if the object is selected. The selection state is per view layer");
724   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
725   parm = RNA_def_pointer(
726       func, "view_layer", "ViewLayer", "", "Use this instead of the active view layer");
727   parm = RNA_def_boolean(func, "result", 0, "", "Object selected");
728   RNA_def_function_return(func, parm);
729
730   func = RNA_def_function(srna, "select_set", "rna_Object_select_set");
731   RNA_def_function_ui_description(
732       func, "Select or deselect the object. The selection state is per view layer");
733   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
734   parm = RNA_def_boolean(func, "state", 0, "", "Selection state to define");
735   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
736   parm = RNA_def_pointer(
737       func, "view_layer", "ViewLayer", "", "Use this instead of the active view layer");
738
739   func = RNA_def_function(srna, "hide_get", "rna_Object_hide_get");
740   RNA_def_function_ui_description(
741       func,
742       "Test if the object is hidden for viewport editing. This hiding state is per view layer");
743   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
744   parm = RNA_def_pointer(
745       func, "view_layer", "ViewLayer", "", "Use this instead of the active view layer");
746   parm = RNA_def_boolean(func, "result", 0, "", "Object hideed");
747   RNA_def_function_return(func, parm);
748
749   func = RNA_def_function(srna, "hide_set", "rna_Object_hide_set");
750   RNA_def_function_ui_description(
751       func, "Hide the object for viewport editing. This hiding state is per view layer");
752   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
753   parm = RNA_def_boolean(func, "state", 0, "", "Hide state to define");
754   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
755   parm = RNA_def_pointer(
756       func, "view_layer", "ViewLayer", "", "Use this instead of the active view layer");
757
758   func = RNA_def_function(srna, "visible_get", "rna_Object_visible_get");
759   RNA_def_function_ui_description(func,
760                                   "Test if the object is visible in the 3D viewport, taking into "
761                                   "account all visibility settings");
762   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
763   parm = RNA_def_pointer(
764       func, "view_layer", "ViewLayer", "", "Use this instead of the active view layer");
765   parm = RNA_def_pointer(
766       func, "viewport", "SpaceView3D", "", "Use this instead of the active 3D viewport");
767   parm = RNA_def_boolean(func, "result", 0, "", "Object visible");
768   RNA_def_function_return(func, parm);
769
770   func = RNA_def_function(srna, "holdout_get", "rna_Object_holdout_get");
771   RNA_def_function_ui_description(func, "Test if object is masked in the view layer");
772   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
773   parm = RNA_def_pointer(
774       func, "view_layer", "ViewLayer", "", "Use this instead of the active view layer");
775   parm = RNA_def_boolean(func, "result", 0, "", "Object holdout");
776   RNA_def_function_return(func, parm);
777
778   func = RNA_def_function(srna, "indirect_only_get", "rna_Object_indirect_only_get");
779   RNA_def_function_ui_description(func,
780                                   "Test if object is set to contribute only indirectly (through "
781                                   "shadows and reflections) in the view layer");
782   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
783   parm = RNA_def_pointer(
784       func, "view_layer", "ViewLayer", "", "Use this instead of the active view layer");
785   parm = RNA_def_boolean(func, "result", 0, "", "Object indirect only");
786   RNA_def_function_return(func, parm);
787
788   /* Local View */
789   func = RNA_def_function(srna, "local_view_get", "rna_Object_local_view_get");
790   RNA_def_function_ui_description(func, "Get the local view state for this object");
791   RNA_def_function_flag(func, FUNC_USE_REPORTS);
792   parm = RNA_def_pointer(func, "viewport", "SpaceView3D", "", "Viewport in local view");
793   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR | PARM_REQUIRED);
794   parm = RNA_def_boolean(func, "result", 0, "", "Object local view state");
795   RNA_def_function_return(func, parm);
796
797   func = RNA_def_function(srna, "local_view_set", "rna_Object_local_view_set");
798   RNA_def_function_ui_description(func, "Set the local view state for this object");
799   RNA_def_function_flag(func, FUNC_USE_REPORTS);
800   parm = RNA_def_pointer(func, "viewport", "SpaceView3D", "", "Viewport in local view");
801   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR | PARM_REQUIRED);
802   parm = RNA_def_boolean(func, "state", 0, "", "Local view state to define");
803   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
804
805   /* Matrix space conversion */
806   func = RNA_def_function(srna, "convert_space", "rna_Object_mat_convert_space");
807   RNA_def_function_ui_description(
808       func, "Convert (transform) the given matrix from one space to another");
809   RNA_def_function_flag(func, FUNC_USE_REPORTS);
810   parm = RNA_def_pointer(
811       func,
812       "pose_bone",
813       "PoseBone",
814       "",
815       "Bone to use to define spaces (may be None, in which case only the two 'WORLD' and "
816       "'LOCAL' spaces are usable)");
817   parm = RNA_def_property(func, "matrix", PROP_FLOAT, PROP_MATRIX);
818   RNA_def_property_multi_array(parm, 2, rna_matrix_dimsize_4x4);
819   RNA_def_property_ui_text(parm, "", "The matrix to transform");
820   parm = RNA_def_property(func, "matrix_return", PROP_FLOAT, PROP_MATRIX);
821   RNA_def_property_multi_array(parm, 2, rna_matrix_dimsize_4x4);
822   RNA_def_property_ui_text(parm, "", "The transformed matrix");
823   RNA_def_function_output(func, parm);
824   parm = RNA_def_enum(func,
825                       "from_space",
826                       space_items,
827                       CONSTRAINT_SPACE_WORLD,
828                       "",
829                       "The space in which 'matrix' is currently");
830   parm = RNA_def_enum(func,
831                       "to_space",
832                       space_items,
833                       CONSTRAINT_SPACE_WORLD,
834                       "",
835                       "The space to which you want to transform 'matrix'");
836
837   /* Camera-related operations */
838   func = RNA_def_function(srna, "calc_matrix_camera", "rna_Object_calc_matrix_camera");
839   RNA_def_function_ui_description(func,
840                                   "Generate the camera projection matrix of this object "
841                                   "(mostly useful for Camera and Light types)");
842   parm = RNA_def_pointer(
843       func, "depsgraph", "Depsgraph", "", "Depsgraph to get evaluated data from");
844   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
845   parm = RNA_def_property(func, "result", PROP_FLOAT, PROP_MATRIX);
846   RNA_def_property_multi_array(parm, 2, rna_matrix_dimsize_4x4);
847   RNA_def_property_ui_text(parm, "", "The camera projection matrix");
848   RNA_def_function_output(func, parm);
849   parm = RNA_def_int(func, "x", 1, 0, INT_MAX, "", "Width of the render area", 0, 10000);
850   parm = RNA_def_int(func, "y", 1, 0, INT_MAX, "", "Height of the render area", 0, 10000);
851   parm = RNA_def_float(
852       func, "scale_x", 1.0f, 1.0e-6f, FLT_MAX, "", "Width scaling factor", 1.0e-2f, 100.0f);
853   parm = RNA_def_float(
854       func, "scale_y", 1.0f, 1.0e-6f, FLT_MAX, "", "Height scaling factor", 1.0e-2f, 100.0f);
855
856   func = RNA_def_function(srna, "camera_fit_coords", "rna_Object_camera_fit_coords");
857   RNA_def_function_ui_description(func,
858                                   "Compute the coordinate (and scale for ortho cameras) "
859                                   "given object should be to 'see' all given coordinates");
860   parm = RNA_def_pointer(
861       func, "depsgraph", "Depsgraph", "", "Depsgraph to get evaluated data from");
862   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
863   parm = RNA_def_float_array(func,
864                              "coordinates",
865                              1,
866                              NULL,
867                              -FLT_MAX,
868                              FLT_MAX,
869                              "",
870                              "Coordinates to fit in",
871                              -FLT_MAX,
872                              FLT_MAX);
873   RNA_def_parameter_flags(parm, PROP_NEVER_NULL | PROP_DYNAMIC, PARM_REQUIRED);
874   parm = RNA_def_property(func, "co_return", PROP_FLOAT, PROP_XYZ);
875   RNA_def_property_array(parm, 3);
876   RNA_def_property_ui_text(parm, "", "The location to aim to be able to see all given points");
877   RNA_def_parameter_flags(parm, 0, PARM_OUTPUT);
878   parm = RNA_def_property(func, "scale_return", PROP_FLOAT, PROP_NONE);
879   RNA_def_property_ui_text(
880       parm, "", "The ortho scale to aim to be able to see all given points (if relevant)");
881   RNA_def_parameter_flags(parm, 0, PARM_OUTPUT);
882
883   /* mesh */
884   func = RNA_def_function(srna, "to_mesh", "rna_Object_to_mesh");
885   RNA_def_function_ui_description(func, "Create a Mesh data-block with modifiers applied");
886   RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_CONTEXT);
887   parm = RNA_def_pointer(func,
888                          "depsgraph",
889                          "Depsgraph",
890                          "Dependency Graph",
891                          "Evaluated dependency graph within which to evaluate modifiers");
892   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
893   parm = RNA_def_boolean(func, "apply_modifiers", 0, "", "Apply modifiers");
894   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
895   RNA_def_boolean(func,
896                   "calc_undeformed",
897                   false,
898                   "Calculate Undeformed",
899                   "Calculate undeformed vertex coordinates");
900   parm = RNA_def_pointer(func,
901                          "mesh",
902                          "Mesh",
903                          "",
904                          "Mesh created from object, remove it if it is only used for export");
905   RNA_def_function_return(func, parm);
906
907   /* Armature */
908   func = RNA_def_function(srna, "find_armature", "modifiers_isDeformedByArmature");
909   RNA_def_function_ui_description(
910       func, "Find armature influencing this object as a parent or via a modifier");
911   parm = RNA_def_pointer(
912       func, "ob_arm", "Object", "", "Armature object influencing this object or NULL");
913   RNA_def_function_return(func, parm);
914
915   /* Shape key */
916   func = RNA_def_function(srna, "shape_key_add", "rna_Object_shape_key_add");
917   RNA_def_function_ui_description(func, "Add shape key to this object");
918   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
919   RNA_def_string(func, "name", "Key", 0, "", "Unique name for the new keyblock"); /* optional */
920   RNA_def_boolean(func, "from_mix", 1, "", "Create new shape from existing mix of shapes");
921   parm = RNA_def_pointer(func, "key", "ShapeKey", "", "New shape keyblock");
922   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
923   RNA_def_function_return(func, parm);
924
925   func = RNA_def_function(srna, "shape_key_remove", "rna_Object_shape_key_remove");
926   RNA_def_function_ui_description(func, "Remove a Shape Key from this object");
927   RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS);
928   parm = RNA_def_pointer(func, "key", "ShapeKey", "", "Keyblock to be removed");
929   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
930   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
931
932   func = RNA_def_function(srna, "shape_key_clear", "rna_Object_shape_key_clear");
933   RNA_def_function_ui_description(func, "Remove all Shape Keys from this object");
934   RNA_def_function_flag(func, FUNC_USE_MAIN);
935
936   /* Ray Cast */
937   func = RNA_def_function(srna, "ray_cast", "rna_Object_ray_cast");
938   RNA_def_function_ui_description(
939       func,
940       "Cast a ray onto evaluated geometry, in object space "
941       "(using context's or provided depsgraph to get evaluated mesh if needed)");
942   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
943
944   /* ray start and end */
945   parm = RNA_def_float_vector(func,
946                               "origin",
947                               3,
948                               NULL,
949                               -FLT_MAX,
950                               FLT_MAX,
951                               "",
952                               "Origin of the ray, in object space",
953                               -1e4,
954                               1e4);
955   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
956   parm = RNA_def_float_vector(func,
957                               "direction",
958                               3,
959                               NULL,
960                               -FLT_MAX,
961                               FLT_MAX,
962                               "",
963                               "Direction of the ray, in object space",
964                               -1e4,
965                               1e4);
966   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
967   RNA_def_float(func,
968                 "distance",
969                 BVH_RAYCAST_DIST_MAX,
970                 0.0,
971                 BVH_RAYCAST_DIST_MAX,
972                 "",
973                 "Maximum distance",
974                 0.0,
975                 BVH_RAYCAST_DIST_MAX);
976   parm = RNA_def_pointer(
977       func,
978       "depsgraph",
979       "Depsgraph",
980       "",
981       "Depsgraph to use to get evaluated data, when called from original object "
982       "(only needed if current Context's depsgraph is not suitable)");
983   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
984
985   /* return location and normal */
986   parm = RNA_def_boolean(func, "result", 0, "", "Wheter the ray successfully hit the geometry");
987   RNA_def_function_output(func, parm);
988   parm = RNA_def_float_vector(func,
989                               "location",
990                               3,
991                               NULL,
992                               -FLT_MAX,
993                               FLT_MAX,
994                               "Location",
995                               "The hit location of this ray cast",
996                               -1e4,
997                               1e4);
998   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
999   RNA_def_function_output(func, parm);
1000   parm = RNA_def_float_vector(func,
1001                               "normal",
1002                               3,
1003                               NULL,
1004                               -FLT_MAX,
1005                               FLT_MAX,
1006                               "Normal",
1007                               "The face normal at the ray cast hit location",
1008                               -1e4,
1009                               1e4);
1010   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
1011   RNA_def_function_output(func, parm);
1012   parm = RNA_def_int(
1013       func, "index", 0, 0, 0, "", "The face index, -1 when original data isn't available", 0, 0);
1014   RNA_def_function_output(func, parm);
1015
1016   /* Nearest Point */
1017   func = RNA_def_function(srna, "closest_point_on_mesh", "rna_Object_closest_point_on_mesh");
1018   RNA_def_function_ui_description(
1019       func,
1020       "Find the nearest point on evaluated geometry, in object space "
1021       "(using context's or provided depsgraph to get evaluated mesh if needed)");
1022   RNA_def_function_flag(func, FUNC_USE_CONTEXT | FUNC_USE_REPORTS);
1023
1024   /* location of point for test and max distance */
1025   parm = RNA_def_float_vector(func,
1026                               "origin",
1027                               3,
1028                               NULL,
1029                               -FLT_MAX,
1030                               FLT_MAX,
1031                               "",
1032                               "Point to find closest geometry from (in object space)",
1033                               -1e4,
1034                               1e4);
1035   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1036   /* default is sqrt(FLT_MAX) */
1037   RNA_def_float(
1038       func, "distance", 1.844674352395373e+19, 0.0, FLT_MAX, "", "Maximum distance", 0.0, FLT_MAX);
1039   parm = RNA_def_pointer(
1040       func,
1041       "depsgraph",
1042       "Depsgraph",
1043       "",
1044       "Depsgraph to use to get evaluated data, when called from original object "
1045       "(only needed if current Context's depsgraph is not suitable)");
1046   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1047
1048   /* return location and normal */
1049   parm = RNA_def_boolean(func, "result", 0, "", "Wheter closest point on geometry was found");
1050   RNA_def_function_output(func, parm);
1051   parm = RNA_def_float_vector(func,
1052                               "location",
1053                               3,
1054                               NULL,
1055                               -FLT_MAX,
1056                               FLT_MAX,
1057                               "Location",
1058                               "The location on the object closest to the point",
1059                               -1e4,
1060                               1e4);
1061   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
1062   RNA_def_function_output(func, parm);
1063   parm = RNA_def_float_vector(func,
1064                               "normal",
1065                               3,
1066                               NULL,
1067                               -FLT_MAX,
1068                               FLT_MAX,
1069                               "Normal",
1070                               "The face normal at the closest point",
1071                               -1e4,
1072                               1e4);
1073   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
1074   RNA_def_function_output(func, parm);
1075
1076   parm = RNA_def_int(
1077       func, "index", 0, 0, 0, "", "The face index, -1 when original data isn't available", 0, 0);
1078   RNA_def_function_output(func, parm);
1079
1080   /* View */
1081
1082   /* utility function for checking if the object is modified */
1083   func = RNA_def_function(srna, "is_modified", "rna_Object_is_modified");
1084   RNA_def_function_ui_description(func,
1085                                   "Determine if this object is modified from the base mesh data");
1086   parm = RNA_def_pointer(func, "scene", "Scene", "", "Scene in which to check the object");
1087   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1088   parm = RNA_def_enum(func, "settings", mesh_type_items, 0, "", "Modifier settings to apply");
1089   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1090   parm = RNA_def_boolean(func, "result", 0, "", "Whether the object is modified");
1091   RNA_def_function_return(func, parm);
1092
1093   func = RNA_def_function(srna, "is_deform_modified", "rna_Object_is_deform_modified");
1094   RNA_def_function_ui_description(
1095       func, "Determine if this object is modified by a deformation from the base mesh data");
1096   parm = RNA_def_pointer(func, "scene", "Scene", "", "Scene in which to check the object");
1097   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
1098   parm = RNA_def_enum(func, "settings", mesh_type_items, 0, "", "Modifier settings to apply");
1099   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1100   parm = RNA_def_boolean(func, "result", 0, "", "Whether the object is deform-modified");
1101   RNA_def_function_return(func, parm);
1102
1103 #  ifndef NDEBUG
1104   /* mesh */
1105   func = RNA_def_function(srna, "dm_info", "rna_Object_me_eval_info");
1106   RNA_def_function_ui_description(
1107       func,
1108       "Returns a string for original/evaluated mesh data (debug builds only, "
1109       "using context's or provided depsgraph to get evaluated mesh if needed)");
1110   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
1111
1112   parm = RNA_def_enum(func, "type", mesh_dm_info_items, 0, "", "Modifier settings to apply");
1113   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1114   parm = RNA_def_pointer(
1115       func,
1116       "depsgraph",
1117       "Depsgraph",
1118       "",
1119       "Depsgraph to use to get evaluated data, when called from original object "
1120       "(only needed if current Context's depsgraph is not suitable)");
1121   RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
1122   /* weak!, no way to return dynamic string type */
1123   parm = RNA_def_string(func, "result", NULL, 16384, "", "Requested informations");
1124   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0); /* needed for string return value */
1125   RNA_def_function_output(func, parm);
1126 #  endif /* NDEBUG */
1127
1128   func = RNA_def_function(srna, "update_from_editmode", "rna_Object_update_from_editmode");
1129   RNA_def_function_ui_description(func, "Load the objects edit-mode data into the object data");
1130   RNA_def_function_flag(func, FUNC_USE_MAIN);
1131   parm = RNA_def_boolean(func, "result", 0, "", "Success");
1132   RNA_def_function_return(func, parm);
1133
1134   func = RNA_def_function(srna, "cache_release", "BKE_object_free_caches");
1135   RNA_def_function_ui_description(func,
1136                                   "Release memory used by caches associated with this object. "
1137                                   "Intended to be used by render engines only");
1138 }
1139
1140 #endif /* RNA_RUNTIME */