17facb3ae20204aea553f15dd082e069e6eac9a2
[blender.git] / source / blender / blenloader / intern / versioning_250.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 #ifndef WIN32
22 #  include <unistd.h> /* for read close */
23 #else
24 #  include <zlib.h> /* odd include order-issue */
25 #  include <io.h>   // for open close read
26 #  include "winsock2.h"
27 #  include "BLI_winstuff.h"
28 #endif
29
30 /* allow readfile to use deprecated functionality */
31 #define DNA_DEPRECATED_ALLOW
32
33 #include "DNA_anim_types.h"
34 #include "DNA_armature_types.h"
35 #include "DNA_brush_types.h"
36 #include "DNA_camera_types.h"
37 #include "DNA_cloth_types.h"
38 #include "DNA_constraint_types.h"
39 #include "DNA_ipo_types.h"
40 #include "DNA_key_types.h"
41 #include "DNA_lattice_types.h"
42 #include "DNA_light_types.h"
43 #include "DNA_material_types.h"
44 #include "DNA_mesh_types.h"
45 #include "DNA_meshdata_types.h"
46 #include "DNA_node_types.h"
47 #include "DNA_object_fluidsim_types.h"
48 #include "DNA_object_types.h"
49 #include "DNA_view3d_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_sdna_types.h"
52 #include "DNA_sequence_types.h"
53 #include "DNA_smoke_types.h"
54 #include "DNA_sound_types.h"
55 #include "DNA_space_types.h"
56 #include "DNA_world_types.h"
57
58 #include "MEM_guardedalloc.h"
59
60 #include "BLI_utildefines.h"
61 #include "BLI_blenlib.h"
62 #include "BLI_math.h"
63
64 #include "BKE_anim.h"
65 #include "BKE_armature.h"
66 #include "BKE_colortools.h"
67 #include "BKE_global.h"  // for G
68 #include "BKE_library.h"
69 #include "BKE_main.h"
70 #include "BKE_mesh.h"  // for ME_ defines (patching)
71 #include "BKE_modifier.h"
72 #include "BKE_multires.h"
73 #include "BKE_particle.h"
74 #include "BKE_pointcache.h"
75 #include "BKE_screen.h"
76 #include "BKE_sequencer.h"
77 #include "BKE_texture.h"
78 #include "BKE_sound.h"
79
80 #include "NOD_socket.h"
81
82 #include "BLO_readfile.h"
83
84 #include "readfile.h"
85
86 #include <errno.h>
87
88 /* 2.50 patch */
89 static void area_add_header_region(ScrArea *sa, ListBase *lb)
90 {
91   ARegion *ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
92
93   BLI_addtail(lb, ar);
94   ar->regiontype = RGN_TYPE_HEADER;
95   if (sa->headertype == 1) {
96     ar->alignment = RGN_ALIGN_BOTTOM;
97   }
98   else {
99     ar->alignment = RGN_ALIGN_TOP;
100   }
101
102   /* initialize view2d data for header region, to allow panning */
103   /* is copy from ui_view2d.c */
104   ar->v2d.keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
105   ar->v2d.keepofs = V2D_LOCKOFS_Y;
106   ar->v2d.keeptot = V2D_KEEPTOT_STRICT;
107   ar->v2d.align = V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y;
108   ar->v2d.flag = (V2D_PIXELOFS_X | V2D_PIXELOFS_Y);
109 }
110
111 static void sequencer_init_preview_region(ARegion *ar)
112 {
113   // XXX a bit ugly still, copied from space_sequencer
114   /* NOTE: if you change values here, also change them in space_sequencer.c, sequencer_new */
115   ar->regiontype = RGN_TYPE_PREVIEW;
116   ar->alignment = RGN_ALIGN_TOP;
117   ar->flag |= RGN_FLAG_HIDDEN;
118   ar->v2d.keepzoom = V2D_KEEPASPECT | V2D_KEEPZOOM;
119   ar->v2d.minzoom = 0.00001f;
120   ar->v2d.maxzoom = 100000.0f;
121   ar->v2d.tot.xmin = -960.0f; /* 1920 width centered */
122   ar->v2d.tot.ymin = -540.0f; /* 1080 height centered */
123   ar->v2d.tot.xmax = 960.0f;
124   ar->v2d.tot.ymax = 540.0f;
125   ar->v2d.min[0] = 0.0f;
126   ar->v2d.min[1] = 0.0f;
127   ar->v2d.max[0] = 12000.0f;
128   ar->v2d.max[1] = 12000.0f;
129   ar->v2d.cur = ar->v2d.tot;
130   ar->v2d.align = V2D_ALIGN_FREE;  // (V2D_ALIGN_NO_NEG_X|V2D_ALIGN_NO_NEG_Y);
131   ar->v2d.keeptot = V2D_KEEPTOT_FREE;
132 }
133
134 static void area_add_window_regions(ScrArea *sa, SpaceLink *sl, ListBase *lb)
135 {
136   ARegion *ar;
137   ARegion *ar_main;
138
139   if (sl) {
140     /* first channels for ipo action nla... */
141     switch (sl->spacetype) {
142       case SPACE_GRAPH:
143         ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
144         BLI_addtail(lb, ar);
145         ar->regiontype = RGN_TYPE_CHANNELS;
146         ar->alignment = RGN_ALIGN_LEFT;
147         ar->v2d.scroll = (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
148
149         /* for some reason, this doesn't seem to go auto like for NLA... */
150         ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
151         BLI_addtail(lb, ar);
152         ar->regiontype = RGN_TYPE_UI;
153         ar->alignment = RGN_ALIGN_RIGHT;
154         ar->v2d.scroll = V2D_SCROLL_RIGHT;
155         ar->v2d.flag = RGN_FLAG_HIDDEN;
156         break;
157
158       case SPACE_ACTION:
159         ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
160         BLI_addtail(lb, ar);
161         ar->regiontype = RGN_TYPE_CHANNELS;
162         ar->alignment = RGN_ALIGN_LEFT;
163         ar->v2d.scroll = V2D_SCROLL_BOTTOM;
164         ar->v2d.flag = V2D_VIEWSYNC_AREA_VERTICAL;
165         break;
166
167       case SPACE_NLA:
168         ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
169         BLI_addtail(lb, ar);
170         ar->regiontype = RGN_TYPE_CHANNELS;
171         ar->alignment = RGN_ALIGN_LEFT;
172         ar->v2d.scroll = V2D_SCROLL_BOTTOM;
173         ar->v2d.flag = V2D_VIEWSYNC_AREA_VERTICAL;
174
175         /* for some reason, some files still don't get this auto */
176         ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
177         BLI_addtail(lb, ar);
178         ar->regiontype = RGN_TYPE_UI;
179         ar->alignment = RGN_ALIGN_RIGHT;
180         ar->v2d.scroll = V2D_SCROLL_RIGHT;
181         ar->v2d.flag = RGN_FLAG_HIDDEN;
182         break;
183
184       case SPACE_NODE:
185         ar = MEM_callocN(sizeof(ARegion), "nodetree area for node");
186         BLI_addtail(lb, ar);
187         ar->regiontype = RGN_TYPE_UI;
188         ar->alignment = RGN_ALIGN_LEFT;
189         ar->v2d.scroll = (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
190         ar->v2d.flag = V2D_VIEWSYNC_AREA_VERTICAL;
191         /* temporarily hide it */
192         ar->flag = RGN_FLAG_HIDDEN;
193         break;
194       case SPACE_FILE:
195         ar = MEM_callocN(sizeof(ARegion), "nodetree area for node");
196         BLI_addtail(lb, ar);
197         ar->regiontype = RGN_TYPE_CHANNELS;
198         ar->alignment = RGN_ALIGN_LEFT;
199
200         ar = MEM_callocN(sizeof(ARegion), "ui area for file");
201         BLI_addtail(lb, ar);
202         ar->regiontype = RGN_TYPE_UI;
203         ar->alignment = RGN_ALIGN_TOP;
204         break;
205       case SPACE_SEQ:
206         ar_main = (ARegion *)lb->first;
207         for (; ar_main; ar_main = ar_main->next) {
208           if (ar_main->regiontype == RGN_TYPE_WINDOW) {
209             break;
210           }
211         }
212         ar = MEM_callocN(sizeof(ARegion), "preview area for sequencer");
213         BLI_insertlinkbefore(lb, ar_main, ar);
214         sequencer_init_preview_region(ar);
215         break;
216       case SPACE_VIEW3D:
217         /* toolbar */
218         ar = MEM_callocN(sizeof(ARegion), "toolbar for view3d");
219
220         BLI_addtail(lb, ar);
221         ar->regiontype = RGN_TYPE_TOOLS;
222         ar->alignment = RGN_ALIGN_LEFT;
223         ar->flag = RGN_FLAG_HIDDEN;
224
225         /* tool properties */
226         ar = MEM_callocN(sizeof(ARegion), "tool properties for view3d");
227
228         BLI_addtail(lb, ar);
229         ar->regiontype = RGN_TYPE_TOOL_PROPS;
230         ar->alignment = RGN_ALIGN_BOTTOM | RGN_SPLIT_PREV;
231         ar->flag = RGN_FLAG_HIDDEN;
232
233         /* buttons/list view */
234         ar = MEM_callocN(sizeof(ARegion), "buttons for view3d");
235
236         BLI_addtail(lb, ar);
237         ar->regiontype = RGN_TYPE_UI;
238         ar->alignment = RGN_ALIGN_RIGHT;
239         ar->flag = RGN_FLAG_HIDDEN;
240 #if 0
241       case SPACE_PROPERTIES:
242         /* context UI region */
243         ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
244         BLI_addtail(lb, ar);
245         ar->regiontype = RGN_TYPE_UI;
246         ar->alignment = RGN_ALIGN_RIGHT;
247
248         break;
249 #endif
250     }
251   }
252
253   /* main region */
254   ar = MEM_callocN(sizeof(ARegion), "area region from do_versions");
255
256   BLI_addtail(lb, ar);
257   ar->winrct = sa->totrct;
258
259   ar->regiontype = RGN_TYPE_WINDOW;
260
261   if (sl) {
262     /* if active spacetype has view2d data, copy that over to main region */
263     /* and we split view3d */
264     switch (sl->spacetype) {
265       case SPACE_VIEW3D:
266         blo_do_versions_view3d_split_250((View3D *)sl, lb);
267         break;
268
269       case SPACE_OUTLINER: {
270         SpaceOutliner *soops = (SpaceOutliner *)sl;
271
272         memcpy(&ar->v2d, &soops->v2d, sizeof(View2D));
273
274         ar->v2d.scroll &= ~V2D_SCROLL_LEFT;
275         ar->v2d.scroll |= (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
276         ar->v2d.align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
277         ar->v2d.keepzoom |= (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_KEEPASPECT);
278         ar->v2d.keeptot = V2D_KEEPTOT_STRICT;
279         ar->v2d.minzoom = ar->v2d.maxzoom = 1.0f;
280         // ar->v2d.flag |= V2D_IS_INITIALISED;
281         break;
282       }
283       case SPACE_GRAPH: {
284         SpaceGraph *sipo = (SpaceGraph *)sl;
285         memcpy(&ar->v2d, &sipo->v2d, sizeof(View2D));
286
287         /* init mainarea view2d */
288         ar->v2d.scroll |= (V2D_SCROLL_BOTTOM | V2D_SCROLL_HORIZONTAL_HANDLES);
289         ar->v2d.scroll |= (V2D_SCROLL_LEFT | V2D_SCROLL_VERTICAL_HANDLES);
290
291         ar->v2d.min[0] = FLT_MIN;
292         ar->v2d.min[1] = FLT_MIN;
293
294         ar->v2d.max[0] = MAXFRAMEF;
295         ar->v2d.max[1] = FLT_MAX;
296
297         // ar->v2d.flag |= V2D_IS_INITIALISED;
298         break;
299       }
300       case SPACE_NLA: {
301         SpaceNla *snla = (SpaceNla *)sl;
302         memcpy(&ar->v2d, &snla->v2d, sizeof(View2D));
303
304         ar->v2d.tot.ymin = (float)(-sa->winy) / 3.0f;
305         ar->v2d.tot.ymax = 0.0f;
306
307         ar->v2d.scroll |= (V2D_SCROLL_BOTTOM | V2D_SCROLL_HORIZONTAL_HANDLES);
308         ar->v2d.scroll |= (V2D_SCROLL_RIGHT);
309         ar->v2d.align = V2D_ALIGN_NO_POS_Y;
310         ar->v2d.flag |= V2D_VIEWSYNC_AREA_VERTICAL;
311         break;
312       }
313       case SPACE_ACTION: {
314         SpaceAction *saction = (SpaceAction *)sl;
315
316         /* We totally reinit the view for the Action Editor,
317          * as some old instances had some weird cruft set. */
318         ar->v2d.tot.xmin = -20.0f;
319         ar->v2d.tot.ymin = (float)(-sa->winy) / 3.0f;
320         ar->v2d.tot.xmax = (float)((sa->winx > 120) ? (sa->winx) : 120);
321         ar->v2d.tot.ymax = 0.0f;
322
323         ar->v2d.cur = ar->v2d.tot;
324
325         ar->v2d.min[0] = 0.0f;
326         ar->v2d.min[1] = 0.0f;
327
328         ar->v2d.max[0] = MAXFRAMEF;
329         ar->v2d.max[1] = FLT_MAX;
330
331         ar->v2d.minzoom = 0.01f;
332         ar->v2d.maxzoom = 50;
333         ar->v2d.scroll = (V2D_SCROLL_BOTTOM | V2D_SCROLL_HORIZONTAL_HANDLES);
334         ar->v2d.scroll |= (V2D_SCROLL_RIGHT);
335         ar->v2d.keepzoom = V2D_LOCKZOOM_Y;
336         ar->v2d.align = V2D_ALIGN_NO_POS_Y;
337         ar->v2d.flag = V2D_VIEWSYNC_AREA_VERTICAL;
338
339         /* for old files with ShapeKey editors open + an action set, clear the action as
340          * it doesn't make sense in the new system (i.e. violates concept that ShapeKey edit
341          * only shows ShapeKey-rooted actions only)
342          */
343         if (saction->mode == SACTCONT_SHAPEKEY) {
344           saction->action = NULL;
345         }
346         break;
347       }
348       case SPACE_SEQ: {
349         SpaceSeq *sseq = (SpaceSeq *)sl;
350         memcpy(&ar->v2d, &sseq->v2d, sizeof(View2D));
351
352         ar->v2d.scroll |= (V2D_SCROLL_BOTTOM | V2D_SCROLL_HORIZONTAL_HANDLES);
353         ar->v2d.scroll |= (V2D_SCROLL_LEFT | V2D_SCROLL_VERTICAL_HANDLES);
354         ar->v2d.align = V2D_ALIGN_NO_NEG_Y;
355         ar->v2d.flag |= V2D_IS_INITIALISED;
356         break;
357       }
358       case SPACE_NODE: {
359         SpaceNode *snode = (SpaceNode *)sl;
360         memcpy(&ar->v2d, &snode->v2d, sizeof(View2D));
361
362         ar->v2d.scroll = (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
363         ar->v2d.keepzoom = V2D_LIMITZOOM | V2D_KEEPASPECT;
364         break;
365       }
366       case SPACE_PROPERTIES: {
367         SpaceProperties *sbuts = (SpaceProperties *)sl;
368         memcpy(&ar->v2d, &sbuts->v2d, sizeof(View2D));
369
370         ar->v2d.scroll |= (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
371         break;
372       }
373       case SPACE_FILE: {
374         // SpaceFile *sfile = (SpaceFile *)sl;
375         ar->v2d.tot.xmin = ar->v2d.tot.ymin = 0;
376         ar->v2d.tot.xmax = ar->winx;
377         ar->v2d.tot.ymax = ar->winy;
378         ar->v2d.cur = ar->v2d.tot;
379         ar->regiontype = RGN_TYPE_WINDOW;
380         ar->v2d.scroll = (V2D_SCROLL_RIGHT | V2D_SCROLL_BOTTOM);
381         ar->v2d.align = (V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_POS_Y);
382         ar->v2d.keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM | V2D_KEEPASPECT);
383         break;
384       }
385       case SPACE_TEXT: {
386         SpaceText *st = (SpaceText *)sl;
387         st->flags |= ST_FIND_WRAP;
388       }
389         // case SPACE_XXX: // FIXME... add other ones
390         //  memcpy(&ar->v2d, &((SpaceXxx *)sl)->v2d, sizeof(View2D));
391         //  break;
392     }
393   }
394 }
395
396 static void do_versions_windowmanager_2_50(bScreen *screen)
397 {
398   ScrArea *sa;
399   SpaceLink *sl;
400
401   /* add regions */
402   for (sa = screen->areabase.first; sa; sa = sa->next) {
403     /* we keep headertype variable to convert old files only */
404     if (sa->headertype) {
405       area_add_header_region(sa, &sa->regionbase);
406     }
407
408     area_add_window_regions(sa, sa->spacedata.first, &sa->regionbase);
409
410     /* space imageselect is deprecated */
411     for (sl = sa->spacedata.first; sl; sl = sl->next) {
412       if (sl->spacetype == SPACE_IMASEL) {
413         sl->spacetype = SPACE_EMPTY; /* spacedata then matches */
414       }
415     }
416
417     /* space sound is deprecated */
418     for (sl = sa->spacedata.first; sl; sl = sl->next) {
419       if (sl->spacetype == SPACE_SOUND) {
420         sl->spacetype = SPACE_EMPTY; /* spacedata then matches */
421       }
422     }
423
424     /* pushed back spaces also need regions! */
425     if (sa->spacedata.first) {
426       sl = sa->spacedata.first;
427       for (sl = sl->next; sl; sl = sl->next) {
428         if (sa->headertype) {
429           area_add_header_region(sa, &sl->regionbase);
430         }
431         area_add_window_regions(sa, sl, &sl->regionbase);
432       }
433     }
434   }
435 }
436
437 static void versions_gpencil_add_main(ListBase *lb, ID *id, const char *name)
438 {
439   BLI_addtail(lb, id);
440   id->us = 1;
441   id->flag = LIB_FAKEUSER;
442   *((short *)id->name) = ID_GD;
443
444   BKE_id_new_name_validate(lb, id, name);
445   /* alphabetic insertion: is in BKE_id_new_name_validate */
446
447   if (G.debug & G_DEBUG) {
448     printf("Converted GPencil to ID: %s\n", id->name + 2);
449   }
450 }
451
452 static void do_versions_gpencil_2_50(Main *main, bScreen *screen)
453 {
454   ScrArea *sa;
455   SpaceLink *sl;
456
457   /* add regions */
458   for (sa = screen->areabase.first; sa; sa = sa->next) {
459     for (sl = sa->spacedata.first; sl; sl = sl->next) {
460       if (sl->spacetype == SPACE_VIEW3D) {
461         View3D *v3d = (View3D *)sl;
462         if (v3d->gpd) {
463           versions_gpencil_add_main(&main->gpencils, (ID *)v3d->gpd, "GPencil View3D");
464           v3d->gpd = NULL;
465         }
466       }
467       else if (sl->spacetype == SPACE_NODE) {
468         SpaceNode *snode = (SpaceNode *)sl;
469         if (snode->gpd) {
470           versions_gpencil_add_main(&main->gpencils, (ID *)snode->gpd, "GPencil Node");
471           snode->gpd = NULL;
472         }
473       }
474       else if (sl->spacetype == SPACE_SEQ) {
475         SpaceSeq *sseq = (SpaceSeq *)sl;
476         if (sseq->gpd) {
477           versions_gpencil_add_main(&main->gpencils, (ID *)sseq->gpd, "GPencil Node");
478           sseq->gpd = NULL;
479         }
480       }
481       else if (sl->spacetype == SPACE_IMAGE) {
482         SpaceImage *sima = (SpaceImage *)sl;
483 #if 0 /* see comment on r28002 */
484         if (sima->gpd) {
485           versions_gpencil_add_main(&main->gpencil, (ID *)sima->gpd, "GPencil Image");
486           sima->gpd = NULL;
487         }
488 #else
489         sima->gpd = NULL;
490 #endif
491       }
492     }
493   }
494 }
495
496 static void do_version_mdef_250(Main *main)
497 {
498   Object *ob;
499   ModifierData *md;
500   MeshDeformModifierData *mmd;
501
502   for (ob = main->objects.first; ob; ob = ob->id.next) {
503     for (md = ob->modifiers.first; md; md = md->next) {
504       if (md->type == eModifierType_MeshDeform) {
505         mmd = (MeshDeformModifierData *)md;
506
507         if (mmd->bindcos) {
508           /* make bindcos NULL in order to trick older versions
509            * into thinking that the mesh was not bound yet */
510           mmd->bindcagecos = mmd->bindcos;
511           mmd->bindcos = NULL;
512
513           modifier_mdef_compact_influences(md);
514         }
515       }
516     }
517   }
518 }
519
520 static void do_version_constraints_radians_degrees_250(ListBase *lb)
521 {
522   bConstraint *con;
523
524   for (con = lb->first; con; con = con->next) {
525     if (con->type == CONSTRAINT_TYPE_KINEMATIC) {
526       bKinematicConstraint *data = con->data;
527       data->poleangle *= (float)(M_PI / 180.0);
528     }
529     else if (con->type == CONSTRAINT_TYPE_ROTLIMIT) {
530       bRotLimitConstraint *data = con->data;
531
532       data->xmin *= (float)(M_PI / 180.0);
533       data->xmax *= (float)(M_PI / 180.0);
534       data->ymin *= (float)(M_PI / 180.0);
535       data->ymax *= (float)(M_PI / 180.0);
536       data->zmin *= (float)(M_PI / 180.0);
537       data->zmax *= (float)(M_PI / 180.0);
538     }
539   }
540 }
541
542 static void do_version_bone_roll_256(Bone *bone)
543 {
544   Bone *child;
545   float submat[3][3];
546
547   copy_m3_m4(submat, bone->arm_mat);
548   mat3_to_vec_roll(submat, NULL, &bone->arm_roll);
549
550   for (child = bone->childbase.first; child; child = child->next) {
551     do_version_bone_roll_256(child);
552   }
553 }
554
555 /* deprecated, only keep this for readfile.c */
556 /* XXX Deprecated function to add a socket in ntree->inputs/ntree->outputs list
557  * (previously called node_group_add_socket). This function has been superseded
558  * by the implementation of proxy nodes. It is still necessary though
559  * for do_versions of pre-2.56.2 code (r35033), so later proxy nodes
560  * can be generated consistently from ntree socket lists.
561  */
562 static bNodeSocket *do_versions_node_group_add_socket_2_56_2(bNodeTree *ngroup,
563                                                              const char *name,
564                                                              int type,
565                                                              int in_out)
566 {
567   //  bNodeSocketType *stype = ntreeGetSocketType(type);
568   bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket");
569
570   BLI_strncpy(gsock->name, name, sizeof(gsock->name));
571   gsock->type = type;
572
573   gsock->next = gsock->prev = NULL;
574   gsock->new_sock = NULL;
575   gsock->link = NULL;
576   /* assign new unique index */
577   gsock->own_index = ngroup->cur_index++;
578   gsock->limit = (in_out == SOCK_IN ? 0xFFF : 1);
579
580   //  if (stype->value_structsize > 0)
581   //      gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value");
582
583   BLI_addtail(in_out == SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock);
584
585   ngroup->update |= (in_out == SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT);
586
587   return gsock;
588 }
589
590 /* Create default_value structs for node sockets from the internal bNodeStack value.
591  * These structs were used from 2.59.2 on, but are replaced in the subsequent do_versions for
592  * custom nodes by generic ID property values. This conversion happened _after_ do_versions
593  * originally due to messy type initialization for node sockets.
594  * Now created here intermediately for convenience and to keep do_versions consistent.
595  *
596  * Node compatibility code is gross ...
597  */
598 static void do_versions_socket_default_value_259(bNodeSocket *sock)
599 {
600   bNodeSocketValueFloat *valfloat;
601   bNodeSocketValueVector *valvector;
602   bNodeSocketValueRGBA *valrgba;
603
604   if (sock->default_value) {
605     return;
606   }
607
608   switch (sock->type) {
609     case SOCK_FLOAT:
610       valfloat = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueFloat),
611                                                    "default socket value");
612       valfloat->value = sock->ns.vec[0];
613       valfloat->min = sock->ns.min;
614       valfloat->max = sock->ns.max;
615       valfloat->subtype = PROP_NONE;
616       break;
617     case SOCK_VECTOR:
618       valvector = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueVector),
619                                                     "default socket value");
620       copy_v3_v3(valvector->value, sock->ns.vec);
621       valvector->min = sock->ns.min;
622       valvector->max = sock->ns.max;
623       valvector->subtype = PROP_NONE;
624       break;
625     case SOCK_RGBA:
626       valrgba = sock->default_value = MEM_callocN(sizeof(bNodeSocketValueRGBA),
627                                                   "default socket value");
628       copy_v4_v4(valrgba->value, sock->ns.vec);
629       break;
630   }
631 }
632
633 void blo_do_versions_250(FileData *fd, Library *lib, Main *bmain)
634 {
635   /* WATCH IT!!!: pointers from libdata have not been converted */
636
637   if (bmain->versionfile < 250) {
638     bScreen *screen;
639     Scene *scene;
640     Base *base;
641     Material *ma;
642     Camera *cam;
643     Curve *cu;
644     Scene *sce;
645     Tex *tx;
646     ParticleSettings *part;
647     Object *ob;
648     // PTCacheID *pid;
649     // ListBase pidlist;
650
651     bSound *sound;
652     Sequence *seq;
653
654     for (sound = bmain->sounds.first; sound; sound = sound->id.next) {
655       if (sound->newpackedfile) {
656         sound->packedfile = sound->newpackedfile;
657         sound->newpackedfile = NULL;
658       }
659     }
660
661     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
662       if (scene->ed && scene->ed->seqbasep) {
663         SEQ_BEGIN (scene->ed, seq) {
664           if (seq->type == SEQ_TYPE_SOUND_HD) {
665             char str[FILE_MAX];
666             BLI_join_dirfile(str, sizeof(str), seq->strip->dir, seq->strip->stripdata->name);
667             BLI_path_abs(str, BKE_main_blendfile_path(bmain));
668             seq->sound = BKE_sound_new_file(bmain, str);
669           }
670 #define SEQ_USE_PROXY_CUSTOM_DIR (1 << 19)
671 #define SEQ_USE_PROXY_CUSTOM_FILE (1 << 21)
672           /* don't know, if anybody used that this way, but just in case, upgrade to new way... */
673           if ((seq->flag & SEQ_USE_PROXY_CUSTOM_FILE) && !(seq->flag & SEQ_USE_PROXY_CUSTOM_DIR)) {
674             BLI_snprintf(seq->strip->proxy->dir, FILE_MAXDIR, "%s/BL_proxy", seq->strip->dir);
675           }
676 #undef SEQ_USE_PROXY_CUSTOM_DIR
677 #undef SEQ_USE_PROXY_CUSTOM_FILE
678         }
679         SEQ_END;
680       }
681     }
682
683     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
684       do_versions_windowmanager_2_50(screen);
685       do_versions_gpencil_2_50(bmain, screen);
686     }
687
688     /* shader, composite and texture node trees have id.name empty, put something in
689      * to have them show in RNA viewer and accessible otherwise.
690      */
691     for (ma = bmain->materials.first; ma; ma = ma->id.next) {
692       if (ma->nodetree && ma->nodetree->id.name[0] == '\0') {
693         strcpy(ma->nodetree->id.name, "NTShader Nodetree");
694       }
695     }
696
697     /* and composite trees */
698     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
699       enum { R_PANORAMA = (1 << 10) };
700       if (sce->nodetree && sce->nodetree->id.name[0] == '\0') {
701         strcpy(sce->nodetree->id.name, "NTCompositing Nodetree");
702       }
703
704       /* move to cameras */
705       if (sce->r.mode & R_PANORAMA) {
706         for (base = sce->base.first; base; base = base->next) {
707           ob = blo_do_versions_newlibadr(fd, lib, base->object);
708
709           if (ob->type == OB_CAMERA && !ob->id.lib) {
710             cam = blo_do_versions_newlibadr(fd, lib, ob->data);
711             cam->flag |= CAM_PANORAMA;
712           }
713         }
714
715         sce->r.mode &= ~R_PANORAMA;
716       }
717     }
718
719     /* and texture trees */
720     for (tx = bmain->textures.first; tx; tx = tx->id.next) {
721       bNode *node;
722
723       if (tx->nodetree) {
724         if (tx->nodetree->id.name[0] == '\0') {
725           strcpy(tx->nodetree->id.name, "NTTexture Nodetree");
726         }
727
728         /* which_output 0 is now "not specified" */
729         for (node = tx->nodetree->nodes.first; node; node = node->next) {
730           if (node->type == TEX_NODE_OUTPUT) {
731             node->custom1++;
732           }
733         }
734       }
735     }
736
737     /* particle draw and render types */
738     for (part = bmain->particles.first; part; part = part->id.next) {
739       if (part->draw_as) {
740         if (part->draw_as == PART_DRAW_DOT) {
741           part->ren_as = PART_DRAW_HALO;
742           part->draw_as = PART_DRAW_REND;
743         }
744         else if (part->draw_as <= PART_DRAW_AXIS) {
745           part->ren_as = PART_DRAW_HALO;
746         }
747         else {
748           part->ren_as = part->draw_as;
749           part->draw_as = PART_DRAW_REND;
750         }
751       }
752       part->path_end = 1.0f;
753       part->clength = 1.0f;
754     }
755
756     /* set old pointcaches to have disk cache flag */
757     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
758
759       // BKE_ptcache_ids_from_object(&pidlist, ob);
760
761       // for (pid = pidlist.first; pid; pid = pid->next)
762       //  pid->cache->flag |= PTCACHE_DISK_CACHE;
763
764       // BLI_freelistN(&pidlist);
765     }
766
767     /* type was a mixed flag & enum. move the 2d flag elsewhere */
768     for (cu = bmain->curves.first; cu; cu = cu->id.next) {
769       Nurb *nu;
770
771       for (nu = cu->nurb.first; nu; nu = nu->next) {
772         nu->flag |= (nu->type & CU_2D);
773         nu->type &= CU_TYPE;
774       }
775     }
776   }
777
778   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 1)) {
779     Object *ob;
780     Tex *tex;
781     Scene *sce;
782     ToolSettings *ts;
783     // PTCacheID *pid;
784     // ListBase pidlist;
785
786     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
787       // BKE_ptcache_ids_from_object(&pidlist, ob);
788
789       // for (pid = pidlist.first; pid; pid = pid->next) {
790       //  if (BLI_listbase_is_empty(pid->ptcaches))
791       //      pid->ptcaches->first = pid->ptcaches->last = pid->cache;
792       //}
793
794       // BLI_freelistN(&pidlist);
795
796       if (ob->type == OB_MESH) {
797         Mesh *me = blo_do_versions_newlibadr(fd, lib, ob->data);
798         void *olddata = ob->data;
799         ob->data = me;
800
801         /* XXX - library meshes crash on loading most yoFrankie levels,
802          * the multires pointer gets invalid -  Campbell */
803         if (me && me->id.lib == NULL && me->mr && me->mr->level_count > 1) {
804           multires_load_old(ob, me);
805         }
806
807         ob->data = olddata;
808       }
809
810       if (ob->totcol && ob->matbits == NULL) {
811         int a;
812
813         ob->matbits = MEM_calloc_arrayN(ob->totcol, sizeof(char), "ob->matbits");
814         for (a = 0; a < ob->totcol; a++) {
815           ob->matbits[a] = (ob->colbits & (1 << a)) != 0;
816         }
817       }
818     }
819
820     /* texture filter */
821     for (tex = bmain->textures.first; tex; tex = tex->id.next) {
822       if (tex->afmax == 0) {
823         tex->afmax = 8;
824       }
825     }
826
827     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
828       ts = sce->toolsettings;
829       if (!ts->uv_selectmode || ts->vgroup_weight == 0.0f) {
830         ts->selectmode = SCE_SELECT_VERTEX;
831
832         /* autokeying - setting should be taken from the user-prefs
833          * but the userprefs version may not have correct flags set
834          * (i.e. will result in blank box when enabled)
835          */
836         ts->autokey_mode = U.autokey_mode;
837         if (ts->autokey_mode == 0) {
838           ts->autokey_mode = 2; /* 'add/replace' but not on */
839         }
840         ts->uv_selectmode = UV_SELECT_VERTEX;
841         ts->vgroup_weight = 1.0f;
842       }
843     }
844   }
845
846   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 2)) {
847     Object *ob;
848
849     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
850       if (ob->flag & 8192) {  // OB_POSEMODE = 8192
851         ob->mode |= OB_MODE_POSE;
852       }
853     }
854   }
855
856   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 4)) {
857     Scene *sce;
858     Object *ob;
859     ParticleSettings *part;
860     bool do_gravity = false;
861
862     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
863       if (sce->unit.scale_length == 0.0f) {
864         sce->unit.scale_length = 1.0f;
865       }
866     }
867
868     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
869       /* fluid-sim stuff */
870       FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType(
871           ob, eModifierType_Fluidsim);
872       if (fluidmd) {
873         fluidmd->fss->fmd = fluidmd;
874       }
875
876       /* rotation modes were added,
877        * but old objects would now default to being 'quaternion based' */
878       ob->rotmode = ROT_MODE_EUL;
879     }
880
881     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
882       if (sce->audio.main == 0.0f) {
883         sce->audio.main = 1.0f;
884       }
885
886       sce->r.ffcodecdata.audio_mixrate = sce->audio.mixrate;
887       sce->r.ffcodecdata.audio_volume = sce->audio.main;
888       sce->audio.distance_model = 2;
889       sce->audio.doppler_factor = 1.0f;
890       sce->audio.speed_of_sound = 343.3f;
891     }
892
893     /* Add default gravity to scenes */
894     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
895       if ((sce->physics_settings.flag & PHYS_GLOBAL_GRAVITY) == 0 &&
896           is_zero_v3(sce->physics_settings.gravity)) {
897         sce->physics_settings.gravity[0] = sce->physics_settings.gravity[1] = 0.0f;
898         sce->physics_settings.gravity[2] = -9.81f;
899         sce->physics_settings.flag = PHYS_GLOBAL_GRAVITY;
900         do_gravity = true;
901       }
902     }
903
904     /* Assign proper global gravity weights for dynamics
905      * (only z-coordinate is taken into account) */
906     if (do_gravity) {
907       for (part = bmain->particles.first; part; part = part->id.next) {
908         part->effector_weights->global_gravity = part->acc[2] / -9.81f;
909       }
910     }
911
912     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
913       ModifierData *md;
914
915       if (do_gravity) {
916         for (md = ob->modifiers.first; md; md = md->next) {
917           ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob,
918                                                                               eModifierType_Cloth);
919           if (clmd) {
920             clmd->sim_parms->effector_weights->global_gravity = clmd->sim_parms->gravity[2] /
921                                                                 -9.81f;
922           }
923         }
924
925         if (ob->soft) {
926           ob->soft->effector_weights->global_gravity = ob->soft->grav / 9.81f;
927         }
928       }
929
930       /* Normal wind shape is plane */
931       if (ob->pd) {
932         if (ob->pd->forcefield == PFIELD_WIND) {
933           ob->pd->shape = PFIELD_SHAPE_PLANE;
934         }
935
936         if (ob->pd->flag & PFIELD_PLANAR) {
937           ob->pd->shape = PFIELD_SHAPE_PLANE;
938         }
939         else if (ob->pd->flag & PFIELD_SURFACE) {
940           ob->pd->shape = PFIELD_SHAPE_SURFACE;
941         }
942
943         ob->pd->flag |= PFIELD_DO_LOCATION;
944       }
945     }
946   }
947
948   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 6)) {
949     Object *ob;
950
951     /* New variables for axis-angle rotations and/or quaternion rotations were added,
952      * and need proper initialization */
953     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
954       /* new variables for all objects */
955       ob->quat[0] = 1.0f;
956       ob->rotAxis[1] = 1.0f;
957
958       /* bones */
959       if (ob->pose) {
960         bPoseChannel *pchan;
961
962         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
963           /* just need to initalise rotation axis properly... */
964           pchan->rotAxis[1] = 1.0f;
965         }
966       }
967     }
968   }
969
970   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 7)) {
971     Mesh *me;
972     Nurb *nu;
973     Lattice *lt;
974     Curve *cu;
975     Key *key;
976     const float *data;
977     int a, tot;
978
979     /* shape keys are no longer applied to the mesh itself, but rather
980      * to the derivedmesh/displist, so here we ensure that the basis
981      * shape key is always set in the mesh coordinates. */
982     for (me = bmain->meshes.first; me; me = me->id.next) {
983       if ((key = blo_do_versions_newlibadr(fd, lib, me->key)) && key->refkey) {
984         data = key->refkey->data;
985         tot = MIN2(me->totvert, key->refkey->totelem);
986
987         for (a = 0; a < tot; a++, data += 3) {
988           copy_v3_v3(me->mvert[a].co, data);
989         }
990       }
991     }
992
993     for (lt = bmain->lattices.first; lt; lt = lt->id.next) {
994       if ((key = blo_do_versions_newlibadr(fd, lib, lt->key)) && key->refkey) {
995         data = key->refkey->data;
996         tot = MIN2(lt->pntsu * lt->pntsv * lt->pntsw, key->refkey->totelem);
997
998         for (a = 0; a < tot; a++, data += 3) {
999           copy_v3_v3(lt->def[a].vec, data);
1000         }
1001       }
1002     }
1003
1004     for (cu = bmain->curves.first; cu; cu = cu->id.next) {
1005       if ((key = blo_do_versions_newlibadr(fd, lib, cu->key)) && key->refkey) {
1006         data = key->refkey->data;
1007
1008         for (nu = cu->nurb.first; nu; nu = nu->next) {
1009           if (nu->bezt) {
1010             BezTriple *bezt = nu->bezt;
1011
1012             for (a = 0; a < nu->pntsu; a++, bezt++) {
1013               copy_v3_v3(bezt->vec[0], data);
1014               data += 3;
1015               copy_v3_v3(bezt->vec[1], data);
1016               data += 3;
1017               copy_v3_v3(bezt->vec[2], data);
1018               data += 3;
1019               bezt->tilt = *data;
1020               data++;
1021             }
1022           }
1023           else if (nu->bp) {
1024             BPoint *bp = nu->bp;
1025
1026             for (a = 0; a < nu->pntsu * nu->pntsv; a++, bp++) {
1027               copy_v3_v3(bp->vec, data);
1028               data += 3;
1029               bp->tilt = *data;
1030               data++;
1031             }
1032           }
1033         }
1034       }
1035     }
1036   }
1037
1038   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 8)) {
1039     {
1040       Scene *sce = bmain->scenes.first;
1041       while (sce) {
1042         if (sce->r.frame_step == 0) {
1043           sce->r.frame_step = 1;
1044         }
1045
1046         sce = sce->id.next;
1047       }
1048     }
1049
1050     {
1051       /* ensure all nodes have unique names */
1052       bNodeTree *ntree = bmain->nodetrees.first;
1053       while (ntree) {
1054         bNode *node = ntree->nodes.first;
1055
1056         while (node) {
1057           nodeUniqueName(ntree, node);
1058           node = node->next;
1059         }
1060
1061         ntree = ntree->id.next;
1062       }
1063     }
1064
1065     {
1066       Object *ob = bmain->objects.first;
1067       while (ob) {
1068         /* shaded mode disabled for now */
1069         if (ob->dt == OB_MATERIAL) {
1070           ob->dt = OB_TEXTURE;
1071         }
1072         ob = ob->id.next;
1073       }
1074     }
1075
1076     {
1077       bScreen *screen;
1078       ScrArea *sa;
1079       SpaceLink *sl;
1080
1081       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1082         for (sa = screen->areabase.first; sa; sa = sa->next) {
1083           for (sl = sa->spacedata.first; sl; sl = sl->next) {
1084             if (sl->spacetype == SPACE_VIEW3D) {
1085               View3D *v3d = (View3D *)sl;
1086               if (v3d->drawtype == OB_MATERIAL) {
1087                 v3d->drawtype = OB_SOLID;
1088               }
1089             }
1090           }
1091         }
1092       }
1093     }
1094
1095     /* only convert old 2.50 files with color management */
1096     if (bmain->versionfile == 250) {
1097       Scene *sce = bmain->scenes.first;
1098       Material *ma = bmain->materials.first;
1099       Tex *tex = bmain->textures.first;
1100       int i, convert = 0;
1101
1102       /* convert to new color management system:
1103        * while previously colors were stored as srgb,
1104        * now they are stored as linear internally,
1105        * with screen gamma correction in certain places in the UI. */
1106
1107       /* don't know what scene is active, so we'll convert if any scene has it enabled... */
1108       while (sce) {
1109         if (sce->r.color_mgt_flag & R_COLOR_MANAGEMENT) {
1110           convert = 1;
1111         }
1112         sce = sce->id.next;
1113       }
1114
1115       if (convert) {
1116         while (ma) {
1117           srgb_to_linearrgb_v3_v3(&ma->r, &ma->r);
1118           srgb_to_linearrgb_v3_v3(&ma->specr, &ma->specr);
1119           ma = ma->id.next;
1120         }
1121
1122         while (tex) {
1123           if (tex->coba) {
1124             ColorBand *band = (ColorBand *)tex->coba;
1125             for (i = 0; i < band->tot; i++) {
1126               CBData *data = band->data + i;
1127               srgb_to_linearrgb_v3_v3(&data->r, &data->r);
1128             }
1129           }
1130           tex = tex->id.next;
1131         }
1132       }
1133     }
1134   }
1135
1136   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 9)) {
1137     Scene *sce;
1138     Mesh *me;
1139     Object *ob;
1140
1141     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1142       if (!sce->toolsettings->particle.selectmode) {
1143         sce->toolsettings->particle.selectmode = SCE_SELECT_PATH;
1144       }
1145     }
1146
1147     if (bmain->versionfile == 250 && bmain->subversionfile > 1) {
1148       for (me = bmain->meshes.first; me; me = me->id.next) {
1149         multires_load_old_250(me);
1150       }
1151
1152       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1153         MultiresModifierData *mmd = (MultiresModifierData *)modifiers_findByType(
1154             ob, eModifierType_Multires);
1155
1156         if (mmd) {
1157           mmd->totlvl--;
1158           mmd->lvl--;
1159           mmd->sculptlvl = mmd->lvl;
1160           mmd->renderlvl = mmd->lvl;
1161         }
1162       }
1163     }
1164   }
1165
1166   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 10)) {
1167     Object *ob;
1168
1169     /* properly initialize hair clothsim data on old files */
1170     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1171       ModifierData *md;
1172       for (md = ob->modifiers.first; md; md = md->next) {
1173         if (md->type == eModifierType_Cloth) {
1174           ClothModifierData *clmd = (ClothModifierData *)md;
1175           if (clmd->sim_parms->velocity_smooth < 0.01f) {
1176             clmd->sim_parms->velocity_smooth = 0.f;
1177           }
1178         }
1179       }
1180     }
1181   }
1182
1183   /* fix bad area setup in subversion 10 */
1184   if (bmain->versionfile == 250 && bmain->subversionfile == 10) {
1185     /* fix for new view type in sequencer */
1186     bScreen *screen;
1187     ScrArea *sa;
1188     SpaceLink *sl;
1189
1190     /* remove all preview window in wrong spaces */
1191     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1192       for (sa = screen->areabase.first; sa; sa = sa->next) {
1193         for (sl = sa->spacedata.first; sl; sl = sl->next) {
1194           if (sl->spacetype != SPACE_SEQ) {
1195             ARegion *ar;
1196             ListBase *regionbase;
1197
1198             if (sl == sa->spacedata.first) {
1199               regionbase = &sa->regionbase;
1200             }
1201             else {
1202               regionbase = &sl->regionbase;
1203             }
1204
1205             for (ar = regionbase->first; ar; ar = ar->next) {
1206               if (ar->regiontype == RGN_TYPE_PREVIEW) {
1207                 break;
1208               }
1209             }
1210
1211             if (ar && (ar->regiontype == RGN_TYPE_PREVIEW)) {
1212               SpaceType *st = BKE_spacetype_from_id(SPACE_SEQ);
1213               BKE_area_region_free(st, ar);
1214               BLI_freelinkN(regionbase, ar);
1215             }
1216           }
1217         }
1218       }
1219     }
1220   }
1221
1222   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 11)) {
1223     {
1224       /* fix for new view type in sequencer */
1225       bScreen *screen;
1226       ScrArea *sa;
1227       SpaceLink *sl;
1228
1229       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1230         for (sa = screen->areabase.first; sa; sa = sa->next) {
1231           for (sl = sa->spacedata.first; sl; sl = sl->next) {
1232             if (sl->spacetype == SPACE_SEQ) {
1233               ARegion *ar;
1234               ARegion *ar_main;
1235               ListBase *regionbase;
1236               SpaceSeq *sseq = (SpaceSeq *)sl;
1237
1238               if (sl == sa->spacedata.first) {
1239                 regionbase = &sa->regionbase;
1240               }
1241               else {
1242                 regionbase = &sl->regionbase;
1243               }
1244
1245               if (sseq->view == 0) {
1246                 sseq->view = SEQ_VIEW_SEQUENCE;
1247               }
1248               if (sseq->mainb == 0) {
1249                 sseq->mainb = SEQ_DRAW_IMG_IMBUF;
1250               }
1251
1252               ar_main = (ARegion *)regionbase->first;
1253               for (; ar_main; ar_main = ar_main->next) {
1254                 if (ar_main->regiontype == RGN_TYPE_WINDOW) {
1255                   break;
1256                 }
1257               }
1258               ar = MEM_callocN(sizeof(ARegion), "preview area for sequencer");
1259               BLI_insertlinkbefore(regionbase, ar_main, ar);
1260               sequencer_init_preview_region(ar);
1261             }
1262           }
1263         }
1264       }
1265     }
1266   }
1267
1268   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 12)) {
1269     Object *ob;
1270     Brush *brush;
1271
1272     /* anim viz changes */
1273     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1274       /* initialize object defaults */
1275       animviz_settings_init(&ob->avs);
1276
1277       /* if armature, copy settings for pose from armature data
1278        * performing initialization where appropriate
1279        */
1280       if (ob->pose && ob->data) {
1281         bArmature *arm = blo_do_versions_newlibadr(fd, lib, ob->data);
1282         if (arm) { /* XXX - why does this fail in some cases? */
1283           bAnimVizSettings *avs = &ob->pose->avs;
1284
1285           /* path settings --------------------- */
1286           /* ranges */
1287           avs->path_bc = 10;
1288           avs->path_ac = 10;
1289
1290           avs->path_sf = 1;
1291           avs->path_ef = 250;
1292
1293           /* flags */
1294           if (arm->pathflag & ARM_PATH_FNUMS) {
1295             avs->path_viewflag |= MOTIONPATH_VIEW_FNUMS;
1296           }
1297           if (arm->pathflag & ARM_PATH_KFRAS) {
1298             avs->path_viewflag |= MOTIONPATH_VIEW_KFRAS;
1299           }
1300           if (arm->pathflag & ARM_PATH_KFNOS) {
1301             avs->path_viewflag |= MOTIONPATH_VIEW_KFNOS;
1302           }
1303
1304           /* bake flags */
1305           if (arm->pathflag & ARM_PATH_HEADS) {
1306             avs->path_bakeflag |= MOTIONPATH_BAKE_HEADS;
1307           }
1308
1309           /* type */
1310           if (arm->pathflag & ARM_PATH_ACFRA) {
1311             avs->path_type = MOTIONPATH_TYPE_ACFRA;
1312           }
1313
1314           /* stepsize */
1315           avs->path_step = 1;
1316         }
1317         else {
1318           animviz_settings_init(&ob->pose->avs);
1319         }
1320       }
1321     }
1322
1323     /* brush texture changes */
1324     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
1325       BKE_texture_mtex_default(&brush->mtex);
1326       BKE_texture_mtex_default(&brush->mask_mtex);
1327     }
1328   }
1329
1330   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 13)) {
1331     /* NOTE: if you do more conversion, be sure to do it outside of this and
1332      * increase subversion again, otherwise it will not be correct */
1333     Object *ob;
1334
1335     /* convert degrees to radians for internal use */
1336     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1337       bPoseChannel *pchan;
1338
1339       do_version_constraints_radians_degrees_250(&ob->constraints);
1340
1341       if (ob->pose) {
1342         for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
1343           pchan->limitmin[0] *= (float)(M_PI / 180.0);
1344           pchan->limitmin[1] *= (float)(M_PI / 180.0);
1345           pchan->limitmin[2] *= (float)(M_PI / 180.0);
1346           pchan->limitmax[0] *= (float)(M_PI / 180.0);
1347           pchan->limitmax[1] *= (float)(M_PI / 180.0);
1348           pchan->limitmax[2] *= (float)(M_PI / 180.0);
1349
1350           do_version_constraints_radians_degrees_250(&pchan->constraints);
1351         }
1352       }
1353     }
1354   }
1355
1356   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 14)) {
1357     /* fix for bad View2D extents for Animation Editors */
1358     bScreen *screen;
1359     ScrArea *sa;
1360     SpaceLink *sl;
1361
1362     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1363       for (sa = screen->areabase.first; sa; sa = sa->next) {
1364         for (sl = sa->spacedata.first; sl; sl = sl->next) {
1365           ListBase *regionbase;
1366           ARegion *ar;
1367
1368           if (sl == sa->spacedata.first) {
1369             regionbase = &sa->regionbase;
1370           }
1371           else {
1372             regionbase = &sl->regionbase;
1373           }
1374
1375           if (ELEM(sl->spacetype, SPACE_ACTION, SPACE_NLA)) {
1376             for (ar = (ARegion *)regionbase->first; ar; ar = ar->next) {
1377               if (ar->regiontype == RGN_TYPE_WINDOW) {
1378                 ar->v2d.cur.ymax = ar->v2d.tot.ymax = 0.0f;
1379                 ar->v2d.cur.ymin = ar->v2d.tot.ymin = (float)(-sa->winy) / 3.0f;
1380               }
1381             }
1382           }
1383         }
1384       }
1385     }
1386   }
1387
1388   if (bmain->versionfile < 250 || (bmain->versionfile == 250 && bmain->subversionfile < 17)) {
1389     Scene *sce;
1390     Sequence *seq;
1391
1392     /* initialize to sane default so toggling on border shows something */
1393     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1394       if (sce->r.border.xmin == 0.0f && sce->r.border.ymin == 0.0f && sce->r.border.xmax == 0.0f &&
1395           sce->r.border.ymax == 0.0f) {
1396         sce->r.border.xmin = 0.0f;
1397         sce->r.border.ymin = 0.0f;
1398         sce->r.border.xmax = 1.0f;
1399         sce->r.border.ymax = 1.0f;
1400       }
1401
1402       if ((sce->r.ffcodecdata.flags & FFMPEG_MULTIPLEX_AUDIO) == 0) {
1403         sce->r.ffcodecdata.audio_codec = 0x0;  // CODEC_ID_NONE
1404       }
1405
1406       SEQ_BEGIN (sce->ed, seq) {
1407         seq->volume = 1.0f;
1408       }
1409       SEQ_END;
1410     }
1411
1412     /* particle brush strength factor was changed from int to float */
1413     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1414       ParticleEditSettings *pset = &sce->toolsettings->particle;
1415       int a;
1416
1417       for (a = 0; a < ARRAY_SIZE(pset->brush); a++) {
1418         pset->brush[a].strength /= 100.0f;
1419       }
1420     }
1421
1422     /* sequencer changes */
1423     {
1424       bScreen *screen;
1425       ScrArea *sa;
1426       SpaceLink *sl;
1427
1428       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1429         for (sa = screen->areabase.first; sa; sa = sa->next) {
1430           for (sl = sa->spacedata.first; sl; sl = sl->next) {
1431             if (sl->spacetype == SPACE_SEQ) {
1432               ARegion *ar_preview;
1433               ListBase *regionbase;
1434
1435               if (sl == sa->spacedata.first) {
1436                 regionbase = &sa->regionbase;
1437               }
1438               else {
1439                 regionbase = &sl->regionbase;
1440               }
1441
1442               ar_preview = (ARegion *)regionbase->first;
1443               for (; ar_preview; ar_preview = ar_preview->next) {
1444                 if (ar_preview->regiontype == RGN_TYPE_PREVIEW) {
1445                   break;
1446                 }
1447               }
1448               if (ar_preview && (ar_preview->regiontype == RGN_TYPE_PREVIEW)) {
1449                 sequencer_init_preview_region(ar_preview);
1450               }
1451             }
1452           }
1453         }
1454       }
1455     } /* sequencer changes */
1456   }
1457
1458   if (bmain->versionfile <= 251) { /* 2.5.1 had no subversions */
1459     bScreen *sc;
1460
1461     /* Blender 2.5.2 - subversion 0 introduced a new setting: V3D_HIDE_OVERLAYS.
1462      * This bit was used in the past for V3D_TRANSFORM_SNAP, which is now deprecated.
1463      * Here we clear it for old files so they don't come in with V3D_HIDE_OVERLAYS set,
1464      * which would cause cameras, lights, etc to become invisible */
1465     for (sc = bmain->screens.first; sc; sc = sc->id.next) {
1466       ScrArea *sa;
1467       for (sa = sc->areabase.first; sa; sa = sa->next) {
1468         SpaceLink *sl;
1469         for (sl = sa->spacedata.first; sl; sl = sl->next) {
1470           if (sl->spacetype == SPACE_VIEW3D) {
1471             View3D *v3d = (View3D *)sl;
1472             v3d->flag2 &= ~V3D_HIDE_OVERLAYS;
1473           }
1474         }
1475       }
1476     }
1477   }
1478
1479   if (bmain->versionfile < 252 || (bmain->versionfile == 252 && bmain->subversionfile < 1)) {
1480     Brush *brush;
1481     Object *ob;
1482     Scene *scene;
1483     bNodeTree *ntree;
1484
1485     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
1486       if (brush->curve) {
1487         brush->curve->preset = CURVE_PRESET_SMOOTH;
1488       }
1489     }
1490
1491     /* properly initialize active flag for fluidsim modifiers */
1492     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1493       ModifierData *md;
1494       for (md = ob->modifiers.first; md; md = md->next) {
1495         if (md->type == eModifierType_Fluidsim) {
1496           FluidsimModifierData *fmd = (FluidsimModifierData *)md;
1497           fmd->fss->flag |= OB_FLUIDSIM_ACTIVE;
1498           fmd->fss->flag |= OB_FLUIDSIM_OVERRIDE_TIME;
1499         }
1500       }
1501     }
1502
1503     /* adjustment to color balance node values */
1504     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1505       if (scene->nodetree) {
1506         bNode *node = scene->nodetree->nodes.first;
1507
1508         while (node) {
1509           if (node->type == CMP_NODE_COLORBALANCE) {
1510             NodeColorBalance *n = (NodeColorBalance *)node->storage;
1511             n->lift[0] += 1.f;
1512             n->lift[1] += 1.f;
1513             n->lift[2] += 1.f;
1514           }
1515           node = node->next;
1516         }
1517       }
1518     }
1519     /* check inside node groups too */
1520     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1521       bNode *node = ntree->nodes.first;
1522
1523       while (node) {
1524         if (node->type == CMP_NODE_COLORBALANCE) {
1525           NodeColorBalance *n = (NodeColorBalance *)node->storage;
1526           n->lift[0] += 1.f;
1527           n->lift[1] += 1.f;
1528           n->lift[2] += 1.f;
1529         }
1530
1531         node = node->next;
1532       }
1533     }
1534   }
1535
1536   /* old-track -> constraints (this time we're really doing it!) */
1537   if (bmain->versionfile < 252 || (bmain->versionfile == 252 && bmain->subversionfile < 2)) {
1538     Object *ob;
1539
1540     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1541       blo_do_version_old_trackto_to_constraints(ob);
1542     }
1543   }
1544
1545   if (bmain->versionfile < 252 || (bmain->versionfile == 252 && bmain->subversionfile < 5)) {
1546     bScreen *sc;
1547
1548     /* Image editor scopes */
1549     for (sc = bmain->screens.first; sc; sc = sc->id.next) {
1550       ScrArea *sa;
1551
1552       for (sa = sc->areabase.first; sa; sa = sa->next) {
1553         SpaceLink *sl;
1554
1555         for (sl = sa->spacedata.first; sl; sl = sl->next) {
1556           if (sl->spacetype == SPACE_IMAGE) {
1557             SpaceImage *sima = (SpaceImage *)sl;
1558             scopes_new(&sima->scopes);
1559           }
1560         }
1561       }
1562     }
1563   }
1564
1565   if (bmain->versionfile < 253) {
1566     Object *ob;
1567     Scene *scene;
1568     bScreen *sc;
1569     Tex *tex;
1570     Brush *brush;
1571
1572     for (sc = bmain->screens.first; sc; sc = sc->id.next) {
1573       ScrArea *sa;
1574       for (sa = sc->areabase.first; sa; sa = sa->next) {
1575         SpaceLink *sl;
1576
1577         for (sl = sa->spacedata.first; sl; sl = sl->next) {
1578           if (sl->spacetype == SPACE_NODE) {
1579             SpaceNode *snode = (SpaceNode *)sl;
1580             ListBase *regionbase;
1581             ARegion *ar;
1582
1583             if (sl == sa->spacedata.first) {
1584               regionbase = &sa->regionbase;
1585             }
1586             else {
1587               regionbase = &sl->regionbase;
1588             }
1589
1590             if (snode->v2d.minzoom > 0.09f) {
1591               snode->v2d.minzoom = 0.09f;
1592             }
1593             if (snode->v2d.maxzoom < 2.31f) {
1594               snode->v2d.maxzoom = 2.31f;
1595             }
1596
1597             for (ar = regionbase->first; ar; ar = ar->next) {
1598               if (ar->regiontype == RGN_TYPE_WINDOW) {
1599                 if (ar->v2d.minzoom > 0.09f) {
1600                   ar->v2d.minzoom = 0.09f;
1601                 }
1602                 if (ar->v2d.maxzoom < 2.31f) {
1603                   ar->v2d.maxzoom = 2.31f;
1604                 }
1605               }
1606             }
1607           }
1608         }
1609       }
1610     }
1611
1612     do_version_mdef_250(bmain);
1613
1614     /* parent type to modifier */
1615     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1616       if (ob->parent) {
1617         Object *parent = (Object *)blo_do_versions_newlibadr(fd, lib, ob->parent);
1618         if (parent) { /* parent may not be in group */
1619           enum { PARCURVE = 1 };
1620           if (parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
1621             ArmatureModifierData *amd;
1622             bArmature *arm = (bArmature *)blo_do_versions_newlibadr(fd, lib, parent->data);
1623
1624             amd = (ArmatureModifierData *)modifier_new(eModifierType_Armature);
1625             amd->object = ob->parent;
1626             BLI_addtail((ListBase *)&ob->modifiers, amd);
1627             amd->deformflag = arm->deformflag;
1628             ob->partype = PAROBJECT;
1629           }
1630           else if (parent->type == OB_LATTICE && ob->partype == PARSKEL) {
1631             LatticeModifierData *lmd;
1632
1633             lmd = (LatticeModifierData *)modifier_new(eModifierType_Lattice);
1634             lmd->object = ob->parent;
1635             BLI_addtail((ListBase *)&ob->modifiers, lmd);
1636             ob->partype = PAROBJECT;
1637           }
1638           else if (parent->type == OB_CURVE && ob->partype == PARCURVE) {
1639             CurveModifierData *cmd;
1640
1641             cmd = (CurveModifierData *)modifier_new(eModifierType_Curve);
1642             cmd->object = ob->parent;
1643             BLI_addtail((ListBase *)&ob->modifiers, cmd);
1644             ob->partype = PAROBJECT;
1645           }
1646         }
1647       }
1648     }
1649
1650     /* initialize scene active layer */
1651     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1652       int i;
1653       for (i = 0; i < 20; i++) {
1654         if (scene->lay & (1 << i)) {
1655           scene->layact = 1 << i;
1656           break;
1657         }
1658       }
1659     }
1660
1661     for (tex = bmain->textures.first; tex; tex = tex->id.next) {
1662       /* If you're picky, this isn't correct until we do a version bump
1663        * since you could set saturation to be 0.0. */
1664       if (tex->saturation == 0.0f) {
1665         tex->saturation = 1.0f;
1666       }
1667     }
1668
1669     {
1670       Curve *cu;
1671       for (cu = bmain->curves.first; cu; cu = cu->id.next) {
1672         cu->smallcaps_scale = 0.75f;
1673       }
1674     }
1675
1676     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1677       if (scene) {
1678         Sequence *seq;
1679         SEQ_BEGIN (scene->ed, seq) {
1680           if (seq->sat == 0.0f) {
1681             seq->sat = 1.0f;
1682           }
1683         }
1684         SEQ_END;
1685       }
1686     }
1687
1688     /* GSOC 2010 Sculpt - New settings for Brush */
1689
1690     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
1691       /* Sanity Check */
1692
1693       /* infinite number of dabs */
1694       if (brush->spacing == 0) {
1695         brush->spacing = 10;
1696       }
1697
1698       /* will have no effect */
1699       if (brush->alpha == 0) {
1700         brush->alpha = 0.5f;
1701       }
1702
1703       /* bad radius */
1704       if (brush->unprojected_radius == 0) {
1705         brush->unprojected_radius = 0.125f;
1706       }
1707
1708       /* unusable size */
1709       if (brush->size == 0) {
1710         brush->size = 35;
1711       }
1712
1713       /* can't see overlay */
1714       if (brush->texture_overlay_alpha == 0) {
1715         brush->texture_overlay_alpha = 33;
1716       }
1717
1718       /* same as draw brush */
1719       if (brush->crease_pinch_factor == 0) {
1720         brush->crease_pinch_factor = 0.5f;
1721       }
1722
1723       /* will sculpt no vertexes */
1724       if (brush->plane_trim == 0) {
1725         brush->plane_trim = 0.5f;
1726       }
1727
1728       /* same as smooth stroke off */
1729       if (brush->smooth_stroke_radius == 0) {
1730         brush->smooth_stroke_radius = 75;
1731       }
1732
1733       /* will keep cursor in one spot */
1734       if (brush->smooth_stroke_radius == 1) {
1735         brush->smooth_stroke_factor = 0.9f;
1736       }
1737
1738       /* same as dots */
1739       if (brush->rate == 0) {
1740         brush->rate = 0.1f;
1741       }
1742
1743       /* New Settings */
1744       if (bmain->versionfile < 252 || (bmain->versionfile == 252 && bmain->subversionfile < 5)) {
1745         brush->flag |= BRUSH_SPACE_ATTEN;  // explicitly enable adaptive space
1746
1747         /* spacing was originally in pixels, convert it to percentage for new version
1748          * size should not be zero due to sanity check above
1749          */
1750         brush->spacing = (int)(100 * ((float)brush->spacing) / ((float)brush->size));
1751
1752         if (brush->add_col[0] == 0 && brush->add_col[1] == 0 && brush->add_col[2] == 0) {
1753           brush->add_col[0] = 1.00f;
1754           brush->add_col[1] = 0.39f;
1755           brush->add_col[2] = 0.39f;
1756         }
1757
1758         if (brush->sub_col[0] == 0 && brush->sub_col[1] == 0 && brush->sub_col[2] == 0) {
1759           brush->sub_col[0] = 0.39f;
1760           brush->sub_col[1] = 0.39f;
1761           brush->sub_col[2] = 1.00f;
1762         }
1763       }
1764     }
1765   }
1766
1767   /* GSOC Sculpt 2010 - Sanity check on Sculpt/Paint settings */
1768   if (bmain->versionfile < 253) {
1769     Scene *sce;
1770     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1771       if (sce->toolsettings->sculpt_paint_unified_alpha == 0) {
1772         sce->toolsettings->sculpt_paint_unified_alpha = 0.5f;
1773       }
1774
1775       if (sce->toolsettings->sculpt_paint_unified_unprojected_radius == 0) {
1776         sce->toolsettings->sculpt_paint_unified_unprojected_radius = 0.125f;
1777       }
1778
1779       if (sce->toolsettings->sculpt_paint_unified_size == 0) {
1780         sce->toolsettings->sculpt_paint_unified_size = 35;
1781       }
1782     }
1783   }
1784
1785   if (bmain->versionfile < 253 || (bmain->versionfile == 253 && bmain->subversionfile < 1)) {
1786     Object *ob;
1787
1788     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1789       ModifierData *md;
1790
1791       for (md = ob->modifiers.first; md; md = md->next) {
1792         if (md->type == eModifierType_Smoke) {
1793           SmokeModifierData *smd = (SmokeModifierData *)md;
1794
1795           if ((smd->type & MOD_SMOKE_TYPE_DOMAIN) && smd->domain) {
1796             smd->domain->vorticity = 2.0f;
1797             smd->domain->time_scale = 1.0f;
1798
1799             if (!(smd->domain->flags & (1 << 4))) {
1800               continue;
1801             }
1802
1803             /* delete old MOD_SMOKE_INITVELOCITY flag */
1804             smd->domain->flags &= ~(1 << 4);
1805
1806             /* for now just add it to all flow objects in the scene */
1807             {
1808               Object *ob2;
1809               for (ob2 = bmain->objects.first; ob2; ob2 = ob2->id.next) {
1810                 ModifierData *md2;
1811                 for (md2 = ob2->modifiers.first; md2; md2 = md2->next) {
1812                   if (md2->type == eModifierType_Smoke) {
1813                     SmokeModifierData *smd2 = (SmokeModifierData *)md2;
1814
1815                     if ((smd2->type & MOD_SMOKE_TYPE_FLOW) && smd2->flow) {
1816                       smd2->flow->flags |= MOD_SMOKE_FLOW_INITVELOCITY;
1817                     }
1818                   }
1819                 }
1820               }
1821             }
1822           }
1823           else if ((smd->type & MOD_SMOKE_TYPE_FLOW) && smd->flow) {
1824             smd->flow->vel_multi = 1.0f;
1825           }
1826         }
1827       }
1828     }
1829   }
1830
1831   if (bmain->versionfile < 255 || (bmain->versionfile == 255 && bmain->subversionfile < 1)) {
1832     Brush *br;
1833     ParticleSettings *part;
1834     bScreen *sc;
1835
1836     for (br = bmain->brushes.first; br; br = br->id.next) {
1837       if (br->ob_mode == 0) {
1838         br->ob_mode = OB_MODE_ALL_PAINT;
1839       }
1840     }
1841
1842     for (part = bmain->particles.first; part; part = part->id.next) {
1843       if (part->boids) {
1844         part->boids->pitch = 1.0f;
1845       }
1846
1847       part->flag &= ~PART_HAIR_REGROW; /* this was a deprecated flag before */
1848       part->kink_amp_clump = 1.f;      /* keep old files looking similar */
1849     }
1850
1851     for (sc = bmain->screens.first; sc; sc = sc->id.next) {
1852       ScrArea *sa;
1853       for (sa = sc->areabase.first; sa; sa = sa->next) {
1854         SpaceLink *sl;
1855         for (sl = sa->spacedata.first; sl; sl = sl->next) {
1856           if (sl->spacetype == SPACE_INFO) {
1857             SpaceInfo *sinfo = (SpaceInfo *)sl;
1858             ARegion *ar;
1859
1860             sinfo->rpt_mask = INFO_RPT_OP;
1861
1862             for (ar = sa->regionbase.first; ar; ar = ar->next) {
1863               if (ar->regiontype == RGN_TYPE_WINDOW) {
1864                 ar->v2d.scroll = (V2D_SCROLL_RIGHT);
1865                 ar->v2d.align = V2D_ALIGN_NO_NEG_X | V2D_ALIGN_NO_NEG_Y; /* align bottom left */
1866                 ar->v2d.keepofs = V2D_LOCKOFS_X;
1867                 ar->v2d.keepzoom = (V2D_LOCKZOOM_X | V2D_LOCKZOOM_Y | V2D_LIMITZOOM |
1868                                     V2D_KEEPASPECT);
1869                 ar->v2d.keeptot = V2D_KEEPTOT_BOUNDS;
1870                 ar->v2d.minzoom = ar->v2d.maxzoom = 1.0f;
1871               }
1872             }
1873           }
1874         }
1875       }
1876     }
1877   }
1878
1879   if (bmain->versionfile < 255 || (bmain->versionfile == 255 && bmain->subversionfile < 3)) {
1880     Object *ob;
1881
1882     /* ocean res is now squared, reset old ones - will be massive */
1883     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1884       ModifierData *md;
1885       for (md = ob->modifiers.first; md; md = md->next) {
1886         if (md->type == eModifierType_Ocean) {
1887           OceanModifierData *omd = (OceanModifierData *)md;
1888           omd->resolution = 7;
1889           omd->oceancache = NULL;
1890         }
1891       }
1892     }
1893   }
1894
1895   if (bmain->versionfile < 256) {
1896     bScreen *sc;
1897     ScrArea *sa;
1898     Key *key;
1899
1900     /* Fix for sample line scope initializing with no height */
1901     for (sc = bmain->screens.first; sc; sc = sc->id.next) {
1902       sa = sc->areabase.first;
1903       while (sa) {
1904         SpaceLink *sl;
1905         for (sl = sa->spacedata.first; sl; sl = sl->next) {
1906           if (sl->spacetype == SPACE_IMAGE) {
1907             SpaceImage *sima = (SpaceImage *)sl;
1908             if (sima->sample_line_hist.height == 0) {
1909               sima->sample_line_hist.height = 100;
1910             }
1911           }
1912         }
1913         sa = sa->next;
1914       }
1915     }
1916
1917     /* old files could have been saved with slidermin = slidermax = 0.0, but the UI in
1918      * 2.4x would never reveal this to users as a dummy value always ended up getting used
1919      * instead
1920      */
1921     for (key = bmain->shapekeys.first; key; key = key->id.next) {
1922       KeyBlock *kb;
1923
1924       for (kb = key->block.first; kb; kb = kb->next) {
1925         if (IS_EQF(kb->slidermin, kb->slidermax) && IS_EQF(kb->slidermax, 0.0f)) {
1926           kb->slidermax = kb->slidermin + 1.0f;
1927         }
1928       }
1929     }
1930   }
1931
1932   if (bmain->versionfile < 256 || (bmain->versionfile == 256 && bmain->subversionfile < 1)) {
1933     /* fix for bones that didn't have arm_roll before */
1934     bArmature *arm;
1935     Bone *bone;
1936     Object *ob;
1937
1938     for (arm = bmain->armatures.first; arm; arm = arm->id.next) {
1939       for (bone = arm->bonebase.first; bone; bone = bone->next) {
1940         do_version_bone_roll_256(bone);
1941       }
1942     }
1943
1944     /* fix for objects which have zero dquat's
1945      * since this is multiplied with the quat rather than added */
1946     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1947       if (is_zero_v4(ob->dquat)) {
1948         unit_qt(ob->dquat);
1949       }
1950       if (is_zero_v3(ob->drotAxis) && ob->drotAngle == 0.0f) {
1951         unit_axis_angle(ob->drotAxis, &ob->drotAngle);
1952       }
1953     }
1954   }
1955
1956   if (bmain->versionfile < 256 || (bmain->versionfile == 256 && bmain->subversionfile < 2)) {
1957     bNodeTree *ntree;
1958     bNode *node;
1959     bNodeSocket *sock, *gsock;
1960     bNodeLink *link;
1961
1962     /* node sockets are not exposed automatically any more,
1963      * this mimics the old behavior by adding all unlinked sockets to groups.
1964      */
1965     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1966       /* this adds copies and links from all unlinked internal sockets to group inputs/outputs. */
1967
1968       /* first make sure the own_index for new sockets is valid */
1969       for (node = ntree->nodes.first; node; node = node->next) {
1970         for (sock = node->inputs.first; sock; sock = sock->next) {
1971           if (sock->own_index >= ntree->cur_index) {
1972             ntree->cur_index = sock->own_index + 1;
1973           }
1974         }
1975         for (sock = node->outputs.first; sock; sock = sock->next) {
1976           if (sock->own_index >= ntree->cur_index) {
1977             ntree->cur_index = sock->own_index + 1;
1978           }
1979         }
1980       }
1981
1982       /* add ntree->inputs/ntree->outputs sockets for all unlinked sockets in the group tree. */
1983       for (node = ntree->nodes.first; node; node = node->next) {
1984         for (sock = node->inputs.first; sock; sock = sock->next) {
1985           if (!sock->link && !nodeSocketIsHidden(sock)) {
1986
1987             gsock = do_versions_node_group_add_socket_2_56_2(
1988                 ntree, sock->name, sock->type, SOCK_IN);
1989
1990             /* initialize the default socket value */
1991             copy_v4_v4(gsock->ns.vec, sock->ns.vec);
1992
1993             /* XXX nodeAddLink does not work with incomplete (node==NULL) links any longer,
1994              * have to create these directly here.
1995              * These links are updated again in subsequent do_version!
1996              */
1997             link = MEM_callocN(sizeof(bNodeLink), "link");
1998             BLI_addtail(&ntree->links, link);
1999             link->fromnode = NULL;
2000             link->fromsock = gsock;
2001             link->tonode = node;
2002             link->tosock = sock;
2003             ntree->update |= NTREE_UPDATE_LINKS;
2004
2005             sock->link = link;
2006           }
2007         }
2008         for (sock = node->outputs.first; sock; sock = sock->next) {
2009           if (nodeCountSocketLinks(ntree, sock) == 0 && !nodeSocketIsHidden(sock)) {
2010             gsock = do_versions_node_group_add_socket_2_56_2(
2011                 ntree, sock->name, sock->type, SOCK_OUT);
2012
2013             /* initialize the default socket value */
2014             copy_v4_v4(gsock->ns.vec, sock->ns.vec);
2015
2016             /* XXX nodeAddLink does not work with incomplete (node==NULL) links any longer,
2017              * have to create these directly here.
2018              * These links are updated again in subsequent do_version!
2019              */
2020             link = MEM_callocN(sizeof(bNodeLink), "link");
2021             BLI_addtail(&ntree->links, link);
2022             link->fromnode = node;
2023             link->fromsock = sock;
2024             link->tonode = NULL;
2025             link->tosock = gsock;
2026             ntree->update |= NTREE_UPDATE_LINKS;
2027
2028             gsock->link = link;
2029           }
2030         }
2031       }
2032
2033       /* External group node socket need to adjust their own_index to point at
2034        * associated 'ntree' inputs/outputs internal sockets. This happens in
2035        * do_versions_after_linking_250, after lib linking. */
2036     }
2037   }
2038
2039   if (bmain->versionfile < 256 || (bmain->versionfile == 256 && bmain->subversionfile < 3)) {
2040     bScreen *sc;
2041     Brush *brush;
2042     Object *ob;
2043     ParticleSettings *part;
2044
2045     /* redraws flag in SpaceTime has been moved to Screen level */
2046     for (sc = bmain->screens.first; sc; sc = sc->id.next) {
2047       if (sc->redraws_flag == 0) {
2048         /* just initialize to default? */
2049         /* XXX: we could also have iterated through areas,
2050          * and taken them from the first timeline available... */
2051         sc->redraws_flag = TIME_ALL_3D_WIN | TIME_ALL_ANIM_WIN;
2052       }
2053     }
2054
2055     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
2056       if (brush->height == 0) {
2057         brush->height = 0.4f;
2058       }
2059     }
2060
2061     /* replace 'rim material' option for in offset*/
2062     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2063       ModifierData *md;
2064       for (md = ob->modifiers.first; md; md = md->next) {
2065         if (md->type == eModifierType_Solidify) {
2066           SolidifyModifierData *smd = (SolidifyModifierData *)md;
2067           if (smd->flag & MOD_SOLIDIFY_RIM_MATERIAL) {
2068             smd->mat_ofs_rim = 1;
2069             smd->flag &= ~MOD_SOLIDIFY_RIM_MATERIAL;
2070           }
2071         }
2072       }
2073     }
2074
2075     /* particle draw color from material */
2076     for (part = bmain->particles.first; part; part = part->id.next) {
2077       if (part->draw & PART_DRAW_MAT_COL) {
2078         part->draw_col = PART_DRAW_COL_MAT;
2079       }
2080     }
2081   }
2082
2083   if (bmain->versionfile < 256 || (bmain->versionfile == 256 && bmain->subversionfile < 6)) {
2084     Mesh *me;
2085
2086     for (me = bmain->meshes.first; me; me = me->id.next) {
2087       BKE_mesh_calc_normals_tessface(me->mvert, me->totvert, me->mface, me->totface, NULL);
2088     }
2089   }
2090
2091   if (bmain->versionfile < 256 || (bmain->versionfile == 256 && bmain->subversionfile < 2)) {
2092     /* update blur area sizes from 0..1 range to 0..100 percentage */
2093     Scene *scene;
2094     bNode *node;
2095     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
2096       if (scene->nodetree) {
2097         for (node = scene->nodetree->nodes.first; node; node = node->next) {
2098           if (node->type == CMP_NODE_BLUR) {
2099             NodeBlurData *nbd = node->storage;
2100             nbd->percentx *= 100.0f;
2101             nbd->percenty *= 100.0f;
2102           }
2103         }
2104       }
2105     }
2106   }
2107
2108   if (bmain->versionfile < 258 || (bmain->versionfile == 258 && bmain->subversionfile < 1)) {
2109     /* screen view2d settings were not properly initialized T27164.
2110      * v2d->scroll caused the bug but best reset other values too
2111      * which are in old blend files only.
2112      * Need to make less ugly - possibly an iterator? */
2113     bScreen *screen;
2114
2115     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2116       ScrArea *sa;
2117       /* add regions */
2118       for (sa = screen->areabase.first; sa; sa = sa->next) {
2119         SpaceLink *sl = sa->spacedata.first;
2120         if (sl->spacetype == SPACE_IMAGE) {
2121           ARegion *ar;
2122           for (ar = sa->regionbase.first; ar; ar = ar->next) {
2123             if (ar->regiontype == RGN_TYPE_WINDOW) {
2124               View2D *v2d = &ar->v2d;
2125               v2d->minzoom = v2d->maxzoom = v2d->scroll = v2d->keeptot = v2d->keepzoom =
2126                   v2d->keepofs = v2d->align = 0;
2127             }
2128           }
2129         }
2130
2131         for (sl = sa->spacedata.first; sl; sl = sl->next) {
2132           if (sl->spacetype == SPACE_IMAGE) {
2133             ARegion *ar;
2134             for (ar = sl->regionbase.first; ar; ar = ar->next) {
2135               if (ar->regiontype == RGN_TYPE_WINDOW) {
2136                 View2D *v2d = &ar->v2d;
2137                 v2d->minzoom = v2d->maxzoom = v2d->scroll = v2d->keeptot = v2d->keepzoom =
2138                     v2d->keepofs = v2d->align = 0;
2139               }
2140             }
2141           }
2142         }
2143       }
2144     }
2145
2146     {
2147       ParticleSettings *part;
2148       for (part = bmain->particles.first; part; part = part->id.next) {
2149         /* Initialize particle billboard scale */
2150         part->bb_size[0] = part->bb_size[1] = 1.0f;
2151       }
2152     }
2153   }
2154
2155   if (bmain->versionfile < 259 || (bmain->versionfile == 259 && bmain->subversionfile < 1)) {
2156     {
2157       Scene *scene;
2158       Sequence *seq;
2159
2160       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
2161         scene->r.ffcodecdata.audio_channels = 2;
2162         scene->audio.volume = 1.0f;
2163         SEQ_BEGIN (scene->ed, seq) {
2164           seq->pitch = 1.0f;
2165         }
2166         SEQ_END;
2167       }
2168     }
2169
2170     {
2171       bScreen *screen;
2172       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2173         ScrArea *sa;
2174
2175         /* add regions */
2176         for (sa = screen->areabase.first; sa; sa = sa->next) {
2177           SpaceLink *sl = sa->spacedata.first;
2178           if (sl->spacetype == SPACE_SEQ) {
2179             ARegion *ar;
2180             for (ar = sa->regionbase.first; ar; ar = ar->next) {
2181               if (ar->regiontype == RGN_TYPE_WINDOW) {
2182                 if (ar->v2d.min[1] == 4.0f) {
2183                   ar->v2d.min[1] = 0.5f;
2184                 }
2185               }
2186             }
2187           }
2188           for (sl = sa->spacedata.first; sl; sl = sl->next) {
2189             if (sl->spacetype == SPACE_SEQ) {
2190               ARegion *ar;
2191               for (ar = sl->regionbase.first; ar; ar = ar->next) {
2192                 if (ar->regiontype == RGN_TYPE_WINDOW) {
2193                   if (ar->v2d.min[1] == 4.0f) {
2194                     ar->v2d.min[1] = 0.5f;
2195                   }
2196                 }
2197               }
2198             }
2199           }
2200         }
2201       }
2202     }
2203
2204     {
2205       /* Make "auto-clamped" handles a per-keyframe setting instead of per-FCurve
2206        *
2207        * We're only patching F-Curves in Actions here, since it is assumed that most
2208        * drivers out there won't be using this (and if they are, they're in the minority).
2209        * While we should aim to fix everything ideally, in practice it's far too hard
2210        * to get to every animdata block, not to mention the performance hit that'd have
2211        */
2212       bAction *act;
2213       FCurve *fcu;
2214
2215       for (act = bmain->actions.first; act; act = act->id.next) {
2216         for (fcu = act->curves.first; fcu; fcu = fcu->next) {
2217           BezTriple *bezt;
2218           uint i = 0;
2219
2220           /* only need to touch curves that had this flag set */
2221           if ((fcu->flag & FCURVE_AUTO_HANDLES) == 0) {
2222             continue;
2223           }
2224           if ((fcu->totvert == 0) || (fcu->bezt == NULL)) {
2225             continue;
2226           }
2227
2228           /* only change auto-handles to auto-clamped */
2229           for (bezt = fcu->bezt; i < fcu->totvert; i++, bezt++) {
2230             if (bezt->h1 == HD_AUTO) {
2231               bezt->h1 = HD_AUTO_ANIM;
2232             }
2233             if (bezt->h2 == HD_AUTO) {
2234               bezt->h2 = HD_AUTO_ANIM;
2235             }
2236           }
2237
2238           fcu->flag &= ~FCURVE_AUTO_HANDLES;
2239         }
2240       }
2241     }
2242   }
2243
2244   if (bmain->versionfile < 259 || (bmain->versionfile == 259 && bmain->subversionfile < 2)) {
2245     {
2246       /* Convert default socket values from bNodeStack */
2247       FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2248         bNode *node;
2249         bNodeSocket *sock;
2250
2251         for (node = ntree->nodes.first; node; node = node->next) {
2252           for (sock = node->inputs.first; sock; sock = sock->next) {
2253             do_versions_socket_default_value_259(sock);
2254           }
2255           for (sock = node->outputs.first; sock; sock = sock->next) {
2256             do_versions_socket_default_value_259(sock);
2257           }
2258         }
2259
2260         for (sock = ntree->inputs.first; sock; sock = sock->next) {
2261           do_versions_socket_default_value_259(sock);
2262         }
2263         for (sock = ntree->outputs.first; sock; sock = sock->next) {
2264           do_versions_socket_default_value_259(sock);
2265         }
2266
2267         ntree->update |= NTREE_UPDATE;
2268       }
2269       FOREACH_NODETREE_END;
2270     }
2271
2272     {
2273       /* Initialize group tree nodetypes.
2274        * These are used to distinguish tree types and
2275        * associate them with specific node types for polling.
2276        */
2277       bNodeTree *ntree;
2278       /* all node trees in bmain->nodetree are considered groups */
2279       for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
2280         ntree->nodetype = NODE_GROUP;
2281       }
2282     }
2283   }
2284
2285   if (bmain->versionfile < 259 || (bmain->versionfile == 259 && bmain->subversionfile < 4)) {
2286     {
2287       /* Adaptive time step for particle systems */
2288       ParticleSettings *part;
2289       for (part = bmain->particles.first; part; part = part->id.next) {
2290         part->courant_target = 0.2f;
2291         part->time_flag &= ~PART_TIME_AUTOSF;
2292       }
2293     }
2294   }
2295 }
2296
2297 /* updates group node socket identifier so that
2298  * external links to/from the group node are preserved.
2299  */
2300 static void lib_node_do_versions_group_indices(bNode *gnode)
2301 {
2302   bNodeTree *ngroup = (bNodeTree *)gnode->id;
2303   bNodeSocket *sock;
2304   bNodeLink *link;
2305
2306   for (sock = gnode->outputs.first; sock; sock = sock->next) {
2307     int old_index = sock->to_index;
2308
2309     for (link = ngroup->links.first; link; link = link->next) {
2310       if (link->tonode == NULL && link->fromsock->own_index == old_index) {
2311         strcpy(sock->identifier, link->fromsock->identifier);
2312         /* deprecated */
2313         sock->own_index = link->fromsock->own_index;
2314         sock->to_index = 0;
2315         sock->groupsock = NULL;
2316       }
2317     }
2318   }
2319   for (sock = gnode->inputs.first; sock; sock = sock->next) {
2320     int old_index = sock->to_index;
2321
2322     for (link = ngroup->links.first; link; link = link->next) {
2323       if (link->fromnode == NULL && link->tosock->own_index == old_index) {
2324         strcpy(sock->identifier, link->tosock->identifier);
2325         /* deprecated */
2326         sock->own_index = link->tosock->own_index;
2327         sock->to_index = 0;
2328         sock->groupsock = NULL;
2329       }
2330     }
2331   }
2332 }
2333
2334 void do_versions_after_linking_250(Main *bmain)
2335 {
2336   if (bmain->versionfile < 256 || (bmain->versionfile == 256 && bmain->subversionfile < 2)) {
2337     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2338       /* updates external links for all group nodes in a tree */
2339       bNode *node;
2340       for (node = ntree->nodes.first; node; node = node->next) {
2341         if (node->type == NODE_GROUP) {
2342           bNodeTree *ngroup = (bNodeTree *)node->id;
2343           if (ngroup) {
2344             lib_node_do_versions_group_indices(node);
2345           }
2346         }
2347       }
2348     }
2349     FOREACH_NODETREE_END;
2350   }
2351 }