Cleanup: style, use braces for blenkernel
[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_space_types.h"
41 #include "DNA_view3d_types.h"
42 #include "DNA_windowmanager_types.h"
43 #include "DNA_workspace_types.h"
44 #include "DNA_gpencil_types.h"
45
46 #include "BLI_math.h"
47 #include "BLI_blenlib.h"
48 #include "BLI_utildefines.h"
49 #include "BLI_callbacks.h"
50 #include "BLI_string.h"
51 #include "BLI_string_utils.h"
52 #include "BLI_threads.h"
53 #include "BLI_task.h"
54
55 #include "BLT_translation.h"
56
57 #include "BKE_anim.h"
58 #include "BKE_animsys.h"
59 #include "BKE_action.h"
60 #include "BKE_armature.h"
61 #include "BKE_cachefile.h"
62 #include "BKE_collection.h"
63 #include "BKE_colortools.h"
64 #include "BKE_editmesh.h"
65 #include "BKE_fcurve.h"
66 #include "BKE_freestyle.h"
67 #include "BKE_gpencil.h"
68 #include "BKE_icons.h"
69 #include "BKE_idprop.h"
70 #include "BKE_image.h"
71 #include "BKE_layer.h"
72 #include "BKE_library.h"
73 #include "BKE_library_remap.h"
74 #include "BKE_linestyle.h"
75 #include "BKE_main.h"
76 #include "BKE_mask.h"
77 #include "BKE_node.h"
78 #include "BKE_object.h"
79 #include "BKE_paint.h"
80 #include "BKE_rigidbody.h"
81 #include "BKE_scene.h"
82 #include "BKE_screen.h"
83 #include "BKE_sequencer.h"
84 #include "BKE_sound.h"
85 #include "BKE_unit.h"
86 #include "BKE_workspace.h"
87 #include "BKE_world.h"
88
89 #include "DEG_depsgraph.h"
90 #include "DEG_depsgraph_build.h"
91 #include "DEG_depsgraph_debug.h"
92 #include "DEG_depsgraph_query.h"
93
94 #include "RE_engine.h"
95
96 #include "engines/eevee/eevee_lightcache.h"
97
98 #include "PIL_time.h"
99
100 #include "IMB_colormanagement.h"
101 #include "IMB_imbuf.h"
102
103 #include "bmesh.h"
104
105 const char *RE_engine_id_BLENDER_EEVEE = "BLENDER_EEVEE";
106 const char *RE_engine_id_BLENDER_WORKBENCH = "BLENDER_WORKBENCH";
107 const char *RE_engine_id_CYCLES = "CYCLES";
108
109 void free_avicodecdata(AviCodecData *acd)
110 {
111   if (acd) {
112     if (acd->lpFormat) {
113       MEM_freeN(acd->lpFormat);
114       acd->lpFormat = NULL;
115       acd->cbFormat = 0;
116     }
117     if (acd->lpParms) {
118       MEM_freeN(acd->lpParms);
119       acd->lpParms = NULL;
120       acd->cbParms = 0;
121     }
122   }
123 }
124
125 static void remove_sequencer_fcurves(Scene *sce)
126 {
127   AnimData *adt = BKE_animdata_from_id(&sce->id);
128
129   if (adt && adt->action) {
130     FCurve *fcu, *nextfcu;
131
132     for (fcu = adt->action->curves.first; fcu; fcu = nextfcu) {
133       nextfcu = fcu->next;
134
135       if ((fcu->rna_path) && strstr(fcu->rna_path, "sequences_all")) {
136         action_groups_remove_channel(adt->action, fcu);
137         free_fcurve(fcu);
138       }
139     }
140   }
141 }
142
143 /* flag -- copying options (see BKE_library.h's LIB_ID_COPY_... flags for more). */
144 ToolSettings *BKE_toolsettings_copy(ToolSettings *toolsettings, const int flag)
145 {
146   if (toolsettings == NULL) {
147     return NULL;
148   }
149   ToolSettings *ts = MEM_dupallocN(toolsettings);
150   if (ts->vpaint) {
151     ts->vpaint = MEM_dupallocN(ts->vpaint);
152     BKE_paint_copy(&ts->vpaint->paint, &ts->vpaint->paint, flag);
153   }
154   if (ts->wpaint) {
155     ts->wpaint = MEM_dupallocN(ts->wpaint);
156     BKE_paint_copy(&ts->wpaint->paint, &ts->wpaint->paint, flag);
157   }
158   if (ts->sculpt) {
159     ts->sculpt = MEM_dupallocN(ts->sculpt);
160     BKE_paint_copy(&ts->sculpt->paint, &ts->sculpt->paint, flag);
161   }
162   if (ts->uvsculpt) {
163     ts->uvsculpt = MEM_dupallocN(ts->uvsculpt);
164     BKE_paint_copy(&ts->uvsculpt->paint, &ts->uvsculpt->paint, flag);
165   }
166   if (ts->gp_paint) {
167     ts->gp_paint = MEM_dupallocN(ts->gp_paint);
168     BKE_paint_copy(&ts->gp_paint->paint, &ts->gp_paint->paint, flag);
169   }
170
171   BKE_paint_copy(&ts->imapaint.paint, &ts->imapaint.paint, flag);
172   ts->imapaint.paintcursor = NULL;
173   ts->particle.paintcursor = NULL;
174   ts->particle.scene = NULL;
175   ts->particle.object = NULL;
176
177   /* duplicate Grease Pencil interpolation curve */
178   ts->gp_interpolate.custom_ipo = curvemapping_copy(ts->gp_interpolate.custom_ipo);
179   /* duplicate Grease Pencil multiframe fallof */
180   ts->gp_sculpt.cur_falloff = curvemapping_copy(ts->gp_sculpt.cur_falloff);
181   ts->gp_sculpt.cur_primitive = curvemapping_copy(ts->gp_sculpt.cur_primitive);
182   return ts;
183 }
184
185 void BKE_toolsettings_free(ToolSettings *toolsettings)
186 {
187   if (toolsettings == NULL) {
188     return;
189   }
190   if (toolsettings->vpaint) {
191     BKE_paint_free(&toolsettings->vpaint->paint);
192     MEM_freeN(toolsettings->vpaint);
193   }
194   if (toolsettings->wpaint) {
195     BKE_paint_free(&toolsettings->wpaint->paint);
196     MEM_freeN(toolsettings->wpaint);
197   }
198   if (toolsettings->sculpt) {
199     BKE_paint_free(&toolsettings->sculpt->paint);
200     MEM_freeN(toolsettings->sculpt);
201   }
202   if (toolsettings->uvsculpt) {
203     BKE_paint_free(&toolsettings->uvsculpt->paint);
204     MEM_freeN(toolsettings->uvsculpt);
205   }
206   if (toolsettings->gp_paint) {
207     BKE_paint_free(&toolsettings->gp_paint->paint);
208     MEM_freeN(toolsettings->gp_paint);
209   }
210   BKE_paint_free(&toolsettings->imapaint.paint);
211
212   /* free Grease Pencil interpolation curve */
213   if (toolsettings->gp_interpolate.custom_ipo) {
214     curvemapping_free(toolsettings->gp_interpolate.custom_ipo);
215   }
216   /* free Grease Pencil multiframe falloff curve */
217   if (toolsettings->gp_sculpt.cur_falloff) {
218     curvemapping_free(toolsettings->gp_sculpt.cur_falloff);
219   }
220   if (toolsettings->gp_sculpt.cur_primitive) {
221     curvemapping_free(toolsettings->gp_sculpt.cur_primitive);
222   }
223
224   MEM_freeN(toolsettings);
225 }
226
227 /**
228  * Only copy internal data of Scene ID from source to already allocated/initialized destination.
229  * You probably never want to use that directly, use BKE_id_copy or BKE_id_copy_ex for typical needs.
230  *
231  * WARNING! This function will not handle ID user count!
232  *
233  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
234  */
235 void BKE_scene_copy_data(Main *bmain, Scene *sce_dst, const Scene *sce_src, const int flag)
236 {
237   /* We never handle usercount here for own data. */
238   const int flag_subdata = flag | LIB_ID_CREATE_NO_USER_REFCOUNT;
239
240   sce_dst->ed = NULL;
241   sce_dst->depsgraph_hash = NULL;
242   sce_dst->fps_info = NULL;
243
244   /* Master Collection */
245   if (sce_src->master_collection) {
246     sce_dst->master_collection = BKE_collection_copy_master(
247         bmain, sce_src->master_collection, flag);
248   }
249
250   /* View Layers */
251   BLI_duplicatelist(&sce_dst->view_layers, &sce_src->view_layers);
252   for (ViewLayer *view_layer_src = sce_src->view_layers.first,
253                  *view_layer_dst = sce_dst->view_layers.first;
254        view_layer_src;
255        view_layer_src = view_layer_src->next, view_layer_dst = view_layer_dst->next) {
256     BKE_view_layer_copy_data(sce_dst, sce_src, view_layer_dst, view_layer_src, flag_subdata);
257   }
258
259   BLI_duplicatelist(&(sce_dst->markers), &(sce_src->markers));
260   BLI_duplicatelist(&(sce_dst->transform_spaces), &(sce_src->transform_spaces));
261   BLI_duplicatelist(&(sce_dst->r.views), &(sce_src->r.views));
262   BKE_keyingsets_copy(&(sce_dst->keyingsets), &(sce_src->keyingsets));
263
264   if (sce_src->nodetree) {
265     /* Note: nodetree is *not* in bmain, however this specific case is handled at lower level
266      *       (see BKE_libblock_copy_ex()). */
267     BKE_id_copy_ex(bmain, (ID *)sce_src->nodetree, (ID **)&sce_dst->nodetree, flag);
268     BKE_libblock_relink_ex(bmain, sce_dst->nodetree, (void *)(&sce_src->id), &sce_dst->id, false);
269   }
270
271   if (sce_src->rigidbody_world) {
272     sce_dst->rigidbody_world = BKE_rigidbody_world_copy(sce_src->rigidbody_world, flag_subdata);
273   }
274
275   /* copy color management settings */
276   BKE_color_managed_display_settings_copy(&sce_dst->display_settings, &sce_src->display_settings);
277   BKE_color_managed_view_settings_copy(&sce_dst->view_settings, &sce_src->view_settings);
278   BKE_color_managed_colorspace_settings_copy(&sce_dst->sequencer_colorspace_settings,
279                                              &sce_src->sequencer_colorspace_settings);
280
281   BKE_color_managed_display_settings_copy(&sce_dst->r.im_format.display_settings,
282                                           &sce_src->r.im_format.display_settings);
283   BKE_color_managed_view_settings_copy(&sce_dst->r.im_format.view_settings,
284                                        &sce_src->r.im_format.view_settings);
285
286   BKE_color_managed_display_settings_copy(&sce_dst->r.bake.im_format.display_settings,
287                                           &sce_src->r.bake.im_format.display_settings);
288   BKE_color_managed_view_settings_copy(&sce_dst->r.bake.im_format.view_settings,
289                                        &sce_src->r.bake.im_format.view_settings);
290
291   curvemapping_copy_data(&sce_dst->r.mblur_shutter_curve, &sce_src->r.mblur_shutter_curve);
292
293   /* tool settings */
294   sce_dst->toolsettings = BKE_toolsettings_copy(sce_dst->toolsettings, flag_subdata);
295
296   /* make a private copy of the avicodecdata */
297   if (sce_src->r.avicodecdata) {
298     sce_dst->r.avicodecdata = MEM_dupallocN(sce_src->r.avicodecdata);
299     sce_dst->r.avicodecdata->lpFormat = MEM_dupallocN(sce_dst->r.avicodecdata->lpFormat);
300     sce_dst->r.avicodecdata->lpParms = MEM_dupallocN(sce_dst->r.avicodecdata->lpParms);
301   }
302
303   if (sce_src->r.ffcodecdata.properties) {
304     /* intentionally check sce_dst not sce_src. */ /* XXX ??? comment outdated... */
305     sce_dst->r.ffcodecdata.properties = IDP_CopyProperty_ex(sce_src->r.ffcodecdata.properties,
306                                                             flag_subdata);
307   }
308
309   /* before scene copy */
310   BKE_sound_create_scene(sce_dst);
311
312   /* Copy sequencer, this is local data! */
313   if (sce_src->ed) {
314     sce_dst->ed = MEM_callocN(sizeof(*sce_dst->ed), __func__);
315     sce_dst->ed->seqbasep = &sce_dst->ed->seqbase;
316     BKE_sequence_base_dupli_recursive(sce_src,
317                                       sce_dst,
318                                       &sce_dst->ed->seqbase,
319                                       &sce_src->ed->seqbase,
320                                       SEQ_DUPE_ALL,
321                                       flag_subdata);
322   }
323
324   if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
325     BKE_previewimg_id_copy(&sce_dst->id, &sce_src->id);
326   }
327   else {
328     sce_dst->preview = NULL;
329   }
330
331   sce_dst->eevee.light_cache = NULL;
332   sce_dst->eevee.light_cache_info[0] = '\0';
333   /* TODO Copy the cache. */
334 }
335
336 Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
337 {
338   Scene *sce_copy;
339
340   /* TODO this should/could most likely be replaced by call to more generic code at some point...
341    * But for now, let's keep it well isolated here. */
342   if (type == SCE_COPY_EMPTY) {
343     ListBase rv;
344
345     sce_copy = BKE_scene_add(bmain, sce->id.name + 2);
346
347     rv = sce_copy->r.views;
348     curvemapping_free_data(&sce_copy->r.mblur_shutter_curve);
349     sce_copy->r = sce->r;
350     sce_copy->r.views = rv;
351     sce_copy->unit = sce->unit;
352     sce_copy->physics_settings = sce->physics_settings;
353     sce_copy->audio = sce->audio;
354     sce_copy->eevee = sce->eevee;
355     sce_copy->eevee.light_cache = NULL;
356     sce_copy->eevee.light_cache_info[0] = '\0';
357
358     if (sce->id.properties) {
359       sce_copy->id.properties = IDP_CopyProperty(sce->id.properties);
360     }
361
362     MEM_freeN(sce_copy->toolsettings);
363     BKE_sound_destroy_scene(sce_copy);
364
365     /* copy color management settings */
366     BKE_color_managed_display_settings_copy(&sce_copy->display_settings, &sce->display_settings);
367     BKE_color_managed_view_settings_copy(&sce_copy->view_settings, &sce->view_settings);
368     BKE_color_managed_colorspace_settings_copy(&sce_copy->sequencer_colorspace_settings,
369                                                &sce->sequencer_colorspace_settings);
370
371     BKE_color_managed_display_settings_copy(&sce_copy->r.im_format.display_settings,
372                                             &sce->r.im_format.display_settings);
373     BKE_color_managed_view_settings_copy(&sce_copy->r.im_format.view_settings,
374                                          &sce->r.im_format.view_settings);
375
376     BKE_color_managed_display_settings_copy(&sce_copy->r.bake.im_format.display_settings,
377                                             &sce->r.bake.im_format.display_settings);
378     BKE_color_managed_view_settings_copy(&sce_copy->r.bake.im_format.view_settings,
379                                          &sce->r.bake.im_format.view_settings);
380
381     curvemapping_copy_data(&sce_copy->r.mblur_shutter_curve, &sce->r.mblur_shutter_curve);
382
383     /* viewport display settings */
384     sce_copy->display = sce->display;
385
386     /* tool settings */
387     sce_copy->toolsettings = BKE_toolsettings_copy(sce->toolsettings, 0);
388
389     /* make a private copy of the avicodecdata */
390     if (sce->r.avicodecdata) {
391       sce_copy->r.avicodecdata = MEM_dupallocN(sce->r.avicodecdata);
392       sce_copy->r.avicodecdata->lpFormat = MEM_dupallocN(sce_copy->r.avicodecdata->lpFormat);
393       sce_copy->r.avicodecdata->lpParms = MEM_dupallocN(sce_copy->r.avicodecdata->lpParms);
394     }
395
396     if (sce->r.ffcodecdata.properties) { /* intentionally check scen not sce. */
397       sce_copy->r.ffcodecdata.properties = IDP_CopyProperty(sce->r.ffcodecdata.properties);
398     }
399
400     /* before scene copy */
401     BKE_sound_create_scene(sce_copy);
402
403     /* grease pencil */
404     sce_copy->gpd = NULL;
405
406     sce_copy->preview = NULL;
407
408     return sce_copy;
409   }
410   else {
411     BKE_id_copy_ex(bmain, (ID *)sce, (ID **)&sce_copy, LIB_ID_COPY_ACTIONS);
412     id_us_min(&sce_copy->id);
413     id_us_ensure_real(&sce_copy->id);
414
415     /* Extra actions, most notably SCE_FULL_COPY also duplicates several 'children' datablocks... */
416
417     if (type == SCE_COPY_FULL) {
418       /* Copy Freestyle LineStyle datablocks. */
419       for (ViewLayer *view_layer_dst = sce_copy->view_layers.first; view_layer_dst;
420            view_layer_dst = view_layer_dst->next) {
421         for (FreestyleLineSet *lineset = view_layer_dst->freestyle_config.linesets.first; lineset;
422              lineset = lineset->next) {
423           if (lineset->linestyle) {
424             id_us_min(&lineset->linestyle->id);
425             BKE_id_copy_ex(
426                 bmain, (ID *)lineset->linestyle, (ID **)&lineset->linestyle, LIB_ID_COPY_ACTIONS);
427           }
428         }
429       }
430
431       /* Full copy of world (included animations) */
432       if (sce_copy->world) {
433         id_us_min(&sce_copy->world->id);
434         BKE_id_copy_ex(bmain, (ID *)sce_copy->world, (ID **)&sce_copy->world, LIB_ID_COPY_ACTIONS);
435       }
436
437       /* Full copy of GreasePencil. */
438       if (sce_copy->gpd) {
439         id_us_min(&sce_copy->gpd->id);
440         BKE_id_copy_ex(bmain, (ID *)sce_copy->gpd, (ID **)&sce_copy->gpd, LIB_ID_COPY_ACTIONS);
441       }
442     }
443     else {
444       /* Remove sequencer if not full copy */
445       /* XXX Why in Hell? :/ */
446       remove_sequencer_fcurves(sce_copy);
447       BKE_sequencer_editing_free(sce_copy, true);
448     }
449
450     /* NOTE: part of SCE_COPY_FULL operations
451      * are done outside of blenkernel with ED_object_single_users! */
452
453     return sce_copy;
454   }
455 }
456
457 void BKE_scene_groups_relink(Scene *sce)
458 {
459   if (sce->rigidbody_world) {
460     BKE_rigidbody_world_groups_relink(sce->rigidbody_world);
461   }
462 }
463
464 void BKE_scene_make_local(Main *bmain, Scene *sce, const bool lib_local)
465 {
466   /* For now should work, may need more work though to support all possible corner cases
467    * (also scene_copy probably needs some love). */
468   BKE_id_make_local_generic(bmain, &sce->id, true, lib_local);
469 }
470
471 /** Free (or release) any data used by this scene (does not free the scene itself). */
472 void BKE_scene_free_ex(Scene *sce, const bool do_id_user)
473 {
474   BKE_animdata_free((ID *)sce, false);
475
476   BKE_sequencer_editing_free(sce, do_id_user);
477
478   BKE_keyingsets_free(&sce->keyingsets);
479
480   /* is no lib link block, but scene extension */
481   if (sce->nodetree) {
482     ntreeFreeNestedTree(sce->nodetree);
483     MEM_freeN(sce->nodetree);
484     sce->nodetree = NULL;
485   }
486
487   if (sce->rigidbody_world) {
488     BKE_rigidbody_free_world(sce);
489   }
490
491   if (sce->r.avicodecdata) {
492     free_avicodecdata(sce->r.avicodecdata);
493     MEM_freeN(sce->r.avicodecdata);
494     sce->r.avicodecdata = NULL;
495   }
496   if (sce->r.ffcodecdata.properties) {
497     IDP_FreeProperty(sce->r.ffcodecdata.properties);
498     MEM_freeN(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 = R_OSA;
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   sce->r.osa = 8;
769
770   /* note; in header_info.c the scene copy happens..., 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_create_scene(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   /* OpenGL Render. */
906   BKE_screen_view3d_shading_init(&sce->display.shading);
907
908   /* SceneEEVEE */
909   sce->eevee.gi_diffuse_bounces = 3;
910   sce->eevee.gi_cubemap_resolution = 512;
911   sce->eevee.gi_visibility_resolution = 32;
912   sce->eevee.gi_cubemap_draw_size = 0.3f;
913   sce->eevee.gi_irradiance_draw_size = 0.1f;
914   sce->eevee.gi_irradiance_smoothing = 0.1f;
915   sce->eevee.gi_filter_quality = 1.0f;
916
917   sce->eevee.taa_samples = 16;
918   sce->eevee.taa_render_samples = 64;
919
920   sce->eevee.sss_samples = 7;
921   sce->eevee.sss_jitter_threshold = 0.3f;
922
923   sce->eevee.ssr_quality = 0.25f;
924   sce->eevee.ssr_max_roughness = 0.5f;
925   sce->eevee.ssr_thickness = 0.2f;
926   sce->eevee.ssr_border_fade = 0.075f;
927   sce->eevee.ssr_firefly_fac = 10.0f;
928
929   sce->eevee.volumetric_start = 0.1f;
930   sce->eevee.volumetric_end = 100.0f;
931   sce->eevee.volumetric_tile_size = 8;
932   sce->eevee.volumetric_samples = 64;
933   sce->eevee.volumetric_sample_distribution = 0.8f;
934   sce->eevee.volumetric_light_clamp = 0.0f;
935   sce->eevee.volumetric_shadow_samples = 16;
936
937   sce->eevee.gtao_distance = 0.2f;
938   sce->eevee.gtao_factor = 1.0f;
939   sce->eevee.gtao_quality = 0.25f;
940
941   sce->eevee.bokeh_max_size = 100.0f;
942   sce->eevee.bokeh_threshold = 1.0f;
943
944   copy_v3_fl(sce->eevee.bloom_color, 1.0f);
945   sce->eevee.bloom_threshold = 0.8f;
946   sce->eevee.bloom_knee = 0.5f;
947   sce->eevee.bloom_intensity = 0.05f;
948   sce->eevee.bloom_radius = 6.5f;
949   sce->eevee.bloom_clamp = 0.0f;
950
951   sce->eevee.motion_blur_samples = 8;
952   sce->eevee.motion_blur_shutter = 0.5f;
953
954   sce->eevee.shadow_method = SHADOW_ESM;
955   sce->eevee.shadow_cube_size = 512;
956   sce->eevee.shadow_cascade_size = 1024;
957
958   sce->eevee.light_cache = NULL;
959   sce->eevee.light_threshold = 0.01f;
960
961   sce->eevee.overscan = 3.0f;
962
963   sce->eevee.flag = SCE_EEVEE_VOLUMETRIC_LIGHTS | SCE_EEVEE_GTAO_BENT_NORMALS |
964                     SCE_EEVEE_GTAO_BOUNCE | SCE_EEVEE_TAA_REPROJECTION |
965                     SCE_EEVEE_SSR_HALF_RESOLUTION;
966 }
967
968 Scene *BKE_scene_add(Main *bmain, const char *name)
969 {
970   Scene *sce;
971
972   sce = BKE_libblock_alloc(bmain, ID_SCE, name, 0);
973   id_us_min(&sce->id);
974   id_us_ensure_real(&sce->id);
975
976   BKE_scene_init(sce);
977
978   return sce;
979 }
980
981 /**
982  * Check if there is any instance of the object in the scene
983  */
984 bool BKE_scene_object_find(Scene *scene, Object *ob)
985 {
986   for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
987        view_layer = view_layer->next) {
988     if (BLI_findptr(&view_layer->object_bases, ob, offsetof(Base, object))) {
989       return true;
990     }
991   }
992   return false;
993 }
994
995 Object *BKE_scene_object_find_by_name(Scene *scene, const char *name)
996 {
997   for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
998        view_layer = view_layer->next) {
999     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
1000       if (STREQ(base->object->id.name + 2, name)) {
1001         return base->object;
1002       }
1003     }
1004   }
1005   return NULL;
1006 }
1007
1008 /**
1009  * Sets the active scene, mainly used when running in background mode (``--scene`` command line argument).
1010  * This is also called to set the scene directly, bypassing windowing code.
1011  * Otherwise #WM_window_set_active_scene is used when changing scenes by the user.
1012  */
1013 void BKE_scene_set_background(Main *bmain, Scene *scene)
1014 {
1015   Object *ob;
1016
1017   /* check for cyclic sets, for reading old files but also for definite security (py?) */
1018   BKE_scene_validate_setscene(bmain, scene);
1019
1020   /* deselect objects (for dataselect) */
1021   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1022     ob->flag &= ~SELECT;
1023   }
1024
1025   /* copy layers and flags from bases to objects */
1026   for (ViewLayer *view_layer = scene->view_layers.first; view_layer;
1027        view_layer = view_layer->next) {
1028     for (Base *base = view_layer->object_bases.first; base; base = base->next) {
1029       ob = base->object;
1030       /* collection patch... */
1031       BKE_scene_object_base_flag_sync_from_base(base);
1032     }
1033   }
1034   /* no full animation update, this to enable render code to work (render code calls own animation updates) */
1035 }
1036
1037 /* called from creator_args.c */
1038 Scene *BKE_scene_set_name(Main *bmain, const char *name)
1039 {
1040   Scene *sce = (Scene *)BKE_libblock_find_name(bmain, ID_SCE, name);
1041   if (sce) {
1042     BKE_scene_set_background(bmain, sce);
1043     printf("Scene switch for render: '%s' in file: '%s'\n", name, BKE_main_blendfile_path(bmain));
1044     return sce;
1045   }
1046
1047   printf("Can't find scene: '%s' in file: '%s'\n", name, BKE_main_blendfile_path(bmain));
1048   return NULL;
1049 }
1050
1051 /* Used by metaballs, return *all* objects (including duplis) existing in the scene (including scene's sets) */
1052 int BKE_scene_base_iter_next(
1053     Depsgraph *depsgraph, SceneBaseIter *iter, Scene **scene, int val, Base **base, Object **ob)
1054 {
1055   bool run_again = true;
1056
1057   /* init */
1058   if (val == 0) {
1059     iter->phase = F_START;
1060     iter->dupob = NULL;
1061     iter->duplilist = NULL;
1062     iter->dupli_refob = NULL;
1063   }
1064   else {
1065     /* run_again is set when a duplilist has been ended */
1066     while (run_again) {
1067       run_again = false;
1068
1069       /* the first base */
1070       if (iter->phase == F_START) {
1071         ViewLayer *view_layer = (depsgraph) ? DEG_get_evaluated_view_layer(depsgraph) :
1072                                               BKE_view_layer_context_active_PLACEHOLDER(*scene);
1073         *base = view_layer->object_bases.first;
1074         if (*base) {
1075           *ob = (*base)->object;
1076           iter->phase = F_SCENE;
1077         }
1078         else {
1079           /* exception: empty scene layer */
1080           while ((*scene)->set) {
1081             (*scene) = (*scene)->set;
1082             ViewLayer *view_layer_set = BKE_view_layer_default_render((*scene));
1083             if (view_layer_set->object_bases.first) {
1084               *base = view_layer_set->object_bases.first;
1085               *ob = (*base)->object;
1086               iter->phase = F_SCENE;
1087               break;
1088             }
1089           }
1090         }
1091       }
1092       else {
1093         if (*base && iter->phase != F_DUPLI) {
1094           *base = (*base)->next;
1095           if (*base) {
1096             *ob = (*base)->object;
1097           }
1098           else {
1099             if (iter->phase == F_SCENE) {
1100               /* (*scene) is finished, now do the set */
1101               while ((*scene)->set) {
1102                 (*scene) = (*scene)->set;
1103                 ViewLayer *view_layer_set = BKE_view_layer_default_render((*scene));
1104                 if (view_layer_set->object_bases.first) {
1105                   *base = view_layer_set->object_bases.first;
1106                   *ob = (*base)->object;
1107                   break;
1108                 }
1109               }
1110             }
1111           }
1112         }
1113       }
1114
1115       if (*base == NULL) {
1116         iter->phase = F_START;
1117       }
1118       else {
1119         if (iter->phase != F_DUPLI) {
1120           if (depsgraph && (*base)->object->transflag & OB_DUPLI) {
1121             /* collections cannot be duplicated for metaballs yet,
1122              * this enters eternal loop because of
1123              * makeDispListMBall getting called inside of collection_duplilist */
1124             if ((*base)->object->instance_collection == NULL) {
1125               iter->duplilist = object_duplilist(depsgraph, (*scene), (*base)->object);
1126
1127               iter->dupob = iter->duplilist->first;
1128
1129               if (!iter->dupob) {
1130                 free_object_duplilist(iter->duplilist);
1131                 iter->duplilist = NULL;
1132               }
1133               iter->dupli_refob = NULL;
1134             }
1135           }
1136         }
1137         /* handle dupli's */
1138         if (iter->dupob) {
1139           (*base)->flag_legacy |= OB_FROMDUPLI;
1140           *ob = iter->dupob->ob;
1141           iter->phase = F_DUPLI;
1142
1143           if (iter->dupli_refob != *ob) {
1144             if (iter->dupli_refob) {
1145               /* Restore previous object's real matrix. */
1146               copy_m4_m4(iter->dupli_refob->obmat, iter->omat);
1147             }
1148             /* Backup new object's real matrix. */
1149             iter->dupli_refob = *ob;
1150             copy_m4_m4(iter->omat, iter->dupli_refob->obmat);
1151           }
1152           copy_m4_m4((*ob)->obmat, iter->dupob->mat);
1153
1154           iter->dupob = iter->dupob->next;
1155         }
1156         else if (iter->phase == F_DUPLI) {
1157           iter->phase = F_SCENE;
1158           (*base)->flag_legacy &= ~OB_FROMDUPLI;
1159
1160           if (iter->dupli_refob) {
1161             /* Restore last object's real matrix. */
1162             copy_m4_m4(iter->dupli_refob->obmat, iter->omat);
1163             iter->dupli_refob = NULL;
1164           }
1165
1166           free_object_duplilist(iter->duplilist);
1167           iter->duplilist = NULL;
1168           run_again = true;
1169         }
1170       }
1171     }
1172   }
1173
1174   return iter->phase;
1175 }
1176
1177 Scene *BKE_scene_find_from_collection(const Main *bmain, const Collection *collection)
1178 {
1179   for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1180     for (ViewLayer *layer = scene->view_layers.first; layer; layer = layer->next) {
1181       if (BKE_view_layer_has_collection(layer, collection)) {
1182         return scene;
1183       }
1184     }
1185   }
1186
1187   return NULL;
1188 }
1189
1190 #ifdef DURIAN_CAMERA_SWITCH
1191 Object *BKE_scene_camera_switch_find(Scene *scene)
1192 {
1193   if (scene->r.mode & R_NO_CAMERA_SWITCH) {
1194     return NULL;
1195   }
1196
1197   TimeMarker *m;
1198   int cfra = scene->r.cfra;
1199   int frame = -(MAXFRAME + 1);
1200   int min_frame = MAXFRAME + 1;
1201   Object *camera = NULL;
1202   Object *first_camera = NULL;
1203
1204   for (m = scene->markers.first; m; m = m->next) {
1205     if (m->camera && (m->camera->restrictflag & OB_RESTRICT_RENDER) == 0) {
1206       if ((m->frame <= cfra) && (m->frame > frame)) {
1207         camera = m->camera;
1208         frame = m->frame;
1209
1210         if (frame == cfra) {
1211           break;
1212         }
1213       }
1214
1215       if (m->frame < min_frame) {
1216         first_camera = m->camera;
1217         min_frame = m->frame;
1218       }
1219     }
1220   }
1221
1222   if (camera == NULL) {
1223     /* If there's no marker to the left of current frame,
1224      * use camera from left-most marker to solve all sort
1225      * of Schrodinger uncertainties.
1226      */
1227     return first_camera;
1228   }
1229
1230   return camera;
1231 }
1232 #endif
1233
1234 int BKE_scene_camera_switch_update(Scene *scene)
1235 {
1236 #ifdef DURIAN_CAMERA_SWITCH
1237   Object *camera = BKE_scene_camera_switch_find(scene);
1238   if (camera) {
1239     scene->camera = camera;
1240     DEG_id_tag_update(&scene->id, ID_RECALC_COPY_ON_WRITE);
1241     return 1;
1242   }
1243 #else
1244   (void)scene;
1245 #endif
1246   return 0;
1247 }
1248
1249 char *BKE_scene_find_marker_name(Scene *scene, int frame)
1250 {
1251   ListBase *markers = &scene->markers;
1252   TimeMarker *m1, *m2;
1253
1254   /* search through markers for match */
1255   for (m1 = markers->first, m2 = markers->last; m1 && m2; m1 = m1->next, m2 = m2->prev) {
1256     if (m1->frame == frame) {
1257       return m1->name;
1258     }
1259
1260     if (m1 == m2) {
1261       break;
1262     }
1263
1264     if (m2->frame == frame) {
1265       return m2->name;
1266     }
1267   }
1268
1269   return NULL;
1270 }
1271
1272 /* return the current marker for this frame,
1273  * we can have more than 1 marker per frame, this just returns the first :/ */
1274 char *BKE_scene_find_last_marker_name(Scene *scene, int frame)
1275 {
1276   TimeMarker *marker, *best_marker = NULL;
1277   int best_frame = -MAXFRAME * 2;
1278   for (marker = scene->markers.first; marker; marker = marker->next) {
1279     if (marker->frame == frame) {
1280       return marker->name;
1281     }
1282
1283     if (marker->frame > best_frame && marker->frame < frame) {
1284       best_marker = marker;
1285       best_frame = marker->frame;
1286     }
1287   }
1288
1289   return best_marker ? best_marker->name : NULL;
1290 }
1291
1292 int BKE_scene_frame_snap_by_seconds(Scene *scene, double interval_in_seconds, int cfra)
1293 {
1294   const int fps = round_db_to_int(FPS * interval_in_seconds);
1295   const int second_prev = cfra - mod_i(cfra, fps);
1296   const int second_next = second_prev + fps;
1297   const int delta_prev = cfra - second_prev;
1298   const int delta_next = second_next - cfra;
1299   return (delta_prev < delta_next) ? second_prev : second_next;
1300 }
1301
1302 void BKE_scene_remove_rigidbody_object(struct Main *bmain, Scene *scene, Object *ob)
1303 {
1304   /* remove rigid body constraint from world before removing object */
1305   if (ob->rigidbody_constraint) {
1306     BKE_rigidbody_remove_constraint(scene, ob);
1307   }
1308   /* remove rigid body object from world before removing object */
1309   if (ob->rigidbody_object) {
1310     BKE_rigidbody_remove_object(bmain, scene, ob);
1311   }
1312 }
1313
1314 /* checks for cycle, returns 1 if it's all OK */
1315 bool BKE_scene_validate_setscene(Main *bmain, Scene *sce)
1316 {
1317   Scene *sce_iter;
1318   int a, totscene;
1319
1320   if (sce->set == NULL) {
1321     return true;
1322   }
1323   totscene = BLI_listbase_count(&bmain->scenes);
1324
1325   for (a = 0, sce_iter = sce; sce_iter->set; sce_iter = sce_iter->set, a++) {
1326     /* more iterations than scenes means we have a cycle */
1327     if (a > totscene) {
1328       /* the tested scene gets zero'ed, that's typically current scene */
1329       sce->set = NULL;
1330       return false;
1331     }
1332   }
1333
1334   return true;
1335 }
1336
1337 /* This function is needed to cope with fractional frames - including two Blender rendering features
1338  * mblur (motion blur that renders 'subframes' and blurs them together), and fields rendering.
1339  */
1340 float BKE_scene_frame_get(const Scene *scene)
1341 {
1342   return BKE_scene_frame_get_from_ctime(scene, scene->r.cfra);
1343 }
1344
1345 /* This function is used to obtain arbitrary fractional frames */
1346 float BKE_scene_frame_get_from_ctime(const Scene *scene, const float frame)
1347 {
1348   float ctime = frame;
1349   ctime += scene->r.subframe;
1350   ctime *= scene->r.framelen;
1351
1352   return ctime;
1353 }
1354 /**
1355  * Sets the frame int/float components.
1356  */
1357 void BKE_scene_frame_set(struct Scene *scene, double cfra)
1358 {
1359   double intpart;
1360   scene->r.subframe = modf(cfra, &intpart);
1361   scene->r.cfra = (int)intpart;
1362 }
1363
1364 /* -------------------------------------------------------------------- */
1365 /** \name Scene Orientation Slots
1366  * \{ */
1367
1368 TransformOrientationSlot *BKE_scene_orientation_slot_get(Scene *scene, int slot_index)
1369 {
1370   if ((scene->orientation_slots[slot_index].flag & SELECT) == 0) {
1371     slot_index = SCE_ORIENT_DEFAULT;
1372   }
1373   return &scene->orientation_slots[slot_index];
1374 }
1375
1376 TransformOrientationSlot *BKE_scene_orientation_slot_get_from_flag(Scene *scene, int flag)
1377 {
1378   BLI_assert(flag && !(flag & ~(V3D_GIZMO_SHOW_OBJECT_TRANSLATE | V3D_GIZMO_SHOW_OBJECT_ROTATE |
1379                                 V3D_GIZMO_SHOW_OBJECT_SCALE)));
1380   int slot_index = SCE_ORIENT_DEFAULT;
1381   if (flag & V3D_GIZMO_SHOW_OBJECT_TRANSLATE) {
1382     slot_index = SCE_ORIENT_TRANSLATE;
1383   }
1384   else if (flag & V3D_GIZMO_SHOW_OBJECT_ROTATE) {
1385     slot_index = SCE_ORIENT_ROTATE;
1386   }
1387   else if (flag & V3D_GIZMO_SHOW_OBJECT_SCALE) {
1388     slot_index = SCE_ORIENT_SCALE;
1389   }
1390   return BKE_scene_orientation_slot_get(scene, slot_index);
1391 }
1392
1393 /**
1394  * Activate a transform orientation in a 3D view based on an enum value.
1395  *
1396  * \param orientation: If this is #V3D_ORIENT_CUSTOM or greater, the custom transform orientation
1397  * with index \a orientation - #V3D_ORIENT_CUSTOM gets activated.
1398  */
1399 void BKE_scene_orientation_slot_set_index(TransformOrientationSlot *orient_slot, int orientation)
1400 {
1401   const bool is_custom = orientation >= V3D_ORIENT_CUSTOM;
1402   orient_slot->type = is_custom ? V3D_ORIENT_CUSTOM : orientation;
1403   orient_slot->index_custom = is_custom ? (orientation - V3D_ORIENT_CUSTOM) : -1;
1404 }
1405
1406 int BKE_scene_orientation_slot_get_index(const TransformOrientationSlot *orient_slot)
1407 {
1408   return (orient_slot->type == V3D_ORIENT_CUSTOM) ?
1409              (orient_slot->type + orient_slot->index_custom) :
1410              orient_slot->type;
1411 }
1412
1413 /** \} */
1414
1415 /* That's like really a bummer, because currently animation data for armatures
1416  * might want to use pose, and pose might be missing on the object.
1417  * This happens when changing visible layers, which leads to situations when
1418  * pose is missing or marked for recalc, animation will change it and then
1419  * object update will restore the pose.
1420  *
1421  * This could be solved by the new dependency graph, but for until then we'll
1422  * do an extra pass on the objects to ensure it's all fine.
1423  */
1424 #define POSE_ANIMATION_WORKAROUND
1425
1426 #ifdef POSE_ANIMATION_WORKAROUND
1427 static void scene_armature_depsgraph_workaround(Main *bmain, Depsgraph *depsgraph)
1428 {
1429   Object *ob;
1430   if (BLI_listbase_is_empty(&bmain->armatures) || !DEG_id_type_updated(depsgraph, ID_OB)) {
1431     return;
1432   }
1433   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1434     if (ob->type == OB_ARMATURE && ob->adt) {
1435       if (ob->pose == NULL || (ob->pose->flag & POSE_RECALC)) {
1436         BKE_pose_rebuild(bmain, ob, ob->data, true);
1437       }
1438     }
1439   }
1440 }
1441 #endif
1442
1443 static bool check_rendered_viewport_visible(Main *bmain)
1444 {
1445   wmWindowManager *wm = bmain->wm.first;
1446   wmWindow *window;
1447   for (window = wm->windows.first; window != NULL; window = window->next) {
1448     const bScreen *screen = BKE_workspace_active_screen_get(window->workspace_hook);
1449     Scene *scene = window->scene;
1450     RenderEngineType *type = RE_engines_find(scene->r.engine);
1451
1452     if (type->draw_engine || !type->render) {
1453       continue;
1454     }
1455
1456     for (ScrArea *area = screen->areabase.first; area != NULL; area = area->next) {
1457       View3D *v3d = area->spacedata.first;
1458       if (area->spacetype != SPACE_VIEW3D) {
1459         continue;
1460       }
1461       if (v3d->shading.type == OB_RENDER) {
1462         return true;
1463       }
1464     }
1465   }
1466   return false;
1467 }
1468
1469 /* TODO(campbell): shouldn't we be able to use 'DEG_get_view_layer' here?
1470  * Currently this is NULL on load, so don't. */
1471 static void prepare_mesh_for_viewport_render(Main *bmain, const ViewLayer *view_layer)
1472 {
1473   /* This is needed to prepare mesh to be used by the render
1474    * engine from the viewport rendering. We do loading here
1475    * so all the objects which shares the same mesh datablock
1476    * are nicely tagged for update and updated.
1477    *
1478    * This makes it so viewport render engine doesn't need to
1479    * call loading of the edit data for the mesh objects.
1480    */
1481
1482   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
1483   if (obedit) {
1484     Mesh *mesh = obedit->data;
1485     if ((obedit->type == OB_MESH) &&
1486         ((obedit->id.recalc & ID_RECALC_ALL) || (mesh->id.recalc & ID_RECALC_ALL))) {
1487       if (check_rendered_viewport_visible(bmain)) {
1488         BMesh *bm = mesh->edit_mesh->bm;
1489         BM_mesh_bm_to_me(bmain,
1490                          bm,
1491                          mesh,
1492                          (&(struct BMeshToMeshParams){
1493                              .calc_object_remap = true,
1494                          }));
1495         DEG_id_tag_update(&mesh->id, 0);
1496       }
1497     }
1498   }
1499 }
1500
1501 /* TODO(sergey): This actually should become view_layer_graph or so.
1502  * Same applies to update_for_newframe.
1503  */
1504 void BKE_scene_graph_update_tagged(Depsgraph *depsgraph, Main *bmain)
1505 {
1506   Scene *scene = DEG_get_input_scene(depsgraph);
1507   ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
1508
1509   bool run_callbacks = DEG_id_type_any_updated(depsgraph);
1510   if (run_callbacks) {
1511     BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_DEPSGRAPH_UPDATE_PRE);
1512   }
1513
1514   /* TODO(sergey): Some functions here are changing global state,
1515    * for example, clearing update tags from bmain.
1516    */
1517   /* (Re-)build dependency graph if needed. */
1518   DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
1519   /* Uncomment this to check if graph was properly tagged for update. */
1520   // DEG_debug_graph_relations_validate(depsgraph, bmain, scene);
1521   /* Flush editing data if needed. */
1522   prepare_mesh_for_viewport_render(bmain, view_layer);
1523   /* Flush recalc flags to dependencies. */
1524   DEG_graph_flush_update(bmain, depsgraph);
1525   /* Update all objects: drivers, matrices, displists, etc. flags set
1526    * by depgraph or manual, no layer check here, gets correct flushed.
1527    */
1528   DEG_evaluate_on_refresh(depsgraph);
1529   /* Update sound system animation (TODO, move to depsgraph). */
1530   BKE_sound_update_scene(bmain, scene);
1531
1532   /* Notify python about depsgraph update */
1533   if (run_callbacks) {
1534     BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_DEPSGRAPH_UPDATE_POST);
1535   }
1536   /* Inform editors about possible changes. */
1537   DEG_ids_check_recalc(bmain, depsgraph, scene, view_layer, false);
1538   /* Clear recalc flags. */
1539   DEG_ids_clear_recalc(bmain, depsgraph);
1540 }
1541
1542 /* applies changes right away, does all sets too */
1543 void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph, Main *bmain)
1544 {
1545   Scene *scene = DEG_get_input_scene(depsgraph);
1546   ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
1547
1548   /* TODO(sergey): Some functions here are changing global state,
1549    * for example, clearing update tags from bmain.
1550    */
1551   const float ctime = BKE_scene_frame_get(scene);
1552   /* Keep this first. */
1553   BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_FRAME_CHANGE_PRE);
1554   /* Update animated image textures for particles, modifiers, gpu, etc,
1555    * call this at the start so modifiers with textures don't lag 1 frame.
1556    */
1557   BKE_image_editors_update_frame(bmain, scene->r.cfra);
1558   BKE_sound_set_cfra(scene->r.cfra);
1559   DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
1560   /* Update animated cache files for modifiers.
1561    *
1562    * TODO(sergey): Make this a depsgraph node?
1563    */
1564   BKE_cachefile_update_frame(bmain,
1565                              depsgraph,
1566                              scene,
1567                              ctime,
1568                              (((double)scene->r.frs_sec) / (double)scene->r.frs_sec_base));
1569 #ifdef POSE_ANIMATION_WORKAROUND
1570   scene_armature_depsgraph_workaround(bmain, depsgraph);
1571 #endif
1572   /* Update all objects: drivers, matrices, displists, etc. flags set
1573    * by depgraph or manual, no layer check here, gets correct flushed.
1574    */
1575   DEG_evaluate_on_framechange(bmain, depsgraph, ctime);
1576   /* Update sound system animation (TODO, move to depsgraph). */
1577   BKE_sound_update_scene(bmain, scene);
1578   /* Notify editors and python about recalc. */
1579   BLI_callback_exec(bmain, &scene->id, BLI_CB_EVT_FRAME_CHANGE_POST);
1580   /* Inform editors about possible changes. */
1581   DEG_ids_check_recalc(bmain, depsgraph, scene, view_layer, true);
1582   /* clear recalc flags */
1583   DEG_ids_clear_recalc(bmain, depsgraph);
1584 }
1585
1586 /** Ensures given scene/view_layer pair has a valid, up-to-date depsgraph.
1587  *
1588  * \warning Sets matching depsgraph as active, so should only be called from the active editing context
1589  *          (usually, from operators).
1590  */
1591 void BKE_scene_view_layer_graph_evaluated_ensure(Main *bmain, Scene *scene, ViewLayer *view_layer)
1592 {
1593   Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
1594   DEG_make_active(depsgraph);
1595   BKE_scene_graph_update_tagged(depsgraph, bmain);
1596 }
1597
1598 /* return default view */
1599 SceneRenderView *BKE_scene_add_render_view(Scene *sce, const char *name)
1600 {
1601   SceneRenderView *srv;
1602
1603   if (!name) {
1604     name = DATA_("RenderView");
1605   }
1606
1607   srv = MEM_callocN(sizeof(SceneRenderView), "new render view");
1608   BLI_strncpy(srv->name, name, sizeof(srv->name));
1609   BLI_uniquename(&sce->r.views,
1610                  srv,
1611                  DATA_("RenderView"),
1612                  '.',
1613                  offsetof(SceneRenderView, name),
1614                  sizeof(srv->name));
1615   BLI_addtail(&sce->r.views, srv);
1616
1617   return srv;
1618 }
1619
1620 bool BKE_scene_remove_render_view(Scene *scene, SceneRenderView *srv)
1621 {
1622   const int act = BLI_findindex(&scene->r.views, srv);
1623
1624   if (act == -1) {
1625     return false;
1626   }
1627   else if (scene->r.views.first == scene->r.views.last) {
1628     /* ensure 1 view is kept */
1629     return false;
1630   }
1631
1632   BLI_remlink(&scene->r.views, srv);
1633   MEM_freeN(srv);
1634
1635   scene->r.actview = 0;
1636
1637   return true;
1638 }
1639
1640 /* render simplification */
1641
1642 int get_render_subsurf_level(const RenderData *r, int lvl, bool for_render)
1643 {
1644   if (r->mode & R_SIMPLIFY) {
1645     if (for_render) {
1646       return min_ii(r->simplify_subsurf_render, lvl);
1647     }
1648     else {
1649       return min_ii(r->simplify_subsurf, lvl);
1650     }
1651   }
1652   else {
1653     return lvl;
1654   }
1655 }
1656
1657 int get_render_child_particle_number(const RenderData *r, int num, bool for_render)
1658 {
1659   if (r->mode & R_SIMPLIFY) {
1660     if (for_render) {
1661       return (int)(r->simplify_particles_render * num);
1662     }
1663     else {
1664       return (int)(r->simplify_particles * num);
1665     }
1666   }
1667   else {
1668     return num;
1669   }
1670 }
1671
1672 /**
1673  * Helper function for the SETLOOPER and SETLOOPER_VIEW_LAYER macros
1674  *
1675  * It iterates over the bases of the active layer and then the bases
1676  * of the active layer of the background (set) scenes recursively.
1677  */
1678 Base *_setlooper_base_step(Scene **sce_iter, ViewLayer *view_layer, Base *base)
1679 {
1680   if (base && base->next) {
1681     /* Common case, step to the next. */
1682     return base->next;
1683   }
1684   else if ((base == NULL) && (view_layer != NULL)) {
1685     /* First time looping, return the scenes first base. */
1686     /* For the first loop we should get the layer from workspace when available. */
1687     if (view_layer->object_bases.first) {
1688       return (Base *)view_layer->object_bases.first;
1689     }
1690     /* No base on this scene layer. */
1691     goto next_set;
1692   }
1693   else {
1694   next_set:
1695     /* Reached the end, get the next base in the set. */
1696     while ((*sce_iter = (*sce_iter)->set)) {
1697       ViewLayer *view_layer_set = BKE_view_layer_default_render((*sce_iter));
1698       base = (Base *)view_layer_set->object_bases.first;
1699
1700       if (base) {
1701         return base;
1702       }
1703     }
1704   }
1705
1706   return NULL;
1707 }
1708
1709 bool BKE_scene_use_shading_nodes_custom(Scene *scene)
1710 {
1711   RenderEngineType *type = RE_engines_find(scene->r.engine);
1712   return (type && type->flag & RE_USE_SHADING_NODES_CUSTOM);
1713 }
1714
1715 bool BKE_scene_use_spherical_stereo(Scene *scene)
1716 {
1717   RenderEngineType *type = RE_engines_find(scene->r.engine);
1718   return (type && type->flag & RE_USE_SPHERICAL_STEREO);
1719 }
1720
1721 bool BKE_scene_uses_blender_eevee(const Scene *scene)
1722 {
1723   return STREQ(scene->r.engine, RE_engine_id_BLENDER_EEVEE);
1724 }
1725
1726 bool BKE_scene_uses_blender_workbench(const Scene *scene)
1727 {
1728   return STREQ(scene->r.engine, RE_engine_id_BLENDER_WORKBENCH);
1729 }
1730
1731 bool BKE_scene_uses_cycles(const Scene *scene)
1732 {
1733   return STREQ(scene->r.engine, RE_engine_id_CYCLES);
1734 }
1735
1736 void BKE_scene_base_flag_to_objects(ViewLayer *view_layer)
1737 {
1738   Base *base = view_layer->object_bases.first;
1739
1740   while (base) {
1741     BKE_scene_object_base_flag_sync_from_base(base);
1742     base = base->next;
1743   }
1744 }
1745
1746 void BKE_scene_object_base_flag_sync_from_base(Base *base)
1747 {
1748   Object *ob = base->object;
1749
1750   ob->flag = base->flag;
1751
1752   if ((base->flag & BASE_SELECTED) != 0) {
1753     ob->flag |= SELECT;
1754   }
1755   else {
1756     ob->flag &= ~SELECT;
1757   }
1758 }
1759
1760 void BKE_scene_object_base_flag_sync_from_object(Base *base)
1761 {
1762   Object *ob = base->object;
1763   base->flag = ob->flag;
1764
1765   if ((ob->flag & SELECT) != 0 && (base->flag & BASE_SELECTABLE) != 0) {
1766     base->flag |= BASE_SELECTED;
1767   }
1768   else {
1769     base->flag &= ~BASE_SELECTED;
1770   }
1771 }
1772
1773 void BKE_scene_disable_color_management(Scene *scene)
1774 {
1775   ColorManagedDisplaySettings *display_settings = &scene->display_settings;
1776   ColorManagedViewSettings *view_settings = &scene->view_settings;
1777   const char *view;
1778   const char *none_display_name;
1779
1780   none_display_name = IMB_colormanagement_display_get_none_name();
1781
1782   BLI_strncpy(display_settings->display_device,
1783               none_display_name,
1784               sizeof(display_settings->display_device));
1785
1786   view = IMB_colormanagement_view_get_default_name(display_settings->display_device);
1787
1788   if (view) {
1789     BLI_strncpy(view_settings->view_transform, view, sizeof(view_settings->view_transform));
1790   }
1791 }
1792
1793 bool BKE_scene_check_color_management_enabled(const Scene *scene)
1794 {
1795   return !STREQ(scene->display_settings.display_device, "None");
1796 }
1797
1798 bool BKE_scene_check_rigidbody_active(const Scene *scene)
1799 {
1800   return scene && scene->rigidbody_world && scene->rigidbody_world->group &&
1801          !(scene->rigidbody_world->flag & RBW_FLAG_MUTED);
1802 }
1803
1804 int BKE_render_num_threads(const RenderData *rd)
1805 {
1806   int threads;
1807
1808   /* override set from command line? */
1809   threads = BLI_system_num_threads_override_get();
1810
1811   if (threads > 0) {
1812     return threads;
1813   }
1814
1815   /* fixed number of threads specified in scene? */
1816   if (rd->mode & R_FIXED_THREADS) {
1817     threads = rd->threads;
1818   }
1819   else {
1820     threads = BLI_system_thread_count();
1821   }
1822
1823   return max_ii(threads, 1);
1824 }
1825
1826 int BKE_scene_num_threads(const Scene *scene)
1827 {
1828   return BKE_render_num_threads(&scene->r);
1829 }
1830
1831 int BKE_render_preview_pixel_size(const RenderData *r)
1832 {
1833   if (r->preview_pixel_size == 0) {
1834     return (U.pixelsize > 1.5f) ? 2 : 1;
1835   }
1836   return r->preview_pixel_size;
1837 }
1838
1839 /* Apply the needed correction factor to value, based on unit_type (only length-related are affected currently)
1840  * and unit->scale_length.
1841  */
1842 double BKE_scene_unit_scale(const UnitSettings *unit, const int unit_type, double value)
1843 {
1844   if (unit->system == USER_UNIT_NONE) {
1845     /* Never apply scale_length when not using a unit setting! */
1846     return value;
1847   }
1848
1849   switch (unit_type) {
1850     case B_UNIT_LENGTH:
1851       return value * (double)unit->scale_length;
1852     case B_UNIT_AREA:
1853     case B_UNIT_POWER:
1854       return value * pow(unit->scale_length, 2);
1855     case B_UNIT_VOLUME:
1856       return value * pow(unit->scale_length, 3);
1857     case B_UNIT_MASS:
1858       return value * pow(unit->scale_length, 3);
1859     case B_UNIT_CAMERA: /* *Do not* use scene's unit scale for camera focal lens! See T42026. */
1860     default:
1861       return value;
1862   }
1863 }
1864
1865 /******************** multiview *************************/
1866
1867 int BKE_scene_multiview_num_views_get(const RenderData *rd)
1868 {
1869   SceneRenderView *srv;
1870   int totviews = 0;
1871
1872   if ((rd->scemode & R_MULTIVIEW) == 0) {
1873     return 1;
1874   }
1875
1876   if (rd->views_format == SCE_VIEWS_FORMAT_STEREO_3D) {
1877     srv = BLI_findstring(&rd->views, STEREO_LEFT_NAME, offsetof(SceneRenderView, name));
1878     if ((srv && srv->viewflag & SCE_VIEW_DISABLE) == 0) {
1879       totviews++;
1880     }
1881
1882     srv = BLI_findstring(&rd->views, STEREO_RIGHT_NAME, offsetof(SceneRenderView, name));
1883     if ((srv && srv->viewflag & SCE_VIEW_DISABLE) == 0) {
1884       totviews++;
1885     }
1886   }
1887   else {
1888     for (srv = rd->views.first; srv; srv = srv->next) {
1889       if ((srv->viewflag & SCE_VIEW_DISABLE) == 0) {
1890         totviews++;
1891       }
1892     }
1893   }
1894   return totviews;
1895 }
1896
1897 bool BKE_scene_multiview_is_stereo3d(const RenderData *rd)
1898 {
1899   SceneRenderView *srv[2];
1900
1901   if ((rd->scemode & R_MULTIVIEW) == 0) {
1902     return false;
1903   }
1904
1905   srv[0] = (SceneRenderView *)BLI_findstring(
1906       &rd->views, STEREO_LEFT_NAME, offsetof(SceneRenderView, name));
1907   srv[1] = (SceneRenderView *)BLI_findstring(
1908       &rd->views, STEREO_RIGHT_NAME, offsetof(SceneRenderView, name));
1909
1910   return (srv[0] && ((srv[0]->viewflag & SCE_VIEW_DISABLE) == 0) && srv[1] &&
1911           ((srv[1]->viewflag & SCE_VIEW_DISABLE) == 0));
1912 }
1913
1914 /* return whether to render this SceneRenderView */
1915 bool BKE_scene_multiview_is_render_view_active(const RenderData *rd, const SceneRenderView *srv)
1916 {
1917   if (srv == NULL) {
1918     return false;
1919   }
1920
1921   if ((rd->scemode & R_MULTIVIEW) == 0) {
1922     return false;
1923   }
1924
1925   if ((srv->viewflag & SCE_VIEW_DISABLE)) {
1926     return false;
1927   }
1928
1929   if (rd->views_format == SCE_VIEWS_FORMAT_MULTIVIEW) {
1930     return true;
1931   }
1932
1933   /* SCE_VIEWS_SETUP_BASIC */
1934   if (STREQ(srv->name, STEREO_LEFT_NAME) || STREQ(srv->name, STEREO_RIGHT_NAME)) {
1935     return true;
1936   }
1937
1938   return false;
1939 }
1940
1941 /* return true if viewname is the first or if the name is NULL or not found */
1942 bool BKE_scene_multiview_is_render_view_first(const RenderData *rd, const char *viewname)
1943 {
1944   SceneRenderView *srv;
1945
1946   if ((rd->scemode & R_MULTIVIEW) == 0) {
1947     return true;
1948   }
1949
1950   if ((!viewname) || (!viewname[0])) {
1951     return true;
1952   }
1953
1954   for (srv = rd->views.first; srv; srv = srv->next) {
1955     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
1956       return STREQ(viewname, srv->name);
1957     }
1958   }
1959
1960   return true;
1961 }
1962
1963 /* return true if viewname is the last or if the name is NULL or not found */
1964 bool BKE_scene_multiview_is_render_view_last(const RenderData *rd, const char *viewname)
1965 {
1966   SceneRenderView *srv;
1967
1968   if ((rd->scemode & R_MULTIVIEW) == 0) {
1969     return true;
1970   }
1971
1972   if ((!viewname) || (!viewname[0])) {
1973     return true;
1974   }
1975
1976   for (srv = rd->views.last; srv; srv = srv->prev) {
1977     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
1978       return STREQ(viewname, srv->name);
1979     }
1980   }
1981
1982   return true;
1983 }
1984
1985 SceneRenderView *BKE_scene_multiview_render_view_findindex(const RenderData *rd, const int view_id)
1986 {
1987   SceneRenderView *srv;
1988   size_t nr;
1989
1990   if ((rd->scemode & R_MULTIVIEW) == 0) {
1991     return NULL;
1992   }
1993
1994   for (srv = rd->views.first, nr = 0; srv; srv = srv->next) {
1995     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
1996       if (nr++ == view_id) {
1997         return srv;
1998       }
1999     }
2000   }
2001   return srv;
2002 }
2003
2004 const char *BKE_scene_multiview_render_view_name_get(const RenderData *rd, const int view_id)
2005 {
2006   SceneRenderView *srv = BKE_scene_multiview_render_view_findindex(rd, view_id);
2007
2008   if (srv) {
2009     return srv->name;
2010   }
2011   else {
2012     return "";
2013   }
2014 }
2015
2016 int BKE_scene_multiview_view_id_get(const RenderData *rd, const char *viewname)
2017 {
2018   SceneRenderView *srv;
2019   size_t nr;
2020
2021   if ((!rd) || ((rd->scemode & R_MULTIVIEW) == 0)) {
2022     return 0;
2023   }
2024
2025   if ((!viewname) || (!viewname[0])) {
2026     return 0;
2027   }
2028
2029   for (srv = rd->views.first, nr = 0; srv; srv = srv->next) {
2030     if (BKE_scene_multiview_is_render_view_active(rd, srv)) {
2031       if (STREQ(viewname, srv->name)) {
2032         return nr;
2033       }
2034       else {
2035         nr += 1;
2036       }
2037     }
2038   }
2039
2040   return 0;
2041 }
2042
2043 void BKE_scene_multiview_filepath_get(SceneRenderView *srv, const char *filepath, char *r_filepath)
2044 {
2045   BLI_strncpy(r_filepath, filepath, FILE_MAX);
2046   BLI_path_suffix(r_filepath, FILE_MAX, srv->suffix, "");
2047 }
2048
2049 /**
2050  * When multiview is not used the filepath is as usual (e.g., ``Image.jpg``).
2051  * When multiview is on, even if only one view is enabled the view is incorporated
2052  * into the file name (e.g., ``Image_L.jpg``). That allows for the user to re-render
2053  * individual views.
2054  */
2055 void BKE_scene_multiview_view_filepath_get(const RenderData *rd,
2056                                            const char *filepath,
2057                                            const char *viewname,
2058                                            char *r_filepath)
2059 {
2060   SceneRenderView *srv;
2061   char suffix[FILE_MAX];
2062
2063   srv = BLI_findstring(&rd->views, viewname, offsetof(SceneRenderView, name));
2064   if (srv) {
2065     BLI_strncpy(suffix, srv->suffix, sizeof(suffix));
2066   }
2067   else {
2068     BLI_strncpy(suffix, viewname, sizeof(suffix));
2069   }
2070
2071   BLI_strncpy(r_filepath, filepath, FILE_MAX);
2072   BLI_path_suffix(r_filepath, FILE_MAX, suffix, "");
2073 }
2074
2075 const char *BKE_scene_multiview_view_suffix_get(const RenderData *rd, const char *viewname)
2076 {
2077   SceneRenderView *srv;
2078
2079   if ((viewname == NULL) || (viewname[0] == '\0')) {
2080     return viewname;
2081   }
2082
2083   srv = BLI_findstring(&rd->views, viewname, offsetof(SceneRenderView, name));
2084   if (srv) {
2085     return srv->suffix;
2086   }
2087   else {
2088     return viewname;
2089   }
2090 }
2091
2092 const char *BKE_scene_multiview_view_id_suffix_get(const RenderData *rd, const int view_id)
2093 {
2094   if ((rd->scemode & R_MULTIVIEW) == 0) {
2095     return "";
2096   }
2097   else {
2098     const char *viewname = BKE_scene_multiview_render_view_name_get(rd, view_id);
2099     return BKE_scene_multiview_view_suffix_get(rd, viewname);
2100   }
2101 }
2102
2103 void BKE_scene_multiview_view_prefix_get(Scene *scene,
2104                                          const char *name,
2105                                          char *rprefix,
2106                                          const char **rext)
2107 {
2108   SceneRenderView *srv;
2109   size_t index_act;
2110   const char *suf_act;
2111   const char delims[] = {'.', '\0'};
2112
2113   rprefix[0] = '\0';
2114
2115   /* begin of extension */
2116   index_act = BLI_str_rpartition(name, delims, rext, &suf_act);
2117   if (*rext == NULL) {
2118     return;
2119   }
2120   BLI_assert(index_act > 0);
2121   UNUSED_VARS_NDEBUG(index_act);
2122
2123   for (srv = scene->r.views.first; srv; srv = srv->next) {
2124     if (BKE_scene_multiview_is_render_view_active(&scene->r, srv)) {
2125       size_t len = strlen(srv->suffix);
2126       if (strlen(*rext) >= len && STREQLEN(*rext - len, srv->suffix, len)) {
2127         BLI_strncpy(rprefix, name, strlen(name) - strlen(*rext) - len + 1);
2128         break;
2129       }
2130     }
2131   }
2132 }
2133
2134 void BKE_scene_multiview_videos_dimensions_get(const RenderData *rd,
2135                                                const size_t width,
2136                                                const size_t height,
2137                                                size_t *r_width,
2138                                                size_t *r_height)
2139 {
2140   if ((rd->scemode & R_MULTIVIEW) && rd->im_format.views_format == R_IMF_VIEWS_STEREO_3D) {
2141     IMB_stereo3d_write_dimensions(rd->im_format.stereo3d_format.display_mode,
2142                                   (rd->im_format.stereo3d_format.flag & S3D_SQUEEZED_FRAME) != 0,
2143                                   width,
2144                                   height,
2145                                   r_width,
2146                                   r_height);
2147   }
2148   else {
2149     *r_width = width;
2150     *r_height = height;
2151   }
2152 }
2153
2154 int BKE_scene_multiview_num_videos_get(const RenderData *rd)
2155 {
2156   if (BKE_imtype_is_movie(rd->im_format.imtype) == false) {
2157     return 0;
2158   }
2159
2160   if ((rd->scemode & R_MULTIVIEW) == 0) {
2161     return 1;
2162   }
2163
2164   if (rd->im_format.views_format == R_IMF_VIEWS_STEREO_3D) {
2165     return 1;
2166   }
2167   else {
2168     /* R_IMF_VIEWS_INDIVIDUAL */
2169     return BKE_scene_multiview_num_views_get(rd);
2170   }
2171 }
2172
2173 /* Manipulation of depsgraph storage. */
2174
2175 /* This is a key which identifies depsgraph. */
2176 typedef struct DepsgraphKey {
2177   ViewLayer *view_layer;
2178   /* TODO(sergey): Need to include window somehow (same layer might be in a
2179    * different states in different windows).
2180    */
2181 } DepsgraphKey;
2182
2183 static unsigned int depsgraph_key_hash(const void *key_v)
2184 {
2185   const DepsgraphKey *key = key_v;
2186   unsigned int hash = BLI_ghashutil_ptrhash(key->view_layer);
2187   /* TODO(sergey): Include hash from other fields in the key. */
2188   return hash;
2189 }
2190
2191 static bool depsgraph_key_compare(const void *key_a_v, const void *key_b_v)
2192 {
2193   const DepsgraphKey *key_a = key_a_v;
2194   const DepsgraphKey *key_b = key_b_v;
2195   /* TODO(sergey): Compare rest of  */
2196   return !(key_a->view_layer == key_b->view_layer);
2197 }
2198
2199 static void depsgraph_key_free(void *key_v)
2200 {
2201   DepsgraphKey *key = key_v;
2202   MEM_freeN(key);
2203 }
2204
2205 static void depsgraph_key_value_free(void *value)
2206 {
2207   Depsgraph *depsgraph = value;
2208   DEG_graph_free(depsgraph);
2209 }
2210
2211 void BKE_scene_allocate_depsgraph_hash(Scene *scene)
2212 {
2213   scene->depsgraph_hash = BLI_ghash_new(
2214       depsgraph_key_hash, depsgraph_key_compare, "Scene Depsgraph Hash");
2215 }
2216
2217 void BKE_scene_ensure_depsgraph_hash(Scene *scene)
2218 {
2219   if (scene->depsgraph_hash == NULL) {
2220     BKE_scene_allocate_depsgraph_hash(scene);
2221   }
2222 }
2223
2224 void BKE_scene_free_depsgraph_hash(Scene *scene)
2225 {
2226   if (scene->depsgraph_hash == NULL) {
2227     return;
2228   }
2229   BLI_ghash_free(scene->depsgraph_hash, depsgraph_key_free, depsgraph_key_value_free);
2230 }
2231
2232 /* Query depsgraph for a specific contexts. */
2233
2234 Depsgraph *BKE_scene_get_depsgraph(Scene *scene, ViewLayer *view_layer, bool allocate)
2235 {
2236   BLI_assert(scene != NULL);
2237   BLI_assert(view_layer != NULL);
2238   /* Make sure hash itself exists. */
2239   if (allocate) {
2240     BKE_scene_ensure_depsgraph_hash(scene);
2241   }
2242   if (scene->depsgraph_hash == NULL) {
2243     return NULL;
2244   }
2245   /* Either ensure item is in the hash or simply return NULL if it's not,
2246    * depending on whether caller wants us to create depsgraph or not.
2247    */
2248   DepsgraphKey key;
2249   key.view_layer = view_layer;
2250   Depsgraph *depsgraph;
2251   if (allocate) {
2252     DepsgraphKey **key_ptr;
2253     Depsgraph **depsgraph_ptr;
2254     if (!BLI_ghash_ensure_p_ex(
2255             scene->depsgraph_hash, &key, (void ***)&key_ptr, (void ***)&depsgraph_ptr)) {
2256       *key_ptr = MEM_mallocN(sizeof(DepsgraphKey), __func__);
2257       **key_ptr = key;
2258       *depsgraph_ptr = DEG_graph_new(scene, view_layer, DAG_EVAL_VIEWPORT);
2259       /* TODO(sergey): Would be cool to avoid string format print,
2260        * but is a bit tricky because we can't know in advance  whether
2261        * we will ever enable debug messages for this depsgraph.
2262        */
2263       char name[1024];
2264       BLI_snprintf(name, sizeof(name), "%s :: %s", scene->id.name, view_layer->name);
2265       DEG_debug_name_set(*depsgraph_ptr, name);
2266     }
2267     depsgraph = *depsgraph_ptr;
2268   }
2269   else {
2270     depsgraph = BLI_ghash_lookup(scene->depsgraph_hash, &key);
2271   }
2272   return depsgraph;
2273 }
2274
2275 /* -------------------------------------------------------------------- */
2276 /** \name Scene Orientation
2277  * \{ */
2278
2279 void BKE_scene_transform_orientation_remove(Scene *scene, TransformOrientation *orientation)
2280 {
2281   const int orientation_index = BKE_scene_transform_orientation_get_index(scene, orientation);
2282
2283   for (int i = 0; i < ARRAY_SIZE(scene->orientation_slots); i++) {
2284     TransformOrientationSlot *orient_slot = &scene->orientation_slots[i];
2285     if (orient_slot->index_custom == orientation_index) {
2286       /* could also use orientation_index-- */
2287       orient_slot->type = V3D_ORIENT_GLOBAL;
2288       orient_slot->index_custom = -1;
2289     }
2290   }
2291
2292   BLI_freelinkN(&scene->transform_spaces, orientation);
2293 }
2294
2295 TransformOrientation *BKE_scene_transform_orientation_find(const Scene *scene, const int index)
2296 {
2297   return BLI_findlink(&scene->transform_spaces, index);
2298 }
2299
2300 /**
2301  * \return the index that \a orientation has within \a scene's transform-orientation list or -1 if not found.
2302  */
2303 int BKE_scene_transform_orientation_get_index(const Scene *scene,
2304                                               const TransformOrientation *orientation)
2305 {
2306   return BLI_findindex(&scene->transform_spaces, orientation);
2307 }
2308
2309 /** \} */
2310
2311 /* -------------------------------------------------------------------- */
2312 /** \name Scene Cursor Rotation
2313  *
2314  * Matches #BKE_object_rot_to_mat3 and #BKE_object_mat3_to_rot.
2315  * \{ */
2316
2317 void BKE_scene_cursor_rot_to_mat3(const View3DCursor *cursor, float mat[3][3])
2318 {
2319   if (cursor->rotation_mode > 0) {
2320     eulO_to_mat3(mat, cursor->rotation_euler, cursor->rotation_mode);
2321   }
2322   else if (cursor->rotation_mode == ROT_MODE_AXISANGLE) {
2323     axis_angle_to_mat3(mat, cursor->rotation_axis, cursor->rotation_angle);
2324   }
2325   else {
2326     float tquat[4];
2327     normalize_qt_qt(tquat, cursor->rotation_quaternion);
2328     quat_to_mat3(mat, tquat);
2329   }
2330 }
2331
2332 void BKE_scene_cursor_rot_to_quat(const View3DCursor *cursor, float quat[4])
2333 {
2334   if (cursor->rotation_mode > 0) {
2335     eulO_to_quat(quat, cursor->rotation_euler, cursor->rotation_mode);
2336   }
2337   else if (cursor->rotation_mode == ROT_MODE_AXISANGLE) {
2338     axis_angle_to_quat(quat, cursor->rotation_axis, cursor->rotation_angle);
2339   }
2340   else {
2341     normalize_qt_qt(quat, cursor->rotation_quaternion);
2342   }
2343 }
2344
2345 void BKE_scene_cursor_mat3_to_rot(View3DCursor *cursor, const float mat[3][3], bool use_compat)
2346 {
2347   BLI_ASSERT_UNIT_M3(mat);
2348
2349   switch (cursor->rotation_mode) {
2350     case ROT_MODE_QUAT: {
2351       mat3_normalized_to_quat(cursor->rotation_quaternion, mat);
2352       break;
2353     }
2354     case ROT_MODE_AXISANGLE: {
2355       mat3_to_axis_angle(cursor->rotation_axis, &cursor->rotation_angle, mat);
2356       break;
2357     }
2358     default: {
2359       if (use_compat) {
2360         mat3_to_compatible_eulO(
2361             cursor->rotation_euler, cursor->rotation_euler, cursor->rotation_mode, mat);
2362       }
2363       else {
2364         mat3_to_eulO(cursor->rotation_euler, cursor->rotation_mode, mat);
2365       }
2366       break;
2367     }
2368   }
2369 }
2370
2371 void BKE_scene_cursor_quat_to_rot(View3DCursor *cursor, const float quat[4], bool use_compat)
2372 {
2373   BLI_ASSERT_UNIT_QUAT(quat);
2374
2375   switch (cursor->rotation_mode) {
2376     case ROT_MODE_QUAT: {
2377       copy_qt_qt(cursor->rotation_quaternion, quat);
2378       break;
2379     }
2380     case ROT_MODE_AXISANGLE: {
2381       quat_to_axis_angle(cursor->rotation_axis, &cursor->rotation_angle, quat);
2382       break;
2383     }
2384     default: {
2385       if (use_compat) {
2386         quat_to_compatible_eulO(
2387             cursor->rotation_euler, cursor->rotation_euler, cursor->rotation_mode, quat);
2388       }
2389       else {
2390         quat_to_eulO(cursor->rotation_euler, cursor->rotation_mode, quat);
2391       }
2392       break;
2393     }
2394   }
2395 }
2396
2397 /** \} */