CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / blenloader / intern / versioning_legacy.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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup blenloader
22  */
23
24 #include <limits.h>
25
26 #ifndef WIN32
27 #  include <unistd.h>  // for read close
28 #else
29 #  include "BLI_winstuff.h"
30 #  include "winsock2.h"
31 #  include <io.h>   // for open close read
32 #  include <zlib.h> /* odd include order-issue */
33 #endif
34
35 /* allow readfile to use deprecated functionality */
36 #define DNA_DEPRECATED_ALLOW
37
38 #include "DNA_armature_types.h"
39 #include "DNA_camera_types.h"
40 #include "DNA_collection_types.h"
41 #include "DNA_constraint_types.h"
42 #include "DNA_effect_types.h"
43 #include "DNA_key_types.h"
44 #include "DNA_lattice_types.h"
45 #include "DNA_light_types.h"
46 #include "DNA_material_types.h"
47 #include "DNA_mesh_types.h"
48 #include "DNA_meshdata_types.h"
49 #include "DNA_nla_types.h"
50 #include "DNA_node_types.h"
51 #include "DNA_object_fluidsim_types.h"
52 #include "DNA_object_types.h"
53 #include "DNA_screen_types.h"
54 #include "DNA_sdna_types.h"
55 #include "DNA_sequence_types.h"
56 #include "DNA_sound_types.h"
57 #include "DNA_space_types.h"
58 #include "DNA_vfont_types.h"
59 #include "DNA_view3d_types.h"
60 #include "DNA_world_types.h"
61
62 #include "MEM_guardedalloc.h"
63
64 #include "BLI_blenlib.h"
65 #include "BLI_math.h"
66 #include "BLI_utildefines.h"
67
68 #include "BKE_action.h"
69 #include "BKE_armature.h"
70 #include "BKE_colortools.h"
71 #include "BKE_constraint.h"
72 #include "BKE_deform.h"
73 #include "BKE_fcurve.h"
74 #include "BKE_lattice.h"
75 #include "BKE_main.h"  // for Main
76 #include "BKE_mesh.h"  // for ME_ defines (patching)
77 #include "BKE_modifier.h"
78 #include "BKE_particle.h"
79 #include "BKE_pointcache.h"
80 #include "BKE_sequencer.h"
81
82 #include "NOD_socket.h"
83
84 #include "BLO_readfile.h"
85
86 #include "readfile.h"
87
88 #include "PIL_time.h"
89
90 #include <errno.h>
91
92 /* Make preferences read-only, use versioning_userdef.c. */
93 #define U (*((const UserDef *)&U))
94
95 static void vcol_to_fcol(Mesh *me)
96 {
97   MFace *mface;
98   uint *mcol, *mcoln, *mcolmain;
99   int a;
100
101   if (me->totface == 0 || me->mcol == NULL) {
102     return;
103   }
104
105   mcoln = mcolmain = MEM_malloc_arrayN(me->totface, 4 * sizeof(int), "mcoln");
106   mcol = (uint *)me->mcol;
107   mface = me->mface;
108   for (a = me->totface; a > 0; a--, mface++) {
109     mcoln[0] = mcol[mface->v1];
110     mcoln[1] = mcol[mface->v2];
111     mcoln[2] = mcol[mface->v3];
112     mcoln[3] = mcol[mface->v4];
113     mcoln += 4;
114   }
115
116   MEM_freeN(me->mcol);
117   me->mcol = (MCol *)mcolmain;
118 }
119
120 static void do_version_bone_head_tail_237(Bone *bone)
121 {
122   Bone *child;
123   float vec[3];
124
125   /* head */
126   copy_v3_v3(bone->arm_head, bone->arm_mat[3]);
127
128   /* tail is in current local coord system */
129   copy_v3_v3(vec, bone->arm_mat[1]);
130   mul_v3_fl(vec, bone->length);
131   add_v3_v3v3(bone->arm_tail, bone->arm_head, vec);
132
133   for (child = bone->childbase.first; child; child = child->next) {
134     do_version_bone_head_tail_237(child);
135   }
136 }
137
138 static void bone_version_238(ListBase *lb)
139 {
140   Bone *bone;
141
142   for (bone = lb->first; bone; bone = bone->next) {
143     if (bone->rad_tail == 0.0f && bone->rad_head == 0.0f) {
144       bone->rad_head = 0.25f * bone->length;
145       bone->rad_tail = 0.1f * bone->length;
146
147       bone->dist -= bone->rad_head;
148       if (bone->dist <= 0.0f) {
149         bone->dist = 0.0f;
150       }
151     }
152     bone_version_238(&bone->childbase);
153   }
154 }
155
156 static void bone_version_239(ListBase *lb)
157 {
158   Bone *bone;
159
160   for (bone = lb->first; bone; bone = bone->next) {
161     if (bone->layer == 0) {
162       bone->layer = 1;
163     }
164     bone_version_239(&bone->childbase);
165   }
166 }
167
168 static void ntree_version_241(bNodeTree *ntree)
169 {
170   bNode *node;
171
172   if (ntree->type == NTREE_COMPOSIT) {
173     for (node = ntree->nodes.first; node; node = node->next) {
174       if (node->type == CMP_NODE_BLUR) {
175         if (node->storage == NULL) {
176           NodeBlurData *nbd = MEM_callocN(sizeof(NodeBlurData), "node blur patch");
177           nbd->sizex = node->custom1;
178           nbd->sizey = node->custom2;
179           nbd->filtertype = R_FILTER_QUAD;
180           node->storage = nbd;
181         }
182       }
183       else if (node->type == CMP_NODE_VECBLUR) {
184         if (node->storage == NULL) {
185           NodeBlurData *nbd = MEM_callocN(sizeof(NodeBlurData), "node blur patch");
186           nbd->samples = node->custom1;
187           nbd->maxspeed = node->custom2;
188           nbd->fac = 1.0f;
189           node->storage = nbd;
190         }
191       }
192     }
193   }
194 }
195
196 static void ntree_version_242(bNodeTree *ntree)
197 {
198   bNode *node;
199
200   if (ntree->type == NTREE_COMPOSIT) {
201     for (node = ntree->nodes.first; node; node = node->next) {
202       if (node->type == CMP_NODE_HUE_SAT) {
203         if (node->storage) {
204           NodeHueSat *nhs = node->storage;
205           if (nhs->val == 0.0f) {
206             nhs->val = 1.0f;
207           }
208         }
209       }
210     }
211   }
212 }
213
214 static void ntree_version_245(FileData *fd, Library *lib, bNodeTree *ntree)
215 {
216   bNode *node;
217   NodeTwoFloats *ntf;
218   ID *nodeid;
219   Image *image;
220   ImageUser *iuser;
221
222   if (ntree->type == NTREE_COMPOSIT) {
223     for (node = ntree->nodes.first; node; node = node->next) {
224       if (node->type == CMP_NODE_ALPHAOVER) {
225         if (!node->storage) {
226           ntf = MEM_callocN(sizeof(NodeTwoFloats), "NodeTwoFloats");
227           node->storage = ntf;
228           if (node->custom1) {
229             ntf->x = 1.0f;
230           }
231         }
232       }
233
234       /* fix for temporary flag changes during 245 cycle */
235       nodeid = blo_do_versions_newlibadr(fd, lib, node->id);
236       if (node->storage && nodeid && GS(nodeid->name) == ID_IM) {
237         image = (Image *)nodeid;
238         iuser = node->storage;
239         if (iuser->flag & IMA_OLD_PREMUL) {
240           iuser->flag &= ~IMA_OLD_PREMUL;
241         }
242         if (iuser->flag & IMA_DO_PREMUL) {
243           image->flag &= ~IMA_OLD_PREMUL;
244           image->alpha_mode = IMA_ALPHA_STRAIGHT;
245         }
246       }
247     }
248   }
249 }
250
251 static void idproperties_fix_groups_lengths_recurse(IDProperty *prop)
252 {
253   IDProperty *loop;
254   int i;
255
256   for (loop = prop->data.group.first, i = 0; loop; loop = loop->next, i++) {
257     if (loop->type == IDP_GROUP) {
258       idproperties_fix_groups_lengths_recurse(loop);
259     }
260   }
261
262   if (prop->len != i) {
263     printf("Found and fixed bad id property group length.\n");
264     prop->len = i;
265   }
266 }
267
268 static void idproperties_fix_group_lengths(ListBase idlist)
269 {
270   ID *id;
271
272   for (id = idlist.first; id; id = id->next) {
273     if (id->properties) {
274       idproperties_fix_groups_lengths_recurse(id->properties);
275     }
276   }
277 }
278
279 static void customdata_version_242(Mesh *me)
280 {
281   CustomDataLayer *layer;
282   MTFace *mtf;
283   MCol *mcol;
284   TFace *tf;
285   int a, mtfacen, mcoln;
286
287   if (!me->vdata.totlayer) {
288     CustomData_add_layer(&me->vdata, CD_MVERT, CD_ASSIGN, me->mvert, me->totvert);
289
290     if (me->dvert) {
291       CustomData_add_layer(&me->vdata, CD_MDEFORMVERT, CD_ASSIGN, me->dvert, me->totvert);
292     }
293   }
294
295   if (!me->edata.totlayer) {
296     CustomData_add_layer(&me->edata, CD_MEDGE, CD_ASSIGN, me->medge, me->totedge);
297   }
298
299   if (!me->fdata.totlayer) {
300     CustomData_add_layer(&me->fdata, CD_MFACE, CD_ASSIGN, me->mface, me->totface);
301
302     if (me->tface) {
303       if (me->mcol) {
304         MEM_freeN(me->mcol);
305       }
306
307       me->mcol = CustomData_add_layer(&me->fdata, CD_MCOL, CD_CALLOC, NULL, me->totface);
308       me->mtface = CustomData_add_layer(&me->fdata, CD_MTFACE, CD_CALLOC, NULL, me->totface);
309
310       mtf = me->mtface;
311       mcol = me->mcol;
312       tf = me->tface;
313
314       for (a = 0; a < me->totface; a++, mtf++, tf++, mcol += 4) {
315         memcpy(mcol, tf->col, sizeof(tf->col));
316         memcpy(mtf->uv, tf->uv, sizeof(tf->uv));
317       }
318
319       MEM_freeN(me->tface);
320       me->tface = NULL;
321     }
322     else if (me->mcol) {
323       me->mcol = CustomData_add_layer(&me->fdata, CD_MCOL, CD_ASSIGN, me->mcol, me->totface);
324     }
325   }
326
327   if (me->tface) {
328     MEM_freeN(me->tface);
329     me->tface = NULL;
330   }
331
332   for (a = 0, mtfacen = 0, mcoln = 0; a < me->fdata.totlayer; a++) {
333     layer = &me->fdata.layers[a];
334
335     if (layer->type == CD_MTFACE) {
336       if (layer->name[0] == 0) {
337         if (mtfacen == 0) {
338           strcpy(layer->name, "UVMap");
339         }
340         else {
341           BLI_snprintf(layer->name, sizeof(layer->name), "UVMap.%.3d", mtfacen);
342         }
343       }
344       mtfacen++;
345     }
346     else if (layer->type == CD_MCOL) {
347       if (layer->name[0] == 0) {
348         if (mcoln == 0) {
349           strcpy(layer->name, "Col");
350         }
351         else {
352           BLI_snprintf(layer->name, sizeof(layer->name), "Col.%.3d", mcoln);
353         }
354       }
355       mcoln++;
356     }
357   }
358
359   BKE_mesh_update_customdata_pointers(me, true);
360 }
361
362 /*only copy render texface layer from active*/
363 static void customdata_version_243(Mesh *me)
364 {
365   CustomDataLayer *layer;
366   int a;
367
368   for (a = 0; a < me->fdata.totlayer; a++) {
369     layer = &me->fdata.layers[a];
370     layer->active_rnd = layer->active;
371   }
372 }
373
374 /* struct NodeImageAnim moved to ImageUser, and we make it default available */
375 static void do_version_ntree_242_2(bNodeTree *ntree)
376 {
377   bNode *node;
378
379   if (ntree->type == NTREE_COMPOSIT) {
380     for (node = ntree->nodes.first; node; node = node->next) {
381       if (ELEM(node->type, CMP_NODE_IMAGE, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)) {
382         /* only image had storage */
383         if (node->storage) {
384           NodeImageAnim *nia = node->storage;
385           ImageUser *iuser = MEM_callocN(sizeof(ImageUser), "ima user node");
386
387           iuser->frames = nia->frames;
388           iuser->sfra = nia->sfra;
389           iuser->offset = nia->nr - 1;
390           iuser->cycl = nia->cyclic;
391           iuser->ok = 1;
392
393           node->storage = iuser;
394           MEM_freeN(nia);
395         }
396         else {
397           ImageUser *iuser = node->storage = MEM_callocN(sizeof(ImageUser), "node image user");
398           iuser->sfra = 1;
399           iuser->ok = 1;
400         }
401       }
402     }
403   }
404 }
405
406 static void do_version_free_effect_245(Effect *eff)
407 {
408   PartEff *paf;
409
410   if (eff->type == EFF_PARTICLE) {
411     paf = (PartEff *)eff;
412     if (paf->keys) {
413       MEM_freeN(paf->keys);
414     }
415   }
416   MEM_freeN(eff);
417 }
418
419 static void do_version_free_effects_245(ListBase *lb)
420 {
421   Effect *eff;
422
423   while ((eff = BLI_pophead(lb))) {
424     do_version_free_effect_245(eff);
425   }
426 }
427
428 static void do_version_constraints_245(ListBase *lb)
429 {
430   bConstraint *con;
431   bConstraintTarget *ct;
432
433   for (con = lb->first; con; con = con->next) {
434     if (con->type == CONSTRAINT_TYPE_PYTHON) {
435       bPythonConstraint *data = (bPythonConstraint *)con->data;
436       if (data->tar) {
437         /* version patching needs to be done */
438         ct = MEM_callocN(sizeof(bConstraintTarget), "PyConTarget");
439
440         ct->tar = data->tar;
441         BLI_strncpy(ct->subtarget, data->subtarget, sizeof(ct->subtarget));
442         ct->space = con->tarspace;
443
444         BLI_addtail(&data->targets, ct);
445         data->tarnum++;
446
447         /* clear old targets to avoid problems */
448         data->tar = NULL;
449         data->subtarget[0] = '\0';
450       }
451     }
452     else if (con->type == CONSTRAINT_TYPE_LOCLIKE) {
453       bLocateLikeConstraint *data = (bLocateLikeConstraint *)con->data;
454
455       /* new headtail functionality makes Bone-Tip function obsolete */
456       if (data->flag & LOCLIKE_TIP) {
457         con->headtail = 1.0f;
458       }
459     }
460   }
461 }
462
463 PartEff *blo_do_version_give_parteff_245(Object *ob)
464 {
465   PartEff *paf;
466
467   paf = ob->effect.first;
468   while (paf) {
469     if (paf->type == EFF_PARTICLE) {
470       return paf;
471     }
472     paf = paf->next;
473   }
474   return NULL;
475 }
476
477 /* NOTE: this version patch is intended for versions < 2.52.2,
478  * but was initially introduced in 2.27 already. */
479 void blo_do_version_old_trackto_to_constraints(Object *ob)
480 {
481   /* create new trackto constraint from the relationship */
482   if (ob->track) {
483     bConstraint *con = BKE_constraint_add_for_object(ob, "AutoTrack", CONSTRAINT_TYPE_TRACKTO);
484     bTrackToConstraint *data = con->data;
485
486     /* copy tracking settings from the object */
487     data->tar = ob->track;
488     data->reserved1 = ob->trackflag;
489     data->reserved2 = ob->upflag;
490   }
491
492   /* clear old track setting */
493   ob->track = NULL;
494 }
495
496 void blo_do_versions_pre250(FileData *fd, Library *lib, Main *bmain)
497 {
498   /* WATCH IT!!!: pointers from libdata have not been converted */
499
500   if (bmain->versionfile == 100) {
501     /* tex->extend and tex->imageflag have changed: */
502     Tex *tex = bmain->textures.first;
503     while (tex) {
504       if (tex->id.tag & LIB_TAG_NEED_LINK) {
505
506         if (tex->extend == 0) {
507           if (tex->xrepeat || tex->yrepeat) {
508             tex->extend = TEX_REPEAT;
509           }
510           else {
511             tex->extend = TEX_EXTEND;
512             tex->xrepeat = tex->yrepeat = 1;
513           }
514         }
515       }
516       tex = tex->id.next;
517     }
518   }
519
520   if (bmain->versionfile <= 101) {
521     /* frame mapping */
522     Scene *sce = bmain->scenes.first;
523     while (sce) {
524       sce->r.framapto = 100;
525       sce->r.images = 100;
526       sce->r.framelen = 1.0;
527       sce = sce->id.next;
528     }
529   }
530
531   if (bmain->versionfile <= 103) {
532     /* new variable in object: colbits */
533     Object *ob = bmain->objects.first;
534     int a;
535     while (ob) {
536       ob->colbits = 0;
537       if (ob->totcol) {
538         for (a = 0; a < ob->totcol; a++) {
539           if (ob->mat[a]) {
540             ob->colbits |= (1 << a);
541           }
542         }
543       }
544       ob = ob->id.next;
545     }
546   }
547
548   if (bmain->versionfile <= 104) {
549     /* timeoffs moved */
550     Object *ob = bmain->objects.first;
551     while (ob) {
552       if (ob->transflag & 1) {
553         ob->transflag -= 1;
554       }
555       ob = ob->id.next;
556     }
557   }
558
559   if (bmain->versionfile <= 106) {
560     /* mcol changed */
561     Mesh *me = bmain->meshes.first;
562     while (me) {
563       if (me->mcol) {
564         vcol_to_fcol(me);
565       }
566       me = me->id.next;
567     }
568   }
569
570   if (bmain->versionfile <= 107) {
571     Object *ob;
572     ob = bmain->objects.first;
573     while (ob) {
574       if (ob->dt == 0) {
575         ob->dt = OB_SOLID;
576       }
577       ob = ob->id.next;
578     }
579   }
580
581   if (bmain->versionfile <= 109) {
582     /* new variable: gridlines */
583     bScreen *screen = bmain->screens.first;
584     while (screen) {
585       ScrArea *area = screen->areabase.first;
586       while (area) {
587         SpaceLink *sl = area->spacedata.first;
588         while (sl) {
589           if (sl->spacetype == SPACE_VIEW3D) {
590             View3D *v3d = (View3D *)sl;
591
592             if (v3d->gridlines == 0) {
593               v3d->gridlines = 20;
594             }
595           }
596           sl = sl->next;
597         }
598         area = area->next;
599       }
600       screen = screen->id.next;
601     }
602   }
603
604   if (bmain->versionfile <= 134) {
605     Tex *tex = bmain->textures.first;
606     while (tex) {
607       if ((tex->rfac == 0.0f) && (tex->gfac == 0.0f) && (tex->bfac == 0.0f)) {
608         tex->rfac = 1.0f;
609         tex->gfac = 1.0f;
610         tex->bfac = 1.0f;
611         tex->filtersize = 1.0f;
612       }
613       tex = tex->id.next;
614     }
615   }
616
617   if (bmain->versionfile <= 140) {
618     /* r-g-b-fac in texture */
619     Tex *tex = bmain->textures.first;
620     while (tex) {
621       if ((tex->rfac == 0.0f) && (tex->gfac == 0.0f) && (tex->bfac == 0.0f)) {
622         tex->rfac = 1.0f;
623         tex->gfac = 1.0f;
624         tex->bfac = 1.0f;
625         tex->filtersize = 1.0f;
626       }
627       tex = tex->id.next;
628     }
629   }
630
631   if (bmain->versionfile <= 153) {
632     Scene *sce = bmain->scenes.first;
633     while (sce) {
634       if (sce->r.blurfac == 0.0f) {
635         sce->r.blurfac = 1.0f;
636       }
637       sce = sce->id.next;
638     }
639   }
640
641   if (bmain->versionfile <= 163) {
642     Scene *sce = bmain->scenes.first;
643     while (sce) {
644       if (sce->r.frs_sec == 0) {
645         sce->r.frs_sec = 25;
646       }
647       sce = sce->id.next;
648     }
649   }
650
651   if (bmain->versionfile <= 164) {
652     Mesh *me = bmain->meshes.first;
653     while (me) {
654       me->smoothresh = 30;
655       me = me->id.next;
656     }
657   }
658
659   if (bmain->versionfile <= 165) {
660     Mesh *me = bmain->meshes.first;
661     TFace *tface;
662     int nr;
663     char *cp;
664
665     while (me) {
666       if (me->tface) {
667         nr = me->totface;
668         tface = me->tface;
669         while (nr--) {
670           int j;
671           for (j = 0; j < 4; j++) {
672             int k;
673             cp = ((char *)&tface->col[j]) + 1;
674             for (k = 0; k < 3; k++) {
675               cp[k] = (cp[k] > 126) ? 255 : cp[k] * 2;
676             }
677           }
678
679           tface++;
680         }
681       }
682       me = me->id.next;
683     }
684   }
685
686   if (bmain->versionfile <= 169) {
687     Mesh *me = bmain->meshes.first;
688     while (me) {
689       if (me->subdiv == 0) {
690         me->subdiv = 1;
691       }
692       me = me->id.next;
693     }
694   }
695
696   if (bmain->versionfile <= 169) {
697     bScreen *screen = bmain->screens.first;
698     while (screen) {
699       ScrArea *area = screen->areabase.first;
700       while (area) {
701         SpaceLink *sl = area->spacedata.first;
702         while (sl) {
703           if (sl->spacetype == SPACE_GRAPH) {
704             SpaceGraph *sipo = (SpaceGraph *)sl;
705             sipo->v2d.max[0] = 15000.0;
706           }
707           sl = sl->next;
708         }
709         area = area->next;
710       }
711       screen = screen->id.next;
712     }
713   }
714
715   if (bmain->versionfile <= 170) {
716     Object *ob = bmain->objects.first;
717     PartEff *paf;
718     while (ob) {
719       paf = blo_do_version_give_parteff_245(ob);
720       if (paf) {
721         if (paf->staticstep == 0) {
722           paf->staticstep = 5;
723         }
724       }
725       ob = ob->id.next;
726     }
727   }
728
729   if (bmain->versionfile <= 171) {
730     bScreen *screen = bmain->screens.first;
731     while (screen) {
732       ScrArea *area = screen->areabase.first;
733       while (area) {
734         SpaceLink *sl = area->spacedata.first;
735         while (sl) {
736           if (sl->spacetype == SPACE_TEXT) {
737             SpaceText *st = (SpaceText *)sl;
738             st->lheight = 12;
739           }
740           sl = sl->next;
741         }
742         area = area->next;
743       }
744       screen = screen->id.next;
745     }
746   }
747
748   if (bmain->versionfile <= 173) {
749     int a, b;
750     Mesh *me = bmain->meshes.first;
751     while (me) {
752       if (me->tface) {
753         TFace *tface = me->tface;
754         for (a = 0; a < me->totface; a++, tface++) {
755           for (b = 0; b < 4; b++) {
756             tface->uv[b][0] /= 32767.0f;
757             tface->uv[b][1] /= 32767.0f;
758           }
759         }
760       }
761       me = me->id.next;
762     }
763   }
764
765   if (bmain->versionfile <= 204) {
766     bSound *sound;
767
768     sound = bmain->sounds.first;
769     while (sound) {
770       if (sound->volume < 0.01f) {
771         sound->volume = 1.0f;
772       }
773       sound = sound->id.next;
774     }
775   }
776
777   if (bmain->versionfile <= 212) {
778     bSound *sound;
779     Mesh *me;
780
781     sound = bmain->sounds.first;
782     while (sound) {
783       sound->max_gain = 1.0;
784       sound->min_gain = 0.0;
785       sound->distance = 1.0;
786
787       if (sound->attenuation > 0.0f) {
788         sound->flags |= SOUND_FLAGS_3D;
789       }
790       else {
791         sound->flags &= ~SOUND_FLAGS_3D;
792       }
793
794       sound = sound->id.next;
795     }
796
797     /* me->subdiv changed to reflect the actual reparametization
798      * better, and smeshes were removed - if it was a smesh make
799      * it a subsurf, and reset the subdiv level because subsurf
800      * takes a lot more work to calculate.
801      */
802     for (me = bmain->meshes.first; me; me = me->id.next) {
803       enum {
804         ME_SMESH = (1 << 6),
805         ME_SUBSURF = (1 << 7),
806       };
807       if (me->flag & ME_SMESH) {
808         me->flag &= ~ME_SMESH;
809         me->flag |= ME_SUBSURF;
810
811         me->subdiv = 1;
812       }
813       else {
814         if (me->subdiv < 2) {
815           me->subdiv = 1;
816         }
817         else {
818           me->subdiv--;
819         }
820       }
821     }
822   }
823
824   if (bmain->versionfile <= 220) {
825     Mesh *me;
826
827     /* Began using alpha component of vertex colors, but
828      * old file vertex colors are undefined, reset them
829      * to be fully opaque. -zr
830      */
831     for (me = bmain->meshes.first; me; me = me->id.next) {
832       if (me->mcol) {
833         int i;
834
835         for (i = 0; i < me->totface * 4; i++) {
836           MCol *mcol = &me->mcol[i];
837           mcol->a = 255;
838         }
839       }
840       if (me->tface) {
841         int i, j;
842
843         for (i = 0; i < me->totface; i++) {
844           TFace *tf = &((TFace *)me->tface)[i];
845
846           for (j = 0; j < 4; j++) {
847             char *col = (char *)&tf->col[j];
848
849             col[0] = 255;
850           }
851         }
852       }
853     }
854   }
855
856   if (bmain->versionfile <= 223) {
857     VFont *vf;
858     for (vf = bmain->fonts.first; vf; vf = vf->id.next) {
859       if (STREQ(vf->name + strlen(vf->name) - 6, ".Bfont")) {
860         strcpy(vf->name, FO_BUILTIN_NAME);
861       }
862     }
863   }
864
865   if (bmain->versionfile <= 224) {
866     bSound *sound;
867     Scene *sce;
868     Mesh *me;
869     bScreen *screen;
870
871     for (sound = bmain->sounds.first; sound; sound = sound->id.next) {
872       if (sound->packedfile) {
873         if (sound->newpackedfile == NULL) {
874           sound->newpackedfile = sound->packedfile;
875         }
876         sound->packedfile = NULL;
877       }
878     }
879     /* Make sure that old subsurf meshes don't have zero subdivision level for rendering */
880     for (me = bmain->meshes.first; me; me = me->id.next) {
881       enum { ME_SUBSURF = (1 << 7) };
882       if ((me->flag & ME_SUBSURF) && (me->subdivr == 0)) {
883         me->subdivr = me->subdiv;
884       }
885     }
886
887     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
888       sce->r.stereomode = 1;  // no stereo
889     }
890
891     /* some oldfile patch, moved from set_func_space */
892     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
893       ScrArea *area;
894
895       for (area = screen->areabase.first; area; area = area->next) {
896         SpaceLink *sl;
897
898         for (sl = area->spacedata.first; sl; sl = sl->next) {
899           if (sl->spacetype == SPACE_GRAPH) {
900             SpaceSeq *sseq = (SpaceSeq *)sl;
901             sseq->v2d.keeptot = 0;
902           }
903         }
904       }
905     }
906   }
907
908   if (bmain->versionfile <= 227) {
909     Scene *sce;
910     bScreen *screen;
911     Object *ob;
912
913     /* As of now, this insures that the transition from the old Track system
914      * to the new full constraint Track is painless for everyone. - theeth
915      */
916     ob = bmain->objects.first;
917
918     while (ob) {
919       ListBase *list;
920       list = &ob->constraints;
921
922       /* check for already existing TrackTo constraint
923        * set their track and up flag correctly
924        */
925
926       if (list) {
927         bConstraint *curcon;
928         for (curcon = list->first; curcon; curcon = curcon->next) {
929           if (curcon->type == CONSTRAINT_TYPE_TRACKTO) {
930             bTrackToConstraint *data = curcon->data;
931             data->reserved1 = ob->trackflag;
932             data->reserved2 = ob->upflag;
933           }
934         }
935       }
936
937       if (ob->type == OB_ARMATURE) {
938         if (ob->pose) {
939           bConstraint *curcon;
940           bPoseChannel *pchan;
941           for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
942             for (curcon = pchan->constraints.first; curcon; curcon = curcon->next) {
943               if (curcon->type == CONSTRAINT_TYPE_TRACKTO) {
944                 bTrackToConstraint *data = curcon->data;
945                 data->reserved1 = ob->trackflag;
946                 data->reserved2 = ob->upflag;
947               }
948             }
949           }
950         }
951       }
952
953       /* Change Ob->Track in real TrackTo constraint */
954       blo_do_version_old_trackto_to_constraints(ob);
955
956       ob = ob->id.next;
957     }
958
959     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
960       sce->audio.mixrate = 48000;
961       sce->audio.flag |= AUDIO_SCRUB;
962     }
963
964     /* patch for old wrong max view2d settings, allows zooming out more */
965     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
966       ScrArea *area;
967
968       for (area = screen->areabase.first; area; area = area->next) {
969         SpaceLink *sl;
970
971         for (sl = area->spacedata.first; sl; sl = sl->next) {
972           if (sl->spacetype == SPACE_ACTION) {
973             SpaceAction *sac = (SpaceAction *)sl;
974             sac->v2d.max[0] = 32000;
975           }
976           else if (sl->spacetype == SPACE_NLA) {
977             SpaceNla *sla = (SpaceNla *)sl;
978             sla->v2d.max[0] = 32000;
979           }
980         }
981       }
982     }
983   }
984
985   if (bmain->versionfile <= 228) {
986     bScreen *screen;
987     Object *ob;
988
989     /* As of now, this insures that the transition from the old Track system
990      * to the new full constraint Track is painless for everyone.
991      */
992     ob = bmain->objects.first;
993
994     while (ob) {
995       ListBase *list;
996       list = &ob->constraints;
997
998       /* check for already existing TrackTo constraint
999        * set their track and up flag correctly */
1000
1001       if (list) {
1002         bConstraint *curcon;
1003         for (curcon = list->first; curcon; curcon = curcon->next) {
1004           if (curcon->type == CONSTRAINT_TYPE_TRACKTO) {
1005             bTrackToConstraint *data = curcon->data;
1006             data->reserved1 = ob->trackflag;
1007             data->reserved2 = ob->upflag;
1008           }
1009         }
1010       }
1011
1012       if (ob->type == OB_ARMATURE) {
1013         if (ob->pose) {
1014           bConstraint *curcon;
1015           bPoseChannel *pchan;
1016           for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1017             for (curcon = pchan->constraints.first; curcon; curcon = curcon->next) {
1018               if (curcon->type == CONSTRAINT_TYPE_TRACKTO) {
1019                 bTrackToConstraint *data = curcon->data;
1020                 data->reserved1 = ob->trackflag;
1021                 data->reserved2 = ob->upflag;
1022               }
1023             }
1024           }
1025         }
1026       }
1027
1028       ob = ob->id.next;
1029     }
1030
1031     /* convert old mainb values for new button panels */
1032     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1033       ScrArea *area;
1034
1035       for (area = screen->areabase.first; area; area = area->next) {
1036         SpaceLink *sl;
1037
1038         for (sl = area->spacedata.first; sl; sl = sl->next) {
1039           if (sl->spacetype == SPACE_PROPERTIES) {
1040             SpaceProperties *sbuts = (SpaceProperties *)sl;
1041
1042             sbuts->v2d.maxzoom = 1.2f;
1043
1044             if (sbuts->mainb == BUTS_LAMP) {
1045               sbuts->mainb = CONTEXT_SHADING;
1046               // sbuts->tab[CONTEXT_SHADING] = TAB_SHADING_LAMP;
1047             }
1048             else if (sbuts->mainb == BUTS_MAT) {
1049               sbuts->mainb = CONTEXT_SHADING;
1050               // sbuts->tab[CONTEXT_SHADING] = TAB_SHADING_MAT;
1051             }
1052             else if (sbuts->mainb == BUTS_TEX) {
1053               sbuts->mainb = CONTEXT_SHADING;
1054               // sbuts->tab[CONTEXT_SHADING] = TAB_SHADING_TEX;
1055             }
1056             else if (sbuts->mainb == BUTS_ANIM) {
1057               sbuts->mainb = CONTEXT_OBJECT;
1058             }
1059             else if (sbuts->mainb == BUTS_WORLD) {
1060               sbuts->mainb = CONTEXT_SCENE;
1061               // sbuts->tab[CONTEXT_SCENE] = TAB_SCENE_WORLD;
1062             }
1063             else if (sbuts->mainb == BUTS_RENDER) {
1064               sbuts->mainb = CONTEXT_SCENE;
1065               // sbuts->tab[CONTEXT_SCENE] = TAB_SCENE_RENDER;
1066             }
1067             else if (sbuts->mainb == BUTS_FPAINT) {
1068               sbuts->mainb = CONTEXT_EDITING;
1069             }
1070             else if (sbuts->mainb == BUTS_RADIO) {
1071               sbuts->mainb = CONTEXT_SHADING;
1072               // sbuts->tab[CONTEXT_SHADING] = TAB_SHADING_RAD;
1073             }
1074             else if (sbuts->mainb == BUTS_CONSTRAINT) {
1075               sbuts->mainb = CONTEXT_OBJECT;
1076             }
1077             else if (sbuts->mainb == BUTS_SCRIPT) {
1078               sbuts->mainb = CONTEXT_OBJECT;
1079             }
1080             else if (sbuts->mainb == BUTS_EDIT) {
1081               sbuts->mainb = CONTEXT_EDITING;
1082             }
1083             else {
1084               sbuts->mainb = CONTEXT_SCENE;
1085             }
1086           }
1087         }
1088       }
1089     }
1090   }
1091
1092   /* ton: made this 230 instead of 229,
1093    * to be sure (tuho files) and this is a reliable check anyway
1094    * nevertheless, we might need to think over a fitness (initialize)
1095    * check apart from the do_versions()
1096    */
1097
1098   if (bmain->versionfile <= 230) {
1099     bScreen *screen;
1100
1101     /* new variable blockscale, for panels in any area */
1102     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1103       ScrArea *area;
1104
1105       for (area = screen->areabase.first; area; area = area->next) {
1106         SpaceLink *sl;
1107
1108         for (sl = area->spacedata.first; sl; sl = sl->next) {
1109           /* added: 5x better zoom in for action */
1110           if (sl->spacetype == SPACE_ACTION) {
1111             SpaceAction *sac = (SpaceAction *)sl;
1112             sac->v2d.maxzoom = 50;
1113           }
1114         }
1115       }
1116     }
1117   }
1118
1119   if (bmain->versionfile <= 231) {
1120     bScreen *screen = bmain->screens.first;
1121
1122     /* new bit flags for showing/hiding grid floor and axes */
1123
1124     while (screen) {
1125       ScrArea *area = screen->areabase.first;
1126       while (area) {
1127         SpaceLink *sl = area->spacedata.first;
1128         while (sl) {
1129           if (sl->spacetype == SPACE_VIEW3D) {
1130             View3D *v3d = (View3D *)sl;
1131
1132             if (v3d->gridflag == 0) {
1133               v3d->gridflag |= V3D_SHOW_X;
1134               v3d->gridflag |= V3D_SHOW_Y;
1135               v3d->gridflag |= V3D_SHOW_FLOOR;
1136               v3d->gridflag &= ~V3D_SHOW_Z;
1137             }
1138           }
1139           sl = sl->next;
1140         }
1141         area = area->next;
1142       }
1143       screen = screen->id.next;
1144     }
1145   }
1146
1147   if (bmain->versionfile <= 232) {
1148     Tex *tex = bmain->textures.first;
1149     World *wrld = bmain->worlds.first;
1150     bScreen *screen;
1151
1152     while (tex) {
1153       if ((tex->flag & (TEX_CHECKER_ODD + TEX_CHECKER_EVEN)) == 0) {
1154         tex->flag |= TEX_CHECKER_ODD;
1155       }
1156       /* copied from kernel texture.c */
1157       if (tex->ns_outscale == 0.0f) {
1158         /* musgrave */
1159         tex->mg_H = 1.0f;
1160         tex->mg_lacunarity = 2.0f;
1161         tex->mg_octaves = 2.0f;
1162         tex->mg_offset = 1.0f;
1163         tex->mg_gain = 1.0f;
1164         tex->ns_outscale = 1.0f;
1165         /* distnoise */
1166         tex->dist_amount = 1.0f;
1167         /* voronoi */
1168         tex->vn_w1 = 1.0f;
1169         tex->vn_mexp = 2.5f;
1170       }
1171       tex = tex->id.next;
1172     }
1173
1174     while (wrld) {
1175       if (wrld->aodist == 0.0f) {
1176         wrld->aodist = 10.0f;
1177       }
1178       if (wrld->aoenergy == 0.0f) {
1179         wrld->aoenergy = 1.0f;
1180       }
1181       wrld = wrld->id.next;
1182     }
1183
1184     /* new variable blockscale, for panels in any area, do again because new
1185      * areas didn't initialize it to 0.7 yet
1186      */
1187     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1188       ScrArea *area;
1189       for (area = screen->areabase.first; area; area = area->next) {
1190         SpaceLink *sl;
1191         for (sl = area->spacedata.first; sl; sl = sl->next) {
1192           /* added: 5x better zoom in for nla */
1193           if (sl->spacetype == SPACE_NLA) {
1194             SpaceNla *snla = (SpaceNla *)sl;
1195             snla->v2d.maxzoom = 50;
1196           }
1197         }
1198       }
1199     }
1200   }
1201
1202   if (bmain->versionfile <= 233) {
1203     bScreen *screen;
1204
1205     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1206       ScrArea *area;
1207       for (area = screen->areabase.first; area; area = area->next) {
1208         SpaceLink *sl;
1209         for (sl = area->spacedata.first; sl; sl = sl->next) {
1210           if (sl->spacetype == SPACE_VIEW3D) {
1211             View3D *v3d = (View3D *)sl;
1212             v3d->flag |= V3D_SELECT_OUTLINE;
1213           }
1214         }
1215       }
1216     }
1217   }
1218
1219   if (bmain->versionfile <= 234) {
1220     bScreen *screen;
1221
1222     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1223       ScrArea *area;
1224       for (area = screen->areabase.first; area; area = area->next) {
1225         SpaceLink *sl;
1226         for (sl = area->spacedata.first; sl; sl = sl->next) {
1227           if (sl->spacetype == SPACE_TEXT) {
1228             SpaceText *st = (SpaceText *)sl;
1229             if (st->tabnumber == 0) {
1230               st->tabnumber = 2;
1231             }
1232           }
1233         }
1234       }
1235     }
1236   }
1237
1238   if (bmain->versionfile <= 235) {
1239     Tex *tex = bmain->textures.first;
1240     Scene *sce = bmain->scenes.first;
1241     Sequence *seq;
1242     Editing *ed;
1243
1244     while (tex) {
1245       if (tex->nabla == 0.0f) {
1246         tex->nabla = 0.025f;
1247       }
1248       tex = tex->id.next;
1249     }
1250     while (sce) {
1251       ed = sce->ed;
1252       if (ed) {
1253         SEQ_BEGIN (sce->ed, seq) {
1254           if (seq->type == SEQ_TYPE_IMAGE || seq->type == SEQ_TYPE_MOVIE) {
1255             seq->alpha_mode = SEQ_ALPHA_STRAIGHT;
1256           }
1257         }
1258         SEQ_END;
1259       }
1260
1261       sce = sce->id.next;
1262     }
1263   }
1264
1265   if (bmain->versionfile <= 236) {
1266     Object *ob;
1267     Camera *cam = bmain->cameras.first;
1268
1269     while (cam) {
1270       if (cam->ortho_scale == 0.0f) {
1271         cam->ortho_scale = 256.0f / cam->lens;
1272         if (cam->type == CAM_ORTHO) {
1273           printf("NOTE: ortho render has changed, tweak new Camera 'scale' value.\n");
1274         }
1275       }
1276       cam = cam->id.next;
1277     }
1278     /* force oops draw if depgraph was set*/
1279     /* set time line var */
1280
1281     /* softbody init new vars */
1282     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1283       if (ob->soft) {
1284         if (ob->soft->defgoal == 0.0f) {
1285           ob->soft->defgoal = 0.7f;
1286         }
1287         if (ob->soft->physics_speed == 0.0f) {
1288           ob->soft->physics_speed = 1.0f;
1289         }
1290
1291         if (ob->soft->interval == 0) {
1292           ob->soft->interval = 2;
1293           ob->soft->sfra = 1;
1294           ob->soft->efra = 100;
1295         }
1296       }
1297       if (ob->soft && ob->soft->vertgroup == 0) {
1298         bDeformGroup *locGroup = BKE_object_defgroup_find_name(ob, "SOFTGOAL");
1299         if (locGroup) {
1300           /* retrieve index for that group */
1301           ob->soft->vertgroup = 1 + BLI_findindex(&ob->defbase, locGroup);
1302         }
1303       }
1304     }
1305   }
1306
1307   if (bmain->versionfile <= 237) {
1308     bArmature *arm;
1309     bConstraint *con;
1310     Object *ob;
1311     Bone *bone;
1312
1313     /* armature recode checks */
1314     for (arm = bmain->armatures.first; arm; arm = arm->id.next) {
1315       BKE_armature_where_is(arm);
1316
1317       for (bone = arm->bonebase.first; bone; bone = bone->next) {
1318         do_version_bone_head_tail_237(bone);
1319       }
1320     }
1321     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1322       if (ob->parent) {
1323         Object *parent = blo_do_versions_newlibadr(fd, lib, ob->parent);
1324         if (parent && parent->type == OB_LATTICE) {
1325           ob->partype = PARSKEL;
1326         }
1327       }
1328
1329       /* btw. armature_rebuild_pose is further only called on leave editmode */
1330       if (ob->type == OB_ARMATURE) {
1331         if (ob->pose) {
1332           BKE_pose_tag_recalc(bmain, ob->pose);
1333         }
1334
1335         /* cannot call stuff now (pointers!), done in setup_app_data */
1336         ob->id.recalc |= ID_RECALC_ALL;
1337
1338         /* new generic xray option */
1339         arm = blo_do_versions_newlibadr(fd, lib, ob->data);
1340         enum { ARM_DRAWXRAY = (1 << 1) };
1341         if (arm->flag & ARM_DRAWXRAY) {
1342           ob->dtx |= OB_DRAWXRAY;
1343         }
1344       }
1345       else if (ob->type == OB_MESH) {
1346         Mesh *me = blo_do_versions_newlibadr(fd, lib, ob->data);
1347
1348         enum {
1349           ME_SUBSURF = (1 << 7),
1350           ME_OPT_EDGES = (1 << 8),
1351         };
1352
1353         if ((me->flag & ME_SUBSURF)) {
1354           SubsurfModifierData *smd = (SubsurfModifierData *)modifier_new(eModifierType_Subsurf);
1355
1356           smd->levels = MAX2(1, me->subdiv);
1357           smd->renderLevels = MAX2(1, me->subdivr);
1358           smd->subdivType = me->subsurftype;
1359
1360           smd->modifier.mode = 0;
1361           if (me->subdiv != 0) {
1362             smd->modifier.mode |= 1;
1363           }
1364           if (me->subdivr != 0) {
1365             smd->modifier.mode |= 2;
1366           }
1367
1368           if (me->flag & ME_OPT_EDGES) {
1369             smd->flags |= eSubsurfModifierFlag_ControlEdges;
1370           }
1371
1372           BLI_addtail(&ob->modifiers, smd);
1373
1374           modifier_unique_name(&ob->modifiers, (ModifierData *)smd);
1375         }
1376       }
1377
1378       /* follow path constraint needs to set the 'path' option in curves... */
1379       for (con = ob->constraints.first; con; con = con->next) {
1380         if (con->type == CONSTRAINT_TYPE_FOLLOWPATH) {
1381           bFollowPathConstraint *data = con->data;
1382           Object *obc = blo_do_versions_newlibadr(fd, lib, data->tar);
1383
1384           if (obc && obc->type == OB_CURVE) {
1385             Curve *cu = blo_do_versions_newlibadr(fd, lib, obc->data);
1386             if (cu) {
1387               cu->flag |= CU_PATH;
1388             }
1389           }
1390         }
1391       }
1392     }
1393   }
1394
1395   if (bmain->versionfile <= 238) {
1396     Lattice *lt;
1397     Object *ob;
1398     bArmature *arm;
1399     Mesh *me;
1400     Key *key;
1401     Scene *sce = bmain->scenes.first;
1402
1403     while (sce) {
1404       if (sce->toolsettings == NULL) {
1405         sce->toolsettings = MEM_callocN(sizeof(struct ToolSettings), "Tool Settings Struct");
1406         sce->toolsettings->doublimit = 0.001f;
1407       }
1408       sce = sce->id.next;
1409     }
1410
1411     for (lt = bmain->lattices.first; lt; lt = lt->id.next) {
1412       if (lt->fu == 0.0f && lt->fv == 0.0f && lt->fw == 0.0f) {
1413         calc_lat_fudu(lt->flag, lt->pntsu, &lt->fu, &lt->du);
1414         calc_lat_fudu(lt->flag, lt->pntsv, &lt->fv, &lt->dv);
1415         calc_lat_fudu(lt->flag, lt->pntsw, &lt->fw, &lt->dw);
1416       }
1417     }
1418
1419     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1420       ModifierData *md;
1421       PartEff *paf;
1422
1423       for (md = ob->modifiers.first; md; md = md->next) {
1424         if (md->type == eModifierType_Subsurf) {
1425           SubsurfModifierData *smd = (SubsurfModifierData *)md;
1426
1427           smd->flags &= ~(eSubsurfModifierFlag_Incremental | eSubsurfModifierFlag_DebugIncr);
1428         }
1429       }
1430
1431       if ((ob->softflag & OB_SB_ENABLE) && !modifiers_findByType(ob, eModifierType_Softbody)) {
1432         if (ob->softflag & OB_SB_POSTDEF) {
1433           md = ob->modifiers.first;
1434
1435           while (md && modifierType_getInfo(md->type)->type == eModifierTypeType_OnlyDeform) {
1436             md = md->next;
1437           }
1438
1439           BLI_insertlinkbefore(&ob->modifiers, md, modifier_new(eModifierType_Softbody));
1440         }
1441         else {
1442           BLI_addhead(&ob->modifiers, modifier_new(eModifierType_Softbody));
1443         }
1444
1445         ob->softflag &= ~OB_SB_ENABLE;
1446       }
1447
1448       if (ob->pose) {
1449         bPoseChannel *pchan;
1450         bConstraint *con;
1451         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1452           /* note, pchan->bone is also lib-link stuff */
1453           if (pchan->limitmin[0] == 0.0f && pchan->limitmax[0] == 0.0f) {
1454             pchan->limitmin[0] = pchan->limitmin[1] = pchan->limitmin[2] = -180.0f;
1455             pchan->limitmax[0] = pchan->limitmax[1] = pchan->limitmax[2] = 180.0f;
1456
1457             for (con = pchan->constraints.first; con; con = con->next) {
1458               if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
1459                 bKinematicConstraint *data = (bKinematicConstraint *)con->data;
1460                 data->weight = 1.0f;
1461                 data->orientweight = 1.0f;
1462                 data->flag &= ~CONSTRAINT_IK_ROT;
1463
1464                 /* enforce conversion from old IK_TOPARENT to rootbone index */
1465                 data->rootbone = -1;
1466
1467                 /* update_pose_etc handles rootbone == -1 */
1468                 BKE_pose_tag_recalc(bmain, ob->pose);
1469               }
1470             }
1471           }
1472         }
1473       }
1474
1475       paf = blo_do_version_give_parteff_245(ob);
1476       if (paf) {
1477         if (paf->disp == 0) {
1478           paf->disp = 100;
1479         }
1480         if (paf->speedtex == 0) {
1481           paf->speedtex = 8;
1482         }
1483         if (paf->omat == 0) {
1484           paf->omat = 1;
1485         }
1486       }
1487     }
1488
1489     for (arm = bmain->armatures.first; arm; arm = arm->id.next) {
1490       bone_version_238(&arm->bonebase);
1491       arm->deformflag |= ARM_DEF_VGROUP;
1492     }
1493
1494     for (me = bmain->meshes.first; me; me = me->id.next) {
1495       if (!me->medge) {
1496         BKE_mesh_calc_edges_legacy(me, true); /* true = use mface->edcode */
1497       }
1498       else {
1499         BKE_mesh_strip_loose_faces(me);
1500       }
1501     }
1502
1503     for (key = bmain->shapekeys.first; key; key = key->id.next) {
1504       KeyBlock *kb;
1505       int index = 1;
1506
1507       for (kb = key->block.first; kb; kb = kb->next) {
1508         if (kb == key->refkey) {
1509           if (kb->name[0] == 0) {
1510             strcpy(kb->name, "Basis");
1511           }
1512         }
1513         else {
1514           if (kb->name[0] == 0) {
1515             BLI_snprintf(kb->name, sizeof(kb->name), "Key %d", index);
1516           }
1517           index++;
1518         }
1519       }
1520     }
1521   }
1522
1523   if (bmain->versionfile <= 239) {
1524     bArmature *arm;
1525     Object *ob;
1526     Scene *sce = bmain->scenes.first;
1527     Camera *cam = bmain->cameras.first;
1528     int set_passepartout = 0;
1529
1530     /* deformflag is local in modifier now */
1531     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1532       ModifierData *md;
1533
1534       for (md = ob->modifiers.first; md; md = md->next) {
1535         if (md->type == eModifierType_Armature) {
1536           ArmatureModifierData *amd = (ArmatureModifierData *)md;
1537           if (amd->object && amd->deformflag == 0) {
1538             Object *oba = blo_do_versions_newlibadr(fd, lib, amd->object);
1539             arm = blo_do_versions_newlibadr(fd, lib, oba->data);
1540             amd->deformflag = arm->deformflag;
1541           }
1542         }
1543       }
1544     }
1545
1546     /* updating stepsize for ghost drawing */
1547     for (arm = bmain->armatures.first; arm; arm = arm->id.next) {
1548       bone_version_239(&arm->bonebase);
1549       if (arm->layer == 0) {
1550         arm->layer = 1;
1551       }
1552     }
1553
1554     for (; sce; sce = sce->id.next) {
1555       if (sce->r.scemode & R_PASSEPARTOUT) {
1556         set_passepartout = 1;
1557         sce->r.scemode &= ~R_PASSEPARTOUT;
1558       }
1559     }
1560
1561     for (; cam; cam = cam->id.next) {
1562       if (set_passepartout) {
1563         cam->flag |= CAM_SHOWPASSEPARTOUT;
1564       }
1565
1566       /* make sure old cameras have title safe on */
1567       if (!(cam->flag & CAM_SHOW_SAFE_MARGINS)) {
1568         cam->flag |= CAM_SHOW_SAFE_MARGINS;
1569       }
1570
1571       /* set an appropriate camera passepartout alpha */
1572       if (!(cam->passepartalpha)) {
1573         cam->passepartalpha = 0.2f;
1574       }
1575     }
1576   }
1577
1578   if (bmain->versionfile <= 241) {
1579     Object *ob;
1580     Scene *sce;
1581     Light *la;
1582     bArmature *arm;
1583     bNodeTree *ntree;
1584
1585     /* updating layers still */
1586     for (arm = bmain->armatures.first; arm; arm = arm->id.next) {
1587       bone_version_239(&arm->bonebase);
1588       if (arm->layer == 0) {
1589         arm->layer = 1;
1590       }
1591     }
1592     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1593       if (sce->audio.mixrate == 0) {
1594         sce->audio.mixrate = 48000;
1595       }
1596
1597       /* We don't add default layer since blender2.8 because the layers
1598        * are now in Scene->view_layers and a default layer is created in
1599        * the doversion later on.
1600        */
1601       SceneRenderLayer *srl;
1602       /* new layer flag for sky, was default for solid */
1603       for (srl = sce->r.layers.first; srl; srl = srl->next) {
1604         if (srl->layflag & SCE_LAY_SOLID) {
1605           srl->layflag |= SCE_LAY_SKY;
1606         }
1607         srl->passflag &= (SCE_PASS_COMBINED | SCE_PASS_Z | SCE_PASS_NORMAL | SCE_PASS_VECTOR);
1608       }
1609
1610       /* node version changes */
1611       if (sce->nodetree) {
1612         ntree_version_241(sce->nodetree);
1613       }
1614
1615       /* uv calculation options moved to toolsettings */
1616       if (sce->toolsettings->unwrapper == 0) {
1617         sce->toolsettings->uvcalc_flag = UVCALC_FILLHOLES;
1618         sce->toolsettings->unwrapper = 1;
1619       }
1620     }
1621
1622     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1623       ntree_version_241(ntree);
1624     }
1625
1626     for (la = bmain->lights.first; la; la = la->id.next) {
1627       if (la->buffers == 0) {
1628         la->buffers = 1;
1629       }
1630     }
1631
1632     /* for empty drawsize and drawtype */
1633     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1634       if (ob->empty_drawsize == 0.0f) {
1635         ob->empty_drawtype = OB_ARROWS;
1636         ob->empty_drawsize = 1.0;
1637       }
1638     }
1639
1640     /* during 2.41 images with this name were used for viewer node output, lets fix that */
1641     if (bmain->versionfile == 241) {
1642       Image *ima;
1643       for (ima = bmain->images.first; ima; ima = ima->id.next) {
1644         if (STREQ(ima->name, "Compositor")) {
1645           strcpy(ima->id.name + 2, "Viewer Node");
1646           strcpy(ima->name, "Viewer Node");
1647         }
1648       }
1649     }
1650   }
1651
1652   if (bmain->versionfile <= 242) {
1653     Scene *sce;
1654     bScreen *screen;
1655     Object *ob;
1656     Curve *cu;
1657     Material *ma;
1658     Mesh *me;
1659     Collection *collection;
1660     Nurb *nu;
1661     BezTriple *bezt;
1662     BPoint *bp;
1663     bNodeTree *ntree;
1664     int a;
1665
1666     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1667       ScrArea *area;
1668       area = screen->areabase.first;
1669       while (area) {
1670         SpaceLink *sl;
1671
1672         for (sl = area->spacedata.first; sl; sl = sl->next) {
1673           if (sl->spacetype == SPACE_VIEW3D) {
1674             View3D *v3d = (View3D *)sl;
1675             if (v3d->gridsubdiv == 0) {
1676               v3d->gridsubdiv = 10;
1677             }
1678           }
1679         }
1680         area = area->next;
1681       }
1682     }
1683
1684     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1685       enum {
1686         R_THREADS = (1 << 19),
1687       };
1688       if (sce->toolsettings->select_thresh == 0.0f) {
1689         sce->toolsettings->select_thresh = 0.01f;
1690       }
1691       if (sce->r.threads == 0) {
1692         if (sce->r.mode & R_THREADS) {
1693           sce->r.threads = 2;
1694         }
1695         else {
1696           sce->r.threads = 1;
1697         }
1698       }
1699       if (sce->nodetree) {
1700         ntree_version_242(sce->nodetree);
1701       }
1702     }
1703
1704     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1705       ntree_version_242(ntree);
1706     }
1707
1708     /* add default radius values to old curve points */
1709     for (cu = bmain->curves.first; cu; cu = cu->id.next) {
1710       for (nu = cu->nurb.first; nu; nu = nu->next) {
1711         if (nu->bezt) {
1712           for (bezt = nu->bezt, a = 0; a < nu->pntsu; a++, bezt++) {
1713             if (!bezt->radius) {
1714               bezt->radius = 1.0;
1715             }
1716           }
1717         }
1718         else if (nu->bp) {
1719           for (bp = nu->bp, a = 0; a < nu->pntsu * nu->pntsv; a++, bp++) {
1720             if (!bp->radius) {
1721               bp->radius = 1.0;
1722             }
1723           }
1724         }
1725       }
1726     }
1727
1728     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1729       ModifierData *md;
1730       ListBase *list;
1731       list = &ob->constraints;
1732
1733       /* check for already existing MinMax (floor) constraint
1734        * and update the sticky flagging */
1735
1736       if (list) {
1737         bConstraint *curcon;
1738         for (curcon = list->first; curcon; curcon = curcon->next) {
1739           switch (curcon->type) {
1740             case CONSTRAINT_TYPE_ROTLIKE: {
1741               bRotateLikeConstraint *data = curcon->data;
1742
1743               /* version patch from buttons_object.c */
1744               if (data->flag == 0) {
1745                 data->flag = ROTLIKE_X | ROTLIKE_Y | ROTLIKE_Z;
1746               }
1747
1748               break;
1749             }
1750           }
1751         }
1752       }
1753
1754       if (ob->type == OB_ARMATURE) {
1755         if (ob->pose) {
1756           bConstraint *curcon;
1757           bPoseChannel *pchan;
1758           for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1759             for (curcon = pchan->constraints.first; curcon; curcon = curcon->next) {
1760               switch (curcon->type) {
1761                 case CONSTRAINT_TYPE_KINEMATIC: {
1762                   bKinematicConstraint *data = curcon->data;
1763                   if (!(data->flag & CONSTRAINT_IK_POS)) {
1764                     data->flag |= CONSTRAINT_IK_POS;
1765                     data->flag |= CONSTRAINT_IK_STRETCH;
1766                   }
1767                   break;
1768                 }
1769                 case CONSTRAINT_TYPE_ROTLIKE: {
1770                   bRotateLikeConstraint *data = curcon->data;
1771
1772                   /* version patch from buttons_object.c */
1773                   if (data->flag == 0) {
1774                     data->flag = ROTLIKE_X | ROTLIKE_Y | ROTLIKE_Z;
1775                   }
1776                   break;
1777                 }
1778               }
1779             }
1780           }
1781         }
1782       }
1783
1784       /* copy old object level track settings to curve modifiers */
1785       for (md = ob->modifiers.first; md; md = md->next) {
1786         if (md->type == eModifierType_Curve) {
1787           CurveModifierData *cmd = (CurveModifierData *)md;
1788
1789           if (cmd->defaxis == 0) {
1790             cmd->defaxis = ob->trackflag + 1;
1791           }
1792         }
1793       }
1794     }
1795
1796     for (ma = bmain->materials.first; ma; ma = ma->id.next) {
1797       if (ma->nodetree) {
1798         ntree_version_242(ma->nodetree);
1799       }
1800     }
1801
1802     for (me = bmain->meshes.first; me; me = me->id.next) {
1803       customdata_version_242(me);
1804     }
1805
1806     for (collection = bmain->collections.first; collection; collection = collection->id.next) {
1807       if (collection->layer == 0) {
1808         collection->layer = (1 << 20) - 1;
1809       }
1810     }
1811
1812     /* now, subversion control! */
1813     if (bmain->subversionfile < 3) {
1814       Image *ima;
1815       Tex *tex;
1816
1817       /* Image refactor initialize */
1818       for (ima = bmain->images.first; ima; ima = ima->id.next) {
1819         ima->source = IMA_SRC_FILE;
1820         ima->type = IMA_TYPE_IMAGE;
1821
1822         ima->gen_x = 256;
1823         ima->gen_y = 256;
1824         ima->gen_type = 1;
1825
1826         if (STREQLEN(ima->id.name + 2, "Viewer Node", sizeof(ima->id.name) - 2)) {
1827           ima->source = IMA_SRC_VIEWER;
1828           ima->type = IMA_TYPE_COMPOSITE;
1829         }
1830         if (STREQLEN(ima->id.name + 2, "Render Result", sizeof(ima->id.name) - 2)) {
1831           ima->source = IMA_SRC_VIEWER;
1832           ima->type = IMA_TYPE_R_RESULT;
1833         }
1834       }
1835       for (tex = bmain->textures.first; tex; tex = tex->id.next) {
1836         enum {
1837           TEX_ANIMCYCLIC = (1 << 6),
1838           TEX_ANIM5 = (1 << 7),
1839         };
1840
1841         if (tex->type == TEX_IMAGE && tex->ima) {
1842           ima = blo_do_versions_newlibadr(fd, lib, tex->ima);
1843           if (tex->imaflag & TEX_ANIM5) {
1844             ima->source = IMA_SRC_MOVIE;
1845           }
1846         }
1847         tex->iuser.frames = tex->frames;
1848         tex->iuser.offset = tex->offset;
1849         tex->iuser.sfra = tex->sfra;
1850         tex->iuser.cycl = (tex->imaflag & TEX_ANIMCYCLIC) != 0;
1851       }
1852       for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1853         if (sce->nodetree) {
1854           do_version_ntree_242_2(sce->nodetree);
1855         }
1856       }
1857       for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1858         do_version_ntree_242_2(ntree);
1859       }
1860       for (ma = bmain->materials.first; ma; ma = ma->id.next) {
1861         if (ma->nodetree) {
1862           do_version_ntree_242_2(ma->nodetree);
1863         }
1864       }
1865     }
1866
1867     if (bmain->subversionfile < 4) {
1868       for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1869         sce->r.bake_mode = 1; /* prevent to include render stuff here */
1870         sce->r.bake_filter = 16;
1871         sce->r.bake_flag = R_BAKE_CLEAR;
1872       }
1873     }
1874   }
1875
1876   if (bmain->versionfile <= 243) {
1877     Object *ob = bmain->objects.first;
1878
1879     for (; ob; ob = ob->id.next) {
1880       bDeformGroup *curdef;
1881
1882       for (curdef = ob->defbase.first; curdef; curdef = curdef->next) {
1883         /* replace an empty-string name with unique name */
1884         if (curdef->name[0] == '\0') {
1885           BKE_object_defgroup_unique_name(curdef, ob);
1886         }
1887       }
1888
1889       if (bmain->versionfile < 243 || bmain->subversionfile < 1) {
1890         ModifierData *md;
1891
1892         /* translate old mirror modifier axis values to new flags */
1893         for (md = ob->modifiers.first; md; md = md->next) {
1894           if (md->type == eModifierType_Mirror) {
1895             MirrorModifierData *mmd = (MirrorModifierData *)md;
1896
1897             switch (mmd->axis) {
1898               case 0:
1899                 mmd->flag |= MOD_MIR_AXIS_X;
1900                 break;
1901               case 1:
1902                 mmd->flag |= MOD_MIR_AXIS_Y;
1903                 break;
1904               case 2:
1905                 mmd->flag |= MOD_MIR_AXIS_Z;
1906                 break;
1907             }
1908
1909             mmd->axis = 0;
1910           }
1911         }
1912       }
1913     }
1914
1915     /* render layer added, this is not the active layer */
1916     if (bmain->versionfile <= 243 || bmain->subversionfile < 2) {
1917       Mesh *me;
1918       for (me = bmain->meshes.first; me; me = me->id.next) {
1919         customdata_version_243(me);
1920       }
1921     }
1922   }
1923
1924   if (bmain->versionfile <= 244) {
1925     bScreen *screen;
1926
1927     if (bmain->versionfile != 244 || bmain->subversionfile < 2) {
1928       /* correct older action editors - incorrect scrolling */
1929       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1930         ScrArea *area;
1931         area = screen->areabase.first;
1932         while (area) {
1933           SpaceLink *sl;
1934
1935           for (sl = area->spacedata.first; sl; sl = sl->next) {
1936             if (sl->spacetype == SPACE_ACTION) {
1937               SpaceAction *saction = (SpaceAction *)sl;
1938
1939               saction->v2d.tot.ymin = -1000.0;
1940               saction->v2d.tot.ymax = 0.0;
1941
1942               saction->v2d.cur.ymin = -75.0;
1943               saction->v2d.cur.ymax = 5.0;
1944             }
1945           }
1946           area = area->next;
1947         }
1948       }
1949     }
1950   }
1951
1952   if (bmain->versionfile <= 245) {
1953     Scene *sce;
1954     Object *ob;
1955     Image *ima;
1956     Light *la;
1957     Material *ma;
1958     ParticleSettings *part;
1959     Mesh *me;
1960     bNodeTree *ntree;
1961     Tex *tex;
1962     ModifierData *md;
1963     ParticleSystem *psys;
1964
1965     /* unless the file was created 2.44.3 but not 2.45, update the constraints */
1966     if (!(bmain->versionfile == 244 && bmain->subversionfile == 3) &&
1967         ((bmain->versionfile < 245) ||
1968          (bmain->versionfile == 245 && bmain->subversionfile == 0))) {
1969       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1970         ListBase *list;
1971         list = &ob->constraints;
1972
1973         /* fix up constraints due to constraint recode changes (originally at 2.44.3) */
1974         if (list) {
1975           bConstraint *curcon;
1976           for (curcon = list->first; curcon; curcon = curcon->next) {
1977             /* old CONSTRAINT_LOCAL check -> convert to CONSTRAINT_SPACE_LOCAL */
1978             if (curcon->flag & 0x20) {
1979               curcon->ownspace = CONSTRAINT_SPACE_LOCAL;
1980               curcon->tarspace = CONSTRAINT_SPACE_LOCAL;
1981             }
1982
1983             switch (curcon->type) {
1984               case CONSTRAINT_TYPE_LOCLIMIT: {
1985                 bLocLimitConstraint *data = (bLocLimitConstraint *)curcon->data;
1986
1987                 /* old limit without parent option for objects */
1988                 if (data->flag2) {
1989                   curcon->ownspace = CONSTRAINT_SPACE_LOCAL;
1990                 }
1991                 break;
1992               }
1993             }
1994           }
1995         }
1996
1997         /* correctly initialize constinv matrix */
1998         unit_m4(ob->constinv);
1999
2000         if (ob->type == OB_ARMATURE) {
2001           if (ob->pose) {
2002             bConstraint *curcon;
2003             bPoseChannel *pchan;
2004
2005             for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2006               /* make sure constraints are all up to date */
2007               for (curcon = pchan->constraints.first; curcon; curcon = curcon->next) {
2008                 /* old CONSTRAINT_LOCAL check -> convert to CONSTRAINT_SPACE_LOCAL */
2009                 if (curcon->flag & 0x20) {
2010                   curcon->ownspace = CONSTRAINT_SPACE_LOCAL;
2011                   curcon->tarspace = CONSTRAINT_SPACE_LOCAL;
2012                 }
2013
2014                 switch (curcon->type) {
2015                   case CONSTRAINT_TYPE_ACTION: {
2016                     bActionConstraint *data = (bActionConstraint *)curcon->data;
2017
2018                     /* 'data->local' used to mean that target was in local-space */
2019                     if (data->local) {
2020                       curcon->tarspace = CONSTRAINT_SPACE_LOCAL;
2021                     }
2022                     break;
2023                   }
2024                 }
2025               }
2026
2027               /* correctly initialize constinv matrix */
2028               unit_m4(pchan->constinv);
2029             }
2030           }
2031         }
2032       }
2033     }
2034
2035     /* fix all versions before 2.45 */
2036     if (bmain->versionfile != 245) {
2037
2038       /* repair preview from 242 - 244*/
2039       for (ima = bmain->images.first; ima; ima = ima->id.next) {
2040         ima->preview = NULL;
2041       }
2042     }
2043
2044     /* add point caches */
2045     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2046       if (ob->soft && !ob->soft->pointcache) {
2047         ob->soft->pointcache = BKE_ptcache_add(&ob->soft->ptcaches);
2048       }
2049
2050       for (psys = ob->particlesystem.first; psys; psys = psys->next) {
2051         if (psys->pointcache) {
2052           if (psys->pointcache->flag & PTCACHE_BAKED &&
2053               (psys->pointcache->flag & PTCACHE_DISK_CACHE) == 0) {
2054             printf("Old memory cache isn't supported for particles, so re-bake the simulation!\n");
2055             psys->pointcache->flag &= ~PTCACHE_BAKED;
2056           }
2057         }
2058         else {
2059           psys->pointcache = BKE_ptcache_add(&psys->ptcaches);
2060         }
2061       }
2062
2063       for (md = ob->modifiers.first; md; md = md->next) {
2064         if (md->type == eModifierType_Cloth) {
2065           ClothModifierData *clmd = (ClothModifierData *)md;
2066           if (!clmd->point_cache) {
2067             clmd->point_cache = BKE_ptcache_add(&clmd->ptcaches);
2068             clmd->point_cache->step = 1;
2069           }
2070         }
2071       }
2072     }
2073
2074     /* Copy over old per-level multires vertex data
2075      * into a single vertex array in struct Multires */
2076     for (me = bmain->meshes.first; me; me = me->id.next) {
2077       if (me->mr && !me->mr->verts) {
2078         MultiresLevel *lvl = me->mr->levels.last;
2079         if (lvl) {
2080           me->mr->verts = lvl->verts;
2081           lvl->verts = NULL;
2082           /* Don't need the other vert arrays */
2083           for (lvl = lvl->prev; lvl; lvl = lvl->prev) {
2084             MEM_freeN(lvl->verts);
2085             lvl->verts = NULL;
2086           }
2087         }
2088       }
2089     }
2090
2091     if (bmain->versionfile != 245 || bmain->subversionfile < 1) {
2092       for (la = bmain->lights.first; la; la = la->id.next) {
2093         la->falloff_type = LA_FALLOFF_INVLINEAR;
2094
2095         if (la->curfalloff == NULL) {
2096           la->curfalloff = BKE_curvemapping_add(1, 0.0f, 1.0f, 1.0f, 0.0f);
2097           BKE_curvemapping_initialize(la->curfalloff);
2098         }
2099       }
2100     }
2101
2102     for (ma = bmain->materials.first; ma; ma = ma->id.next) {
2103       if (ma->gloss_mir == 0.0f) {
2104         ma->gloss_mir = 1.0f;
2105       }
2106     }
2107
2108     for (part = bmain->particles.first; part; part = part->id.next) {
2109       if (part->ren_child_nbr == 0) {
2110         part->ren_child_nbr = part->child_nbr;
2111       }
2112     }
2113
2114     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
2115       if (sce->nodetree) {
2116         ntree_version_245(fd, lib, sce->nodetree);
2117       }
2118
2119       if (sce->r.simplify_subsurf == 0) {
2120         sce->r.simplify_subsurf = 6;
2121         sce->r.simplify_particles = 1.0f;
2122       }
2123     }
2124
2125     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
2126       ntree_version_245(fd, lib, ntree);
2127     }
2128
2129     /* fix for temporary flag changes during 245 cycle */
2130     for (ima = bmain->images.first; ima; ima = ima->id.next) {
2131       if (ima->flag & IMA_OLD_PREMUL) {
2132         ima->flag &= ~IMA_OLD_PREMUL;
2133         ima->alpha_mode = IMA_ALPHA_STRAIGHT;
2134       }
2135     }
2136
2137     for (tex = bmain->textures.first; tex; tex = tex->id.next) {
2138       if (tex->iuser.flag & IMA_OLD_PREMUL) {
2139         tex->iuser.flag &= ~IMA_OLD_PREMUL;
2140       }
2141
2142       ima = blo_do_versions_newlibadr(fd, lib, tex->ima);
2143       if (ima && (tex->iuser.flag & IMA_DO_PREMUL)) {
2144         ima->flag &= ~IMA_OLD_PREMUL;
2145         ima->alpha_mode = IMA_ALPHA_STRAIGHT;
2146       }
2147     }
2148   }
2149
2150   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 2)) {
2151     Image *ima;
2152
2153     /* initialize 1:1 Aspect */
2154     for (ima = bmain->images.first; ima; ima = ima->id.next) {
2155       ima->aspx = ima->aspy = 1.0f;
2156     }
2157   }
2158
2159   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 4)) {
2160     bArmature *arm;
2161     ModifierData *md;
2162     Object *ob;
2163
2164     for (arm = bmain->armatures.first; arm; arm = arm->id.next) {
2165       arm->deformflag |= ARM_DEF_B_BONE_REST;
2166     }
2167
2168     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2169       for (md = ob->modifiers.first; md; md = md->next) {
2170         if (md->type == eModifierType_Armature) {
2171           ((ArmatureModifierData *)md)->deformflag |= ARM_DEF_B_BONE_REST;
2172         }
2173       }
2174     }
2175   }
2176
2177   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 5)) {
2178     /* foreground color needs to be something other then black */
2179     Scene *sce;
2180     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
2181       sce->r.fg_stamp[0] = sce->r.fg_stamp[1] = sce->r.fg_stamp[2] = 0.8f;
2182       sce->r.fg_stamp[3] = 1.0f;  /* don't use text alpha yet */
2183       sce->r.bg_stamp[3] = 0.25f; /* make sure the background has full alpha */
2184     }
2185   }
2186
2187   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 6)) {
2188     Scene *sce;
2189     /* fix frs_sec_base */
2190     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
2191       if (sce->r.frs_sec_base == 0) {
2192         sce->r.frs_sec_base = 1;
2193       }
2194     }
2195   }
2196
2197   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 7)) {
2198     Object *ob;
2199     bPoseChannel *pchan;
2200
2201     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2202       if (ob->pose) {
2203         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
2204           do_version_constraints_245(&pchan->constraints);
2205         }
2206       }
2207       do_version_constraints_245(&ob->constraints);
2208
2209       if (ob->soft && ob->soft->keys) {
2210         SoftBody *sb = ob->soft;
2211         int k;
2212
2213         for (k = 0; k < sb->totkey; k++) {
2214           if (sb->keys[k]) {
2215             MEM_freeN(sb->keys[k]);
2216           }
2217         }
2218
2219         MEM_freeN(sb->keys);
2220
2221         sb->keys = NULL;
2222         sb->totkey = 0;
2223       }
2224     }
2225   }
2226
2227   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 8)) {
2228     Scene *sce;
2229     Object *ob;
2230     PartEff *paf = NULL;
2231
2232     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2233       if (ob->soft && ob->soft->keys) {
2234         SoftBody *sb = ob->soft;
2235         int k;
2236
2237         for (k = 0; k < sb->totkey; k++) {
2238           if (sb->keys[k]) {
2239             MEM_freeN(sb->keys[k]);
2240           }
2241         }
2242
2243         MEM_freeN(sb->keys);
2244
2245         sb->keys = NULL;
2246         sb->totkey = 0;
2247       }
2248
2249       /* convert old particles to new system */
2250       if ((paf = blo_do_version_give_parteff_245(ob))) {
2251         ParticleSystem *psys;
2252         ModifierData *md;
2253         ParticleSystemModifierData *psmd;
2254         ParticleSettings *part;
2255
2256         /* create new particle system */
2257         psys = MEM_callocN(sizeof(ParticleSystem), "particle_system");
2258         psys->pointcache = BKE_ptcache_add(&psys->ptcaches);
2259
2260         part = psys->part = BKE_particlesettings_add(bmain, "ParticleSettings");
2261
2262         /* needed for proper libdata lookup */
2263         blo_do_versions_oldnewmap_insert(fd->libmap, psys->part, psys->part, 0);
2264         part->id.lib = ob->id.lib;
2265
2266         part->id.us--;
2267         part->id.tag |= (ob->id.tag & LIB_TAG_NEED_LINK);
2268
2269         psys->totpart = 0;
2270         psys->flag = PSYS_CURRENT;
2271
2272         BLI_addtail(&ob->particlesystem, psys);
2273
2274         md = modifier_new(eModifierType_ParticleSystem);
2275         BLI_snprintf(md->name,
2276                      sizeof(md->name),
2277                      "ParticleSystem %i",
2278                      BLI_listbase_count(&ob->particlesystem));
2279         psmd = (ParticleSystemModifierData *)md;
2280         psmd->psys = psys;
2281         BLI_addtail(&ob->modifiers, md);
2282
2283         /* convert settings from old particle system */
2284         /* general settings */
2285         part->totpart = MIN2(paf->totpart, 100000);
2286         part->sta = paf->sta;
2287         part->end = paf->end;
2288         part->lifetime = paf->lifetime;
2289         part->randlife = paf->randlife;
2290         psys->seed = paf->seed;
2291         part->disp = paf->disp;
2292         part->omat = paf->mat[0];
2293         part->hair_step = paf->totkey;
2294
2295         part->force_group = paf->group;
2296
2297         /* old system didn't interpolate between keypoints at render time */
2298         part->draw_step = part->ren_step = 0;
2299
2300         /* physics */
2301         part->normfac = paf->normfac * 25.0f;
2302         part->obfac = paf->obfac;
2303         part->randfac = paf->randfac * 25.0f;
2304         part->dampfac = paf->damp;
2305         copy_v3_v3(part->acc, paf->force);
2306
2307         /* flags */
2308         if (paf->stype & PAF_VECT) {
2309           if (paf->flag & PAF_STATIC) {
2310             /* new hair lifetime is always 100.0f */
2311             float fac = paf->lifetime / 100.0f;
2312
2313             part->draw_as = PART_DRAW_PATH;
2314             part->type = PART_HAIR;
2315             psys->recalc |= ID_RECALC_PSYS_REDO;
2316
2317             part->normfac *= fac;
2318             part->randfac *= fac;
2319           }
2320           else {
2321             part->draw_as = PART_DRAW_LINE;
2322             part->draw |= PART_DRAW_VEL_LENGTH;
2323             part->draw_line[1] = 0.04f;
2324           }
2325         }
2326
2327         part->rotmode = PART_ROT_VEL;
2328
2329         part->flag |= (paf->flag & PAF_BSPLINE) ? PART_HAIR_BSPLINE : 0;
2330         part->flag |= (paf->flag & PAF_TRAND) ? PART_TRAND : 0;
2331         part->flag |= (paf->flag & PAF_EDISTR) ? PART_EDISTR : 0;
2332         part->flag |= (paf->flag & PAF_UNBORN) ? PART_UNBORN : 0;
2333         part->flag |= (paf->flag & PAF_DIED) ? PART_DIED : 0;
2334         part->from |= (paf->flag & PAF_FACE) ? PART_FROM_FACE : 0;
2335         part->draw |= (paf->flag & PAF_SHOWE) ? PART_DRAW_EMITTER : 0;
2336
2337         psys->vgroup[PSYS_VG_DENSITY] = paf->vertgroup;
2338         psys->vgroup[PSYS_VG_VEL] = paf->vertgroup_v;
2339         psys->vgroup[PSYS_VG_LENGTH] = paf->vertgroup_v;
2340
2341         /* dupliobjects */
2342         if (ob->transflag & OB_DUPLIVERTS) {
2343           Object *dup = bmain->objects.first;
2344
2345           for (; dup; dup = dup->id.next) {
2346             if (ob == blo_do_versions_newlibadr(fd, lib, dup->parent)) {
2347               part->instance_object = dup;
2348               ob->transflag |= OB_DUPLIPARTS;
2349               ob->transflag &= ~OB_DUPLIVERTS;
2350
2351               part->draw_as = PART_DRAW_OB;
2352
2353               /* needed for proper libdata lookup */
2354               blo_do_versions_oldnewmap_insert(fd->libmap, dup, dup, 0);
2355             }
2356           }
2357         }
2358
2359         {
2360           FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType(
2361               ob, eModifierType_Fluidsim);
2362           if (fluidmd && fluidmd->fss && fluidmd->fss->type == OB_FLUIDSIM_PARTICLE) {
2363             part->type = PART_FLUID;
2364           }
2365         }
2366
2367         do_version_free_effects_245(&ob->effect);
2368
2369         printf("Old particle system converted to new system.\n");
2370       }
2371     }
2372
2373     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
2374       ParticleEditSettings *pset = &sce->toolsettings->particle;
2375       int a;
2376
2377       if (pset->brush[0].size == 0) {
2378         pset->flag = PE_KEEP_LENGTHS | PE_LOCK_FIRST | PE_DEFLECT_EMITTER;
2379         pset->emitterdist = 0.25f;
2380         pset->totrekey = 5;
2381         pset->totaddkey = 5;
2382
2383         for (a = 0; a < ARRAY_SIZE(pset->brush); a++) {
2384           pset->brush[a].strength = 50;
2385           pset->brush[a].size = 50;
2386           pset->brush[a].step = 10;
2387         }
2388
2389         pset->brush[PE_BRUSH_CUT].strength = 100;
2390       }
2391     }
2392   }
2393
2394   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 10)) {
2395     Object *ob;
2396
2397     /* dupliface scale */
2398     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2399       ob->instance_faces_scale = 1.0f;
2400     }
2401   }
2402
2403   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 11)) {
2404     Object *ob;
2405     bActionStrip *strip;
2406
2407     /* nla-strips - scale */
2408     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2409       for (strip = ob->nlastrips.first; strip; strip = strip->next) {
2410         float length, actlength, repeat;
2411
2412         if (strip->flag & ACTSTRIP_USESTRIDE) {
2413           repeat = 1.0f;
2414         }
2415         else {
2416           repeat = strip->repeat;
2417         }
2418
2419         length = strip->end - strip->start;
2420         if (length == 0.0f) {
2421           length = 1.0f;
2422         }
2423         actlength = strip->actend - strip->actstart;
2424
2425         strip->scale = length / (repeat * actlength);
2426         if (strip->scale == 0.0f) {
2427           strip->scale = 1.0f;
2428         }
2429       }
2430       if (ob->soft) {
2431         ob->soft->inpush = ob->soft->inspring;
2432         ob->soft->shearstiff = 1.0f;
2433       }
2434     }
2435   }
2436
2437   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 14)) {
2438     Scene *sce;
2439     Sequence *seq;
2440
2441     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
2442       SEQ_BEGIN (sce->ed, seq) {
2443         if (seq->blend_mode == 0) {
2444           seq->blend_opacity = 100.0f;
2445         }
2446       }
2447       SEQ_END;
2448     }
2449   }
2450
2451   /* fix broken group lengths in id properties */
2452   if ((bmain->versionfile < 245) || (bmain->versionfile == 245 && bmain->subversionfile < 15)) {
2453     idproperties_fix_group_lengths(bmain->scenes);
2454     idproperties_fix_group_lengths(bmain->libraries);
2455     idproperties_fix_group_lengths(bmain->objects);
2456     idproperties_fix_group_lengths(bmain->meshes);
2457     idproperties_fix_group_lengths(bmain->curves);
2458     idproperties_fix_group_lengths(bmain->metaballs);
2459     idproperties_fix_group_lengths(bmain->materials);
2460     idproperties_fix_group_lengths(bmain->textures);
2461     idproperties_fix_group_lengths(bmain->images);
2462     idproperties_fix_group_lengths(bmain->lattices);
2463     idproperties_fix_group_lengths(bmain->lights);
2464     idproperties_fix_group_lengths(bmain->cameras);
2465     idproperties_fix_group_lengths(bmain->ipo);
2466     idproperties_fix_group_lengths(bmain->shapekeys);
2467     idproperties_fix_group_lengths(bmain->worlds);
2468     idproperties_fix_group_lengths(bmain->screens);
2469     idproperties_fix_group_lengths(bmain->fonts);
2470     idproperties_fix_group_lengths(bmain->texts);
2471     idproperties_fix_group_lengths(bmain->sounds);
2472     idproperties_fix_group_lengths(bmain->collections);
2473     idproperties_fix_group_lengths(bmain->armatures);
2474     idproperties_fix_group_lengths(bmain->actions);
2475     idproperties_fix_group_lengths(bmain->nodetrees);
2476     idproperties_fix_group_lengths(bmain->brushes);
2477     idproperties_fix_group_lengths(bmain->particles);
2478   }
2479
2480   /* convert fluids to modifier */
2481   if (bmain->versionfile < 246 || (bmain->versionfile == 246 && bmain->subversionfile < 1)) {
2482     Object *ob;
2483
2484     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2485       if (ob->fluidsimSettings) {
2486         FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifier_new(
2487             eModifierType_Fluidsim);
2488         BLI_addhead(&ob->modifiers, (ModifierData *)fluidmd);
2489
2490         MEM_freeN(fluidmd->fss);
2491         fluidmd->fss = MEM_dupallocN(ob->fluidsimSettings);
2492         fluidmd->fss->ipo = blo_do_versions_newlibadr(fd, ob->id.lib, ob->fluidsimSettings->ipo);
2493         MEM_freeN(ob->fluidsimSettings);
2494
2495         fluidmd->fss->lastgoodframe = INT_MAX;
2496         fluidmd->fss->flag = 0;
2497         fluidmd->fss->meshVelocities = NULL;
2498       }
2499     }
2500   }
2501
2502   if (bmain->versionfile < 246 || (bmain->versionfile == 246 && bmain->subversionfile < 1)) {
2503     Object *ob;
2504     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2505       if (ob->pd && (ob->pd->forcefield == PFIELD_WIND)) {
2506         ob->pd->f_noise = 0.0f;
2507       }
2508     }
2509   }
2510
2511   /* set the curve radius interpolation to 2.47 default - easy */
2512   if (bmain->versionfile < 247 || (bmain->versionfile == 247 && bmain->subversionfile < 6)) {
2513     Curve *cu;
2514     Nurb *nu;
2515
2516     for (cu = bmain->curves.first; cu; cu = cu->id.next) {
2517       for (nu = cu->nurb.first; nu; nu = nu->next) {
2518         nu->radius_interp = 3;
2519
2520         /* resolu and resolv are now used differently for surfaces
2521          * rather than using the resolution to define the entire number of divisions,
2522          * use it for the number of divisions per segment
2523          */
2524         if (nu->pntsv > 1) {
2525           nu->resolu = MAX2(1, (int)(((float)nu->resolu / (float)nu->pntsu) + 0.5f));
2526           nu->resolv = MAX2(1, (int)(((float)nu->resolv / (float)nu->pntsv) + 0.5f));
2527         }
2528       }
2529     }
2530   }
2531
2532   if (bmain->versionfile < 248 || (bmain->versionfile == 248 && bmain->subversionfile < 2)) {
2533     Scene *sce;
2534
2535     /* Note, these will need to be added for painting */
2536     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
2537       sce->toolsettings->imapaint.seam_bleed = 2;
2538       sce->toolsettings->imapaint.normal_angle = 80;
2539     }
2540   }
2541
2542   if (bmain->versionfile < 248 || (bmain->versionfile == 248 && bmain->subversionfile < 3)) {
2543     bScreen *screen;
2544
2545     /* adjust default settings for Animation Editors */
2546     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2547       ScrArea *area;
2548
2549       for (area = screen->areabase.first; area; area = area->next) {
2550         SpaceLink *sl;
2551
2552         for (sl = area->spacedata.first; sl; sl = sl->next) {
2553           switch (sl->spacetype) {
2554             case SPACE_ACTION: {
2555               SpaceAction *sact = (SpaceAction *)sl;
2556
2557               sact->mode = SACTCONT_DOPESHEET;
2558               sact->autosnap = SACTSNAP_FRAME;
2559               break;
2560             }
2561             case SPACE_GRAPH: {
2562               SpaceGraph *sipo = (SpaceGraph *)sl;
2563               sipo->autosnap = SACTSNAP_FRAME;
2564               break;
2565             }
2566             case SPACE_NLA: {
2567               SpaceNla *snla = (SpaceNla *)sl;
2568               snla->autosnap = SACTSNAP_FRAME;
2569               break;
2570             }
2571           }
2572         }
2573       }
2574     }
2575   }
2576
2577   /* correct introduce of seed for wind force */
2578   if (bmain->versionfile < 249 && bmain->subversionfile < 1) {
2579     Object *ob;
2580     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2581       if (ob->pd) {
2582         ob->pd->seed = ((uint)(ceil(PIL_check_seconds_timer())) + 1) % 128;
2583       }
2584     }
2585   }
2586
2587   if (bmain->versionfile < 249 && bmain->subversionfile < 2) {
2588     Scene *sce = bmain->scenes.first;
2589     Sequence *seq;
2590     Editing *ed;
2591
2592     while (sce) {
2593       ed = sce->ed;
2594       if (ed) {
2595         SEQP_BEGIN (ed, seq) {
2596           if (seq->strip && seq->strip->proxy) {
2597             seq->strip->proxy->quality = 90;
2598           }
2599         }
2600         SEQ_END;
2601       }
2602
2603       sce = sce->id.next;
2604     }
2605   }
2606 }