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