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