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