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