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