Bevel: Remove Debugging Code
[blender.git] / source / blender / blenloader / intern / versioning_270.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 #include "BLI_utildefines.h"
22 #include "BLI_compiler_attrs.h"
23
24 /* for MinGW32 definition of NULL, could use BLI_blenlib.h instead too */
25 #include <stddef.h>
26
27 /* allow readfile to use deprecated functionality */
28 #define DNA_DEPRECATED_ALLOW
29
30 #include "DNA_anim_types.h"
31 #include "DNA_armature_types.h"
32 #include "DNA_brush_types.h"
33 #include "DNA_camera_types.h"
34 #include "DNA_cloth_types.h"
35 #include "DNA_constraint_types.h"
36 #include "DNA_gpencil_types.h"
37 #include "DNA_sdna_types.h"
38 #include "DNA_sequence_types.h"
39 #include "DNA_space_types.h"
40 #include "DNA_screen_types.h"
41 #include "DNA_object_force_types.h"
42 #include "DNA_object_types.h"
43 #include "DNA_mask_types.h"
44 #include "DNA_mesh_types.h"
45 #include "DNA_modifier_types.h"
46 #include "DNA_particle_types.h"
47 #include "DNA_linestyle_types.h"
48 #include "DNA_view3d_types.h"
49 #include "DNA_fluid_types.h"
50 #include "DNA_rigidbody_types.h"
51 #include "DNA_light_types.h"
52
53 #include "DNA_genfile.h"
54
55 #include "BKE_animsys.h"
56 #include "BKE_colortools.h"
57 #include "BKE_fcurve.h"
58 #include "BKE_main.h"
59 #include "BKE_mask.h"
60 #include "BKE_modifier.h"
61 #include "BKE_node.h"
62 #include "BKE_scene.h"
63 #include "BKE_sequencer.h"
64 #include "BKE_screen.h"
65 #include "BKE_tracking.h"
66
67 #include "BLI_math.h"
68 #include "BLI_listbase.h"
69 #include "BLI_string.h"
70 #include "BLI_string_utils.h"
71
72 #include "BLT_translation.h"
73
74 #include "BLO_readfile.h"
75
76 #include "NOD_common.h"
77 #include "NOD_socket.h"
78 #include "NOD_composite.h"
79
80 #include "readfile.h"
81
82 #include "MEM_guardedalloc.h"
83
84 /* Make preferences read-only, use versioning_userdef.c. */
85 #define U (*((const UserDef *)&U))
86
87 /* ************************************************** */
88 /* GP Palettes API (Deprecated) */
89
90 /* add a new gp-palette */
91 static bGPDpalette *BKE_gpencil_palette_addnew(bGPdata *gpd, const char *name)
92 {
93   bGPDpalette *palette;
94
95   /* check that list is ok */
96   if (gpd == NULL) {
97     return NULL;
98   }
99
100   /* allocate memory and add to end of list */
101   palette = MEM_callocN(sizeof(bGPDpalette), "bGPDpalette");
102
103   /* add to datablock */
104   BLI_addtail(&gpd->palettes, palette);
105
106   /* set basic settings */
107   /* auto-name */
108   BLI_strncpy(palette->info, name, sizeof(palette->info));
109   BLI_uniquename(&gpd->palettes,
110                  palette,
111                  DATA_("GP_Palette"),
112                  '.',
113                  offsetof(bGPDpalette, info),
114                  sizeof(palette->info));
115
116   /* return palette */
117   return palette;
118 }
119
120 /* add a new gp-palettecolor */
121 static bGPDpalettecolor *BKE_gpencil_palettecolor_addnew(bGPDpalette *palette, const char *name)
122 {
123   bGPDpalettecolor *palcolor;
124
125   /* check that list is ok */
126   if (palette == NULL) {
127     return NULL;
128   }
129
130   /* allocate memory and add to end of list */
131   palcolor = MEM_callocN(sizeof(bGPDpalettecolor), "bGPDpalettecolor");
132
133   /* add to datablock */
134   BLI_addtail(&palette->colors, palcolor);
135
136   /* set basic settings */
137   copy_v4_v4(palcolor->color, U.gpencil_new_layer_col);
138   ARRAY_SET_ITEMS(palcolor->fill, 1.0f, 1.0f, 1.0f);
139
140   /* auto-name */
141   BLI_strncpy(palcolor->info, name, sizeof(palcolor->info));
142   BLI_uniquename(&palette->colors,
143                  palcolor,
144                  DATA_("Color"),
145                  '.',
146                  offsetof(bGPDpalettecolor, info),
147                  sizeof(palcolor->info));
148
149   /* return palette color */
150   return palcolor;
151 }
152
153 /**
154  * Setup rotation stabilization from ancient single track spec.
155  * Former Version of 2D stabilization used a single tracking marker to determine the rotation
156  * to be compensated. Now several tracks can contribute to rotation detection and this feature
157  * is enabled by the MovieTrackingTrack#flag on a per track base.
158  */
159 static void migrate_single_rot_stabilization_track_settings(MovieTrackingStabilization *stab)
160 {
161   if (stab->rot_track) {
162     if (!(stab->rot_track->flag & TRACK_USE_2D_STAB_ROT)) {
163       stab->tot_rot_track++;
164       stab->rot_track->flag |= TRACK_USE_2D_STAB_ROT;
165     }
166   }
167   stab->rot_track = NULL; /* this field is now ignored */
168 }
169
170 static void do_version_constraints_radians_degrees_270_1(ListBase *lb)
171 {
172   bConstraint *con;
173
174   for (con = lb->first; con; con = con->next) {
175     if (con->type == CONSTRAINT_TYPE_TRANSFORM) {
176       bTransformConstraint *data = (bTransformConstraint *)con->data;
177       const float deg_to_rad_f = DEG2RADF(1.0f);
178
179       if (data->from == TRANS_ROTATION) {
180         mul_v3_fl(data->from_min, deg_to_rad_f);
181         mul_v3_fl(data->from_max, deg_to_rad_f);
182       }
183
184       if (data->to == TRANS_ROTATION) {
185         mul_v3_fl(data->to_min, deg_to_rad_f);
186         mul_v3_fl(data->to_max, deg_to_rad_f);
187       }
188     }
189   }
190 }
191
192 static void do_version_constraints_radians_degrees_270_5(ListBase *lb)
193 {
194   bConstraint *con;
195
196   for (con = lb->first; con; con = con->next) {
197     if (con->type == CONSTRAINT_TYPE_TRANSFORM) {
198       bTransformConstraint *data = (bTransformConstraint *)con->data;
199
200       if (data->from == TRANS_ROTATION) {
201         copy_v3_v3(data->from_min_rot, data->from_min);
202         copy_v3_v3(data->from_max_rot, data->from_max);
203       }
204       else if (data->from == TRANS_SCALE) {
205         copy_v3_v3(data->from_min_scale, data->from_min);
206         copy_v3_v3(data->from_max_scale, data->from_max);
207       }
208
209       if (data->to == TRANS_ROTATION) {
210         copy_v3_v3(data->to_min_rot, data->to_min);
211         copy_v3_v3(data->to_max_rot, data->to_max);
212       }
213       else if (data->to == TRANS_SCALE) {
214         copy_v3_v3(data->to_min_scale, data->to_min);
215         copy_v3_v3(data->to_max_scale, data->to_max);
216       }
217     }
218   }
219 }
220
221 static void do_version_constraints_stretch_to_limits(ListBase *lb)
222 {
223   bConstraint *con;
224
225   for (con = lb->first; con; con = con->next) {
226     if (con->type == CONSTRAINT_TYPE_STRETCHTO) {
227       bStretchToConstraint *data = (bStretchToConstraint *)con->data;
228       data->bulge_min = 1.0f;
229       data->bulge_max = 1.0f;
230     }
231   }
232 }
233
234 static void do_version_action_editor_properties_region(ListBase *regionbase)
235 {
236   ARegion *ar;
237
238   for (ar = regionbase->first; ar; ar = ar->next) {
239     if (ar->regiontype == RGN_TYPE_UI) {
240       /* already exists */
241       return;
242     }
243     else if (ar->regiontype == RGN_TYPE_WINDOW) {
244       /* add new region here */
245       ARegion *arnew = MEM_callocN(sizeof(ARegion), "buttons for action");
246
247       BLI_insertlinkbefore(regionbase, ar, arnew);
248
249       arnew->regiontype = RGN_TYPE_UI;
250       arnew->alignment = RGN_ALIGN_RIGHT;
251       arnew->flag = RGN_FLAG_HIDDEN;
252
253       return;
254     }
255   }
256 }
257
258 static void do_version_bones_super_bbone(ListBase *lb)
259 {
260   for (Bone *bone = lb->first; bone; bone = bone->next) {
261     bone->scale_in_x = bone->scale_in_y = 1.0f;
262     bone->scale_out_x = bone->scale_out_y = 1.0f;
263
264     do_version_bones_super_bbone(&bone->childbase);
265   }
266 }
267
268 /* TODO(sergey): Consider making it somewhat more generic function in BLI_anim.h. */
269 static void anim_change_prop_name(FCurve *fcu,
270                                   const char *prefix,
271                                   const char *old_prop_name,
272                                   const char *new_prop_name)
273 {
274   const char *old_path = BLI_sprintfN("%s.%s", prefix, old_prop_name);
275   if (STREQ(fcu->rna_path, old_path)) {
276     MEM_freeN(fcu->rna_path);
277     fcu->rna_path = BLI_sprintfN("%s.%s", prefix, new_prop_name);
278   }
279   MEM_freeN((char *)old_path);
280 }
281
282 static void do_version_hue_sat_node(bNodeTree *ntree, bNode *node)
283 {
284   if (node->storage == NULL) {
285     return;
286   }
287
288   /* Make sure new sockets are properly created. */
289   node_verify_socket_templates(ntree, node);
290   /* Convert value from old storage to new sockets. */
291   NodeHueSat *nhs = node->storage;
292   bNodeSocket *hue = nodeFindSocket(node, SOCK_IN, "Hue"),
293               *saturation = nodeFindSocket(node, SOCK_IN, "Saturation"),
294               *value = nodeFindSocket(node, SOCK_IN, "Value");
295   ((bNodeSocketValueFloat *)hue->default_value)->value = nhs->hue;
296   ((bNodeSocketValueFloat *)saturation->default_value)->value = nhs->sat;
297   ((bNodeSocketValueFloat *)value->default_value)->value = nhs->val;
298   /* Take care of possible animation. */
299   AnimData *adt = BKE_animdata_from_id(&ntree->id);
300   if (adt != NULL && adt->action != NULL) {
301     const char *prefix = BLI_sprintfN("nodes[\"%s\"]", node->name);
302     for (FCurve *fcu = adt->action->curves.first; fcu != NULL; fcu = fcu->next) {
303       if (STRPREFIX(fcu->rna_path, prefix)) {
304         anim_change_prop_name(fcu, prefix, "color_hue", "inputs[1].default_value");
305         anim_change_prop_name(fcu, prefix, "color_saturation", "inputs[2].default_value");
306         anim_change_prop_name(fcu, prefix, "color_value", "inputs[3].default_value");
307       }
308     }
309     MEM_freeN((char *)prefix);
310   }
311   /* Free storage, it is no longer used. */
312   MEM_freeN(node->storage);
313   node->storage = NULL;
314 }
315
316 static void do_versions_compositor_render_passes_storage(bNode *node)
317 {
318   int pass_index = 0;
319   const char *sockname;
320   for (bNodeSocket *sock = node->outputs.first; sock && pass_index < 31;
321        sock = sock->next, pass_index++) {
322     if (sock->storage == NULL) {
323       NodeImageLayer *sockdata = MEM_callocN(sizeof(NodeImageLayer), "node image layer");
324       sock->storage = sockdata;
325       BLI_strncpy(sockdata->pass_name,
326                   node_cmp_rlayers_sock_to_pass(pass_index),
327                   sizeof(sockdata->pass_name));
328
329       if (pass_index == 0) {
330         sockname = "Image";
331       }
332       else if (pass_index == 1) {
333         sockname = "Alpha";
334       }
335       else {
336         sockname = node_cmp_rlayers_sock_to_pass(pass_index);
337       }
338       BLI_strncpy(sock->name, sockname, sizeof(sock->name));
339     }
340   }
341 }
342
343 static void do_versions_compositor_render_passes(bNodeTree *ntree)
344 {
345   for (bNode *node = ntree->nodes.first; node; node = node->next) {
346     if (node->type == CMP_NODE_R_LAYERS) {
347       /* First we make sure existing sockets have proper names.
348        * This is important because otherwise verification will
349        * drop links from sockets which were renamed.
350        */
351       do_versions_compositor_render_passes_storage(node);
352       /* Make sure new sockets are properly created. */
353       node_verify_socket_templates(ntree, node);
354       /* Make sure all possibly created sockets have proper storage. */
355       do_versions_compositor_render_passes_storage(node);
356     }
357   }
358 }
359
360 static char *replace_bbone_easing_rnapath(char *old_path)
361 {
362   char *new_path = NULL;
363
364   /* NOTE: This will break paths for any bones/custom-properties
365    * which happen be named after the bbone property id's
366    */
367   if (strstr(old_path, "bbone_in")) {
368     new_path = BLI_str_replaceN(old_path, "bbone_in", "bbone_easein");
369   }
370   else if (strstr(old_path, "bbone_out")) {
371     new_path = BLI_str_replaceN(old_path, "bbone_out", "bbone_easeout");
372   }
373
374   if (new_path) {
375     MEM_freeN(old_path);
376     return new_path;
377   }
378   else {
379     return old_path;
380   }
381 }
382
383 static void do_version_bbone_easing_fcurve_fix(ID *UNUSED(id),
384                                                FCurve *fcu,
385                                                void *UNUSED(user_data))
386 {
387   /* F-Curve's path (for bbone_in/out) */
388   if (fcu->rna_path) {
389     fcu->rna_path = replace_bbone_easing_rnapath(fcu->rna_path);
390   }
391
392   /* Driver -> Driver Vars (for bbone_in/out) */
393   if (fcu->driver) {
394     for (DriverVar *dvar = fcu->driver->variables.first; dvar; dvar = dvar->next) {
395       DRIVER_TARGETS_LOOPER_BEGIN (dvar) {
396         if (dtar->rna_path) {
397           dtar->rna_path = replace_bbone_easing_rnapath(dtar->rna_path);
398         }
399       }
400       DRIVER_TARGETS_LOOPER_END;
401     }
402   }
403
404   /* FModifiers -> Stepped (for frame_start/end) */
405   if (fcu->modifiers.first) {
406     for (FModifier *fcm = fcu->modifiers.first; fcm; fcm = fcm->next) {
407       if (fcm->type == FMODIFIER_TYPE_STEPPED) {
408         FMod_Stepped *data = fcm->data;
409
410         /* Modifier doesn't work if the modifier's copy of start/end frame are both 0
411          * as those were only getting written to the fcm->data copy (T52009)
412          */
413         if ((fcm->sfra == fcm->efra) && (fcm->sfra == 0)) {
414           fcm->sfra = data->start_frame;
415           fcm->efra = data->end_frame;
416         }
417       }
418     }
419   }
420 }
421
422 void blo_do_versions_270(FileData *fd, Library *UNUSED(lib), Main *bmain)
423 {
424   if (!MAIN_VERSION_ATLEAST(bmain, 270, 0)) {
425
426     if (!DNA_struct_elem_find(fd->filesdna, "BevelModifierData", "float", "profile")) {
427       Object *ob;
428
429       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
430         ModifierData *md;
431         for (md = ob->modifiers.first; md; md = md->next) {
432           if (md->type == eModifierType_Bevel) {
433             BevelModifierData *bmd = (BevelModifierData *)md;
434             bmd->profile = 0.5f;
435             bmd->val_flags = MOD_BEVEL_AMT_OFFSET;
436           }
437         }
438       }
439     }
440
441     /* nodes don't use fixed node->id any more, clean up */
442     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
443       if (ntree->type == NTREE_COMPOSIT) {
444         bNode *node;
445         for (node = ntree->nodes.first; node; node = node->next) {
446           if (ELEM(node->type, CMP_NODE_COMPOSITE, CMP_NODE_OUTPUT_FILE)) {
447             node->id = NULL;
448           }
449         }
450       }
451     }
452     FOREACH_NODETREE_END;
453
454     {
455       bScreen *screen;
456
457       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
458         ScrArea *area;
459         for (area = screen->areabase.first; area; area = area->next) {
460           SpaceLink *space_link;
461           for (space_link = area->spacedata.first; space_link; space_link = space_link->next) {
462             if (space_link->spacetype == SPACE_CLIP) {
463               SpaceClip *space_clip = (SpaceClip *)space_link;
464               if (space_clip->mode != SC_MODE_MASKEDIT) {
465                 space_clip->mode = SC_MODE_TRACKING;
466               }
467             }
468           }
469         }
470       }
471     }
472
473     if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingSettings", "float", "default_weight")) {
474       MovieClip *clip;
475       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
476         clip->tracking.settings.default_weight = 1.0f;
477       }
478     }
479   }
480
481   if (!MAIN_VERSION_ATLEAST(bmain, 270, 1)) {
482     Object *ob;
483
484     /* Update Transform constraint (another deg -> rad stuff). */
485     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
486       do_version_constraints_radians_degrees_270_1(&ob->constraints);
487
488       if (ob->pose) {
489         /* Bones constraints! */
490         bPoseChannel *pchan;
491         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
492           do_version_constraints_radians_degrees_270_1(&pchan->constraints);
493         }
494       }
495     }
496   }
497
498   if (!MAIN_VERSION_ATLEAST(bmain, 270, 2)) {
499     Mesh *me;
500
501     /* Mesh smoothresh deg->rad. */
502     for (me = bmain->meshes.first; me; me = me->id.next) {
503       me->smoothresh = DEG2RADF(me->smoothresh);
504     }
505   }
506
507   if (!MAIN_VERSION_ATLEAST(bmain, 270, 3)) {
508     FreestyleLineStyle *linestyle;
509
510     for (linestyle = bmain->linestyles.first; linestyle; linestyle = linestyle->id.next) {
511       linestyle->flag |= LS_NO_SORTING;
512       linestyle->sort_key = LS_SORT_KEY_DISTANCE_FROM_CAMERA;
513       linestyle->integration_type = LS_INTEGRATION_MEAN;
514     }
515   }
516
517   if (!MAIN_VERSION_ATLEAST(bmain, 270, 4)) {
518     /* ui_previews were not handled correctly when copying areas,
519      * leading to corrupted files (see T39847).
520      * This will always reset situation to a valid state.
521      */
522     bScreen *sc;
523
524     for (sc = bmain->screens.first; sc; sc = sc->id.next) {
525       ScrArea *sa;
526       for (sa = sc->areabase.first; sa; sa = sa->next) {
527         SpaceLink *sl;
528
529         for (sl = sa->spacedata.first; sl; sl = sl->next) {
530           ARegion *ar;
531           ListBase *lb = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase;
532
533           for (ar = lb->first; ar; ar = ar->next) {
534             BLI_listbase_clear(&ar->ui_previews);
535           }
536         }
537       }
538     }
539   }
540
541   if (!MAIN_VERSION_ATLEAST(bmain, 270, 5)) {
542     Object *ob;
543
544     /* Update Transform constraint (again :|). */
545     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
546       do_version_constraints_radians_degrees_270_5(&ob->constraints);
547
548       if (ob->pose) {
549         /* Bones constraints! */
550         bPoseChannel *pchan;
551         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
552           do_version_constraints_radians_degrees_270_5(&pchan->constraints);
553         }
554       }
555     }
556   }
557
558   if (!MAIN_VERSION_ATLEAST(bmain, 271, 0)) {
559     if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "BakeData", "bake")) {
560       Scene *sce;
561
562       for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
563         sce->r.bake.flag = R_BAKE_CLEAR;
564         sce->r.bake.width = 512;
565         sce->r.bake.height = 512;
566         sce->r.bake.margin = 16;
567         sce->r.bake.normal_space = R_BAKE_SPACE_TANGENT;
568         sce->r.bake.normal_swizzle[0] = R_BAKE_POSX;
569         sce->r.bake.normal_swizzle[1] = R_BAKE_POSY;
570         sce->r.bake.normal_swizzle[2] = R_BAKE_POSZ;
571         BLI_strncpy(sce->r.bake.filepath, U.renderdir, sizeof(sce->r.bake.filepath));
572
573         sce->r.bake.im_format.planes = R_IMF_PLANES_RGBA;
574         sce->r.bake.im_format.imtype = R_IMF_IMTYPE_PNG;
575         sce->r.bake.im_format.depth = R_IMF_CHAN_DEPTH_8;
576         sce->r.bake.im_format.quality = 90;
577         sce->r.bake.im_format.compress = 15;
578       }
579     }
580
581     if (!DNA_struct_elem_find(fd->filesdna, "FreestyleLineStyle", "float", "texstep")) {
582       FreestyleLineStyle *linestyle;
583
584       for (linestyle = bmain->linestyles.first; linestyle; linestyle = linestyle->id.next) {
585         linestyle->flag |= LS_TEXTURE;
586         linestyle->texstep = 1.0;
587       }
588     }
589
590     {
591       Scene *scene;
592       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
593         int num_layers = BLI_listbase_count(&scene->r.layers);
594         scene->r.actlay = min_ff(scene->r.actlay, num_layers - 1);
595       }
596     }
597   }
598
599   if (!MAIN_VERSION_ATLEAST(bmain, 271, 1)) {
600     if (!DNA_struct_elem_find(fd->filesdna, "Material", "float", "line_col[4]")) {
601       Material *mat;
602
603       for (mat = bmain->materials.first; mat; mat = mat->id.next) {
604         mat->line_col[0] = mat->line_col[1] = mat->line_col[2] = 0.0f;
605         mat->line_col[3] = mat->alpha;
606       }
607     }
608
609     if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "int", "preview_start_resolution")) {
610       Scene *scene;
611       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
612         scene->r.preview_start_resolution = 64;
613       }
614     }
615   }
616
617   if (!MAIN_VERSION_ATLEAST(bmain, 271, 3)) {
618     Brush *br;
619
620     for (br = bmain->brushes.first; br; br = br->id.next) {
621       br->fill_threshold = 0.2f;
622     }
623
624     if (!DNA_struct_elem_find(fd->filesdna, "BevelModifierData", "int", "mat")) {
625       Object *ob;
626       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
627         ModifierData *md;
628
629         for (md = ob->modifiers.first; md; md = md->next) {
630           if (md->type == eModifierType_Bevel) {
631             BevelModifierData *bmd = (BevelModifierData *)md;
632             bmd->mat = -1;
633           }
634         }
635       }
636     }
637   }
638
639   if (!MAIN_VERSION_ATLEAST(bmain, 271, 6)) {
640     Object *ob;
641     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
642       ModifierData *md;
643
644       for (md = ob->modifiers.first; md; md = md->next) {
645         if (md->type == eModifierType_ParticleSystem) {
646           ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
647           if (pmd->psys && pmd->psys->clmd) {
648             pmd->psys->clmd->sim_parms->vel_damping = 1.0f;
649           }
650         }
651       }
652     }
653   }
654
655   if (!MAIN_VERSION_ATLEAST(bmain, 272, 0)) {
656     if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "int", "preview_start_resolution")) {
657       Scene *scene;
658       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
659         scene->r.preview_start_resolution = 64;
660       }
661     }
662   }
663
664   if (!MAIN_VERSION_ATLEAST(bmain, 272, 1)) {
665     Brush *br;
666     for (br = bmain->brushes.first; br; br = br->id.next) {
667       if ((br->ob_mode & OB_MODE_SCULPT) &&
668           ELEM(br->sculpt_tool, SCULPT_TOOL_GRAB, SCULPT_TOOL_SNAKE_HOOK)) {
669         br->alpha = 1.0f;
670       }
671     }
672   }
673
674   if (!MAIN_VERSION_ATLEAST(bmain, 272, 2)) {
675     if (!DNA_struct_elem_find(fd->filesdna, "Image", "float", "gen_color")) {
676       Image *image;
677       for (image = bmain->images.first; image != NULL; image = image->id.next) {
678         image->gen_color[3] = 1.0f;
679       }
680     }
681
682     if (!DNA_struct_elem_find(fd->filesdna, "bStretchToConstraint", "float", "bulge_min")) {
683       Object *ob;
684
685       /* Update Transform constraint (again :|). */
686       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
687         do_version_constraints_stretch_to_limits(&ob->constraints);
688
689         if (ob->pose) {
690           /* Bones constraints! */
691           bPoseChannel *pchan;
692           for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
693             do_version_constraints_stretch_to_limits(&pchan->constraints);
694           }
695         }
696       }
697     }
698   }
699
700   if (!MAIN_VERSION_ATLEAST(bmain, 273, 1)) {
701 #define BRUSH_RAKE (1 << 7)
702 #define BRUSH_RANDOM_ROTATION (1 << 25)
703
704     Brush *br;
705
706     for (br = bmain->brushes.first; br; br = br->id.next) {
707       if (br->flag & BRUSH_RAKE) {
708         br->mtex.brush_angle_mode |= MTEX_ANGLE_RAKE;
709         br->mask_mtex.brush_angle_mode |= MTEX_ANGLE_RAKE;
710       }
711       else if (br->flag & BRUSH_RANDOM_ROTATION) {
712         br->mtex.brush_angle_mode |= MTEX_ANGLE_RANDOM;
713         br->mask_mtex.brush_angle_mode |= MTEX_ANGLE_RANDOM;
714       }
715       br->mtex.random_angle = 2.0 * M_PI;
716       br->mask_mtex.random_angle = 2.0 * M_PI;
717     }
718   }
719
720 #undef BRUSH_RAKE
721 #undef BRUSH_RANDOM_ROTATION
722
723   /* Customizable Safe Areas */
724   if (!MAIN_VERSION_ATLEAST(bmain, 273, 2)) {
725     if (!DNA_struct_elem_find(fd->filesdna, "Scene", "DisplaySafeAreas", "safe_areas")) {
726       Scene *scene;
727
728       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
729         copy_v2_fl2(scene->safe_areas.title, 3.5f / 100.0f, 3.5f / 100.0f);
730         copy_v2_fl2(scene->safe_areas.action, 10.0f / 100.0f, 5.0f / 100.0f);
731         copy_v2_fl2(scene->safe_areas.title_center, 17.5f / 100.0f, 5.0f / 100.0f);
732         copy_v2_fl2(scene->safe_areas.action_center, 15.0f / 100.0f, 5.0f / 100.0f);
733       }
734     }
735   }
736
737   if (!MAIN_VERSION_ATLEAST(bmain, 273, 3)) {
738     ParticleSettings *part;
739     for (part = bmain->particles.first; part; part = part->id.next) {
740       if (part->clumpcurve) {
741         part->child_flag |= PART_CHILD_USE_CLUMP_CURVE;
742       }
743       if (part->roughcurve) {
744         part->child_flag |= PART_CHILD_USE_ROUGH_CURVE;
745       }
746     }
747   }
748
749   if (!MAIN_VERSION_ATLEAST(bmain, 273, 6)) {
750     if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "float", "bending_damping")) {
751       Object *ob;
752       ModifierData *md;
753       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
754         for (md = ob->modifiers.first; md; md = md->next) {
755           if (md->type == eModifierType_Cloth) {
756             ClothModifierData *clmd = (ClothModifierData *)md;
757             clmd->sim_parms->bending_damping = 0.5f;
758           }
759           else if (md->type == eModifierType_ParticleSystem) {
760             ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
761             if (pmd->psys->clmd) {
762               pmd->psys->clmd->sim_parms->bending_damping = 0.5f;
763             }
764           }
765         }
766       }
767     }
768
769     if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "float", "clump_noise_size")) {
770       ParticleSettings *part;
771       for (part = bmain->particles.first; part; part = part->id.next) {
772         part->clump_noise_size = 1.0f;
773       }
774     }
775
776     if (!DNA_struct_elem_find(fd->filesdna, "ParticleSettings", "int", "kink_extra_steps")) {
777       ParticleSettings *part;
778       for (part = bmain->particles.first; part; part = part->id.next) {
779         part->kink_extra_steps = 4;
780       }
781     }
782
783     if (!DNA_struct_elem_find(fd->filesdna, "MTex", "float", "kinkampfac")) {
784       ParticleSettings *part;
785       for (part = bmain->particles.first; part; part = part->id.next) {
786         int a;
787         for (a = 0; a < MAX_MTEX; a++) {
788           MTex *mtex = part->mtex[a];
789           if (mtex) {
790             mtex->kinkampfac = 1.0f;
791           }
792         }
793       }
794     }
795
796     if (!DNA_struct_elem_find(fd->filesdna, "HookModifierData", "char", "flag")) {
797       Object *ob;
798
799       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
800         ModifierData *md;
801         for (md = ob->modifiers.first; md; md = md->next) {
802           if (md->type == eModifierType_Hook) {
803             HookModifierData *hmd = (HookModifierData *)md;
804             hmd->falloff_type = eHook_Falloff_InvSquare;
805           }
806         }
807       }
808     }
809
810     if (!DNA_struct_elem_find(fd->filesdna, "NodePlaneTrackDeformData", "char", "flag")) {
811       FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
812         if (ntree->type == NTREE_COMPOSIT) {
813           bNode *node;
814           for (node = ntree->nodes.first; node; node = node->next) {
815             if (ELEM(node->type, CMP_NODE_PLANETRACKDEFORM)) {
816               NodePlaneTrackDeformData *data = node->storage;
817               data->flag = 0;
818               data->motion_blur_samples = 16;
819               data->motion_blur_shutter = 0.5f;
820             }
821           }
822         }
823       }
824       FOREACH_NODETREE_END;
825     }
826
827     if (!DNA_struct_elem_find(fd->filesdna, "Camera", "GPUDOFSettings", "gpu_dof")) {
828       Camera *ca;
829       for (ca = bmain->cameras.first; ca; ca = ca->id.next) {
830         ca->gpu_dof.fstop = 128.0f;
831         ca->gpu_dof.focal_length = 1.0f;
832         ca->gpu_dof.focus_distance = 1.0f;
833         ca->gpu_dof.sensor = 1.0f;
834       }
835     }
836   }
837
838   if (!MAIN_VERSION_ATLEAST(bmain, 273, 8)) {
839     Object *ob;
840     for (ob = bmain->objects.first; ob != NULL; ob = ob->id.next) {
841       ModifierData *md;
842       for (md = ob->modifiers.last; md != NULL; md = md->prev) {
843         if (modifier_unique_name(&ob->modifiers, md)) {
844           printf(
845               "Warning: Object '%s' had several modifiers with the "
846               "same name, renamed one of them to '%s'.\n",
847               ob->id.name + 2,
848               md->name);
849         }
850       }
851     }
852   }
853
854   if (!MAIN_VERSION_ATLEAST(bmain, 273, 9)) {
855     bScreen *scr;
856     ScrArea *sa;
857     SpaceLink *sl;
858     ARegion *ar;
859
860     /* Make sure sequencer preview area limits zoom */
861     for (scr = bmain->screens.first; scr; scr = scr->id.next) {
862       for (sa = scr->areabase.first; sa; sa = sa->next) {
863         for (sl = sa->spacedata.first; sl; sl = sl->next) {
864           if (sl->spacetype == SPACE_SEQ) {
865             for (ar = sl->regionbase.first; ar; ar = ar->next) {
866               if (ar->regiontype == RGN_TYPE_PREVIEW) {
867                 ar->v2d.keepzoom |= V2D_LIMITZOOM;
868                 ar->v2d.minzoom = 0.001f;
869                 ar->v2d.maxzoom = 1000.0f;
870                 break;
871               }
872             }
873           }
874         }
875       }
876     }
877   }
878
879   if (!MAIN_VERSION_ATLEAST(bmain, 274, 1)) {
880     /* particle systems need to be forced to redistribute for jitter mode fix */
881     {
882       Object *ob;
883       ParticleSystem *psys;
884       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
885         for (psys = ob->particlesystem.first; psys; psys = psys->next) {
886           if ((psys->pointcache->flag & PTCACHE_BAKED) == 0) {
887             psys->recalc |= ID_RECALC_PSYS_RESET;
888           }
889         }
890       }
891     }
892
893     /* hysteresis set to 10% but not activated */
894     if (!DNA_struct_elem_find(fd->filesdna, "LodLevel", "int", "obhysteresis")) {
895       Object *ob;
896       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
897         LodLevel *level;
898         for (level = ob->lodlevels.first; level; level = level->next) {
899           level->obhysteresis = 10;
900         }
901       }
902     }
903   }
904
905   if (!MAIN_VERSION_ATLEAST(bmain, 274, 4)) {
906     SceneRenderView *srv;
907     wmWindowManager *wm;
908     bScreen *screen;
909     wmWindow *win;
910     Scene *scene;
911     Camera *cam;
912     Image *ima;
913
914     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
915       Sequence *seq;
916
917       BKE_scene_add_render_view(scene, STEREO_LEFT_NAME);
918       srv = scene->r.views.first;
919       BLI_strncpy(srv->suffix, STEREO_LEFT_SUFFIX, sizeof(srv->suffix));
920
921       BKE_scene_add_render_view(scene, STEREO_RIGHT_NAME);
922       srv = scene->r.views.last;
923       BLI_strncpy(srv->suffix, STEREO_RIGHT_SUFFIX, sizeof(srv->suffix));
924
925       SEQ_BEGIN (scene->ed, seq) {
926         seq->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Stereo Display 3d Format");
927
928 #define SEQ_USE_PROXY_CUSTOM_DIR (1 << 19)
929 #define SEQ_USE_PROXY_CUSTOM_FILE (1 << 21)
930         if (seq->strip && seq->strip->proxy && !seq->strip->proxy->storage) {
931           if (seq->flag & SEQ_USE_PROXY_CUSTOM_DIR) {
932             seq->strip->proxy->storage = SEQ_STORAGE_PROXY_CUSTOM_DIR;
933           }
934           if (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE) {
935             seq->strip->proxy->storage = SEQ_STORAGE_PROXY_CUSTOM_FILE;
936           }
937         }
938 #undef SEQ_USE_PROXY_CUSTOM_DIR
939 #undef SEQ_USE_PROXY_CUSTOM_FILE
940       }
941       SEQ_END;
942     }
943
944     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
945       ScrArea *sa;
946       for (sa = screen->areabase.first; sa; sa = sa->next) {
947         SpaceLink *sl;
948
949         for (sl = sa->spacedata.first; sl; sl = sl->next) {
950           switch (sl->spacetype) {
951             case SPACE_VIEW3D: {
952               View3D *v3d = (View3D *)sl;
953               v3d->stereo3d_camera = STEREO_3D_ID;
954               v3d->stereo3d_flag |= V3D_S3D_DISPPLANE;
955               v3d->stereo3d_convergence_alpha = 0.15f;
956               v3d->stereo3d_volume_alpha = 0.05f;
957               break;
958             }
959             case SPACE_IMAGE: {
960               SpaceImage *sima = (SpaceImage *)sl;
961               sima->iuser.flag |= IMA_SHOW_STEREO;
962               break;
963             }
964           }
965         }
966       }
967     }
968
969     for (cam = bmain->cameras.first; cam; cam = cam->id.next) {
970       cam->stereo.interocular_distance = 0.065f;
971       cam->stereo.convergence_distance = 30.0f * 0.065f;
972     }
973
974     for (ima = bmain->images.first; ima; ima = ima->id.next) {
975       ima->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Image Stereo 3d Format");
976
977       if (ima->packedfile) {
978         ImagePackedFile *imapf = MEM_mallocN(sizeof(ImagePackedFile), "Image Packed File");
979         BLI_addtail(&ima->packedfiles, imapf);
980
981         imapf->packedfile = ima->packedfile;
982         BLI_strncpy(imapf->filepath, ima->name, FILE_MAX);
983         ima->packedfile = NULL;
984       }
985     }
986
987     for (wm = bmain->wm.first; wm; wm = wm->id.next) {
988       for (win = wm->windows.first; win; win = win->next) {
989         win->stereo3d_format = MEM_callocN(sizeof(Stereo3dFormat), "Stereo Display 3d Format");
990       }
991     }
992   }
993
994   if (!MAIN_VERSION_ATLEAST(bmain, 274, 6)) {
995     bScreen *screen;
996
997     if (!DNA_struct_elem_find(fd->filesdna, "FileSelectParams", "int", "thumbnail_size")) {
998       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
999         ScrArea *sa;
1000
1001         for (sa = screen->areabase.first; sa; sa = sa->next) {
1002           SpaceLink *sl;
1003
1004           for (sl = sa->spacedata.first; sl; sl = sl->next) {
1005             if (sl->spacetype == SPACE_FILE) {
1006               SpaceFile *sfile = (SpaceFile *)sl;
1007
1008               if (sfile->params) {
1009                 sfile->params->thumbnail_size = 128;
1010               }
1011             }
1012           }
1013         }
1014       }
1015     }
1016
1017     if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "short", "simplify_subsurf_render")) {
1018       Scene *scene;
1019       for (scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) {
1020         scene->r.simplify_subsurf_render = scene->r.simplify_subsurf;
1021         scene->r.simplify_particles_render = scene->r.simplify_particles;
1022       }
1023     }
1024
1025     if (!DNA_struct_elem_find(fd->filesdna, "DecimateModifierData", "float", "defgrp_factor")) {
1026       Object *ob;
1027
1028       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1029         ModifierData *md;
1030         for (md = ob->modifiers.first; md; md = md->next) {
1031           if (md->type == eModifierType_Decimate) {
1032             DecimateModifierData *dmd = (DecimateModifierData *)md;
1033             dmd->defgrp_factor = 1.0f;
1034           }
1035         }
1036       }
1037     }
1038   }
1039
1040   if (!MAIN_VERSION_ATLEAST(bmain, 275, 3)) {
1041     Brush *br;
1042 #define BRUSH_TORUS (1 << 1)
1043     for (br = bmain->brushes.first; br; br = br->id.next) {
1044       br->flag &= ~BRUSH_TORUS;
1045     }
1046 #undef BRUSH_TORUS
1047   }
1048
1049   if (!MAIN_VERSION_ATLEAST(bmain, 276, 2)) {
1050     if (!DNA_struct_elem_find(fd->filesdna, "bPoseChannel", "float", "custom_scale")) {
1051       Object *ob;
1052
1053       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1054         if (ob->pose) {
1055           bPoseChannel *pchan;
1056           for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1057             pchan->custom_scale = 1.0f;
1058           }
1059         }
1060       }
1061     }
1062
1063     {
1064       bScreen *screen;
1065 #define RV3D_VIEW_PERSPORTHO 7
1066       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1067         ScrArea *sa;
1068         for (sa = screen->areabase.first; sa; sa = sa->next) {
1069           SpaceLink *sl;
1070           for (sl = sa->spacedata.first; sl; sl = sl->next) {
1071             if (sl->spacetype == SPACE_VIEW3D) {
1072               ARegion *ar;
1073               ListBase *lb = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase;
1074               for (ar = lb->first; ar; ar = ar->next) {
1075                 if (ar->regiontype == RGN_TYPE_WINDOW) {
1076                   if (ar->regiondata) {
1077                     RegionView3D *rv3d = ar->regiondata;
1078                     if (rv3d->view == RV3D_VIEW_PERSPORTHO) {
1079                       rv3d->view = RV3D_VIEW_USER;
1080                     }
1081                   }
1082                 }
1083               }
1084               break;
1085             }
1086           }
1087         }
1088       }
1089 #undef RV3D_VIEW_PERSPORTHO
1090     }
1091
1092     {
1093 #define LA_YF_PHOTON 5
1094       for (Light *la = bmain->lights.first; la; la = la->id.next) {
1095         if (la->type == LA_YF_PHOTON) {
1096           la->type = LA_LOCAL;
1097         }
1098       }
1099 #undef LA_YF_PHOTON
1100     }
1101   }
1102
1103   if (!MAIN_VERSION_ATLEAST(bmain, 276, 3)) {
1104     if (!DNA_struct_elem_find(fd->filesdna, "RenderData", "CurveMapping", "mblur_shutter_curve")) {
1105       Scene *scene;
1106       for (scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) {
1107         CurveMapping *curve_mapping = &scene->r.mblur_shutter_curve;
1108         BKE_curvemapping_set_defaults(curve_mapping, 1, 0.0f, 0.0f, 1.0f, 1.0f);
1109         BKE_curvemapping_initialize(curve_mapping);
1110         BKE_curvemap_reset(
1111             curve_mapping->cm, &curve_mapping->clipr, CURVE_PRESET_MAX, CURVEMAP_SLOPE_POS_NEG);
1112       }
1113     }
1114   }
1115
1116   if (!MAIN_VERSION_ATLEAST(bmain, 276, 4)) {
1117     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1118       ToolSettings *ts = scene->toolsettings;
1119
1120       if (ts->gp_sculpt.brush[0].size == 0) {
1121         GP_Sculpt_Settings *gset = &ts->gp_sculpt;
1122         GP_Sculpt_Data *brush;
1123
1124         brush = &gset->brush[GP_SCULPT_TYPE_SMOOTH];
1125         brush->size = 25;
1126         brush->strength = 0.3f;
1127         brush->flag = GP_SCULPT_FLAG_USE_FALLOFF | GP_SCULPT_FLAG_SMOOTH_PRESSURE;
1128
1129         brush = &gset->brush[GP_SCULPT_TYPE_THICKNESS];
1130         brush->size = 25;
1131         brush->strength = 0.5f;
1132         brush->flag = GP_SCULPT_FLAG_USE_FALLOFF;
1133
1134         brush = &gset->brush[GP_SCULPT_TYPE_GRAB];
1135         brush->size = 50;
1136         brush->strength = 0.3f;
1137         brush->flag = GP_SCULPT_FLAG_USE_FALLOFF;
1138
1139         brush = &gset->brush[GP_SCULPT_TYPE_PUSH];
1140         brush->size = 25;
1141         brush->strength = 0.3f;
1142         brush->flag = GP_SCULPT_FLAG_USE_FALLOFF;
1143
1144         brush = &gset->brush[GP_SCULPT_TYPE_TWIST];
1145         brush->size = 50;
1146         brush->strength = 0.3f;  // XXX?
1147         brush->flag = GP_SCULPT_FLAG_USE_FALLOFF;
1148
1149         brush = &gset->brush[GP_SCULPT_TYPE_PINCH];
1150         brush->size = 50;
1151         brush->strength = 0.5f;  // XXX?
1152         brush->flag = GP_SCULPT_FLAG_USE_FALLOFF;
1153
1154         brush = &gset->brush[GP_SCULPT_TYPE_RANDOMIZE];
1155         brush->size = 25;
1156         brush->strength = 0.5f;
1157         brush->flag = GP_SCULPT_FLAG_USE_FALLOFF;
1158
1159         brush = &gset->brush[GP_SCULPT_TYPE_CLONE];
1160         brush->size = 50;
1161         brush->strength = 1.0f;
1162       }
1163
1164       if (!DNA_struct_elem_find(fd->filesdna, "ToolSettings", "char", "gpencil_v3d_align")) {
1165 #if 0 /* XXX: Cannot do this, as we get random crashes... */
1166         if (scene->gpd) {
1167           bGPdata *gpd = scene->gpd;
1168
1169           /* Copy over the settings stored in the GP data-block linked to the scene,
1170            * for minimal disruption. */
1171           ts->gpencil_v3d_align = 0;
1172
1173           if (gpd->flag & GP_DATA_VIEWALIGN) {
1174             ts->gpencil_v3d_align |= GP_PROJECT_VIEWSPACE;
1175           }
1176           if (gpd->flag & GP_DATA_DEPTH_VIEW) {
1177             ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_VIEW;
1178           }
1179           if (gpd->flag & GP_DATA_DEPTH_STROKE) {
1180             ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_STROKE;
1181           }
1182
1183           if (gpd->flag & GP_DATA_DEPTH_STROKE_ENDPOINTS) {
1184             ts->gpencil_v3d_align |= GP_PROJECT_DEPTH_STROKE_ENDPOINTS;
1185           }
1186         }
1187         else {
1188           /* Default to cursor for all standard 3D views */
1189           ts->gpencil_v3d_align = GP_PROJECT_VIEWSPACE;
1190         }
1191 #endif
1192
1193         ts->gpencil_v3d_align = GP_PROJECT_VIEWSPACE;
1194         ts->gpencil_v2d_align = GP_PROJECT_VIEWSPACE;
1195         ts->gpencil_seq_align = GP_PROJECT_VIEWSPACE;
1196         ts->gpencil_ima_align = GP_PROJECT_VIEWSPACE;
1197       }
1198     }
1199
1200     for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1201       bool enabled = false;
1202
1203       /* Ensure that the datablock's onion-skinning toggle flag
1204        * stays in sync with the status of the actual layers
1205        */
1206       for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1207         if (gpl->flag & GP_LAYER_ONIONSKIN) {
1208           enabled = true;
1209         }
1210       }
1211
1212       if (enabled) {
1213         gpd->flag |= GP_DATA_SHOW_ONIONSKINS;
1214       }
1215       else {
1216         gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
1217       }
1218     }
1219   }
1220   if (!MAIN_VERSION_ATLEAST(bmain, 276, 5)) {
1221     ListBase *lbarray[MAX_LIBARRAY];
1222     int a;
1223
1224     /* Important to clear all non-persistent flags from older versions here,
1225      * otherwise they could collide with any new persistent flag we may add in the future. */
1226     a = set_listbasepointers(bmain, lbarray);
1227     while (a--) {
1228       for (ID *id = lbarray[a]->first; id; id = id->next) {
1229         id->flag &= LIB_FAKEUSER;
1230       }
1231     }
1232   }
1233
1234   if (!MAIN_VERSION_ATLEAST(bmain, 276, 7)) {
1235     Scene *scene;
1236     for (scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) {
1237       scene->r.bake.pass_filter = R_BAKE_PASS_FILTER_ALL;
1238     }
1239   }
1240
1241   if (!MAIN_VERSION_ATLEAST(bmain, 277, 1)) {
1242     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1243       ParticleEditSettings *pset = &scene->toolsettings->particle;
1244       for (int a = 0; a < ARRAY_SIZE(pset->brush); a++) {
1245         if (pset->brush[a].strength > 1.0f) {
1246           pset->brush[a].strength *= 0.01f;
1247         }
1248       }
1249     }
1250
1251     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1252       for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
1253         for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) {
1254           ListBase *regionbase = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase;
1255           /* Bug: Was possible to add preview region to sequencer view by using AZones. */
1256           if (sl->spacetype == SPACE_SEQ) {
1257             SpaceSeq *sseq = (SpaceSeq *)sl;
1258             if (sseq->view == SEQ_VIEW_SEQUENCE) {
1259               for (ARegion *ar = regionbase->first; ar; ar = ar->next) {
1260                 /* remove preview region for sequencer-only view! */
1261                 if (ar->regiontype == RGN_TYPE_PREVIEW) {
1262                   ar->flag |= RGN_FLAG_HIDDEN;
1263                   ar->alignment = RGN_ALIGN_NONE;
1264                   break;
1265                 }
1266               }
1267             }
1268           }
1269           /* Remove old deprecated region from filebrowsers */
1270           else if (sl->spacetype == SPACE_FILE) {
1271             for (ARegion *ar = regionbase->first; ar; ar = ar->next) {
1272               if (ar->regiontype == RGN_TYPE_CHANNELS) {
1273                 /* Free old deprecated 'channel' region... */
1274                 BKE_area_region_free(NULL, ar);
1275                 BLI_freelinkN(regionbase, ar);
1276                 break;
1277               }
1278             }
1279           }
1280         }
1281       }
1282     }
1283
1284     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1285       CurvePaintSettings *cps = &scene->toolsettings->curve_paint_settings;
1286       if (cps->error_threshold == 0) {
1287         cps->curve_type = CU_BEZIER;
1288         cps->flag |= CURVE_PAINT_FLAG_CORNERS_DETECT;
1289         cps->error_threshold = 8;
1290         cps->radius_max = 1.0f;
1291         cps->corner_angle = DEG2RADF(70.0f);
1292       }
1293     }
1294
1295     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1296       Sequence *seq;
1297
1298       SEQ_BEGIN (scene->ed, seq) {
1299         if (seq->type != SEQ_TYPE_TEXT) {
1300           continue;
1301         }
1302
1303         if (seq->effectdata == NULL) {
1304           struct SeqEffectHandle effect_handle = BKE_sequence_get_effect(seq);
1305           effect_handle.init(seq);
1306         }
1307
1308         TextVars *data = seq->effectdata;
1309         if (data->color[3] == 0.0f) {
1310           copy_v4_fl(data->color, 1.0f);
1311           data->shadow_color[3] = 1.0f;
1312         }
1313       }
1314       SEQ_END;
1315     }
1316
1317     /* Adding "Properties" region to DopeSheet */
1318     for (bScreen *screen = bmain->screens.first; screen; screen = screen->id.next) {
1319       for (ScrArea *sa = screen->areabase.first; sa; sa = sa->next) {
1320         /* handle pushed-back space data first */
1321         for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) {
1322           if (sl->spacetype == SPACE_ACTION) {
1323             SpaceAction *saction = (SpaceAction *)sl;
1324             do_version_action_editor_properties_region(&saction->regionbase);
1325           }
1326         }
1327
1328         /* active spacedata info must be handled too... */
1329         if (sa->spacetype == SPACE_ACTION) {
1330           do_version_action_editor_properties_region(&sa->regionbase);
1331         }
1332       }
1333     }
1334   }
1335
1336   if (!MAIN_VERSION_ATLEAST(bmain, 277, 2)) {
1337     if (!DNA_struct_elem_find(fd->filesdna, "Bone", "float", "scaleIn")) {
1338       for (bArmature *arm = bmain->armatures.first; arm; arm = arm->id.next) {
1339         do_version_bones_super_bbone(&arm->bonebase);
1340       }
1341     }
1342     if (!DNA_struct_elem_find(fd->filesdna, "bPoseChannel", "float", "scaleIn")) {
1343       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
1344         if (ob->pose) {
1345           for (bPoseChannel *pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1346             /* see do_version_bones_super_bbone()... */
1347             pchan->scale_in_x = pchan->scale_in_y = 1.0f;
1348             pchan->scale_out_x = pchan->scale_out_y = 1.0f;
1349
1350             /* also make sure some legacy (unused for over a decade) flags are unset,
1351              * so that we can reuse them for stuff that matters now...
1352              * (i.e. POSE_IK_MAT, (unknown/unused x 4), POSE_HAS_IK)
1353              *
1354              * These seem to have been runtime flags used by the IK solver, but that stuff
1355              * should be able to be recalculated automatically anyway, so it should be fine.
1356              */
1357             pchan->flag &= ~((1 << 3) | (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7) | (1 << 8));
1358           }
1359         }
1360       }
1361     }
1362
1363     for (Camera *camera = bmain->cameras.first; camera != NULL; camera = camera->id.next) {
1364       if (camera->stereo.pole_merge_angle_from == 0.0f &&
1365           camera->stereo.pole_merge_angle_to == 0.0f) {
1366         camera->stereo.pole_merge_angle_from = DEG2RADF(60.0f);
1367         camera->stereo.pole_merge_angle_to = DEG2RADF(75.0f);
1368       }
1369     }
1370
1371     if (!DNA_struct_elem_find(fd->filesdna, "NormalEditModifierData", "float", "mix_limit")) {
1372       Object *ob;
1373
1374       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1375         ModifierData *md;
1376         for (md = ob->modifiers.first; md; md = md->next) {
1377           if (md->type == eModifierType_NormalEdit) {
1378             NormalEditModifierData *nemd = (NormalEditModifierData *)md;
1379             nemd->mix_limit = DEG2RADF(180.0f);
1380           }
1381         }
1382       }
1383     }
1384
1385     if (!DNA_struct_elem_find(fd->filesdna, "BooleanModifierData", "float", "double_threshold")) {
1386       Object *ob;
1387       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1388         ModifierData *md;
1389         for (md = ob->modifiers.first; md; md = md->next) {
1390           if (md->type == eModifierType_Boolean) {
1391             BooleanModifierData *bmd = (BooleanModifierData *)md;
1392             bmd->double_threshold = 1e-6f;
1393           }
1394         }
1395       }
1396     }
1397
1398     for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
1399       if (br->sculpt_tool == SCULPT_TOOL_FLATTEN) {
1400         br->flag |= BRUSH_ACCUMULATE;
1401       }
1402     }
1403
1404     if (!DNA_struct_elem_find(fd->filesdna, "ClothSimSettings", "float", "time_scale")) {
1405       Object *ob;
1406       ModifierData *md;
1407       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1408         for (md = ob->modifiers.first; md; md = md->next) {
1409           if (md->type == eModifierType_Cloth) {
1410             ClothModifierData *clmd = (ClothModifierData *)md;
1411             clmd->sim_parms->time_scale = 1.0f;
1412           }
1413           else if (md->type == eModifierType_ParticleSystem) {
1414             ParticleSystemModifierData *pmd = (ParticleSystemModifierData *)md;
1415             if (pmd->psys->clmd) {
1416               pmd->psys->clmd->sim_parms->time_scale = 1.0f;
1417             }
1418           }
1419         }
1420       }
1421     }
1422   }
1423
1424   if (!MAIN_VERSION_ATLEAST(bmain, 277, 3)) {
1425     /* ------- init of grease pencil initialization --------------- */
1426     if (!DNA_struct_elem_find(fd->filesdna, "bGPDstroke", "bGPDpalettecolor", "*palcolor")) {
1427       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1428         ToolSettings *ts = scene->toolsettings;
1429         /* initialize use position for sculpt brushes */
1430         ts->gp_sculpt.flag |= GP_SCULPT_SETT_FLAG_APPLY_POSITION;
1431
1432         /* new strength sculpt brush */
1433         if (ts->gp_sculpt.brush[0].size >= 11) {
1434           GP_Sculpt_Settings *gset = &ts->gp_sculpt;
1435           GP_Sculpt_Data *brush;
1436
1437           brush = &gset->brush[GP_SCULPT_TYPE_STRENGTH];
1438           brush->size = 25;
1439           brush->strength = 0.5f;
1440           brush->flag = GP_SCULPT_FLAG_USE_FALLOFF;
1441         }
1442       }
1443       /* Convert Grease Pencil to new palettes/brushes
1444        * Loop all strokes and create the palette and all colors
1445        */
1446       for (bGPdata *gpd = bmain->gpencils.first; gpd; gpd = gpd->id.next) {
1447         if (BLI_listbase_is_empty(&gpd->palettes)) {
1448           /* create palette */
1449           bGPDpalette *palette = BKE_gpencil_palette_addnew(gpd, "GP_Palette");
1450           for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1451             /* create color using layer name */
1452             bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_addnew(palette, gpl->info);
1453             if (palcolor != NULL) {
1454               /* set color attributes */
1455               copy_v4_v4(palcolor->color, gpl->color);
1456               copy_v4_v4(palcolor->fill, gpl->fill);
1457
1458               if (gpl->flag & GP_LAYER_HIDE) {
1459                 palcolor->flag |= PC_COLOR_HIDE;
1460               }
1461               if (gpl->flag & GP_LAYER_LOCKED) {
1462                 palcolor->flag |= PC_COLOR_LOCKED;
1463               }
1464               if (gpl->flag & GP_LAYER_ONIONSKIN) {
1465                 palcolor->flag |= PC_COLOR_ONIONSKIN;
1466               }
1467               if (gpl->flag & GP_LAYER_VOLUMETRIC) {
1468                 palcolor->flag |= PC_COLOR_VOLUMETRIC;
1469               }
1470
1471               /* set layer opacity to 1 */
1472               gpl->opacity = 1.0f;
1473
1474               /* set tint color */
1475               ARRAY_SET_ITEMS(gpl->tintcolor, 0.0f, 0.0f, 0.0f, 0.0f);
1476
1477               /* flush relevant layer-settings to strokes */
1478               for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1479                 for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1480                   /* set stroke to palette and force recalculation */
1481                   BLI_strncpy(gps->colorname, gpl->info, sizeof(gps->colorname));
1482                   gps->thickness = gpl->thickness;
1483
1484                   /* set alpha strength to 1 */
1485                   for (int i = 0; i < gps->totpoints; i++) {
1486                     gps->points[i].strength = 1.0f;
1487                   }
1488                 }
1489               }
1490             }
1491           }
1492         }
1493       }
1494     }
1495     /* ------- end of grease pencil initialization --------------- */
1496   }
1497
1498   if (!MAIN_VERSION_ATLEAST(bmain, 278, 0)) {
1499     if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingTrack", "float", "weight_stab")) {
1500       MovieClip *clip;
1501       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
1502         MovieTracking *tracking = &clip->tracking;
1503         MovieTrackingObject *tracking_object;
1504         for (tracking_object = tracking->objects.first; tracking_object != NULL;
1505              tracking_object = tracking_object->next) {
1506           ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
1507           MovieTrackingTrack *track;
1508           for (track = tracksbase->first; track != NULL; track = track->next) {
1509             track->weight_stab = track->weight;
1510           }
1511         }
1512       }
1513     }
1514
1515     if (!DNA_struct_elem_find(
1516             fd->filesdna, "MovieTrackingStabilization", "int", "tot_rot_track")) {
1517       MovieClip *clip;
1518       for (clip = bmain->movieclips.first; clip != NULL; clip = clip->id.next) {
1519         if (clip->tracking.stabilization.rot_track) {
1520           migrate_single_rot_stabilization_track_settings(&clip->tracking.stabilization);
1521         }
1522         if (clip->tracking.stabilization.scale == 0.0f) {
1523           /* ensure init.
1524            * Was previously used for autoscale only,
1525            * now used always (as "target scale") */
1526           clip->tracking.stabilization.scale = 1.0f;
1527         }
1528         /* blender prefers 1-based frame counting;
1529          * thus using frame 1 as reference typically works best */
1530         clip->tracking.stabilization.anchor_frame = 1;
1531         /* by default show the track lists expanded, to improve "discoverability" */
1532         clip->tracking.stabilization.flag |= TRACKING_SHOW_STAB_TRACKS;
1533         /* deprecated, not used anymore */
1534         clip->tracking.stabilization.ok = false;
1535       }
1536     }
1537   }
1538   if (!MAIN_VERSION_ATLEAST(bmain, 278, 2)) {
1539     if (!DNA_struct_elem_find(fd->filesdna, "FFMpegCodecData", "int", "ffmpeg_preset")) {
1540       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1541         /* "medium" is the preset FFmpeg uses when no presets are given. */
1542         scene->r.ffcodecdata.ffmpeg_preset = FFM_PRESET_MEDIUM;
1543       }
1544     }
1545     if (!DNA_struct_elem_find(fd->filesdna, "FFMpegCodecData", "int", "constant_rate_factor")) {
1546       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1547         /* fall back to behavior from before we introduced CRF for old files */
1548         scene->r.ffcodecdata.constant_rate_factor = FFM_CRF_NONE;
1549       }
1550     }
1551
1552     if (!DNA_struct_elem_find(fd->filesdna, "FluidModifierData", "float", "slice_per_voxel")) {
1553       Object *ob;
1554       ModifierData *md;
1555
1556       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1557         for (md = ob->modifiers.first; md; md = md->next) {
1558           if (md->type == eModifierType_Fluid) {
1559             FluidModifierData *mmd = (FluidModifierData *)md;
1560             if (mmd->domain) {
1561               mmd->domain->slice_per_voxel = 5.0f;
1562               mmd->domain->slice_depth = 0.5f;
1563               mmd->domain->display_thickness = 1.0f;
1564             }
1565           }
1566         }
1567       }
1568     }
1569   }
1570
1571   if (!MAIN_VERSION_ATLEAST(bmain, 278, 3)) {
1572     for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) {
1573       if (scene->toolsettings != NULL) {
1574         ToolSettings *ts = scene->toolsettings;
1575         ParticleEditSettings *pset = &ts->particle;
1576         for (int a = 0; a < ARRAY_SIZE(pset->brush); a++) {
1577           if (pset->brush[a].count == 0) {
1578             pset->brush[a].count = 10;
1579           }
1580         }
1581       }
1582     }
1583
1584     if (!DNA_struct_elem_find(fd->filesdna, "RigidBodyCon", "float", "spring_stiffness_ang_x")) {
1585       Object *ob;
1586       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1587         RigidBodyCon *rbc = ob->rigidbody_constraint;
1588         if (rbc) {
1589           rbc->spring_stiffness_ang_x = 10.0;
1590           rbc->spring_stiffness_ang_y = 10.0;
1591           rbc->spring_stiffness_ang_z = 10.0;
1592           rbc->spring_damping_ang_x = 0.5;
1593           rbc->spring_damping_ang_y = 0.5;
1594           rbc->spring_damping_ang_z = 0.5;
1595         }
1596       }
1597     }
1598
1599     /* constant detail for sculpting is now a resolution value instead of
1600      * a percentage, we reuse old DNA struct member but convert it */
1601     for (Scene *scene = bmain->scenes.first; scene != NULL; scene = scene->id.next) {
1602       if (scene->toolsettings != NULL) {
1603         ToolSettings *ts = scene->toolsettings;
1604         if (ts->sculpt && ts->sculpt->constant_detail != 0.0f) {
1605           ts->sculpt->constant_detail = 100.0f / ts->sculpt->constant_detail;
1606         }
1607       }
1608     }
1609   }
1610
1611   if (!MAIN_VERSION_ATLEAST(bmain, 278, 4)) {
1612     const float sqrt_3 = (float)M_SQRT3;
1613     for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
1614       br->fill_threshold /= sqrt_3;
1615     }
1616
1617     /* Custom motion paths */
1618     if (!DNA_struct_elem_find(fd->filesdna, "bMotionPath", "int", "line_thickness")) {
1619       Object *ob;
1620       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1621         bMotionPath *mpath;
1622         bPoseChannel *pchan;
1623         mpath = ob->mpath;
1624         if (mpath) {
1625           mpath->color[0] = 1.0f;
1626           mpath->color[1] = 0.0f;
1627           mpath->color[2] = 0.0f;
1628           mpath->line_thickness = 1;
1629           mpath->flag |= MOTIONPATH_FLAG_LINES;
1630         }
1631         /* bones motion path */
1632         if (ob->pose) {
1633           for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1634             mpath = pchan->mpath;
1635             if (mpath) {
1636               mpath->color[0] = 1.0f;
1637               mpath->color[1] = 0.0f;
1638               mpath->color[2] = 0.0f;
1639               mpath->line_thickness = 1;
1640               mpath->flag |= MOTIONPATH_FLAG_LINES;
1641             }
1642           }
1643         }
1644       }
1645     }
1646   }
1647
1648   if (!MAIN_VERSION_ATLEAST(bmain, 278, 5)) {
1649     /* Mask primitive adding code was not initializing correctly id_type of its points' parent. */
1650     for (Mask *mask = bmain->masks.first; mask; mask = mask->id.next) {
1651       for (MaskLayer *mlayer = mask->masklayers.first; mlayer; mlayer = mlayer->next) {
1652         for (MaskSpline *mspline = mlayer->splines.first; mspline; mspline = mspline->next) {
1653           int i = 0;
1654           for (MaskSplinePoint *mspoint = mspline->points; i < mspline->tot_point;
1655                mspoint++, i++) {
1656             if (mspoint->parent.id_type == 0) {
1657               BKE_mask_parent_init(&mspoint->parent);
1658             }
1659           }
1660         }
1661       }
1662     }
1663
1664     /* Fix for T50736, Glare comp node using same var for two different things. */
1665     if (!DNA_struct_elem_find(fd->filesdna, "NodeGlare", "char", "star_45")) {
1666       FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1667         if (ntree->type == NTREE_COMPOSIT) {
1668           ntreeSetTypes(NULL, ntree);
1669           for (bNode *node = ntree->nodes.first; node; node = node->next) {
1670             if (node->type == CMP_NODE_GLARE) {
1671               NodeGlare *ndg = node->storage;
1672               switch (ndg->type) {
1673                 case 2: /* Grrrr! magic numbers :( */
1674                   ndg->streaks = ndg->angle;
1675                   break;
1676                 case 0:
1677                   ndg->star_45 = ndg->angle != 0;
1678                   break;
1679                 default:
1680                   break;
1681               }
1682             }
1683           }
1684         }
1685       }
1686       FOREACH_NODETREE_END;
1687     }
1688
1689     if (!DNA_struct_elem_find(fd->filesdna, "SurfaceDeformModifierData", "float", "mat[4][4]")) {
1690       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
1691         for (ModifierData *md = ob->modifiers.first; md; md = md->next) {
1692           if (md->type == eModifierType_SurfaceDeform) {
1693             SurfaceDeformModifierData *smd = (SurfaceDeformModifierData *)md;
1694             unit_m4(smd->mat);
1695           }
1696         }
1697       }
1698     }
1699
1700     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1701       if (ntree->type == NTREE_COMPOSIT) {
1702         do_versions_compositor_render_passes(ntree);
1703       }
1704     }
1705     FOREACH_NODETREE_END;
1706   }
1707
1708   if (!MAIN_VERSION_ATLEAST(bmain, 279, 0)) {
1709     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1710       if (scene->r.im_format.exr_codec == R_IMF_EXR_CODEC_DWAB) {
1711         scene->r.im_format.exr_codec = R_IMF_EXR_CODEC_DWAA;
1712       }
1713     }
1714
1715     /* Fix related to VGroup modifiers creating named defgroup CD layers! See T51520. */
1716     for (Mesh *me = bmain->meshes.first; me; me = me->id.next) {
1717       CustomData_set_layer_name(&me->vdata, CD_MDEFORMVERT, 0, "");
1718     }
1719   }
1720
1721   if (!MAIN_VERSION_ATLEAST(bmain, 279, 3)) {
1722     if (!DNA_struct_elem_find(fd->filesdna, "FluidDomainSettings", "float", "clipping")) {
1723       Object *ob;
1724       ModifierData *md;
1725
1726       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1727         for (md = ob->modifiers.first; md; md = md->next) {
1728           if (md->type == eModifierType_Fluid) {
1729             FluidModifierData *mmd = (FluidModifierData *)md;
1730             if (mmd->domain) {
1731               mmd->domain->clipping = 1e-3f;
1732             }
1733           }
1734         }
1735       }
1736     }
1737   }
1738
1739   if (!MAIN_VERSION_ATLEAST(bmain, 279, 4)) {
1740     /* Fix for invalid state of screen due to bug in older versions. */
1741     for (bScreen *sc = bmain->screens.first; sc; sc = sc->id.next) {
1742       for (ScrArea *sa = sc->areabase.first; sa; sa = sa->next) {
1743         if (sa->full && sc->state == SCREENNORMAL) {
1744           sa->full = NULL;
1745         }
1746       }
1747     }
1748
1749     if (!DNA_struct_elem_find(fd->filesdna, "Brush", "float", "falloff_angle")) {
1750       for (Brush *br = bmain->brushes.first; br; br = br->id.next) {
1751         br->falloff_angle = DEG2RADF(80);
1752         /* These flags are used for new feautres. They are not related to falloff_angle */
1753         br->flag &= ~(BRUSH_INVERT_TO_SCRAPE_FILL | BRUSH_ORIGINAL_PLANE |
1754                       BRUSH_GRAB_ACTIVE_VERTEX | BRUSH_SCENE_SPACING | BRUSH_FRONTFACE_FALLOFF);
1755       }
1756
1757       for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1758         ToolSettings *ts = scene->toolsettings;
1759         for (int i = 0; i < 2; i++) {
1760           VPaint *vp = i ? ts->vpaint : ts->wpaint;
1761           if (vp != NULL) {
1762             /* remove all other flags */
1763             vp->flag &= (VP_FLAG_VGROUP_RESTRICT);
1764           }
1765         }
1766       }
1767     }
1768
1769     /* Simple deform modifier no longer assumes Z axis (X for bend type).
1770      * Must set previous defaults. */
1771     if (!DNA_struct_elem_find(fd->filesdna, "SimpleDeformModifierData", "char", "deform_axis")) {
1772       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
1773         for (ModifierData *md = ob->modifiers.first; md; md = md->next) {
1774           if (md->type == eModifierType_SimpleDeform) {
1775             SimpleDeformModifierData *smd = (SimpleDeformModifierData *)md;
1776             smd->deform_axis = 2;
1777           }
1778         }
1779       }
1780     }
1781
1782     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1783       int preset = scene->r.ffcodecdata.ffmpeg_preset;
1784       if (preset == FFM_PRESET_NONE || preset >= FFM_PRESET_GOOD) {
1785         continue;
1786       }
1787       if (preset <= FFM_PRESET_FAST) {
1788         preset = FFM_PRESET_REALTIME;
1789       }
1790       else if (preset >= FFM_PRESET_SLOW) {
1791         preset = FFM_PRESET_BEST;
1792       }
1793       else {
1794         preset = FFM_PRESET_GOOD;
1795       }
1796       scene->r.ffcodecdata.ffmpeg_preset = preset;
1797     }
1798
1799     if (!DNA_struct_elem_find(
1800             fd->filesdna, "ParticleInstanceModifierData", "float", "particle_amount")) {
1801       for (Object *ob = bmain->objects.first; ob; ob = ob->id.next) {
1802         for (ModifierData *md = ob->modifiers.first; md; md = md->next) {
1803           if (md->type == eModifierType_ParticleInstance) {
1804             ParticleInstanceModifierData *pimd = (ParticleInstanceModifierData *)md;
1805             pimd->space = eParticleInstanceSpace_World;
1806             pimd->particle_amount = 1.0f;
1807           }
1808         }
1809       }
1810     }
1811   }
1812 }
1813
1814 void do_versions_after_linking_270(Main *bmain)
1815 {
1816   /* To be added to next subversion bump! */
1817   if (!MAIN_VERSION_ATLEAST(bmain, 279, 0)) {
1818     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1819       if (ntree->type == NTREE_COMPOSIT) {
1820         ntreeSetTypes(NULL, ntree);
1821         for (bNode *node = ntree->nodes.first; node; node = node->next) {
1822           if (node->type == CMP_NODE_HUE_SAT) {
1823             do_version_hue_sat_node(ntree, node);
1824           }
1825         }
1826       }
1827     }
1828     FOREACH_NODETREE_END;
1829   }
1830
1831   if (!MAIN_VERSION_ATLEAST(bmain, 279, 2)) {
1832     /* B-Bones (bbone_in/out -> bbone_easein/out) + Stepped FMod Frame Start/End fix */
1833     /* if (!DNA_struct_elem_find(fd->filesdna, "Bone", "float", "bbone_easein")) */
1834     BKE_fcurves_main_cb(bmain, do_version_bbone_easing_fcurve_fix, NULL);
1835   }
1836 }