CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / blenloader / intern / versioning_260.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup blenloader
19  */
20
21 #include "BLI_utildefines.h"
22
23 /* allow readfile to use deprecated functionality */
24 #define DNA_DEPRECATED_ALLOW
25
26 #include "DNA_anim_types.h"
27 #include "DNA_brush_types.h"
28 #include "DNA_camera_types.h"
29 #include "DNA_cloth_types.h"
30 #include "DNA_constraint_types.h"
31 #include "DNA_fluid_types.h"
32 #include "DNA_genfile.h"
33 #include "DNA_key_types.h"
34 #include "DNA_light_types.h"
35 #include "DNA_linestyle_types.h"
36 #include "DNA_mesh_types.h"
37 #include "DNA_meshdata_types.h"
38 #include "DNA_object_fluidsim_types.h"
39 #include "DNA_object_types.h"
40 #include "DNA_screen_types.h"
41 #include "DNA_sdna_types.h"
42 #include "DNA_space_types.h"
43 #include "DNA_text_types.h"
44 #include "DNA_view3d_types.h"
45 #include "DNA_world_types.h"
46
47 #include "MEM_guardedalloc.h"
48
49 #include "BLI_blenlib.h"
50 #include "BLI_math.h"
51 #include "BLI_string_utils.h"
52
53 #include "BLT_translation.h"
54
55 #include "BKE_anim_visualization.h"
56 #include "BKE_image.h"
57 #include "BKE_main.h"  // for Main
58 #include "BKE_mesh.h"  // for ME_ defines (patching)
59 #include "BKE_modifier.h"
60 #include "BKE_particle.h"
61 #include "BKE_pointcache.h"
62 #include "BKE_scene.h"
63 #include "BKE_screen.h"
64 #include "BKE_sequencer.h"
65 #include "BKE_text.h"  // for txt_extended_ascii_as_utf8
66 #include "BKE_texture.h"
67 #include "BKE_tracking.h"
68
69 #ifdef WITH_FFMPEG
70 #  include "BKE_writeffmpeg.h"
71 #endif
72
73 #include "IMB_imbuf.h"  // for proxy / timecode versioning stuff
74
75 #include "NOD_common.h"
76 #include "NOD_texture.h"
77
78 #include "BLO_readfile.h"
79
80 #include "readfile.h"
81
82 /* Make preferences read-only, use versioning_userdef.c. */
83 #define U (*((const UserDef *)&U))
84
85 static void do_versions_nodetree_image_default_alpha_output(bNodeTree *ntree)
86 {
87   bNode *node;
88   bNodeSocket *sock;
89
90   for (node = ntree->nodes.first; node; node = node->next) {
91     if (ELEM(node->type, CMP_NODE_IMAGE, CMP_NODE_R_LAYERS)) {
92       /* default Image output value should have 0 alpha */
93       sock = node->outputs.first;
94       ((bNodeSocketValueRGBA *)(sock->default_value))->value[3] = 0.0f;
95     }
96   }
97 }
98
99 static void do_versions_nodetree_convert_angle(bNodeTree *ntree)
100 {
101   bNode *node;
102   for (node = ntree->nodes.first; node; node = node->next) {
103     if (node->type == CMP_NODE_ROTATE) {
104       /* Convert degrees to radians. */
105       bNodeSocket *sock = ((bNodeSocket *)node->inputs.first)->next;
106       ((bNodeSocketValueFloat *)sock->default_value)->value = DEG2RADF(
107           ((bNodeSocketValueFloat *)sock->default_value)->value);
108     }
109     else if (node->type == CMP_NODE_DBLUR) {
110       /* Convert degrees to radians. */
111       NodeDBlurData *ndbd = node->storage;
112       ndbd->angle = DEG2RADF(ndbd->angle);
113       ndbd->spin = DEG2RADF(ndbd->spin);
114     }
115     else if (node->type == CMP_NODE_DEFOCUS) {
116       /* Convert degrees to radians. */
117       NodeDefocus *nqd = node->storage;
118       /* XXX DNA char to float conversion seems to map the char value
119        * into the [0.0f, 1.0f] range. */
120       nqd->rotation = DEG2RADF(nqd->rotation * 255.0f);
121     }
122     else if (node->type == CMP_NODE_CHROMA_MATTE) {
123       /* Convert degrees to radians. */
124       NodeChroma *ndc = node->storage;
125       ndc->t1 = DEG2RADF(ndc->t1);
126       ndc->t2 = DEG2RADF(ndc->t2);
127     }
128     else if (node->type == CMP_NODE_GLARE) {
129       /* Convert degrees to radians. */
130       NodeGlare *ndg = node->storage;
131       /* XXX DNA char to float conversion seems to map the char value
132        * into the [0.0f, 1.0f] range. */
133       ndg->angle_ofs = DEG2RADF(ndg->angle_ofs * 255.0f);
134     }
135     /* XXX TexMapping struct is used by other nodes too (at least node_composite_mapValue),
136      *     but not the rot part...
137      */
138     else if (node->type == SH_NODE_MAPPING) {
139       /* Convert degrees to radians. */
140       TexMapping *tmap = node->storage;
141       tmap->rot[0] = DEG2RADF(tmap->rot[0]);
142       tmap->rot[1] = DEG2RADF(tmap->rot[1]);
143       tmap->rot[2] = DEG2RADF(tmap->rot[2]);
144     }
145   }
146 }
147
148 static void do_versions_image_settings_2_60(Scene *sce)
149 {
150   /* RenderData.subimtype flag options for imtype */
151   enum {
152     R_OPENEXR_HALF = (1 << 0),
153     R_OPENEXR_ZBUF = (1 << 1),
154     R_PREVIEW_JPG = (1 << 2),
155     R_CINEON_LOG = (1 << 3),
156     R_TIFF_16BIT = (1 << 4),
157
158     R_JPEG2K_12BIT = (1 << 5),
159     /* Jpeg2000 */
160     R_JPEG2K_16BIT = (1 << 6),
161     R_JPEG2K_YCC = (1 << 7),
162     /* when disabled use RGB */
163     R_JPEG2K_CINE_PRESET = (1 << 8),
164     R_JPEG2K_CINE_48FPS = (1 << 9),
165   };
166
167   /* note: rd->subimtype is moved into individual settings now and no longer
168    * exists */
169   RenderData *rd = &sce->r;
170   ImageFormatData *imf = &sce->r.im_format;
171
172   /* we know no data loss happens here, the old values were in char range */
173   imf->imtype = (char)rd->imtype;
174   imf->planes = (char)rd->planes;
175   imf->compress = (char)rd->quality;
176   imf->quality = (char)rd->quality;
177
178   /* default, was stored in multiple places, may override later */
179   imf->depth = R_IMF_CHAN_DEPTH_8;
180
181   /* openexr */
182   imf->exr_codec = rd->quality & 7; /* strange but true! 0-4 are valid values, OPENEXR_COMPRESS */
183
184   switch (imf->imtype) {
185     case R_IMF_IMTYPE_OPENEXR:
186       imf->depth = (rd->subimtype & R_OPENEXR_HALF) ? R_IMF_CHAN_DEPTH_16 : R_IMF_CHAN_DEPTH_32;
187       if (rd->subimtype & R_PREVIEW_JPG) {
188         imf->flag |= R_IMF_FLAG_PREVIEW_JPG;
189       }
190       if (rd->subimtype & R_OPENEXR_ZBUF) {
191         imf->flag |= R_IMF_FLAG_ZBUF;
192       }
193       break;
194     case R_IMF_IMTYPE_TIFF:
195       if (rd->subimtype & R_TIFF_16BIT) {
196         imf->depth = R_IMF_CHAN_DEPTH_16;
197       }
198       break;
199     case R_IMF_IMTYPE_JP2:
200       if (rd->subimtype & R_JPEG2K_16BIT) {
201         imf->depth = R_IMF_CHAN_DEPTH_16;
202       }
203       else if (rd->subimtype & R_JPEG2K_12BIT) {
204         imf->depth = R_IMF_CHAN_DEPTH_12;
205       }
206
207       if (rd->subimtype & R_JPEG2K_YCC) {
208         imf->jp2_flag |= R_IMF_JP2_FLAG_YCC;
209       }
210       if (rd->subimtype & R_JPEG2K_CINE_PRESET) {
211         imf->jp2_flag |= R_IMF_JP2_FLAG_CINE_PRESET;
212       }
213       if (rd->subimtype & R_JPEG2K_CINE_48FPS) {
214         imf->jp2_flag |= R_IMF_JP2_FLAG_CINE_48;
215       }
216       break;
217     case R_IMF_IMTYPE_CINEON:
218     case R_IMF_IMTYPE_DPX:
219       if (rd->subimtype & R_CINEON_LOG) {
220         imf->cineon_flag |= R_IMF_CINEON_FLAG_LOG;
221       }
222       break;
223   }
224 }
225
226 /* socket use flags were only temporary before */
227 static void do_versions_nodetree_socket_use_flags_2_62(bNodeTree *ntree)
228 {
229   bNode *node;
230   bNodeSocket *sock;
231   bNodeLink *link;
232
233   for (node = ntree->nodes.first; node; node = node->next) {
234     for (sock = node->inputs.first; sock; sock = sock->next) {
235       sock->flag &= ~SOCK_IN_USE;
236     }
237     for (sock = node->outputs.first; sock; sock = sock->next) {
238       sock->flag &= ~SOCK_IN_USE;
239     }
240   }
241   for (sock = ntree->inputs.first; sock; sock = sock->next) {
242     sock->flag &= ~SOCK_IN_USE;
243   }
244   for (sock = ntree->outputs.first; sock; sock = sock->next) {
245     sock->flag &= ~SOCK_IN_USE;
246   }
247
248   for (link = ntree->links.first; link; link = link->next) {
249     link->fromsock->flag |= SOCK_IN_USE;
250     link->tosock->flag |= SOCK_IN_USE;
251   }
252 }
253
254 static void do_versions_nodetree_multi_file_output_format_2_62_1(Scene *sce, bNodeTree *ntree)
255 {
256   bNode *node;
257
258   for (node = ntree->nodes.first; node; node = node->next) {
259     if (node->type == CMP_NODE_OUTPUT_FILE) {
260       /* previous CMP_NODE_OUTPUT_FILE nodes get converted to multi-file outputs */
261       NodeImageFile *old_data = node->storage;
262       NodeImageMultiFile *nimf = MEM_callocN(sizeof(NodeImageMultiFile), "node image multi file");
263       bNodeSocket *old_image = BLI_findlink(&node->inputs, 0);
264       bNodeSocket *old_z = BLI_findlink(&node->inputs, 1);
265       bNodeSocket *sock;
266       char filename[FILE_MAXFILE];
267
268       /* ugly, need to remove the old inputs list to avoid bad pointer
269        * checks when adding new sockets.
270        * sock->storage is expected to contain path info in ntreeCompositOutputFileAddSocket.
271        */
272       BLI_listbase_clear(&node->inputs);
273
274       node->storage = nimf;
275
276       /* looks like storage data can be messed up somehow, stupid check here */
277       if (old_data) {
278         char basepath[FILE_MAXDIR];
279
280         /* split off filename from the old path, to be used as socket sub-path */
281         BLI_split_dirfile(old_data->name, basepath, filename, sizeof(basepath), sizeof(filename));
282
283         BLI_strncpy(nimf->base_path, basepath, sizeof(nimf->base_path));
284         nimf->format = old_data->im_format;
285       }
286       else {
287         BLI_strncpy(filename, old_image->name, sizeof(filename));
288       }
289
290       /* if z buffer is saved, change the image type to multilayer exr.
291        * XXX this is slightly messy, Z buffer was ignored before for anything but EXR and IRIS ...
292        * I'm just assuming here that IRIZ means IRIS with z buffer ...
293        */
294       if (old_data && ELEM(old_data->im_format.imtype, R_IMF_IMTYPE_IRIZ, R_IMF_IMTYPE_OPENEXR)) {
295         char sockpath[FILE_MAX];
296
297         nimf->format.imtype = R_IMF_IMTYPE_MULTILAYER;
298
299         BLI_snprintf(sockpath, sizeof(sockpath), "%s_Image", filename);
300         sock = ntreeCompositOutputFileAddSocket(ntree, node, sockpath, &nimf->format);
301         /* XXX later do_versions copies path from socket name, need to set this explicitly */
302         BLI_strncpy(sock->name, sockpath, sizeof(sock->name));
303         if (old_image->link) {
304           old_image->link->tosock = sock;
305           sock->link = old_image->link;
306         }
307
308         BLI_snprintf(sockpath, sizeof(sockpath), "%s_Z", filename);
309         sock = ntreeCompositOutputFileAddSocket(ntree, node, sockpath, &nimf->format);
310         /* XXX later do_versions copies path from socket name, need to set this explicitly */
311         BLI_strncpy(sock->name, sockpath, sizeof(sock->name));
312         if (old_z->link) {
313           old_z->link->tosock = sock;
314           sock->link = old_z->link;
315         }
316       }
317       else {
318         sock = ntreeCompositOutputFileAddSocket(ntree, node, filename, &nimf->format);
319         /* XXX later do_versions copies path from socket name, need to set this explicitly */
320         BLI_strncpy(sock->name, filename, sizeof(sock->name));
321         if (old_image->link) {
322           old_image->link->tosock = sock;
323           sock->link = old_image->link;
324         }
325       }
326
327       nodeRemoveSocket(ntree, node, old_image);
328       nodeRemoveSocket(ntree, node, old_z);
329       if (old_data) {
330         MEM_freeN(old_data);
331       }
332     }
333     else if (node->type == CMP_NODE_OUTPUT_MULTI_FILE__DEPRECATED) {
334       NodeImageMultiFile *nimf = node->storage;
335       bNodeSocket *sock;
336
337       /* CMP_NODE_OUTPUT_MULTI_FILE has been redeclared as CMP_NODE_OUTPUT_FILE */
338       node->type = CMP_NODE_OUTPUT_FILE;
339
340       /* initialize the node-wide image format from render data, if available */
341       if (sce) {
342         nimf->format = sce->r.im_format;
343       }
344
345       /* transfer render format toggle to node format toggle */
346       for (sock = node->inputs.first; sock; sock = sock->next) {
347         NodeImageMultiFileSocket *simf = sock->storage;
348         simf->use_node_format = simf->use_render_format;
349       }
350
351       /* we do have preview now */
352       node->flag |= NODE_PREVIEW;
353     }
354   }
355 }
356
357 /* blue and red are swapped pre 2.62.1, be sane (red == red) now! */
358 static void do_versions_mesh_mloopcol_swap_2_62_1(Mesh *me)
359 {
360   CustomDataLayer *layer;
361   MLoopCol *mloopcol;
362   int a;
363   int i;
364
365   for (a = 0; a < me->ldata.totlayer; a++) {
366     layer = &me->ldata.layers[a];
367
368     if (layer->type == CD_MLOOPCOL) {
369       mloopcol = (MLoopCol *)layer->data;
370       for (i = 0; i < me->totloop; i++, mloopcol++) {
371         SWAP(uchar, mloopcol->r, mloopcol->b);
372       }
373     }
374   }
375 }
376
377 static void do_versions_nodetree_multi_file_output_path_2_63_1(bNodeTree *ntree)
378 {
379   bNode *node;
380
381   for (node = ntree->nodes.first; node; node = node->next) {
382     if (node->type == CMP_NODE_OUTPUT_FILE) {
383       bNodeSocket *sock;
384       for (sock = node->inputs.first; sock; sock = sock->next) {
385         NodeImageMultiFileSocket *input = sock->storage;
386         /* input file path is stored in dedicated struct now instead socket name */
387         BLI_strncpy(input->path, sock->name, sizeof(input->path));
388       }
389     }
390   }
391 }
392
393 static void do_versions_nodetree_file_output_layers_2_64_5(bNodeTree *ntree)
394 {
395   bNode *node;
396
397   for (node = ntree->nodes.first; node; node = node->next) {
398     if (node->type == CMP_NODE_OUTPUT_FILE) {
399       bNodeSocket *sock;
400       for (sock = node->inputs.first; sock; sock = sock->next) {
401         NodeImageMultiFileSocket *input = sock->storage;
402
403         /* multilayer names are stored as separate strings now,
404          * used the path string before, so copy it over.
405          */
406         BLI_strncpy(input->layer, input->path, sizeof(input->layer));
407
408         /* paths/layer names also have to be unique now, initial check */
409         ntreeCompositOutputFileUniquePath(&node->inputs, sock, input->path, '_');
410         ntreeCompositOutputFileUniqueLayer(&node->inputs, sock, input->layer, '_');
411       }
412     }
413   }
414 }
415
416 static void do_versions_nodetree_image_layer_2_64_5(bNodeTree *ntree)
417 {
418   bNode *node;
419
420   for (node = ntree->nodes.first; node; node = node->next) {
421     if (node->type == CMP_NODE_IMAGE) {
422       bNodeSocket *sock;
423       for (sock = node->outputs.first; sock; sock = sock->next) {
424         NodeImageLayer *output = MEM_callocN(sizeof(NodeImageLayer), "node image layer");
425
426         /* take pass index both from current storage ptr (actually an int) */
427         output->pass_index = POINTER_AS_INT(sock->storage);
428
429         /* replace socket data pointer */
430         sock->storage = output;
431       }
432     }
433   }
434 }
435
436 static void do_versions_nodetree_frame_2_64_6(bNodeTree *ntree)
437 {
438   bNode *node;
439
440   for (node = ntree->nodes.first; node; node = node->next) {
441     if (node->type == NODE_FRAME) {
442       /* initialize frame node storage data */
443       if (node->storage == NULL) {
444         NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
445         node->storage = data;
446
447         /* copy current flags */
448         data->flag = node->custom1;
449
450         data->label_size = 20;
451       }
452     }
453
454     /* initialize custom node color */
455     node->color[0] = node->color[1] = node->color[2] = 0.608f; /* default theme color */
456   }
457 }
458
459 static void do_versions_affine_tracker_track(MovieTrackingTrack *track)
460 {
461   int i;
462
463   for (i = 0; i < track->markersnr; i++) {
464     MovieTrackingMarker *marker = &track->markers[i];
465
466     if (is_zero_v2(marker->pattern_corners[0]) && is_zero_v2(marker->pattern_corners[1]) &&
467         is_zero_v2(marker->pattern_corners[2]) && is_zero_v2(marker->pattern_corners[3])) {
468       marker->pattern_corners[0][0] = track->pat_min[0];
469       marker->pattern_corners[0][1] = track->pat_min[1];
470
471       marker->pattern_corners[1][0] = track->pat_max[0];
472       marker->pattern_corners[1][1] = track->pat_min[1];
473
474       marker->pattern_corners[2][0] = track->pat_max[0];
475       marker->pattern_corners[2][1] = track->pat_max[1];
476
477       marker->pattern_corners[3][0] = track->pat_min[0];
478       marker->pattern_corners[3][1] = track->pat_max[1];
479     }
480
481     if (is_zero_v2(marker->search_min) && is_zero_v2(marker->search_max)) {
482       copy_v2_v2(marker->search_min, track->search_min);
483       copy_v2_v2(marker->search_max, track->search_max);
484     }
485   }
486 }
487
488 static const char *node_get_static_idname(int type, int treetype)
489 {
490   /* use static type info header to map static int type to identifier string */
491 #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
492   case ID: \
493     return #Category #StructName;
494
495   /* XXX hack, group types share a single static integer identifier,
496    * but are registered as separate types */
497   if (type == NODE_GROUP) {
498     switch (treetype) {
499       case NTREE_COMPOSIT:
500         return "CompositorNodeGroup";
501       case NTREE_SHADER:
502         return "ShaderNodeGroup";
503       case NTREE_TEXTURE:
504         return "TextureNodeGroup";
505     }
506   }
507   else {
508     switch (type) {
509 #include "NOD_static_types.h"
510     }
511   }
512   return "";
513 }
514
515 static const char *node_socket_get_static_idname(bNodeSocket *sock)
516 {
517   switch (sock->type) {
518     case SOCK_FLOAT: {
519       bNodeSocketValueFloat *dval = sock->default_value;
520       return nodeStaticSocketType(SOCK_FLOAT, dval->subtype);
521     }
522     case SOCK_INT: {
523       bNodeSocketValueInt *dval = sock->default_value;
524       return nodeStaticSocketType(SOCK_INT, dval->subtype);
525     }
526     case SOCK_BOOLEAN: {
527       return nodeStaticSocketType(SOCK_BOOLEAN, PROP_NONE);
528     }
529     case SOCK_VECTOR: {
530       bNodeSocketValueVector *dval = sock->default_value;
531       return nodeStaticSocketType(SOCK_VECTOR, dval->subtype);
532     }
533     case SOCK_RGBA: {
534       return nodeStaticSocketType(SOCK_RGBA, PROP_NONE);
535     }
536     case SOCK_STRING: {
537       bNodeSocketValueString *dval = sock->default_value;
538       return nodeStaticSocketType(SOCK_STRING, dval->subtype);
539     }
540     case SOCK_SHADER: {
541       return nodeStaticSocketType(SOCK_SHADER, PROP_NONE);
542     }
543   }
544   return "";
545 }
546
547 static void do_versions_nodetree_customnodes(bNodeTree *ntree, int UNUSED(is_group))
548 {
549   /* initialize node tree type idname */
550   {
551     bNode *node;
552     bNodeSocket *sock;
553
554     ntree->typeinfo = NULL;
555
556     /* tree type idname */
557     switch (ntree->type) {
558       case NTREE_COMPOSIT:
559         strcpy(ntree->idname, "CompositorNodeTree");
560         break;
561       case NTREE_SHADER:
562         strcpy(ntree->idname, "ShaderNodeTree");
563         break;
564       case NTREE_TEXTURE:
565         strcpy(ntree->idname, "TextureNodeTree");
566         break;
567     }
568
569     /* node type idname */
570     for (node = ntree->nodes.first; node; node = node->next) {
571       BLI_strncpy(
572           node->idname, node_get_static_idname(node->type, ntree->type), sizeof(node->idname));
573
574       /* existing old nodes have been initialized already */
575       node->flag |= NODE_INIT;
576
577       /* sockets idname */
578       for (sock = node->inputs.first; sock; sock = sock->next) {
579         BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
580       }
581       for (sock = node->outputs.first; sock; sock = sock->next) {
582         BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
583       }
584     }
585     /* tree sockets idname */
586     for (sock = ntree->inputs.first; sock; sock = sock->next) {
587       BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
588     }
589     for (sock = ntree->outputs.first; sock; sock = sock->next) {
590       BLI_strncpy(sock->idname, node_socket_get_static_idname(sock), sizeof(sock->idname));
591     }
592   }
593
594   /* initialize socket in_out values */
595   {
596     bNode *node;
597     bNodeSocket *sock;
598
599     for (node = ntree->nodes.first; node; node = node->next) {
600       for (sock = node->inputs.first; sock; sock = sock->next) {
601         sock->in_out = SOCK_IN;
602       }
603       for (sock = node->outputs.first; sock; sock = sock->next) {
604         sock->in_out = SOCK_OUT;
605       }
606     }
607     for (sock = ntree->inputs.first; sock; sock = sock->next) {
608       sock->in_out = SOCK_IN;
609     }
610     for (sock = ntree->outputs.first; sock; sock = sock->next) {
611       sock->in_out = SOCK_OUT;
612     }
613   }
614
615   /* initialize socket identifier strings */
616   {
617     bNode *node;
618     bNodeSocket *sock;
619
620     for (node = ntree->nodes.first; node; node = node->next) {
621       for (sock = node->inputs.first; sock; sock = sock->next) {
622         BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
623         BLI_uniquename(&node->inputs,
624                        sock,
625                        "socket",
626                        '.',
627                        offsetof(bNodeSocket, identifier),
628                        sizeof(sock->identifier));
629       }
630       for (sock = node->outputs.first; sock; sock = sock->next) {
631         BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
632         BLI_uniquename(&node->outputs,
633                        sock,
634                        "socket",
635                        '.',
636                        offsetof(bNodeSocket, identifier),
637                        sizeof(sock->identifier));
638       }
639     }
640     for (sock = ntree->inputs.first; sock; sock = sock->next) {
641       BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
642       BLI_uniquename(&ntree->inputs,
643                      sock,
644                      "socket",
645                      '.',
646                      offsetof(bNodeSocket, identifier),
647                      sizeof(sock->identifier));
648     }
649     for (sock = ntree->outputs.first; sock; sock = sock->next) {
650       BLI_strncpy(sock->identifier, sock->name, sizeof(sock->identifier));
651       BLI_uniquename(&ntree->outputs,
652                      sock,
653                      "socket",
654                      '.',
655                      offsetof(bNodeSocket, identifier),
656                      sizeof(sock->identifier));
657     }
658   }
659 }
660
661 void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
662 {
663   if (bmain->versionfile < 260) {
664     {
665       /* set default alpha value of Image outputs in image and render layer nodes to 0 */
666       Scene *sce;
667       bNodeTree *ntree;
668
669       for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
670         /* there are files with invalid audio_channels value, the real cause
671          * is unknown, but we fix it here anyway to avoid crashes */
672         if (sce->r.ffcodecdata.audio_channels == 0) {
673           sce->r.ffcodecdata.audio_channels = 2;
674         }
675
676         if (sce->nodetree) {
677           do_versions_nodetree_image_default_alpha_output(sce->nodetree);
678         }
679       }
680
681       for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
682         do_versions_nodetree_image_default_alpha_output(ntree);
683       }
684     }
685
686     {
687       /* support old particle dupliobject rotation settings */
688       ParticleSettings *part;
689
690       for (part = bmain->particles.first; part; part = part->id.next) {
691         if (ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) {
692           part->draw |= PART_DRAW_ROTATE_OB;
693
694           if (part->rotmode == 0) {
695             part->rotmode = PART_ROT_VEL;
696           }
697         }
698       }
699     }
700   }
701
702   if (bmain->versionfile < 260 || (bmain->versionfile == 260 && bmain->subversionfile < 1)) {
703     Object *ob;
704
705     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
706       ob->collision_boundtype = ob->boundtype;
707     }
708
709     {
710       Camera *cam;
711       for (cam = bmain->cameras.first; cam; cam = cam->id.next) {
712         if (cam->sensor_x < 0.01f) {
713           cam->sensor_x = DEFAULT_SENSOR_WIDTH;
714         }
715
716         if (cam->sensor_y < 0.01f) {
717           cam->sensor_y = DEFAULT_SENSOR_HEIGHT;
718         }
719       }
720     }
721   }
722
723   if (bmain->versionfile < 260 || (bmain->versionfile == 260 && bmain->subversionfile < 2)) {
724     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
725       if (ntree->type == NTREE_SHADER) {
726         bNode *node;
727         for (node = ntree->nodes.first; node; node = node->next) {
728           if (node->type == SH_NODE_MAPPING) {
729             TexMapping *tex_mapping;
730
731             tex_mapping = node->storage;
732             tex_mapping->projx = PROJ_X;
733             tex_mapping->projy = PROJ_Y;
734             tex_mapping->projz = PROJ_Z;
735           }
736         }
737       }
738     }
739     FOREACH_NODETREE_END;
740   }
741
742   if (bmain->versionfile < 260 || (bmain->versionfile == 260 && bmain->subversionfile < 4)) {
743     {
744       /* Convert node angles to radians! */
745       Scene *sce;
746       Material *mat;
747       bNodeTree *ntree;
748
749       for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
750         if (sce->nodetree) {
751           do_versions_nodetree_convert_angle(sce->nodetree);
752         }
753       }
754
755       for (mat = bmain->materials.first; mat; mat = mat->id.next) {
756         if (mat->nodetree) {
757           do_versions_nodetree_convert_angle(mat->nodetree);
758         }
759       }
760
761       for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
762         do_versions_nodetree_convert_angle(ntree);
763       }
764     }
765
766     {
767       /* Tomato compatibility code. */
768       bScreen *screen;
769       MovieClip *clip;
770
771       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
772         ScrArea *area;
773         for (area = screen->areabase.first; area; area = area->next) {
774           SpaceLink *sl;
775           for (sl = area->spacedata.first; sl; sl = sl->next) {
776             if (sl->spacetype == SPACE_VIEW3D) {
777               View3D *v3d = (View3D *)sl;
778               if (v3d->bundle_size == 0.0f) {
779                 v3d->bundle_size = 0.2f;
780                 v3d->flag2 |= V3D_SHOW_RECONSTRUCTION;
781               }
782
783               if (v3d->bundle_drawtype == 0) {
784                 v3d->bundle_drawtype = OB_PLAINAXES;
785               }
786             }
787             else if (sl->spacetype == SPACE_CLIP) {
788               SpaceClip *sclip = (SpaceClip *)sl;
789               if (sclip->scopes.track_preview_height == 0) {
790                 sclip->scopes.track_preview_height = 120;
791               }
792             }
793           }
794         }
795       }
796
797       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
798         MovieTrackingTrack *track;
799
800         if (clip->aspx < 1.0f) {
801           clip->aspx = 1.0f;
802           clip->aspy = 1.0f;
803         }
804
805         clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN | IMB_TC_FREE_RUN |
806                                     IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN;
807
808         if (clip->proxy.build_size_flag == 0) {
809           clip->proxy.build_size_flag = IMB_PROXY_25;
810         }
811
812         if (clip->proxy.quality == 0) {
813           clip->proxy.quality = 90;
814         }
815
816         if (clip->tracking.camera.pixel_aspect < 0.01f) {
817           clip->tracking.camera.pixel_aspect = 1.0f;
818         }
819
820         track = clip->tracking.tracks.first;
821         while (track) {
822           if (track->minimum_correlation == 0.0f) {
823             track->minimum_correlation = 0.75f;
824           }
825
826           track = track->next;
827         }
828       }
829     }
830   }
831
832   if (bmain->versionfile < 260 || (bmain->versionfile == 260 && bmain->subversionfile < 6)) {
833     Scene *sce;
834     MovieClip *clip;
835
836     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
837       do_versions_image_settings_2_60(sce);
838     }
839
840     for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
841       MovieTrackingSettings *settings = &clip->tracking.settings;
842
843       if (settings->default_pattern_size == 0.0f) {
844         settings->default_motion_model = TRACK_MOTION_MODEL_TRANSLATION;
845         settings->default_minimum_correlation = 0.75;
846         settings->default_pattern_size = 11;
847         settings->default_search_size = 51;
848       }
849     }
850
851     {
852       Object *ob;
853       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
854         /* convert delta addition into delta scale */
855         int i;
856         for (i = 0; i < 3; i++) {
857           if ((ob->dsize[i] == 0.0f) || /* simple case, user never touched dsize */
858               (ob->scale[i] == 0.0f))   /* cant scale the dsize to give a non zero result,
859                                          * so fallback to 1.0f */
860           {
861             ob->dscale[i] = 1.0f;
862           }
863           else {
864             ob->dscale[i] = (ob->scale[i] + ob->dsize[i]) / ob->scale[i];
865           }
866         }
867       }
868     }
869   }
870   /* sigh, this dscale vs dsize version patching was not done right, fix for fix,
871    * this intentionally checks an exact subversion, also note this was never in a release,
872    * at some point this could be removed. */
873   else if (bmain->versionfile == 260 && bmain->subversionfile == 6) {
874     Object *ob;
875     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
876       if (is_zero_v3(ob->dscale)) {
877         copy_vn_fl(ob->dscale, 3, 1.0f);
878       }
879     }
880   }
881
882   if (bmain->versionfile < 260 || (bmain->versionfile == 260 && bmain->subversionfile < 8)) {
883     Brush *brush;
884
885     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
886       if (brush->sculpt_tool == SCULPT_TOOL_ROTATE) {
887         brush->alpha = 1.0f;
888       }
889     }
890   }
891
892   if (bmain->versionfile < 261 || (bmain->versionfile == 261 && bmain->subversionfile < 1)) {
893     {
894       /* update use flags for node sockets (was only temporary before) */
895       Scene *sce;
896       Material *mat;
897       Tex *tex;
898       World *world;
899       bNodeTree *ntree;
900
901       for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
902         if (sce->nodetree) {
903           do_versions_nodetree_socket_use_flags_2_62(sce->nodetree);
904         }
905       }
906
907       for (mat = bmain->materials.first; mat; mat = mat->id.next) {
908         if (mat->nodetree) {
909           do_versions_nodetree_socket_use_flags_2_62(mat->nodetree);
910         }
911       }
912
913       for (tex = bmain->textures.first; tex; tex = tex->id.next) {
914         if (tex->nodetree) {
915           do_versions_nodetree_socket_use_flags_2_62(tex->nodetree);
916         }
917       }
918
919       for (Light *la = bmain->lights.first; la; la = la->id.next) {
920         if (la->nodetree) {
921           do_versions_nodetree_socket_use_flags_2_62(la->nodetree);
922         }
923       }
924
925       for (world = bmain->worlds.first; world; world = world->id.next) {
926         if (world->nodetree) {
927           do_versions_nodetree_socket_use_flags_2_62(world->nodetree);
928         }
929       }
930
931       for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
932         do_versions_nodetree_socket_use_flags_2_62(ntree);
933       }
934     }
935     {
936       MovieClip *clip;
937       Object *ob;
938
939       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
940         MovieTracking *tracking = &clip->tracking;
941         MovieTrackingObject *tracking_object = tracking->objects.first;
942
943         clip->proxy.build_tc_flag |= IMB_TC_RECORD_RUN_NO_GAPS;
944
945         if (!tracking->settings.object_distance) {
946           tracking->settings.object_distance = 1.0f;
947         }
948
949         if (BLI_listbase_is_empty(&tracking->objects)) {
950           BKE_tracking_object_add(tracking, "Camera");
951         }
952
953         while (tracking_object) {
954           if (!tracking_object->scale) {
955             tracking_object->scale = 1.0f;
956           }
957
958           tracking_object = tracking_object->next;
959         }
960       }
961
962       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
963         bConstraint *con;
964         for (con = ob->constraints.first; con; con = con->next) {
965           if (con->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
966             bObjectSolverConstraint *data = (bObjectSolverConstraint *)con->data;
967
968             if (data->invmat[3][3] == 0.0f) {
969               unit_m4(data->invmat);
970             }
971           }
972         }
973       }
974     }
975   }
976
977   if (bmain->versionfile < 261 || (bmain->versionfile == 261 && bmain->subversionfile < 2)) {
978     {
979       /* convert deprecated sculpt_paint_unified_* fields to
980        * UnifiedPaintSettings */
981       Scene *scene;
982       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
983         ToolSettings *ts = scene->toolsettings;
984         UnifiedPaintSettings *ups = &ts->unified_paint_settings;
985         ups->size = ts->sculpt_paint_unified_size;
986         ups->unprojected_radius = ts->sculpt_paint_unified_unprojected_radius;
987         ups->alpha = ts->sculpt_paint_unified_alpha;
988         ups->flag = ts->sculpt_paint_settings;
989       }
990     }
991   }
992
993   if (bmain->versionfile < 261 || (bmain->versionfile == 261 && bmain->subversionfile < 3)) {
994     {
995       /* convert extended ascii to utf-8 for text editor */
996       Text *text;
997       for (text = bmain->texts.first; text; text = text->id.next) {
998         if (!(text->flags & TXT_ISEXT)) {
999           TextLine *tl;
1000
1001           for (tl = text->lines.first; tl; tl = tl->next) {
1002             int added = txt_extended_ascii_as_utf8(&tl->line);
1003             tl->len += added;
1004
1005             /* reset cursor position if line was changed */
1006             if (added && tl == text->curl) {
1007               text->curc = 0;
1008             }
1009           }
1010         }
1011       }
1012     }
1013     {
1014       /* set new dynamic paint values */
1015       Object *ob;
1016       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1017         ModifierData *md;
1018         for (md = ob->modifiers.first; md; md = md->next) {
1019           if (md->type == eModifierType_DynamicPaint) {
1020             DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)md;
1021             if (pmd->canvas) {
1022               DynamicPaintSurface *surface = pmd->canvas->surfaces.first;
1023               for (; surface; surface = surface->next) {
1024                 surface->color_dry_threshold = 1.0f;
1025                 surface->influence_scale = 1.0f;
1026                 surface->radius_scale = 1.0f;
1027                 surface->flags |= MOD_DPAINT_USE_DRYING;
1028               }
1029             }
1030           }
1031         }
1032       }
1033     }
1034   }
1035
1036   if (bmain->versionfile < 262) {
1037     Object *ob;
1038     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1039       ModifierData *md;
1040
1041       for (md = ob->modifiers.first; md; md = md->next) {
1042         if (md->type == eModifierType_Cloth) {
1043           ClothModifierData *clmd = (ClothModifierData *)md;
1044           if (clmd->sim_parms) {
1045             clmd->sim_parms->vel_damping = 1.0f;
1046           }
1047         }
1048       }
1049     }
1050   }
1051
1052   if (bmain->versionfile < 263) {
1053     /* set fluidsim rate. the version patch for this in 2.62 was wrong, so
1054      * try to correct it, if rate is 0.0 that's likely not intentional */
1055     Object *ob;
1056
1057     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1058       ModifierData *md;
1059       for (md = ob->modifiers.first; md; md = md->next) {
1060         if (md->type == eModifierType_Fluidsim) {
1061           FluidsimModifierData *fmd = (FluidsimModifierData *)md;
1062           if (fmd->fss->animRate == 0.0f) {
1063             fmd->fss->animRate = 1.0f;
1064           }
1065         }
1066       }
1067     }
1068   }
1069
1070   if (bmain->versionfile < 262 || (bmain->versionfile == 262 && bmain->subversionfile < 1)) {
1071     /* update use flags for node sockets (was only temporary before) */
1072     Scene *sce;
1073     bNodeTree *ntree;
1074
1075     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1076       if (sce->nodetree) {
1077         do_versions_nodetree_multi_file_output_format_2_62_1(sce, sce->nodetree);
1078       }
1079     }
1080
1081     /* XXX can't associate with scene for group nodes, image format will stay uninitialized */
1082     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1083       do_versions_nodetree_multi_file_output_format_2_62_1(NULL, ntree);
1084     }
1085   }
1086
1087   /* only swap for pre-release bmesh merge which had MLoopCol red/blue swap */
1088   if (bmain->versionfile == 262 && bmain->subversionfile == 1) {
1089     {
1090       Mesh *me;
1091       for (me = bmain->meshes.first; me; me = me->id.next) {
1092         do_versions_mesh_mloopcol_swap_2_62_1(me);
1093       }
1094     }
1095   }
1096
1097   if (bmain->versionfile < 262 || (bmain->versionfile == 262 && bmain->subversionfile < 2)) {
1098     /* Set new idname of keyingsets from their now "label-only" name. */
1099     Scene *scene;
1100     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1101       KeyingSet *ks;
1102       for (ks = scene->keyingsets.first; ks; ks = ks->next) {
1103         if (!ks->idname[0]) {
1104           BLI_strncpy(ks->idname, ks->name, sizeof(ks->idname));
1105         }
1106       }
1107     }
1108   }
1109
1110   if (bmain->versionfile < 262 || (bmain->versionfile == 262 && bmain->subversionfile < 3)) {
1111     Object *ob;
1112     ModifierData *md;
1113
1114     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1115       for (md = ob->modifiers.first; md; md = md->next) {
1116         if (md->type == eModifierType_Lattice) {
1117           LatticeModifierData *lmd = (LatticeModifierData *)md;
1118           lmd->strength = 1.0f;
1119         }
1120       }
1121     }
1122   }
1123
1124   if (bmain->versionfile < 262 || (bmain->versionfile == 262 && bmain->subversionfile < 4)) {
1125     /* Read Viscosity presets from older files */
1126     Object *ob;
1127
1128     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1129       ModifierData *md;
1130       for (md = ob->modifiers.first; md; md = md->next) {
1131         if (md->type == eModifierType_Fluidsim) {
1132           FluidsimModifierData *fmd = (FluidsimModifierData *)md;
1133           if (fmd->fss->viscosityMode == 3) {
1134             fmd->fss->viscosityValue = 5.0;
1135             fmd->fss->viscosityExponent = 5;
1136           }
1137           else if (fmd->fss->viscosityMode == 4) {
1138             fmd->fss->viscosityValue = 2.0;
1139             fmd->fss->viscosityExponent = 3;
1140           }
1141         }
1142       }
1143     }
1144   }
1145
1146   if (bmain->versionfile < 263) {
1147     /* Default for old files is to save particle rotations to pointcache */
1148     ParticleSettings *part;
1149     for (part = bmain->particles.first; part; part = part->id.next) {
1150       part->flag |= PART_ROTATIONS;
1151     }
1152   }
1153
1154   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 1)) {
1155     /* file output node paths are now stored in the file info struct instead socket name */
1156     Scene *sce;
1157     bNodeTree *ntree;
1158
1159     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1160       if (sce->nodetree) {
1161         do_versions_nodetree_multi_file_output_path_2_63_1(sce->nodetree);
1162       }
1163     }
1164     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1165       do_versions_nodetree_multi_file_output_path_2_63_1(ntree);
1166     }
1167   }
1168
1169   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 3)) {
1170     Scene *scene;
1171     Brush *brush;
1172
1173     /* For weight paint, each brush now gets its own weight;
1174      * unified paint settings also have weight. Update unified
1175      * paint settings and brushes with a default weight value. */
1176
1177     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1178       ToolSettings *ts = scene->toolsettings;
1179       if (ts) {
1180         ts->unified_paint_settings.weight = ts->vgroup_weight;
1181         ts->unified_paint_settings.flag |= UNIFIED_PAINT_WEIGHT;
1182       }
1183     }
1184
1185     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
1186       brush->weight = 0.5;
1187     }
1188   }
1189
1190   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 2)) {
1191     bScreen *screen;
1192
1193     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1194       ScrArea *area;
1195       for (area = screen->areabase.first; area; area = area->next) {
1196         SpaceLink *sl;
1197
1198         for (sl = area->spacedata.first; sl; sl = sl->next) {
1199           if (sl->spacetype == SPACE_CLIP) {
1200             SpaceClip *sclip = (SpaceClip *)sl;
1201             ARegion *region;
1202             bool hide = false;
1203
1204             for (region = area->regionbase.first; region; region = region->next) {
1205               if (region->regiontype == RGN_TYPE_PREVIEW) {
1206                 if (region->alignment != RGN_ALIGN_NONE) {
1207                   region->flag |= RGN_FLAG_HIDDEN;
1208                   region->v2d.flag &= ~V2D_IS_INITIALISED;
1209                   region->alignment = RGN_ALIGN_NONE;
1210
1211                   hide = true;
1212                 }
1213               }
1214             }
1215
1216             if (hide) {
1217               sclip->view = SC_VIEW_CLIP;
1218             }
1219           }
1220         }
1221       }
1222     }
1223   }
1224
1225   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 4)) {
1226     Camera *cam;
1227     Curve *cu;
1228
1229     for (cam = bmain->cameras.first; cam; cam = cam->id.next) {
1230       if (cam->flag & CAM_PANORAMA) {
1231         cam->type = CAM_PANO;
1232         cam->flag &= ~CAM_PANORAMA;
1233       }
1234     }
1235
1236     for (cu = bmain->curves.first; cu; cu = cu->id.next) {
1237       if (cu->bevfac2 == 0.0f) {
1238         cu->bevfac1 = 0.0f;
1239         cu->bevfac2 = 1.0f;
1240       }
1241     }
1242   }
1243
1244   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 5)) {
1245     {
1246       /* file output node paths are now stored in the file info struct instead socket name */
1247       Scene *sce;
1248       bNodeTree *ntree;
1249
1250       for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1251         if (sce->nodetree) {
1252           do_versions_nodetree_file_output_layers_2_64_5(sce->nodetree);
1253           do_versions_nodetree_image_layer_2_64_5(sce->nodetree);
1254         }
1255       }
1256       for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1257         do_versions_nodetree_file_output_layers_2_64_5(ntree);
1258         do_versions_nodetree_image_layer_2_64_5(ntree);
1259       }
1260     }
1261   }
1262
1263   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 6)) {
1264     /* update use flags for node sockets (was only temporary before) */
1265     Scene *sce;
1266     Material *mat;
1267     Tex *tex;
1268     World *world;
1269     bNodeTree *ntree;
1270
1271     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
1272       if (sce->nodetree) {
1273         do_versions_nodetree_frame_2_64_6(sce->nodetree);
1274       }
1275     }
1276
1277     for (mat = bmain->materials.first; mat; mat = mat->id.next) {
1278       if (mat->nodetree) {
1279         do_versions_nodetree_frame_2_64_6(mat->nodetree);
1280       }
1281     }
1282
1283     for (tex = bmain->textures.first; tex; tex = tex->id.next) {
1284       if (tex->nodetree) {
1285         do_versions_nodetree_frame_2_64_6(tex->nodetree);
1286       }
1287     }
1288
1289     for (Light *la = bmain->lights.first; la; la = la->id.next) {
1290       if (la->nodetree) {
1291         do_versions_nodetree_frame_2_64_6(la->nodetree);
1292       }
1293     }
1294
1295     for (world = bmain->worlds.first; world; world = world->id.next) {
1296       if (world->nodetree) {
1297         do_versions_nodetree_frame_2_64_6(world->nodetree);
1298       }
1299     }
1300
1301     for (ntree = bmain->nodetrees.first; ntree; ntree = ntree->id.next) {
1302       do_versions_nodetree_frame_2_64_6(ntree);
1303     }
1304   }
1305
1306   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 7)) {
1307     Object *ob;
1308
1309     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1310       ModifierData *md;
1311       for (md = ob->modifiers.first; md; md = md->next) {
1312         if (md->type == eModifierType_Fluid) {
1313           FluidModifierData *mmd = (FluidModifierData *)md;
1314           if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
1315             int maxres = max_iii(mmd->domain->res[0], mmd->domain->res[1], mmd->domain->res[2]);
1316             mmd->domain->scale = mmd->domain->dx * maxres;
1317             mmd->domain->dx = 1.0f / mmd->domain->scale;
1318           }
1319         }
1320       }
1321     }
1322   }
1323
1324   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 9)) {
1325     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1326       if (ntree->type == NTREE_SHADER) {
1327         bNode *node;
1328         for (node = ntree->nodes.first; node; node = node->next) {
1329           if (ELEM(node->type, SH_NODE_TEX_IMAGE, SH_NODE_TEX_ENVIRONMENT)) {
1330             NodeTexImage *tex = node->storage;
1331
1332             tex->iuser.frames = 1;
1333             tex->iuser.sfra = 1;
1334             tex->iuser.ok = 1;
1335           }
1336         }
1337       }
1338     }
1339     FOREACH_NODETREE_END;
1340   }
1341
1342   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 10)) {
1343     {
1344       Scene *scene;
1345       // composite redesign
1346       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1347         if (scene->nodetree) {
1348           if (scene->nodetree->chunksize == 0) {
1349             scene->nodetree->chunksize = 256;
1350           }
1351         }
1352       }
1353
1354       FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1355         if (ntree->type == NTREE_COMPOSIT) {
1356           bNode *node;
1357           for (node = ntree->nodes.first; node; node = node->next) {
1358             if (node->type == CMP_NODE_DEFOCUS) {
1359               NodeDefocus *data = node->storage;
1360               if (data->maxblur == 0.0f) {
1361                 data->maxblur = 16.0f;
1362               }
1363             }
1364           }
1365         }
1366       }
1367       FOREACH_NODETREE_END;
1368     }
1369
1370     {
1371       bScreen *screen;
1372
1373       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1374         ScrArea *area;
1375
1376         for (area = screen->areabase.first; area; area = area->next) {
1377           SpaceLink *sl;
1378
1379           for (sl = area->spacedata.first; sl; sl = sl->next) {
1380             if (sl->spacetype == SPACE_CLIP) {
1381               SpaceClip *sclip = (SpaceClip *)sl;
1382
1383               if (sclip->around == 0) {
1384                 sclip->around = V3D_AROUND_CENTER_MEDIAN;
1385               }
1386             }
1387           }
1388         }
1389       }
1390     }
1391
1392     {
1393       MovieClip *clip;
1394
1395       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
1396         clip->start_frame = 1;
1397       }
1398     }
1399   }
1400
1401   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 11)) {
1402     MovieClip *clip;
1403
1404     for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
1405       MovieTrackingTrack *track;
1406
1407       track = clip->tracking.tracks.first;
1408       while (track) {
1409         do_versions_affine_tracker_track(track);
1410
1411         track = track->next;
1412       }
1413     }
1414   }
1415
1416   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 13)) {
1417     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1418       if (ntree->type == NTREE_COMPOSIT) {
1419         bNode *node;
1420         for (node = ntree->nodes.first; node; node = node->next) {
1421           if (node->type == CMP_NODE_DILATEERODE) {
1422             if (node->storage == NULL) {
1423               NodeDilateErode *data = MEM_callocN(sizeof(NodeDilateErode), __func__);
1424               data->falloff = PROP_SMOOTH;
1425               node->storage = data;
1426             }
1427           }
1428         }
1429       }
1430     }
1431     FOREACH_NODETREE_END;
1432   }
1433
1434   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 14)) {
1435     ParticleSettings *part;
1436
1437     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1438       if (ntree->type == NTREE_COMPOSIT) {
1439         bNode *node;
1440         for (node = ntree->nodes.first; node; node = node->next) {
1441           if (node->type == CMP_NODE_KEYING) {
1442             NodeKeyingData *data = node->storage;
1443
1444             if (data->despill_balance == 0.0f) {
1445               data->despill_balance = 0.5f;
1446             }
1447           }
1448         }
1449       }
1450     }
1451     FOREACH_NODETREE_END;
1452
1453     /* keep compatibility for dupliobject particle size */
1454     for (part = bmain->particles.first; part; part = part->id.next) {
1455       if (ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) {
1456         if ((part->draw & PART_DRAW_ROTATE_OB) == 0) {
1457           part->draw |= PART_DRAW_NO_SCALE_OB;
1458         }
1459       }
1460     }
1461   }
1462
1463   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 17)) {
1464     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1465       if (ntree->type == NTREE_COMPOSIT) {
1466         bNode *node;
1467         for (node = ntree->nodes.first; node; node = node->next) {
1468           if (node->type == CMP_NODE_MASK) {
1469             if (node->storage == NULL) {
1470               NodeMask *data = MEM_callocN(sizeof(NodeMask), __func__);
1471               /* move settings into own struct */
1472               data->size_x = (int)node->custom3;
1473               data->size_y = (int)node->custom4;
1474               node->custom3 = 0.5f; /* default shutter */
1475               node->storage = data;
1476             }
1477           }
1478         }
1479       }
1480     }
1481     FOREACH_NODETREE_END;
1482   }
1483
1484   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 18)) {
1485     Scene *scene;
1486
1487     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1488       if (scene->ed) {
1489         Sequence *seq;
1490
1491         SEQ_BEGIN (scene->ed, seq) {
1492           Strip *strip = seq->strip;
1493
1494           if (strip && strip->color_balance) {
1495             SequenceModifierData *smd;
1496             ColorBalanceModifierData *cbmd;
1497
1498             smd = BKE_sequence_modifier_new(seq, NULL, seqModifierType_ColorBalance);
1499             cbmd = (ColorBalanceModifierData *)smd;
1500
1501             cbmd->color_balance = *strip->color_balance;
1502
1503             /* multiplication with color balance used is handled differently,
1504              * so we need to move multiplication to modifier so files would be
1505              * compatible
1506              */
1507             cbmd->color_multiply = seq->mul;
1508             seq->mul = 1.0f;
1509
1510             MEM_freeN(strip->color_balance);
1511             strip->color_balance = NULL;
1512           }
1513         }
1514         SEQ_END;
1515       }
1516     }
1517   }
1518
1519   /* color management pipeline changes compatibility code */
1520   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 19)) {
1521     Scene *scene;
1522     Image *ima;
1523     bool colormanagement_disabled = false;
1524
1525     /* make scenes which are not using color management have got None as display device,
1526      * so they wouldn't perform linear-to-sRGB conversion on display
1527      */
1528     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1529       if ((scene->r.color_mgt_flag & R_COLOR_MANAGEMENT) == 0) {
1530         ColorManagedDisplaySettings *display_settings = &scene->display_settings;
1531
1532         if (display_settings->display_device[0] == 0) {
1533           BKE_scene_disable_color_management(scene);
1534         }
1535
1536         colormanagement_disabled = true;
1537       }
1538     }
1539
1540     for (ima = bmain->images.first; ima; ima = ima->id.next) {
1541       if (ima->source == IMA_SRC_VIEWER) {
1542         ima->flag |= IMA_VIEW_AS_RENDER;
1543       }
1544       else if (colormanagement_disabled) {
1545         /* if color-management not used, set image's color space to raw, so no sRGB->linear
1546          * conversion would happen on display and render there's no clear way to check whether
1547          * color management is enabled or not in render engine so set all images to raw if there's
1548          * at least one scene with color management disabled this would still behave incorrect in
1549          * cases when color management was used for only some of scenes, but such a setup is
1550          * crazy anyway and think it's fair enough to break compatibility in that cases.
1551          */
1552
1553         BLI_strncpy(ima->colorspace_settings.name, "Raw", sizeof(ima->colorspace_settings.name));
1554       }
1555     }
1556   }
1557
1558   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 20)) {
1559     Key *key;
1560     for (key = bmain->shapekeys.first; key; key = key->id.next) {
1561       blo_do_versions_key_uidgen(key);
1562     }
1563   }
1564
1565   if (bmain->versionfile < 263 || (bmain->versionfile == 263 && bmain->subversionfile < 21)) {
1566     {
1567       Mesh *me;
1568       for (me = bmain->meshes.first; me; me = me->id.next) {
1569         CustomData_update_typemap(&me->vdata);
1570         CustomData_free_layers(&me->vdata, CD_MSTICKY, me->totvert);
1571       }
1572     }
1573   }
1574
1575   /* correction for files saved in blender version when BKE_pose_copy_data
1576    * didn't copy animation visualization, which lead to deadlocks on motion
1577    * path calculation for proxied armatures, see [#32742]
1578    */
1579   if (bmain->versionfile < 264) {
1580     Object *ob;
1581
1582     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1583       if (ob->pose) {
1584         if (ob->pose->avs.path_step == 0) {
1585           animviz_settings_init(&ob->pose->avs);
1586         }
1587       }
1588     }
1589   }
1590
1591   if (bmain->versionfile < 264 || (bmain->versionfile == 264 && bmain->subversionfile < 1)) {
1592     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1593       if (ntree->type == NTREE_SHADER) {
1594         bNode *node;
1595         for (node = ntree->nodes.first; node; node = node->next) {
1596           if (node->type == SH_NODE_TEX_COORD) {
1597             node->flag |= NODE_OPTIONS;
1598           }
1599         }
1600       }
1601     }
1602     FOREACH_NODETREE_END;
1603   }
1604
1605   if (bmain->versionfile < 264 || (bmain->versionfile == 264 && bmain->subversionfile < 2)) {
1606     MovieClip *clip;
1607
1608     for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
1609       MovieTracking *tracking = &clip->tracking;
1610       MovieTrackingObject *tracking_object;
1611
1612       for (tracking_object = tracking->objects.first; tracking_object;
1613            tracking_object = tracking_object->next) {
1614         if (tracking_object->keyframe1 == 0 && tracking_object->keyframe2 == 0) {
1615           tracking_object->keyframe1 = tracking->settings.keyframe1;
1616           tracking_object->keyframe2 = tracking->settings.keyframe2;
1617         }
1618       }
1619     }
1620   }
1621
1622   if (bmain->versionfile < 264 || (bmain->versionfile == 264 && bmain->subversionfile < 3)) {
1623     /* smoke branch */
1624     {
1625       Object *ob;
1626
1627       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1628         ModifierData *md;
1629         for (md = ob->modifiers.first; md; md = md->next) {
1630           if (md->type == eModifierType_Fluid) {
1631             FluidModifierData *mmd = (FluidModifierData *)md;
1632             if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
1633               /* keep branch saves if possible */
1634               if (!mmd->domain->flame_max_temp) {
1635                 mmd->domain->burning_rate = 0.75f;
1636                 mmd->domain->flame_smoke = 1.0f;
1637                 mmd->domain->flame_vorticity = 0.5f;
1638                 mmd->domain->flame_ignition = 1.25f;
1639                 mmd->domain->flame_max_temp = 1.75f;
1640                 mmd->domain->adapt_threshold = 0.02f;
1641                 mmd->domain->adapt_margin = 4;
1642                 mmd->domain->flame_smoke_color[0] = 0.7f;
1643                 mmd->domain->flame_smoke_color[1] = 0.7f;
1644                 mmd->domain->flame_smoke_color[2] = 0.7f;
1645               }
1646             }
1647             else if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
1648               if (!mmd->flow->texture_size) {
1649                 mmd->flow->fuel_amount = 1.0;
1650                 mmd->flow->surface_distance = 1.5;
1651                 mmd->flow->color[0] = 0.7f;
1652                 mmd->flow->color[1] = 0.7f;
1653                 mmd->flow->color[2] = 0.7f;
1654                 mmd->flow->texture_size = 1.0f;
1655               }
1656             }
1657           }
1658         }
1659       }
1660     }
1661
1662     /* render border for viewport */
1663     {
1664       bScreen *screen;
1665
1666       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1667         ScrArea *area;
1668         for (area = screen->areabase.first; area; area = area->next) {
1669           SpaceLink *sl;
1670           for (sl = area->spacedata.first; sl; sl = sl->next) {
1671             if (sl->spacetype == SPACE_VIEW3D) {
1672               View3D *v3d = (View3D *)sl;
1673               if (v3d->render_border.xmin == 0.0f && v3d->render_border.ymin == 0.0f &&
1674                   v3d->render_border.xmax == 0.0f && v3d->render_border.ymax == 0.0f) {
1675                 v3d->render_border.xmax = 1.0f;
1676                 v3d->render_border.ymax = 1.0f;
1677               }
1678             }
1679           }
1680         }
1681       }
1682     }
1683   }
1684
1685   if (bmain->versionfile < 264 || (bmain->versionfile == 264 && bmain->subversionfile < 5)) {
1686     /* set a unwrapping margin and ABF by default */
1687     Scene *scene;
1688
1689     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1690       if (scene->toolsettings->uvcalc_margin == 0.0f) {
1691         scene->toolsettings->uvcalc_margin = 0.001f;
1692         scene->toolsettings->unwrapper = 0;
1693       }
1694     }
1695   }
1696
1697   if (bmain->versionfile < 264 || (bmain->versionfile == 264 && bmain->subversionfile < 6)) {
1698     /* Fix for bug #32982, internal_links list could get corrupted from r51630 onward.
1699      * Simply remove bad internal_links lists to avoid NULL pointers.
1700      */
1701     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1702       bNode *node;
1703       bNodeLink *link, *nextlink;
1704
1705       for (node = ntree->nodes.first; node; node = node->next) {
1706         for (link = node->internal_links.first; link; link = nextlink) {
1707           nextlink = link->next;
1708           if (!link->fromnode || !link->fromsock || !link->tonode || !link->tosock) {
1709             BLI_remlink(&node->internal_links, link);
1710           }
1711         }
1712       }
1713     }
1714     FOREACH_NODETREE_END;
1715   }
1716
1717   if (bmain->versionfile < 264 || (bmain->versionfile == 264 && bmain->subversionfile < 7)) {
1718     /* convert tiles size from resolution and number of tiles */
1719     {
1720       Scene *scene;
1721
1722       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1723         if (scene->r.tilex == 0 || scene->r.tiley == 1) {
1724           scene->r.tilex = scene->r.tiley = 64;
1725         }
1726       }
1727     }
1728
1729     /* collision masks */
1730     {
1731       Object *ob;
1732       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
1733         if (ob->col_group == 0) {
1734           ob->col_group = 0x01;
1735           ob->col_mask = 0xff;
1736         }
1737       }
1738     }
1739   }
1740
1741   if (bmain->versionfile < 264 || (bmain->versionfile == 264 && bmain->subversionfile < 7)) {
1742     MovieClip *clip;
1743
1744     for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
1745       MovieTrackingTrack *track;
1746       MovieTrackingObject *object;
1747
1748       for (track = clip->tracking.tracks.first; track; track = track->next) {
1749         do_versions_affine_tracker_track(track);
1750       }
1751
1752       for (object = clip->tracking.objects.first; object; object = object->next) {
1753         for (track = object->tracks.first; track; track = track->next) {
1754           do_versions_affine_tracker_track(track);
1755         }
1756       }
1757     }
1758   }
1759
1760   if (bmain->versionfile < 265 || (bmain->versionfile == 265 && bmain->subversionfile < 3)) {
1761     bScreen *screen;
1762     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1763       ScrArea *area;
1764       for (area = screen->areabase.first; area; area = area->next) {
1765         SpaceLink *sl;
1766         for (sl = area->spacedata.first; sl; sl = sl->next) {
1767           switch (sl->spacetype) {
1768             case SPACE_VIEW3D: {
1769               View3D *v3d = (View3D *)sl;
1770               v3d->flag2 |= V3D_SHOW_ANNOTATION;
1771               break;
1772             }
1773             case SPACE_SEQ: {
1774               SpaceSeq *sseq = (SpaceSeq *)sl;
1775               sseq->flag |= SEQ_SHOW_GPENCIL;
1776               break;
1777             }
1778             case SPACE_IMAGE: {
1779               SpaceImage *sima = (SpaceImage *)sl;
1780               sima->flag |= SI_SHOW_GPENCIL;
1781               break;
1782             }
1783             case SPACE_NODE: {
1784               SpaceNode *snode = (SpaceNode *)sl;
1785               snode->flag |= SNODE_SHOW_GPENCIL;
1786               break;
1787             }
1788             case SPACE_CLIP: {
1789               SpaceClip *sclip = (SpaceClip *)sl;
1790               sclip->flag |= SC_SHOW_ANNOTATION;
1791               break;
1792             }
1793           }
1794         }
1795       }
1796     }
1797   }
1798
1799   if (bmain->versionfile < 265 || (bmain->versionfile == 265 && bmain->subversionfile < 5)) {
1800     Scene *scene;
1801     Tex *tex;
1802
1803     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
1804       Sequence *seq;
1805
1806       SEQ_BEGIN (scene->ed, seq) {
1807         enum { SEQ_MAKE_PREMUL = (1 << 6) };
1808         if (seq->flag & SEQ_MAKE_PREMUL) {
1809           seq->alpha_mode = SEQ_ALPHA_STRAIGHT;
1810         }
1811         else {
1812           BKE_sequence_alpha_mode_from_extension(seq);
1813         }
1814       }
1815       SEQ_END;
1816
1817       if (scene->r.bake_samples == 0) {
1818         scene->r.bake_samples = 256;
1819       }
1820     }
1821
1822     for (Image *image = bmain->images.first; image; image = image->id.next) {
1823       if (image->flag & IMA_DO_PREMUL) {
1824         image->alpha_mode = IMA_ALPHA_STRAIGHT;
1825       }
1826       else {
1827         BKE_image_alpha_mode_from_extension(image);
1828       }
1829     }
1830
1831     for (tex = bmain->textures.first; tex; tex = tex->id.next) {
1832       if (tex->type == TEX_IMAGE && (tex->imaflag & TEX_USEALPHA) == 0) {
1833         Image *image = blo_do_versions_newlibadr(fd, tex->id.lib, tex->ima);
1834
1835         if (image && (image->flag & IMA_DO_PREMUL) == 0) {
1836           const int IMA_IGNORE_ALPHA = (1 << 12);
1837           image->flag |= IMA_IGNORE_ALPHA;
1838         }
1839       }
1840     }
1841
1842     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1843       if (ntree->type == NTREE_COMPOSIT) {
1844         bNode *node;
1845         for (node = ntree->nodes.first; node; node = node->next) {
1846           if (node->type == CMP_NODE_IMAGE) {
1847             Image *image = blo_do_versions_newlibadr(fd, ntree->id.lib, node->id);
1848
1849             if (image) {
1850               if ((image->flag & IMA_DO_PREMUL) == 0 && image->alpha_mode == IMA_ALPHA_STRAIGHT) {
1851                 node->custom1 |= CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT;
1852               }
1853             }
1854           }
1855         }
1856       }
1857     }
1858     FOREACH_NODETREE_END;
1859   }
1860   else if (bmain->versionfile < 266 || (bmain->versionfile == 266 && bmain->subversionfile < 1)) {
1861     /* texture use alpha was removed for 2.66 but added back again for 2.66a,
1862      * for compatibility all textures assumed it to be enabled */
1863     Tex *tex;
1864
1865     for (tex = bmain->textures.first; tex; tex = tex->id.next) {
1866       if (tex->type == TEX_IMAGE) {
1867         tex->imaflag |= TEX_USEALPHA;
1868       }
1869     }
1870   }
1871
1872   if (bmain->versionfile < 265 || (bmain->versionfile == 265 && bmain->subversionfile < 7)) {
1873     Curve *cu;
1874
1875     for (cu = bmain->curves.first; cu; cu = cu->id.next) {
1876       if (cu->flag & (CU_FRONT | CU_BACK)) {
1877         if (cu->ext1 != 0.0f || cu->ext2 != 0.0f) {
1878           Nurb *nu;
1879
1880           for (nu = cu->nurb.first; nu; nu = nu->next) {
1881             int a;
1882
1883             if (nu->bezt) {
1884               BezTriple *bezt = nu->bezt;
1885               a = nu->pntsu;
1886
1887               while (a--) {
1888                 bezt->radius = 1.0f;
1889                 bezt++;
1890               }
1891             }
1892             else if (nu->bp) {
1893               BPoint *bp = nu->bp;
1894               a = nu->pntsu * nu->pntsv;
1895
1896               while (a--) {
1897                 bp->radius = 1.0f;
1898                 bp++;
1899               }
1900             }
1901           }
1902         }
1903       }
1904     }
1905   }
1906
1907   if (MAIN_VERSION_OLDER(bmain, 265, 9)) {
1908     Mesh *me;
1909     for (me = bmain->meshes.first; me; me = me->id.next) {
1910       BKE_mesh_do_versions_cd_flag_init(me);
1911     }
1912   }
1913
1914   if (MAIN_VERSION_OLDER(bmain, 265, 10)) {
1915     Brush *br;
1916     for (br = bmain->brushes.first; br; br = br->id.next) {
1917       if (br->ob_mode & OB_MODE_TEXTURE_PAINT) {
1918         br->mtex.brush_map_mode = MTEX_MAP_MODE_TILED;
1919       }
1920     }
1921   }
1922
1923   // add storage for compositor translate nodes when not existing
1924   if (MAIN_VERSION_OLDER(bmain, 265, 11)) {
1925     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1926       if (ntree->type == NTREE_COMPOSIT) {
1927         bNode *node;
1928         for (node = ntree->nodes.first; node; node = node->next) {
1929           if (node->type == CMP_NODE_TRANSLATE && node->storage == NULL) {
1930             node->storage = MEM_callocN(sizeof(NodeTranslateData), "node translate data");
1931           }
1932         }
1933       }
1934     }
1935     FOREACH_NODETREE_END;
1936   }
1937
1938   if (MAIN_VERSION_OLDER(bmain, 266, 2)) {
1939     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1940       do_versions_nodetree_customnodes(ntree, ((ID *)ntree == id));
1941     }
1942     FOREACH_NODETREE_END;
1943   }
1944
1945   if (MAIN_VERSION_OLDER(bmain, 266, 2)) {
1946     bScreen *screen;
1947     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
1948       ScrArea *area;
1949       for (area = screen->areabase.first; area; area = area->next) {
1950         SpaceLink *sl;
1951         for (sl = area->spacedata.first; sl; sl = sl->next) {
1952           if (sl->spacetype == SPACE_NODE) {
1953             SpaceNode *snode = (SpaceNode *)sl;
1954
1955             /* reset pointers to force tree path update from context */
1956             snode->nodetree = NULL;
1957             snode->edittree = NULL;
1958             snode->id = NULL;
1959             snode->from = NULL;
1960
1961             /* convert deprecated treetype setting to tree_idname */
1962             switch (snode->treetype) {
1963               case NTREE_COMPOSIT:
1964                 strcpy(snode->tree_idname, "CompositorNodeTree");
1965                 break;
1966               case NTREE_SHADER:
1967                 strcpy(snode->tree_idname, "ShaderNodeTree");
1968                 break;
1969               case NTREE_TEXTURE:
1970                 strcpy(snode->tree_idname, "TextureNodeTree");
1971                 break;
1972             }
1973           }
1974         }
1975       }
1976     }
1977   }
1978
1979   if (MAIN_VERSION_OLDER(bmain, 266, 3)) {
1980     {
1981       /* Fix for a very old issue:
1982        * Node names were nominally made unique in r24478 (2.50.8), but the do_versions check
1983        * to update existing node names only applied to bmain->nodetree (i.e. group nodes).
1984        * Uniqueness is now required for proper preview mapping,
1985        * so do this now to ensure old files don't break.
1986        */
1987       bNode *node;
1988       FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1989         if (id == &ntree->id) {
1990           continue; /* already fixed for node groups */
1991         }
1992
1993         for (node = ntree->nodes.first; node; node = node->next) {
1994           nodeUniqueName(ntree, node);
1995         }
1996       }
1997       FOREACH_NODETREE_END;
1998     }
1999   }
2000
2001   if (!MAIN_VERSION_ATLEAST(bmain, 266, 4)) {
2002     Brush *brush;
2003     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
2004       BKE_texture_mtex_default(&brush->mask_mtex);
2005
2006       if (brush->ob_mode & OB_MODE_TEXTURE_PAINT) {
2007         brush->spacing /= 2;
2008       }
2009     }
2010   }
2011
2012   if (!MAIN_VERSION_ATLEAST(bmain, 266, 6)) {
2013     Brush *brush;
2014 #define BRUSH_TEXTURE_OVERLAY (1 << 21)
2015
2016     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
2017       brush->overlay_flags = 0;
2018       if (brush->flag & BRUSH_TEXTURE_OVERLAY) {
2019         brush->overlay_flags |= (BRUSH_OVERLAY_PRIMARY | BRUSH_OVERLAY_CURSOR);
2020       }
2021     }
2022 #undef BRUSH_TEXTURE_OVERLAY
2023   }
2024
2025   if (bmain->versionfile < 267) {
2026     // if (!DNA_struct_elem_find(fd->filesdna, "Brush", "int", "stencil_pos")) {
2027     Brush *brush;
2028
2029     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
2030       if (brush->stencil_dimension[0] == 0) {
2031         brush->stencil_dimension[0] = 256;
2032         brush->stencil_dimension[1] = 256;
2033         brush->stencil_pos[0] = 256;
2034         brush->stencil_pos[1] = 256;
2035       }
2036       if (brush->mask_stencil_dimension[0] == 0) {
2037         brush->mask_stencil_dimension[0] = 256;
2038         brush->mask_stencil_dimension[1] = 256;
2039         brush->mask_stencil_pos[0] = 256;
2040         brush->mask_stencil_pos[1] = 256;
2041       }
2042     }
2043
2044     /* TIP: to initialize new variables added, use the new function
2045      * DNA_struct_elem_find(fd->filesdna, "structname", "typename", "varname")
2046      * example:
2047      * if (!DNA_struct_elem_find(fd->filesdna, "UserDef", "short", "image_gpubuffer_limit"))
2048      *     user->image_gpubuffer_limit = 10;
2049      */
2050   }
2051
2052   /* default values in Freestyle settings */
2053   if (bmain->versionfile < 267) {
2054     Scene *sce;
2055     SceneRenderLayer *srl;
2056     FreestyleLineStyle *linestyle;
2057
2058     for (sce = bmain->scenes.first; sce; sce = sce->id.next) {
2059       if (sce->r.line_thickness_mode == 0) {
2060         sce->r.line_thickness_mode = R_LINE_THICKNESS_ABSOLUTE;
2061         sce->r.unit_line_thickness = 1.0f;
2062       }
2063       for (srl = sce->r.layers.first; srl; srl = srl->next) {
2064         if (srl->freestyleConfig.mode == 0) {
2065           srl->freestyleConfig.mode = FREESTYLE_CONTROL_EDITOR_MODE;
2066         }
2067         if (srl->freestyleConfig.raycasting_algorithm ==
2068                 FREESTYLE_ALGO_CULLED_ADAPTIVE_CUMULATIVE ||
2069             srl->freestyleConfig.raycasting_algorithm ==
2070                 FREESTYLE_ALGO_CULLED_ADAPTIVE_TRADITIONAL) {
2071           srl->freestyleConfig.raycasting_algorithm = 0; /* deprecated */
2072           srl->freestyleConfig.flags |= FREESTYLE_CULLING;
2073         }
2074       }
2075
2076       /* not freestyle */
2077       {
2078         MeshStatVis *statvis = &sce->toolsettings->statvis;
2079         if (statvis->thickness_samples == 0) {
2080           statvis->overhang_axis = OB_NEGZ;
2081           statvis->overhang_min = 0;
2082           statvis->overhang_max = DEG2RADF(45.0f);
2083
2084           statvis->thickness_max = 0.1f;
2085           statvis->thickness_samples = 1;
2086
2087           statvis->distort_min = DEG2RADF(5.0f);
2088           statvis->distort_max = DEG2RADF(45.0f);
2089
2090           statvis->sharp_min = DEG2RADF(90.0f);
2091           statvis->sharp_max = DEG2RADF(180.0f);
2092         }
2093       }
2094     }
2095     for (linestyle = bmain->linestyles.first; linestyle; linestyle = linestyle->id.next) {
2096 #if 1
2097       /* disable the Misc panel for now */
2098       if (linestyle->panel == LS_PANEL_MISC) {
2099         linestyle->panel = LS_PANEL_STROKES;
2100       }
2101 #endif
2102       if (linestyle->thickness_position == 0) {
2103         linestyle->thickness_position = LS_THICKNESS_CENTER;
2104         linestyle->thickness_ratio = 0.5f;
2105       }
2106       if (linestyle->chaining == 0) {
2107         linestyle->chaining = LS_CHAINING_PLAIN;
2108       }
2109       if (linestyle->rounds == 0) {
2110         linestyle->rounds = 3;
2111       }
2112     }
2113   }
2114
2115   if (bmain->versionfile < 267) {
2116     /* Initialize the active_viewer_key for compositing */
2117     bScreen *screen;
2118     Scene *scene;
2119     bNodeInstanceKey active_viewer_key = {0};
2120     /* simply pick the first node space and use that for the active viewer key */
2121     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2122       ScrArea *area;
2123       for (area = screen->areabase.first; area; area = area->next) {
2124         SpaceLink *sl;
2125         for (sl = area->spacedata.first; sl; sl = sl->next) {
2126           if (sl->spacetype == SPACE_NODE) {
2127             SpaceNode *snode = (SpaceNode *)sl;
2128             bNodeTreePath *path = snode->treepath.last;
2129             if (!path) {
2130               continue;
2131             }
2132
2133             active_viewer_key = path->parent_key;
2134             break;
2135           }
2136         }
2137         if (active_viewer_key.value != 0) {
2138           break;
2139         }
2140       }
2141       if (active_viewer_key.value != 0) {
2142         break;
2143       }
2144     }
2145
2146     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
2147       /* NB: scene->nodetree is a local ID block, has been direct_link'ed */
2148       if (scene->nodetree) {
2149         scene->nodetree->active_viewer_key = active_viewer_key;
2150       }
2151     }
2152   }
2153
2154   if (MAIN_VERSION_OLDER(bmain, 267, 1)) {
2155     Object *ob;
2156
2157     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2158       ModifierData *md;
2159       for (md = ob->modifiers.first; md; md = md->next) {
2160         if (md->type == eModifierType_Fluid) {
2161           FluidModifierData *mmd = (FluidModifierData *)md;
2162           if ((mmd->type & MOD_FLUID_TYPE_DOMAIN) && mmd->domain) {
2163             if (mmd->domain->flags & FLUID_DOMAIN_USE_HIGH_SMOOTH) {
2164               mmd->domain->highres_sampling = SM_HRES_LINEAR;
2165             }
2166             else {
2167               mmd->domain->highres_sampling = SM_HRES_NEAREST;
2168             }
2169           }
2170         }
2171       }
2172     }
2173   }
2174
2175   if (!MAIN_VERSION_ATLEAST(bmain, 268, 1)) {
2176     Brush *brush;
2177     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
2178       brush->spacing = MAX2(1, brush->spacing);
2179     }
2180   }
2181
2182   if (!MAIN_VERSION_ATLEAST(bmain, 268, 2)) {
2183     Brush *brush;
2184 #define BRUSH_FIXED (1 << 6)
2185     for (brush = bmain->brushes.first; brush; brush = brush->id.next) {
2186       brush->flag &= ~BRUSH_FIXED;
2187
2188       if (brush->cursor_overlay_alpha < 2) {
2189         brush->cursor_overlay_alpha = 33;
2190       }
2191       if (brush->texture_overlay_alpha < 2) {
2192         brush->texture_overlay_alpha = 33;
2193       }
2194       if (brush->mask_overlay_alpha < 2) {
2195         brush->mask_overlay_alpha = 33;
2196       }
2197     }
2198 #undef BRUSH_FIXED
2199   }
2200
2201   if (!MAIN_VERSION_ATLEAST(bmain, 268, 4)) {
2202     bScreen *screen;
2203     Object *ob;
2204
2205     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2206       bConstraint *con;
2207       for (con = ob->constraints.first; con; con = con->next) {
2208         if (con->type == CONSTRAINT_TYPE_SHRINKWRAP) {
2209           bShrinkwrapConstraint *data = (bShrinkwrapConstraint *)con->data;
2210           if (data->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS) {
2211             data->projAxis = OB_POSX;
2212           }
2213           else if (data->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS) {
2214             data->projAxis = OB_POSY;
2215           }
2216           else {
2217             data->projAxis = OB_POSZ;
2218           }
2219           data->projAxisSpace = CONSTRAINT_SPACE_LOCAL;
2220         }
2221       }
2222     }
2223
2224     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2225       ModifierData *md;
2226       for (md = ob->modifiers.first; md; md = md->next) {
2227         if (md->type == eModifierType_Fluid) {
2228           FluidModifierData *mmd = (FluidModifierData *)md;
2229           if ((mmd->type & MOD_FLUID_TYPE_FLOW) && mmd->flow) {
2230             if (!mmd->flow->particle_size) {
2231               mmd->flow->particle_size = 1.0f;
2232             }
2233           }
2234         }
2235       }
2236     }
2237
2238     /*
2239      * FIX some files have a zoom level of 0, and was checked during the drawing of the node space
2240      *
2241      * We moved this check to the do versions to be sure the value makes any sense.
2242      */
2243     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2244       ScrArea *area;
2245       for (area = screen->areabase.first; area; area = area->next) {
2246         SpaceLink *sl;
2247         for (sl = area->spacedata.first; sl; sl = sl->next) {
2248           if (sl->spacetype == SPACE_NODE) {
2249             SpaceNode *snode = (SpaceNode *)sl;
2250             if (snode->zoom < 0.02f) {
2251               snode->zoom = 1.0;
2252             }
2253           }
2254         }
2255       }
2256     }
2257   }
2258
2259   if (!MAIN_VERSION_ATLEAST(bmain, 268, 5)) {
2260     bScreen *screen;
2261     ScrArea *area;
2262
2263     /* add missing (+) expander in node editor */
2264     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2265       for (area = screen->areabase.first; area; area = area->next) {
2266         ARegion *region, *arnew;
2267
2268         if (area->spacetype == SPACE_NODE) {
2269           region = BKE_area_find_region_type(area, RGN_TYPE_TOOLS);
2270
2271           if (region) {
2272             continue;
2273           }
2274
2275           /* add subdiv level; after header */
2276           region = BKE_area_find_region_type(area, RGN_TYPE_HEADER);
2277
2278           /* is error! */
2279           if (region == NULL) {
2280             continue;
2281           }
2282
2283           arnew = MEM_callocN(sizeof(ARegion), "node tools");
2284
2285           BLI_insertlinkafter(&area->regionbase, region, arnew);
2286           arnew->regiontype = RGN_TYPE_TOOLS;
2287           arnew->alignment = RGN_ALIGN_LEFT;
2288
2289           arnew->flag = RGN_FLAG_HIDDEN;
2290         }
2291       }
2292     }
2293   }
2294
2295   if (!MAIN_VERSION_ATLEAST(bmain, 269, 1)) {
2296     /* Removal of Cycles SSS Compatible falloff */
2297     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2298       if (ntree->type == NTREE_SHADER) {
2299         bNode *node;
2300         for (node = ntree->nodes.first; node; node = node->next) {
2301           if (node->type == SH_NODE_SUBSURFACE_SCATTERING) {
2302             if (node->custom1 == SHD_SUBSURFACE_COMPATIBLE) {
2303               node->custom1 = SHD_SUBSURFACE_CUBIC;
2304             }
2305           }
2306         }
2307       }
2308     }
2309     FOREACH_NODETREE_END;
2310   }
2311
2312   if (!MAIN_VERSION_ATLEAST(bmain, 269, 2)) {
2313     /* Initialize CDL settings for Color Balance nodes */
2314     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2315       if (ntree->type == NTREE_COMPOSIT) {
2316         bNode *node;
2317         for (node = ntree->nodes.first; node; node = node->next) {
2318           if (node->type == CMP_NODE_COLORBALANCE) {
2319             NodeColorBalance *n = node->storage;
2320             if (node->custom1 == 0) {
2321               /* LGG mode stays the same, just init CDL settings */
2322               ntreeCompositColorBalanceSyncFromLGG(ntree, node);
2323             }
2324             else if (node->custom1 == 1) {
2325               /* CDL previously used same variables as LGG, copy them over
2326                * and then sync LGG for comparable results in both modes.
2327                */
2328               copy_v3_v3(n->offset, n->lift);
2329               copy_v3_v3(n->power, n->gamma);
2330               copy_v3_v3(n->slope, n->gain);
2331               ntreeCompositColorBalanceSyncFromCDL(ntree, node);
2332             }
2333           }
2334         }
2335       }
2336     }
2337     FOREACH_NODETREE_END;
2338   }
2339
2340   if (!MAIN_VERSION_ATLEAST(bmain, 269, 3)) {
2341     bScreen *screen;
2342     ScrArea *area;
2343     SpaceLink *sl;
2344     Scene *scene;
2345
2346     /* Update files using invalid (outdated) outlinevis Outliner values. */
2347     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2348       for (area = screen->areabase.first; area; area = area->next) {
2349         for (sl = area->spacedata.first; sl; sl = sl->next) {
2350           if (sl->spacetype == SPACE_OUTLINER) {
2351             SpaceOutliner *so = (SpaceOutliner *)sl;
2352
2353             if (!ELEM(so->outlinevis, SO_SCENES, SO_LIBRARIES, SO_SEQUENCE, SO_DATA_API)) {
2354               so->outlinevis = SO_SCENES;
2355             }
2356           }
2357         }
2358       }
2359     }
2360
2361     if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingTrack", "float", "weight")) {
2362       MovieClip *clip;
2363       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
2364         MovieTracking *tracking = &clip->tracking;
2365         MovieTrackingObject *tracking_object;
2366         for (tracking_object = tracking->objects.first; tracking_object;
2367              tracking_object = tracking_object->next) {
2368           ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
2369           MovieTrackingTrack *track;
2370           for (track = tracksbase->first; track; track = track->next) {
2371             track->weight = 1.0f;
2372           }
2373         }
2374       }
2375     }
2376
2377     if (!DNA_struct_elem_find(fd->filesdna, "TriangulateModifierData", "int", "quad_method")) {
2378       Object *ob;
2379       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2380         ModifierData *md;
2381         for (md = ob->modifiers.first; md; md = md->next) {
2382           if (md->type == eModifierType_Triangulate) {
2383             TriangulateModifierData *tmd = (TriangulateModifierData *)md;
2384             if ((tmd->flag & MOD_TRIANGULATE_BEAUTY)) {
2385               tmd->quad_method = MOD_TRIANGULATE_QUAD_BEAUTY;
2386               tmd->ngon_method = MOD_TRIANGULATE_NGON_BEAUTY;
2387             }
2388             else {
2389               tmd->quad_method = MOD_TRIANGULATE_QUAD_FIXED;
2390               tmd->ngon_method = MOD_TRIANGULATE_NGON_EARCLIP;
2391             }
2392           }
2393         }
2394       }
2395     }
2396
2397     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
2398       /* this can now be turned off */
2399       ToolSettings *ts = scene->toolsettings;
2400       if (ts->sculpt) {
2401         ts->sculpt->flags |= SCULPT_DYNTOPO_SUBDIVIDE;
2402       }
2403
2404       /* 'Increment' mode disabled for nodes, use true grid snapping instead */
2405       if (scene->toolsettings->snap_node_mode == SCE_SNAP_MODE_INCREMENT) {
2406         scene->toolsettings->snap_node_mode = SCE_SNAP_MODE_GRID;
2407       }
2408
2409 #ifdef WITH_FFMPEG
2410       /* Update for removed "sound-only" option in FFMPEG export settings. */
2411       if (scene->r.ffcodecdata.type >= FFMPEG_INVALID) {
2412         scene->r.ffcodecdata.type = FFMPEG_AVI;
2413       }
2414 #endif
2415     }
2416   }
2417
2418   if (!MAIN_VERSION_ATLEAST(bmain, 269, 4)) {
2419     /* Internal degrees to radians conversions... */
2420     {
2421       Scene *scene;
2422       Object *ob;
2423
2424       for (Light *la = bmain->lights.first; la; la = la->id.next) {
2425         la->spotsize = DEG2RADF(la->spotsize);
2426       }
2427
2428       for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2429         ModifierData *md;
2430
2431         for (md = ob->modifiers.first; md; md = md->next) {
2432           if (md->type == eModifierType_EdgeSplit) {
2433             EdgeSplitModifierData *emd = (EdgeSplitModifierData *)md;
2434             emd->split_angle = DEG2RADF(emd->split_angle);
2435           }
2436           else if (md->type == eModifierType_Bevel) {
2437             BevelModifierData *bmd = (BevelModifierData *)md;
2438             bmd->bevel_angle = DEG2RADF(bmd->bevel_angle);
2439           }
2440         }
2441       }
2442
2443       for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
2444         Sequence *seq;
2445         SEQ_BEGIN (scene->ed, seq) {
2446           if (seq->type == SEQ_TYPE_WIPE) {
2447             WipeVars *wv = seq->effectdata;
2448             wv->angle = DEG2RADF(wv->angle);
2449           }
2450         }
2451         SEQ_END;
2452       }
2453
2454       FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2455         if (ntree->type == NTREE_COMPOSIT) {
2456           bNode *node;
2457           for (node = ntree->nodes.first; node; node = node->next) {
2458             if (node->type == CMP_NODE_BOKEHIMAGE) {
2459               NodeBokehImage *n = node->storage;
2460               n->angle = DEG2RADF(n->angle);
2461             }
2462             if (node->type == CMP_NODE_MASK_BOX) {
2463               NodeBoxMask *n = node->storage;
2464               n->rotation = DEG2RADF(n->rotation);
2465             }
2466             if (node->type == CMP_NODE_MASK_ELLIPSE) {
2467               NodeEllipseMask *n = node->storage;
2468               n->rotation = DEG2RADF(n->rotation);
2469             }
2470           }
2471         }
2472       }
2473       FOREACH_NODETREE_END;
2474     }
2475
2476     if (!DNA_struct_elem_find(fd->filesdna, "MovieTrackingPlaneTrack", "float", "image_opacity")) {
2477       MovieClip *clip;
2478       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
2479         MovieTrackingPlaneTrack *plane_track;
2480         for (plane_track = clip->tracking.plane_tracks.first; plane_track;
2481              plane_track = plane_track->next) {
2482           plane_track->image_opacity = 1.0f;
2483         }
2484       }
2485     }
2486   }
2487
2488   if (!MAIN_VERSION_ATLEAST(bmain, 269, 7)) {
2489     Scene *scene;
2490     for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
2491       Sculpt *sd = scene->toolsettings->sculpt;
2492
2493       if (sd) {
2494         enum {
2495           SCULPT_SYMM_X = (1 << 0),
2496           SCULPT_SYMM_Y = (1 << 1),
2497           SCULPT_SYMM_Z = (1 << 2),
2498           SCULPT_SYMMETRY_FEATHER = (1 << 6),
2499         };
2500         int symmetry_flags = sd->flags & 7;
2501
2502         if (symmetry_flags & SCULPT_SYMM_X) {
2503           sd->paint.symmetry_flags |= PAINT_SYMM_X;
2504         }
2505         if (symmetry_flags & SCULPT_SYMM_Y) {
2506           sd->paint.symmetry_flags |= PAINT_SYMM_Y;
2507         }
2508         if (symmetry_flags & SCULPT_SYMM_Z) {
2509           sd->paint.symmetry_flags |= PAINT_SYMM_Z;
2510         }
2511         if (symmetry_flags & SCULPT_SYMMETRY_FEATHER) {
2512           sd->paint.symmetry_flags |= PAINT_SYMMETRY_FEATHER;
2513         }
2514       }
2515     }
2516   }
2517
2518   if (!MAIN_VERSION_ATLEAST(bmain, 269, 8)) {
2519     Curve *cu;
2520
2521     for (cu = bmain->curves.first; cu; cu = cu->id.next) {
2522       if (cu->str) {
2523         cu->len_wchar = BLI_strlen_utf8(cu->str);
2524       }
2525     }
2526   }
2527
2528   if (!MAIN_VERSION_ATLEAST(bmain, 269, 9)) {
2529     Object *ob;
2530
2531     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
2532       ModifierData *md;
2533       for (md = ob->modifiers.first; md; md = md->next) {
2534         if (md->type == eModifierType_Build) {
2535           BuildModifierData *bmd = (BuildModifierData *)md;
2536           if (bmd->randomize) {
2537             bmd->flag |= MOD_BUILD_FLAG_RANDOMIZE;
2538           }
2539         }
2540       }
2541     }
2542   }
2543
2544   if (!MAIN_VERSION_ATLEAST(bmain, 269, 11)) {
2545     bScreen *screen;
2546
2547     for (screen = bmain->screens.first; screen; screen = screen->id.next) {
2548       ScrArea *area;
2549       for (area = screen->areabase.first; area; area = area->next) {
2550         SpaceLink *space_link;
2551
2552         for (space_link = area->spacedata.first; space_link; space_link = space_link->next) {
2553           if (space_link->spacetype == SPACE_IMAGE) {
2554             ARegion *region;
2555             ListBase *lb;
2556
2557             if (space_link == area->spacedata.first) {
2558               lb = &area->regionbase;
2559             }
2560             else {
2561               lb = &space_link->regionbase;
2562             }
2563
2564             for (region = lb->first; region; region = region->next) {
2565               if (region->regiontype == RGN_TYPE_PREVIEW) {
2566                 region->regiontype = RGN_TYPE_TOOLS;
2567                 region->alignment = RGN_ALIGN_LEFT;
2568               }
2569               else if (region->regiontype == RGN_TYPE_UI) {
2570                 region->alignment = RGN_ALIGN_RIGHT;
2571               }
2572             }
2573           }
2574         }
2575       }
2576     }
2577   }
2578 }
2579
2580 void do_versions_after_linking_260(Main *bmain)
2581 {
2582   /* Convert the previously used ntree->inputs/ntree->outputs lists to interface nodes.
2583    * Pre 2.56.2 node trees automatically have all unlinked sockets exposed already,
2584    * see do_versions_after_linking_250.
2585    *
2586    * This assumes valid typeinfo pointers, as set in lib_link_ntree.
2587    *
2588    * Note: theoretically only needed in node groups (main->nodetree),
2589    * but due to a temporary bug such links could have been added in all trees,
2590    * so have to clean up all of them ...
2591    *
2592    * Note: this always runs, without it links with NULL fromnode and tonode remain
2593    * which causes problems.
2594    */
2595   if (!MAIN_VERSION_ATLEAST(bmain, 266, 3)) {
2596     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2597       bNode *input_node = NULL, *output_node = NULL;
2598       int num_inputs = 0, num_outputs = 0;
2599       bNodeLink *link, *next_link;
2600       /* Only create new interface nodes for actual older files.
2601        * New file versions already have input/output nodes with duplicate links,
2602        * in that case just remove the invalid links.
2603        */
2604       const bool create_io_nodes = MAIN_VERSION_OLDER(bmain, 266, 2);
2605
2606       float input_locx = 1000000.0f, input_locy = 0.0f;
2607       float output_locx = -1000000.0f, output_locy = 0.0f;
2608       /* rough guess, not nice but we don't have access to UI constants here ... */
2609       static const float offsetx = 42 + 3 * 20 + 20;
2610       /*static const float offsety = 0.0f;*/
2611
2612       if (create_io_nodes) {
2613         if (ntree->inputs.first) {
2614           input_node = nodeAddStaticNode(NULL, ntree, NODE_GROUP_INPUT);
2615         }
2616
2617         if (ntree->outputs.first) {
2618           output_node = nodeAddStaticNode(NULL, ntree, NODE_GROUP_OUTPUT);
2619         }
2620       }
2621
2622       /* Redirect links from/to the node tree interface to input/output node.
2623        * If the fromnode/tonode pointers are NULL, this means a link from/to
2624        * the ntree interface sockets, which need to be redirected to new interface nodes.
2625        */
2626       for (link = ntree->links.first; link; link = next_link) {
2627         bool free_link = false;
2628         next_link = link->next;
2629
2630         if (link->fromnode == NULL) {
2631           if (input_node) {
2632             link->fromnode = input_node;
2633             link->fromsock = node_group_input_find_socket(input_node, link->fromsock->identifier);
2634             num_inputs++;
2635
2636             if (link->tonode) {
2637               if (input_locx > link->tonode->locx - offsetx) {
2638                 input_locx = link->tonode->locx - offsetx;
2639               }
2640               input_locy += link->tonode->locy;
2641             }
2642           }
2643           else {
2644             free_link = true;
2645           }
2646         }
2647
2648         if (link->tonode == NULL) {
2649           if (output_node) {
2650             link->tonode = output_node;
2651             link->tosock = node_group_output_find_socket(output_node, link->tosock->identifier);
2652             num_outputs++;
2653
2654             if (link->fromnode) {
2655               if (output_locx < link->fromnode->locx + offsetx) {
2656                 output_locx = link->fromnode->locx + offsetx;
2657               }
2658               output_locy += link->fromnode->locy;
2659             }
2660           }
2661           else {
2662             free_link = true;
2663           }
2664         }
2665
2666         if (free_link) {
2667           nodeRemLink(ntree, link);
2668         }
2669       }
2670
2671       if (num_inputs > 0) {
2672         input_locy /= num_inputs;
2673         input_node->locx = input_locx;
2674         input_node->locy = input_locy;
2675       }
2676       if (num_outputs > 0) {
2677         output_locy /= num_outputs;
2678         output_node->locx = output_locx;
2679         output_node->locy = output_locy;
2680       }
2681     }
2682     FOREACH_NODETREE_END;
2683   }
2684
2685   if (!MAIN_VERSION_ATLEAST(bmain, 280, 60)) {
2686     /* From this point we no longer write incomplete links for forward
2687      * compatibility with 2.66, we have to clean them up for all previous
2688      * versions. */
2689     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
2690       bNodeLink *link, *next_link;
2691
2692       for (link = ntree->links.first; link; link = next_link) {
2693         next_link = link->next;
2694         if (link->fromnode == NULL || link->tonode == NULL) {
2695           nodeRemLink(ntree, link);
2696         }
2697       }
2698     }
2699     FOREACH_NODETREE_END;
2700   }
2701 }