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