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