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 }