CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / blenloader / intern / versioning_280.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
17 /** \file
18  * \ingroup blenloader
19  */
20
21 /* allow readfile to use deprecated functionality */
22 #define DNA_DEPRECATED_ALLOW
23
24 #include <float.h>
25 #include <string.h>
26
27 #include "BLI_listbase.h"
28 #include "BLI_math.h"
29 #include "BLI_mempool.h"
30 #include "BLI_string.h"
31 #include "BLI_utildefines.h"
32
33 #include "DNA_defaults.h"
34
35 #include "DNA_anim_types.h"
36 #include "DNA_armature_types.h"
37 #include "DNA_camera_types.h"
38 #include "DNA_cloth_types.h"
39 #include "DNA_collection_types.h"
40 #include "DNA_constraint_types.h"
41 #include "DNA_curve_types.h"
42 #include "DNA_curveprofile_types.h"
43 #include "DNA_fluid_types.h"
44 #include "DNA_freestyle_types.h"
45 #include "DNA_genfile.h"
46 #include "DNA_gpencil_modifier_types.h"
47 #include "DNA_gpencil_types.h"
48 #include "DNA_gpu_types.h"
49 #include "DNA_key_types.h"
50 #include "DNA_layer_types.h"
51 #include "DNA_light_types.h"
52 #include "DNA_lightprobe_types.h"
53 #include "DNA_linestyle_types.h"
54 #include "DNA_material_types.h"
55 #include "DNA_mesh_types.h"
56 #include "DNA_modifier_types.h"
57 #include "DNA_object_types.h"
58 #include "DNA_particle_types.h"
59 #include "DNA_rigidbody_types.h"
60 #include "DNA_scene_types.h"
61 #include "DNA_screen_types.h"
62 #include "DNA_shader_fx_types.h"
63 #include "DNA_text_types.h"
64 #include "DNA_texture_types.h"
65 #include "DNA_view3d_types.h"
66 #include "DNA_workspace_types.h"
67 #include "DNA_world_types.h"
68
69 #include "BKE_animsys.h"
70 #include "BKE_brush.h"
71 #include "BKE_cloth.h"
72 #include "BKE_collection.h"
73 #include "BKE_colortools.h"
74 #include "BKE_constraint.h"
75 #include "BKE_curveprofile.h"
76 #include "BKE_customdata.h"
77 #include "BKE_fcurve.h"
78 #include "BKE_freestyle.h"
79 #include "BKE_global.h"
80 #include "BKE_gpencil.h"
81 #include "BKE_gpencil_geom.h"
82 #include "BKE_gpencil_modifier.h"
83 #include "BKE_idprop.h"
84 #include "BKE_key.h"
85 #include "BKE_layer.h"
86 #include "BKE_lib_id.h"
87 #include "BKE_main.h"
88 #include "BKE_mesh.h"
89 #include "BKE_node.h"
90 #include "BKE_paint.h"
91 #include "BKE_pointcache.h"
92 #include "BKE_report.h"
93 #include "BKE_rigidbody.h"
94 #include "BKE_screen.h"
95 #include "BKE_sequencer.h"
96 #include "BKE_studiolight.h"
97 #include "BKE_unit.h"
98 #include "BKE_workspace.h"
99
100 /* Only for IMB_BlendMode */
101 #include "IMB_imbuf.h"
102
103 #include "DEG_depsgraph.h"
104
105 #include "BLT_translation.h"
106
107 #include "BLO_readfile.h"
108 #include "readfile.h"
109
110 #include "MEM_guardedalloc.h"
111
112 /* Make preferences read-only, use versioning_userdef.c. */
113 #define U (*((const UserDef *)&U))
114
115 /**
116  * Rename if the ID doesn't exist.
117  */
118 static ID *rename_id_for_versioning(Main *bmain,
119                                     const short id_type,
120                                     const char *name_src,
121                                     const char *name_dst)
122 {
123   /* We can ignore libraries */
124   ListBase *lb = which_libbase(bmain, id_type);
125   ID *id = NULL;
126   LISTBASE_FOREACH (ID *, idtest, lb) {
127     if (idtest->lib == NULL) {
128       if (STREQ(idtest->name + 2, name_src)) {
129         id = idtest;
130       }
131       if (STREQ(idtest->name + 2, name_dst)) {
132         return NULL;
133       }
134     }
135   }
136   if (id != NULL) {
137     BLI_strncpy(id->name + 2, name_dst, sizeof(id->name) - 2);
138     /* We know it's unique, this just sorts. */
139     BLI_libblock_ensure_unique_name(bmain, id->name);
140   }
141   return id;
142 }
143
144 static bScreen *screen_parent_find(const bScreen *screen)
145 {
146   /* Can avoid lookup if screen state isn't maximized/full
147    * (parent and child store the same state). */
148   if (ELEM(screen->state, SCREENMAXIMIZED, SCREENFULL)) {
149     LISTBASE_FOREACH (const ScrArea *, area, &screen->areabase) {
150       if (area->full && area->full != screen) {
151         BLI_assert(area->full->state == screen->state);
152         return area->full;
153       }
154     }
155   }
156
157   return NULL;
158 }
159
160 static void do_version_workspaces_create_from_screens(Main *bmain)
161 {
162   for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
163     const bScreen *screen_parent = screen_parent_find(screen);
164     WorkSpace *workspace;
165     if (screen->temp) {
166       continue;
167     }
168
169     if (screen_parent) {
170       /* Full-screen with "Back to Previous" option, don't create
171        * a new workspace, add layout workspace containing parent. */
172       workspace = BLI_findstring(
173           &bmain->workspaces, screen_parent->id.name + 2, offsetof(ID, name) + 2);
174     }
175     else {
176       workspace = BKE_workspace_add(bmain, screen->id.name + 2);
177     }
178     if (workspace == NULL) {
179       continue; /* Not much we can do.. */
180     }
181     BKE_workspace_layout_add(bmain, workspace, screen, screen->id.name + 2);
182   }
183 }
184
185 static void do_version_area_change_space_to_space_action(ScrArea *area, const Scene *scene)
186 {
187   SpaceType *stype = BKE_spacetype_from_id(SPACE_ACTION);
188   SpaceAction *saction = (SpaceAction *)stype->new (area, scene);
189   ARegion *region_channels;
190
191   /* Properly free current regions */
192   LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
193     BKE_area_region_free(area->type, region);
194   }
195   BLI_freelistN(&area->regionbase);
196
197   area->type = stype;
198   area->spacetype = stype->spaceid;
199
200   BLI_addhead(&area->spacedata, saction);
201   area->regionbase = saction->regionbase;
202   BLI_listbase_clear(&saction->regionbase);
203
204   /* Different defaults for timeline */
205   region_channels = BKE_area_find_region_type(area, RGN_TYPE_CHANNELS);
206   region_channels->flag |= RGN_FLAG_HIDDEN;
207
208   saction->mode = SACTCONT_TIMELINE;
209   saction->ads.flag |= ADS_FLAG_SUMMARY_COLLAPSED;
210   saction->ads.filterflag |= ADS_FILTER_SUMMARY;
211 }
212
213 /**
214  * \brief After lib-link versioning for new workspace design.
215  *
216  * - Adds a workspace for (almost) each screen of the old file
217  *   and adds the needed workspace-layout to wrap the screen.
218  * - Active screen isn't stored directly in window anymore, but in the active workspace.
219  * - Active scene isn't stored in screen anymore, but in window.
220  * - Create workspace instance hook for each window.
221  *
222  * \note Some of the created workspaces might be deleted again
223  * in case of reading the default `startup.blend`.
224  */
225 static void do_version_workspaces_after_lib_link(Main *bmain)
226 {
227   BLI_assert(BLI_listbase_is_empty(&bmain->workspaces));
228
229   do_version_workspaces_create_from_screens(bmain);
230
231   for (wmWindowManager *wm = bmain->wm.first; wm; wm = wm->id.next) {
232     LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
233       bScreen *screen_parent = screen_parent_find(win->screen);
234       bScreen *screen = screen_parent ? screen_parent : win->screen;
235
236       if (screen->temp) {
237         /* We do not generate a new workspace for those screens...
238          * still need to set some data in win. */
239         win->workspace_hook = BKE_workspace_instance_hook_create(bmain);
240         win->scene = screen->scene;
241         /* Deprecated from now on! */
242         win->screen = NULL;
243         continue;
244       }
245
246       WorkSpace *workspace = BLI_findstring(
247           &bmain->workspaces, screen->id.name + 2, offsetof(ID, name) + 2);
248       BLI_assert(workspace != NULL);
249       WorkSpaceLayout *layout = BKE_workspace_layout_find(workspace, win->screen);
250       BLI_assert(layout != NULL);
251
252       win->workspace_hook = BKE_workspace_instance_hook_create(bmain);
253
254       BKE_workspace_active_set(win->workspace_hook, workspace);
255       BKE_workspace_active_layout_set(win->workspace_hook, layout);
256
257       /* Move scene and view layer to window. */
258       Scene *scene = screen->scene;
259       ViewLayer *layer = BLI_findlink(&scene->view_layers, scene->r.actlay);
260       if (!layer) {
261         layer = BKE_view_layer_default_view(scene);
262       }
263
264       win->scene = scene;
265       STRNCPY(win->view_layer_name, layer->name);
266
267       /* Deprecated from now on! */
268       win->screen = NULL;
269     }
270   }
271
272   for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
273     /* Deprecated from now on! */
274     BLI_freelistN(&screen->scene->transform_spaces);
275     screen->scene = NULL;
276   }
277 }
278
279 #ifdef USE_COLLECTION_COMPAT_28
280 enum {
281   COLLECTION_DEPRECATED_VISIBLE = (1 << 0),
282   COLLECTION_DEPRECATED_VIEWPORT = (1 << 0),
283   COLLECTION_DEPRECATED_SELECTABLE = (1 << 1),
284   COLLECTION_DEPRECATED_DISABLED = (1 << 2),
285   COLLECTION_DEPRECATED_RENDER = (1 << 3),
286 };
287
288 static void do_version_view_layer_visibility(ViewLayer *view_layer)
289 {
290   /* Convert from deprecated VISIBLE flag to DISABLED */
291   LayerCollection *lc;
292   for (lc = view_layer->layer_collections.first; lc; lc = lc->next) {
293     if (lc->flag & COLLECTION_DEPRECATED_DISABLED) {
294       lc->flag &= ~COLLECTION_DEPRECATED_DISABLED;
295     }
296
297     if ((lc->flag & COLLECTION_DEPRECATED_VISIBLE) == 0) {
298       lc->flag |= COLLECTION_DEPRECATED_DISABLED;
299     }
300
301     lc->flag |= COLLECTION_DEPRECATED_VIEWPORT | COLLECTION_DEPRECATED_RENDER;
302   }
303 }
304
305 static void do_version_layer_collection_pre(ViewLayer *view_layer,
306                                             ListBase *lb,
307                                             GSet *enabled_set,
308                                             GSet *selectable_set)
309 {
310   /* Convert from deprecated DISABLED to new layer collection and collection flags */
311   LISTBASE_FOREACH (LayerCollection *, lc, lb) {
312     if (lc->scene_collection) {
313       if (!(lc->flag & COLLECTION_DEPRECATED_DISABLED)) {
314         BLI_gset_insert(enabled_set, lc->scene_collection);
315       }
316       if (lc->flag & COLLECTION_DEPRECATED_SELECTABLE) {
317         BLI_gset_insert(selectable_set, lc->scene_collection);
318       }
319     }
320
321     do_version_layer_collection_pre(
322         view_layer, &lc->layer_collections, enabled_set, selectable_set);
323   }
324 }
325
326 static void do_version_layer_collection_post(ViewLayer *view_layer,
327                                              ListBase *lb,
328                                              GSet *enabled_set,
329                                              GSet *selectable_set,
330                                              GHash *collection_map)
331 {
332   /* Apply layer collection exclude flags. */
333   LISTBASE_FOREACH (LayerCollection *, lc, lb) {
334     if (!(lc->collection->flag & COLLECTION_IS_MASTER)) {
335       SceneCollection *sc = BLI_ghash_lookup(collection_map, lc->collection);
336       const bool enabled = (sc && BLI_gset_haskey(enabled_set, sc));
337       const bool selectable = (sc && BLI_gset_haskey(selectable_set, sc));
338
339       if (!enabled) {
340         lc->flag |= LAYER_COLLECTION_EXCLUDE;
341       }
342       if (enabled && !selectable) {
343         lc->collection->flag |= COLLECTION_RESTRICT_SELECT;
344       }
345     }
346
347     do_version_layer_collection_post(
348         view_layer, &lc->layer_collections, enabled_set, selectable_set, collection_map);
349   }
350 }
351
352 static void do_version_scene_collection_convert(
353     Main *bmain, ID *id, SceneCollection *sc, Collection *collection, GHash *collection_map)
354 {
355   if (collection_map) {
356     BLI_ghash_insert(collection_map, collection, sc);
357   }
358
359   for (SceneCollection *nsc = sc->scene_collections.first; nsc;) {
360     SceneCollection *nsc_next = nsc->next;
361     Collection *ncollection = BKE_collection_add(bmain, collection, nsc->name);
362     ncollection->id.lib = id->lib;
363     do_version_scene_collection_convert(bmain, id, nsc, ncollection, collection_map);
364     nsc = nsc_next;
365   }
366
367   LISTBASE_FOREACH (LinkData *, link, &sc->objects) {
368     Object *ob = link->data;
369     if (ob) {
370       BKE_collection_object_add(bmain, collection, ob);
371       id_us_min(&ob->id);
372     }
373   }
374
375   BLI_freelistN(&sc->objects);
376   MEM_freeN(sc);
377 }
378
379 static void do_version_group_collection_to_collection(Main *bmain, Collection *group)
380 {
381   /* Convert old 2.8 group collections to new unified collections. */
382   if (group->collection) {
383     do_version_scene_collection_convert(bmain, &group->id, group->collection, group, NULL);
384   }
385
386   group->collection = NULL;
387   group->view_layer = NULL;
388   id_fake_user_set(&group->id);
389 }
390
391 static void do_version_scene_collection_to_collection(Main *bmain, Scene *scene)
392 {
393   /* Convert old 2.8 scene collections to new unified collections. */
394
395   /* Temporarily clear view layers so we don't do any layer collection syncing
396    * and destroy old flags that we want to restore. */
397   ListBase view_layers = scene->view_layers;
398   BLI_listbase_clear(&scene->view_layers);
399
400   if (!scene->master_collection) {
401     scene->master_collection = BKE_collection_master_add();
402   }
403
404   /* Convert scene collections. */
405   GHash *collection_map = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
406   if (scene->collection) {
407     do_version_scene_collection_convert(
408         bmain, &scene->id, scene->collection, scene->master_collection, collection_map);
409     scene->collection = NULL;
410   }
411
412   scene->view_layers = view_layers;
413
414   /* Convert layer collections. */
415   ViewLayer *view_layer;
416   for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
417     GSet *enabled_set = BLI_gset_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
418     GSet *selectable_set = BLI_gset_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
419
420     do_version_layer_collection_pre(
421         view_layer, &view_layer->layer_collections, enabled_set, selectable_set);
422
423     BKE_layer_collection_sync(scene, view_layer);
424
425     do_version_layer_collection_post(
426         view_layer, &view_layer->layer_collections, enabled_set, selectable_set, collection_map);
427
428     BLI_gset_free(enabled_set, NULL);
429     BLI_gset_free(selectable_set, NULL);
430
431     BKE_layer_collection_sync(scene, view_layer);
432   }
433
434   BLI_ghash_free(collection_map, NULL, NULL);
435 }
436 #endif
437
438 static void do_version_layers_to_collections(Main *bmain, Scene *scene)
439 {
440   /* Since we don't have access to FileData we check the (always valid) first
441    * render layer instead. */
442   if (!scene->master_collection) {
443     scene->master_collection = BKE_collection_master_add();
444   }
445
446   if (scene->view_layers.first) {
447     return;
448   }
449
450   /* Create collections from layers. */
451   Collection *collection_master = scene->master_collection;
452   Collection *collections[20] = {NULL};
453
454   for (int layer = 0; layer < 20; layer++) {
455     LISTBASE_FOREACH (Base *, base, &scene->base) {
456       if (base->lay & (1 << layer)) {
457         /* Create collections when needed only. */
458         if (collections[layer] == NULL) {
459           char name[MAX_NAME];
460
461           BLI_snprintf(
462               name, sizeof(collection_master->id.name), DATA_("Collection %d"), layer + 1);
463
464           Collection *collection = BKE_collection_add(bmain, collection_master, name);
465           collection->id.lib = scene->id.lib;
466           if (collection->id.lib != NULL) {
467             collection->id.tag |= LIB_TAG_INDIRECT;
468           }
469           collections[layer] = collection;
470
471           if (!(scene->lay & (1 << layer))) {
472             collection->flag |= COLLECTION_RESTRICT_VIEWPORT | COLLECTION_RESTRICT_RENDER;
473           }
474         }
475
476         /* Note usually this would do slow collection syncing for view layers,
477          * but since no view layers exists yet at this point it's fast. */
478         BKE_collection_object_add(bmain, collections[layer], base->object);
479       }
480
481       if (base->flag & SELECT) {
482         base->object->flag |= SELECT;
483       }
484       else {
485         base->object->flag &= ~SELECT;
486       }
487     }
488   }
489
490   /* Handle legacy render layers. */
491   bool have_override = false;
492   const bool need_default_renderlayer = scene->r.layers.first == NULL;
493
494   LISTBASE_FOREACH (SceneRenderLayer *, srl, &scene->r.layers) {
495     ViewLayer *view_layer = BKE_view_layer_add(scene, srl->name, NULL, VIEWLAYER_ADD_NEW);
496
497     if (srl->layflag & SCE_LAY_DISABLE) {
498       view_layer->flag &= ~VIEW_LAYER_RENDER;
499     }
500
501     if ((srl->layflag & SCE_LAY_FRS) == 0) {
502       view_layer->flag &= ~VIEW_LAYER_FREESTYLE;
503     }
504
505     view_layer->layflag = srl->layflag;
506     view_layer->passflag = srl->passflag;
507     view_layer->pass_alpha_threshold = srl->pass_alpha_threshold;
508     view_layer->samples = srl->samples;
509     view_layer->mat_override = srl->mat_override;
510
511     BKE_freestyle_config_free(&view_layer->freestyle_config, true);
512     view_layer->freestyle_config = srl->freestyleConfig;
513     view_layer->id_properties = srl->prop;
514
515     /* Set exclusion and overrides. */
516     for (int layer = 0; layer < 20; layer++) {
517       Collection *collection = collections[layer];
518       if (collection) {
519         LayerCollection *lc = BKE_layer_collection_first_from_scene_collection(view_layer,
520                                                                                collection);
521
522         if (srl->lay_exclude & (1 << layer)) {
523           /* Disable excluded layer. */
524           have_override = true;
525           lc->flag |= LAYER_COLLECTION_EXCLUDE;
526           LISTBASE_FOREACH (LayerCollection *, nlc, &lc->layer_collections) {
527             nlc->flag |= LAYER_COLLECTION_EXCLUDE;
528           }
529         }
530         else {
531           if (srl->lay_zmask & (1 << layer)) {
532             have_override = true;
533             lc->flag |= LAYER_COLLECTION_HOLDOUT;
534           }
535
536           if ((srl->lay & (1 << layer)) == 0) {
537             have_override = true;
538             lc->flag |= LAYER_COLLECTION_INDIRECT_ONLY;
539           }
540         }
541       }
542     }
543
544     /* for convenience set the same active object in all the layers */
545     if (scene->basact) {
546       view_layer->basact = BKE_view_layer_base_find(view_layer, scene->basact->object);
547     }
548
549     LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
550       if ((base->flag & BASE_SELECTABLE) && (base->object->flag & SELECT)) {
551         base->flag |= BASE_SELECTED;
552       }
553     }
554   }
555
556   BLI_freelistN(&scene->r.layers);
557
558   /* If render layers included overrides, or there are no render layers,
559    * we also create a vanilla viewport layer. */
560   if (have_override || need_default_renderlayer) {
561     ViewLayer *view_layer = BKE_view_layer_add(scene, "Viewport", NULL, VIEWLAYER_ADD_NEW);
562
563     /* If we ported all the original render layers,
564      * we don't need to make the viewport layer renderable. */
565     if (!BLI_listbase_is_single(&scene->view_layers)) {
566       view_layer->flag &= ~VIEW_LAYER_RENDER;
567     }
568
569     /* convert active base */
570     if (scene->basact) {
571       view_layer->basact = BKE_view_layer_base_find(view_layer, scene->basact->object);
572     }
573
574     /* convert selected bases */
575     LISTBASE_FOREACH (Base *, base, &view_layer->object_bases) {
576       if ((base->flag & BASE_SELECTABLE) && (base->object->flag & SELECT)) {
577         base->flag |= BASE_SELECTED;
578       }
579
580       /* keep lay around for forward compatibility (open those files in 2.79) */
581       base->lay = base->object->lay;
582     }
583   }
584
585   /* remove bases once and for all */
586   LISTBASE_FOREACH (Base *, base, &scene->base) {
587     id_us_min(&base->object->id);
588   }
589
590   BLI_freelistN(&scene->base);
591   scene->basact = NULL;
592 }
593
594 static void do_version_collection_propagate_lib_to_children(Collection *collection)
595 {
596   if (collection->id.lib != NULL) {
597     for (CollectionChild *collection_child = collection->children.first; collection_child != NULL;
598          collection_child = collection_child->next) {
599       if (collection_child->collection->id.lib == NULL) {
600         collection_child->collection->id.lib = collection->id.lib;
601       }
602       do_version_collection_propagate_lib_to_children(collection_child->collection);
603     }
604   }
605 }
606
607 /** convert old annotations colors */
608 static void do_versions_fix_annotations(bGPdata *gpd)
609 {
610   LISTBASE_FOREACH (const bGPDpalette *, palette, &gpd->palettes) {
611     LISTBASE_FOREACH (bGPDpalettecolor *, palcolor, &palette->colors) {
612       /* fix layers */
613       LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
614         /* unlock/unhide layer */
615         gpl->flag &= ~GP_LAYER_LOCKED;
616         gpl->flag &= ~GP_LAYER_HIDE;
617         /* set opacity to 1 */
618         gpl->opacity = 1.0f;
619         /* disable tint */
620         gpl->tintcolor[3] = 0.0f;
621
622         LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
623           LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
624             if ((gps->colorname[0] != '\0') && (STREQ(gps->colorname, palcolor->info))) {
625               /* copy color settings */
626               copy_v4_v4(gpl->color, palcolor->color);
627             }
628           }
629         }
630       }
631     }
632   }
633 }
634
635 static void do_versions_remove_region(ListBase *regionbase, ARegion *region)
636 {
637   BLI_freelinkN(regionbase, region);
638 }
639
640 static void do_versions_remove_regions_by_type(ListBase *regionbase, int regiontype)
641 {
642   ARegion *region, *region_next;
643   for (region = regionbase->first; region; region = region_next) {
644     region_next = region->next;
645     if (region->regiontype == regiontype) {
646       do_versions_remove_region(regionbase, region);
647     }
648   }
649 }
650
651 static ARegion *do_versions_find_region_or_null(ListBase *regionbase, int regiontype)
652 {
653   LISTBASE_FOREACH (ARegion *, region, regionbase) {
654     if (region->regiontype == regiontype) {
655       return region;
656     }
657   }
658   return NULL;
659 }
660
661 static ARegion *do_versions_find_region(ListBase *regionbase, int regiontype)
662 {
663   ARegion *region = do_versions_find_region_or_null(regionbase, regiontype);
664   if (region == NULL) {
665     BLI_assert(!"Did not find expected region in versioning");
666   }
667   return region;
668 }
669
670 static ARegion *do_versions_add_region(int regiontype, const char *name)
671 {
672   ARegion *region = MEM_callocN(sizeof(ARegion), name);
673   region->regiontype = regiontype;
674   return region;
675 }
676
677 static void do_versions_area_ensure_tool_region(Main *bmain,
678                                                 const short space_type,
679                                                 const short region_flag)
680 {
681   for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
682     LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
683       LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
684         if (sl->spacetype == space_type) {
685           ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
686                                                                  &sl->regionbase;
687           ARegion *region = BKE_area_find_region_type(area, RGN_TYPE_TOOLS);
688           if (!region) {
689             ARegion *header = BKE_area_find_region_type(area, RGN_TYPE_HEADER);
690             region = do_versions_add_region(RGN_TYPE_TOOLS, "tools region");
691             BLI_insertlinkafter(regionbase, header, region);
692             region->alignment = RGN_ALIGN_LEFT;
693             region->flag = region_flag;
694           }
695         }
696       }
697     }
698   }
699 }
700
701 static void do_version_bones_split_bbone_scale(ListBase *lb)
702 {
703   LISTBASE_FOREACH (Bone *, bone, lb) {
704     bone->scale_in_y = bone->scale_in_x;
705     bone->scale_out_y = bone->scale_out_x;
706
707     do_version_bones_split_bbone_scale(&bone->childbase);
708   }
709 }
710
711 static void do_version_bones_inherit_scale(ListBase *lb)
712 {
713   LISTBASE_FOREACH (Bone *, bone, lb) {
714     if (bone->flag & BONE_NO_SCALE) {
715       bone->inherit_scale_mode = BONE_INHERIT_SCALE_NONE_LEGACY;
716       bone->flag &= ~BONE_NO_SCALE;
717     }
718
719     do_version_bones_inherit_scale(&bone->childbase);
720   }
721 }
722
723 static bool replace_bbone_scale_rnapath(char **p_old_path)
724 {
725   char *old_path = *p_old_path;
726
727   if (old_path == NULL) {
728     return false;
729   }
730
731   if (BLI_str_endswith(old_path, "bbone_scalein") ||
732       BLI_str_endswith(old_path, "bbone_scaleout")) {
733     *p_old_path = BLI_strdupcat(old_path, "x");
734
735     MEM_freeN(old_path);
736     return true;
737   }
738
739   return false;
740 }
741
742 static void do_version_bbone_scale_fcurve_fix(ListBase *curves, FCurve *fcu)
743 {
744   /* Update driver variable paths. */
745   if (fcu->driver) {
746     LISTBASE_FOREACH (DriverVar *, dvar, &fcu->driver->variables) {
747       DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
748         replace_bbone_scale_rnapath(&dtar->rna_path);
749       }
750       DRIVER_TARGETS_LOOPER_END;
751     }
752   }
753
754   /* Update F-Curve's path. */
755   if (replace_bbone_scale_rnapath(&fcu->rna_path)) {
756     /* If matched, duplicate the curve and tweak name. */
757     FCurve *second = copy_fcurve(fcu);
758
759     second->rna_path[strlen(second->rna_path) - 1] = 'y';
760
761     BLI_insertlinkafter(curves, fcu, second);
762
763     /* Add to the curve group. */
764     second->grp = fcu->grp;
765
766     if (fcu->grp != NULL && fcu->grp->channels.last == fcu) {
767       fcu->grp->channels.last = second;
768     }
769   }
770 }
771
772 static void do_version_bbone_scale_animdata_cb(ID *UNUSED(id),
773                                                AnimData *adt,
774                                                void *UNUSED(wrapper_data))
775 {
776   LISTBASE_FOREACH_MUTABLE (FCurve *, fcu, &adt->drivers) {
777     do_version_bbone_scale_fcurve_fix(&adt->drivers, fcu);
778   }
779 }
780
781 static void do_version_constraints_maintain_volume_mode_uniform(ListBase *lb)
782 {
783   LISTBASE_FOREACH (bConstraint *, con, lb) {
784     if (con->type == CONSTRAINT_TYPE_SAMEVOL) {
785       bSameVolumeConstraint *data = (bSameVolumeConstraint *)con->data;
786       data->mode = SAMEVOL_UNIFORM;
787     }
788   }
789 }
790
791 static void do_version_constraints_copy_scale_power(ListBase *lb)
792 {
793   LISTBASE_FOREACH (bConstraint *, con, lb) {
794     if (con->type == CONSTRAINT_TYPE_SIZELIKE) {
795       bSizeLikeConstraint *data = (bSizeLikeConstraint *)con->data;
796       data->power = 1.0f;
797     }
798   }
799 }
800
801 static void do_version_constraints_copy_rotation_mix_mode(ListBase *lb)
802 {
803   LISTBASE_FOREACH (bConstraint *, con, lb) {
804     if (con->type == CONSTRAINT_TYPE_ROTLIKE) {
805       bRotateLikeConstraint *data = (bRotateLikeConstraint *)con->data;
806       data->mix_mode = (data->flag & ROTLIKE_OFFSET) ? ROTLIKE_MIX_OFFSET : ROTLIKE_MIX_REPLACE;
807       data->flag &= ~ROTLIKE_OFFSET;
808     }
809   }
810 }
811
812 static void do_versions_seq_alloc_transform_and_crop(ListBase *seqbase)
813 {
814   for (Sequence *seq = seqbase->first; seq != NULL; seq = seq->next) {
815     if (ELEM(seq->type, SEQ_TYPE_SOUND_RAM, SEQ_TYPE_SOUND_HD) == 0) {
816       if (seq->strip->transform == NULL) {
817         seq->strip->transform = MEM_callocN(sizeof(struct StripTransform), "StripTransform");
818       }
819
820       if (seq->strip->crop == NULL) {
821         seq->strip->crop = MEM_callocN(sizeof(struct StripCrop), "StripCrop");
822       }
823
824       if (seq->seqbase.first != NULL) {
825         do_versions_seq_alloc_transform_and_crop(&seq->seqbase);
826       }
827     }
828   }
829 }
830
831 /* Return true if there is something to convert. */
832 static void do_versions_material_convert_legacy_blend_mode(bNodeTree *ntree, char blend_method)
833 {
834   bool need_update = false;
835
836   /* Iterate backwards from end so we don't encounter newly added links. */
837   bNodeLink *prevlink;
838   for (bNodeLink *link = ntree->links.last; link; link = prevlink) {
839     prevlink = link->prev;
840
841     /* Detect link to replace. */
842     bNode *fromnode = link->fromnode;
843     bNodeSocket *fromsock = link->fromsock;
844     bNode *tonode = link->tonode;
845     bNodeSocket *tosock = link->tosock;
846
847     if (!(tonode->type == SH_NODE_OUTPUT_MATERIAL && STREQ(tosock->identifier, "Surface"))) {
848       continue;
849     }
850
851     /* Only do outputs that are enabled for EEVEE */
852     if (!ELEM(tonode->custom1, SHD_OUTPUT_ALL, SHD_OUTPUT_EEVEE)) {
853       continue;
854     }
855
856     if (blend_method == 1 /* MA_BM_ADD */) {
857       nodeRemLink(ntree, link);
858
859       bNode *add_node = nodeAddStaticNode(NULL, ntree, SH_NODE_ADD_SHADER);
860       add_node->locx = 0.5f * (fromnode->locx + tonode->locx);
861       add_node->locy = 0.5f * (fromnode->locy + tonode->locy);
862
863       bNodeSocket *shader1_socket = add_node->inputs.first;
864       bNodeSocket *shader2_socket = add_node->inputs.last;
865       bNodeSocket *add_socket = nodeFindSocket(add_node, SOCK_OUT, "Shader");
866
867       bNode *transp_node = nodeAddStaticNode(NULL, ntree, SH_NODE_BSDF_TRANSPARENT);
868       transp_node->locx = add_node->locx;
869       transp_node->locy = add_node->locy - 110.0f;
870
871       bNodeSocket *transp_socket = nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
872
873       /* Link to input and material output node. */
874       nodeAddLink(ntree, fromnode, fromsock, add_node, shader1_socket);
875       nodeAddLink(ntree, transp_node, transp_socket, add_node, shader2_socket);
876       nodeAddLink(ntree, add_node, add_socket, tonode, tosock);
877
878       need_update = true;
879     }
880     else if (blend_method == 2 /* MA_BM_MULTIPLY */) {
881       nodeRemLink(ntree, link);
882
883       bNode *transp_node = nodeAddStaticNode(NULL, ntree, SH_NODE_BSDF_TRANSPARENT);
884
885       bNodeSocket *color_socket = nodeFindSocket(transp_node, SOCK_IN, "Color");
886       bNodeSocket *transp_socket = nodeFindSocket(transp_node, SOCK_OUT, "BSDF");
887
888       /* If incomming link is from a closure socket, we need to convert it. */
889       if (fromsock->type == SOCK_SHADER) {
890         transp_node->locx = 0.33f * fromnode->locx + 0.66f * tonode->locx;
891         transp_node->locy = 0.33f * fromnode->locy + 0.66f * tonode->locy;
892
893         bNode *shtorgb_node = nodeAddStaticNode(NULL, ntree, SH_NODE_SHADERTORGB);
894         shtorgb_node->locx = 0.66f * fromnode->locx + 0.33f * tonode->locx;
895         shtorgb_node->locy = 0.66f * fromnode->locy + 0.33f * tonode->locy;
896
897         bNodeSocket *shader_socket = nodeFindSocket(shtorgb_node, SOCK_IN, "Shader");
898         bNodeSocket *rgba_socket = nodeFindSocket(shtorgb_node, SOCK_OUT, "Color");
899
900         nodeAddLink(ntree, fromnode, fromsock, shtorgb_node, shader_socket);
901         nodeAddLink(ntree, shtorgb_node, rgba_socket, transp_node, color_socket);
902       }
903       else {
904         transp_node->locx = 0.5f * (fromnode->locx + tonode->locx);
905         transp_node->locy = 0.5f * (fromnode->locy + tonode->locy);
906
907         nodeAddLink(ntree, fromnode, fromsock, transp_node, color_socket);
908       }
909
910       /* Link to input and material output node. */
911       nodeAddLink(ntree, transp_node, transp_socket, tonode, tosock);
912
913       need_update = true;
914     }
915   }
916
917   if (need_update) {
918     ntreeUpdateTree(NULL, ntree);
919   }
920 }
921
922 static void do_versions_local_collection_bits_set(LayerCollection *layer_collection)
923 {
924   layer_collection->local_collections_bits = ~(0);
925   LISTBASE_FOREACH (LayerCollection *, child, &layer_collection->layer_collections) {
926     do_versions_local_collection_bits_set(child);
927   }
928 }
929
930 static void do_version_curvemapping_flag_extend_extrapolate(CurveMapping *cumap)
931 {
932   if (cumap == NULL) {
933     return;
934   }
935
936 #define CUMA_EXTEND_EXTRAPOLATE_OLD 1
937   for (int curve_map_index = 0; curve_map_index < 4; curve_map_index++) {
938     CurveMap *cuma = &cumap->cm[curve_map_index];
939     if (cuma->flag & CUMA_EXTEND_EXTRAPOLATE_OLD) {
940       cumap->flag |= CUMA_EXTEND_EXTRAPOLATE;
941       return;
942     }
943   }
944 #undef CUMA_EXTEND_EXTRAPOLATE_OLD
945 }
946
947 /* Util version to walk over all CurveMappings in the given `bmain` */
948 static void do_version_curvemapping_walker(Main *bmain, void (*callback)(CurveMapping *cumap))
949 {
950   LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
951     callback(&scene->r.mblur_shutter_curve);
952
953     if (scene->view_settings.curve_mapping) {
954       callback(scene->view_settings.curve_mapping);
955     }
956
957     if (scene->ed != NULL) {
958       LISTBASE_FOREACH (Sequence *, seq, &scene->ed->seqbase) {
959         LISTBASE_FOREACH (SequenceModifierData *, smd, &seq->modifiers) {
960           const SequenceModifierTypeInfo *smti = BKE_sequence_modifier_type_info_get(smd->type);
961
962           if (smti) {
963             if (smd->type == seqModifierType_Curves) {
964               CurvesModifierData *cmd = (CurvesModifierData *)smd;
965               callback(&cmd->curve_mapping);
966             }
967             else if (smd->type == seqModifierType_HueCorrect) {
968               HueCorrectModifierData *hcmd = (HueCorrectModifierData *)smd;
969               callback(&hcmd->curve_mapping);
970             }
971           }
972         }
973       }
974     }
975
976     // toolsettings
977     ToolSettings *ts = scene->toolsettings;
978     if (ts->vpaint) {
979       callback(ts->vpaint->paint.cavity_curve);
980     }
981     if (ts->wpaint) {
982       callback(ts->wpaint->paint.cavity_curve);
983     }
984     if (ts->sculpt) {
985       callback(ts->sculpt->paint.cavity_curve);
986     }
987     if (ts->uvsculpt) {
988       callback(ts->uvsculpt->paint.cavity_curve);
989     }
990     if (ts->gp_paint) {
991       callback(ts->gp_paint->paint.cavity_curve);
992     }
993     if (ts->gp_interpolate.custom_ipo) {
994       callback(ts->gp_interpolate.custom_ipo);
995     }
996     if (ts->gp_sculpt.cur_falloff) {
997       callback(ts->gp_sculpt.cur_falloff);
998     }
999     if (ts->gp_sculpt.cur_primitive) {
1000       callback(ts->gp_sculpt.cur_primitive);
1001     }
1002     callback(ts->imapaint.paint.cavity_curve);
1003   }
1004
1005   FOREACH_NODETREE_BEGIN (bmain, node_tree, id) {
1006     LISTBASE_FOREACH (bNode *, node, &node_tree->nodes) {
1007       if (ELEM(node->type,
1008                SH_NODE_CURVE_VEC,
1009                SH_NODE_CURVE_RGB,
1010                CMP_NODE_CURVE_VEC,
1011                CMP_NODE_CURVE_RGB,
1012                CMP_NODE_TIME,
1013                CMP_NODE_HUECORRECT,
1014                TEX_NODE_CURVE_RGB,
1015                TEX_NODE_CURVE_TIME)) {
1016         callback((CurveMapping *)node->storage);
1017       }
1018     }
1019   }
1020   FOREACH_NODETREE_END;
1021
1022   LISTBASE_FOREACH (Light *, light, &bmain->lights) {
1023     if (light->curfalloff) {
1024       callback(light->curfalloff);
1025     }
1026   }
1027
1028   LISTBASE_FOREACH (Brush *, brush, &bmain->brushes) {
1029     if (brush->curve) {
1030       callback(brush->curve);
1031     }
1032     if (brush->gpencil_settings) {
1033       if (brush->gpencil_settings->curve_sensitivity) {
1034         callback(brush->gpencil_settings->curve_sensitivity);
1035       }
1036       if (brush->gpencil_settings->curve_strength) {
1037         callback(brush->gpencil_settings->curve_strength);
1038       }
1039       if (brush->gpencil_settings->curve_jitter) {
1040         callback(brush->gpencil_settings->curve_jitter);
1041       }
1042     }
1043   }
1044
1045   LISTBASE_FOREACH (ParticleSettings *, part, &bmain->particles) {
1046     if (part->clumpcurve) {
1047       callback(part->clumpcurve);
1048     }
1049     if (part->roughcurve) {
1050       callback(part->roughcurve);
1051     }
1052     if (part->twistcurve) {
1053       callback(part->twistcurve);
1054     }
1055   }
1056
1057   /* Object */
1058   LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
1059     /* Object modifiers */
1060     LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
1061       if (md->type == eModifierType_Hook) {
1062         HookModifierData *hmd = (HookModifierData *)md;
1063
1064         if (hmd->curfalloff) {
1065           callback(hmd->curfalloff);
1066         }
1067       }
1068       else if (md->type == eModifierType_Warp) {
1069         WarpModifierData *tmd = (WarpModifierData *)md;
1070         if (tmd->curfalloff) {
1071           callback(tmd->curfalloff);
1072         }
1073       }
1074       else if (md->type == eModifierType_WeightVGEdit) {
1075         WeightVGEditModifierData *wmd = (WeightVGEditModifierData *)md;
1076
1077         if (wmd->cmap_curve) {
1078           callback(wmd->cmap_curve);
1079         }
1080       }
1081     }
1082     /* Grease pencil modifiers */
1083     LISTBASE_FOREACH (ModifierData *, md, &ob->greasepencil_modifiers) {
1084       if (md->type == eGpencilModifierType_Thick) {
1085         ThickGpencilModifierData *gpmd = (ThickGpencilModifierData *)md;
1086
1087         if (gpmd->curve_thickness) {
1088           callback(gpmd->curve_thickness);
1089         }
1090       }
1091       else if (md->type == eGpencilModifierType_Hook) {
1092         HookGpencilModifierData *gpmd = (HookGpencilModifierData *)md;
1093
1094         if (gpmd->curfalloff) {
1095           callback(gpmd->curfalloff);
1096         }
1097       }
1098       else if (md->type == eGpencilModifierType_Noise) {
1099         NoiseGpencilModifierData *gpmd = (NoiseGpencilModifierData *)md;
1100
1101         if (gpmd->curve_intensity) {
1102           callback(gpmd->curve_intensity);
1103         }
1104       }
1105       else if (md->type == eGpencilModifierType_Tint) {
1106         TintGpencilModifierData *gpmd = (TintGpencilModifierData *)md;
1107
1108         if (gpmd->curve_intensity) {
1109           callback(gpmd->curve_intensity);
1110         }
1111       }
1112       else if (md->type == eGpencilModifierType_Smooth) {
1113         SmoothGpencilModifierData *gpmd = (SmoothGpencilModifierData *)md;
1114
1115         if (gpmd->curve_intensity) {
1116           callback(gpmd->curve_intensity);
1117         }
1118       }
1119       else if (md->type == eGpencilModifierType_Color) {
1120         ColorGpencilModifierData *gpmd = (ColorGpencilModifierData *)md;
1121
1122         if (gpmd->curve_intensity) {
1123           callback(gpmd->curve_intensity);
1124         }
1125       }
1126       else if (md->type == eGpencilModifierType_Opacity) {
1127         OpacityGpencilModifierData *gpmd = (OpacityGpencilModifierData *)md;
1128
1129         if (gpmd->curve_intensity) {
1130           callback(gpmd->curve_intensity);
1131         }
1132       }
1133     }
1134   }
1135
1136   /* Free Style */
1137   LISTBASE_FOREACH (struct FreestyleLineStyle *, linestyle, &bmain->linestyles) {
1138     LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->alpha_modifiers) {
1139       switch (m->type) {
1140         case LS_MODIFIER_ALONG_STROKE:
1141           callback(((LineStyleAlphaModifier_AlongStroke *)m)->curve);
1142           break;
1143         case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1144           callback(((LineStyleAlphaModifier_DistanceFromCamera *)m)->curve);
1145           break;
1146         case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1147           callback(((LineStyleAlphaModifier_DistanceFromObject *)m)->curve);
1148           break;
1149         case LS_MODIFIER_MATERIAL:
1150           callback(((LineStyleAlphaModifier_Material *)m)->curve);
1151           break;
1152         case LS_MODIFIER_TANGENT:
1153           callback(((LineStyleAlphaModifier_Tangent *)m)->curve);
1154           break;
1155         case LS_MODIFIER_NOISE:
1156           callback(((LineStyleAlphaModifier_Noise *)m)->curve);
1157           break;
1158         case LS_MODIFIER_CREASE_ANGLE:
1159           callback(((LineStyleAlphaModifier_CreaseAngle *)m)->curve);
1160           break;
1161         case LS_MODIFIER_CURVATURE_3D:
1162           callback(((LineStyleAlphaModifier_Curvature_3D *)m)->curve);
1163           break;
1164       }
1165     }
1166
1167     LISTBASE_FOREACH (LineStyleModifier *, m, &linestyle->thickness_modifiers) {
1168       switch (m->type) {
1169         case LS_MODIFIER_ALONG_STROKE:
1170           callback(((LineStyleThicknessModifier_AlongStroke *)m)->curve);
1171           break;
1172         case LS_MODIFIER_DISTANCE_FROM_CAMERA:
1173           callback(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);
1174           break;
1175         case LS_MODIFIER_DISTANCE_FROM_OBJECT:
1176           callback(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);
1177           break;
1178         case LS_MODIFIER_MATERIAL:
1179           callback(((LineStyleThicknessModifier_Material *)m)->curve);
1180           break;
1181         case LS_MODIFIER_TANGENT:
1182           callback(((LineStyleThicknessModifier_Tangent *)m)->curve);
1183           break;
1184         case LS_MODIFIER_CREASE_ANGLE:
1185           callback(((LineStyleThicknessModifier_CreaseAngle *)m)->curve);
1186           break;
1187         case LS_MODIFIER_CURVATURE_3D:
1188           callback(((LineStyleThicknessModifier_Curvature_3D *)m)->curve);
1189           break;
1190       }
1191     }
1192   }
1193 }
1194
1195 static void do_version_fcurve_hide_viewport_fix(struct ID *UNUSED(id),
1196                                                 struct FCurve *fcu,
1197                                                 void *UNUSED(user_data))
1198 {
1199   if (strcmp(fcu->rna_path, "hide")) {
1200     return;
1201   }
1202
1203   MEM_freeN(fcu->rna_path);
1204   fcu->rna_path = BLI_strdupn("hide_viewport", 13);
1205 }
1206
1207 void do_versions_after_linking_280(Main *bmain, ReportList *UNUSED(reports))
1208 {
1209   bool use_collection_compat_28 = true;
1210
1211   if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1212     use_collection_compat_28 = false;
1213
1214     /* Convert group layer visibility flags to hidden nested collection. */
1215     for (Collection *collection = bmain->collections.first; collection;
1216          collection = collection->id.next) {
1217       /* Add fake user for all existing groups. */
1218       id_fake_user_set(&collection->id);
1219
1220       if (collection->flag & (COLLECTION_RESTRICT_VIEWPORT | COLLECTION_RESTRICT_RENDER)) {
1221         continue;
1222       }
1223
1224       Collection *hidden_collection_array[20] = {NULL};
1225       for (CollectionObject *cob = collection->gobject.first, *cob_next = NULL; cob;
1226            cob = cob_next) {
1227         cob_next = cob->next;
1228         Object *ob = cob->ob;
1229
1230         if (!(ob->lay & collection->layer)) {
1231           /* Find or create hidden collection matching object's first layer. */
1232           Collection **collection_hidden = NULL;
1233           int coll_idx = 0;
1234           for (; coll_idx < 20; coll_idx++) {
1235             if (ob->lay & (1 << coll_idx)) {
1236               collection_hidden = &hidden_collection_array[coll_idx];
1237               break;
1238             }
1239           }
1240           BLI_assert(collection_hidden != NULL);
1241
1242           if (*collection_hidden == NULL) {
1243             char name[MAX_ID_NAME];
1244             BLI_snprintf(name, sizeof(name), DATA_("Hidden %d"), coll_idx + 1);
1245             *collection_hidden = BKE_collection_add(bmain, collection, name);
1246             (*collection_hidden)->flag |= COLLECTION_RESTRICT_VIEWPORT |
1247                                           COLLECTION_RESTRICT_RENDER;
1248           }
1249
1250           BKE_collection_object_add(bmain, *collection_hidden, ob);
1251           BKE_collection_object_remove(bmain, collection, ob, true);
1252         }
1253       }
1254     }
1255
1256     /* We need to assign lib pointer to generated hidden collections *after* all have been
1257      * created, otherwise we'll end up with several data-blocks sharing same name/library,
1258      * which is FORBIDDEN! Note: we need this to be recursive, since a child collection may be
1259      * sorted before its parent in bmain. */
1260     for (Collection *collection = bmain->collections.first; collection != NULL;
1261          collection = collection->id.next) {
1262       do_version_collection_propagate_lib_to_children(collection);
1263     }
1264
1265     /* Convert layers to collections. */
1266     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1267       do_version_layers_to_collections(bmain, scene);
1268     }
1269   }
1270
1271   if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1272     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1273       /* same render-layer as do_version_workspaces_after_lib_link will activate,
1274        * so same layer as BKE_view_layer_default_view would return */
1275       ViewLayer *layer = screen->scene->view_layers.first;
1276
1277       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1278         LISTBASE_FOREACH (SpaceLink *, space, &area->spacedata) {
1279           if (space->spacetype == SPACE_OUTLINER) {
1280             SpaceOutliner *soutliner = (SpaceOutliner *)space;
1281
1282             soutliner->outlinevis = SO_VIEW_LAYER;
1283
1284             if (BLI_listbase_count_at_most(&layer->layer_collections, 2) == 1) {
1285               if (soutliner->treestore == NULL) {
1286                 soutliner->treestore = BLI_mempool_create(
1287                     sizeof(TreeStoreElem), 1, 512, BLI_MEMPOOL_ALLOW_ITER);
1288               }
1289
1290               /* Create a tree store element for the collection. This is normally
1291                * done in check_persistent (outliner_tree.c), but we need to access
1292                * it here :/ (expand element if it's the only one) */
1293               TreeStoreElem *tselem = BLI_mempool_calloc(soutliner->treestore);
1294               tselem->type = TSE_LAYER_COLLECTION;
1295               tselem->id = layer->layer_collections.first;
1296               tselem->nr = tselem->used = 0;
1297               tselem->flag &= ~TSE_CLOSED;
1298             }
1299           }
1300         }
1301       }
1302     }
1303   }
1304
1305   if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1306     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1307       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1308         LISTBASE_FOREACH (SpaceLink *, space, &area->spacedata) {
1309           if (space->spacetype == SPACE_IMAGE) {
1310             SpaceImage *sima = (SpaceImage *)space;
1311             if ((sima) && (sima->gpd)) {
1312               sima->gpd->flag |= GP_DATA_ANNOTATIONS;
1313               do_versions_fix_annotations(sima->gpd);
1314             }
1315           }
1316           if (space->spacetype == SPACE_CLIP) {
1317             SpaceClip *spclip = (SpaceClip *)space;
1318             MovieClip *clip = spclip->clip;
1319             if ((clip) && (clip->gpd)) {
1320               clip->gpd->flag |= GP_DATA_ANNOTATIONS;
1321               do_versions_fix_annotations(clip->gpd);
1322             }
1323           }
1324         }
1325       }
1326     }
1327   }
1328
1329   /* New workspace design */
1330   if (!MAIN_VERSION_ATLEAST(bmain, 280, 1)) {
1331     do_version_workspaces_after_lib_link(bmain);
1332   }
1333
1334   if (!MAIN_VERSION_ATLEAST(bmain, 280, 2)) {
1335     /* Cleanup any remaining SceneRenderLayer data for files that were created
1336      * with Blender 2.8 before the SceneRenderLayer > RenderLayer refactor. */
1337     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1338       LISTBASE_FOREACH (SceneRenderLayer *, srl, &scene->r.layers) {
1339         if (srl->prop) {
1340           IDP_FreeProperty(srl->prop);
1341         }
1342         BKE_freestyle_config_free(&srl->freestyleConfig, true);
1343       }
1344       BLI_freelistN(&scene->r.layers);
1345     }
1346   }
1347
1348   if (!MAIN_VERSION_ATLEAST(bmain, 280, 3)) {
1349     /* Due to several changes to particle RNA and draw code particles from older files may
1350      * no longer be visible.
1351      * Here we correct this by setting a default draw size for those files. */
1352     for (Object *object = bmain->objects.first; object; object = object->id.next) {
1353       LISTBASE_FOREACH (ParticleSystem *, psys, &object->particlesystem) {
1354         if (psys->part->draw_size == 0.0f) {
1355           psys->part->draw_size = 0.1f;
1356         }
1357       }
1358     }
1359   }
1360
1361   if (!MAIN_VERSION_ATLEAST(bmain, 280, 4)) {
1362     for (Object *object = bmain->objects.first; object; object = object->id.next) {
1363       if (object->particlesystem.first) {
1364         object->duplicator_visibility_flag = OB_DUPLI_FLAG_VIEWPORT;
1365         LISTBASE_FOREACH (ParticleSystem *, psys, &object->particlesystem) {
1366           if (psys->part->draw & PART_DRAW_EMITTER) {
1367             object->duplicator_visibility_flag |= OB_DUPLI_FLAG_RENDER;
1368             break;
1369           }
1370         }
1371       }
1372       else if (object->transflag & OB_DUPLI) {
1373         object->duplicator_visibility_flag = OB_DUPLI_FLAG_VIEWPORT;
1374       }
1375       else {
1376         object->duplicator_visibility_flag = OB_DUPLI_FLAG_VIEWPORT | OB_DUPLI_FLAG_RENDER;
1377       }
1378     }
1379
1380     /* Cleanup deprecated flag from particlesettings data-blocks. */
1381     for (ParticleSettings *part = bmain->particles.first; part; part = part->id.next) {
1382       part->draw &= ~PART_DRAW_EMITTER;
1383     }
1384   }
1385
1386   /* SpaceTime & SpaceLogic removal/replacing */
1387   if (!MAIN_VERSION_ATLEAST(bmain, 280, 9)) {
1388     const wmWindowManager *wm = bmain->wm.first;
1389     const Scene *scene = bmain->scenes.first;
1390
1391     if (wm != NULL) {
1392       /* Action editors need a scene for creation. First, update active
1393        * screens using the active scene of the window they're displayed in.
1394        * Next, update remaining screens using first scene in main listbase. */
1395
1396       LISTBASE_FOREACH (wmWindow *, win, &wm->windows) {
1397         const bScreen *screen = BKE_workspace_active_screen_get(win->workspace_hook);
1398         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1399           if (ELEM(area->butspacetype, SPACE_TIME, SPACE_LOGIC)) {
1400             do_version_area_change_space_to_space_action(area, win->scene);
1401
1402             /* Don't forget to unset! */
1403             area->butspacetype = SPACE_EMPTY;
1404           }
1405         }
1406       }
1407     }
1408     if (scene != NULL) {
1409       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1410         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1411           if (ELEM(area->butspacetype, SPACE_TIME, SPACE_LOGIC)) {
1412             /* Areas that were already handled won't be handled again */
1413             do_version_area_change_space_to_space_action(area, scene);
1414
1415             /* Don't forget to unset! */
1416             area->butspacetype = SPACE_EMPTY;
1417           }
1418         }
1419       }
1420     }
1421   }
1422
1423 #ifdef USE_COLLECTION_COMPAT_28
1424   if (use_collection_compat_28 && !MAIN_VERSION_ATLEAST(bmain, 280, 14)) {
1425     for (Collection *group = bmain->collections.first; group; group = group->id.next) {
1426       do_version_group_collection_to_collection(bmain, group);
1427     }
1428
1429     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1430       do_version_scene_collection_to_collection(bmain, scene);
1431     }
1432   }
1433 #endif
1434
1435   /* Update Curve object Shape Key data layout to include the Radius property */
1436   if (!MAIN_VERSION_ATLEAST(bmain, 280, 23)) {
1437     for (Curve *cu = bmain->curves.first; cu; cu = cu->id.next) {
1438       if (!cu->key || cu->key->elemsize != sizeof(float[4])) {
1439         continue;
1440       }
1441
1442       cu->key->elemstr[0] = 3; /*KEYELEM_ELEM_SIZE_CURVE*/
1443       cu->key->elemsize = sizeof(float[3]);
1444
1445       int new_count = BKE_keyblock_curve_element_count(&cu->nurb);
1446
1447       LISTBASE_FOREACH (KeyBlock *, block, &cu->key->block) {
1448         int old_count = block->totelem;
1449         void *old_data = block->data;
1450
1451         if (!old_data || old_count <= 0) {
1452           continue;
1453         }
1454
1455         block->totelem = new_count;
1456         block->data = MEM_callocN(sizeof(float[3]) * new_count, __func__);
1457
1458         float *oldptr = old_data;
1459         float(*newptr)[3] = block->data;
1460
1461         LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
1462           if (nu->bezt) {
1463             BezTriple *bezt = nu->bezt;
1464
1465             for (int a = 0; a < nu->pntsu; a++, bezt++) {
1466               if ((old_count -= 3) < 0) {
1467                 memcpy(newptr, bezt->vec, sizeof(float[3][3]));
1468                 newptr[3][0] = bezt->tilt;
1469               }
1470               else {
1471                 memcpy(newptr, oldptr, sizeof(float[3][4]));
1472               }
1473
1474               newptr[3][1] = bezt->radius;
1475
1476               oldptr += 3 * 4;
1477               newptr += 4; /*KEYELEM_ELEM_LEN_BEZTRIPLE*/
1478             }
1479           }
1480           else if (nu->bp) {
1481             BPoint *bp = nu->bp;
1482
1483             for (int a = 0; a < nu->pntsu * nu->pntsv; a++, bp++) {
1484               if (--old_count < 0) {
1485                 copy_v3_v3(newptr[0], bp->vec);
1486                 newptr[1][0] = bp->tilt;
1487               }
1488               else {
1489                 memcpy(newptr, oldptr, sizeof(float[4]));
1490               }
1491
1492               newptr[1][1] = bp->radius;
1493
1494               oldptr += 4;
1495               newptr += 2; /*KEYELEM_ELEM_LEN_BPOINT*/
1496             }
1497           }
1498         }
1499
1500         MEM_freeN(old_data);
1501       }
1502     }
1503   }
1504
1505   /* Move B-Bone custom handle settings from bPoseChannel to Bone. */
1506   if (!MAIN_VERSION_ATLEAST(bmain, 280, 25)) {
1507     for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
1508       bArmature *arm = ob->data;
1509
1510       /* If it is an armature from the same file. */
1511       if (ob->pose && arm && arm->id.lib == ob->id.lib) {
1512         bool rebuild = false;
1513
1514         LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
1515           /* If the 2.7 flag is enabled, processing is needed. */
1516           if (pchan->bone && (pchan->bboneflag & PCHAN_BBONE_CUSTOM_HANDLES)) {
1517             /* If the settings in the Bone are not set, copy. */
1518             if (pchan->bone->bbone_prev_type == BBONE_HANDLE_AUTO &&
1519                 pchan->bone->bbone_next_type == BBONE_HANDLE_AUTO &&
1520                 pchan->bone->bbone_prev == NULL && pchan->bone->bbone_next == NULL) {
1521               pchan->bone->bbone_prev_type = (pchan->bboneflag & PCHAN_BBONE_CUSTOM_START_REL) ?
1522                                                  BBONE_HANDLE_RELATIVE :
1523                                                  BBONE_HANDLE_ABSOLUTE;
1524               pchan->bone->bbone_next_type = (pchan->bboneflag & PCHAN_BBONE_CUSTOM_END_REL) ?
1525                                                  BBONE_HANDLE_RELATIVE :
1526                                                  BBONE_HANDLE_ABSOLUTE;
1527
1528               if (pchan->bbone_prev) {
1529                 pchan->bone->bbone_prev = pchan->bbone_prev->bone;
1530               }
1531               if (pchan->bbone_next) {
1532                 pchan->bone->bbone_next = pchan->bbone_next->bone;
1533               }
1534             }
1535
1536             rebuild = true;
1537             pchan->bboneflag = 0;
1538           }
1539         }
1540
1541         /* Tag pose rebuild for all objects that use this armature. */
1542         if (rebuild) {
1543           for (Object *ob2 = bmain->objects.first; ob2; ob2 = ob2->id.next) {
1544             if (ob2->pose && ob2->data == arm) {
1545               ob2->pose->flag |= POSE_RECALC;
1546             }
1547           }
1548         }
1549       }
1550     }
1551   }
1552
1553   if (!MAIN_VERSION_ATLEAST(bmain, 280, 30)) {
1554     for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
1555       if (brush->gpencil_settings != NULL) {
1556         brush->gpencil_tool = brush->gpencil_settings->brush_type;
1557       }
1558     }
1559     BKE_paint_toolslots_init_from_main(bmain);
1560   }
1561
1562   if (!MAIN_VERSION_ATLEAST(bmain, 280, 38)) {
1563     /* Ensure we get valid rigidbody object/constraint data in relevant collections' objects.
1564      */
1565     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1566       RigidBodyWorld *rbw = scene->rigidbody_world;
1567
1568       if (rbw == NULL) {
1569         continue;
1570       }
1571
1572       BKE_rigidbody_objects_collection_validate(scene, rbw);
1573       BKE_rigidbody_constraints_collection_validate(scene, rbw);
1574     }
1575   }
1576
1577   if (!MAIN_VERSION_ATLEAST(bmain, 280, 69)) {
1578     /* Unify DOF settings (EEVEE part only) */
1579     const int SCE_EEVEE_DOF_ENABLED = (1 << 7);
1580     LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
1581       if (STREQ(scene->r.engine, RE_engine_id_BLENDER_EEVEE)) {
1582         if (scene->eevee.flag & SCE_EEVEE_DOF_ENABLED) {
1583           Object *cam_ob = scene->camera;
1584           if (cam_ob && cam_ob->type == OB_CAMERA) {
1585             Camera *cam = cam_ob->data;
1586             cam->dof.flag |= CAM_DOF_ENABLED;
1587           }
1588         }
1589       }
1590     }
1591
1592     LISTBASE_FOREACH (Camera *, camera, &bmain->cameras) {
1593       camera->dof.focus_object = camera->dof_ob;
1594       camera->dof.focus_distance = camera->dof_distance;
1595       camera->dof.aperture_fstop = camera->gpu_dof.fstop;
1596       camera->dof.aperture_rotation = camera->gpu_dof.rotation;
1597       camera->dof.aperture_ratio = camera->gpu_dof.ratio;
1598       camera->dof.aperture_blades = camera->gpu_dof.num_blades;
1599       camera->dof_ob = NULL;
1600     }
1601   }
1602
1603   if (!MAIN_VERSION_ATLEAST(bmain, 281, 2)) {
1604     /* Replace Multiply and Additive blend mode by Alpha Blend
1605      * now that we use dualsource blending. */
1606     /* We take care of doing only nodetrees that are always part of materials
1607      * with old blending modes. */
1608     for (Material *ma = bmain->materials.first; ma; ma = ma->id.next) {
1609       bNodeTree *ntree = ma->nodetree;
1610       if (ma->blend_method == 1 /* MA_BM_ADD */) {
1611         if (ma->use_nodes) {
1612           do_versions_material_convert_legacy_blend_mode(ntree, 1 /* MA_BM_ADD */);
1613         }
1614         ma->blend_method = MA_BM_BLEND;
1615       }
1616       else if (ma->blend_method == 2 /* MA_BM_MULTIPLY */) {
1617         if (ma->use_nodes) {
1618           do_versions_material_convert_legacy_blend_mode(ntree, 2 /* MA_BM_MULTIPLY */);
1619         }
1620         ma->blend_method = MA_BM_BLEND;
1621       }
1622     }
1623
1624     /* Update all ruler layers to set new flag. */
1625     LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
1626       bGPdata *gpd = scene->gpd;
1627       if (gpd == NULL) {
1628         continue;
1629       }
1630       LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
1631         if (STREQ(gpl->info, "RulerData3D")) {
1632           gpl->flag |= GP_LAYER_IS_RULER;
1633           break;
1634         }
1635       }
1636     }
1637
1638     /* This versioning could probably be done only on earlier versions, not sure however
1639      * which exact version fully deprecated tessfaces, so think we can keep that one here, no
1640      * harm to be expected anyway for being over-conservative. */
1641     for (Mesh *me = bmain->meshes.first; me != NULL; me = me->id.next) {
1642       /*check if we need to convert mfaces to mpolys*/
1643       if (me->totface && !me->totpoly) {
1644         /* temporarily switch main so that reading from
1645          * external CustomData works */
1646         Main *gmain = G_MAIN;
1647         G_MAIN = bmain;
1648
1649         BKE_mesh_do_versions_convert_mfaces_to_mpolys(me);
1650
1651         G_MAIN = gmain;
1652       }
1653
1654       /* Deprecated, only kept for conversion. */
1655       BKE_mesh_tessface_clear(me);
1656
1657       /* Moved from do_versions because we need updated polygons for calculating normals. */
1658       if (MAIN_VERSION_OLDER(bmain, 256, 6)) {
1659         BKE_mesh_calc_normals(me);
1660       }
1661     }
1662   }
1663
1664   if (!MAIN_VERSION_ATLEAST(bmain, 282, 2)) {
1665     /* Init all Vertex/Sculpt and Weight Paint brushes. */
1666     Brush *brush;
1667     Material *ma;
1668     /* Pen Soft brush. */
1669     brush = (Brush *)rename_id_for_versioning(bmain, ID_BR, "Draw Soft", "Pencil Soft");
1670     if (brush) {
1671       brush->gpencil_settings->icon_id = GP_BRUSH_ICON_PEN;
1672     }
1673     rename_id_for_versioning(bmain, ID_BR, "Draw Pencil", "Pencil");
1674     rename_id_for_versioning(bmain, ID_BR, "Draw Pen", "Pen");
1675     rename_id_for_versioning(bmain, ID_BR, "Draw Ink", "Ink Pen");
1676     rename_id_for_versioning(bmain, ID_BR, "Draw Noise", "Ink Pen Rough");
1677     rename_id_for_versioning(bmain, ID_BR, "Draw Marker", "Marker Bold");
1678     rename_id_for_versioning(bmain, ID_BR, "Draw Block", "Marker Chisel");
1679
1680     ma = BLI_findstring(&bmain->materials, "Black", offsetof(ID, name) + 2);
1681     if (ma && ma->gp_style) {
1682       rename_id_for_versioning(bmain, ID_MA, "Black", "Solid Stroke");
1683     }
1684     ma = BLI_findstring(&bmain->materials, "Red", offsetof(ID, name) + 2);
1685     if (ma && ma->gp_style) {
1686       rename_id_for_versioning(bmain, ID_MA, "Red", "Squares Stroke");
1687     }
1688     ma = BLI_findstring(&bmain->materials, "Grey", offsetof(ID, name) + 2);
1689     if (ma && ma->gp_style) {
1690       rename_id_for_versioning(bmain, ID_MA, "Grey", "Solid Fill");
1691     }
1692     ma = BLI_findstring(&bmain->materials, "Black Dots", offsetof(ID, name) + 2);
1693     if (ma && ma->gp_style) {
1694       rename_id_for_versioning(bmain, ID_MA, "Black Dots", "Dots Stroke");
1695     }
1696
1697     /* Remove useless Fill Area.001 brush. */
1698     brush = BLI_findstring(&bmain->brushes, "Fill Area.001", offsetof(ID, name) + 2);
1699     if (brush) {
1700       BKE_id_delete(bmain, brush);
1701     }
1702
1703     brush = BLI_findstring(&bmain->brushes, "Pencil", offsetof(ID, name) + 2);
1704
1705     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1706       ToolSettings *ts = scene->toolsettings;
1707
1708       BKE_brush_gpencil_vertex_presets(bmain, ts);
1709       BKE_brush_gpencil_sculpt_presets(bmain, ts);
1710       BKE_brush_gpencil_weight_presets(bmain, ts);
1711
1712       /* Ensure new Paint modes. */
1713       BKE_paint_ensure_from_paintmode(scene, PAINT_MODE_GPENCIL);
1714       BKE_paint_ensure_from_paintmode(scene, PAINT_MODE_VERTEX_GPENCIL);
1715       BKE_paint_ensure_from_paintmode(scene, PAINT_MODE_SCULPT_GPENCIL);
1716       BKE_paint_ensure_from_paintmode(scene, PAINT_MODE_WEIGHT_GPENCIL);
1717
1718       /* Set default Draw brush. */
1719       if (brush != NULL) {
1720         Paint *paint = &ts->gp_paint->paint;
1721         BKE_paint_brush_set(paint, brush);
1722         /* Enable cursor by default. */
1723         paint->flags |= PAINT_SHOW_BRUSH;
1724       }
1725       /* Ensure Palette by default. */
1726       BKE_gpencil_palette_ensure(bmain, scene);
1727     }
1728   }
1729
1730   if (!MAIN_VERSION_ATLEAST(bmain, 283, 8)) {
1731
1732     /* During development of Blender 2.80 the "Object.hide" property was
1733      * removed, and reintroduced in 5e968a996a53 as "Object.hide_viewport". */
1734     LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
1735       BKE_fcurves_id_cb(&ob->id, do_version_fcurve_hide_viewport_fix, NULL);
1736     }
1737
1738     /* Reset all grease pencil brushes. */
1739     LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
1740       BKE_brush_gpencil_paint_presets(bmain, scene->toolsettings);
1741       BKE_brush_gpencil_sculpt_presets(bmain, scene->toolsettings);
1742       BKE_brush_gpencil_weight_presets(bmain, scene->toolsettings);
1743       BKE_brush_gpencil_vertex_presets(bmain, scene->toolsettings);
1744
1745       /* Ensure new Paint modes. */
1746       BKE_paint_ensure_from_paintmode(scene, PAINT_MODE_VERTEX_GPENCIL);
1747       BKE_paint_ensure_from_paintmode(scene, PAINT_MODE_SCULPT_GPENCIL);
1748       BKE_paint_ensure_from_paintmode(scene, PAINT_MODE_WEIGHT_GPENCIL);
1749     }
1750   }
1751
1752   /**
1753    * Versioning code until next subversion bump goes here.
1754    *
1755    * \note Be sure to check when bumping the version:
1756    * - #blo_do_versions_280 in this file.
1757    * - "versioning_userdef.c", #BLO_version_defaults_userpref_blend
1758    * - "versioning_userdef.c", #do_versions_theme
1759    *
1760    * \note Keep this message at the bottom of the function.
1761    */
1762   {
1763     /* Keep this block, even when empty. */
1764   }
1765 }
1766
1767 /* NOTE: This version patch is intended for versions < 2.52.2,
1768  * but was initially introduced in 2.27 already.
1769  * But in 2.79 another case generating non-unique names was discovered
1770  * (see T55668, involving Meta strips). */
1771 static void do_versions_seq_unique_name_all_strips(Scene *sce, ListBase *seqbasep)
1772 {
1773   for (Sequence *seq = seqbasep->first; seq != NULL; seq = seq->next) {
1774     BKE_sequence_base_unique_name_recursive(&sce->ed->seqbase, seq);
1775     if (seq->seqbase.first != NULL) {
1776       do_versions_seq_unique_name_all_strips(sce, &seq->seqbase);
1777     }
1778   }
1779 }
1780
1781 static void do_versions_seq_set_cache_defaults(Editing *ed)
1782 {
1783   ed->cache_flag = SEQ_CACHE_STORE_FINAL_OUT;
1784   ed->cache_flag |= SEQ_CACHE_VIEW_FINAL_OUT;
1785   ed->cache_flag |= SEQ_CACHE_VIEW_ENABLE;
1786   ed->recycle_max_cost = 10.0f;
1787 }
1788
1789 void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *bmain)
1790 {
1791   bool use_collection_compat_28 = true;
1792
1793   if (!MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
1794     use_collection_compat_28 = false;
1795
1796     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1797       scene->r.gauss = 1.5f;
1798     }
1799   }
1800
1801   if (!MAIN_VERSION_ATLEAST(bmain, 280, 1)) {
1802     if (!DNA_struct_elem_find(fd->filesdna, "Light", "float", "bleedexp")) {
1803       for (Light *la = bmain->lights.first; la; la = la->id.next) {
1804         la->bleedexp = 2.5f;
1805       }
1806     }
1807
1808     if (!DNA_struct_elem_find(fd->filesdna, "GPUDOFSettings", "float", "ratio")) {
1809       for (Camera *ca = bmain->cameras.first; ca; ca = ca->id.next) {
1810         ca->gpu_dof.ratio = 1.0f;
1811       }
1812     }
1813
1814     /* MTexPoly now removed. */
1815     if (DNA_struct_find(fd->filesdna, "MTexPoly")) {
1816       for (Mesh *me = bmain->meshes.first; me; me = me->id.next) {
1817         /* If we have UV's, so this file will have MTexPoly layers too! */
1818         if (me->mloopuv != NULL) {
1819           CustomData_update_typemap(&me->pdata);
1820           CustomData_free_layers(&me->pdata, CD_MTEXPOLY, me->totpoly);
1821           BKE_mesh_update_customdata_pointers(me, false);
1822         }
1823       }
1824     }
1825   }
1826
1827   if (!MAIN_VERSION_ATLEAST(bmain, 280, 2)) {
1828     if (!DNA_struct_elem_find(fd->filesdna, "Light", "float", "cascade_max_dist")) {
1829       for (Light *la = bmain->lights.first; la; la = la->id.next) {
1830         la->cascade_max_dist = 1000.0f;
1831         la->cascade_count = 4;
1832         la->cascade_exponent = 0.8f;
1833         la->cascade_fade = 0.1f;
1834       }
1835     }
1836
1837     if (!DNA_struct_elem_find(fd->filesdna, "Light", "float", "contact_dist")) {
1838       for (Light *la = bmain->lights.first; la; la = la->id.next) {
1839         la->contact_dist = 0.2f;
1840         la->contact_bias = 0.03f;
1841         la->contact_spread = 0.2f;
1842         la->contact_thickness = 0.2f;
1843       }
1844     }
1845
1846     if (!DNA_struct_elem_find(fd->filesdna, "LightProbe", "float", "vis_bias")) {
1847       for (LightProbe *probe = bmain->lightprobes.first; probe; probe = probe->id.next) {
1848         probe->vis_bias = 1.0f;
1849         probe->vis_blur = 0.2f;
1850       }
1851     }
1852
1853     typedef enum eNTreeDoVersionErrors {
1854       NTREE_DOVERSION_NO_ERROR = 0,
1855       NTREE_DOVERSION_NEED_OUTPUT = (1 << 0),
1856       NTREE_DOVERSION_TRANSPARENCY_EMISSION = (1 << 1),
1857     } eNTreeDoVersionErrors;
1858
1859     /* Eevee shader nodes renamed because of the output node system.
1860      * Note that a new output node is not being added here, because it would be overkill
1861      * to handle this case in lib_verify_nodetree.
1862      *
1863      * Also, metallic node is now unified into the principled node. */
1864     eNTreeDoVersionErrors error = NTREE_DOVERSION_NO_ERROR;
1865
1866     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1867       if (ntree->type == NTREE_SHADER) {
1868         LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1869           if (node->type == 194 /* SH_NODE_EEVEE_METALLIC */ &&
1870               STREQ(node->idname, "ShaderNodeOutputMetallic")) {
1871             BLI_strncpy(node->idname, "ShaderNodeEeveeMetallic", sizeof(node->idname));
1872             error |= NTREE_DOVERSION_NEED_OUTPUT;
1873           }
1874
1875           else if (node->type == SH_NODE_EEVEE_SPECULAR &&
1876                    STREQ(node->idname, "ShaderNodeOutputSpecular")) {
1877             BLI_strncpy(node->idname, "ShaderNodeEeveeSpecular", sizeof(node->idname));
1878             error |= NTREE_DOVERSION_NEED_OUTPUT;
1879           }
1880
1881           else if (node->type == 196 /* SH_NODE_OUTPUT_EEVEE_MATERIAL */ &&
1882                    STREQ(node->idname, "ShaderNodeOutputEeveeMaterial")) {
1883             node->type = SH_NODE_OUTPUT_MATERIAL;
1884             BLI_strncpy(node->idname, "ShaderNodeOutputMaterial", sizeof(node->idname));
1885           }
1886
1887           else if (node->type == 194 /* SH_NODE_EEVEE_METALLIC */ &&
1888                    STREQ(node->idname, "ShaderNodeEeveeMetallic")) {
1889             node->type = SH_NODE_BSDF_PRINCIPLED;
1890             BLI_strncpy(node->idname, "ShaderNodeBsdfPrincipled", sizeof(node->idname));
1891             node->custom1 = SHD_GLOSSY_MULTI_GGX;
1892             error |= NTREE_DOVERSION_TRANSPARENCY_EMISSION;
1893           }
1894         }
1895       }
1896     }
1897     FOREACH_NODETREE_END;
1898
1899     if (error & NTREE_DOVERSION_NEED_OUTPUT) {
1900       BKE_report(fd->reports, RPT_ERROR, "Eevee material conversion problem. Error in console");
1901       printf(
1902           "You need to connect Principled and Eevee Specular shader nodes to new material "
1903           "output "
1904           "nodes.\n");
1905     }
1906
1907     if (error & NTREE_DOVERSION_TRANSPARENCY_EMISSION) {
1908       BKE_report(fd->reports, RPT_ERROR, "Eevee material conversion problem. Error in console");
1909       printf(
1910           "You need to combine transparency and emission shaders to the converted Principled "
1911           "shader nodes.\n");
1912     }
1913
1914 #ifdef USE_COLLECTION_COMPAT_28
1915     if (use_collection_compat_28 &&
1916         (DNA_struct_elem_find(fd->filesdna, "ViewLayer", "FreestyleConfig", "freestyle_config") ==
1917          false) &&
1918         DNA_struct_elem_find(fd->filesdna, "Scene", "ListBase", "view_layers")) {
1919       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1920         ViewLayer *view_layer;
1921         for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
1922           view_layer->flag |= VIEW_LAYER_FREESTYLE;
1923           view_layer->layflag = 0x7FFF; /* solid ztra halo edge strand */
1924           view_layer->passflag = SCE_PASS_COMBINED | SCE_PASS_Z;
1925           view_layer->pass_alpha_threshold = 0.5f;
1926           BKE_freestyle_config_init(&view_layer->freestyle_config);
1927         }
1928       }
1929     }
1930 #endif
1931
1932     {
1933       /* Init grease pencil edit line color */
1934       if (!DNA_struct_elem_find(fd->filesdna, "bGPdata", "float", "line_color[4]")) {
1935         for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1936           ARRAY_SET_ITEMS(gpd->line_color, 0.6f, 0.6f, 0.6f, 0.5f);
1937         }
1938       }
1939
1940       /* Init grease pencil pixel size factor */
1941       if (!DNA_struct_elem_find(fd->filesdna, "bGPdata", "float", "pixfactor")) {
1942         for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1943           gpd->pixfactor = GP_DEFAULT_PIX_FACTOR;
1944         }
1945       }
1946
1947       /* Grease pencil multiframe falloff curve */
1948       if (!DNA_struct_elem_find(
1949               fd->filesdna, "GP_Sculpt_Settings", "CurveMapping", "cur_falloff")) {
1950         for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1951           /* sculpt brushes */
1952           GP_Sculpt_Settings *gset = &scene->toolsettings->gp_sculpt;
1953           if ((gset) && (gset->cur_falloff == NULL)) {
1954             gset->cur_falloff = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
1955             BKE_curvemapping_initialize(gset->cur_falloff);
1956             BKE_curvemap_reset(gset->cur_falloff->cm,
1957                                &gset->cur_falloff->clipr,
1958                                CURVE_PRESET_GAUSS,
1959                                CURVEMAP_SLOPE_POSITIVE);
1960           }
1961         }
1962       }
1963     }
1964
1965     /* 2.79 style Maintain Volume mode. */
1966     LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
1967       do_version_constraints_maintain_volume_mode_uniform(&ob->constraints);
1968       if (ob->pose) {
1969         LISTBASE_FOREACH (bPoseChannel *, pchan, &ob->pose->chanbase) {
1970           do_version_constraints_maintain_volume_mode_uniform(&pchan->constraints);
1971         }
1972       }
1973     }
1974   }
1975
1976 #ifdef USE_COLLECTION_COMPAT_28
1977   if (use_collection_compat_28 && !MAIN_VERSION_ATLEAST(bmain, 280, 3)) {
1978     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1979       ViewLayer *view_layer;
1980       for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
1981         do_version_view_layer_visibility(view_layer);
1982       }
1983     }
1984
1985     for (Collection *group = bmain->collections.first; group; group = group->id.next) {
1986       if (group->view_layer != NULL) {
1987         do_version_view_layer_visibility(group->view_layer);
1988       }
1989     }
1990   }
1991 #endif
1992
1993   if (!MAIN_VERSION_ATLEAST(bmain, 280, 3)) {
1994     /* init grease pencil grids and paper */
1995     if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_paper_color[3]")) {
1996       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1997         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
1998           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
1999             if (sl->spacetype == SPACE_VIEW3D) {
2000               View3D *v3d = (View3D *)sl;
2001               v3d->overlay.gpencil_paper_opacity = 0.5f;
2002               v3d->overlay.gpencil_grid_opacity = 0.9f;
2003             }
2004           }
2005         }
2006       }
2007     }
2008   }
2009
2010   if (!MAIN_VERSION_ATLEAST(bmain, 280, 6)) {
2011     if (DNA_struct_elem_find(fd->filesdna, "SpaceOutliner", "int", "filter") == false) {
2012       bScreen *screen;
2013       ScrArea *area;
2014       SpaceLink *sl;
2015
2016       /* Update files using invalid (outdated) outlinevis Outliner values. */
2017       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2018         for (area = screen->areabase.first; area; area = area->next) {
2019           for (sl = area->spacedata.first; sl; sl = sl->next) {
2020             if (sl->spacetype == SPACE_OUTLINER) {
2021               SpaceOutliner *so = (SpaceOutliner *)sl;
2022
2023               if (!ELEM(so->outlinevis,
2024                         SO_SCENES,
2025                         SO_LIBRARIES,
2026                         SO_SEQUENCE,
2027                         SO_DATA_API,
2028                         SO_ID_ORPHANS)) {
2029                 so->outlinevis = SO_VIEW_LAYER;
2030               }
2031             }
2032           }
2033         }
2034       }
2035     }
2036
2037     if (!DNA_struct_elem_find(fd->filesdna, "LightProbe", "float", "intensity")) {
2038       for (LightProbe *probe = bmain->lightprobes.first; probe; probe = probe->id.next) {
2039         probe->intensity = 1.0f;
2040       }
2041     }
2042
2043     for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2044       bConstraint *con, *con_next;
2045       con = ob->constraints.first;
2046       while (con) {
2047         con_next = con->next;
2048         if (con->type == 17) { /* CONSTRAINT_TYPE_RIGIDBODYJOINT */
2049           BLI_remlink(&ob->constraints, con);
2050           BKE_constraint_free_data(con);
2051           MEM_freeN(con);
2052         }
2053         con = con_next;
2054       }
2055     }
2056
2057     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2058       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2059         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2060           if (sl->spacetype == SPACE_VIEW3D) {
2061             View3D *v3d = (View3D *)sl;
2062             v3d->shading.light = V3D_LIGHTING_STUDIO;
2063             v3d->shading.flag |= V3D_SHADING_OBJECT_OUTLINE;
2064
2065             /* Assume (demo) files written with 2.8 want to show
2066              * Eevee renders in the viewport. */
2067             if (MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
2068               v3d->drawtype = OB_MATERIAL;
2069             }
2070           }
2071         }
2072       }
2073     }
2074   }
2075
2076   if (!MAIN_VERSION_ATLEAST(bmain, 280, 7)) {
2077     /* Render engine storage moved elsewhere and back during 2.8
2078      * development, we assume any files saved in 2.8 had Eevee set
2079      * as scene render engine. */
2080     if (MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
2081       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2082         BLI_strncpy(scene->r.engine, RE_engine_id_BLENDER_EEVEE, sizeof(scene->r.engine));
2083       }
2084     }
2085   }
2086
2087   if (!MAIN_VERSION_ATLEAST(bmain, 280, 8)) {
2088     /* Blender Internal removal */
2089     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2090       if (STREQ(scene->r.engine, "BLENDER_RENDER") || STREQ(scene->r.engine, "BLENDER_GAME")) {
2091         BLI_strncpy(scene->r.engine, RE_engine_id_BLENDER_EEVEE, sizeof(scene->r.engine));
2092       }
2093
2094       scene->r.bake_mode = 0;
2095     }
2096
2097     for (Tex *tex = bmain->textures.first; tex; tex = tex->id.next) {
2098       /* Removed envmap, pointdensity, voxeldata, ocean textures. */
2099       if (ELEM(tex->type, 10, 14, 15, 16)) {
2100         tex->type = 0;
2101       }
2102     }
2103   }
2104
2105   if (!MAIN_VERSION_ATLEAST(bmain, 280, 11)) {
2106
2107     /* Remove info editor, but only if at the top of the window. */
2108     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2109       /* Calculate window width/height from screen vertices */
2110       int win_width = 0, win_height = 0;
2111       LISTBASE_FOREACH (ScrVert *, vert, &screen->vertbase) {
2112         win_width = MAX2(win_width, vert->vec.x);
2113         win_height = MAX2(win_height, vert->vec.y);
2114       }
2115
2116       for (ScrArea *area = screen->areabase.first, *area_next; area; area = area_next) {
2117         area_next = area->next;
2118
2119         if (area->spacetype == SPACE_INFO) {
2120           if ((area->v2->vec.y == win_height) && (area->v1->vec.x == 0) &&
2121               (area->v4->vec.x == win_width)) {
2122             BKE_screen_area_free(area);
2123
2124             BLI_remlink(&screen->areabase, area);
2125
2126             BKE_screen_remove_double_scredges(screen);
2127             BKE_screen_remove_unused_scredges(screen);
2128             BKE_screen_remove_unused_scrverts(screen);
2129
2130             MEM_freeN(area);
2131           }
2132         }
2133         /* AREA_TEMP_INFO is deprecated from now on, it should only be set for info areas
2134          * which are deleted above, so don't need to unset it. Its slot/bit can be reused */
2135       }
2136     }
2137   }
2138
2139   if (!MAIN_VERSION_ATLEAST(bmain, 280, 11)) {
2140     for (Light *la = bmain->lights.first; la; la = la->id.next) {
2141       if (la->mode & (1 << 13)) { /* LA_SHAD_RAY */
2142         la->mode |= LA_SHADOW;
2143         la->mode &= ~(1 << 13);
2144       }
2145     }
2146   }
2147
2148   if (!MAIN_VERSION_ATLEAST(bmain, 280, 12)) {
2149     /* Remove tool property regions. */
2150     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2151       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2152         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2153           if (ELEM(sl->spacetype, SPACE_VIEW3D, SPACE_CLIP)) {
2154             ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
2155                                                                    &sl->regionbase;
2156
2157             for (ARegion *region = regionbase->first, *region_next; region; region = region_next) {
2158               region_next = region->next;
2159
2160               if (region->regiontype == RGN_TYPE_TOOL_PROPS) {
2161                 BKE_area_region_free(NULL, region);
2162                 BLI_freelinkN(regionbase, region);
2163               }
2164             }
2165           }
2166         }
2167       }
2168     }
2169   }
2170
2171   if (!MAIN_VERSION_ATLEAST(bmain, 280, 13)) {
2172     /* Initialize specular factor. */
2173     if (!DNA_struct_elem_find(fd->filesdna, "Light", "float", "spec_fac")) {
2174       for (Light *la = bmain->lights.first; la; la = la->id.next) {
2175         la->spec_fac = 1.0f;
2176       }
2177     }
2178
2179     /* Initialize new view3D options. */
2180     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2181       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2182         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2183           if (sl->spacetype == SPACE_VIEW3D) {
2184             View3D *v3d = (View3D *)sl;
2185             v3d->shading.light = V3D_LIGHTING_STUDIO;
2186             v3d->shading.color_type = V3D_SHADING_MATERIAL_COLOR;
2187             copy_v3_fl(v3d->shading.single_color, 0.8f);
2188             v3d->shading.shadow_intensity = 0.5;
2189
2190             v3d->overlay.backwire_opacity = 0.5f;
2191             v3d->overlay.normals_length = 0.1f;
2192             v3d->overlay.flag = 0;
2193           }
2194         }
2195       }
2196     }
2197   }
2198
2199   if (!MAIN_VERSION_ATLEAST(bmain, 280, 14)) {
2200     if (!DNA_struct_elem_find(fd->filesdna, "Scene", "SceneDisplay", "display")) {
2201       /* Initialize new scene.SceneDisplay */
2202       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2203         copy_v3_v3(scene->display.light_direction, (float[3]){-M_SQRT1_3, -M_SQRT1_3, M_SQRT1_3});
2204       }
2205     }
2206     if (!DNA_struct_elem_find(fd->filesdna, "SceneDisplay", "float", "shadow_shift")) {
2207       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2208         scene->display.shadow_shift = 0.1;
2209       }
2210     }
2211
2212     if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "transform_pivot_point")) {
2213       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2214         scene->toolsettings->transform_pivot_point = V3D_AROUND_CENTER_MEDIAN;
2215       }
2216     }
2217
2218     if (!DNA_struct_find(fd->filesdna, "SceneEEVEE")) {
2219       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2220         /* First set the default for all the properties. */
2221
2222         scene->eevee.gi_diffuse_bounces = 3;
2223         scene->eevee.gi_cubemap_resolution = 512;
2224         scene->eevee.gi_visibility_resolution = 32;
2225
2226         scene->eevee.taa_samples = 16;
2227         scene->eevee.taa_render_samples = 64;
2228
2229         scene->eevee.sss_samples = 7;
2230         scene->eevee.sss_jitter_threshold = 0.3f;
2231
2232         scene->eevee.ssr_quality = 0.25f;
2233         scene->eevee.ssr_max_roughness = 0.5f;
2234         scene->eevee.ssr_thickness = 0.2f;
2235         scene->eevee.ssr_border_fade = 0.075f;
2236         scene->eevee.ssr_firefly_fac = 10.0f;
2237
2238         scene->eevee.volumetric_start = 0.1f;
2239         scene->eevee.volumetric_end = 100.0f;
2240         scene->eevee.volumetric_tile_size = 8;
2241         scene->eevee.volumetric_samples = 64;
2242         scene->eevee.volumetric_sample_distribution = 0.8f;
2243         scene->eevee.volumetric_light_clamp = 0.0f;
2244         scene->eevee.volumetric_shadow_samples = 16;
2245
2246         scene->eevee.gtao_distance = 0.2f;
2247         scene->eevee.gtao_factor = 1.0f;
2248         scene->eevee.gtao_quality = 0.25f;
2249
2250         scene->eevee.bokeh_max_size = 100.0f;
2251         scene->eevee.bokeh_threshold = 1.0f;
2252
2253         copy_v3_fl(scene->eevee.bloom_color, 1.0f);
2254         scene->eevee.bloom_threshold = 0.8f;
2255         scene->eevee.bloom_knee = 0.5f;
2256         scene->eevee.bloom_intensity = 0.05f;
2257         scene->eevee.bloom_radius = 6.5f;
2258         scene->eevee.bloom_clamp = 0.0f;
2259
2260         scene->eevee.motion_blur_samples = 8;
2261         scene->eevee.motion_blur_shutter = 0.5f;
2262
2263         scene->eevee.shadow_method = SHADOW_ESM;
2264         scene->eevee.shadow_cube_size = 512;
2265         scene->eevee.shadow_cascade_size = 1024;
2266
2267         scene->eevee.flag = SCE_EEVEE_VOLUMETRIC_LIGHTS | SCE_EEVEE_GTAO_BENT_NORMALS |
2268                             SCE_EEVEE_GTAO_BOUNCE | SCE_EEVEE_TAA_REPROJECTION |
2269                             SCE_EEVEE_SSR_HALF_RESOLUTION;
2270
2271         /* If the file is pre-2.80 move on. */
2272         if (scene->layer_properties == NULL) {
2273           continue;
2274         }
2275
2276         /* Now we handle eventual properties that may be set in the file. */
2277 #define EEVEE_GET_BOOL(_props, _name, _flag) \
2278   { \
2279     IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2280     if (_idprop != NULL) { \
2281       const int _value = IDP_Int(_idprop); \
2282       if (_value) { \
2283         scene->eevee.flag |= _flag; \
2284       } \
2285       else { \
2286         scene->eevee.flag &= ~_flag; \
2287       } \
2288     } \
2289   } \
2290   ((void)0)
2291
2292 #define EEVEE_GET_INT(_props, _name) \
2293   { \
2294     IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2295     if (_idprop != NULL) { \
2296       scene->eevee._name = IDP_Int(_idprop); \
2297     } \
2298   } \
2299   ((void)0)
2300
2301 #define EEVEE_GET_FLOAT(_props, _name) \
2302   { \
2303     IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2304     if (_idprop != NULL) { \
2305       scene->eevee._name = IDP_Float(_idprop); \
2306     } \
2307   } \
2308   ((void)0)
2309
2310 #define EEVEE_GET_FLOAT_ARRAY(_props, _name, _length) \
2311   { \
2312     IDProperty *_idprop = IDP_GetPropertyFromGroup(_props, #_name); \
2313     if (_idprop != NULL) { \
2314       const float *_values = IDP_Array(_idprop); \
2315       for (int _i = 0; _i < _length; _i++) { \
2316         scene->eevee._name[_i] = _values[_i]; \
2317       } \
2318     } \
2319   } \
2320   ((void)0)
2321         const int SCE_EEVEE_DOF_ENABLED = (1 << 7);
2322         IDProperty *props = IDP_GetPropertyFromGroup(scene->layer_properties,
2323                                                      RE_engine_id_BLENDER_EEVEE);
2324         // EEVEE_GET_BOOL(props, volumetric_enable, SCE_EEVEE_VOLUMETRIC_ENABLED);
2325         EEVEE_GET_BOOL(props, volumetric_lights, SCE_EEVEE_VOLUMETRIC_LIGHTS);
2326         EEVEE_GET_BOOL(props, volumetric_shadows, SCE_EEVEE_VOLUMETRIC_SHADOWS);
2327         EEVEE_GET_BOOL(props, gtao_enable, SCE_EEVEE_GTAO_ENABLED);
2328         EEVEE_GET_BOOL(props, gtao_use_bent_normals, SCE_EEVEE_GTAO_BENT_NORMALS);
2329         EEVEE_GET_BOOL(props, gtao_bounce, SCE_EEVEE_GTAO_BOUNCE);
2330         EEVEE_GET_BOOL(props, dof_enable, SCE_EEVEE_DOF_ENABLED);
2331         EEVEE_GET_BOOL(props, bloom_enable, SCE_EEVEE_BLOOM_ENABLED);
2332         EEVEE_GET_BOOL(props, motion_blur_enable, SCE_EEVEE_MOTION_BLUR_ENABLED);
2333         EEVEE_GET_BOOL(props, shadow_high_bitdepth, SCE_EEVEE_SHADOW_HIGH_BITDEPTH);
2334         EEVEE_GET_BOOL(props, taa_reprojection, SCE_EEVEE_TAA_REPROJECTION);
2335         // EEVEE_GET_BOOL(props, sss_enable, SCE_EEVEE_SSS_ENABLED);
2336         // EEVEE_GET_BOOL(props, sss_separate_albedo, SCE_EEVEE_SSS_SEPARATE_ALBEDO);
2337         EEVEE_GET_BOOL(props, ssr_enable, SCE_EEVEE_SSR_ENABLED);
2338         EEVEE_GET_BOOL(props, ssr_refraction, SCE_EEVEE_SSR_REFRACTION);
2339         EEVEE_GET_BOOL(props, ssr_halfres, SCE_EEVEE_SSR_HALF_RESOLUTION);
2340
2341         EEVEE_GET_INT(props, gi_diffuse_bounces);
2342         EEVEE_GET_INT(props, gi_diffuse_bounces);
2343         EEVEE_GET_INT(props, gi_cubemap_resolution);
2344         EEVEE_GET_INT(props, gi_visibility_resolution);
2345
2346         EEVEE_GET_INT(props, taa_samples);
2347         EEVEE_GET_INT(props, taa_render_samples);
2348
2349         EEVEE_GET_INT(props, sss_samples);
2350         EEVEE_GET_FLOAT(props, sss_jitter_threshold);
2351
2352         EEVEE_GET_FLOAT(props, ssr_quality);
2353         EEVEE_GET_FLOAT(props, ssr_max_roughness);
2354         EEVEE_GET_FLOAT(props, ssr_thickness);
2355         EEVEE_GET_FLOAT(props, ssr_border_fade);
2356         EEVEE_GET_FLOAT(props, ssr_firefly_fac);
2357
2358         EEVEE_GET_FLOAT(props, volumetric_start);
2359         EEVEE_GET_FLOAT(props, volumetric_end);
2360         EEVEE_GET_INT(props, volumetric_tile_size);
2361         EEVEE_GET_INT(props, volumetric_samples);
2362         EEVEE_GET_FLOAT(props, volumetric_sample_distribution);
2363         EEVEE_GET_FLOAT(props, volumetric_light_clamp);
2364         EEVEE_GET_INT(props, volumetric_shadow_samples);
2365
2366         EEVEE_GET_FLOAT(props, gtao_distance);
2367         EEVEE_GET_FLOAT(props, gtao_factor);
2368         EEVEE_GET_FLOAT(props, gtao_quality);
2369
2370         EEVEE_GET_FLOAT(props, bokeh_max_size);
2371         EEVEE_GET_FLOAT(props, bokeh_threshold);
2372
2373         EEVEE_GET_FLOAT_ARRAY(props, bloom_color, 3);
2374         EEVEE_GET_FLOAT(props, bloom_threshold);
2375         EEVEE_GET_FLOAT(props, bloom_knee);
2376         EEVEE_GET_FLOAT(props, bloom_intensity);
2377         EEVEE_GET_FLOAT(props, bloom_radius);
2378         EEVEE_GET_FLOAT(props, bloom_clamp);
2379
2380         EEVEE_GET_INT(props, motion_blur_samples);
2381         EEVEE_GET_FLOAT(props, motion_blur_shutter);
2382
2383         EEVEE_GET_INT(props, shadow_method);
2384         EEVEE_GET_INT(props, shadow_cube_size);
2385         EEVEE_GET_INT(props, shadow_cascade_size);
2386
2387         /* Cleanup. */
2388         IDP_FreeProperty(scene->layer_properties);
2389         scene->layer_properties = NULL;
2390
2391 #undef EEVEE_GET_FLOAT_ARRAY
2392 #undef EEVEE_GET_FLOAT
2393 #undef EEVEE_GET_INT
2394 #undef EEVEE_GET_BOOL
2395       }
2396     }
2397
2398     if (!MAIN_VERSION_ATLEAST(bmain, 280, 15)) {
2399       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2400         scene->display.matcap_ssao_distance = 0.2f;
2401         scene->display.matcap_ssao_attenuation = 1.0f;
2402         scene->display.matcap_ssao_samples = 16;
2403       }
2404
2405       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2406         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2407           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2408             if (sl->spacetype == SPACE_OUTLINER) {
2409               SpaceOutliner *soops = (SpaceOutliner *)sl;
2410               soops->filter_id_type = ID_GR;
2411               soops->outlinevis = SO_VIEW_LAYER;
2412             }
2413           }
2414         }
2415       }
2416
2417       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2418         switch (scene->toolsettings->snap_mode) {
2419           case 0:
2420             scene->toolsettings->snap_mode = SCE_SNAP_MODE_INCREMENT;
2421             break;
2422           case 1:
2423             scene->toolsettings->snap_mode = SCE_SNAP_MODE_VERTEX;
2424             break;
2425           case 2:
2426             scene->toolsettings->snap_mode = SCE_SNAP_MODE_EDGE;
2427             break;
2428           case 3:
2429             scene->toolsettings->snap_mode = SCE_SNAP_MODE_FACE;
2430             break;
2431           case 4:
2432             scene->toolsettings->snap_mode = SCE_SNAP_MODE_VOLUME;
2433             break;
2434         }
2435         switch (scene->toolsettings->snap_node_mode) {
2436           case 5:
2437             scene->toolsettings->snap_node_mode = SCE_SNAP_MODE_NODE_X;
2438             break;
2439           case 6:
2440             scene->toolsettings->snap_node_mode = SCE_SNAP_MODE_NODE_Y;
2441             break;
2442           case 7:
2443             scene->toolsettings->snap_node_mode = SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y;
2444             break;
2445           case 8:
2446             scene->toolsettings->snap_node_mode = SCE_SNAP_MODE_GRID;
2447             break;
2448         }
2449         switch (scene->toolsettings->snap_uv_mode) {
2450           case 0:
2451             scene->toolsettings->snap_uv_mode = SCE_SNAP_MODE_INCREMENT;
2452             break;
2453           case 1:
2454             scene->toolsettings->snap_uv_mode = SCE_SNAP_MODE_VERTEX;
2455             break;
2456         }
2457       }
2458
2459       ParticleSettings *part;
2460       for (part = bmain->particles.first; part; part = part->id.next) {
2461         part->shape_flag = PART_SHAPE_CLOSE_TIP;
2462         part->shape = 0.0f;
2463         part->rad_root = 1.0f;
2464         part->rad_tip = 0.0f;
2465         part->rad_scale = 0.01f;
2466       }
2467     }
2468   }
2469
2470   if (!MAIN_VERSION_ATLEAST(bmain, 280, 18)) {
2471     if (!DNA_struct_elem_find(fd->filesdna, "Material", "float", "roughness")) {
2472       for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
2473         if (mat->use_nodes) {
2474           if (MAIN_VERSION_ATLEAST(bmain, 280, 0)) {
2475             mat->roughness = mat->gloss_mir;
2476           }
2477           else {
2478             mat->roughness = 0.25f;
2479           }
2480         }
2481         else {
2482           mat->roughness = 1.0f - mat->gloss_mir;
2483         }
2484         mat->metallic = mat->ray_mirror;
2485       }
2486
2487       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2488         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2489           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2490             if (sl->spacetype == SPACE_VIEW3D) {
2491               View3D *v3d = (View3D *)sl;
2492               v3d->shading.flag |= V3D_SHADING_SPECULAR_HIGHLIGHT;
2493             }
2494           }
2495         }
2496       }
2497     }
2498
2499     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "xray_alpha")) {
2500       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2501         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2502           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2503             if (sl->spacetype == SPACE_VIEW3D) {
2504               View3D *v3d = (View3D *)sl;
2505               v3d->shading.xray_alpha = 0.5f;
2506             }
2507           }
2508         }
2509       }
2510     }
2511     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "matcap[256]")) {
2512       StudioLight *default_matcap = BKE_studiolight_find_default(STUDIOLIGHT_TYPE_MATCAP);
2513       /* when loading the internal file is loaded before the matcaps */
2514       if (default_matcap) {
2515         for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2516           LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2517             LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2518               if (sl->spacetype == SPACE_VIEW3D) {
2519                 View3D *v3d = (View3D *)sl;
2520                 BLI_strncpy(v3d->shading.matcap, default_matcap->name, FILE_MAXFILE);
2521               }
2522             }
2523           }
2524         }
2525       }
2526     }
2527     if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "wireframe_threshold")) {
2528       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2529         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2530           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2531             if (sl->spacetype == SPACE_VIEW3D) {
2532               View3D *v3d = (View3D *)sl;
2533               v3d->overlay.wireframe_threshold = 0.5f;
2534             }
2535           }
2536         }
2537       }
2538     }
2539     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "cavity_valley_factor")) {
2540       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2541         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2542           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2543             if (sl->spacetype == SPACE_VIEW3D) {
2544               View3D *v3d = (View3D *)sl;
2545               v3d->shading.cavity_valley_factor = 1.0f;
2546               v3d->shading.cavity_ridge_factor = 1.0f;
2547             }
2548           }
2549         }
2550       }
2551     }
2552     if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "xray_alpha_bone")) {
2553       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2554         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2555           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2556             if (sl->spacetype == SPACE_VIEW3D) {
2557               View3D *v3d = (View3D *)sl;
2558               v3d->overlay.xray_alpha_bone = 0.5f;
2559             }
2560           }
2561         }
2562       }
2563     }
2564   }
2565
2566   if (!MAIN_VERSION_ATLEAST(bmain, 280, 19)) {
2567     if (!DNA_struct_elem_find(fd->filesdna, "Image", "ListBase", "renderslot")) {
2568       for (Image *ima = bmain->images.first; ima; ima = ima->id.next) {
2569         if (ima->type == IMA_TYPE_R_RESULT) {
2570           for (int i = 0; i < 8; i++) {
2571             RenderSlot *slot = MEM_callocN(sizeof(RenderSlot), "Image Render Slot Init");
2572             BLI_snprintf(slot->name, sizeof(slot->name), "Slot %d", i + 1);
2573             BLI_addtail(&ima->renderslots, slot);
2574           }
2575         }
2576       }
2577     }
2578     if (!DNA_struct_elem_find(fd->filesdna, "SpaceAction", "char", "mode_prev")) {
2579       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2580         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2581           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2582             if (sl->spacetype == SPACE_ACTION) {
2583               SpaceAction *saction = (SpaceAction *)sl;
2584               /* "Dopesheet" should be default here,
2585                * unless it looks like the Action Editor was active instead. */
2586               if ((saction->mode_prev == 0) && (saction->action == NULL)) {
2587                 saction->mode_prev = SACTCONT_DOPESHEET;
2588               }
2589             }
2590           }
2591         }
2592       }
2593     }
2594
2595     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2596       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2597         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2598           if (sl->spacetype == SPACE_VIEW3D) {
2599             View3D *v3d = (View3D *)sl;
2600             if (v3d->drawtype == OB_TEXTURE) {
2601               v3d->drawtype = OB_SOLID;
2602               v3d->shading.light = V3D_LIGHTING_STUDIO;
2603               v3d->shading.color_type = V3D_SHADING_TEXTURE_COLOR;
2604             }
2605           }
2606         }
2607       }
2608     }
2609   }
2610
2611   if (!MAIN_VERSION_ATLEAST(bmain, 280, 21)) {
2612     for (Scene *sce = bmain->scenes.first; sce != NULL; sce = sce->id.next) {
2613       if (sce->ed != NULL && sce->ed->seqbase.first != NULL) {
2614         do_versions_seq_unique_name_all_strips(sce, &sce->ed->seqbase);
2615       }
2616     }
2617
2618     if (!DNA_struct_elem_find(
2619             fd->filesdna, "View3DOverlay", "float", "texture_paint_mode_opacity")) {
2620       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2621         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2622           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2623             if (sl->spacetype == SPACE_VIEW3D) {
2624               enum {
2625                 V3D_SHOW_MODE_SHADE_OVERRIDE = (1 << 15),
2626               };
2627               View3D *v3d = (View3D *)sl;
2628               float alpha = (v3d->flag2 & V3D_SHOW_MODE_SHADE_OVERRIDE) ? 0.0f : 1.0f;
2629               v3d->overlay.texture_paint_mode_opacity = alpha;
2630               v3d->overlay.vertex_paint_mode_opacity = alpha;
2631               v3d->overlay.weight_paint_mode_opacity = alpha;
2632             }
2633           }
2634         }
2635       }
2636     }
2637
2638     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "background_type")) {
2639       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2640         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2641           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2642             if (sl->spacetype == SPACE_VIEW3D) {
2643               View3D *v3d = (View3D *)sl;
2644               copy_v3_fl(v3d->shading.background_color, 0.05f);
2645             }
2646           }
2647         }
2648       }
2649     }
2650
2651     if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "gi_cubemap_draw_size")) {
2652       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2653         scene->eevee.gi_irradiance_draw_size = 0.1f;
2654         scene->eevee.gi_cubemap_draw_size = 0.3f;
2655       }
2656     }
2657
2658     if (!DNA_struct_elem_find(
2659             fd->filesdna, "RigidBodyWorld", "RigidBodyWorld_Shared", "*shared")) {
2660       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2661         RigidBodyWorld *rbw = scene->rigidbody_world;
2662
2663         if (rbw == NULL) {
2664           continue;
2665         }
2666
2667         if (rbw->shared == NULL) {
2668           rbw->shared = MEM_callocN(sizeof(*rbw->shared), "RigidBodyWorld_Shared");
2669         }
2670
2671         /* Move shared pointers from deprecated location to current location */
2672         rbw->shared->pointcache = rbw->pointcache;
2673         rbw->shared->ptcaches = rbw->ptcaches;
2674
2675         rbw->pointcache = NULL;
2676         BLI_listbase_clear(&rbw->ptcaches);
2677
2678         if (rbw->shared->pointcache == NULL) {
2679           rbw->shared->pointcache = BKE_ptcache_add(&(rbw->shared->ptcaches));
2680         }
2681       }
2682     }
2683
2684     if (!DNA_struct_elem_find(fd->filesdna, "SoftBody", "SoftBody_Shared", "*shared")) {
2685       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2686         SoftBody *sb = ob->soft;
2687         if (sb == NULL) {
2688           continue;
2689         }
2690         if (sb->shared == NULL) {
2691           sb->shared = MEM_callocN(sizeof(*sb->shared), "SoftBody_Shared");
2692         }
2693
2694         /* Move shared pointers from deprecated location to current location */
2695         sb->shared->pointcache = sb->pointcache;
2696         sb->shared->ptcaches = sb->ptcaches;
2697
2698         sb->pointcache = NULL;
2699         BLI_listbase_clear(&sb->ptcaches);
2700       }
2701     }
2702
2703     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "short", "type")) {
2704       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2705         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2706           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2707             if (sl->spacetype == SPACE_VIEW3D) {
2708               View3D *v3d = (View3D *)sl;
2709               if (v3d->drawtype == OB_RENDER) {
2710                 v3d->drawtype = OB_SOLID;
2711               }
2712               v3d->shading.type = v3d->drawtype;
2713               v3d->shading.prev_type = OB_SOLID;
2714             }
2715           }
2716         }
2717       }
2718     }
2719
2720     if (!DNA_struct_elem_find(fd->filesdna, "SceneDisplay", "View3DShading", "shading")) {
2721       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2722         BKE_screen_view3d_shading_init(&scene->display.shading);
2723       }
2724     }
2725     /* initialize grease pencil view data */
2726     if (!DNA_struct_elem_find(fd->filesdna, "SpaceView3D", "float", "vertex_opacity")) {
2727       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2728         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2729           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2730             if (sl->spacetype == SPACE_VIEW3D) {
2731               View3D *v3d = (View3D *)sl;
2732               v3d->vertex_opacity = 1.0f;
2733               v3d->gp_flag |= V3D_GP_SHOW_EDIT_LINES;
2734             }
2735           }
2736         }
2737       }
2738     }
2739   }
2740
2741   if (!MAIN_VERSION_ATLEAST(bmain, 280, 22)) {
2742     if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "annotate_v3d_align")) {
2743       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2744         scene->toolsettings->annotate_v3d_align = GP_PROJECT_VIEWSPACE | GP_PROJECT_CURSOR;
2745         scene->toolsettings->annotate_thickness = 3;
2746       }
2747     }
2748     if (!DNA_struct_elem_find(fd->filesdna, "bGPDlayer", "short", "line_change")) {
2749       for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
2750         LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
2751           gpl->line_change = gpl->thickness;
2752           if ((gpl->thickness < 1) || (gpl->thickness > 10)) {
2753             gpl->thickness = 3;
2754           }
2755         }
2756       }
2757     }
2758     if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_paper_opacity")) {
2759       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2760         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2761           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2762             if (sl->spacetype == SPACE_VIEW3D) {
2763               View3D *v3d = (View3D *)sl;
2764               v3d->overlay.gpencil_paper_opacity = 0.5f;
2765             }
2766           }
2767         }
2768       }
2769     }
2770     if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_grid_opacity")) {
2771       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2772         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2773           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2774             if (sl->spacetype == SPACE_VIEW3D) {
2775               View3D *v3d = (View3D *)sl;
2776               v3d->overlay.gpencil_grid_opacity = 0.5f;
2777             }
2778           }
2779         }
2780       }
2781     }
2782
2783     /* default loc axis */
2784     if (!DNA_struct_elem_find(fd->filesdna, "GP_Sculpt_Settings", "int", "lock_axis")) {
2785       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2786         /* lock axis */
2787         GP_Sculpt_Settings *gset = &scene->toolsettings->gp_sculpt;
2788         if (gset) {
2789           gset->lock_axis = GP_LOCKAXIS_Y;
2790         }
2791       }
2792     }
2793
2794     /* Versioning code for Subsurf modifier. */
2795     if (!DNA_struct_elem_find(fd->filesdna, "SubsurfModifier", "short", "uv_smooth")) {
2796       for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
2797         LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
2798           if (md->type == eModifierType_Subsurf) {
2799             SubsurfModifierData *smd = (SubsurfModifierData *)md;
2800             if (smd->flags & eSubsurfModifierFlag_SubsurfUv_DEPRECATED) {
2801               smd->uv_smooth = SUBSURF_UV_SMOOTH_PRESERVE_CORNERS;
2802             }
2803             else {
2804               smd->uv_smooth = SUBSURF_UV_SMOOTH_NONE;
2805             }
2806           }
2807         }
2808       }
2809     }
2810
2811     if (!DNA_struct_elem_find(fd->filesdna, "SubsurfModifier", "short", "quality")) {
2812       for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
2813         LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
2814           if (md->type == eModifierType_Subsurf) {
2815             SubsurfModifierData *smd = (SubsurfModifierData *)md;
2816             smd->quality = min_ii(smd->renderLevels, 3);
2817           }
2818         }
2819       }
2820     }
2821     /* Versioning code for Multires modifier. */
2822     if (!DNA_struct_elem_find(fd->filesdna, "MultiresModifier", "short", "quality")) {
2823       for (Object *object = bmain->objects.first; object != NULL; object = object->id.next) {
2824         LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
2825           if (md->type == eModifierType_Multires) {
2826             MultiresModifierData *mmd = (MultiresModifierData *)md;
2827             mmd->quality = 3;
2828             if (mmd->flags & eMultiresModifierFlag_PlainUv_DEPRECATED) {
2829               mmd->uv_smooth = SUBSURF_UV_SMOOTH_NONE;
2830             }
2831             else {
2832               mmd->uv_smooth = SUBSURF_UV_SMOOTH_PRESERVE_CORNERS;
2833             }
2834           }
2835         }
2836       }
2837     }
2838
2839     if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "short", "bending_model")) {
2840       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2841         LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2842           ClothModifierData *clmd = NULL;
2843           if (md->type == eModifierType_Cloth) {
2844             clmd = (ClothModifierData *)md;
2845           }
2846           else if (md->type == eModifierType_ParticleSystem) {
2847             ParticleSystemModifierData *psmd = (ParticleSystemModifierData *)md;
2848             ParticleSystem *psys = psmd->psys;
2849             clmd = psys->clmd;
2850           }
2851           if (clmd != NULL) {
2852             clmd->sim_parms->bending_model = CLOTH_BENDING_LINEAR;
2853             clmd->sim_parms->tension = clmd->sim_parms->structural;
2854             clmd->sim_parms->compression = clmd->sim_parms->structural;
2855             clmd->sim_parms->shear = clmd->sim_parms->structural;
2856             clmd->sim_parms->max_tension = clmd->sim_parms->max_struct;
2857             clmd->sim_parms->max_compression = clmd->sim_parms->max_struct;
2858             clmd->sim_parms->max_shear = clmd->sim_parms->max_struct;
2859             clmd->sim_parms->vgroup_shear = clmd->sim_parms->vgroup_struct;
2860             clmd->sim_parms->tension_damp = clmd->sim_parms->Cdis;
2861             clmd->sim_parms->compression_damp = clmd->sim_parms->Cdis;
2862             clmd->sim_parms->shear_damp = clmd->sim_parms->Cdis;
2863           }
2864         }
2865       }
2866     }
2867
2868     if (!DNA_struct_elem_find(fd->filesdna, "BrushGpencilSettings", "float", "era_strength_f")) {
2869       for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
2870         if (brush->gpencil_settings != NULL) {
2871           BrushGpencilSettings *gp = brush->gpencil_settings;
2872           if (gp->brush_type == GPAINT_TOOL_ERASE) {
2873             gp->era_strength_f = 100.0f;
2874             gp->era_thickness_f = 10.0f;
2875           }
2876         }
2877       }
2878     }
2879
2880     for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2881       LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2882         if (md->type == eModifierType_Cloth) {
2883           ClothModifierData *clmd = (ClothModifierData *)md;
2884
2885           if (!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_GOAL)) {
2886             clmd->sim_parms->vgroup_mass = 0;
2887           }
2888
2889           if (!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_SCALING)) {
2890             clmd->sim_parms->vgroup_struct = 0;
2891             clmd->sim_parms->vgroup_shear = 0;
2892             clmd->sim_parms->vgroup_bend = 0;
2893           }
2894
2895           if (!(clmd->sim_parms->flags & CLOTH_SIMSETTINGS_FLAG_SEW)) {
2896             clmd->sim_parms->shrink_min = 0.0f;
2897             clmd->sim_parms->vgroup_shrink = 0;
2898           }
2899
2900           if (!(clmd->coll_parms->flags & CLOTH_COLLSETTINGS_FLAG_ENABLED)) {
2901             clmd->coll_parms->flags &= ~CLOTH_COLLSETTINGS_FLAG_SELF;
2902           }
2903         }
2904       }
2905     }
2906   }
2907
2908   if (!MAIN_VERSION_ATLEAST(bmain, 280, 24)) {
2909     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2910       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2911         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2912           if (sl->spacetype == SPACE_VIEW3D) {
2913             View3D *v3d = (View3D *)sl;
2914             v3d->overlay.edit_flag |= V3D_OVERLAY_EDIT_FACES | V3D_OVERLAY_EDIT_SEAMS |
2915                                       V3D_OVERLAY_EDIT_SHARP | V3D_OVERLAY_EDIT_FREESTYLE_EDGE |
2916                                       V3D_OVERLAY_EDIT_FREESTYLE_FACE | V3D_OVERLAY_EDIT_EDGES |
2917                                       V3D_OVERLAY_EDIT_CREASES | V3D_OVERLAY_EDIT_BWEIGHTS |
2918                                       V3D_OVERLAY_EDIT_CU_HANDLES | V3D_OVERLAY_EDIT_CU_NORMALS;
2919           }
2920         }
2921       }
2922     }
2923
2924     if (!DNA_struct_elem_find(fd->filesdna, "ShrinkwrapModifierData", "char", "shrinkMode")) {
2925       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2926         LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2927           if (md->type == eModifierType_Shrinkwrap) {
2928             ShrinkwrapModifierData *smd = (ShrinkwrapModifierData *)md;
2929             if (smd->shrinkOpts & MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE) {
2930               smd->shrinkMode = MOD_SHRINKWRAP_ABOVE_SURFACE;
2931               smd->shrinkOpts &= ~MOD_SHRINKWRAP_KEEP_ABOVE_SURFACE;
2932             }
2933           }
2934         }
2935       }
2936     }
2937
2938     if (!DNA_struct_elem_find(fd->filesdna, "PartDeflect", "float", "pdef_cfrict")) {
2939       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
2940         if (ob->pd) {
2941           ob->pd->pdef_cfrict = 5.0f;
2942         }
2943
2944         LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
2945           if (md->type == eModifierType_Cloth) {
2946             ClothModifierData *clmd = (ClothModifierData *)md;
2947
2948             clmd->coll_parms->selfepsilon = 0.015f;
2949           }
2950         }
2951       }
2952     }
2953
2954     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "xray_alpha_wire")) {
2955       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2956         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2957           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2958             if (sl->spacetype == SPACE_VIEW3D) {
2959               View3D *v3d = (View3D *)sl;
2960               v3d->shading.flag |= V3D_SHADING_XRAY_WIREFRAME;
2961             }
2962           }
2963         }
2964       }
2965     }
2966   }
2967
2968   if (!MAIN_VERSION_ATLEAST(bmain, 280, 25)) {
2969     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
2970       UnitSettings *unit = &scene->unit;
2971       if (unit->system != USER_UNIT_NONE) {
2972         unit->length_unit = bUnit_GetBaseUnitOfType(scene->unit.system, B_UNIT_LENGTH);
2973         unit->mass_unit = bUnit_GetBaseUnitOfType(scene->unit.system, B_UNIT_MASS);
2974       }
2975       unit->time_unit = bUnit_GetBaseUnitOfType(USER_UNIT_NONE, B_UNIT_TIME);
2976     }
2977
2978     /* gpencil grid settings */
2979     for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
2980       ARRAY_SET_ITEMS(gpd->grid.color, 0.5f, 0.5f, 0.5f);  // Color
2981       ARRAY_SET_ITEMS(gpd->grid.scale, 1.0f, 1.0f);        // Scale
2982       gpd->grid.lines = GP_DEFAULT_GRID_LINES;             // Number of lines
2983     }
2984   }
2985
2986   if (!MAIN_VERSION_ATLEAST(bmain, 280, 28)) {
2987     for (Mesh *mesh = bmain->meshes.first; mesh; mesh = mesh->id.next) {
2988       BKE_mesh_calc_edges_loose(mesh);
2989     }
2990   }
2991
2992   if (!MAIN_VERSION_ATLEAST(bmain, 280, 29)) {
2993     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
2994       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
2995         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
2996           if (sl->spacetype == SPACE_VIEW3D) {
2997             enum { V3D_OCCLUDE_WIRE = (1 << 14) };
2998             View3D *v3d = (View3D *)sl;
2999             if (v3d->flag2 & V3D_OCCLUDE_WIRE) {
3000               v3d->overlay.edit_flag |= V3D_OVERLAY_EDIT_OCCLUDE_WIRE;
3001               v3d->flag2 &= ~V3D_OCCLUDE_WIRE;
3002             }
3003           }
3004         }
3005       }
3006     }
3007
3008     /* Files stored pre 2.5 (possibly re-saved with newer versions) may have non-visible
3009      * spaces without a header (visible/active ones are properly versioned).
3010      * Multiple version patches below assume there's always a header though. So inserting this
3011      * patch in-between older ones to add a header when needed.
3012      *
3013      * From here on it should be fine to assume there always is a header.
3014      */
3015     if (!MAIN_VERSION_ATLEAST(bmain, 283, 1)) {
3016       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3017         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3018           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3019             ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3020                                                                    &sl->regionbase;
3021             ARegion *region_header = do_versions_find_region_or_null(regionbase, RGN_TYPE_HEADER);
3022
3023             if (!region_header) {
3024               /* Headers should always be first in the region list, except if there's also a
3025                * tool-header. These were only introduced in later versions though, so should be
3026                * fine to always insert headers first. */
3027               BLI_assert(!do_versions_find_region_or_null(regionbase, RGN_TYPE_TOOL_HEADER));
3028
3029               ARegion *region = do_versions_add_region(RGN_TYPE_HEADER,
3030                                                        "header 2.83.1 versioning");
3031               region->alignment = (U.uiflag & USER_HEADER_BOTTOM) ? RGN_ALIGN_BOTTOM :
3032                                                                     RGN_ALIGN_TOP;
3033               BLI_addhead(regionbase, region);
3034             }
3035           }
3036         }
3037       }
3038     }
3039
3040     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3041       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3042         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3043           if (sl->spacetype == SPACE_PROPERTIES) {
3044             ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3045                                                                    &sl->regionbase;
3046             ARegion *region = MEM_callocN(sizeof(ARegion), "navigation bar for properties");
3047             ARegion *region_header = NULL;
3048
3049             for (region_header = regionbase->first; region_header;
3050                  region_header = region_header->next) {
3051               if (region_header->regiontype == RGN_TYPE_HEADER) {
3052                 break;
3053               }
3054             }
3055             BLI_assert(region_header);
3056
3057             BLI_insertlinkafter(regionbase, region_header, region);
3058
3059             region->regiontype = RGN_TYPE_NAV_BAR;
3060             region->alignment = RGN_ALIGN_LEFT;
3061           }
3062         }
3063       }
3064     }
3065
3066     /* grease pencil fade layer opacity */
3067     if (!DNA_struct_elem_find(fd->filesdna, "View3DOverlay", "float", "gpencil_fade_layer")) {
3068       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3069         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3070           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3071             if (sl->spacetype == SPACE_VIEW3D) {
3072               View3D *v3d = (View3D *)sl;
3073               v3d->overlay.gpencil_fade_layer = 0.5f;
3074             }
3075           }
3076         }
3077       }
3078     }
3079   }
3080
3081   if (!MAIN_VERSION_ATLEAST(bmain, 280, 30)) {
3082     /* grease pencil main material show switches */
3083     for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
3084       if (mat->gp_style) {
3085         mat->gp_style->flag |= GP_MATERIAL_STROKE_SHOW;
3086         mat->gp_style->flag |= GP_MATERIAL_FILL_SHOW;
3087       }
3088     }
3089   }
3090
3091   if (!MAIN_VERSION_ATLEAST(bmain, 280, 33)) {
3092
3093     if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "overscan")) {
3094       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3095         scene->eevee.overscan = 3.0f;
3096       }
3097     }
3098
3099     for (Light *la = bmain->lights.first; la; la = la->id.next) {
3100       /* Removed Hemi lights. */
3101       if (!ELEM(la->type, LA_LOCAL, LA_SUN, LA_SPOT, LA_AREA)) {
3102         la->type = LA_SUN;
3103       }
3104     }
3105
3106     if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "light_threshold")) {
3107       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3108         scene->eevee.light_threshold = 0.01f;
3109       }
3110     }
3111
3112     if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "gi_irradiance_smoothing")) {
3113       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3114         scene->eevee.gi_irradiance_smoothing = 0.1f;
3115       }
3116     }
3117
3118     if (!DNA_struct_elem_find(fd->filesdna, "SceneEEVEE", "float", "gi_filter_quality")) {
3119       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3120         scene->eevee.gi_filter_quality = 1.0f;
3121       }
3122     }
3123
3124     if (!DNA_struct_elem_find(fd->filesdna, "Light", "float", "att_dist")) {
3125       for (Light *la = bmain->lights.first; la; la = la->id.next) {
3126         la->att_dist = la->clipend;
3127       }
3128     }
3129
3130     if (!DNA_struct_elem_find(fd->filesdna, "Brush", "char", "weightpaint_tool")) {
3131       /* Magic defines from old files (2.7x) */
3132
3133 #define PAINT_BLEND_MIX 0
3134 #define PAINT_BLEND_ADD 1
3135 #define PAINT_BLEND_SUB 2
3136 #define PAINT_BLEND_MUL 3
3137 #define PAINT_BLEND_BLUR 4
3138 #define PAINT_BLEND_LIGHTEN 5
3139 #define PAINT_BLEND_DARKEN 6
3140 #define PAINT_BLEND_AVERAGE 7
3141 #define PAINT_BLEND_SMEAR 8
3142 #define PAINT_BLEND_COLORDODGE 9
3143 #define PAINT_BLEND_DIFFERENCE 10
3144 #define PAINT_BLEND_SCREEN 11
3145 #define PAINT_BLEND_HARDLIGHT 12
3146 #define PAINT_BLEND_OVERLAY 13
3147 #define PAINT_BLEND_SOFTLIGHT 14
3148 #define PAINT_BLEND_EXCLUSION 15
3149 #define PAINT_BLEND_LUMINOSITY 16
3150 #define PAINT_BLEND_SATURATION 17
3151 #define PAINT_BLEND_HUE 18
3152 #define PAINT_BLEND_ALPHA_SUB 19
3153 #define PAINT_BLEND_ALPHA_ADD 20
3154
3155       for (Brush *brush = bmain->brushes.first; brush; brush = brush->id.next) {
3156         if (brush->ob_mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT)) {
3157           const char tool_init = brush->vertexpaint_tool;
3158           bool is_blend = false;
3159
3160           {
3161             char tool = tool_init;
3162             switch (tool_init) {
3163               case PAINT_BLEND_MIX:
3164                 tool = VPAINT_TOOL_DRAW;
3165                 break;
3166               case PAINT_BLEND_BLUR:
3167                 tool = VPAINT_TOOL_BLUR;
3168                 break;
3169               case PAINT_BLEND_AVERAGE:
3170                 tool = VPAINT_TOOL_AVERAGE;
3171                 break;
3172               case PAINT_BLEND_SMEAR:
3173                 tool = VPAINT_TOOL_SMEAR;
3174                 break;
3175               default:
3176                 tool = VPAINT_TOOL_DRAW;
3177                 is_blend = true;
3178                 break;
3179             }
3180             brush->vertexpaint_tool = tool;
3181           }
3182
3183           if (is_blend == false) {
3184             brush->blend = IMB_BLEND_MIX;
3185           }
3186           else {
3187             short blend = IMB_BLEND_MIX;
3188             switch (tool_init) {
3189               case PAINT_BLEND_ADD:
3190                 blend = IMB_BLEND_ADD;
3191                 break;
3192               case PAINT_BLEND_SUB:
3193                 blend = IMB_BLEND_SUB;
3194                 break;
3195               case PAINT_BLEND_MUL:
3196                 blend = IMB_BLEND_MUL;
3197                 break;
3198               case PAINT_BLEND_LIGHTEN:
3199                 blend = IMB_BLEND_LIGHTEN;
3200                 break;
3201               case PAINT_BLEND_DARKEN:
3202                 blend = IMB_BLEND_DARKEN;
3203                 break;
3204               case PAINT_BLEND_COLORDODGE:
3205                 blend = IMB_BLEND_COLORDODGE;
3206                 break;
3207               case PAINT_BLEND_DIFFERENCE:
3208                 blend = IMB_BLEND_DIFFERENCE;
3209                 break;
3210               case PAINT_BLEND_SCREEN:
3211                 blend = IMB_BLEND_SCREEN;
3212                 break;
3213               case PAINT_BLEND_HARDLIGHT:
3214                 blend = IMB_BLEND_HARDLIGHT;
3215                 break;
3216               case PAINT_BLEND_OVERLAY:
3217                 blend = IMB_BLEND_OVERLAY;
3218                 break;
3219               case PAINT_BLEND_SOFTLIGHT:
3220                 blend = IMB_BLEND_SOFTLIGHT;
3221                 break;
3222               case PAINT_BLEND_EXCLUSION:
3223                 blend = IMB_BLEND_EXCLUSION;
3224                 break;
3225               case PAINT_BLEND_LUMINOSITY:
3226                 blend = IMB_BLEND_LUMINOSITY;
3227                 break;
3228               case PAINT_BLEND_SATURATION:
3229                 blend = IMB_BLEND_SATURATION;
3230                 break;
3231               case PAINT_BLEND_HUE:
3232                 blend = IMB_BLEND_HUE;
3233                 break;
3234               case PAINT_BLEND_ALPHA_SUB:
3235                 blend = IMB_BLEND_ERASE_ALPHA;
3236                 break;
3237               case PAINT_BLEND_ALPHA_ADD:
3238                 blend = IMB_BLEND_ADD_ALPHA;
3239                 break;
3240             }
3241             brush->blend = blend;
3242           }
3243         }
3244         /* For now these match, in the future new items may not. */
3245         brush->weightpaint_tool = brush->vertexpaint_tool;
3246       }
3247
3248 #undef PAINT_BLEND_MIX
3249 #undef PAINT_BLEND_ADD
3250 #undef PAINT_BLEND_SUB
3251 #undef PAINT_BLEND_MUL
3252 #undef PAINT_BLEND_BLUR
3253 #undef PAINT_BLEND_LIGHTEN
3254 #undef PAINT_BLEND_DARKEN
3255 #undef PAINT_BLEND_AVERAGE
3256 #undef PAINT_BLEND_SMEAR
3257 #undef PAINT_BLEND_COLORDODGE
3258 #undef PAINT_BLEND_DIFFERENCE
3259 #undef PAINT_BLEND_SCREEN
3260 #undef PAINT_BLEND_HARDLIGHT
3261 #undef PAINT_BLEND_OVERLAY
3262 #undef PAINT_BLEND_SOFTLIGHT
3263 #undef PAINT_BLEND_EXCLUSION
3264 #undef PAINT_BLEND_LUMINOSITY
3265 #undef PAINT_BLEND_SATURATION
3266 #undef PAINT_BLEND_HUE
3267 #undef PAINT_BLEND_ALPHA_SUB
3268 #undef PAINT_BLEND_ALPHA_ADD
3269     }
3270   }
3271
3272   if (!MAIN_VERSION_ATLEAST(bmain, 280, 34)) {
3273     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3274       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3275         LISTBASE_FOREACH (SpaceLink *, slink, &area->spacedata) {
3276           if (slink->spacetype == SPACE_USERPREF) {
3277             ARegion *navigation_region = BKE_spacedata_find_region_type(
3278                 slink, area, RGN_TYPE_NAV_BAR);
3279
3280             if (!navigation_region) {
3281               ARegion *main_region = BKE_spacedata_find_region_type(slink, area, RGN_TYPE_WINDOW);
3282               ListBase *regionbase = (slink == area->spacedata.first) ? &area->regionbase :
3283                                                                         &slink->regionbase;
3284
3285               navigation_region = MEM_callocN(sizeof(ARegion),
3286                                               "userpref navigation-region do_versions");
3287
3288               /* Order matters, addhead not addtail! */
3289               BLI_insertlinkbefore(regionbase, main_region, navigation_region);
3290
3291               navigation_region->regiontype = RGN_TYPE_NAV_BAR;
3292               navigation_region->alignment = RGN_ALIGN_LEFT;
3293             }
3294           }
3295         }
3296       }
3297     }
3298   }
3299
3300   if (!MAIN_VERSION_ATLEAST(bmain, 280, 36)) {
3301     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "float", "curvature_ridge_factor")) {
3302       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3303         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3304           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3305             if (sl->spacetype == SPACE_VIEW3D) {
3306               View3D *v3d = (View3D *)sl;
3307               v3d->shading.curvature_ridge_factor = 1.0f;
3308               v3d->shading.curvature_valley_factor = 1.0f;
3309             }
3310           }
3311         }
3312       }
3313     }
3314
3315     /* Rename OpenGL to Workbench. */
3316     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3317       if (STREQ(scene->r.engine, "BLENDER_OPENGL")) {
3318         STRNCPY(scene->r.engine, RE_engine_id_BLENDER_WORKBENCH);
3319       }
3320     }
3321
3322     /* init Annotations onion skin */
3323     if (!DNA_struct_elem_find(fd->filesdna, "bGPDlayer", "int", "gstep")) {
3324       for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
3325         LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
3326           ARRAY_SET_ITEMS(gpl->gcolor_prev, 0.302f, 0.851f, 0.302f);
3327           ARRAY_SET_ITEMS(gpl->gcolor_next, 0.250f, 0.1f, 1.0f);
3328         }
3329       }
3330     }
3331
3332     /* Move studio_light selection to lookdev_light. */
3333     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "lookdev_light[256]")) {
3334       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3335         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3336           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3337             if (sl->spacetype == SPACE_VIEW3D) {
3338               View3D *v3d = (View3D *)sl;
3339               memcpy(v3d->shading.lookdev_light, v3d->shading.studio_light, sizeof(char) * 256);
3340             }
3341           }
3342         }
3343       }
3344     }
3345
3346     /* Change Solid mode shadow orientation. */
3347     if (!DNA_struct_elem_find(fd->filesdna, "SceneDisplay", "float", "shadow_focus")) {
3348       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3349         float *dir = scene->display.light_direction;
3350         SWAP(float, dir[2], dir[1]);
3351         dir[2] = -dir[2];
3352         dir[0] = -dir[0];
3353       }
3354     }
3355   }
3356
3357   if (!MAIN_VERSION_ATLEAST(bmain, 280, 37)) {
3358     for (Camera *ca = bmain->cameras.first; ca; ca = ca->id.next) {
3359       ca->drawsize *= 2.0f;
3360     }
3361
3362     /* Grease pencil primitive curve */
3363     if (!DNA_struct_elem_find(
3364             fd->filesdna, "GP_Sculpt_Settings", "CurveMapping", "cur_primitive")) {
3365       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3366         GP_Sculpt_Settings *gset = &scene->toolsettings->gp_sculpt;
3367         if ((gset) && (gset->cur_primitive == NULL)) {
3368           gset->cur_primitive = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
3369           BKE_curvemapping_initialize(gset->cur_primitive);
3370           BKE_curvemap_reset(gset->cur_primitive->cm,
3371                              &gset->cur_primitive->clipr,
3372                              CURVE_PRESET_BELL,
3373                              CURVEMAP_SLOPE_POSITIVE);
3374         }
3375       }
3376     }
3377   }
3378
3379   if (!MAIN_VERSION_ATLEAST(bmain, 280, 38)) {
3380     if (DNA_struct_elem_find(fd->filesdna, "Object", "char", "empty_image_visibility_flag")) {
3381       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3382         ob->empty_image_visibility_flag ^= (OB_EMPTY_IMAGE_HIDE_PERSPECTIVE |
3383                                             OB_EMPTY_IMAGE_HIDE_ORTHOGRAPHIC |
3384                                             OB_EMPTY_IMAGE_HIDE_BACK);
3385       }
3386     }
3387
3388     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3389       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3390         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3391           switch (sl->spacetype) {
3392             case SPACE_IMAGE: {
3393               SpaceImage *sima = (SpaceImage *)sl;
3394               sima->flag &= ~(SI_FLAG_UNUSED_0 | SI_FLAG_UNUSED_1 | SI_FLAG_UNUSED_3 |
3395                               SI_FLAG_UNUSED_6 | SI_FLAG_UNUSED_7 | SI_FLAG_UNUSED_8 |
3396                               SI_FLAG_UNUSED_17 | SI_FLAG_UNUSED_18 | SI_FLAG_UNUSED_23 |
3397                               SI_FLAG_UNUSED_24);
3398               break;
3399             }
3400             case SPACE_VIEW3D: {
3401               View3D *v3d = (View3D *)sl;
3402               v3d->flag &= ~(V3D_LOCAL_COLLECTIONS | V3D_FLAG_UNUSED_1 | V3D_FLAG_UNUSED_10 |
3403                              V3D_FLAG_UNUSED_12);
3404               v3d->flag2 &= ~(V3D_FLAG2_UNUSED_3 | V3D_FLAG2_UNUSED_6 | V3D_FLAG2_UNUSED_12 |
3405                               V3D_FLAG2_UNUSED_13 | V3D_FLAG2_UNUSED_14 | V3D_FLAG2_UNUSED_15);
3406               break;
3407             }
3408             case SPACE_OUTLINER: {
3409               SpaceOutliner *so = (SpaceOutliner *)sl;
3410               so->filter &= ~(SO_FILTER_UNUSED_1 | SO_FILTER_UNUSED_5 | SO_FILTER_UNUSED_12);
3411               so->storeflag &= ~(SO_TREESTORE_UNUSED_1);
3412               break;
3413             }
3414             case SPACE_FILE: {
3415               SpaceFile *sfile = (SpaceFile *)sl;
3416               if (sfile->params) {
3417                 sfile->params->flag &= ~(FILE_PARAMS_FLAG_UNUSED_1 | FILE_PARAMS_FLAG_UNUSED_6 |
3418                                          FILE_PARAMS_FLAG_UNUSED_9);
3419               }
3420               break;
3421             }
3422             case SPACE_NODE: {
3423               SpaceNode *snode = (SpaceNode *)sl;
3424               snode->flag &= ~(SNODE_FLAG_UNUSED_6 | SNODE_FLAG_UNUSED_10 | SNODE_FLAG_UNUSED_11);
3425               break;
3426             }
3427             case SPACE_PROPERTIES: {
3428               SpaceProperties *sbuts = (SpaceProperties *)sl;
3429               sbuts->flag &= ~(SB_FLAG_UNUSED_2 | SB_FLAG_UNUSED_3);
3430               break;
3431             }
3432             case SPACE_NLA: {
3433               SpaceNla *snla = (SpaceNla *)sl;
3434               snla->flag &= ~(SNLA_FLAG_UNUSED_0 | SNLA_FLAG_UNUSED_1 | SNLA_FLAG_UNUSED_3);
3435               break;
3436             }
3437           }
3438         }
3439       }
3440     }
3441
3442     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3443       scene->r.mode &= ~(R_MODE_UNUSED_1 | R_MODE_UNUSED_2 | R_MODE_UNUSED_3 | R_MODE_UNUSED_4 |
3444                          R_MODE_UNUSED_5 | R_MODE_UNUSED_6 | R_MODE_UNUSED_7 | R_MODE_UNUSED_8 |
3445                          R_MODE_UNUSED_10 | R_MODE_UNUSED_13 | R_MODE_UNUSED_16 |
3446                          R_MODE_UNUSED_17 | R_MODE_UNUSED_18 | R_MODE_UNUSED_19 |
3447                          R_MODE_UNUSED_20 | R_MODE_UNUSED_21 | R_MODE_UNUSED_27);
3448
3449       scene->r.scemode &= ~(R_SCEMODE_UNUSED_8 | R_SCEMODE_UNUSED_11 | R_SCEMODE_UNUSED_13 |
3450                             R_SCEMODE_UNUSED_16 | R_SCEMODE_UNUSED_17 | R_SCEMODE_UNUSED_19);
3451
3452       if (scene->toolsettings->sculpt) {
3453         scene->toolsettings->sculpt->flags &= ~(SCULPT_FLAG_UNUSED_0 | SCULPT_FLAG_UNUSED_1 |
3454                                                 SCULPT_FLAG_UNUSED_2);
3455       }
3456
3457       if (scene->ed) {
3458         Sequence *seq;
3459         SEQ_BEGIN (scene->ed, seq) {
3460           seq->flag &= ~(SEQ_FLAG_UNUSED_6 | SEQ_FLAG_UNUSED_18 | SEQ_FLAG_UNUSED_19 |
3461                          SEQ_FLAG_UNUSED_21);
3462           if (seq->type == SEQ_TYPE_SPEED) {
3463             SpeedControlVars *s = (SpeedControlVars *)seq->effectdata;
3464             s->flags &= ~(SEQ_SPEED_UNUSED_1);
3465           }
3466         }
3467         SEQ_END;
3468       }
3469     }
3470
3471     for (World *world = bmain->worlds.first; world; world = world->id.next) {
3472       world->flag &= ~(WO_MODE_UNUSED_1 | WO_MODE_UNUSED_2 | WO_MODE_UNUSED_3 | WO_MODE_UNUSED_4 |
3473                        WO_MODE_UNUSED_5 | WO_MODE_UNUSED_7);
3474     }
3475
3476     for (Image *image = bmain->images.first; image; image = image->id.next) {
3477       image->flag &= ~(IMA_HIGH_BITDEPTH | IMA_FLAG_UNUSED_1 | IMA_FLAG_UNUSED_4 |
3478                        IMA_FLAG_UNUSED_6 | IMA_FLAG_UNUSED_8 | IMA_FLAG_UNUSED_15 |
3479                        IMA_FLAG_UNUSED_16);
3480     }
3481
3482     for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3483       ob->flag &= ~(OB_FLAG_UNUSED_11 | OB_FLAG_UNUSED_12);
3484       ob->transflag &= ~(OB_TRANSFLAG_UNUSED_0 | OB_TRANSFLAG_UNUSED_1);
3485       ob->shapeflag &= ~OB_SHAPE_FLAG_UNUSED_1;
3486     }
3487
3488     for (Mesh *me = bmain->meshes.first; me; me = me->id.next) {
3489       me->flag &= ~(ME_FLAG_UNUSED_0 | ME_FLAG_UNUSED_1 | ME_FLAG_UNUSED_3 | ME_FLAG_UNUSED_4 |
3490                     ME_FLAG_UNUSED_6 | ME_FLAG_UNUSED_7 | ME_FLAG_UNUSED_8);
3491     }
3492
3493     for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
3494       mat->blend_flag &= ~(1 << 2); /* UNUSED */
3495     }
3496   }
3497
3498   if (!MAIN_VERSION_ATLEAST(bmain, 280, 40)) {
3499     if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "snap_transform_mode_flag")) {
3500       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3501         scene->toolsettings->snap_transform_mode_flag = SCE_SNAP_TRANSFORM_MODE_TRANSLATE;
3502       }
3503     }
3504
3505     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3506       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3507         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3508           switch (sl->spacetype) {
3509             case SPACE_VIEW3D: {
3510               enum { V3D_BACKFACE_CULLING = (1 << 10) };
3511               View3D *v3d = (View3D *)sl;
3512               if (v3d->flag2 & V3D_BACKFACE_CULLING) {
3513                 v3d->flag2 &= ~V3D_BACKFACE_CULLING;
3514                 v3d->shading.flag |= V3D_SHADING_BACKFACE_CULLING;
3515               }
3516               break;
3517             }
3518           }
3519         }
3520       }
3521     }
3522
3523     if (!DNA_struct_find(fd->filesdna, "TransformOrientationSlot")) {
3524       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3525         for (int i = 0; i < ARRAY_SIZE(scene->orientation_slots); i++) {
3526           scene->orientation_slots[i].index_custom = -1;
3527         }
3528       }
3529     }
3530
3531     /* Grease pencil cutter/select segment intersection threshold  */
3532     if (!DNA_struct_elem_find(fd->filesdna, "GP_Sculpt_Settings", "float", "isect_threshold")) {
3533       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3534         GP_Sculpt_Settings *gset = &scene->toolsettings->gp_sculpt;
3535         if (gset) {
3536           gset->isect_threshold = 0.1f;
3537         }
3538       }
3539     }
3540
3541     /* Fix anamorphic bokeh eevee rna limits.*/
3542     for (Camera *ca = bmain->cameras.first; ca; ca = ca->id.next) {
3543       if (ca->gpu_dof.ratio < 0.01f) {
3544         ca->gpu_dof.ratio = 0.01f;
3545       }
3546     }
3547
3548     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3549       LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3550         LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3551           if (sl->spacetype == SPACE_USERPREF) {
3552             ARegion *execute_region = BKE_spacedata_find_region_type(sl, area, RGN_TYPE_EXECUTE);
3553
3554             if (!execute_region) {
3555               ListBase *regionbase = (sl == area->spacedata.first) ? &area->regionbase :
3556                                                                      &sl->regionbase;
3557               ARegion *region_navbar = BKE_spacedata_find_region_type(sl, area, RGN_TYPE_NAV_BAR);
3558
3559               execute_region = MEM_callocN(sizeof(ARegion), "execute region for properties");
3560
3561               BLI_assert(region_navbar);
3562
3563               BLI_insertlinkafter(regionbase, region_navbar, execute_region);
3564
3565               execute_region->regiontype = RGN_TYPE_EXECUTE;
3566               execute_region->alignment = RGN_ALIGN_BOTTOM | RGN_SPLIT_PREV;
3567               execute_region->flag |= RGN_FLAG_DYNAMIC_SIZE;
3568             }
3569           }
3570         }
3571       }
3572     }
3573   }
3574
3575   if (!MAIN_VERSION_ATLEAST(bmain, 280, 43)) {
3576     ListBase *lb = which_libbase(bmain, ID_BR);
3577     BKE_main_id_repair_duplicate_names_listbase(lb);
3578   }
3579
3580   if (!MAIN_VERSION_ATLEAST(bmain, 280, 44)) {
3581     if (!DNA_struct_elem_find(fd->filesdna, "Material", "float", "a")) {
3582       for (Material *mat = bmain->materials.first; mat; mat = mat->id.next) {
3583         mat->a = 1.0f;
3584       }
3585     }
3586
3587     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3588       enum {
3589         R_ALPHAKEY = 2,
3590       };
3591       scene->r.seq_flag &= ~(R_SEQ_UNUSED_0 | R_SEQ_UNUSED_1 | R_SEQ_UNUSED_2);
3592       scene->r.color_mgt_flag &= ~R_COLOR_MANAGEMENT_UNUSED_1;
3593       if (scene->r.alphamode == R_ALPHAKEY) {
3594         scene->r.alphamode = R_ADDSKY;
3595       }
3596       ToolSettings *ts = scene->toolsettings;
3597       ts->particle.flag &= ~PE_UNUSED_6;
3598       if (ts->sculpt != NULL) {
3599         ts->sculpt->flags &= ~SCULPT_FLAG_UNUSED_6;
3600       }
3601     }
3602   }
3603
3604   if (!MAIN_VERSION_ATLEAST(bmain, 280, 46)) {
3605     /* Add wireframe color. */
3606     if (!DNA_struct_elem_find(fd->filesdna, "View3DShading", "char", "wire_color_type")) {
3607       for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
3608         LISTBASE_FOREACH (ScrArea *, area, &screen->areabase) {
3609           LISTBASE_FOREACH (SpaceLink *, sl, &area->spacedata) {
3610             if (sl->spacetype == SPACE_VIEW3D) {
3611               View3D *v3d = (View3D *)sl;
3612               v3d->shading.wire_color_type = V3D_SHADING_SINGLE_COLOR;
3613             }
3614           }
3615         }
3616       }
3617     }
3618
3619     if (!DNA_struct_elem_find(fd->filesdna, "View3DCursor", "short", "rotation_mode")) {
3620       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3621         if (is_zero_v3(scene->cursor.rotation_axis)) {
3622           scene->cursor.rotation_mode = ROT_MODE_XYZ;
3623           scene->cursor.rotation_quaternion[0] = 1.0f;
3624           scene->cursor.rotation_axis[1] = 1.0f;
3625         }
3626       }
3627     }
3628   }
3629
3630   if (!MAIN_VERSION_ATLEAST(bmain, 280, 47)) {
3631     LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
3632       ParticleEditSettings *pset = &scene->toolsettings->particle;
3633       if (pset->brushtype < 0) {
3634         pset->brushtype = PE_BRUSH_COMB;
3635       }
3636     }
3637
3638     LISTBASE_FOREACH (Object *, ob, &bmain->objects) {
3639       {
3640         enum { PARCURVE = 1, PARKEY = 2, PAR_DEPRECATED = 16 };
3641         if (ELEM(ob->partype, PARCURVE, PARKEY, PAR_DEPRECATED)) {
3642           ob->partype = PAROBJECT;
3643         }
3644       }
3645
3646       {
3647         enum { OB_WAVE = 21, OB_LIFE = 23, OB_SECTOR = 24 };
3648         if (ELEM(ob->type, OB_WAVE, OB_LIFE, OB_SECTOR)) {
3649           ob->type = OB_EMPTY;
3650         }
3651       }
3652
3653       ob->transflag &= ~(OB_TRANSFLAG_UNUSED_0 | OB_TRANSFLAG_UNUSED_1 | OB_TRANSFLAG_UNUSED_3 |
3654                          OB_TRANSFLAG_UNUSED_6 | OB_TRANSFLAG_UNUSED_12);
3655
3656       ob->nlaflag &= ~(OB_ADS_UNUSED_1 | OB_ADS_UNUSED_2);
3657     }
3658
3659     LISTBASE_FOREACH (bArmature *, arm, &bmain->armatures) {
3660       arm->flag &= ~(ARM_FLAG_UNUSED_1 | ARM_FLAG_UNUSED_5 | ARM_FLAG_UNUSED_6 |
3661                      ARM_FLAG_UNUSED_7 | ARM_FLAG_UNUSED_12);
3662     }
3663
3664     LISTBASE_FOREACH (Text *, text, &bmain->texts) {
3665       text->flags &= ~(TXT_FLAG_UNUSED_8 | TXT_FLAG_UNUSED_9);
3666     }
3667   }
3668
3669   if (!MAIN_VERSION_ATLEAST(bmain, 280, 48)) {
3670     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
3671       /* Those are not currently used, but are accessible through RNA API and were not
3672        * properly initialized previously. This is mere copy of BKE_init_scene() code. */
3673       if (scene->r.im_format.view_settings.look[0] == '\0') {
3674         BKE_color_managed_display_settings_init(&scene->r.im_format.display_settings);
3675         BKE_color_managed_view_settings_init_render(
3676             &scene->r.im_format.view_settings, &scene->r.im_format.display_settings, "Filmic");
3677       }
3678
3679       if (scene->r.bake.im_format.view_settings.look[0] == '\0') {
3680         BKE_color_managed_display_settings_init(&scene->r.bake.im_format.display_settings);
3681         BKE_color_managed_view_settings_init_render(&scene->r.bake.im_format.view_settings,
3682                                                     &scene->r.bake.im_format.display_settings,
3683                                                     "Filmic");
3684       }
3685     }
3686   }
3687
3688   if (!MAIN_VERSION_ATLEAST(bmain, 280, 49)) {
3689     /* All tool names changed, reset to defaults. */
3690     for (WorkSpace *workspace = bmain->workspaces.first; workspace;
3691          workspace = workspace->id.next) {
3692       while (!BLI_listbase_is_empty(&workspace->tools)) {
3693         BKE_workspace_tool_remove(workspace, workspace->tools.first);
3694       }
3695     }
3696   }
3697
3698   if (!MAIN_VERSION_ATLEAST(bmain, 280, 52)) {
3699     LISTBASE_FOREACH (ParticleSettings *, part, &bmain->particles) {
3700       /* Replace deprecated PART_DRAW_BB by PART_DRAW_NOT */
3701       if (part->ren_as == PART_DRAW_BB) {
3702         part->ren_as = PART_DRAW_NOT;
3703       }
3704       if (part->draw_as == PART_DRAW_BB) {
3705         part->draw_as = PART_DRAW_NOT;
3706       }
3707     }
3708
3709     if (!DNA_struct_elem_find(fd->filesdna, "TriangulateModifierData", "int", "min_vertices")) {
3710       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
3711         LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
3712           if (md->type == eModifierType_Triangulate) {
3713             TriangulateModifierData *smd = (TriangulateModifierData *)md;
3714             smd->min_vertices = 4;
3715           }
3716         }
3717       }
3718     }
3719
3720     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
3721       if (ntree->type == NTREE_SHADER) {
3722         LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
3723           /* Fix missing version patching from earlier changes. */
3724           if (STREQ(node->idname, "ShaderNodeOutputLamp")) {
3725             STRNCPY(node->idname, "ShaderNodeOutputLight");
3726           }
3727           if (node->type == SH_NODE_BSDF_PRINCIPLED && node->custom2 == 0) {
3728 &