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