Fix T67140: transforming bone does not update bone tab in properties editor
[blender.git] / source / blender / makesrna / intern / rna_scene_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
27 #include "BLI_utildefines.h"
28 #include "BLI_kdopbvh.h"
29 #include "BLI_path_util.h"
30
31 #include "RNA_define.h"
32 #include "RNA_enum_types.h"
33
34 #include "DNA_anim_types.h"
35 #include "DNA_object_types.h"
36 #include "DNA_scene_types.h"
37
38 #include "rna_internal.h" /* own include */
39
40 #ifdef WITH_ALEMBIC
41 #  include "../../alembic/ABC_alembic.h"
42 #endif
43
44 const EnumPropertyItem rna_enum_abc_compression_items[] = {
45 #ifdef WITH_ALEMBIC
46     {ABC_ARCHIVE_OGAWA, "OGAWA", 0, "Ogawa", ""},
47     {ABC_ARCHIVE_HDF5, "HDF5", 0, "HDF5", ""},
48 #endif
49     {0, NULL, 0, NULL, NULL}};
50
51 #ifdef RNA_RUNTIME
52
53 #  include "BKE_animsys.h"
54 #  include "BKE_editmesh.h"
55 #  include "BKE_global.h"
56 #  include "BKE_image.h"
57 #  include "BKE_scene.h"
58 #  include "BKE_writeavi.h"
59
60 #  include "DEG_depsgraph_query.h"
61
62 #  include "ED_transform.h"
63 #  include "ED_transform_snap_object_context.h"
64 #  include "ED_uvedit.h"
65
66 #  ifdef WITH_PYTHON
67 #    include "BPY_extern.h"
68 #  endif
69
70 static void rna_Scene_frame_set(Scene *scene, Main *bmain, int frame, float subframe)
71 {
72   double cfra = (double)frame + (double)subframe;
73
74   CLAMP(cfra, MINAFRAME, MAXFRAME);
75   BKE_scene_frame_set(scene, cfra);
76
77 #  ifdef WITH_PYTHON
78   BPy_BEGIN_ALLOW_THREADS;
79 #  endif
80
81   for (ViewLayer *view_layer = scene->view_layers.first; view_layer != NULL;
82        view_layer = view_layer->next) {
83     Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
84     BKE_scene_graph_update_for_newframe(depsgraph, bmain);
85   }
86
87 #  ifdef WITH_PYTHON
88   BPy_END_ALLOW_THREADS;
89 #  endif
90
91   BKE_scene_camera_switch_update(scene);
92
93   /* don't do notifier when we're rendering, avoid some viewport crashes
94    * redrawing while the data is being modified for render */
95   if (!G.is_rendering) {
96     /* cant use NC_SCENE|ND_FRAME because this causes wm_event_do_notifiers to call
97      * BKE_scene_graph_update_for_newframe which will loose any un-keyed changes [#24690] */
98     /* WM_main_add_notifier(NC_SCENE|ND_FRAME, scene); */
99
100     /* instead just redraw the views */
101     WM_main_add_notifier(NC_WINDOW, NULL);
102   }
103 }
104
105 static void rna_Scene_uvedit_aspect(Scene *scene, Object *ob, float *aspect)
106 {
107   if ((ob->type == OB_MESH) && (ob->mode == OB_MODE_EDIT)) {
108     BMEditMesh *em;
109     em = BKE_editmesh_from_object(ob);
110     if (EDBM_uv_check(em)) {
111       ED_uvedit_get_aspect(scene, ob, em->bm, aspect, aspect + 1);
112       return;
113     }
114   }
115
116   aspect[0] = aspect[1] = 1.0f;
117 }
118
119 static void rna_SceneRender_get_frame_path(
120     RenderData *rd, Main *bmain, int frame, bool preview, const char *view, char *name)
121 {
122   const char *suffix = BKE_scene_multiview_view_suffix_get(rd, view);
123
124   /* avoid NULL pointer */
125   if (!suffix) {
126     suffix = "";
127   }
128
129   if (BKE_imtype_is_movie(rd->im_format.imtype)) {
130     BKE_movie_filepath_get(name, rd, preview != 0, suffix);
131   }
132   else {
133     BKE_image_path_from_imformat(name,
134                                  rd->pic,
135                                  BKE_main_blendfile_path(bmain),
136                                  (frame == INT_MIN) ? rd->cfra : frame,
137                                  &rd->im_format,
138                                  (rd->scemode & R_EXTENSION) != 0,
139                                  true,
140                                  suffix);
141   }
142 }
143
144 static void rna_Scene_ray_cast(Scene *scene,
145                                Main *bmain,
146                                ViewLayer *view_layer,
147                                float origin[3],
148                                float direction[3],
149                                float ray_dist,
150                                bool *r_success,
151                                float r_location[3],
152                                float r_normal[3],
153                                int *r_index,
154                                Object **r_ob,
155                                float r_obmat[16])
156 {
157   normalize_v3(direction);
158
159   Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
160   SnapObjectContext *sctx = ED_transform_snap_object_context_create(bmain, scene, depsgraph, 0);
161
162   bool ret = ED_transform_snap_object_project_ray_ex(sctx,
163                                                      &(const struct SnapObjectParams){
164                                                          .snap_select = SNAP_ALL,
165                                                      },
166                                                      origin,
167                                                      direction,
168                                                      &ray_dist,
169                                                      r_location,
170                                                      r_normal,
171                                                      r_index,
172                                                      r_ob,
173                                                      (float(*)[4])r_obmat);
174
175   ED_transform_snap_object_context_destroy(sctx);
176
177   if (r_ob != NULL && *r_ob != NULL) {
178     *r_ob = DEG_get_original_object(*r_ob);
179   }
180
181   if (ret) {
182     *r_success = true;
183   }
184   else {
185     *r_success = false;
186
187     unit_m4((float(*)[4])r_obmat);
188     zero_v3(r_location);
189     zero_v3(r_normal);
190   }
191 }
192
193 static void rna_Scene_sequencer_editing_free(Scene *scene)
194 {
195   BKE_sequencer_editing_free(scene, true);
196 }
197
198 #  ifdef WITH_ALEMBIC
199
200 static void rna_Scene_alembic_export(Scene *scene,
201                                      bContext *C,
202                                      const char *filepath,
203                                      int frame_start,
204                                      int frame_end,
205                                      int xform_samples,
206                                      int geom_samples,
207                                      float shutter_open,
208                                      float shutter_close,
209                                      bool selected_only,
210                                      bool uvs,
211                                      bool normals,
212                                      bool vcolors,
213                                      bool apply_subdiv,
214                                      bool flatten_hierarchy,
215                                      bool visible_layers_only,
216                                      bool renderable_only,
217                                      bool face_sets,
218                                      bool use_subdiv_schema,
219                                      bool export_hair,
220                                      bool export_particles,
221                                      int compression_type,
222                                      bool packuv,
223                                      float scale,
224                                      bool triangulate,
225                                      int quad_method,
226                                      int ngon_method)
227 {
228 /* We have to enable allow_threads, because we may change scene frame number
229  * during export. */
230 #    ifdef WITH_PYTHON
231   BPy_BEGIN_ALLOW_THREADS;
232 #    endif
233
234   const struct AlembicExportParams params = {
235       .frame_start = frame_start,
236       .frame_end = frame_end,
237
238       .frame_samples_xform = xform_samples,
239       .frame_samples_shape = geom_samples,
240
241       .shutter_open = shutter_open,
242       .shutter_close = shutter_close,
243
244       .selected_only = selected_only,
245       .uvs = uvs,
246       .normals = normals,
247       .vcolors = vcolors,
248       .apply_subdiv = apply_subdiv,
249       .flatten_hierarchy = flatten_hierarchy,
250       .visible_layers_only = visible_layers_only,
251       .renderable_only = renderable_only,
252       .face_sets = face_sets,
253       .use_subdiv_schema = use_subdiv_schema,
254       .export_hair = export_hair,
255       .export_particles = export_particles,
256       .compression_type = compression_type,
257       .packuv = packuv,
258       .triangulate = triangulate,
259       .quad_method = quad_method,
260       .ngon_method = ngon_method,
261
262       .global_scale = scale,
263   };
264
265   ABC_export(scene, C, filepath, &params, true);
266
267 #    ifdef WITH_PYTHON
268   BPy_END_ALLOW_THREADS;
269 #    endif
270 }
271
272 #  endif
273
274 #else
275
276 void RNA_api_scene(StructRNA *srna)
277 {
278   FunctionRNA *func;
279   PropertyRNA *parm;
280
281   func = RNA_def_function(srna, "frame_set", "rna_Scene_frame_set");
282   RNA_def_function_ui_description(func, "Set scene frame updating all objects immediately");
283   parm = RNA_def_int(
284       func, "frame", 0, MINAFRAME, MAXFRAME, "", "Frame number to set", MINAFRAME, MAXFRAME);
285   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
286   RNA_def_float(
287       func, "subframe", 0.0, 0.0, 1.0, "", "Sub-frame time, between 0.0 and 1.0", 0.0, 1.0);
288   RNA_def_function_flag(func, FUNC_USE_MAIN);
289
290   func = RNA_def_function(srna, "uvedit_aspect", "rna_Scene_uvedit_aspect");
291   RNA_def_function_ui_description(func, "Get uv aspect for current object");
292   parm = RNA_def_pointer(func, "object", "Object", "", "Object");
293   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
294   parm = RNA_def_float_vector(func, "result", 2, NULL, 0.0f, FLT_MAX, "", "aspect", 0.0f, FLT_MAX);
295   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
296   RNA_def_function_output(func, parm);
297
298   /* Ray Cast */
299   func = RNA_def_function(srna, "ray_cast", "rna_Scene_ray_cast");
300   RNA_def_function_flag(func, FUNC_USE_MAIN);
301   RNA_def_function_ui_description(func, "Cast a ray onto in object space");
302   parm = RNA_def_pointer(func, "view_layer", "ViewLayer", "", "Scene Layer");
303   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
304   /* ray start and end */
305   parm = RNA_def_float_vector(func, "origin", 3, NULL, -FLT_MAX, FLT_MAX, "", "", -1e4, 1e4);
306   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
307   parm = RNA_def_float_vector(func, "direction", 3, NULL, -FLT_MAX, FLT_MAX, "", "", -1e4, 1e4);
308   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
309   RNA_def_float(func,
310                 "distance",
311                 BVH_RAYCAST_DIST_MAX,
312                 0.0,
313                 BVH_RAYCAST_DIST_MAX,
314                 "",
315                 "Maximum distance",
316                 0.0,
317                 BVH_RAYCAST_DIST_MAX);
318   /* return location and normal */
319   parm = RNA_def_boolean(func, "result", 0, "", "");
320   RNA_def_function_output(func, parm);
321   parm = RNA_def_float_vector(func,
322                               "location",
323                               3,
324                               NULL,
325                               -FLT_MAX,
326                               FLT_MAX,
327                               "Location",
328                               "The hit location of this ray cast",
329                               -1e4,
330                               1e4);
331   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
332   RNA_def_function_output(func, parm);
333   parm = RNA_def_float_vector(func,
334                               "normal",
335                               3,
336                               NULL,
337                               -FLT_MAX,
338                               FLT_MAX,
339                               "Normal",
340                               "The face normal at the ray cast hit location",
341                               -1e4,
342                               1e4);
343   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
344   RNA_def_function_output(func, parm);
345   parm = RNA_def_int(
346       func, "index", 0, 0, 0, "", "The face index, -1 when original data isn't available", 0, 0);
347   RNA_def_function_output(func, parm);
348   parm = RNA_def_pointer(func, "object", "Object", "", "Ray cast object");
349   RNA_def_function_output(func, parm);
350   parm = RNA_def_float_matrix(func, "matrix", 4, 4, NULL, 0.0f, 0.0f, "", "Matrix", 0.0f, 0.0f);
351   RNA_def_function_output(func, parm);
352
353   /* Sequencer. */
354   func = RNA_def_function(srna, "sequence_editor_create", "BKE_sequencer_editing_ensure");
355   RNA_def_function_ui_description(func, "Ensure sequence editor is valid in this scene");
356   parm = RNA_def_pointer(
357       func, "sequence_editor", "SequenceEditor", "", "New sequence editor data or NULL");
358   RNA_def_function_return(func, parm);
359
360   func = RNA_def_function(srna, "sequence_editor_clear", "rna_Scene_sequencer_editing_free");
361   RNA_def_function_ui_description(func, "Clear sequence editor in this scene");
362
363 #  ifdef WITH_ALEMBIC
364   /* XXX Deprecated, will be removed in 2.8 in favour of calling the export operator. */
365   func = RNA_def_function(srna, "alembic_export", "rna_Scene_alembic_export");
366   RNA_def_function_ui_description(
367       func, "Export to Alembic file (deprecated, use the Alembic export operator)");
368
369   parm = RNA_def_string(
370       func, "filepath", NULL, FILE_MAX, "File Path", "File path to write Alembic file");
371   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
372   RNA_def_property_subtype(parm, PROP_FILEPATH); /* allow non utf8 */
373
374   RNA_def_int(func, "frame_start", 1, INT_MIN, INT_MAX, "Start", "Start Frame", INT_MIN, INT_MAX);
375   RNA_def_int(func, "frame_end", 1, INT_MIN, INT_MAX, "End", "End Frame", INT_MIN, INT_MAX);
376   RNA_def_int(
377       func, "xform_samples", 1, 1, 128, "Xform samples", "Transform samples per frame", 1, 128);
378   RNA_def_int(
379       func, "geom_samples", 1, 1, 128, "Geom samples", "Geometry samples per frame", 1, 128);
380   RNA_def_float(func, "shutter_open", 0.0f, -1.0f, 1.0f, "Shutter open", "", -1.0f, 1.0f);
381   RNA_def_float(func, "shutter_close", 1.0f, -1.0f, 1.0f, "Shutter close", "", -1.0f, 1.0f);
382   RNA_def_boolean(func, "selected_only", 0, "Selected only", "Export only selected objects");
383   RNA_def_boolean(func, "uvs", 1, "UVs", "Export UVs");
384   RNA_def_boolean(func, "normals", 1, "Normals", "Export normals");
385   RNA_def_boolean(func, "vcolors", 0, "Vertex colors", "Export vertex colors");
386   RNA_def_boolean(
387       func, "apply_subdiv", 1, "Subsurfs as meshes", "Export subdivision surfaces as meshes");
388   RNA_def_boolean(func, "flatten", 0, "Flatten hierarchy", "Flatten hierarchy");
389   RNA_def_boolean(func,
390                   "visible_layers_only",
391                   0,
392                   "Visible layers only",
393                   "Export only objects in visible layers");
394   RNA_def_boolean(func,
395                   "renderable_only",
396                   0,
397                   "Renderable objects only",
398                   "Export only objects marked renderable in the outliner");
399   RNA_def_boolean(func, "face_sets", 0, "Facesets", "Export face sets");
400   RNA_def_boolean(func,
401                   "subdiv_schema",
402                   0,
403                   "Use Alembic subdivision Schema",
404                   "Use Alembic subdivision Schema");
405   RNA_def_boolean(
406       func, "export_hair", 1, "Export Hair", "Exports hair particle systems as animated curves");
407   RNA_def_boolean(
408       func, "export_particles", 1, "Export Particles", "Exports non-hair particle systems");
409   RNA_def_enum(func, "compression_type", rna_enum_abc_compression_items, 0, "Compression", "");
410   RNA_def_boolean(
411       func, "packuv", 0, "Export with packed UV islands", "Export with packed UV islands");
412   RNA_def_float(
413       func,
414       "scale",
415       1.0f,
416       0.0001f,
417       1000.0f,
418       "Scale",
419       "Value by which to enlarge or shrink the objects with respect to the world's origin",
420       0.0001f,
421       1000.0f);
422   RNA_def_boolean(
423       func, "triangulate", 0, "Triangulate", "Export Polygons (Quads & NGons) as Triangles");
424   RNA_def_enum(func,
425                "quad_method",
426                rna_enum_modifier_triangulate_quad_method_items,
427                0,
428                "Quad Method",
429                "Method for splitting the quads into triangles");
430   RNA_def_enum(func,
431                "ngon_method",
432                rna_enum_modifier_triangulate_quad_method_items,
433                0,
434                "Polygon Method",
435                "Method for splitting the polygons into triangles");
436
437   RNA_def_function_flag(func, FUNC_USE_CONTEXT);
438 #  endif
439 }
440
441 void RNA_api_scene_render(StructRNA *srna)
442 {
443   FunctionRNA *func;
444   PropertyRNA *parm;
445
446   func = RNA_def_function(srna, "frame_path", "rna_SceneRender_get_frame_path");
447   RNA_def_function_flag(func, FUNC_USE_MAIN);
448   RNA_def_function_ui_description(
449       func, "Return the absolute path to the filename to be written for a given frame");
450   RNA_def_int(func,
451               "frame",
452               INT_MIN,
453               INT_MIN,
454               INT_MAX,
455               "",
456               "Frame number to use, if unset the current frame will be used",
457               MINAFRAME,
458               MAXFRAME);
459   RNA_def_boolean(func, "preview", 0, "Preview", "Use preview range");
460   RNA_def_string_file_path(func,
461                            "view",
462                            NULL,
463                            FILE_MAX,
464                            "View",
465                            "The name of the view to use to replace the \"%\" chars");
466   parm = RNA_def_string_file_path(func,
467                                   "filepath",
468                                   NULL,
469                                   FILE_MAX,
470                                   "File Path",
471                                   "The resulting filepath from the scenes render settings");
472   RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0); /* needed for string return value */
473   RNA_def_function_output(func, parm);
474 }
475
476 #endif