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