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