CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / blenloader / intern / versioning_cycles.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 /* allow readfile to use deprecated functionality */
22 #define DNA_DEPRECATED_ALLOW
23
24 #include <float.h>
25 #include <string.h>
26
27 #include "BLI_listbase.h"
28 #include "BLI_math.h"
29 #include "BLI_string.h"
30 #include "BLI_utildefines.h"
31
32 #include "DNA_anim_types.h"
33 #include "DNA_camera_types.h"
34 #include "DNA_color_types.h"
35 #include "DNA_light_types.h"
36 #include "DNA_node_types.h"
37 #include "DNA_particle_types.h"
38
39 #include "BKE_animsys.h"
40 #include "BKE_colortools.h"
41 #include "BKE_idprop.h"
42 #include "BKE_main.h"
43 #include "BKE_node.h"
44
45 #include "MEM_guardedalloc.h"
46
47 #include "IMB_colormanagement.h"
48
49 #include "BLO_readfile.h"
50 #include "readfile.h"
51
52 static bool socket_is_used(bNodeSocket *sock)
53 {
54   return sock->flag & SOCK_IN_USE;
55 }
56
57 static float *cycles_node_socket_float_value(bNodeSocket *socket)
58 {
59   bNodeSocketValueFloat *socket_data = socket->default_value;
60   return &socket_data->value;
61 }
62
63 static float *cycles_node_socket_rgba_value(bNodeSocket *socket)
64 {
65   bNodeSocketValueRGBA *socket_data = socket->default_value;
66   return socket_data->value;
67 }
68
69 static float *cycles_node_socket_vector_value(bNodeSocket *socket)
70 {
71   bNodeSocketValueVector *socket_data = socket->default_value;
72   return socket_data->value;
73 }
74
75 static IDProperty *cycles_properties_from_ID(ID *id)
76 {
77   IDProperty *idprop = IDP_GetProperties(id, false);
78   return (idprop) ? IDP_GetPropertyTypeFromGroup(idprop, "cycles", IDP_GROUP) : NULL;
79 }
80
81 static float cycles_property_float(IDProperty *idprop, const char *name, float default_value)
82 {
83   IDProperty *prop = IDP_GetPropertyTypeFromGroup(idprop, name, IDP_FLOAT);
84   return (prop) ? IDP_Float(prop) : default_value;
85 }
86
87 static float cycles_property_int(IDProperty *idprop, const char *name, int default_value)
88 {
89   IDProperty *prop = IDP_GetPropertyTypeFromGroup(idprop, name, IDP_INT);
90   return (prop) ? IDP_Int(prop) : default_value;
91 }
92
93 static bool cycles_property_boolean(IDProperty *idprop, const char *name, bool default_value)
94 {
95   IDProperty *prop = IDP_GetPropertyTypeFromGroup(idprop, name, IDP_INT);
96   return (prop) ? IDP_Int(prop) : default_value;
97 }
98
99 static void displacement_node_insert(bNodeTree *ntree)
100 {
101   bool need_update = false;
102
103   /* Iterate backwards from end so we don't encounter newly added links. */
104   bNodeLink *prevlink;
105   for (bNodeLink *link = ntree->links.last; link; link = prevlink) {
106     prevlink = link->prev;
107
108     /* Detect link to replace. */
109     bNode *fromnode = link->fromnode;
110     bNodeSocket *fromsock = link->fromsock;
111     bNode *tonode = link->tonode;
112     bNodeSocket *tosock = link->tosock;
113
114     if (!(tonode->type == SH_NODE_OUTPUT_MATERIAL && fromnode->type != SH_NODE_DISPLACEMENT &&
115           STREQ(tosock->identifier, "Displacement"))) {
116       continue;
117     }
118
119     /* Replace link with displacement node. */
120     nodeRemLink(ntree, link);
121
122     /* Add displacement node. */
123     bNode *node = nodeAddStaticNode(NULL, ntree, SH_NODE_DISPLACEMENT);
124     node->locx = 0.5f * (fromnode->locx + tonode->locx);
125     node->locy = 0.5f * (fromnode->locy + tonode->locy);
126
127     bNodeSocket *scale_socket = nodeFindSocket(node, SOCK_IN, "Scale");
128     bNodeSocket *midlevel_socket = nodeFindSocket(node, SOCK_IN, "Midlevel");
129     bNodeSocket *height_socket = nodeFindSocket(node, SOCK_IN, "Height");
130     bNodeSocket *displacement_socket = nodeFindSocket(node, SOCK_OUT, "Displacement");
131
132     /* Set default values for compatibility. */
133     *cycles_node_socket_float_value(scale_socket) = 0.1f;
134     *cycles_node_socket_float_value(midlevel_socket) = 0.0f;
135
136     /* Link to input and material output node. */
137     nodeAddLink(ntree, fromnode, fromsock, node, height_socket);
138     nodeAddLink(ntree, node, displacement_socket, tonode, tosock);
139
140     need_update = true;
141   }
142
143   if (need_update) {
144     ntreeUpdateTree(NULL, ntree);
145   }
146 }
147
148 static void displacement_principled_nodes(bNode *node)
149 {
150   if (node->type == SH_NODE_DISPLACEMENT) {
151     if (node->custom1 != SHD_SPACE_WORLD) {
152       node->custom1 = SHD_SPACE_OBJECT;
153     }
154   }
155   else if (node->type == SH_NODE_BSDF_PRINCIPLED) {
156     if (node->custom2 != SHD_SUBSURFACE_RANDOM_WALK) {
157       node->custom2 = SHD_SUBSURFACE_BURLEY;
158     }
159   }
160 }
161
162 static bool node_has_roughness(bNode *node)
163 {
164   return ELEM(node->type,
165               SH_NODE_BSDF_ANISOTROPIC,
166               SH_NODE_BSDF_GLASS,
167               SH_NODE_BSDF_GLOSSY,
168               SH_NODE_BSDF_REFRACTION);
169 }
170
171 static void square_roughness_node_insert(bNodeTree *ntree)
172 {
173   bool need_update = false;
174
175   /* Update default values */
176   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
177     if (node_has_roughness(node)) {
178       bNodeSocket *roughness_input = nodeFindSocket(node, SOCK_IN, "Roughness");
179       float *roughness_value = cycles_node_socket_float_value(roughness_input);
180       *roughness_value = sqrtf(max_ff(*roughness_value, 0.0f));
181     }
182   }
183
184   /* Iterate backwards from end so we don't encounter newly added links. */
185   bNodeLink *prevlink;
186   for (bNodeLink *link = ntree->links.last; link; link = prevlink) {
187     prevlink = link->prev;
188
189     /* Detect link to replace. */
190     bNode *fromnode = link->fromnode;
191     bNodeSocket *fromsock = link->fromsock;
192     bNode *tonode = link->tonode;
193     bNodeSocket *tosock = link->tosock;
194
195     if (!(node_has_roughness(tonode) && STREQ(tosock->identifier, "Roughness"))) {
196       continue;
197     }
198
199     /* Replace links with sqrt node */
200     nodeRemLink(ntree, link);
201
202     /* Add sqrt node. */
203     bNode *node = nodeAddStaticNode(NULL, ntree, SH_NODE_MATH);
204     node->custom1 = NODE_MATH_POWER;
205     node->locx = 0.5f * (fromnode->locx + tonode->locx);
206     node->locy = 0.5f * (fromnode->locy + tonode->locy);
207
208     /* Link to input and material output node. */
209     *cycles_node_socket_float_value(node->inputs.last) = 0.5f;
210     nodeAddLink(ntree, fromnode, fromsock, node, node->inputs.first);
211     nodeAddLink(ntree, node, node->outputs.first, tonode, tosock);
212
213     need_update = true;
214   }
215
216   if (need_update) {
217     ntreeUpdateTree(NULL, ntree);
218   }
219 }
220
221 static void mapping_node_order_flip(bNode *node)
222 {
223   /* Flip euler order of mapping shader node */
224   if (node->type == SH_NODE_MAPPING && node->storage) {
225     TexMapping *texmap = node->storage;
226
227     float quat[4];
228     eulO_to_quat(quat, texmap->rot, EULER_ORDER_ZYX);
229     quat_to_eulO(texmap->rot, EULER_ORDER_XYZ, quat);
230   }
231 }
232
233 static void vector_curve_node_remap(bNode *node)
234 {
235   /* Remap values of vector curve node from normalized to absolute values */
236   if (node->type == SH_NODE_CURVE_VEC && node->storage) {
237     CurveMapping *mapping = node->storage;
238     mapping->flag &= ~CUMA_DO_CLIP;
239
240     for (int curve_index = 0; curve_index < CM_TOT; curve_index++) {
241       CurveMap *cm = &mapping->cm[curve_index];
242       if (cm->curve) {
243         for (int i = 0; i < cm->totpoint; i++) {
244           cm->curve[i].x = (cm->curve[i].x * 2.0f) - 1.0f;
245           cm->curve[i].y = (cm->curve[i].y - 0.5f) * 2.0f;
246         }
247       }
248     }
249
250     BKE_curvemapping_changed_all(mapping);
251   }
252 }
253
254 static void ambient_occlusion_node_relink(bNodeTree *ntree)
255 {
256   bool need_update = false;
257
258   /* Set default values. */
259   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
260     if (node->type == SH_NODE_AMBIENT_OCCLUSION) {
261       node->custom1 = 1; /* samples */
262       node->custom2 &= ~SHD_AO_LOCAL;
263
264       bNodeSocket *distance_socket = nodeFindSocket(node, SOCK_IN, "Distance");
265       *cycles_node_socket_float_value(distance_socket) = 0.0f;
266     }
267   }
268
269   /* Iterate backwards from end so we don't encounter newly added links. */
270   bNodeLink *prevlink;
271   for (bNodeLink *link = ntree->links.last; link; link = prevlink) {
272     prevlink = link->prev;
273
274     /* Detect link to replace. */
275     bNode *fromnode = link->fromnode;
276     bNode *tonode = link->tonode;
277     bNodeSocket *tosock = link->tosock;
278
279     if (!(fromnode->type == SH_NODE_AMBIENT_OCCLUSION)) {
280       continue;
281     }
282
283     /* Replace links with color socket. */
284     nodeRemLink(ntree, link);
285     bNodeSocket *color_socket = nodeFindSocket(fromnode, SOCK_OUT, "Color");
286     nodeAddLink(ntree, fromnode, color_socket, tonode, tosock);
287
288     need_update = true;
289   }
290
291   if (need_update) {
292     ntreeUpdateTree(NULL, ntree);
293   }
294 }
295
296 static void image_node_colorspace(bNode *node)
297 {
298   if (node->id == NULL) {
299     return;
300   }
301
302   int color_space;
303   if (node->type == SH_NODE_TEX_IMAGE && node->storage) {
304     NodeTexImage *tex = node->storage;
305     color_space = tex->color_space;
306   }
307   else if (node->type == SH_NODE_TEX_ENVIRONMENT && node->storage) {
308     NodeTexEnvironment *tex = node->storage;
309     color_space = tex->color_space;
310   }
311   else {
312     return;
313   }
314
315   const int SHD_COLORSPACE_NONE = 0;
316   Image *image = (Image *)node->id;
317   if (color_space == SHD_COLORSPACE_NONE) {
318     STRNCPY(image->colorspace_settings.name,
319             IMB_colormanagement_role_colorspace_name_get(COLOR_ROLE_DATA));
320   }
321 }
322
323 static void light_emission_node_to_energy(Light *light, float *energy, float color[3])
324 {
325   *energy = 1.0;
326   copy_v3_fl(color, 1.0f);
327
328   /* If nodetree has animation or drivers, don't try to convert. */
329   bNodeTree *ntree = light->nodetree;
330   if (ntree == NULL || ntree->adt) {
331     return;
332   }
333
334   /* Find emission node */
335   bNode *output_node = ntreeShaderOutputNode(ntree, SHD_OUTPUT_CYCLES);
336   if (output_node == NULL) {
337     return;
338   }
339
340   bNode *emission_node = NULL;
341   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
342     if (link->tonode == output_node && link->fromnode->type == SH_NODE_EMISSION) {
343       emission_node = link->fromnode;
344       break;
345     }
346   }
347
348   if (emission_node == NULL) {
349     return;
350   }
351
352   /* Don't convert if anything is linked */
353   bNodeSocket *strength_socket = nodeFindSocket(emission_node, SOCK_IN, "Strength");
354   bNodeSocket *color_socket = nodeFindSocket(emission_node, SOCK_IN, "Color");
355
356   if ((strength_socket->flag & SOCK_IN_USE) || (color_socket->flag & SOCK_IN_USE)) {
357     return;
358   }
359
360   float *strength_value = cycles_node_socket_float_value(strength_socket);
361   float *color_value = cycles_node_socket_rgba_value(color_socket);
362
363   *energy = *strength_value;
364   copy_v3_v3(color, color_value);
365
366   *strength_value = 1.0f;
367   copy_v4_fl(color_value, 1.0f);
368   light->use_nodes = false;
369 }
370
371 static void light_emission_unify(Light *light, const char *engine)
372 {
373   if (light->type != LA_SUN) {
374     light->energy *= 100.0f;
375   }
376
377   /* Attempt to extract constant energy and color from nodes. */
378   bool use_nodes = light->use_nodes;
379   float energy, color[3];
380   light_emission_node_to_energy(light, &energy, color);
381
382   if (STREQ(engine, "CYCLES")) {
383     if (use_nodes) {
384       /* Energy extracted from nodes */
385       light->energy = energy;
386       copy_v3_v3(&light->r, color);
387     }
388     else {
389       /* Default cycles multipliers if there are no nodes */
390       if (light->type == LA_SUN) {
391         light->energy = 1.0f;
392       }
393       else {
394         light->energy = 100.0f;
395       }
396     }
397   }
398   else {
399     /* Disable nodes if scene was configured for Eevee */
400     light->use_nodes = false;
401   }
402 }
403
404 /* The B input of the Math node is no longer used for single-operand operators.
405  * Previously, if the B input was linked and the A input was not, the B input
406  * was used as the input of the operator. To correct this, we move the link
407  * from B to A if B is linked and A is not.
408  */
409 static void update_math_node_single_operand_operators(bNodeTree *ntree)
410 {
411   bool need_update = false;
412
413   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
414     if (node->type == SH_NODE_MATH) {
415       if (ELEM(node->custom1,
416                NODE_MATH_SQRT,
417                NODE_MATH_CEIL,
418                NODE_MATH_SINE,
419                NODE_MATH_ROUND,
420                NODE_MATH_FLOOR,
421                NODE_MATH_COSINE,
422                NODE_MATH_ARCSINE,
423                NODE_MATH_TANGENT,
424                NODE_MATH_ABSOLUTE,
425                NODE_MATH_FRACTION,
426                NODE_MATH_ARCCOSINE,
427                NODE_MATH_ARCTANGENT)) {
428         bNodeSocket *sockA = BLI_findlink(&node->inputs, 0);
429         bNodeSocket *sockB = BLI_findlink(&node->inputs, 1);
430         if (!sockA->link && sockB->link) {
431           nodeAddLink(ntree, sockB->link->fromnode, sockB->link->fromsock, node, sockA);
432           nodeRemLink(ntree, sockB->link);
433           need_update = true;
434         }
435       }
436     }
437   }
438
439   if (need_update) {
440     ntreeUpdateTree(NULL, ntree);
441   }
442 }
443
444 /* The Value output of the Vector Math node is no longer available in the Add
445  * and Subtract operators. Previously, this Value output was computed from the
446  * Vector output V as follows:
447  *
448  *   Value = (abs(V.x) + abs(V.y) + abs(V.z)) / 3
449  *
450  * Or more compactly using vector operators:
451  *
452  *   Value = dot(abs(V), (1 / 3, 1 / 3, 1 / 3))
453  *
454  * To correct this, if the Value output was used, we are going to compute
455  * it using the second equation by adding an absolute and a dot node, and
456  * then connect them appropriately.
457  */
458 static void update_vector_math_node_add_and_subtract_operators(bNodeTree *ntree)
459 {
460   bool need_update = false;
461
462   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
463     if (node->type == SH_NODE_VECTOR_MATH) {
464       bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
465       if (socket_is_used(sockOutValue) &&
466           ELEM(node->custom1, NODE_VECTOR_MATH_ADD, NODE_VECTOR_MATH_SUBTRACT)) {
467
468         bNode *absNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
469         absNode->custom1 = NODE_VECTOR_MATH_ABSOLUTE;
470         absNode->locx = node->locx + node->width + 20.0f;
471         absNode->locy = node->locy;
472
473         bNode *dotNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
474         dotNode->custom1 = NODE_VECTOR_MATH_DOT_PRODUCT;
475         dotNode->locx = absNode->locx + absNode->width + 20.0f;
476         dotNode->locy = absNode->locy;
477         bNodeSocket *sockDotB = BLI_findlink(&dotNode->inputs, 1);
478         bNodeSocket *sockDotOutValue = nodeFindSocket(dotNode, SOCK_OUT, "Value");
479         copy_v3_fl(cycles_node_socket_vector_value(sockDotB), 1 / 3.0f);
480
481         LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
482           if (link->fromsock == sockOutValue) {
483             nodeAddLink(ntree, dotNode, sockDotOutValue, link->tonode, link->tosock);
484             nodeRemLink(ntree, link);
485           }
486         }
487
488         bNodeSocket *sockAbsA = BLI_findlink(&absNode->inputs, 0);
489         bNodeSocket *sockDotA = BLI_findlink(&dotNode->inputs, 0);
490         bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
491         bNodeSocket *sockAbsOutVector = nodeFindSocket(absNode, SOCK_OUT, "Vector");
492
493         nodeAddLink(ntree, node, sockOutVector, absNode, sockAbsA);
494         nodeAddLink(ntree, absNode, sockAbsOutVector, dotNode, sockDotA);
495
496         need_update = true;
497       }
498     }
499   }
500
501   if (need_update) {
502     ntreeUpdateTree(NULL, ntree);
503   }
504 }
505
506 /* The Vector output of the Vector Math node is no longer available in the Dot
507  * Product operator. Previously, this Vector was always zero initialized. To
508  * correct this, we zero out any socket the Vector Output was connected to.
509  */
510 static void update_vector_math_node_dot_product_operator(bNodeTree *ntree)
511 {
512   bool need_update = false;
513
514   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
515     if (node->type == SH_NODE_VECTOR_MATH) {
516       bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
517       if (socket_is_used(sockOutVector) && node->custom1 == NODE_VECTOR_MATH_DOT_PRODUCT) {
518         LISTBASE_FOREACH_MUTABLE (bNodeLink *, link, &ntree->links) {
519           if (link->fromsock == sockOutVector) {
520             switch (link->tosock->type) {
521               case SOCK_FLOAT:
522                 *cycles_node_socket_float_value(link->tosock) = 0.0f;
523                 break;
524               case SOCK_VECTOR:
525                 copy_v3_fl(cycles_node_socket_vector_value(link->tosock), 0.0f);
526                 break;
527               case SOCK_RGBA:
528                 copy_v4_fl(cycles_node_socket_rgba_value(link->tosock), 0.0f);
529                 break;
530             }
531             nodeRemLink(ntree, link);
532           }
533         }
534         need_update = true;
535       }
536     }
537   }
538
539   if (need_update) {
540     ntreeUpdateTree(NULL, ntree);
541   }
542 }
543
544 /* Previously, the Vector output of the cross product operator was normalized.
545  * To correct this, a Normalize node is added to normalize the output if used.
546  * Moreover, the Value output was removed. This Value was equal to the length
547  * of the cross product. To correct this, a Length node is added if needed.
548  */
549 static void update_vector_math_node_cross_product_operator(bNodeTree *ntree)
550 {
551   bool need_update = false;
552
553   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
554     if (node->type == SH_NODE_VECTOR_MATH) {
555       if (node->custom1 == NODE_VECTOR_MATH_CROSS_PRODUCT) {
556         bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
557         if (socket_is_used(sockOutVector)) {
558           bNode *normalizeNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
559           normalizeNode->custom1 = NODE_VECTOR_MATH_NORMALIZE;
560           normalizeNode->locx = node->locx + node->width + 20.0f;
561           normalizeNode->locy = node->locy;
562           bNodeSocket *sockNormalizeOut = nodeFindSocket(normalizeNode, SOCK_OUT, "Vector");
563
564           LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
565             if (link->fromsock == sockOutVector) {
566               nodeAddLink(ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock);
567               nodeRemLink(ntree, link);
568             }
569           }
570           bNodeSocket *sockNormalizeA = BLI_findlink(&normalizeNode->inputs, 0);
571           nodeAddLink(ntree, node, sockOutVector, normalizeNode, sockNormalizeA);
572
573           need_update = true;
574         }
575
576         bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
577         if (socket_is_used(sockOutValue)) {
578           bNode *lengthNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
579           lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH;
580           lengthNode->locx = node->locx + node->width + 20.0f;
581           if (socket_is_used(sockOutVector)) {
582             lengthNode->locy = node->locy - lengthNode->height - 20.0f;
583           }
584           else {
585             lengthNode->locy = node->locy;
586           }
587           bNodeSocket *sockLengthOut = nodeFindSocket(lengthNode, SOCK_OUT, "Value");
588
589           LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
590             if (link->fromsock == sockOutValue) {
591               nodeAddLink(ntree, lengthNode, sockLengthOut, link->tonode, link->tosock);
592               nodeRemLink(ntree, link);
593             }
594           }
595           bNodeSocket *sockLengthA = BLI_findlink(&lengthNode->inputs, 0);
596           nodeAddLink(ntree, node, sockOutVector, lengthNode, sockLengthA);
597
598           need_update = true;
599         }
600       }
601     }
602   }
603
604   if (need_update) {
605     ntreeUpdateTree(NULL, ntree);
606   }
607 }
608
609 /* The Value output of the Vector Math node is no longer available in the
610  * Normalize operator. This Value output was equal to the length of the
611  * the input vector A. To correct this, we either add a Length node or
612  * convert the Normalize node into a Length node, depending on if the
613  * Vector output is needed.
614  */
615 static void update_vector_math_node_normalize_operator(bNodeTree *ntree)
616 {
617   bool need_update = false;
618
619   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
620     if (node->type == SH_NODE_VECTOR_MATH) {
621       bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
622       if (node->custom1 == NODE_VECTOR_MATH_NORMALIZE && socket_is_used(sockOutValue)) {
623         bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
624         if (socket_is_used(sockOutVector)) {
625           bNode *lengthNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
626           lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH;
627           lengthNode->locx = node->locx + node->width + 20.0f;
628           lengthNode->locy = node->locy;
629           bNodeSocket *sockLengthValue = nodeFindSocket(lengthNode, SOCK_OUT, "Value");
630
631           LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
632             if (link->fromsock == sockOutValue) {
633               nodeAddLink(ntree, lengthNode, sockLengthValue, link->tonode, link->tosock);
634               nodeRemLink(ntree, link);
635             }
636           }
637           bNodeSocket *sockA = BLI_findlink(&node->inputs, 0);
638           bNodeSocket *sockLengthA = BLI_findlink(&lengthNode->inputs, 0);
639           if (sockA->link) {
640             bNodeLink *link = sockA->link;
641             nodeAddLink(ntree, link->fromnode, link->fromsock, lengthNode, sockLengthA);
642           }
643           else {
644             copy_v3_v3(cycles_node_socket_vector_value(sockLengthA),
645                        cycles_node_socket_vector_value(sockA));
646           }
647
648           need_update = true;
649         }
650         else {
651           node->custom1 = NODE_VECTOR_MATH_LENGTH;
652         }
653       }
654     }
655   }
656   if (need_update) {
657     ntreeUpdateTree(NULL, ntree);
658   }
659 }
660
661 /* The Vector Math operator types didn't have an enum, but rather, their
662  * values were hard coded into the code. After the enum was created and
663  * after more vector operators were added, the hard coded values needs
664  * to be remapped to their correct enum values. To fix this, we remap
665  * the values according to the following rules:
666  *
667  * Dot Product Operator : 3 -> 7
668  * Normalize Operator   : 5 -> 11
669  *
670  * Additionally, since the Average operator was removed, it is assigned
671  * a value of -1 just to be identified later in the versioning code:
672  *
673  * Average Operator : 2 -> -1
674  *
675  */
676 static void update_vector_math_node_operators_enum_mapping(bNodeTree *ntree)
677 {
678   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
679     if (node->type == SH_NODE_VECTOR_MATH) {
680       switch (node->custom1) {
681         case 2:
682           node->custom1 = -1;
683           break;
684         case 3:
685           node->custom1 = 7;
686           break;
687         case 5:
688           node->custom1 = 11;
689           break;
690       }
691     }
692   }
693 }
694
695 /* The Average operator is no longer available in the Vector Math node.
696  * The Vector output was equal to the normalized sum of input vectors while
697  * the Value output was equal to the length of the sum of input vectors.
698  * To correct this, we convert the node into an Add node and add a length
699  * node or a normalize node if needed.
700  */
701 static void update_vector_math_node_average_operator(bNodeTree *ntree)
702 {
703   bool need_update = false;
704
705   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
706     if (node->type == SH_NODE_VECTOR_MATH) {
707       /* See update_vector_math_node_operators_enum_mapping. */
708       if (node->custom1 == -1) {
709         node->custom1 = NODE_VECTOR_MATH_ADD;
710         bNodeSocket *sockOutVector = nodeFindSocket(node, SOCK_OUT, "Vector");
711         if (socket_is_used(sockOutVector)) {
712           bNode *normalizeNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
713           normalizeNode->custom1 = NODE_VECTOR_MATH_NORMALIZE;
714           normalizeNode->locx = node->locx + node->width + 20.0f;
715           normalizeNode->locy = node->locy;
716           bNodeSocket *sockNormalizeOut = nodeFindSocket(normalizeNode, SOCK_OUT, "Vector");
717
718           LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
719             if (link->fromsock == sockOutVector) {
720               nodeAddLink(ntree, normalizeNode, sockNormalizeOut, link->tonode, link->tosock);
721               nodeRemLink(ntree, link);
722             }
723           }
724           bNodeSocket *sockNormalizeA = BLI_findlink(&normalizeNode->inputs, 0);
725           nodeAddLink(ntree, node, sockOutVector, normalizeNode, sockNormalizeA);
726
727           need_update = true;
728         }
729
730         bNodeSocket *sockOutValue = nodeFindSocket(node, SOCK_OUT, "Value");
731         if (socket_is_used(sockOutValue)) {
732           bNode *lengthNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
733           lengthNode->custom1 = NODE_VECTOR_MATH_LENGTH;
734           lengthNode->locx = node->locx + node->width + 20.0f;
735           if (socket_is_used(sockOutVector)) {
736             lengthNode->locy = node->locy - lengthNode->height - 20.0f;
737           }
738           else {
739             lengthNode->locy = node->locy;
740           }
741           bNodeSocket *sockLengthOut = nodeFindSocket(lengthNode, SOCK_OUT, "Value");
742
743           LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
744             if (link->fromsock == sockOutValue) {
745               nodeAddLink(ntree, lengthNode, sockLengthOut, link->tonode, link->tosock);
746               nodeRemLink(ntree, link);
747             }
748           }
749           bNodeSocket *sockLengthA = BLI_findlink(&lengthNode->inputs, 0);
750           nodeAddLink(ntree, node, sockOutVector, lengthNode, sockLengthA);
751
752           need_update = true;
753         }
754       }
755     }
756   }
757
758   if (need_update) {
759     ntreeUpdateTree(NULL, ntree);
760   }
761 }
762
763 /* The Noise node now have a dimension property. This property should be
764  * initialized to 3 by default.
765  */
766 static void update_noise_node_dimensions(bNodeTree *ntree)
767 {
768   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
769     if (node->type == SH_NODE_TEX_NOISE && node->storage) {
770       NodeTexNoise *tex = (NodeTexNoise *)node->storage;
771       tex->dimensions = 3;
772     }
773   }
774 }
775
776 /* This structure is only used to pass data to
777  * update_mapping_node_fcurve_rna_path_callback.
778  */
779 typedef struct {
780   char *nodePath;
781   bNode *minimumNode;
782   bNode *maximumNode;
783 } MappingNodeFCurveCallbackData;
784
785 /* This callback function is used by update_mapping_node_inputs_and_properties.
786  * It is executed on every fcurve in the nodetree id updating its RNA paths. The
787  * paths needs to be updated because the node properties became inputs.
788  *
789  * nodes["Mapping"].translation --> nodes["Mapping"].inputs[1].default_value
790  * nodes["Mapping"].rotation --> nodes["Mapping"].inputs[2].default_value
791  * nodes["Mapping"].scale --> nodes["Mapping"].inputs[3].default_value
792  * nodes["Mapping"].max --> nodes["Maximum"].inputs[1].default_value
793  * nodes["Mapping"].min --> nodes["Minimum"].inputs[1].default_value
794  *
795  * The fcurve can be that of any node or property in the nodetree, so we only
796  * update if the rna path starts with the rna path of the mapping node and
797  * doesn't end with "default_value", that is, not the Vector input.
798  */
799 static void update_mapping_node_fcurve_rna_path_callback(ID *UNUSED(id),
800                                                          FCurve *fcurve,
801                                                          void *_data)
802 {
803   MappingNodeFCurveCallbackData *data = (MappingNodeFCurveCallbackData *)_data;
804   if (!STRPREFIX(fcurve->rna_path, data->nodePath) ||
805       BLI_str_endswith(fcurve->rna_path, "default_value")) {
806     return;
807   }
808   char *old_fcurve_rna_path = fcurve->rna_path;
809
810   if (BLI_str_endswith(old_fcurve_rna_path, "translation")) {
811     fcurve->rna_path = BLI_sprintfN("%s.%s", data->nodePath, "inputs[1].default_value");
812   }
813   else if (BLI_str_endswith(old_fcurve_rna_path, "rotation")) {
814     fcurve->rna_path = BLI_sprintfN("%s.%s", data->nodePath, "inputs[2].default_value");
815   }
816   else if (BLI_str_endswith(old_fcurve_rna_path, "scale")) {
817     fcurve->rna_path = BLI_sprintfN("%s.%s", data->nodePath, "inputs[3].default_value");
818   }
819   else if (data->minimumNode && BLI_str_endswith(old_fcurve_rna_path, "max")) {
820     fcurve->rna_path = BLI_sprintfN(
821         "nodes[\"%s\"].%s", data->minimumNode->name, "inputs[1].default_value");
822   }
823   else if (data->maximumNode && BLI_str_endswith(old_fcurve_rna_path, "min")) {
824     fcurve->rna_path = BLI_sprintfN(
825         "nodes[\"%s\"].%s", data->maximumNode->name, "inputs[1].default_value");
826   }
827
828   if (fcurve->rna_path != old_fcurve_rna_path) {
829     MEM_freeN(old_fcurve_rna_path);
830   }
831 }
832
833 /* The Mapping node has been rewritten to support dynamic inputs. Previously,
834  * the transformation information was stored in a TexMapping struct in the
835  * node->storage member of bNode. Currently, the transformation information
836  * is stored in input sockets. To correct this, we transfer the information
837  * from the TexMapping struct to the input sockets.
838  *
839  * Additionally, the Minimum and Maximum properties are no longer available
840  * in the node. To correct this, a Vector Minimum and/or a Vector Maximum
841  * nodes are added if needed.
842  *
843  * Finally, the TexMapping struct is freed and node->storage is set to NULL.
844  *
845  * Since the RNA paths of the properties changed, we also have to update the
846  * rna_path of the FCurves if they exist. To do that, we loop over FCurves
847  * and check if they control a property of the node, if they do, we update
848  * the path to be that of the corresponding socket in the node or the added
849  * minimum/maximum node.
850  *
851  */
852 static void update_mapping_node_inputs_and_properties(bNodeTree *ntree)
853 {
854   bool need_update = false;
855
856   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
857     /* If node->storage is NULL, then conversion has already taken place.
858      * This can happen if a file with the new mapping node [saved from (2, 81, 8) or newer]
859      * is opened in a blender version prior to (2, 81, 8) and saved from there again. */
860     if (node->type == SH_NODE_MAPPING && node->storage) {
861       TexMapping *mapping = (TexMapping *)node->storage;
862       node->custom1 = mapping->type;
863       node->width = 140.0f;
864
865       bNodeSocket *sockLocation = nodeFindSocket(node, SOCK_IN, "Location");
866       copy_v3_v3(cycles_node_socket_vector_value(sockLocation), mapping->loc);
867       bNodeSocket *sockRotation = nodeFindSocket(node, SOCK_IN, "Rotation");
868       copy_v3_v3(cycles_node_socket_vector_value(sockRotation), mapping->rot);
869       bNodeSocket *sockScale = nodeFindSocket(node, SOCK_IN, "Scale");
870       copy_v3_v3(cycles_node_socket_vector_value(sockScale), mapping->size);
871
872       bNode *maximumNode = NULL;
873       if (mapping->flag & TEXMAP_CLIP_MIN) {
874         maximumNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
875         maximumNode->custom1 = NODE_VECTOR_MATH_MAXIMUM;
876         if (mapping->flag & TEXMAP_CLIP_MAX) {
877           maximumNode->locx = node->locx + (node->width + 20.0f) * 2.0f;
878         }
879         else {
880           maximumNode->locx = node->locx + node->width + 20.0f;
881         }
882         maximumNode->locy = node->locy;
883         bNodeSocket *sockMaximumB = BLI_findlink(&maximumNode->inputs, 1);
884         copy_v3_v3(cycles_node_socket_vector_value(sockMaximumB), mapping->min);
885         bNodeSocket *sockMappingResult = nodeFindSocket(node, SOCK_OUT, "Vector");
886
887         LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
888           if (link->fromsock == sockMappingResult) {
889             bNodeSocket *sockMaximumResult = nodeFindSocket(maximumNode, SOCK_OUT, "Vector");
890             nodeAddLink(ntree, maximumNode, sockMaximumResult, link->tonode, link->tosock);
891             nodeRemLink(ntree, link);
892           }
893         }
894         if (!(mapping->flag & TEXMAP_CLIP_MAX)) {
895           bNodeSocket *sockMaximumA = BLI_findlink(&maximumNode->inputs, 0);
896           nodeAddLink(ntree, node, sockMappingResult, maximumNode, sockMaximumA);
897         }
898
899         need_update = true;
900       }
901
902       bNode *minimumNode = NULL;
903       if (mapping->flag & TEXMAP_CLIP_MAX) {
904         minimumNode = nodeAddStaticNode(NULL, ntree, SH_NODE_VECTOR_MATH);
905         minimumNode->custom1 = NODE_VECTOR_MATH_MINIMUM;
906         minimumNode->locx = node->locx + node->width + 20.0f;
907         minimumNode->locy = node->locy;
908         bNodeSocket *sockMinimumB = BLI_findlink(&minimumNode->inputs, 1);
909         copy_v3_v3(cycles_node_socket_vector_value(sockMinimumB), mapping->max);
910
911         bNodeSocket *sockMinimumResult = nodeFindSocket(minimumNode, SOCK_OUT, "Vector");
912         bNodeSocket *sockMappingResult = nodeFindSocket(node, SOCK_OUT, "Vector");
913
914         if (maximumNode) {
915           bNodeSocket *sockMaximumA = BLI_findlink(&maximumNode->inputs, 0);
916           nodeAddLink(ntree, minimumNode, sockMinimumResult, maximumNode, sockMaximumA);
917         }
918         else {
919           LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
920             if (link->fromsock == sockMappingResult) {
921               nodeAddLink(ntree, minimumNode, sockMinimumResult, link->tonode, link->tosock);
922               nodeRemLink(ntree, link);
923             }
924           }
925         }
926         bNodeSocket *sockMinimumA = BLI_findlink(&minimumNode->inputs, 0);
927         nodeAddLink(ntree, node, sockMappingResult, minimumNode, sockMinimumA);
928
929         need_update = true;
930       }
931
932       MEM_freeN(node->storage);
933       node->storage = NULL;
934
935       char *nodePath = BLI_sprintfN("nodes[\"%s\"]", node->name);
936       MappingNodeFCurveCallbackData data = {nodePath, minimumNode, maximumNode};
937       BKE_fcurves_id_cb(&ntree->id, update_mapping_node_fcurve_rna_path_callback, &data);
938       MEM_freeN(nodePath);
939     }
940   }
941
942   if (need_update) {
943     ntreeUpdateTree(NULL, ntree);
944   }
945 }
946
947 /* The Musgrave node now has a dimension property. This property should
948  * be initialized to 3 by default.
949  */
950 static void update_musgrave_node_dimensions(bNodeTree *ntree)
951 {
952   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
953     if (node->type == SH_NODE_TEX_MUSGRAVE && node->storage) {
954       NodeTexMusgrave *tex = (NodeTexMusgrave *)node->storage;
955       tex->dimensions = 3;
956     }
957   }
958 }
959
960 /* The Color output of the Musgrave node has been removed. Previously, this
961  * output was just equal to the Fac output. To correct this, we move links
962  * from the Color output to the Fac output if they exist.
963  */
964 static void update_musgrave_node_color_output(bNodeTree *ntree)
965 {
966   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
967     if (link->fromnode && link->fromnode->type == SH_NODE_TEX_MUSGRAVE) {
968       if (link->fromsock->type == SOCK_RGBA) {
969         link->fromsock = link->fromsock->next;
970       }
971     }
972   }
973 }
974
975 /* The Voronoi node now have a dimension property. This property should be
976  * initialized to 3 by default.
977  */
978 static void update_voronoi_node_dimensions(bNodeTree *ntree)
979 {
980   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
981     if (node->type == SH_NODE_TEX_VORONOI && node->storage) {
982       NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
983       tex->dimensions = 3;
984     }
985   }
986 }
987
988 /* The F3 and F4 features of the Voronoi node have been removed.
989  * To correct this, we set the feature type to be F2 if it is F3
990  * or F4. The SHD_VORONOI_F3 and SHD_VORONOI_F4 enum values were
991  * 2 and 3 respectively.
992  */
993 static void update_voronoi_node_f3_and_f4(bNodeTree *ntree)
994 {
995   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
996     if (node->type == SH_NODE_TEX_VORONOI && node->storage) {
997       NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
998       if (ELEM(tex->feature, 2, 3)) {
999         tex->feature = SHD_VORONOI_F2;
1000       }
1001     }
1002   }
1003 }
1004
1005 /* The Fac output of the Voronoi node has been removed. Previously, this
1006  * output was the voronoi distance in the Intensity mode and the Cell ID
1007  * in the Cell mode. To correct this, we update the identifier and name
1008  * of the Fac socket such that it gets mapped to the Distance socket.
1009  * This is supposed to work with update_voronoi_node_coloring.
1010  */
1011 static void update_voronoi_node_fac_output(bNodeTree *ntree)
1012 {
1013   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1014     if (node->type == SH_NODE_TEX_VORONOI) {
1015       bNodeSocket *facOutput = BLI_findlink(&node->outputs, 1);
1016       strcpy(facOutput->identifier, "Distance");
1017       strcpy(facOutput->name, "Distance");
1018     }
1019   }
1020 }
1021
1022 /* The Crackle feature of the Voronoi node has been removed. Previously,
1023  * this feature returned the F2 distance minus the F1 distance. The
1024  * crackle feature had an enum value of 4. To fix this we do the
1025  * following:
1026  *
1027  * 1. The node feature is set to F1.
1028  * 2. A new Voronoi node is added and its feature is set to F2.
1029  * 3. The properties, input values, and connections are copied
1030  *    from the node to the new Voronoi node so that they match
1031  *    exactly.
1032  * 4. A Subtract node is added.
1033  * 5. The outputs of the F1 and F2 voronoi are connected to
1034  *    the inputs of the subtract node.
1035  * 6. The output of the subtract node is connected to the
1036  *    appropriate sockets.
1037  *
1038  */
1039 static void update_voronoi_node_crackle(bNodeTree *ntree)
1040 {
1041   bool need_update = false;
1042
1043   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1044     if (node->type == SH_NODE_TEX_VORONOI && node->storage) {
1045       NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
1046       bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
1047       bNodeSocket *sockColor = nodeFindSocket(node, SOCK_OUT, "Color");
1048       if (tex->feature == 4 && (socket_is_used(sockDistance) || socket_is_used(sockColor))) {
1049         tex->feature = SHD_VORONOI_F1;
1050
1051         bNode *voronoiNode = nodeAddStaticNode(NULL, ntree, SH_NODE_TEX_VORONOI);
1052         NodeTexVoronoi *texVoronoi = (NodeTexVoronoi *)voronoiNode->storage;
1053         texVoronoi->feature = SHD_VORONOI_F2;
1054         texVoronoi->distance = tex->distance;
1055         texVoronoi->dimensions = 3;
1056         voronoiNode->locx = node->locx + node->width + 20.0f;
1057         voronoiNode->locy = node->locy;
1058
1059         bNodeSocket *sockVector = nodeFindSocket(node, SOCK_IN, "Vector");
1060         bNodeSocket *sockScale = nodeFindSocket(node, SOCK_IN, "Scale");
1061         bNodeSocket *sockExponent = nodeFindSocket(node, SOCK_IN, "Exponent");
1062         bNodeSocket *sockVoronoiVector = nodeFindSocket(voronoiNode, SOCK_IN, "Vector");
1063         bNodeSocket *sockVoronoiScale = nodeFindSocket(voronoiNode, SOCK_IN, "Scale");
1064         bNodeSocket *sockVoronoiExponent = nodeFindSocket(voronoiNode, SOCK_IN, "Exponent");
1065         if (sockVector->link) {
1066           nodeAddLink(ntree,
1067                       sockVector->link->fromnode,
1068                       sockVector->link->fromsock,
1069                       voronoiNode,
1070                       sockVoronoiVector);
1071         }
1072         *cycles_node_socket_float_value(sockVoronoiScale) = *cycles_node_socket_float_value(
1073             sockScale);
1074         if (sockScale->link) {
1075           nodeAddLink(ntree,
1076                       sockScale->link->fromnode,
1077                       sockScale->link->fromsock,
1078                       voronoiNode,
1079                       sockVoronoiScale);
1080         }
1081         *cycles_node_socket_float_value(sockVoronoiExponent) = *cycles_node_socket_float_value(
1082             sockExponent);
1083         if (sockExponent->link) {
1084           nodeAddLink(ntree,
1085                       sockExponent->link->fromnode,
1086                       sockExponent->link->fromsock,
1087                       voronoiNode,
1088                       sockVoronoiExponent);
1089         }
1090
1091         bNode *subtractNode = nodeAddStaticNode(NULL, ntree, SH_NODE_MATH);
1092         subtractNode->custom1 = NODE_MATH_SUBTRACT;
1093         subtractNode->locx = voronoiNode->locx + voronoiNode->width + 20.0f;
1094         subtractNode->locy = voronoiNode->locy;
1095         bNodeSocket *sockSubtractOutValue = nodeFindSocket(subtractNode, SOCK_OUT, "Value");
1096
1097         LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
1098           if (link->fromnode == node) {
1099             nodeAddLink(ntree, subtractNode, sockSubtractOutValue, link->tonode, link->tosock);
1100             nodeRemLink(ntree, link);
1101           }
1102         }
1103
1104         bNodeSocket *sockDistanceF1 = nodeFindSocket(node, SOCK_OUT, "Distance");
1105         bNodeSocket *sockDistanceF2 = nodeFindSocket(voronoiNode, SOCK_OUT, "Distance");
1106         bNodeSocket *sockSubtractA = BLI_findlink(&subtractNode->inputs, 0);
1107         bNodeSocket *sockSubtractB = BLI_findlink(&subtractNode->inputs, 1);
1108
1109         nodeAddLink(ntree, node, sockDistanceF1, subtractNode, sockSubtractB);
1110         nodeAddLink(ntree, voronoiNode, sockDistanceF2, subtractNode, sockSubtractA);
1111
1112         need_update = true;
1113       }
1114     }
1115   }
1116
1117   if (need_update) {
1118     ntreeUpdateTree(NULL, ntree);
1119   }
1120 }
1121
1122 /**
1123  * The coloring property of the Voronoi node was removed. Previously,
1124  * if the coloring enum was set to Intensity (0), the voronoi distance
1125  * was returned in all outputs, otherwise, the Cell ID was returned.
1126  * Since we remapped the Fac output in update_voronoi_node_fac_output,
1127  * then to fix this, we relink the Color output to the Distance
1128  * output if coloring was set to 0, and the other way around otherwise.
1129  */
1130 static void update_voronoi_node_coloring(bNodeTree *ntree)
1131 {
1132   bool need_update = false;
1133
1134   LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
1135     bNode *node = link->fromnode;
1136     if (node && node->type == SH_NODE_TEX_VORONOI && node->storage) {
1137       NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
1138       if (tex->coloring == 0) {
1139         bNodeSocket *sockColor = nodeFindSocket(node, SOCK_OUT, "Color");
1140         if (link->fromsock == sockColor) {
1141           bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
1142           nodeAddLink(ntree, node, sockDistance, link->tonode, link->tosock);
1143           nodeRemLink(ntree, link);
1144           need_update = true;
1145         }
1146       }
1147       else {
1148         bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
1149         if (link->fromsock == sockDistance) {
1150           bNodeSocket *sockColor = nodeFindSocket(node, SOCK_OUT, "Color");
1151           nodeAddLink(ntree, node, sockColor, link->tonode, link->tosock);
1152           nodeRemLink(ntree, link);
1153           need_update = true;
1154         }
1155       }
1156     }
1157   }
1158
1159   if (need_update) {
1160     ntreeUpdateTree(NULL, ntree);
1161   }
1162 }
1163
1164 /* Previously, the output euclidean distance was actually the squared
1165  * euclidean distance. To fix this, we square the output distance
1166  * socket if the distance metric is set to SHD_VORONOI_EUCLIDEAN.
1167  */
1168 static void update_voronoi_node_square_distance(bNodeTree *ntree)
1169 {
1170   bool need_update = false;
1171
1172   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1173     if (node->type == SH_NODE_TEX_VORONOI && node->storage) {
1174       NodeTexVoronoi *tex = (NodeTexVoronoi *)node->storage;
1175       bNodeSocket *sockDistance = nodeFindSocket(node, SOCK_OUT, "Distance");
1176       if (tex->distance == SHD_VORONOI_EUCLIDEAN &&
1177           (tex->feature == SHD_VORONOI_F1 || tex->feature == SHD_VORONOI_F2) &&
1178           socket_is_used(sockDistance)) {
1179         bNode *multiplyNode = nodeAddStaticNode(NULL, ntree, SH_NODE_MATH);
1180         multiplyNode->custom1 = NODE_MATH_MULTIPLY;
1181         multiplyNode->locx = node->locx + node->width + 20.0f;
1182         multiplyNode->locy = node->locy;
1183
1184         bNodeSocket *sockValue = nodeFindSocket(multiplyNode, SOCK_OUT, "Value");
1185         LISTBASE_FOREACH_BACKWARD_MUTABLE (bNodeLink *, link, &ntree->links) {
1186           if (link->fromsock == sockDistance) {
1187             nodeAddLink(ntree, multiplyNode, sockValue, link->tonode, link->tosock);
1188             nodeRemLink(ntree, link);
1189           }
1190         }
1191
1192         bNodeSocket *sockMultiplyA = BLI_findlink(&multiplyNode->inputs, 0);
1193         bNodeSocket *sockMultiplyB = BLI_findlink(&multiplyNode->inputs, 1);
1194
1195         nodeAddLink(ntree, node, sockDistance, multiplyNode, sockMultiplyA);
1196         nodeAddLink(ntree, node, sockDistance, multiplyNode, sockMultiplyB);
1197
1198         need_update = true;
1199       }
1200     }
1201   }
1202
1203   if (need_update) {
1204     ntreeUpdateTree(NULL, ntree);
1205   }
1206 }
1207
1208 /* Noise and Wave Texture nodes: Restore previous Distortion range.
1209  * In 2.81 we used noise() for distortion, now we use snoise() which has twice the range.
1210  * To fix this we halve distortion value, directly or by adding multiply node for used sockets.
1211  */
1212 static void update_noise_and_wave_distortion(bNodeTree *ntree)
1213 {
1214   bool need_update = false;
1215
1216   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1217     if (node->type == SH_NODE_TEX_NOISE || node->type == SH_NODE_TEX_WAVE) {
1218
1219       bNodeSocket *sockDistortion = nodeFindSocket(node, SOCK_IN, "Distortion");
1220       float *distortion = cycles_node_socket_float_value(sockDistortion);
1221
1222       if (socket_is_used(sockDistortion) && sockDistortion->link != NULL) {
1223         bNode *distortionInputNode = sockDistortion->link->fromnode;
1224         bNodeSocket *distortionInputSock = sockDistortion->link->fromsock;
1225
1226         bNode *mulNode = nodeAddStaticNode(NULL, ntree, SH_NODE_MATH);
1227         mulNode->custom1 = NODE_MATH_MULTIPLY;
1228         mulNode->locx = node->locx;
1229         mulNode->locy = node->locy - 240.0f;
1230         mulNode->flag |= NODE_HIDDEN;
1231         bNodeSocket *mulSockA = BLI_findlink(&mulNode->inputs, 0);
1232         bNodeSocket *mulSockB = BLI_findlink(&mulNode->inputs, 1);
1233         *cycles_node_socket_float_value(mulSockB) = 0.5f;
1234         bNodeSocket *mulSockOut = nodeFindSocket(mulNode, SOCK_OUT, "Value");
1235
1236         nodeRemLink(ntree, sockDistortion->link);
1237         nodeAddLink(ntree, distortionInputNode, distortionInputSock, mulNode, mulSockA);
1238         nodeAddLink(ntree, mulNode, mulSockOut, node, sockDistortion);
1239
1240         need_update = true;
1241       }
1242       else if (*distortion != 0.0f) {
1243         *distortion = *distortion * 0.5f;
1244       }
1245     }
1246   }
1247
1248   if (need_update) {
1249     ntreeUpdateTree(NULL, ntree);
1250   }
1251 }
1252
1253 /**
1254  * Wave Texture node: Restore previous texture directions and offset.
1255  * 1. In 2.81, Wave texture had fixed diagonal direction (Bands) or
1256  *    mapping along distance (Rings). Now, directions are customizable
1257  *    properties, with X axis being new default. To fix this we set new
1258  *    direction options to Diagonal and Spherical.
1259  * 2. Sine profile is now negatively offset by PI/2 to better match
1260  *    other profiles. To fix this we set new Phase Offset input to PI/2
1261  *    in nodes with Sine profile.
1262  */
1263 static void update_wave_node_directions_and_offset(bNodeTree *ntree)
1264 {
1265   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1266     if (node->type == SH_NODE_TEX_WAVE) {
1267       NodeTexWave *tex = (NodeTexWave *)node->storage;
1268       tex->bands_direction = SHD_WAVE_BANDS_DIRECTION_DIAGONAL;
1269       tex->rings_direction = SHD_WAVE_RINGS_DIRECTION_SPHERICAL;
1270
1271       if (tex->wave_profile == SHD_WAVE_PROFILE_SIN) {
1272         bNodeSocket *sockPhaseOffset = nodeFindSocket(node, SOCK_IN, "Phase Offset");
1273         *cycles_node_socket_float_value(sockPhaseOffset) = M_PI_2;
1274       }
1275     }
1276   }
1277 }
1278
1279 void blo_do_versions_cycles(FileData *UNUSED(fd), Library *UNUSED(lib), Main *bmain)
1280 {
1281   /* Particle shape shared with Eevee. */
1282   if (!MAIN_VERSION_ATLEAST(bmain, 280, 16)) {
1283     for (ParticleSettings *part = bmain->particles.first; part; part = part->id.next) {
1284       IDProperty *cpart = cycles_properties_from_ID(&part->id);
1285
1286       if (cpart) {
1287         part->shape = cycles_property_float(cpart, "shape", 0.0);
1288         part->rad_root = cycles_property_float(cpart, "root_width", 1.0);
1289         part->rad_tip = cycles_property_float(cpart, "tip_width", 0.0);
1290         part->rad_scale = cycles_property_float(cpart, "radius_scale", 0.01);
1291         if (cycles_property_boolean(cpart, "use_closetip", true)) {
1292           part->shape_flag |= PART_SHAPE_CLOSE_TIP;
1293         }
1294       }
1295     }
1296   }
1297
1298   if (!MAIN_VERSION_ATLEAST(bmain, 280, 68)) {
1299     /* Unify Cycles and Eevee film transparency. */
1300     for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1301       if (STREQ(scene->r.engine, RE_engine_id_CYCLES)) {
1302         IDProperty *cscene = cycles_properties_from_ID(&scene->id);
1303         if (cscene) {
1304           bool cycles_film_transparency = cycles_property_boolean(
1305               cscene, "film_transparent", false);
1306           scene->r.alphamode = cycles_film_transparency ? R_ALPHAPREMUL : R_ADDSKY;
1307         }
1308       }
1309     }
1310   }
1311
1312   if (!MAIN_VERSION_ATLEAST(bmain, 281, 3)) {
1313     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1314       if (ntree->type == NTREE_SHADER) {
1315         update_vector_math_node_operators_enum_mapping(ntree);
1316       }
1317     }
1318     FOREACH_NODETREE_END;
1319   }
1320
1321   if (!MAIN_VERSION_ATLEAST(bmain, 281, 10)) {
1322     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1323       if (ntree->type == NTREE_SHADER) {
1324         update_musgrave_node_color_output(ntree);
1325       }
1326     }
1327     FOREACH_NODETREE_END;
1328   }
1329
1330   if (!MAIN_VERSION_ATLEAST(bmain, 281, 11)) {
1331     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1332       if (ntree->type == NTREE_SHADER) {
1333         update_voronoi_node_f3_and_f4(ntree);
1334         update_voronoi_node_fac_output(ntree);
1335       }
1336     }
1337     FOREACH_NODETREE_END;
1338   }
1339 }
1340
1341 void do_versions_after_linking_cycles(Main *bmain)
1342 {
1343   if (!MAIN_VERSION_ATLEAST(bmain, 280, 66)) {
1344     /* Shader node tree changes. After lib linking so we have all the typeinfo
1345      * pointers and updated sockets and we can use the high level node API to
1346      * manipulate nodes. */
1347     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1348       if (ntree->type != NTREE_SHADER) {
1349         continue;
1350       }
1351
1352       if (!MAIN_VERSION_ATLEAST(bmain, 273, 5)) {
1353         /* Euler order was ZYX in previous versions. */
1354         LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1355           mapping_node_order_flip(node);
1356         }
1357       }
1358
1359       if (!MAIN_VERSION_ATLEAST(bmain, 276, 6)) {
1360         LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1361           vector_curve_node_remap(node);
1362         }
1363       }
1364
1365       if (!MAIN_VERSION_ATLEAST(bmain, 279, 2) ||
1366           (MAIN_VERSION_ATLEAST(bmain, 280, 0) && !MAIN_VERSION_ATLEAST(bmain, 280, 4))) {
1367         displacement_node_insert(ntree);
1368       }
1369
1370       if (!MAIN_VERSION_ATLEAST(bmain, 279, 3)) {
1371         LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1372           displacement_principled_nodes(node);
1373         }
1374       }
1375
1376       if (!MAIN_VERSION_ATLEAST(bmain, 279, 4) ||
1377           (MAIN_VERSION_ATLEAST(bmain, 280, 0) && !MAIN_VERSION_ATLEAST(bmain, 280, 5))) {
1378         /* Switch to squared roughness convention */
1379         square_roughness_node_insert(ntree);
1380       }
1381
1382       if (!MAIN_VERSION_ATLEAST(bmain, 279, 5)) {
1383         ambient_occlusion_node_relink(ntree);
1384       }
1385
1386       if (!MAIN_VERSION_ATLEAST(bmain, 280, 66)) {
1387         LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
1388           image_node_colorspace(node);
1389         }
1390       }
1391     }
1392     FOREACH_NODETREE_END;
1393   }
1394
1395   if (!MAIN_VERSION_ATLEAST(bmain, 280, 64)) {
1396     /* Unfiy Cycles and Eevee settings. */
1397     Scene *scene = bmain->scenes.first;
1398     const char *engine = (scene) ? scene->r.engine : "CYCLES";
1399
1400     for (Light *light = bmain->lights.first; light; light = light->id.next) {
1401       light_emission_unify(light, engine);
1402     }
1403   }
1404
1405   if (!MAIN_VERSION_ATLEAST(bmain, 280, 69)) {
1406     /* Unify Cycles and Eevee depth of field. */
1407     Scene *scene = bmain->scenes.first;
1408     const char *engine = (scene) ? scene->r.engine : "CYCLES";
1409
1410     if (STREQ(engine, RE_engine_id_CYCLES)) {
1411       for (Camera *camera = bmain->cameras.first; camera; camera = camera->id.next) {
1412         IDProperty *ccamera = cycles_properties_from_ID(&camera->id);
1413         if (ccamera) {
1414           const bool is_fstop = cycles_property_int(ccamera, "aperture_type", 0) == 1;
1415
1416           camera->dof.aperture_fstop = cycles_property_float(ccamera, "aperture_fstop", 5.6f);
1417           camera->dof.aperture_blades = cycles_property_int(ccamera, "aperture_blades", 0);
1418           camera->dof.aperture_rotation = cycles_property_float(ccamera, "aperture_rotation", 0.0);
1419           camera->dof.aperture_ratio = cycles_property_float(ccamera, "aperture_ratio", 1.0f);
1420           camera->dof.flag |= CAM_DOF_ENABLED;
1421
1422           float aperture_size = cycles_property_float(ccamera, "aperture_size", 0.0f);
1423
1424           if (is_fstop) {
1425             continue;
1426           }
1427           else if (aperture_size > 0.0f) {
1428             if (camera->type == CAM_ORTHO) {
1429               camera->dof.aperture_fstop = 1.0f / (2.0f * aperture_size);
1430             }
1431             else {
1432               camera->dof.aperture_fstop = (camera->lens * 1e-3f) / (2.0f * aperture_size);
1433             }
1434
1435             continue;
1436           }
1437         }
1438
1439         /* No depth of field, set default settings. */
1440         camera->dof.aperture_fstop = 2.8f;
1441         camera->dof.aperture_blades = 0;
1442         camera->dof.aperture_rotation = 0.0f;
1443         camera->dof.aperture_ratio = 1.0f;
1444         camera->dof.flag &= ~CAM_DOF_ENABLED;
1445       }
1446     }
1447   }
1448
1449   if (!MAIN_VERSION_ATLEAST(bmain, 281, 2)) {
1450     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1451       if (ntree->type == NTREE_SHADER) {
1452         update_math_node_single_operand_operators(ntree);
1453       }
1454     }
1455     FOREACH_NODETREE_END;
1456   }
1457
1458   if (!MAIN_VERSION_ATLEAST(bmain, 281, 3)) {
1459     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1460       if (ntree->type == NTREE_SHADER) {
1461         update_vector_math_node_add_and_subtract_operators(ntree);
1462         update_vector_math_node_dot_product_operator(ntree);
1463         update_vector_math_node_cross_product_operator(ntree);
1464         update_vector_math_node_normalize_operator(ntree);
1465         update_vector_math_node_average_operator(ntree);
1466       }
1467     }
1468     FOREACH_NODETREE_END;
1469   }
1470
1471   if (!MAIN_VERSION_ATLEAST(bmain, 281, 7)) {
1472     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1473       if (ntree->type == NTREE_SHADER) {
1474         update_noise_node_dimensions(ntree);
1475       }
1476     }
1477     FOREACH_NODETREE_END;
1478   }
1479
1480   if (!MAIN_VERSION_ATLEAST(bmain, 281, 8)) {
1481     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1482       if (ntree->type == NTREE_SHADER) {
1483         update_mapping_node_inputs_and_properties(ntree);
1484       }
1485     }
1486     FOREACH_NODETREE_END;
1487   }
1488
1489   if (!MAIN_VERSION_ATLEAST(bmain, 281, 10)) {
1490     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1491       if (ntree->type == NTREE_SHADER) {
1492         update_musgrave_node_dimensions(ntree);
1493       }
1494     }
1495     FOREACH_NODETREE_END;
1496   }
1497
1498   if (!MAIN_VERSION_ATLEAST(bmain, 281, 11)) {
1499     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1500       if (ntree->type == NTREE_SHADER) {
1501         update_voronoi_node_dimensions(ntree);
1502         update_voronoi_node_crackle(ntree);
1503         update_voronoi_node_coloring(ntree);
1504         update_voronoi_node_square_distance(ntree);
1505       }
1506     }
1507     FOREACH_NODETREE_END;
1508   }
1509
1510   if (!MAIN_VERSION_ATLEAST(bmain, 282, 4)) {
1511     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1512       if (ntree->type == NTREE_SHADER) {
1513         update_noise_and_wave_distortion(ntree);
1514       }
1515     }
1516     FOREACH_NODETREE_END;
1517   }
1518
1519   if (!MAIN_VERSION_ATLEAST(bmain, 283, 4)) {
1520     FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
1521       if (ntree->type == NTREE_SHADER) {
1522         update_wave_node_directions_and_offset(ntree);
1523       }
1524     }
1525     FOREACH_NODETREE_END;
1526   }
1527 }