a250b005bad0953c24904976cf9baf648af624dc
[blender.git] / source / blender / blenkernel / intern / scene.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <stddef.h>
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "DNA_anim_types.h"
31 #include "DNA_collection_types.h"
32 #include "DNA_linestyle_types.h"
33 #include "DNA_mesh_types.h"
34 #include "DNA_node_types.h"
35 #include "DNA_object_types.h"
36 #include "DNA_rigidbody_types.h"
37 #include "DNA_scene_types.h"
38 #include "DNA_screen_types.h"
39 #include "DNA_sequence_types.h"
40 #include "DNA_sound_types.h"
41 #include "DNA_space_types.h"
42 #include "DNA_view3d_types.h"
43 #include "DNA_windowmanager_types.h"
44 #include "DNA_workspace_types.h"
45 #include "DNA_gpencil_types.h"
46
47 #include "BLI_math.h"
48 #include "BLI_blenlib.h"
49 #include "BLI_utildefines.h"
50 #include "BLI_callbacks.h"
51 #include "BLI_string.h"
52 #include "BLI_string_utils.h"
53 #include "BLI_threads.h"
54 #include "BLI_task.h"
55
56 #include "BLT_translation.h"
57
58 #include "BKE_anim.h"
59 #include "BKE_animsys.h"
60 #include "BKE_action.h"
61 #include "BKE_armature.h"
62 #include "BKE_cachefile.h"
63 #include "BKE_collection.h"
64 #include "BKE_colortools.h"
65 #include "BKE_editmesh.h"
66 #include "BKE_fcurve.h"
67 #include "BKE_freestyle.h"
68 #include "BKE_gpencil.h"
69 #include "BKE_icons.h"
70 #include "BKE_idprop.h"
71 #include "BKE_image.h"
72 #include "BKE_layer.h"
73 #include "BKE_library.h"
74 #include "BKE_library_remap.h"
75 #include "BKE_linestyle.h"
76 #include "BKE_main.h"
77 #include "BKE_mask.h"
78 #include "BKE_node.h"
79 #include "BKE_object.h"
80 #include "BKE_paint.h"
81 #include "BKE_rigidbody.h"
82 #include "BKE_scene.h"
83 #include "BKE_screen.h"
84 #include "BKE_sequencer.h"
85 #include "BKE_sound.h"
86 #include "BKE_unit.h"
87 #include "BKE_workspace.h"
88 #include "BKE_world.h"
89
90 #include "DEG_depsgraph.h"
91 #include "DEG_depsgraph_build.h"
92 #include "DEG_depsgraph_debug.h"
93 #include "DEG_depsgraph_query.h"
94
95 #include "RE_engine.h"
96
97 #include "engines/eevee/eevee_lightcache.h"
98
99 #include "PIL_time.h"
100
101 #include "IMB_colormanagement.h"
102 #include "IMB_imbuf.h"
103
104 #include "bmesh.h"
105
106 const char *RE_engine_id_BLENDER_EEVEE = "BLENDER_EEVEE";
107 const char *RE_engine_id_BLENDER_WORKBENCH = "BLENDER_WORKBENCH";
108 const char *RE_engine_id_CYCLES = "CYCLES";
109
110 void free_avicodecdata(AviCodecData *acd)
111 {
112   if (acd) {
113     if (acd->lpFormat) {
114       MEM_freeN(acd->lpFormat);
115       acd->lpFormat = NULL;
116       acd->cbFormat = 0;
117     }
118     if (acd->lpParms) {
119       MEM_freeN(acd->lpParms);
120       acd->lpParms = NULL;
121       acd->cbParms = 0;
122     }
123   }
124 }
125
126 static void remove_sequencer_fcurves(Scene *sce)
127 {
128   AnimData *adt = BKE_animdata_from_id(&sce->id);
129
130   if (adt && adt->action) {
131     FCurve *fcu, *nextfcu;
132
133     for (fcu = adt->action->curves.first; fcu; fcu = nextfcu) {
134       nextfcu = fcu->next;
135
136       if ((fcu->rna_path) && strstr(fcu->rna_path, "sequences_all")) {
137         action_groups_remove_channel(adt->action, fcu);
138         free_fcurve(fcu);
139       }
140     }
141   }
142 }
143
144 /* flag -- copying options (see BKE_library.h's LIB_ID_COPY_... flags for more). */
145 ToolSettings *BKE_toolsettings_copy(ToolSettings *toolsettings, const int flag)
146 {
147   if (toolsettings == NULL) {
148     return NULL;
149   }
150   ToolSettings *ts = MEM_dupallocN(toolsettings);
151   if (ts->vpaint) {
152     ts->vpaint = MEM_dupallocN(ts->vpaint);
153     BKE_paint_copy(&ts->vpaint->paint, &ts->vpaint->paint, flag);
154   }
155   if (ts->wpaint) {
156     ts->wpaint = MEM_dupallocN(ts->wpaint);
157     BKE_paint_copy(&ts->wpaint->paint, &ts->wpaint->paint, flag);
158   }
159   if (ts->sculpt) {
160     ts->sculpt = MEM_dupallocN(ts->sculpt);
161     BKE_paint_copy(&ts->sculpt->paint, &ts->sculpt->paint, flag);
162   }
163   if (ts->uvsculpt) {
164     ts->uvsculpt = MEM_dupallocN(ts->uvsculpt);
165     BKE_paint_copy(&ts->uvsculpt->paint, &ts->uvsculpt->paint, flag);
166   }
167   if (ts->gp_paint) {
168     ts->gp_paint = MEM_dupallocN(ts->gp_paint);
169     BKE_paint_copy(&ts->gp_paint->paint, &ts->gp_paint->paint, flag);
170   }
171
172   BKE_paint_copy(&ts->imapaint.paint, &ts->imapaint.paint, flag);
173   ts->imapaint.paintcursor = NULL;
174   ts->particle.paintcursor = NULL;
175   ts->particle.scene = NULL;
176   ts->particle.object = NULL;
177
178   /* duplicate Grease Pencil interpolation curve */
179   ts->gp_interpolate.custom_ipo = curvemapping_copy(ts->gp_interpolate.custom_ipo);
180   /* duplicate Grease Pencil multiframe fallof */
181   ts->gp_sculpt.cur_falloff = curvemapping_copy(ts->gp_sculpt.cur_falloff);
182   ts->gp_sculpt.cur_primitive = curvemapping_copy(ts->gp_sculpt.cur_primitive);
183   return ts;
184 }
185
186 void BKE_toolsettings_free(ToolSettings *toolsettings)
187 {
188   if (toolsettings == NULL) {
189     return;
190   }
191   if (toolsettings->vpaint) {
192     BKE_paint_free(&toolsettings->vpaint->paint);
193     MEM_freeN(toolsettings->vpaint);
194   }
195   if (toolsettings->wpaint) {
196     BKE_paint_free(&toolsettings->wpaint->paint);
197     MEM_freeN(toolsettings->wpaint);
198   }
199   if (toolsettings->sculpt) {
200     BKE_paint_free(&toolsettings->sculpt->paint);
201     MEM_freeN(toolsettings->sculpt);
202   }
203   if (toolsettings->uvsculpt) {
204     BKE_paint_free(&toolsettings->uvsculpt->paint);
205     MEM_freeN(toolsettings->uvsculpt);
206   }
207   if (toolsettings->gp_paint) {
208     BKE_paint_free(&toolsettings->gp_paint->paint);
209     MEM_freeN(toolsettings->gp_paint);
210   }
211   BKE_paint_free(&toolsettings->imapaint.paint);
212
213   /* free Grease Pencil interpolation curve */
214   if (toolsettings->gp_interpolate.custom_ipo) {
215     curvemapping_free(toolsettings->gp_interpolate.custom_ipo);
216   }
217   /* free Grease Pencil multiframe falloff curve */
218   if (toolsettings->gp_sculpt.cur_falloff) {
219     curvemapping_free(toolsettings->gp_sculpt.cur_falloff);
220   }
221   if (toolsettings->gp_sculpt.cur_primitive) {
222     curvemapping_free(toolsettings->gp_sculpt.cur_primitive);
223   }
224
225   MEM_freeN(toolsettings);
226 }
227
228 /**
229  * Only copy internal data of Scene ID from source
230  * to already allocated/initialized destination.
231  * You probably never want to use that directly,
232  * use #BKE_id_copy or #BKE_id_copy_ex for typical needs.
233  *
234  * WARNING! This function will not handle ID user count!
235  *
236  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
237  */
238 void BKE_scene_copy_data(Main *bmain, Scene *sce_dst, const Scene *sce_src, const int flag)
239 {
240   /* We never handle usercount here for own data. */
241   const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
242
243   sce_dst->ed = NULL;
244   sce_dst->depsgraph_hash = NULL;
245   sce_dst->fps_info = NULL;
246
247   /* Master Collection */
248   if (sce_src->master_collection) {
249     sce_dst->master_collection = BKE_collection_copy_master(
250         bmain, sce_src->master_collection, flag);
251   }
252
253   /* View Layers */
254   BLI_duplicatelist(&sce_dst->view_layers, &sce_src->view_layers);
255   for (ViewLayer *view_layer_src = sce_src->view_layers.first,
256                  *view_layer_dst = sce_dst->view_layers.first;
257        view_layer_src;
258        view_layer_src = view_layer_src->next, view_layer_dst = view_layer_dst->next) {
259     BKE_view_layer_copy_data(sce_dst, sce_src, view_layer_dst, view_layer_src, flag_subdata);
260   }
261
262   BLI_duplicatelist(&(sce_dst->markers), &(sce_src->markers));
263   BLI_duplicatelist(&(sce_dst->transform_spaces), &(sce_src->transform_spaces));
264   BLI_duplicatelist(&(sce_dst->r.views), &(sce_src->r.views));
265   BKE_keyingsets_copy(&(sce_dst->keyingsets), &(sce_src->keyingsets));
266
267   if (sce_src->nodetree) {
268     /* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
269      *       (see BKE_libblock_copy_ex()). */
270     BKE_id_copy_ex(bmain, (ID *)sce_src->nodetree, (ID **)&sce_dst->nodetree, flag);
271     BKE_libblock_relink_ex(bmain, sce_dst->nodetree, (void *)(&sce_src->id), &sce_dst->id, false);
272   }
273
274   if (sce_src->rigidbody_world) {
275     sce_dst->rigidbody_world = BKE_rigidbody_world_copy(sce_src->rigidbody_world, flag_subdata);
276   }
277
278   /* copy color management settings */
279   BKE_color_managed_display_settings_copy(&sce_dst->display_settings, &sce_src->display_settings);
280   BKE_color_managed_view_settings_copy(&sce_dst->view_settings, &sce_src->view_settings);
281   BKE_color_managed_colorspace_settings_copy(&sce_dst->sequencer_colorspace_settings,
282                                              &sce_src->sequencer_colorspace_settings);
283
284   BKE_color_managed_display_settings_copy(&sce_dst->r.im_format.display_settings,
285                                           &sce_src->r.im_format.display_settings);
286   BKE_color_managed_view_settings_copy(&sce_dst->r.im_format.view_settings,
287                                        &sce_src->r.im_format.view_settings);
288
289   BKE_color_managed_display_settings_copy(&sce_dst->r.bake.im_format.display_settings,
290                                           &sce_src->r.bake.im_format.display_settings);
291   BKE_color_managed_view_settings_copy(&sce_dst->r.bake.im_format.view_settings,
292                                        &sce_src->r.bake.im_format.view_settings);
293
294   curvemapping_copy_data(&sce_dst->r.mblur_shutter_curve, &sce_src->r.mblur_shutter_curve);
295
296   /* tool settings */
297   sce_dst->toolsettings = BKE_toolsettings_copy(sce_dst->toolsettings, flag_subdata);
298
299   /* make a private copy of the avicodecdata */
300   if (sce_src->r.avicodecdata) {
301     sce_dst->r.avicodecdata = MEM_dupallocN(sce_src->r.avicodecdata);
302     sce_dst->r.avicodecdata->lpFormat = MEM_dupallocN(sce_dst->r.avicodecdata->lpFormat);
303     sce_dst->r.avicodecdata->lpParms = MEM_dupallocN(sce_dst->r.avicodecdata->lpParms);
304   }
305
306   if (sce_src->r.ffcodecdata.properties) {
307     /* intentionally check sce_dst not sce_src. */ /* XXX ??? comment outdated... */
308     sce_dst->r.ffcodecdata.properties = IDP_CopyProperty_ex(sce_src->r.ffcodecdata.properties,
309                                                             flag_subdata);
310   }
311
312   BKE_sound_reset_scene_runtime(sce_dst);
313
314   /* Copy sequencer, this is local data! */
315   if (sce_src->ed) {
316     sce_dst->ed = MEM_callocN(sizeof(*sce_dst->ed), __func__);
317     sce_dst->ed->seqbasep = &sce_dst->ed->seqbase;
318     BKE_sequence_base_dupli_recursive(sce_src,
319                                       sce_dst,
320                                       &sce_dst->ed->seqbase,
321                                       &sce_src->ed->seqbase,
322                                       SEQ_DUPE_ALL,
323                                       flag_subdata);
324   }
325
326   if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
327     BKE_previewimg_id_copy(&sce_dst->id, &sce_src->id);
328   }
329   else {
330     sce_dst->preview = NULL;
331   }
332
333   sce_dst->eevee.light_cache = NULL;
334   sce_dst->eevee.light_cache_info[0] = '\0';
335   /* TODO Copy the cache. */
336 }
337
338 Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
339 {
340   Scene *sce_copy;
341
342   /* TODO this should/could most likely be replaced by call to more generic code at some point...
343    * But for now, let's keep it well isolated here. */
344   if (type == SCE_COPY_EMPTY) {
345     ListBase rv;
346
347     sce_copy = BKE_scene_add(bmain, sce->id.name + 2);
348
349     rv = sce_copy->r.views;
350     curvemapping_free_data(&sce_copy->r.mblur_shutter_curve);
351     sce_copy->r = sce->r;
352     sce_copy->r.views = rv;
353     sce_copy->unit = sce->unit;
354     sce_copy->physics_settings = sce->physics_settings;
355     sce_copy->audio = sce->audio;
356     sce_copy->eevee = sce->eevee;
357     sce_copy->eevee.light_cache = NULL;
358     sce_copy->eevee.light_cache_info[0] = '\0';
359
360     if (sce->id.properties) {
361       sce_copy->id.properties = IDP_CopyProperty(sce->id.properties);
362     }
363
364     MEM_freeN(sce_copy->toolsettings);
365     BKE_sound_destroy_scene(sce_copy);
366
367     /* copy color management settings */
368     BKE_color_managed_display_settings_copy(&sce_copy->display_settings, &sce->display_settings);
369     BKE_color_managed_view_settings_copy(&sce_copy->view_settings, &sce->view_settings);
370     BKE_color_managed_colorspace_settings_copy(&sce_copy->sequencer_colorspace_settings,
371                                                &sce->sequencer_colorspace_settings);
372
373     BKE_color_managed_display_settings_copy(&sce_copy->r.im_format.display_settings,
374                                             &sce->r.im_format.display_settings);
375     BKE_color_managed_view_settings_copy(&sce_copy->r.im_format.view_settings,
376                                          &sce->r.im_format.view_settings);
377
378     BKE_color_managed_display_settings_copy(&sce_copy->r.bake.im_format.display_settings,
379                                             &sce->r.bake.im_format.display_settings);
380     BKE_color_managed_view_settings_copy(&sce_copy->r.bake.im_format.view_settings,
381                                          &sce->r.bake.im_format.view_settings);
382
383     curvemapping_copy_data(&sce_copy->r.mblur_shutter_curve, &sce->r.mblur_shutter_curve);
384
385     /* viewport display settings */
386     sce_copy->display = sce->display;
387
388     /* tool settings */
389     sce_copy->toolsettings = BKE_toolsettings_copy(sce->toolsettings, 0);
390
391     /* make a private copy of the avicodecdata */
392     if (sce->r.avicodecdata) {
393       sce_copy->r.avicodecdata = MEM_dupallocN(sce->r.avicodecdata);
394       sce_copy->r.avicodecdata->lpFormat = MEM_dupallocN(sce_copy->r.avicodecdata->lpFormat);
395       sce_copy->r.avicodecdata->lpParms = MEM_dupallocN(sce_copy->r.avicodecdata->lpParms);
396     }
397
398     if (sce->r.ffcodecdata.properties) { /* intentionally check scen not sce. */
399       sce_copy->r.ffcodecdata.properties = IDP_CopyProperty(sce->r.ffcodecdata.properties);
400     }
401
402     BKE_sound_reset_scene_runtime(sce_copy);
403
404     /* grease pencil */
405     sce_copy->gpd = NULL;
406
407     sce_copy->preview = NULL;
408
409     return sce_copy;
410   }
411   else {
412     BKE_id_copy_ex(bmain, (ID *)sce, (ID **)&sce_copy, LIB_ID_COPY_ACTIONS);
413     id_us_min(&sce_copy->id);
414     id_us_ensure_real(&sce_copy->id);
415
416     /* Extra actions, most notably SCE_FULL_COPY also duplicates several 'children' datablocks. */
417
418     if (type == SCE_COPY_FULL) {
419       /* Copy Freestyle LineStyle datablocks. */
420       for (ViewLayer *view_layer_dst = sce_copy->view_layers.first; view_layer_dst;
421            view_layer_dst = view_layer_dst->next) {
422         for (FreestyleLineSet *lineset = view_layer_dst->freestyle_config.linesets.first; lineset;
423              lineset = lineset->next) {
424           if (lineset->linestyle) {
425             id_us_min(&lineset->linestyle->id);
426             BKE_id_copy_ex(
427                 bmain, (ID *)lineset->linestyle, (ID **)&lineset->linestyle, LIB_ID_COPY_ACTIONS);
428           }
429         }
430       }
431
432       /* Full copy of world (included animations) */
433       if (sce_copy->world) {
434         id_us_min(&sce_copy->world->id);
435         BKE_id_copy_ex(bmain, (ID *)sce_copy->world, (ID **)&sce_copy->world, LIB_ID_COPY_ACTIONS);
436       }
437
438       /* Full copy of GreasePencil. */
439       if (sce_copy->gpd) {
440         id_us_min(&sce_copy->gpd->id);
441         BKE_id_copy_ex(bmain, (ID *)sce_copy->gpd, (ID **)&sce_copy->gpd, LIB_ID_COPY_ACTIONS);
442       }
443     }
444     else {
445       /* Remove sequencer if not full copy */
446       /* XXX Why in Hell? :/ */
447       remove_sequencer_fcurves(sce_copy);
448       BKE_sequencer_editing_free(sce_copy, true);
449     }
450
451     /* NOTE: part of SCE_COPY_FULL operations
452      * are done outside of blenkernel with ED_object_single_users! */
453
454     return sce_copy;
455   }
456 }
457
458 void BKE_scene_groups_relink(Scene *sce)
459 {
460   if (sce->rigidbody_world) {
461     BKE_rigidbody_world_groups_relink(sce->rigidbody_world);
462   }
463 }
464
465 void BKE_scene_make_local(Main *bmain, Scene *sce, const bool lib_local)
466 {
467   /* For now should work, may need more work though to support all possible corner cases
468    * (also scene_copy probably needs some love). */
469   BKE_id_make_local_generic(bmain, &sce->id, true, lib_local);
470 }
471
472 /** Free (or release) any data used by this scene (does not free the scene itself). */
473 void BKE_scene_free_ex(Scene *sce, const bool do_id_user)
474 {
475   BKE_animdata_free((ID *)sce, false);
476
477   BKE_sequencer_editing_free(sce, do_id_user);
478
479   BKE_keyingsets_free(&sce->keyingsets);
480
481   /* is no lib link block, but scene extension */
482   if (sce->nodetree) {
483     ntreeFreeNestedTree(sce->nodetree);
484     MEM_freeN(sce->nodetree);
485     sce->nodetree = NULL;
486   }
487
488   if (sce->rigidbody_world) {
489     BKE_rigidbody_free_world(sce);
490   }
491
492   if (sce->r.avicodecdata) {
493     free_avicodecdata(sce->r.avicodecdata);
494     MEM_freeN(sce->r.avicodecdata);
495     sce->r.avicodecdata = NULL;
496   }
497   if (sce->r.ffcodecdata.properties) {
498     IDP_FreeProperty(sce->r.ffcodecdata.properties);
499     sce->r.ffcodecdata.properties = NULL;
500   }
501
502   BLI_freelistN(&sce->markers);
503   BLI_freelistN(&sce->transform_spaces);
504   BLI_freelistN(&sce->r.views);
505
506   BKE_toolsettings_free(sce->toolsettings);
507   sce->toolsettings = NULL;
508
509   BKE_scene_free_depsgraph_hash(sce);
510
511   MEM_SAFE_FREE(sce->fps_info);
512
513   BKE_sound_destroy_scene(sce);
514
515   BKE_color_managed_view_settings_free(&sce->view_settings);
516
517   BKE_previewimg_free(&sce->preview);
518   curvemapping_free_data(&sce->r.mblur_shutter_curve);
519
520   for (ViewLayer *view_layer = sce->view_layers.first, *view_layer_next; view_layer;
521        view_layer = view_layer_next) {
522     view_layer_next = view_layer->next;
523
524     BLI_remlink(&sce->view_layers, view_layer);
525     BKE_view_layer_free_ex(view_layer, do_id_user);
526   }
527
528   /* Master Collection */
529   // TODO: what to do with do_id_user? it's also true when just
530   // closing the file which seems wrong? should decrement users
531   // for objects directly in the master collection? then other
532   // collections in the scene need to do it too?
533   if (sce->master_collection) {
534     BKE_collection_free(sce->master_collection);
535     MEM_freeN(sce->master_collection);
536     sce->master_collection = NULL;
537   }
538
539   if (sce->eevee.light_cache) {
540     EEVEE_lightcache_free(sce->eevee.light_cache);
541     sce->eevee.light_cache = NULL;
542   }
543
544   /* These are freed on doversion. */
545   BLI_assert(sce->layer_properties == NULL);
546 }
547
548 void BKE_scene_free(Scene *sce)
549 {
550   BKE_scene_free_ex(sce, true);
551 }
552
553 void BKE_scene_init(Scene *sce)
554 {
555   ParticleEditSettings *pset;
556   int a;
557   const char *colorspace_name;
558   SceneRenderView *srv;
559   CurveMapping *mblur_shutter_curve;
560
561   BLI_assert(MEMCMP_STRUCT_AFTER_IS_ZERO(sce, id));
562
563   sce->cursor.rotation_mode = ROT_MODE_XYZ;
564   sce->cursor.rotation_quaternion[0] = 1.0f;
565   sce->cursor.rotation_axis[1] = 1.0f;
566
567   sce->r.mode = 0;
568   sce->r.cfra = 1;
569   sce->r.sfra = 1;
570   sce->r.efra = 250;
571   sce->r.frame_step = 1;
572   sce->r.xsch = 1920;
573   sce->r.ysch = 1080;
574   sce->r.xasp = 1;
575   sce->r.yasp = 1;
576   sce->r.tilex = 256;
577   sce->r.tiley = 256;
578   sce->r.size = 100;
579
580   sce->r.im_format.planes = R_IMF_PLANES_RGBA;
581   sce->r.im_format.imtype = R_IMF_IMTYPE_PNG;
582   sce->r.im_format.depth = R_IMF_CHAN_DEPTH_8;
583   sce->r.im_format.quality = 90;
584   sce->r.im_format.compress = 15;
585
586   sce->r.displaymode = R_OUTPUT_WINDOW;
587   sce->r.framapto = 100;
588   sce->r.images = 100;
589   sce->r.framelen = 1.0;
590   sce->r.blurfac = 0.5;
591   sce->r.frs_sec = 24;
592   sce->r.frs_sec_base = 1;
593
594   /* OCIO_TODO: for forwards compatibility only, so if no tonecurve are used,
595    *            images would look in the same way as in current blender
596    *
597    *            perhaps at some point should be completely deprecated?
598    */
599   sce->r.color_mgt_flag |= R_COLOR_MANAGEMENT;
600
601   sce->r.gauss = 1.5;
602   sce->r.dither_intensity = 1.0f;
603
604   sce->r.bake_mode = 0;
605   sce->r.bake_filter = 16;
606   sce->r.bake_flag = R_BAKE_CLEAR;
607   sce->r.bake_samples = 256;
608   sce->r.bake_biasdist = 0.001;
609
610   sce->r.bake.flag = R_BAKE_CLEAR;
611   sce->r.bake.pass_filter = R_BAKE_PASS_FILTER_ALL;
612   sce->r.bake.width = 512;
613   sce->r.bake.height = 512;
614   sce->r.bake.margin = 16;
615   sce->r.bake.normal_space = R_BAKE_SPACE_TANGENT;
616   sce->r.bake.normal_swizzle[0] = R_BAKE_POSX;
617   sce->r.bake.normal_swizzle[1] = R_BAKE_POSY;
618   sce->r.bake.normal_swizzle[2] = R_BAKE_POSZ;
619   BLI_strncpy(sce->r.bake.filepath, U.renderdir, sizeof(sce->r.bake.filepath));
620
621   sce->r.bake.im_format.planes = R_IMF_PLANES_RGBA;
622   sce->r.bake.im_format.imtype = R_IMF_IMTYPE_PNG;
623   sce->r.bake.im_format.depth = R_IMF_CHAN_DEPTH_8;
624   sce->r.bake.im_format.quality = 90;
625   sce->r.bake.im_format.compress = 15;
626
627   sce->r.scemode = R_DOCOMP | R_DOSEQ | R_EXTENSION;
628   sce->r.stamp = R_STAMP_TIME | R_STAMP_FRAME | R_STAMP_DATE | R_STAMP_CAMERA | R_STAMP_SCENE |
629                  R_STAMP_FILENAME | R_STAMP_RENDERTIME | R_STAMP_MEMORY;
630   sce->r.stamp_font_id = 12;
631   sce->r.fg_stamp[0] = sce->r.fg_stamp[1] = sce->r.fg_stamp[2] = 0.8f;
632   sce->r.fg_stamp[3] = 1.0f;
633   sce->r.bg_stamp[0] = sce->r.bg_stamp[1] = sce->r.bg_stamp[2] = 0.0f;
634   sce->r.bg_stamp[3] = 0.25f;
635
636   sce->r.seq_prev_type = OB_SOLID;
637   sce->r.seq_rend_type = OB_SOLID;
638   sce->r.seq_flag = 0;
639
640   sce->r.threads = 1;
641
642   sce->r.simplify_subsurf = 6;
643   sce->r.simplify_particles = 1.0f;
644
645   sce->r.border.xmin = 0.0f;
646   sce->r.border.ymin = 0.0f;
647   sce->r.border.xmax = 1.0f;
648   sce->r.border.ymax = 1.0f;
649
650   sce->r.preview_start_resolution = 64;
651
652   sce->r.line_thickness_mode = R_LINE_THICKNESS_ABSOLUTE;
653   sce->r.unit_line_thickness = 1.0f;
654
655   mblur_shutter_curve = &sce->r.mblur_shutter_curve;
656   curvemapping_set_defaults(mblur_shutter_curve, 1, 0.0f, 0.0f, 1.0f, 1.0f);
657   curvemapping_initialize(mblur_shutter_curve);
658   curvemap_reset(mblur_shutter_curve->cm,
659                  &mblur_shutter_curve->clipr,
660                  CURVE_PRESET_MAX,
661                  CURVEMAP_SLOPE_POS_NEG);
662
663   sce->toolsettings = MEM_callocN(sizeof(struct ToolSettings), "Tool Settings Struct");
664
665   sce->toolsettings->object_flag |= SCE_OBJECT_MODE_LOCK;
666   sce->toolsettings->doublimit = 0.001;
667   sce->toolsettings->vgroup_weight = 1.0f;
668   sce->toolsettings->uvcalc_margin = 0.001f;
669   sce->toolsettings->uvcalc_flag = UVCALC_TRANSFORM_CORRECT;
670   sce->toolsettings->unwrapper = 1;
671   sce->toolsettings->select_thresh = 0.01f;
672
673   sce->toolsettings->selectmode = SCE_SELECT_VERTEX;
674   sce->toolsettings->uv_selectmode = UV_SELECT_VERTEX;
675   sce->toolsettings->autokey_mode = U.autokey_mode;
676
677   sce->toolsettings->transform_pivot_point = V3D_AROUND_CENTER_MEDIAN;
678   sce->toolsettings->snap_mode = SCE_SNAP_MODE_INCREMENT;
679   sce->toolsettings->snap_node_mode = SCE_SNAP_MODE_GRID;
680   sce->toolsettings->snap_uv_mode = SCE_SNAP_MODE_INCREMENT;
681   sce->toolsettings->snap_transform_mode_flag = SCE_SNAP_TRANSFORM_MODE_TRANSLATE;
682
683   sce->toolsettings->curve_paint_settings.curve_type = CU_BEZIER;
684   sce->toolsettings->curve_paint_settings.flag |= CURVE_PAINT_FLAG_CORNERS_DETECT;
685   sce->toolsettings->curve_paint_settings.error_threshold = 8;
686   sce->toolsettings->curve_paint_settings.radius_max = 1.0f;
687   sce->toolsettings->curve_paint_settings.corner_angle = DEG2RADF(70.0f);
688
689   sce->toolsettings->statvis.overhang_axis = OB_NEGZ;
690   sce->toolsettings->statvis.overhang_min = 0;
691   sce->toolsettings->statvis.overhang_max = DEG2RADF(45.0f);
692   sce->toolsettings->statvis.thickness_max = 0.1f;
693   sce->toolsettings->statvis.thickness_samples = 1;
694   sce->toolsettings->statvis.distort_min = DEG2RADF(5.0f);
695   sce->toolsettings->statvis.distort_max = DEG2RADF(45.0f);
696
697   sce->toolsettings->statvis.sharp_min = DEG2RADF(90.0f);
698   sce->toolsettings->statvis.sharp_max = DEG2RADF(180.0f);
699
700   sce->toolsettings->proportional_size = 1.0f;
701
702   sce->toolsettings->imapaint.paint.flags |= PAINT_SHOW_BRUSH;
703   sce->toolsettings->imapaint.normal_angle = 80;
704   sce->toolsettings->imapaint.seam_bleed = 2;
705
706   /* grease pencil multiframe falloff curve */
707   sce->toolsettings->gp_sculpt.cur_falloff = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
708   CurveMapping *gp_falloff_curve = sce->toolsettings->gp_sculpt.cur_falloff;
709   curvemapping_initialize(gp_falloff_curve);
710   curvemap_reset(
711       gp_falloff_curve->cm, &gp_falloff_curve->clipr, CURVE_PRESET_GAUSS, CURVEMAP_SLOPE_POSITIVE);
712
713   sce->toolsettings->gp_sculpt.cur_primitive = curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
714   CurveMapping *gp_primitive_curve = sce->toolsettings->gp_sculpt.cur_primitive;
715   curvemapping_initialize(gp_primitive_curve);
716   curvemap_reset(gp_primitive_curve->cm,
717                  &gp_primitive_curve->clipr,
718                  CURVE_PRESET_BELL,
719                  CURVEMAP_SLOPE_POSITIVE);
720
721   sce->toolsettings->gp_sculpt.guide.spacing = 20.0f;
722
723   sce->physics_settings.gravity[0] = 0.0f;
724   sce->physics_settings.gravity[1] = 0.0f;
725   sce->physics_settings.gravity[2] = -9.81f;
726   sce->physics_settings.flag = PHYS_GLOBAL_GRAVITY;
727
728   sce->unit.system = USER_UNIT_METRIC;
729   sce->unit.scale_length = 1.0f;
730   sce->unit.length_unit = bUnit_GetBaseUnitOfType(USER_UNIT_METRIC, B_UNIT_LENGTH);
731   sce->unit.mass_unit = bUnit_GetBaseUnitOfType(USER_UNIT_METRIC, B_UNIT_MASS);
732   sce->unit.time_unit = bUnit_GetBaseUnitOfType(USER_UNIT_METRIC, B_UNIT_TIME);
733
734   pset = &sce->toolsettings->particle;
735   pset->flag = PE_KEEP_LENGTHS | PE_LOCK_FIRST | PE_DEFLECT_EMITTER | PE_AUTO_VELOCITY;
736   pset->emitterdist = 0.25f;
737   pset->totrekey = 5;
738   pset->totaddkey = 5;
739   pset->brushtype = PE_BRUSH_COMB;
740   pset->draw_step = 2;
741   pset->fade_frames = 2;
742   pset->selectmode = SCE_SELECT_PATH;
743
744   for (a = 0; a < ARRAY_SIZE(pset->brush); a++) {
745     pset->brush[a].strength = 0.5f;
746     pset->brush[a].size = 50;
747     pset->brush[a].step = 10;
748     pset->brush[a].count = 10;
749   }
750   pset->brush[PE_BRUSH_CUT].strength = 1.0f;
751
752   sce->r.ffcodecdata.audio_mixrate = 48000;
753   sce->r.ffcodecdata.audio_volume = 1.0f;
754   sce->r.ffcodecdata.audio_bitrate = 192;
755   sce->r.ffcodecdata.audio_channels = 2;
756
757   BLI_strncpy(sce->r.engine, RE_engine_id_BLENDER_EEVEE, sizeof(sce->r.engine));
758
759   sce->audio.distance_model = 2.0f;
760   sce->audio.doppler_factor = 1.0f;
761   sce->audio.speed_of_sound = 343.3f;
762   sce->audio.volume = 1.0f;
763   sce->audio.flag = AUDIO_SYNC;
764
765   BLI_strncpy(sce->r.pic, U.renderdir, sizeof(sce->r.pic));
766
767   BLI_rctf_init(&sce->r.safety, 0.1f, 0.9f, 0.1f, 0.9f);
768
769   /* Note; in header_info.c the scene copy happens...,
770    * if you add more to renderdata it has to be checked there. */
771
772   /* multiview - stereo */
773   BKE_scene_add_render_view(sce, STEREO_LEFT_NAME);
774   srv = sce->r.views.first;
775   BLI_strncpy(srv->suffix, STEREO_LEFT_SUFFIX, sizeof(srv->suffix));
776
777   BKE_scene_add_render_view(sce, STEREO_RIGHT_NAME);
778   srv = sce->r.views.last;
779   BLI_strncpy(srv->suffix, STEREO_RIGHT_SUFFIX, sizeof(srv->suffix));
780
781   BKE_sound_reset_scene_runtime(sce);
782
783   /* color management */
784   colorspace_name = IMB_colormanagement_role_colorspace_name_get(COLOR_ROLE_DEFAULT_SEQUENCER);
785
786   BKE_color_managed_display_settings_init(&sce->display_settings);
787   BKE_color_managed_view_settings_init_render(
788       &sce->view_settings, &sce->display_settings, "Filmic");
789   BLI_strncpy(sce->sequencer_colorspace_settings.name,
790               colorspace_name,
791               sizeof(sce->sequencer_colorspace_settings.name));
792
793   /* Those next two sets (render and baking settings) are not currently in use,
794    * but are exposed to RNA API and hence must have valid data. */
795   BKE_color_managed_display_settings_init(&sce->r.im_format.display_settings);
796   BKE_color_managed_view_settings_init_render(
797       &sce->r.im_format.view_settings, &sce->r.im_format.display_settings, "Filmic");
798
799   BKE_color_managed_display_settings_init(&sce->r.bake.im_format.display_settings);
800   BKE_color_managed_view_settings_init_render(
801       &sce->r.bake.im_format.view_settings, &sce->r.bake.im_format.display_settings, "Filmic");
802
803   /* Safe Areas */
804   copy_v2_fl2(sce->safe_areas.title, 10.0f / 100.0f, 5.0f / 100.0f);
805   copy_v2_fl2(sce->safe_areas.action, 3.5f / 100.0f, 3.5f / 100.0f);
806   copy_v2_fl2(sce->safe_areas.title_center, 17.5f / 100.0f, 5.0f / 100.0f);
807   copy_v2_fl2(sce->safe_areas.action_center, 15.0f / 100.0f, 5.0f / 100.0f);
808
809   sce->preview = NULL;
810
811   /* GP Sculpt brushes */
812   {
813     GP_Sculpt_Settings *gset = &sce->toolsettings->gp_sculpt;
814     GP_Sculpt_Data *gp_brush;
815     float curcolor_add[3], curcolor_sub[3];
816     ARRAY_SET_ITEMS(curcolor_add, 1.0f, 0.6f, 0.6f);
817     ARRAY_SET_ITEMS(curcolor_sub, 0.6f, 0.6f, 1.0f);
818
819     gp_brush = &gset->brush[GP_SCULPT_TYPE_SMOOTH];
820     gp_brush->size = 25;
821     gp_brush->strength = 0.3f;
822     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_SMOOTH_PRESSURE |
823                      GP_SCULPT_FLAG_ENABLE_CURSOR;
824     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
825     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
826
827     gp_brush = &gset->brush[GP_SCULPT_TYPE_THICKNESS];
828     gp_brush->size = 25;
829     gp_brush->strength = 0.5f;
830     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_ENABLE_CURSOR;
831     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
832     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
833
834     gp_brush = &gset->brush[GP_SCULPT_TYPE_STRENGTH];
835     gp_brush->size = 25;
836     gp_brush->strength = 0.5f;
837     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_ENABLE_CURSOR;
838     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
839     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
840
841     gp_brush = &gset->brush[GP_SCULPT_TYPE_GRAB];
842     gp_brush->size = 50;
843     gp_brush->strength = 0.3f;
844     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_ENABLE_CURSOR;
845     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
846     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
847
848     gp_brush = &gset->brush[GP_SCULPT_TYPE_PUSH];
849     gp_brush->size = 25;
850     gp_brush->strength = 0.3f;
851     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_ENABLE_CURSOR;
852     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
853     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
854
855     gp_brush = &gset->brush[GP_SCULPT_TYPE_TWIST];
856     gp_brush->size = 50;
857     gp_brush->strength = 0.3f;
858     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_ENABLE_CURSOR;
859     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
860     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
861
862     gp_brush = &gset->brush[GP_SCULPT_TYPE_PINCH];
863     gp_brush->size = 50;
864     gp_brush->strength = 0.5f;
865     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_ENABLE_CURSOR;
866     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
867     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
868
869     gp_brush = &gset->brush[GP_SCULPT_TYPE_RANDOMIZE];
870     gp_brush->size = 25;
871     gp_brush->strength = 0.5f;
872     gp_brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_ENABLE_CURSOR;
873     copy_v3_v3(gp_brush->curcolor_add, curcolor_add);
874     copy_v3_v3(gp_brush->curcolor_sub, curcolor_sub);
875   }
876
877   /* GP Stroke Placement */
878   sce->toolsettings->gpencil_v3d_align = GP_PROJECT_VIEWSPACE;
879   sce->toolsettings->gpencil_v2d_align = GP_PROJECT_VIEWSPACE;
880   sce->toolsettings->gpencil_seq_align = GP_PROJECT_VIEWSPACE;
881   sce->toolsettings->gpencil_ima_align = GP_PROJECT_VIEWSPACE;
882
883   /* Annotations */
884   sce->toolsettings->annotate_v3d_align = GP_PROJECT_VIEWSPACE | GP_PROJECT_CURSOR;
885   sce->toolsettings->annotate_thickness = 3;
886
887   for (int i = 0; i < ARRAY_SIZE(sce->orientation_slots); i++) {
888     sce->orientation_slots[i].index_custom = -1;
889   }
890
891   /* Master Collection */
892   sce->master_collection = BKE_collection_master_add();
893
894   BKE_view_layer_add(sce, "View Layer");
895
896   /* SceneDisplay */
897   copy_v3_v3(sce->display.light_direction, (float[3]){M_SQRT1_3, M_SQRT1_3, M_SQRT1_3});
898   sce->display.shadow_shift = 0.1f;
899   sce->display.shadow_focus = 0.0f;
900
901   sce->display.matcap_ssao_distance = 0.2f;
902   sce->display.matcap_ssao_attenuation = 1.0f;
903   sce->display.matcap_ssao_samples = 16;
904
905   sce->display.render_aa = SCE_DISPLAY_AA_SAMPLES_8;
906   sce->display.viewport_aa = SCE_DISPLAY_AA_FXAA;
907
908   /* OpenGL Render. */
909   BKE_screen_view3d_shading_init(&sce->display.shading);
910
911   /* SceneEEVEE */
912   sce->eevee.gi_diffuse_bounces = 3;
913   sce->eevee.gi_cubemap_resolution = 512;
914   sce->eevee.gi_visibility_resolution = 32;
915   sce->eevee.gi_cubemap_draw_size = 0.3f;
916   sce->eevee.gi_irradiance_draw_size = 0.1f;
917   sce->eevee.gi_irradiance_smoothing = 0.1f;
918   sce->eevee.gi_filter_quality = 3.0f;
919
920   sce->eevee.taa_samples = 16;
921   sce->eevee.taa_render_samples = 64;
922
923   sce->eevee.sss_samples = 7;
924   sce->eevee.sss_jitter_threshold = 0.3f;
925
926   sce->eevee.ssr_quality = 0.25f;
927   sce->eevee.ssr_max_roughness = 0.5f;
928   sce->eevee.ssr_thickness = 0.2f;
929   sce->eevee.ssr_border_fade = 0.075f;
930   sce->eevee.ssr_firefly_fac = 10.0f;
931
932   sce->eevee.volumetric_start = 0.1f;
933   sce->eevee.volumetric_end = 100.0f;
934   sce->eevee.volumetric_tile_size = 8;
935   sce->eevee.volumetric_samples = 64;
936   sce->eevee.volumetric_sample_distribution = 0.8f;
937   sce->eevee.volumetric_light_clamp = 0.0f;
938   sce->eevee.volumetric_shadow_samples = 16;
939
940   sce->eevee.gtao_distance = 0.2f;
941   sce->eevee.gtao_factor = 1.0f;
942   sce->eevee.gtao_quality = 0.25f;
943
944   sce->eevee.bokeh_max_size = 100.0f;
945   sce->eevee.bokeh_threshold = 1.0f;
946
947   copy_v3_fl(sce->eevee.bloom_color, 1.0f);
948   sce->eevee.bloom_threshold = 0.8f;
949   sce->eevee.bloom_knee = 0.5f;
950   sce->eevee.bloom_intensity = 0.05f;
951   sce->eevee.bloom_radius = 6.5f;
952   sce->eevee.bloom_clamp = 0.0f;
953
954   sce->eevee.motion_blur_samples = 8;
955   sce->eevee.motion_blur_shutter = 0.5f;
956
957   sce->eevee.shadow_method = SHADOW_ESM;
958   sce->eevee.shadow_cube_size = 512;
959   sce->eevee.shadow_cascade_size = 1024;
960
961   sce->eevee.light_cache = NULL;
962   sce->eevee.light_threshold = 0.01f;
963
964   sce->eevee.overscan = 3.0f;
965
966   sce->eevee.flag = SCE_EEVEE_VOLUMETRIC_LIGHTS | SCE_EEVEE_GTAO_BENT_NORMALS |
967                     SCE_EEVEE_GTAO_BOUNCE | SCE_EEVEE_TAA_REPROJECTION |
968                     SCE_EEVEE_SSR_HALF_RESOLUTION;
969 }
970
971 Scene *BKE_scene_add(Main *bmain, const char *name)
972 {
973   Scene *sce;
974
975   sce = BKE_libblock_alloc(bmain, ID_SCE, name, 0);
976   id_us_min(&sce->id);
977   id_us_ensure_real(&sce->id);
978
979   BKE_scene_init(sce);
980
981   return sce;
982 }
983
984 /**
985  * Check if there is any instance of the object in the scene
986  */
987 bool BKE_scene_object_find(Scene *scene, Object *ob)
988 {
989   for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
990        view_layer = view_layer->next) {
991     if (BLI_findptr(&view_layer->object_bases, ob, offsetof(Base, object))) {
992       return true;
993     }
994   }
995   return false;
996 }
997
998 Object *BKE_scene_object_find_by_name(Scene *scene, const char *name)
999 {
1000   for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
1001        view_layer = view_layer->next) {
1002     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
1003       if (STREQ(base->object->id.name + 2, name)) {
1004         return base->object;
1005       }
1006     }
1007   }
1008   return NULL;
1009 }
1010
1011 /**
1012  * Sets the active scene, mainly used when running in background mode
1013  * (``--scene`` command line argument).
1014  * This is also called to set the scene directly, bypassing windowing code.
1015  * Otherwise #WM_window_set_active_scene is used when changing scenes by the user.
1016  */
1017 void BKE_scene_set_background(Main *bmain, Scene *scene)
1018 {
1019   Object *ob;
1020
1021   /* check for cyclic sets, for reading old files but also for definite security (py?) */
1022   BKE_scene_validate_setscene(bmain, scene);
1023
1024   /* deselect objects (for dataselect) */
1025   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1026     ob->flag &= ~SELECT;
1027   }
1028
1029   /* copy layers and flags from bases to objects */
1030   for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
1031        view_layer = view_layer->next) {
1032     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
1033       ob = base->object;
1034       /* collection patch... */
1035       BKE_scene_object_base_flag_sync_from_base(base);
1036     }
1037   }
1038   /* No full animation update, this to enable render code to work
1039    * (render code calls own animation updates). */
1040 }
1041
1042 /* called from creator_args.c */
1043 Scene *BKE_scene_set_name(Main *bmain, const char *name)
1044 {
1045   Scene *sce = (Scene *)BKE_libblock_find_name(bmain, ID_SCE, name);
1046   if (sce) {
1047     BKE_scene_set_background(bmain, sce);
1048     printf("Scene switch for render: '%s' in file: '%s'\n", name, BKE_main_blendfile_path(bmain));
1049     return sce;
1050   }
1051
1052   printf("Can't find scene: '%s' in file: '%s'\n", name, BKE_main_blendfile_path(bmain));
1053   return NULL;
1054 }
1055
1056 /* Used by metaballs, return *all* objects (including duplis)
1057  * existing in the scene (including scene's sets). */
1058 int BKE_scene_base_iter_next(
1059     Depsgraph *depsgraph, SceneBaseIter *iter, Scene **scene, int val, Base **base, Object **ob)
1060 {
1061   bool run_again = true;
1062
1063   /* init */
1064   if (val == 0) {
1065     iter->phase = F_START;
1066     iter->dupob = NULL;
1067     iter->duplilist = NULL;
1068     iter->dupli_refob = NULL;
1069   }
1070   else {
1071     /* run_again is set when a duplilist has been ended */
1072     while (run_again) {
1073       run_again = false;
1074
1075       /* the first base */
1076       if (iter->phase == F_START) {
1077         ViewLayer *view_layer = (depsgraph) ? DEG_get_evaluated_view_layer(depsgraph) :
1078                                               BKE_view_layer_context_active_PLACEHOLDER(*scene);
1079         *base = view_layer->object_bases.first;
1080         if (*base) {
1081           *ob = (*base)->object;
1082           iter->phase = F_SCENE;
1083         }
1084         else {
1085           /* exception: empty scene layer */
1086           while ((*scene)->set) {
1087             (*scene) = (*scene)->set;
1088             ViewLayer *view_layer_set = BKE_view_layer_default_render((*scene));
1089             if (view_layer_set->object_bases.first) {
1090               *base = view_layer_set->object_bases.first;
1091               *ob = (*base)->object;
1092               iter->phase = F_SCENE;
1093               break;
1094             }
1095           }
1096         }
1097       }
1098       else {
1099         if (*base && iter->phase != F_DUPLI) {
1100           *base = (*base)->next;
1101           if (*base) {
1102             *ob = (*base)->object;
1103           }
1104           else {
1105             if (iter->phase == F_SCENE) {
1106               /* (*scene) is finished, now do the set */
1107               while ((*scene)->set) {
1108                 (*scene) = (*scene)->set;
1109                 ViewLayer *view_layer_set = BKE_view_layer_default_render((*scene));
1110                 if (view_layer_set->object_bases.first) {
1111                   *base = view_layer_set->object_bases.first;
1112                   *ob = (*base)->object;
1113                   break;
1114                 }
1115               }
1116             }
1117           }
1118         }
1119       }
1120
1121       if (*base == NULL) {
1122         iter->phase = F_START;
1123       }
1124       else {
1125         if (iter->phase != F_DUPLI) {
1126           if (depsgraph && (*base)->object->transflag & OB_DUPLI) {
1127             /* collections cannot be duplicated for metaballs yet,
1128              * this enters eternal loop because of
1129              * makeDispListMBall getting called inside of collection_duplilist */
1130             if ((*base)->object->instance_collection == NULL) {
1131               iter->duplilist = object_duplilist(depsgraph, (*scene), (*base)->object);
1132
1133               iter->dupob = iter->duplilist->first;
1134
1135               if (!iter->dupob) {
1136                 free_object_duplilist(iter->duplilist);
1137                 iter->duplilist = NULL;
1138               }
1139               iter->dupli_refob = NULL;
1140             }
1141           }
1142         }
1143         /* handle dupli's */
1144         if (iter->dupob) {
1145           (*base)->flag_legacy |= OB_FROMDUPLI;
1146           *ob = iter->dupob->ob;
1147           iter->phase = F_DUPLI;
1148
1149           if (iter->dupli_refob != *ob) {
1150             if (iter->dupli_refob) {
1151               /* Restore previous object's real matrix. */
1152               copy_m4_m4(iter->dupli_refob->obmat, iter->omat);
1153             }
1154             /* Backup new object's real matrix. */
1155             iter->dupli_refob = *ob;
1156             copy_m4_m4(iter->omat, iter->dupli_refob->obmat);
1157           }
1158           copy_m4_m4((*ob)->obmat, iter->dupob->mat);
1159
1160           iter->dupob = iter->dupob->next;
1161         }
1162         else if (iter->phase == F_DUPLI) {
1163           iter->phase = F_SCENE;
1164           (*base)->flag_legacy &= ~OB_FROMDUPLI;
1165
1166           if (iter->dupli_refob) {
1167             /* Restore last object's real matrix. */
1168             copy_m4_m4(iter->dupli_refob->obmat, iter->omat);
1169             iter->dupli_refob = NULL;
1170           }
1171
1172           free_object_duplilist(iter->duplilist);
1173           iter->duplilist = NULL;
1174           run_again = true;
1175         }
1176       }
1177     }
1178   }
1179
1180   return iter->phase;
1181 }
1182
1183 Scene *BKE_scene_find_from_collection(const Main *bmain, const Collection *collection)
1184 {
1185   for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1186     for (ViewLayer *layer = scene->view_layers.first; layer; layer = layer->next) {
1187       if (BKE_view_layer_has_collection(layer, collection)) {
1188         return scene;
1189       }
1190     }
1191   }
1192
1193   return NULL;
1194 }
1195
1196 #ifdef DURIAN_CAMERA_SWITCH
1197 Object *BKE_scene_camera_switch_find(Scene *scene)
1198 {
1199   if (scene->r.mode & R_NO_CAMERA_SWITCH) {
1200     return NULL;
1201   }
1202
1203   TimeMarker *m;
1204   int cfra = scene->r.cfra;
1205   int frame = -(MAXFRAME + 1);
1206   int min_frame = MAXFRAME + 1;
1207   Object *camera = NULL;
1208   Object *first_camera = NULL;
1209
1210   for (m = scene->markers.first; m; m = m->next) {
1211     if (m->camera && (m->camera->restrictflag & OB_RESTRICT_RENDER) == 0) {
1212       if ((m->frame <= cfra) && (m->frame > frame)) {
1213         camera = m->camera;
1214         frame = m->frame;
1215
1216         if (frame == cfra) {
1217           break;
1218         }
1219       }
1220
1221       if (m->frame < min_frame) {
1222         first_camera = m->camera;
1223         min_frame = m->frame;
1224       }
1225     }
1226   }
1227
1228   if (camera == NULL) {
1229     /* If there's no marker to the left of current frame,
1230      * use camera from left-most marker to solve all sort
1231      * of Schrodinger uncertainties.
1232      */
1233     return first_camera;
1234   }
1235
1236   return camera;
1237 }
1238 #endif
1239
1240 int BKE_scene_camera_switch_update(Scene *scene)
1241 {
1242 #ifdef DURIAN_CAMERA_SWITCH
1243   Object *camera = BKE_scene_camera_switch_find(scene);
1244   if (camera) {
1245     scene->camera = camera;
1246     DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
1247     return 1;
1248   }
1249 #else
1250   (void)scene;
1251 #endif
1252   return 0;
1253 }
1254
1255 char *BKE_scene_find_marker_name(Scene *scene, int frame)
1256 {
1257   ListBase *markers = &scene->markers;
1258   TimeMarker *m1, *m2;
1259
1260   /* search through markers for match */
1261   for (m1 = markers->first, m2 = markers->last; m1 && m2; m1 = m1->next, m2 = m2->prev) {
1262     if (m1->frame == frame) {
1263       return m1->name;
1264     }
1265
1266     if (m1 == m2) {
1267       break;
1268     }
1269
1270     if (m2->frame == frame) {
1271       return m2->name;
1272     }
1273   }
1274
1275   return NULL;
1276 }
1277
1278 /* return the current marker for this frame,
1279  * we can have more than 1 marker per frame, this just returns the first :/ */
1280 char *BKE_scene_find_last_marker_name(Scene *scene, int frame)
1281 {
1282   TimeMarker *marker, *best_marker = NULL;
1283   int best_frame = -MAXFRAME * 2;
1284   for (marker = scene->markers.first; marker; marker = marker->next) {
1285     if (marker->frame == frame) {
1286       return marker->name;
1287     }
1288
1289     if (marker->frame > best_frame && marker->frame < frame) {
1290       best_marker = marker;
1291       best_frame = marker->frame;
1292     }
1293   }
1294
1295   return best_marker ? best_marker->name : NULL;
1296 }
1297
1298 int BKE_scene_frame_snap_by_seconds(Scene *scene, double interval_in_seconds, int cfra)
1299 {
1300   const int fps = round_db_to_int(FPS * interval_in_seconds);
1301   const int second_prev = cfra - mod_i(cfra, fps);
1302   const int second_next = second_prev + fps;
1303   const int delta_prev = cfra - second_prev;
1304   const int delta_next = second_next - cfra;
1305   return (delta_prev < delta_next) ? second_prev : second_next;
1306 }
1307
1308 void BKE_scene_remove_rigidbody_object(struct Main *bmain, Scene *scene, Object *ob)
1309 {
1310   /* remove rigid body constraint from world before removing object */
1311   if (ob->rigidbody_constraint) {
1312     BKE_rigidbody_remove_constraint(scene, ob);
1313   }
1314   /* remove rigid body object from world before removing object */
1315   if (ob->rigidbody_object) {
1316     BKE_rigidbody_remove_object(bmain, scene, ob);
1317   }
1318 }
1319
1320 /* checks for cycle, returns 1 if it's all OK */
1321 bool BKE_scene_validate_setscene(Main *bmain, Scene *sce)
1322 {
1323   Scene *sce_iter;
1324   int a, totscene;
1325
1326   if (sce->set == NULL) {
1327     return true;
1328   }
1329   totscene = BLI_listbase_count(&bmain->scenes);
1330
1331   for (a = 0, sce_iter = sce; sce_iter->set; sce_iter = sce_iter->set, a++) {
1332     /* more iterations than scenes means we have a cycle */
1333     if (a > totscene) {
1334       /* the tested scene gets zero'ed, that's typically current scene */
1335       sce->set = NULL;
1336       return false;
1337     }
1338   }
1339
1340   return true;
1341 }
1342
1343 /**
1344  * This function is needed to cope with fractional frames - including two Blender rendering
1345  * features mblur (motion blur that renders 'subframes' and blurs them together),
1346  * and fields rendering.
1347  */
1348 float BKE_scene_frame_get(const Scene *scene)
1349 {
1350   return BKE_scene_frame_get_from_ctime(scene, scene->r.cfra);
1351 }
1352
1353 /* This function is used to obtain arbitrary fractional frames */
1354 float BKE_scene_frame_get_from_ctime(const Scene *scene, const float frame)
1355 {
1356   float ctime = frame;
1357   ctime += scene->r.subframe;
1358   ctime *= scene->r.framelen;
1359
1360   return ctime;
1361 }
1362 /**
1363  * Sets the frame int/float components.
1364  */
1365 void BKE_scene_frame_set(struct Scene *scene, double cfra)
1366 {
1367   double intpart;
1368   scene->r.subframe = modf(cfra, &intpart);
1369   scene->r.cfra = (int)intpart;
1370 }
1371
1372 /* -------------------------------------------------------------------- */
1373 /** \name Scene Orientation Slots
1374  * \{ */
1375
1376 TransformOrientationSlot *BKE_scene_orientation_slot_get(Scene *scene, int slot_index)
1377 {
1378   if ((scene->orientation_slots[slot_index].flag & SELECT) == 0) {
1379     slot_index = SCE_ORIENT_DEFAULT;
1380   }
1381   return &scene->orientation_slots[slot_index];
1382 }
1383
1384 TransformOrientationSlot *BKE_scene_orientation_slot_get_from_flag(Scene *scene, int flag)
1385 {
1386   BLI_assert(flag && !(flag & ~(V3D_GIZMO_SHOW_OBJECT_TRANSLATE | V3D_GIZMO_SHOW_OBJECT_ROTATE |
1387                                 V3D_GIZMO_SHOW_OBJECT_SCALE)));
1388   int slot_index = SCE_ORIENT_DEFAULT;
1389   if (flag & V3D_GIZMO_SHOW_OBJECT_TRANSLATE) {
1390     slot_index = SCE_ORIENT_TRANSLATE;
1391   }
1392   else if (flag & V3D_GIZMO_SHOW_OBJECT_ROTATE) {
1393     slot_index = SCE_ORIENT_ROTATE;
1394   }
1395   else if (flag & V3D_GIZMO_SHOW_OBJECT_SCALE) {
1396     slot_index = SCE_ORIENT_SCALE;
1397   }
1398   return BKE_scene_orientation_slot_get(scene, slot_index);
1399 }
1400
1401 /**
1402  * Activate a transform orientation in a 3D view based on an enum value.
1403  *
1404  * \param orientation: If this is #V3D_ORIENT_CUSTOM or greater, the custom transform orientation
1405  * with index \a orientation - #V3D_ORIENT_CUSTOM gets activated.
1406  */
1407 void BKE_scene_orientation_slot_set_index(TransformOrientationSlot *orient_slot, int orientation)
1408 {
1409   const bool is_custom = orientation >= V3D_ORIENT_CUSTOM;
1410   orient_slot->type = is_custom ? V3D_ORIENT_CUSTOM : orientation;
1411   orient_slot->index_custom = is_custom ? (orientation - V3D_ORIENT_CUSTOM) : -1;
1412 }
1413
1414 int BKE_scene_orientation_slot_get_index(const TransformOrientationSlot *orient_slot)
1415 {
1416   return (orient_slot->type == V3D_ORIENT_CUSTOM) ?
1417              (orient_slot->type + orient_slot->index_custom) :
1418              orient_slot->type;
1419 }
1420
1421 /** \} */
1422
1423 /* That's like really a bummer, because currently animation data for armatures
1424  * might want to use pose, and pose might be missing on the object.
1425  * This happens when changing visible layers, which leads to situations when
1426  * pose is missing or marked for recalc, animation will change it and then
1427  * object update will restore the pose.
1428  *
1429  * This could be solved by the new dependency graph, but for until then we'll
1430  * do an extra pass on the objects to ensure it's all fine.
1431  */
1432 #define POSE_ANIMATION_WORKAROUND
1433
1434 #ifdef POSE_ANIMATION_WORKAROUND
1435 static void scene_armature_depsgraph_workaround(Main *bmain, Depsgraph *depsgraph)
1436 {
1437   Object *ob;
1438   if (BLI_listbase_is_empty(&bmain->armatures) || !DEG_id_type_updated(depsgraph, ID_OB)) {
1439     return;
1440   }
1441   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1442     if (ob->type == OB_ARMATURE && ob->adt) {
1443       if (ob->pose == NULL || (ob->pose->flag & POSE_RECALC)) {
1444         BKE_pose_rebuild(bmain, ob, ob->data, true);
1445       }
1446     }
1447   }
1448 }
1449 #endif
1450
1451 static bool check_rendered_viewport_visible(Main *bmain)
1452 {
1453   wmWindowManager *wm = bmain->wm.first;
1454   wmWindow *window;
1455   for (window = wm->windows.first; window != NULL; window = window->next) {
1456     const bScreen *screen = BKE_workspace_active_screen_get(window->workspace_hook);
1457     Scene *scene = window->scene;
1458     RenderEngineType *type = RE_engines_find(scene->r.engine);
1459
1460     if (type->draw_engine || !type->render) {
1461       continue;
1462     }
1463
1464     for (ScrArea *area = screen->areabase.first; area != NULL; area = area->next) {
1465       View3D *v3d = area->spacedata.first;
1466       if (area->spacetype != SPACE_VIEW3D) {
1467         continue;
1468       }
1469       if (v3d->shading.type == OB_RENDER) {
1470         return true;
1471       }
1472     }
1473   }
1474   return false;
1475 }
1476
1477 /* TODO(campbell): shouldn't we be able to use 'DEG_get_view_layer' here?
1478  * Currently this is NULL on load, so don't. */
1479 static void prepare_mesh_for_viewport_render(Main *bmain, const ViewLayer *view_layer)
1480 {
1481   /* This is needed to prepare mesh to be used by the render
1482    * engine from the viewport rendering. We do loading here
1483    * so all the objects which shares the same mesh datablock
1484    * are nicely tagged for update and updated.
1485    *
1486    * This makes it so viewport render engine doesn't need to
1487    * call loading of the edit data for the mesh objects.
1488    */
1489
1490   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
1491   if (obedit) {
1492     Mesh *mesh = obedit->data;
1493     if ((obedit->type == OB_MESH) &&
1494         ((obedit->id.recalc & ID_RECALC_ALL) || (mesh->id.recalc & ID_RECALC_ALL))) {
1495       if (check_rendered_viewport_visible(bmain)) {
1496         BMesh *bm = mesh->edit_mesh->bm;
1497         BM_mesh_bm_to_me(bmain,
1498                          bm,
1499                          mesh,
1500                          (&(struct BMeshToMeshParams){
1501                              .calc_object_remap = true,
1502                          }));
1503         DEG_id_tag_update(&mesh->id, 0);
1504       }
1505     }
1506   }
1507 }
1508
1509 void BKE_scene_update_sound(Depsgraph *depsgraph, Main *bmain)
1510 {
1511   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1512   const int recalc = scene->id.recalc;
1513   BKE_sound_ensure_scene(scene);
1514   if (recalc & ID_RECALC_AUDIO_SEEK) {
1515     BKE_sound_seek_scene(bmain, scene);
1516   }
1517   if (recalc & ID_RECALC_AUDIO_FPS) {
1518     BKE_sound_update_fps(bmain, scene);
1519   }
1520   if (recalc & ID_RECALC_AUDIO_VOLUME) {
1521     BKE_sound_set_scene_volume(scene, scene->audio.volume);
1522   }
1523   if (recalc & ID_RECALC_AUDIO_MUTE) {
1524     const bool is_mute = (scene->audio.flag & AUDIO_MUTE);
1525     BKE_sound_mute_scene(scene, is_mute);
1526   }
1527   if (recalc & ID_RECALC_AUDIO_LISTENER) {
1528     BKE_sound_update_scene_listener(scene);
1529   }
1530   BKE_sound_update_scene(depsgraph, scene);
1531 }
1532
1533 /* TODO(sergey): This actually should become view_layer_graph or so.
1534  * Same applies to update_for_newframe.
1535  *
1536  * If only_if_tagged is truth then the function will do nothing if the dependency graph is up
1537  * to date already.
1538  */
1539 static void scene_graph_update_tagged(Depsgraph *depsgraph, Main *bmain, bool only_if_tagged)
1540 {
1541   if (only_if_tagged && DEG_is_fully_evaluated(depsgraph)) {
1542     return;
1543   }
1544
1545   Scene *scene = DEG_get_input_scene(depsgraph);
1546   ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
1547
1548   bool run_callbacks = DEG_id_type_any_updated(depsgraph);
1549   if (run_callbacks) {
1550     BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_DEPSGRAPH_UPDATE_PRE);
1551   }
1552
1553   /* TODO(sergey): Some functions here are changing global state,
1554    * for example, clearing update tags from bmain.
1555    */
1556   /* (Re-)build dependency graph if needed. */
1557   DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
1558   /* Uncomment this to check if graph was properly tagged for update. */
1559   // DEG_debug_graph_relations_validate(depsgraph, bmain, scene);
1560   /* Flush editing data if needed. */
1561   prepare_mesh_for_viewport_render(bmain, view_layer);
1562   /* Flush recalc flags to dependencies. */
1563   DEG_graph_flush_update(bmain, depsgraph);
1564   /* Update all objects: drivers, matrices, displists, etc. flags set
1565    * by depgraph or manual, no layer check here, gets correct flushed.
1566    */
1567   DEG_evaluate_on_refresh(depsgraph);
1568   /* Update sound system. */
1569   BKE_scene_update_sound(depsgraph, bmain);
1570   /* Notify python about depsgraph update. */
1571   if (run_callbacks) {
1572     BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_DEPSGRAPH_UPDATE_POST);
1573   }
1574   /* Inform editors about possible changes. */
1575   DEG_ids_check_recalc(bmain, depsgraph, scene, view_layer, false);
1576   /* Clear recalc flags. */
1577   DEG_ids_clear_recalc(bmain, depsgraph);
1578 }
1579
1580 void BKE_scene_graph_update_tagged(Depsgraph *depsgraph, Main *bmain)
1581 {
1582   scene_graph_update_tagged(depsgraph, bmain, false);
1583 }
1584
1585 void BKE_scene_graph_evaluated_ensure(Depsgraph *depsgraph, Main *bmain)
1586 {
1587   scene_graph_update_tagged(depsgraph, bmain, true);
1588 }
1589
1590 /* applies changes right away, does all sets too */
1591 void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph, Main *bmain)
1592 {
1593   Scene *scene = DEG_get_input_scene(depsgraph);
1594   ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
1595
1596   /* TODO(sergey): Some functions here are changing global state,
1597    * for example, clearing update tags from bmain.
1598    */
1599   const float ctime = BKE_scene_frame_get(scene);
1600   /* Keep this first. */
1601   BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_FRAME_CHANGE_PRE);
1602   /* Update animated image textures for particles, modifiers, gpu, etc,
1603    * call this at the start so modifiers with textures don't lag 1 frame.
1604    */
1605   BKE_image_editors_update_frame(bmain, scene->r.cfra);
1606   BKE_sound_set_cfra(scene->r.cfra);
1607   DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
1608 #ifdef POSE_ANIMATION_WORKAROUND
1609   scene_armature_depsgraph_workaround(bmain, depsgraph);
1610 #endif
1611   /* Update all objects: drivers, matrices, displists, etc. flags set
1612    * by depgraph or manual, no layer check here, gets correct flushed.
1613    */
1614   DEG_evaluate_on_framechange(bmain, depsgraph, ctime);
1615   /* Update sound system animation. */
1616   BKE_scene_update_sound(depsgraph, bmain);
1617   /* Notify editors and python about recalc. */
1618   BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_FRAME_CHANGE_POST);
1619   /* Inform editors about possible changes. */
1620   DEG_ids_check_recalc(bmain, depsgraph, scene, view_layer, true);
1621   /* clear recalc flags */
1622   DEG_ids_clear_recalc(bmain, depsgraph);
1623 }
1624
1625 /** Ensures given scene/view_layer pair has a valid, up-to-date depsgraph.
1626  *
1627  * \warning Sets matching depsgraph as active,
1628  * so should only be called from the active editing context (usually, from operators).
1629  */
1630 void BKE_scene_view_layer_graph_evaluated_ensure(Main *bmain, Scene *scene, ViewLayer *view_layer)
1631 {
1632   Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
1633   DEG_make_active(depsgraph);
1634   BKE_scene_graph_update_tagged(depsgraph, bmain);
1635 }
1636
1637 /* return default view */
1638 SceneRenderView *BKE_scene_add_render_view(Scene *sce, const char *name)
1639 {
1640   SceneRenderView *srv;
1641
1642   if (!name) {
1643     name = DATA_("RenderView");
1644   }
1645
1646   srv = MEM_callocN(sizeof(SceneRenderView), "new render view");
1647   BLI_strncpy(srv->name, name, sizeof(srv->name));
1648   BLI_uniquename(&sce->r.views,
1649                  srv,
1650                  DATA_("RenderView"),
1651                  '.',
1652                  offsetof(SceneRenderView, name),
1653                  sizeof(srv->name));
1654   BLI_addtail(&sce->r.views, srv);
1655
1656   return srv;
1657 }
1658
1659 bool BKE_scene_remove_render_view(Scene *scene, SceneRenderView *srv)
1660 {
1661   const int act = BLI_findindex(&scene->r.views, srv);
1662
1663   if (act == -1) {
1664     return false;
1665   }
1666   else if (scene->r.views.first == scene->r.views.last) {
1667     /* ensure 1 view is kept */
1668     return false;
1669   }
1670
1671   BLI_remlink(&scene->r.views, srv);
1672   MEM_freeN(srv);
1673
1674   scene->r.actview = 0;
1675
1676   return true;
1677 }
1678
1679 /* render simplification */
1680
1681 int get_render_subsurf_level(const RenderData *r, int lvl, bool for_render)
1682 {
1683   if (r->mode & R_SIMPLIFY) {
1684     if (for_render) {
1685       return min_ii(r->simplify_subsurf_render, lvl);
1686     }
1687     else {
1688       return min_ii(r->simplify_subsurf, lvl);
1689     }
1690   }
1691   else {
1692     return lvl;
1693   }
1694 }
1695
1696 int get_render_child_particle_number(const RenderData *r, int num, bool for_render)
1697 {
1698   if (r->mode & R_SIMPLIFY) {
1699     if (for_render) {
1700       return (int)(r->simplify_particles_render * num);
1701     }
1702     else {
1703       return (int)(r->simplify_particles * num);
1704     }
1705   }
1706   else {
1707     return num;
1708   }
1709 }
1710
1711 /**
1712  * Helper function for the SETLOOPER and SETLOOPER_VIEW_LAYER macros
1713  *
1714  * It iterates over the bases of the active layer and then the bases
1715  * of the active layer of the background (set) scenes recursively.
1716  */
1717 Base *_setlooper_base_step(Scene **sce_iter, ViewLayer *view_layer, Base *base)
1718 {
1719   if (base && base->next) {
1720     /* Common case, step to the next. */
1721     return base->next;
1722   }
1723   else if ((base == NULL) && (view_layer != NULL)) {
1724     /* First time looping, return the scenes first base. */
1725     /* For the first loop we should get the layer from workspace when available. */
1726     if (view_layer->object_bases.first) {
1727       return (Base *)view_layer->object_bases.first;
1728     }
1729     /* No base on this scene layer. */
1730     goto next_set;
1731   }
1732   else {
1733   next_set:
1734     /* Reached the end, get the next base in the set. */
1735     while ((*sce_iter = (*sce_iter)->set)) {
1736       ViewLayer *view_layer_set = BKE_view_layer_default_render((*sce_iter));
1737       base = (Base *)view_layer_set->object_bases.first;
1738
1739       if (base) {
1740         return base;
1741       }
1742     }
1743   }
1744
1745   return NULL;
1746 }
1747
1748 bool BKE_scene_use_shading_nodes_custom(Scene *scene)
1749 {
1750   RenderEngineType *type = RE_engines_find(scene->r.engine);
1751   return (type && type->flag & RE_USE_SHADING_NODES_CUSTOM);
1752 }
1753
1754 bool BKE_scene_use_spherical_stereo(Scene *scene)
1755 {
1756   RenderEngineType *type = RE_engines_find(scene->r.engine);
1757   return (type && type->flag & RE_USE_SPHERICAL_STEREO);
1758 }
1759
1760 bool BKE_scene_uses_blender_eevee(const Scene *scene)
1761 {
1762   return STREQ(scene->r.engine, RE_engine_id_BLENDER_EEVEE);
1763 }
1764
1765 bool BKE_scene_uses_blender_workbench(const Scene *scene)
1766 {
1767   return STREQ(scene->r.engine, RE_engine_id_BLENDER_WORKBENCH);
1768 }
1769
1770 bool BKE_scene_uses_cycles(const Scene *scene)
1771 {
1772   return STREQ(scene->r.engine, RE_engine_id_CYCLES);
1773 }
1774
1775 void BKE_scene_base_flag_to_objects(ViewLayer *view_layer)
1776 {
1777   Base *base = view_layer->object_bases.first;
1778
1779   while (base) {
1780     BKE_scene_object_base_flag_sync_from_base(base);
1781     base = base->next;
1782   }
1783 }
1784
1785 /**
1786  * Synchronize object base flags
1787  *
1788  * This is usually handled by the depsgraph.
1789  * However, in rare occasions we need to use the latest object flags
1790  * before depsgraph is fully updated.
1791  *
1792  * It should (ideally) only run for copy-on-written objects since this is
1793  * runtime data generated per-viewlayer.
1794  */
1795 void BKE_scene_object_base_flag_sync_from_base(Base *base)
1796 {
1797   Object *ob = base->object;
1798   ob->base_flag = base->flag;
1799 }
1800
1801 void BKE_scene_disable_color_management(Scene *scene)
1802 {
1803   ColorManagedDisplaySettings *display_settings = &scene->display_settings;
1804   ColorManagedViewSettings *view_settings = &scene->view_settings;
1805   const char *view;
1806   const char *none_display_name;
1807
1808   none_display_name = IMB_colormanagement_display_get_none_name();
1809
1810   BLI_strncpy(display_settings->display_device,
1811               none_display_name,
1812               sizeof(display_settings->display_device));
1813
1814   view = IMB_colormanagement_view_get_default_name(display_settings->display_device);
1815
1816   if (view) {
1817     BLI_strncpy(view_settings->view_transform, view, sizeof(view_settings->view_transform));
1818   }
1819 }
1820
1821 bool BKE_scene_check_color_management_enabled(const Scene *scene)
1822 {
1823   return !STREQ(scene->display_settings.display_device, "None");
1824 }
1825
1826 bool BKE_scene_check_rigidbody_active(const Scene *scene)
1827 {
1828   return scene && scene->rigidbody_world && scene->rigidbody_world->group &&
1829          !(scene->rigidbody_world->flag & RBW_FLAG_MUTED);
1830 }
1831
1832 int BKE_render_num_threads(const RenderData *rd)
1833 {
1834   int threads;
1835
1836   /* override set from command line? */
1837   threads = BLI_system_num_threads_override_get();
1838
1839   if (threads > 0) {
1840     return threads;
1841   }
1842
1843   /* fixed number of threads specified in scene? */
1844   if (rd->mode & R_FIXED_THREADS) {
1845     threads = rd->threads;
1846   }
1847   else {
1848     threads = BLI_system_thread_count();
1849   }
1850
1851   return max_ii(threads, 1);
1852 }
1853
1854 int BKE_scene_num_threads(const Scene *scene)
1855 {
1856   return BKE_render_num_threads(&scene->r);
1857 }
1858
1859 int BKE_render_preview_pixel_size(const RenderData *r)
1860 {
1861   if (r->preview_pixel_size == 0) {
1862     return (U.pixelsize > 1.5f) ? 2 : 1;
1863   }
1864   return r->preview_pixel_size;
1865 }
1866
1867 /**
1868  * Apply the needed correction factor to value, based on unit_type
1869  * (only length-related are affected currently) and unit->scale_length.
1870  */
1871 double BKE_scene_unit_scale(const UnitSettings *unit, const int unit_type, double value)
1872 {
1873   if (unit->system == USER_UNIT_NONE) {
1874     /* Never apply scale_length when not using a unit setting! */
1875     return value;
1876   }
1877
1878   switch (unit_type) {
1879     case B_UNIT_LENGTH:
1880       return value * (double)unit->scale_length;
1881     case B_UNIT_AREA:
1882     case B_UNIT_POWER:
1883       return value * pow(unit->scale_length, 2);
1884     case B_UNIT_VOLUME:
1885       return value * pow(unit->scale_length, 3);
1886     case B_UNIT_MASS:
1887       return value * pow(unit->scale_length, 3);
1888     case B_UNIT_CAMERA: /* *Do not* use scene's unit scale for camera focal lens! See T42026. */
1889     default:
1890       return value;
1891   }
1892 }
1893
1894 /******************** multiview *************************/
1895
1896 int BKE_scene_multiview_num_views_get(const RenderData *rd)
1897 {
1898   SceneRenderView *srv;
1899   int totviews = 0;
1900
1901   if ((rd->scemode & R_MULTIVIEW) == 0) {
1902     return 1;
1903   }
1904
1905   if (rd->views_format == SCE_VIEWS_FORMAT_STEREO_3D) {
1906     srv = BLI_findstring(&rd->views, STEREO_LEFT_NAME, offsetof(SceneRenderView, name));
1907     if ((srv && srv->viewflag & SCE_VIEW_DISABLE) == 0) {
1908       totviews++;
1909     }
1910
1911     srv = BLI_findstring(&rd->views, STEREO_RIGHT_NAME, offsetof(SceneRenderView, name));
1912     if ((srv && srv->viewflag & SCE_VIEW_DISABLE) == 0) {
1913       totviews++;
1914     }
1915   }
1916   else {
1917     for (srv = rd->views.first; srv; srv = srv->next) {
1918       if ((srv->viewflag & SCE_VIEW_DISABLE) == 0) {
1919         totviews++;
1920       }
1921     }
1922   }
1923   return totviews;
1924 }
1925
1926 bool BKE_scene_multiview_is_stereo3d(const RenderData *rd)
1927 {
1928   SceneRenderView *srv[2];
1929
1930   if ((rd->scemode & R_MULTIVIEW) == 0) {
1931     return false;
1932   }
1933
1934   srv[0] = (SceneRenderView *)BLI_findstring(
1935       &rd->views, STEREO_LEFT_NAME, offsetof(SceneRenderView, name));
1936   srv[1] = (SceneRenderView *)BLI_findstring(
1937       &rd->views, STEREO_RIGHT_NAME, offsetof(SceneRenderView, name));
1938
1939   return (srv[0] && ((srv[0]->viewflag & SCE_VIEW_DISABLE) == 0) && srv[1] &&
1940           ((srv[1]->viewflag & SCE_VIEW_DISABLE) == 0));
1941 }
1942
1943 /* return whether to render this SceneRenderView */
1944 bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
1945 {
1946   if (srv == NULL) {
1947     return false;
1948   }
1949
1950   if ((rd->scemode & R_MULTIVIEW) == 0) {
1951     return false;
1952   }
1953
1954   if ((srv->viewflag & SCE_VIEW_DISABLE)) {
1955     return false;
1956   }
1957
1958   if (rd->views_format == SCE_VIEWS_FORMAT_MULTIVIEW) {
1959     return true;
1960   }
1961
1962   /* SCE_VIEWS_SETUP_BASIC */
1963   if (STREQ(srv->name, STEREO_LEFT_NAME) || STREQ(srv->name, STEREO_RIGHT_NAME)) {
1964     return true;
1965   }
1966
1967   return false;
1968 }
1969
1970 /* return true if viewname is the first or if the name is NULL or not found */
1971 bool BKE_scene_multiview_is_render_view_first(const RenderData *rd, const char *viewname)
1972 {
1973   SceneRenderView *srv;
1974
1975   if ((rd->scemode & R_MULTIVIEW) == 0) {
1976     return true;
1977   }
1978
1979   if ((!viewname) || (!viewname[0])) {
1980     return true;
1981   }
1982
1983   for (srv = rd->views.first; srv; srv = srv->next) {
1984     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
1985       return STREQ(viewname, srv->name);
1986     }
1987   }
1988
1989   return true;
1990 }
1991
1992 /* return true if viewname is the last or if the name is NULL or not found */
1993 bool BKE_scene_multiview_is_render_view_last(const RenderData *rd, const char *viewname)
1994 {
1995   SceneRenderView *srv;
1996
1997   if ((rd->scemode & R_MULTIVIEW) == 0) {
1998     return true;
1999   }
2000
2001   if ((!viewname) || (!viewname[0])) {
2002     return true;
2003   }
2004
2005   for (srv = rd->views.last; srv; srv = srv->prev) {
2006     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
2007       return STREQ(viewname, srv->name);
2008     }
2009   }
2010
2011   return true;
2012 }
2013
2014 SceneRenderView *BKE_scene_multiview_render_view_findindex(const RenderData *rd, const int view_id)
2015 {
2016   SceneRenderView *srv;
2017   size_t nr;
2018
2019   if ((rd->scemode & R_MULTIVIEW) == 0) {
2020     return NULL;
2021   }
2022
2023   for (srv = rd->views.first, nr = 0; srv; srv = srv->next) {
2024     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
2025       if (nr++ == view_id) {
2026         return srv;
2027       }
2028     }
2029   }
2030   return srv;
2031 }
2032
2033 const char *BKE_scene_multiview_render_view_name_get(const RenderData *rd, const int view_id)
2034 {
2035   SceneRenderView *srv = BKE_scene_multiview_render_view_findindex(rd, view_id);
2036
2037   if (srv) {
2038     return srv->name;
2039   }
2040   else {
2041     return "";
2042   }
2043 }
2044
2045 int BKE_scene_multiview_view_id_get(const RenderData *rd, const char *viewname)
2046 {
2047   SceneRenderView *srv;
2048   size_t nr;
2049
2050   if ((!rd) || ((rd->scemode & R_MULTIVIEW) == 0)) {
2051     return 0;
2052   }
2053
2054   if ((!viewname) || (!viewname[0])) {
2055     return 0;
2056   }
2057
2058   for (srv = rd->views.first, nr = 0; srv; srv = srv->next) {
2059     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
2060       if (STREQ(viewname, srv->name)) {
2061         return nr;
2062       }
2063       else {
2064         nr += 1;
2065       }
2066     }
2067   }
2068
2069   return 0;
2070 }
2071
2072 void BKE_scene_multiview_filepath_get(SceneRenderView *srv, const char *filepath, char *r_filepath)
2073 {
2074   BLI_strncpy(r_filepath, filepath, FILE_MAX);
2075   BLI_path_suffix(r_filepath, FILE_MAX, srv->suffix, "");
2076 }
2077
2078 /**
2079  * When multiview is not used the filepath is as usual (e.g., ``Image.jpg``).
2080  * When multiview is on, even if only one view is enabled the view is incorporated
2081  * into the file name (e.g., ``Image_L.jpg``). That allows for the user to re-render
2082  * individual views.
2083  */
2084 void BKE_scene_multiview_view_filepath_get(const RenderData *rd,
2085                                            const char *filepath,
2086                                            const char *viewname,
2087                                            char *r_filepath)
2088 {
2089   SceneRenderView *srv;
2090   char suffix[FILE_MAX];
2091
2092   srv = BLI_findstring(&rd->views, viewname, offsetof(SceneRenderView, name));
2093   if (srv) {
2094     BLI_strncpy(suffix, srv->suffix, sizeof(suffix));
2095   }
2096   else {
2097     BLI_strncpy(suffix, viewname, sizeof(suffix));
2098   }
2099
2100   BLI_strncpy(r_filepath, filepath, FILE_MAX);
2101   BLI_path_suffix(r_filepath, FILE_MAX, suffix, "");
2102 }
2103
2104 const char *BKE_scene_multiview_view_suffix_get(const RenderData *rd, const char *viewname)
2105 {
2106   SceneRenderView *srv;
2107
2108   if ((viewname == NULL) || (viewname[0] == '\0')) {
2109     return viewname;
2110   }
2111
2112   srv = BLI_findstring(&rd->views, viewname, offsetof(SceneRenderView, name));
2113   if (srv) {
2114     return srv->suffix;
2115   }
2116   else {
2117     return viewname;
2118   }
2119 }
2120
2121 const char *BKE_scene_multiview_view_id_suffix_get(const RenderData *rd, const int view_id)
2122 {
2123   if ((rd->scemode & R_MULTIVIEW) == 0) {
2124     return "";
2125   }
2126   else {
2127     const char *viewname = BKE_scene_multiview_render_view_name_get(rd, view_id);
2128     return BKE_scene_multiview_view_suffix_get(rd, viewname);
2129   }
2130 }
2131
2132 void BKE_scene_multiview_view_prefix_get(Scene *scene,
2133                                          const char *name,
2134                                          char *rprefix,
2135                                          const char **rext)
2136 {
2137   SceneRenderView *srv;
2138   size_t index_act;
2139   const char *suf_act;
2140   const char delims[] = {'.', '\0'};
2141
2142   rprefix[0] = '\0';
2143
2144   /* begin of extension */
2145   index_act = BLI_str_rpartition(name, delims, rext, &suf_act);
2146   if (*rext == NULL) {
2147     return;
2148   }
2149   BLI_assert(index_act > 0);
2150   UNUSED_VARS_NDEBUG(index_act);
2151
2152   for (srv = scene->r.views.first; srv; srv = srv->next) {
2153     if (BKE_scene_multiview_is_render_view_active(&scene->r, srv)) {
2154       size_t len = strlen(srv->suffix);
2155       if (strlen(*rext) >= len && STREQLEN(*rext - len, srv->suffix, len)) {
2156         BLI_strncpy(rprefix, name, strlen(name) - strlen(*rext) - len + 1);
2157         break;
2158       }
2159     }
2160   }
2161 }
2162
2163 void BKE_scene_multiview_videos_dimensions_get(const RenderData *rd,
2164                                                const size_t width,
2165                                                const size_t height,
2166                                                size_t *r_width,
2167                                                size_t *r_height)
2168 {
2169   if ((rd->scemode & R_MULTIVIEW) && rd->im_format.views_format == R_IMF_VIEWS_STEREO_3D) {
2170     IMB_stereo3d_write_dimensions(rd->im_format.stereo3d_format.display_mode,
2171                                   (rd->im_format.stereo3d_format.flag & S3D_SQUEEZED_FRAME) != 0,
2172                                   width,
2173                                   height,
2174                                   r_width,
2175                                   r_height);
2176   }
2177   else {
2178     *r_width = width;
2179     *r_height = height;
2180   }
2181 }
2182
2183 int BKE_scene_multiview_num_videos_get(const RenderData *rd)
2184 {
2185   if (BKE_imtype_is_movie(rd->im_format.imtype) == false) {
2186     return 0;
2187   }
2188
2189   if ((rd->scemode & R_MULTIVIEW) == 0) {
2190     return 1;
2191   }
2192
2193   if (rd->im_format.views_format == R_IMF_VIEWS_STEREO_3D) {
2194     return 1;
2195   }
2196   else {
2197     /* R_IMF_VIEWS_INDIVIDUAL */
2198     return BKE_scene_multiview_num_views_get(rd);
2199   }
2200 }
2201
2202 /* Manipulation of depsgraph storage. */
2203
2204 /* This is a key which identifies depsgraph. */
2205 typedef struct DepsgraphKey {
2206   ViewLayer *view_layer;
2207   /* TODO(sergey): Need to include window somehow (same layer might be in a
2208    * different states in different windows).
2209    */
2210 } DepsgraphKey;
2211
2212 static unsigned int depsgraph_key_hash(const void *key_v)
2213 {
2214   const DepsgraphKey *key = key_v;
2215   unsigned int hash = BLI_ghashutil_ptrhash(key->view_layer);
2216   /* TODO(sergey): Include hash from other fields in the key. */
2217   return hash;
2218 }
2219
2220 static bool depsgraph_key_compare(const void *key_a_v, const void *key_b_v)
2221 {
2222   const DepsgraphKey *key_a = key_a_v;
2223   const DepsgraphKey *key_b = key_b_v;
2224   /* TODO(sergey): Compare rest of  */
2225   return !(key_a->view_layer == key_b->view_layer);
2226 }
2227
2228 static void depsgraph_key_free(void *key_v)
2229 {
2230   DepsgraphKey *key = key_v;
2231   MEM_freeN(key);
2232 }
2233
2234 static void depsgraph_key_value_free(void *value)
2235 {
2236   Depsgraph *depsgraph = value;
2237   DEG_graph_free(depsgraph);
2238 }
2239
2240 void BKE_scene_allocate_depsgraph_hash(Scene *scene)
2241 {
2242   scene->depsgraph_hash = BLI_ghash_new(
2243       depsgraph_key_hash, depsgraph_key_compare, "Scene Depsgraph Hash");
2244 }
2245
2246 void BKE_scene_ensure_depsgraph_hash(Scene *scene)
2247 {
2248   if (scene->depsgraph_hash == NULL) {
2249     BKE_scene_allocate_depsgraph_hash(scene);
2250   }
2251 }
2252
2253 void BKE_scene_free_depsgraph_hash(Scene *scene)
2254 {
2255   if (scene->depsgraph_hash == NULL) {
2256     return;
2257   }
2258   BLI_ghash_free(scene->depsgraph_hash, depsgraph_key_free, depsgraph_key_value_free);
2259   scene->depsgraph_hash = NULL;
2260 }
2261
2262 /* Query depsgraph for a specific contexts. */
2263
2264 Depsgraph *BKE_scene_get_depsgraph(Scene *scene, ViewLayer *view_layer, bool allocate)
2265 {
2266   BLI_assert(scene != NULL);
2267   BLI_assert(view_layer != NULL);
2268   /* Make sure hash itself exists. */
2269   if (allocate) {
2270     BKE_scene_ensure_depsgraph_hash(scene);
2271   }
2272   if (scene->depsgraph_hash == NULL) {
2273     return NULL;
2274   }
2275   /* Either ensure item is in the hash or simply return NULL if it's not,
2276    * depending on whether caller wants us to create depsgraph or not.
2277    */
2278   DepsgraphKey key;
2279   key.view_layer = view_layer;
2280   Depsgraph *depsgraph;
2281   if (allocate) {
2282     DepsgraphKey **key_ptr;
2283     Depsgraph **depsgraph_ptr;
2284     if (!BLI_ghash_ensure_p_ex(
2285             scene->depsgraph_hash, &key, (void ***)&key_ptr, (void ***)&depsgraph_ptr)) {
2286       *key_ptr = MEM_mallocN(sizeof(DepsgraphKey), __func__);
2287       **key_ptr = key;
2288       *depsgraph_ptr = DEG_graph_new(scene, view_layer, DAG_EVAL_VIEWPORT);
2289       /* TODO(sergey): Would be cool to avoid string format print,
2290        * but is a bit tricky because we can't know in advance  whether
2291        * we will ever enable debug messages for this depsgraph.
2292        */
2293       char name[1024];
2294       BLI_snprintf(name, sizeof(name), "%s :: %s", scene->id.name, view_layer->name);
2295       DEG_debug_name_set(*depsgraph_ptr, name);
2296     }
2297     depsgraph = *depsgraph_ptr;
2298   }
2299   else {
2300     depsgraph = BLI_ghash_lookup(scene->depsgraph_hash, &key);
2301   }
2302   return depsgraph;
2303 }
2304
2305 /* -------------------------------------------------------------------- */
2306 /** \name Scene Orientation
2307  * \{ */
2308
2309 void BKE_scene_transform_orientation_remove(Scene *scene, TransformOrientation *orientation)
2310 {
2311   const int orientation_index = BKE_scene_transform_orientation_get_index(scene, orientation);
2312
2313   for (int i = 0; i < ARRAY_SIZE(scene->orientation_slots); i++) {
2314     TransformOrientationSlot *orient_slot = &scene->orientation_slots[i];
2315     if (orient_slot->index_custom == orientation_index) {
2316       /* could also use orientation_index-- */
2317       orient_slot->type = V3D_ORIENT_GLOBAL;
2318       orient_slot->index_custom = -1;
2319     }
2320   }
2321
2322   BLI_freelinkN(&scene->transform_spaces, orientation);
2323 }
2324
2325 TransformOrientation *BKE_scene_transform_orientation_find(const Scene *scene, const int index)
2326 {
2327   return BLI_findlink(&scene->transform_spaces, index);
2328 }
2329
2330 /**
2331  * \return the index that \a orientation has within \a scene's transform-orientation list
2332  * or -1 if not found.
2333  */
2334 int BKE_scene_transform_orientation_get_index(const Scene *scene,
2335                                               const TransformOrientation *orientation)
2336 {
2337   return BLI_findindex(&scene->transform_spaces, orientation);
2338 }
2339
2340 /** \} */
2341
2342 /* -------------------------------------------------------------------- */
2343 /** \name Scene Cursor Rotation
2344  *
2345  * Matches #BKE_object_rot_to_mat3 and #BKE_object_mat3_to_rot.
2346  * \{ */
2347
2348 void BKE_scene_cursor_rot_to_mat3(const View3DCursor *cursor, float mat[3][3])
2349 {
2350   if (cursor->rotation_mode > 0) {
2351     eulO_to_mat3(mat, cursor->rotation_euler, cursor->rotation_mode);
2352   }
2353   else if (cursor->rotation_mode == ROT_MODE_AXISANGLE) {
2354     axis_angle_to_mat3(mat, cursor->rotation_axis, cursor->rotation_angle);
2355   }
2356   else {
2357     float tquat[4];
2358     normalize_qt_qt(tquat, cursor->rotation_quaternion);
2359     quat_to_mat3(mat, tquat);
2360   }
2361 }
2362
2363 void BKE_scene_cursor_rot_to_quat(const View3DCursor *cursor, float quat[4])
2364 {
2365   if (cursor->rotation_mode > 0) {
2366     eulO_to_quat(quat, cursor->rotation_euler, cursor->rotation_mode);
2367   }
2368   else if (cursor->rotation_mode == ROT_MODE_AXISANGLE) {
2369     axis_angle_to_quat(quat, cursor->rotation_axis, cursor->rotation_angle);
2370   }
2371   else {
2372     normalize_qt_qt(quat, cursor->rotation_quaternion);
2373   }
2374 }
2375
2376 void BKE_scene_cursor_mat3_to_rot(View3DCursor *cursor, const float mat[3][3], bool use_compat)
2377 {
2378   BLI_ASSERT_UNIT_M3(mat);
2379
2380   switch (cursor->rotation_mode) {
2381     case ROT_MODE_QUAT: {
2382       mat3_normalized_to_quat(cursor->rotation_quaternion, mat);
2383       break;
2384     }
2385     case ROT_MODE_AXISANGLE: {
2386       mat3_to_axis_angle(cursor->rotation_axis, &cursor->rotation_angle, mat);
2387       break;
2388     }
2389     default: {
2390       if (use_compat) {
2391         mat3_to_compatible_eulO(
2392             cursor->rotation_euler, cursor->rotation_euler, cursor->rotation_mode, mat);
2393       }
2394       else {
2395         mat3_to_eulO(cursor->rotation_euler, cursor->rotation_mode, mat);
2396       }
2397       break;
2398     }
2399   }
2400 }
2401
2402 void BKE_scene_cursor_quat_to_rot(View3DCursor *cursor, const float quat[4], bool use_compat)
2403 {
2404   BLI_ASSERT_UNIT_QUAT(quat);
2405
2406   switch (cursor->rotation_mode) {
2407     case ROT_MODE_QUAT: {
2408       copy_qt_qt(cursor->rotation_quaternion, quat);
2409       break;
2410     }
2411     case ROT_MODE_AXISANGLE: {
2412       quat_to_axis_angle(cursor->rotation_axis, &cursor->rotation_angle, quat);
2413       break;
2414     }
2415     default: {
2416       if (use_compat) {
2417         quat_to_compatible_eulO(
2418             cursor->rotation_euler, cursor->rotation_euler, cursor->rotation_mode, quat);
2419       }
2420       else {
2421         quat_to_eulO(cursor->rotation_euler, cursor->rotation_mode, quat);
2422       }
2423       break;
2424     }
2425   }
2426 }
2427
2428 void BKE_scene_cursor_to_mat4(const View3DCursor *cursor, float mat[4][4])
2429 {
2430   float mat3[3][3];
2431   BKE_scene_cursor_rot_to_mat3(cursor, mat3);
2432   copy_m4_m3(mat, mat3);
2433   copy_v3_v3(mat[3], cursor->location);
2434 }
2435
2436 void BKE_scene_cursor_from_mat4(View3DCursor *cursor, const float mat[4][4], bool use_compat)
2437 {
2438   float mat3[3][3];
2439   copy_m3_m4(mat3, mat);
2440   BKE_scene_cursor_mat3_to_rot(cursor, mat3, use_compat);
2441   copy_v3_v3(cursor->location, mat[3]);
2442 }
2443
2444 /** \} */
2445
2446 /* Dependency graph evaluation. */
2447
2448 void BKE_scene_eval_sequencer_sequences(Depsgraph *depsgraph, Scene *scene)
2449 {
2450   DEG_debug_print_eval(depsgraph, __func__, scene->id.name, scene);
2451   if (scene->ed == NULL) {
2452     return;
2453   }
2454   BKE_sound_ensure_scene(scene);
2455   Sequence *seq;
2456   SEQ_BEGIN (scene->ed, seq) {
2457     if (seq->scene_sound == NULL) {
2458       if (seq->sound != NULL) {
2459         if (seq->scene_sound == NULL) {
2460           seq->scene_sound = BKE_sound_add_scene_sound_defaults(scene, seq);
2461         }
2462       }
2463       else if (seq->type == SEQ_TYPE_SCENE) {
2464         if (seq->scene != NULL) {
2465           BKE_sound_ensure_scene(seq->scene);
2466           seq->scene_sound = BKE_sound_scene_add_scene_sound_defaults(scene, seq);
2467         }
2468       }
2469     }
2470     if (seq->scene_sound) {
2471       if (scene->id.recalc & ID_RECALC_AUDIO || seq->sound->id.recalc & ID_RECALC_AUDIO) {
2472         BKE_sound_update_scene_sound(seq->scene_sound, seq->sound);
2473       }
2474       BKE_sound_set_scene_sound_volume(
2475           seq->scene_sound, seq->volume, (seq->flag & SEQ_AUDIO_VOLUME_ANIMATED) != 0);
2476       BKE_sound_set_scene_sound_pitch(
2477           seq->scene_sound, seq->pitch, (seq->flag & SEQ_AUDIO_PITCH_ANIMATED) != 0);
2478       BKE_sound_set_scene_sound_pan(
2479           seq->scene_sound, seq->pan, (seq->flag & SEQ_AUDIO_PAN_ANIMATED) != 0);
2480     }
2481   }
2482   SEQ_END;
2483   BKE_sequencer_update_muting(scene->ed);
2484   BKE_sequencer_update_sound_bounds_all(scene);
2485 }