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