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