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