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