92b24d40b0dc1f71ac1135666eeac087b6950a1a
[blender.git] / source / blender / nodes / shader / node_shader_tree.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  * The Original Code is Copyright (C) 2007 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup nodes
22  */
23
24 #include <string.h>
25
26 #include "DNA_light_types.h"
27 #include "DNA_material_types.h"
28 #include "DNA_node_types.h"
29 #include "DNA_scene_types.h"
30 #include "DNA_space_types.h"
31 #include "DNA_world_types.h"
32 #include "DNA_linestyle_types.h"
33 #include "DNA_workspace_types.h"
34
35 #include "BLI_listbase.h"
36 #include "BLI_threads.h"
37 #include "BLI_utildefines.h"
38 #include "BLI_alloca.h"
39
40 #include "BLT_translation.h"
41
42 #include "BKE_context.h"
43 #include "BKE_linestyle.h"
44 #include "BKE_node.h"
45 #include "BKE_scene.h"
46 #include "BKE_library.h"
47
48 #include "RNA_access.h"
49
50 #include "GPU_material.h"
51
52 #include "RE_shader_ext.h"
53
54 #include "NOD_common.h"
55
56 #include "node_common.h"
57 #include "node_exec.h"
58 #include "node_util.h"
59 #include "node_shader_util.h"
60
61 typedef struct nTreeTags {
62   float ssr_id, sss_id;
63 } nTreeTags;
64
65 static void ntree_shader_tag_nodes(bNodeTree *ntree, bNode *output_node, nTreeTags *tags);
66
67 static bool shader_tree_poll(const bContext *C, bNodeTreeType *UNUSED(treetype))
68 {
69   Scene *scene = CTX_data_scene(C);
70   const char *engine_id = scene->r.engine;
71
72   /* Allow empty engine string too,
73    * this is from older versions that didn't have registerable engines yet. */
74   return (engine_id[0] == '\0' || STREQ(engine_id, RE_engine_id_CYCLES) ||
75           !BKE_scene_use_shading_nodes_custom(scene));
76 }
77
78 static void shader_get_from_context(const bContext *C,
79                                     bNodeTreeType *UNUSED(treetype),
80                                     bNodeTree **r_ntree,
81                                     ID **r_id,
82                                     ID **r_from)
83 {
84   SpaceNode *snode = CTX_wm_space_node(C);
85   Scene *scene = CTX_data_scene(C);
86   ViewLayer *view_layer = CTX_data_view_layer(C);
87   Object *ob = OBACT(view_layer);
88
89   if (snode->shaderfrom == SNODE_SHADER_OBJECT) {
90     if (ob) {
91       *r_from = &ob->id;
92       if (ob->type == OB_LAMP) {
93         *r_id = ob->data;
94         *r_ntree = ((Light *)ob->data)->nodetree;
95       }
96       else {
97         Material *ma = give_current_material(ob, ob->actcol);
98         if (ma) {
99           *r_id = &ma->id;
100           *r_ntree = ma->nodetree;
101         }
102       }
103     }
104   }
105 #ifdef WITH_FREESTYLE
106   else if (snode->shaderfrom == SNODE_SHADER_LINESTYLE) {
107     FreestyleLineStyle *linestyle = BKE_linestyle_active_from_view_layer(view_layer);
108     if (linestyle) {
109       *r_from = NULL;
110       *r_id = &linestyle->id;
111       *r_ntree = linestyle->nodetree;
112     }
113   }
114 #endif
115   else { /* SNODE_SHADER_WORLD */
116     if (scene->world) {
117       *r_from = NULL;
118       *r_id = &scene->world->id;
119       *r_ntree = scene->world->nodetree;
120     }
121   }
122 }
123
124 static void foreach_nodeclass(Scene *UNUSED(scene), void *calldata, bNodeClassCallback func)
125 {
126   func(calldata, NODE_CLASS_INPUT, N_("Input"));
127   func(calldata, NODE_CLASS_OUTPUT, N_("Output"));
128   func(calldata, NODE_CLASS_SHADER, N_("Shader"));
129   func(calldata, NODE_CLASS_TEXTURE, N_("Texture"));
130   func(calldata, NODE_CLASS_OP_COLOR, N_("Color"));
131   func(calldata, NODE_CLASS_OP_VECTOR, N_("Vector"));
132   func(calldata, NODE_CLASS_CONVERTOR, N_("Convertor"));
133   func(calldata, NODE_CLASS_SCRIPT, N_("Script"));
134   func(calldata, NODE_CLASS_GROUP, N_("Group"));
135   func(calldata, NODE_CLASS_INTERFACE, N_("Interface"));
136   func(calldata, NODE_CLASS_LAYOUT, N_("Layout"));
137 }
138
139 static void localize(bNodeTree *localtree, bNodeTree *UNUSED(ntree))
140 {
141   bNode *node, *node_next;
142
143   /* replace muted nodes and reroute nodes by internal links */
144   for (node = localtree->nodes.first; node; node = node_next) {
145     node_next = node->next;
146
147     if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
148       nodeInternalRelink(localtree, node);
149       ntreeFreeLocalNode(localtree, node);
150     }
151   }
152 }
153
154 static void local_sync(bNodeTree *localtree, bNodeTree *ntree)
155 {
156   BKE_node_preview_sync_tree(ntree, localtree);
157 }
158
159 static void local_merge(Main *UNUSED(bmain), bNodeTree *localtree, bNodeTree *ntree)
160 {
161   BKE_node_preview_merge_tree(ntree, localtree, true);
162 }
163
164 static void update(bNodeTree *ntree)
165 {
166   ntreeSetOutput(ntree);
167
168   ntree_update_reroute_nodes(ntree);
169
170   if (ntree->update & NTREE_UPDATE_NODES) {
171     /* clean up preview cache, in case nodes have been removed */
172     BKE_node_preview_remove_unused(ntree);
173   }
174 }
175
176 static bool shader_validate_link(bNodeTree *UNUSED(ntree), bNodeLink *link)
177 {
178   /* Can't connect shader into other socket types, other way around is fine
179    * since it will be interpreted as emission. */
180   if (link->fromsock->type == SOCK_SHADER) {
181     return (link->tosock->type == SOCK_SHADER);
182   }
183   return true;
184 }
185
186 bNodeTreeType *ntreeType_Shader;
187
188 void register_node_tree_type_sh(void)
189 {
190   bNodeTreeType *tt = ntreeType_Shader = MEM_callocN(sizeof(bNodeTreeType),
191                                                      "shader node tree type");
192
193   tt->type = NTREE_SHADER;
194   strcpy(tt->idname, "ShaderNodeTree");
195   strcpy(tt->ui_name, N_("Shader Editor"));
196   tt->ui_icon = 0; /* defined in drawnode.c */
197   strcpy(tt->ui_description, N_("Shader nodes"));
198
199   tt->foreach_nodeclass = foreach_nodeclass;
200   tt->localize = localize;
201   tt->local_sync = local_sync;
202   tt->local_merge = local_merge;
203   tt->update = update;
204   tt->poll = shader_tree_poll;
205   tt->get_from_context = shader_get_from_context;
206   tt->validate_link = shader_validate_link;
207
208   tt->ext.srna = &RNA_ShaderNodeTree;
209
210   ntreeTypeAdd(tt);
211 }
212
213 /* GPU material from shader nodes */
214
215 static void ntree_shader_link_builtin_normal(bNodeTree *ntree,
216                                              bNode *node_from,
217                                              bNodeSocket *socket_from,
218                                              bNode *displacement_node,
219                                              bNodeSocket *displacement_socket);
220
221 static bNodeSocket *ntree_shader_node_find_input(bNode *node, const char *identifier);
222
223 static bNode *ntree_group_output_node(bNodeTree *ntree);
224
225 static bNode *ntree_shader_relink_output_from_group(bNodeTree *ntree,
226                                                     bNode *group_node,
227                                                     bNode *sh_output_node,
228                                                     int target)
229 {
230   int i;
231   bNodeTree *group_ntree = (bNodeTree *)group_node->id;
232
233   int sock_len = BLI_listbase_count(&sh_output_node->inputs);
234   bNodeSocket **group_surface_sockets = BLI_array_alloca(group_surface_sockets, sock_len);
235
236   /* Create output sockets to plug output connection to. */
237   i = 0;
238   for (bNodeSocket *sock = sh_output_node->inputs.first; sock; sock = sock->next, ++i) {
239     group_surface_sockets[i] = ntreeAddSocketInterface(
240         group_ntree, SOCK_OUT, sock->typeinfo->idname, sock->name);
241   }
242
243   bNode *group_output_node = ntree_group_output_node(group_ntree);
244
245   /* If no group output node is present, we need to create one. */
246   if (group_output_node == NULL) {
247     group_output_node = nodeAddStaticNode(NULL, group_ntree, NODE_GROUP_OUTPUT);
248   }
249
250   /* Need to update tree so all node instances nodes gets proper sockets. */
251   node_group_update(ntree, group_node);
252   node_group_output_update(group_ntree, group_output_node);
253   ntreeUpdateTree(G.main, group_ntree);
254
255   /* Remove other shader output nodes so that only the new one can be selected as active. */
256   for (bNode *node = ntree->nodes.first; node; node = node->next) {
257     if (ELEM(node->type, SH_NODE_OUTPUT_MATERIAL, SH_NODE_OUTPUT_WORLD, SH_NODE_OUTPUT_LIGHT)) {
258       ntreeFreeLocalNode(ntree, node);
259     }
260   }
261
262   /* Create new shader output node outside the group. */
263   bNode *new_output_node = nodeAddStaticNode(NULL, ntree, sh_output_node->type);
264   new_output_node->custom1 = target;
265
266   i = 0;
267   for (bNodeSocket *sock = sh_output_node->inputs.first; sock; sock = sock->next, ++i) {
268     if (sock->link != NULL) {
269       /* Link the shader output node incoming link to the group output sockets */
270       bNodeSocket *group_output_node_surface_input_sock = nodeFindSocket(
271           group_output_node, SOCK_IN, group_surface_sockets[i]->identifier);
272       nodeAddLink(group_ntree,
273                   sock->link->fromnode,
274                   sock->link->fromsock,
275                   group_output_node,
276                   group_output_node_surface_input_sock);
277
278       /* Link the group output sockets to the new shader output node. */
279       bNodeSocket *group_node_surface_output = nodeFindSocket(
280           group_node, SOCK_OUT, group_surface_sockets[i]->identifier);
281       bNodeSocket *output_node_surface_input = ntree_shader_node_find_input(new_output_node,
282                                                                             sock->name);
283
284       nodeAddLink(ntree,
285                   group_node,
286                   group_node_surface_output,
287                   new_output_node,
288                   output_node_surface_input);
289     }
290   }
291
292   ntreeUpdateTree(G.main, group_ntree);
293   ntreeUpdateTree(G.main, ntree);
294
295   return new_output_node;
296 }
297
298 static bNode *ntree_shader_output_node_from_group(bNodeTree *ntree, int target)
299 {
300   bNode *output_node = NULL;
301
302   /* Search if node groups do not contain valid output nodes (recursively). */
303   for (bNode *node = ntree->nodes.first; node; node = node->next) {
304     if (!ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) {
305       continue;
306     }
307     if (node->id != NULL) {
308       output_node = ntree_shader_output_node_from_group((bNodeTree *)node->id, target);
309
310       if (output_node == NULL) {
311         output_node = ntreeShaderOutputNode((bNodeTree *)node->id, target);
312       }
313
314       if (output_node != NULL) {
315         /* Output is inside this group node. Create relink to make the output outside the group. */
316         output_node = ntree_shader_relink_output_from_group(ntree, node, output_node, target);
317         break;
318       }
319     }
320   }
321   return output_node;
322 }
323
324 /* Find an output node of the shader tree.
325  *
326  * NOTE: it will only return output which is NOT in the group, which isn't how
327  * render engines works but it's how the GPU shader compilation works. This we
328  * can change in the future and make it a generic function, but for now it stays
329  * private here.
330  */
331 bNode *ntreeShaderOutputNode(bNodeTree *ntree, int target)
332 {
333   /* Make sure we only have single node tagged as output. */
334   ntreeSetOutput(ntree);
335
336   /* Find output node that matches type and target. If there are
337    * multiple, we prefer exact target match and active nodes. */
338   bNode *output_node = NULL;
339
340   for (bNode *node = ntree->nodes.first; node; node = node->next) {
341     if (!ELEM(node->type, SH_NODE_OUTPUT_MATERIAL, SH_NODE_OUTPUT_WORLD, SH_NODE_OUTPUT_LIGHT)) {
342       continue;
343     }
344
345     if (node->custom1 == SHD_OUTPUT_ALL) {
346       if (output_node == NULL) {
347         output_node = node;
348       }
349       else if (output_node->custom1 == SHD_OUTPUT_ALL) {
350         if ((node->flag & NODE_DO_OUTPUT) && !(output_node->flag & NODE_DO_OUTPUT)) {
351           output_node = node;
352         }
353       }
354     }
355     else if (node->custom1 == target) {
356       if (output_node == NULL) {
357         output_node = node;
358       }
359       else if (output_node->custom1 == SHD_OUTPUT_ALL) {
360         output_node = node;
361       }
362       else if ((node->flag & NODE_DO_OUTPUT) && !(output_node->flag & NODE_DO_OUTPUT)) {
363         output_node = node;
364       }
365     }
366   }
367
368   return output_node;
369 }
370
371 /* Find the active output node of a group nodetree.
372  *
373  * Does not return the shading output node but the group output node.
374  */
375 static bNode *ntree_group_output_node(bNodeTree *ntree)
376 {
377   /* Make sure we only have single node tagged as output. */
378   ntreeSetOutput(ntree);
379
380   /* Find output node that matches type and target. If there are
381    * multiple, we prefer exact target match and active nodes. */
382   bNode *output_node = NULL;
383
384   for (bNode *node = ntree->nodes.first; node; node = node->next) {
385     if ((node->type == NODE_GROUP_OUTPUT) && (node->flag & NODE_DO_OUTPUT)) {
386       output_node = node;
387     }
388   }
389
390   return output_node;
391 }
392
393 /* Find socket with a specified identifier. */
394 static bNodeSocket *ntree_shader_node_find_socket(ListBase *sockets, const char *identifier)
395 {
396   for (bNodeSocket *sock = sockets->first; sock != NULL; sock = sock->next) {
397     if (STREQ(sock->identifier, identifier)) {
398       return sock;
399     }
400   }
401   return NULL;
402 }
403
404 /* Find input socket with a specified identifier. */
405 static bNodeSocket *ntree_shader_node_find_input(bNode *node, const char *identifier)
406 {
407   return ntree_shader_node_find_socket(&node->inputs, identifier);
408 }
409
410 /* Find output socket with a specified identifier. */
411 static bNodeSocket *ntree_shader_node_find_output(bNode *node, const char *identifier)
412 {
413   return ntree_shader_node_find_socket(&node->outputs, identifier);
414 }
415
416 static void ntree_shader_unlink_hidden_value_sockets(bNode *group_node, bNodeSocket *isock)
417 {
418   bNodeTree *group_ntree = (bNodeTree *)group_node->id;
419   bNode *node;
420   bool removed_link = false;
421
422   for (node = group_ntree->nodes.first; node; node = node->next) {
423     for (bNodeSocket *sock = node->inputs.first; sock; sock = sock->next) {
424       if ((sock->flag & SOCK_HIDE_VALUE) == 0) {
425         continue;
426       }
427       /* If socket is linked to a group input node and sockets id match. */
428       if (sock && sock->link && sock->link->fromnode->type == NODE_GROUP_INPUT) {
429         if (STREQ(isock->identifier, sock->link->fromsock->identifier)) {
430           nodeRemLink(group_ntree, sock->link);
431           removed_link = true;
432         }
433       }
434     }
435   }
436
437   if (removed_link) {
438     ntreeUpdateTree(G.main, group_ntree);
439   }
440 }
441
442 /* Node groups once expanded looses their input sockets values.
443  * To fix this, link value/rgba nodes into the sockets and copy the group sockets values. */
444 static void ntree_shader_groups_expand_inputs(bNodeTree *localtree)
445 {
446   bNode *value_node, *group_node;
447   bNodeSocket *value_socket;
448   bNodeSocketValueVector *src_vector;
449   bNodeSocketValueRGBA *src_rgba, *dst_rgba;
450   bNodeSocketValueFloat *src_float, *dst_float;
451   bNodeSocketValueInt *src_int;
452   bool link_added = false;
453
454   for (group_node = localtree->nodes.first; group_node; group_node = group_node->next) {
455
456     if (!(ELEM(group_node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) || group_node->id == NULL) {
457       continue;
458     }
459
460     /* Do it recursively. */
461     ntree_shader_groups_expand_inputs((bNodeTree *)group_node->id);
462
463     bNodeSocket *group_socket = group_node->inputs.first;
464     for (; group_socket; group_socket = group_socket->next) {
465       if (group_socket->link != NULL) {
466         continue;
467       }
468
469       /* Detect the case where an input is plugged into a hidden value socket.
470        * In this case we should just remove the link to trigger the socket default override. */
471       ntree_shader_unlink_hidden_value_sockets(group_node, group_socket);
472
473       switch (group_socket->type) {
474         case SOCK_VECTOR:
475           value_node = nodeAddStaticNode(NULL, localtree, SH_NODE_RGB);
476           value_socket = ntree_shader_node_find_output(value_node, "Color");
477           BLI_assert(value_socket != NULL);
478           src_vector = group_socket->default_value;
479           dst_rgba = value_socket->default_value;
480           copy_v3_v3(dst_rgba->value, src_vector->value);
481           dst_rgba->value[3] = 1.0f; /* should never be read */
482           break;
483         case SOCK_RGBA:
484           value_node = nodeAddStaticNode(NULL, localtree, SH_NODE_RGB);
485           value_socket = ntree_shader_node_find_output(value_node, "Color");
486           BLI_assert(value_socket != NULL);
487           src_rgba = group_socket->default_value;
488           dst_rgba = value_socket->default_value;
489           copy_v4_v4(dst_rgba->value, src_rgba->value);
490           break;
491         case SOCK_INT:
492           /* HACK: Support as float. */
493           value_node = nodeAddStaticNode(NULL, localtree, SH_NODE_VALUE);
494           value_socket = ntree_shader_node_find_output(value_node, "Value");
495           BLI_assert(value_socket != NULL);
496           src_int = group_socket->default_value;
497           dst_float = value_socket->default_value;
498           dst_float->value = (float)(src_int->value);
499           break;
500         case SOCK_FLOAT:
501           value_node = nodeAddStaticNode(NULL, localtree, SH_NODE_VALUE);
502           value_socket = ntree_shader_node_find_output(value_node, "Value");
503           BLI_assert(value_socket != NULL);
504           src_float = group_socket->default_value;
505           dst_float = value_socket->default_value;
506           dst_float->value = src_float->value;
507           break;
508         default:
509           continue;
510       }
511
512       nodeAddLink(localtree, value_node, value_socket, group_node, group_socket);
513
514       link_added = true;
515     }
516   }
517
518   if (link_added) {
519     ntreeUpdateTree(G.main, localtree);
520   }
521 }
522
523 /* Check whether shader has a displacement.
524  *
525  * Will also return a node and it's socket which is connected to a displacement
526  * output. Additionally, link which is attached to the displacement output is
527  * also returned.
528  */
529 static bool ntree_shader_has_displacement(bNodeTree *ntree,
530                                           bNode *output_node,
531                                           bNode **r_node,
532                                           bNodeSocket **r_socket,
533                                           bNodeLink **r_link)
534 {
535   if (output_node == NULL) {
536     /* We can't have displacement without output node, apparently. */
537     return false;
538   }
539   /* Make sure sockets links pointers are correct. */
540   ntreeUpdateTree(G.main, ntree);
541   bNodeSocket *displacement = ntree_shader_node_find_input(output_node, "Displacement");
542
543   if (displacement == NULL) {
544     /* Non-cycles node is used as an output. */
545     return false;
546   }
547   if (displacement->link != NULL) {
548     *r_node = displacement->link->fromnode;
549     *r_socket = displacement->link->fromsock;
550     *r_link = displacement->link;
551   }
552   return displacement->link != NULL;
553 }
554
555 static void ntree_shader_relink_node_normal(bNodeTree *ntree,
556                                             bNode *node,
557                                             bNode *node_from,
558                                             bNodeSocket *socket_from)
559 {
560   /* TODO(sergey): Can we do something smarter here than just a name-based
561    * matching?
562    */
563   for (bNodeSocket *sock = node->inputs.first; sock; sock = sock->next) {
564     if (STREQ(sock->identifier, "Normal") && sock->link == NULL) {
565       /* It's a normal input and nothing is connected to it. */
566       nodeAddLink(ntree, node_from, socket_from, node, sock);
567     }
568     else if (sock->link) {
569       bNodeLink *link = sock->link;
570       if (ELEM(link->fromnode->type, SH_NODE_NEW_GEOMETRY, SH_NODE_TEX_COORD) &&
571           STREQ(link->fromsock->identifier, "Normal")) {
572         /* Linked to a geometry node normal output. */
573         nodeAddLink(ntree, node_from, socket_from, node, sock);
574       }
575     }
576   }
577 }
578
579 static void ntree_shader_link_builtin_group_normal(bNodeTree *ntree,
580                                                    bNode *group_node,
581                                                    bNode *node_from,
582                                                    bNodeSocket *socket_from,
583                                                    bNode *displacement_node,
584                                                    bNodeSocket *displacement_socket)
585 {
586   bNodeTree *group_ntree = (bNodeTree *)group_node->id;
587   /* Create input socket to plug displacement connection to. */
588   bNodeSocket *group_normal_socket = ntreeAddSocketInterface(
589       group_ntree, SOCK_IN, "NodeSocketVector", "Normal");
590   /* Need to update tree so all node instances nodes gets proper sockets. */
591   bNode *group_input_node = ntreeFindType(group_ntree, NODE_GROUP_INPUT);
592   node_group_update(ntree, group_node);
593   if (group_input_node) {
594     node_group_input_update(group_ntree, group_input_node);
595   }
596   ntreeUpdateTree(G.main, group_ntree);
597   /* Assumes sockets are always added at the end. */
598   bNodeSocket *group_node_normal_socket = group_node->inputs.last;
599   if (displacement_node == group_node) {
600     /* This should never happen as all displacement nodes are duplicated and tagged. */
601     BLI_assert(0);
602   }
603   else if (group_input_node) {
604     /* Connect group node normal input. */
605     nodeAddLink(ntree, node_from, socket_from, group_node, group_node_normal_socket);
606     BLI_assert(group_input_node != NULL);
607     bNodeSocket *group_input_node_normal_socket = nodeFindSocket(
608         group_input_node, SOCK_OUT, group_normal_socket->identifier);
609     BLI_assert(group_input_node_normal_socket != NULL);
610     /* Relink normals inside of the instanced tree. */
611     ntree_shader_link_builtin_normal(group_ntree,
612                                      group_input_node,
613                                      group_input_node_normal_socket,
614                                      displacement_node,
615                                      displacement_socket);
616     ntreeUpdateTree(G.main, group_ntree);
617   }
618 }
619
620 /* Use specified node and socket as an input for unconnected normal sockets. */
621 static void ntree_shader_link_builtin_normal(bNodeTree *ntree,
622                                              bNode *node_from,
623                                              bNodeSocket *socket_from,
624                                              bNode *displacement_node,
625                                              bNodeSocket *displacement_socket)
626 {
627   for (bNode *node = ntree->nodes.first; node != NULL; node = node->next) {
628     if (node == node_from) {
629       /* Don't connect node itself! */
630       continue;
631     }
632     if (node->tmp_flag == -2) {
633       /* This node is used inside the displacement tree. Skip to avoid cycles. */
634       continue;
635     }
636     if ((ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP)) && node->id) {
637       /* Special re-linking for group nodes. */
638       ntree_shader_link_builtin_group_normal(
639           ntree, node, node_from, socket_from, displacement_node, displacement_socket);
640       continue;
641     }
642     if (ELEM(node->type, NODE_GROUP_INPUT, NODE_GROUP_OUTPUT)) {
643       /* Group inputs and outputs needs nothing special. */
644       continue;
645     }
646     ntree_shader_relink_node_normal(ntree, node, node_from, socket_from);
647   }
648 }
649
650 static void ntree_shader_bypass_bump_link(bNodeTree *ntree, bNode *bump_node, bNodeLink *bump_link)
651 {
652   /* Bypass bump nodes. This replicates cycles "implicit" behavior. */
653   bNodeSocket *bump_normal_input = ntree_shader_node_find_input(bump_node, "Normal");
654   bNode *fromnode;
655   bNodeSocket *fromsock;
656   /* Default to builtin normals if there is no link. */
657   if (bump_normal_input->link) {
658     fromsock = bump_normal_input->link->fromsock;
659     fromnode = bump_normal_input->link->fromnode;
660   }
661   else {
662     fromnode = nodeAddStaticNode(NULL, ntree, SH_NODE_NEW_GEOMETRY);
663     fromsock = ntree_shader_node_find_output(fromnode, "Normal");
664   }
665   /* Bypass the bump node by creating a link between the previous and next node. */
666   nodeAddLink(ntree, fromnode, fromsock, bump_link->tonode, bump_link->tosock);
667   nodeRemLink(ntree, bump_link);
668 }
669
670 static void ntree_shader_bypass_tagged_bump_nodes(bNodeTree *ntree)
671 {
672   /* Bypass bump links inside copied nodes */
673   bNodeLink *link, *link_next;
674   for (link = ntree->links.first; link; link = link_next) {
675     /* link might be freed by ntree_shader_bypass_bump_link. */
676     link_next = link->next;
677     bNode *node = link->fromnode;
678     /* If node is a copy. */
679     if (node->tmp_flag == -2 && node->type == SH_NODE_BUMP) {
680       ntree_shader_bypass_bump_link(ntree, node, link);
681     }
682   }
683   /* Do the same inside nodegroups. */
684   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
685     /* If node is a copy. */
686     if (node->tmp_flag == -2 && ELEM(node->type, NODE_GROUP, NODE_CUSTOM_GROUP) && node->id) {
687       bNodeTree *group_ntree = (bNodeTree *)node->id;
688       /* Tag all nodes inside this group as copies. */
689       LISTBASE_FOREACH (bNode *, group_node, &group_ntree->nodes) {
690         group_node->tmp_flag = -2;
691       }
692       /* Recursive. */
693       ntree_shader_bypass_tagged_bump_nodes(group_ntree);
694     }
695   }
696   ntreeUpdateTree(G.main, ntree);
697 }
698
699 static bool ntree_branch_count_and_tag_nodes(bNode *fromnode,
700                                              bNode *tonode,
701                                              void *userdata,
702                                              const bool UNUSED(reversed))
703 {
704   int *node_count = (int *)userdata;
705   if (fromnode->tmp_flag == -1) {
706     fromnode->tmp_flag = *node_count;
707     (*node_count)++;
708   }
709   if (tonode->tmp_flag == -1) {
710     tonode->tmp_flag = *node_count;
711     (*node_count)++;
712   }
713   return true;
714 }
715
716 static void ntree_shader_copy_branch_displacement(bNodeTree *ntree,
717                                                   bNode *displacement_node,
718                                                   bNodeSocket *displacement_socket,
719                                                   bNodeLink *displacement_link)
720 {
721   /* Init tmp flag. */
722   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
723     node->tmp_flag = -1;
724   }
725   /* Count and tag all nodes inside the displacement branch of the tree. */
726   displacement_node->tmp_flag = 0;
727   int node_count = 1;
728   nodeChainIter(ntree, displacement_node, ntree_branch_count_and_tag_nodes, &node_count, true);
729   /* Make a full copy of the branch */
730   bNode **nodes_copy = MEM_mallocN(sizeof(bNode *) * node_count, __func__);
731   LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
732     if (node->tmp_flag >= 0) {
733       int id = node->tmp_flag;
734       nodes_copy[id] = BKE_node_copy_ex(ntree, node, LIB_ID_CREATE_NO_USER_REFCOUNT);
735       nodes_copy[id]->tmp_flag = -2; /* Copy */
736       if (ELEM(nodes_copy[id]->type, NODE_GROUP, NODE_CUSTOM_GROUP) && nodes_copy[id]->id) {
737         nodes_copy[id]->id = (ID *)ntreeLocalize((bNodeTree *)nodes_copy[id]->id);
738       }
739       /* Make sure to clear all sockets links as they are invalid. */
740       LISTBASE_FOREACH (bNodeSocket *, sock, &nodes_copy[id]->inputs) {
741         sock->link = NULL;
742       }
743       LISTBASE_FOREACH (bNodeSocket *, sock, &nodes_copy[id]->outputs) {
744         sock->link = NULL;
745       }
746     }
747   }
748   /* Recreate links between copied nodes. */
749   LISTBASE_FOREACH (bNodeLink *, link, &ntree->links) {
750     if (link->fromnode->tmp_flag >= 0 && link->tonode->tmp_flag >= 0) {
751       bNode *fromnode = nodes_copy[link->fromnode->tmp_flag];
752       bNode *tonode = nodes_copy[link->tonode->tmp_flag];
753       bNodeSocket *fromsock = ntree_shader_node_find_output(fromnode, link->fromsock->identifier);
754       bNodeSocket *tosock = ntree_shader_node_find_input(tonode, link->tosock->identifier);
755       nodeAddLink(ntree, fromnode, fromsock, tonode, tosock);
756     }
757   }
758   /* Replace displacement socket/node/link. */
759   bNode *tonode = displacement_link->tonode;
760   bNodeSocket *tosock = displacement_link->tosock;
761   displacement_node = nodes_copy[displacement_node->tmp_flag];
762   displacement_socket = ntree_shader_node_find_output(displacement_node,
763                                                       displacement_socket->identifier);
764   nodeRemLink(ntree, displacement_link);
765   nodeAddLink(ntree, displacement_node, displacement_socket, tonode, tosock);
766   MEM_freeN(nodes_copy);
767
768   ntreeUpdateTree(G.main, ntree);
769 }
770
771 /* Re-link displacement output to unconnected normal sockets via bump node.
772  * This way material with have proper displacement in the viewport.
773  */
774 static void ntree_shader_relink_displacement(bNodeTree *ntree, bNode *output_node)
775 {
776   bNode *displacement_node;
777   bNodeSocket *displacement_socket;
778   bNodeLink *displacement_link;
779   if (!ntree_shader_has_displacement(
780           ntree, output_node, &displacement_node, &displacement_socket, &displacement_link)) {
781     /* There is no displacement output connected, nothing to re-link. */
782     return;
783   }
784
785   /* Copy the whole displacement branch to avoid cyclic dependancy
786    * and issue when bypassing bump nodes. */
787   ntree_shader_copy_branch_displacement(
788       ntree, displacement_node, displacement_socket, displacement_link);
789   /* Bypass bump nodes inside the copied branch to mimic cycles behavior. */
790   ntree_shader_bypass_tagged_bump_nodes(ntree);
791
792   /* Displacement Node may have changed because of branch copy and bump bypass. */
793   ntree_shader_has_displacement(
794       ntree, output_node, &displacement_node, &displacement_socket, &displacement_link);
795
796   /* We have to disconnect displacement output socket, otherwise we'll have
797    * cycles in the Cycles material :)
798    */
799   nodeRemLink(ntree, displacement_link);
800
801   /* Convert displacement vector to bump height. */
802   bNode *dot_node = nodeAddStaticNode(NULL, ntree, SH_NODE_VECT_MATH);
803   bNode *geo_node = nodeAddStaticNode(NULL, ntree, SH_NODE_NEW_GEOMETRY);
804   bNodeSocket *normal_socket = ntree_shader_node_find_output(geo_node, "Normal");
805   dot_node->custom1 = 3; /* dot product */
806
807   nodeAddLink(ntree, displacement_node, displacement_socket, dot_node, dot_node->inputs.first);
808   nodeAddLink(ntree, geo_node, normal_socket, dot_node, dot_node->inputs.last);
809   displacement_node = dot_node;
810   displacement_socket = ntree_shader_node_find_output(dot_node, "Value");
811
812   /* We can't connect displacement to normal directly, use bump node for that
813    * and hope that it gives good enough approximation.
814    */
815   bNode *bump_node = nodeAddStaticNode(NULL, ntree, SH_NODE_BUMP);
816   bNodeSocket *bump_input_socket = ntree_shader_node_find_input(bump_node, "Height");
817   bNodeSocket *bump_output_socket = ntree_shader_node_find_output(bump_node, "Normal");
818   BLI_assert(bump_input_socket != NULL);
819   BLI_assert(bump_output_socket != NULL);
820   /* Connect bump node to where displacement output was originally
821    * connected to.
822    */
823   nodeAddLink(ntree, displacement_node, displacement_socket, bump_node, bump_input_socket);
824
825   /* Tag as part of the new displacmeent tree. */
826   dot_node->tmp_flag = -2;
827   geo_node->tmp_flag = -2;
828   bump_node->tmp_flag = -2;
829
830   ntreeUpdateTree(G.main, ntree);
831
832   /* Connect all free-standing Normal inputs and relink geometry/coordinate nodes. */
833   ntree_shader_link_builtin_normal(
834       ntree, bump_node, bump_output_socket, displacement_node, displacement_socket);
835   /* We modified the tree, it needs to be updated now. */
836   ntreeUpdateTree(G.main, ntree);
837 }
838
839 static bool ntree_tag_bsdf_cb(bNode *fromnode,
840                               bNode *UNUSED(tonode),
841                               void *userdata,
842                               const bool UNUSED(reversed))
843 {
844   /* Don't evaluate nodes more than once. */
845   if (fromnode->tmp_flag) {
846     return true;
847   }
848   fromnode->tmp_flag = 1;
849
850   switch (fromnode->type) {
851     case NODE_GROUP:
852     case NODE_CUSTOM_GROUP:
853       /* Recursive */
854       if (fromnode->id != NULL) {
855         bNodeTree *ntree = (bNodeTree *)fromnode->id;
856         bNode *group_output = ntree_group_output_node(ntree);
857         ntree_shader_tag_nodes(ntree, group_output, (nTreeTags *)userdata);
858       }
859       break;
860     case SH_NODE_BSDF_ANISOTROPIC:
861     case SH_NODE_EEVEE_SPECULAR:
862     case SH_NODE_BSDF_GLOSSY:
863     case SH_NODE_BSDF_GLASS:
864       fromnode->ssr_id = ((nTreeTags *)userdata)->ssr_id;
865       ((nTreeTags *)userdata)->ssr_id += 1;
866       break;
867     case SH_NODE_SUBSURFACE_SCATTERING:
868       fromnode->sss_id = ((nTreeTags *)userdata)->sss_id;
869       ((nTreeTags *)userdata)->sss_id += 1;
870       break;
871     case SH_NODE_BSDF_PRINCIPLED:
872       fromnode->ssr_id = ((nTreeTags *)userdata)->ssr_id;
873       fromnode->sss_id = ((nTreeTags *)userdata)->sss_id;
874       ((nTreeTags *)userdata)->sss_id += 1;
875       ((nTreeTags *)userdata)->ssr_id += 1;
876       break;
877     default:
878       /* We could return false here but since we
879        * allow the use of Closure as RGBA, we can have
880        * Bsdf nodes linked to other Bsdf nodes. */
881       break;
882   }
883
884   return true;
885 }
886
887 /* EEVEE: Scan the ntree to set the Screen Space Reflection
888  * layer id of every specular node AND the Subsurface Scattering id of every SSS node.
889  */
890 void ntree_shader_tag_nodes(bNodeTree *ntree, bNode *output_node, nTreeTags *tags)
891 {
892   if (output_node == NULL) {
893     return;
894   }
895   /* Make sure sockets links pointers are correct. */
896   ntreeUpdateTree(G.main, ntree);
897
898   /* Reset visit flag. */
899   for (bNode *node = ntree->nodes.first; node; node = node->next) {
900     node->tmp_flag = 0;
901   }
902
903   nodeChainIter(ntree, output_node, ntree_tag_bsdf_cb, tags, true);
904 }
905
906 /* This one needs to work on a local tree. */
907 void ntreeGPUMaterialNodes(bNodeTree *localtree,
908                            GPUMaterial *mat,
909                            bool *has_surface_output,
910                            bool *has_volume_output)
911 {
912   bNodeTreeExec *exec;
913
914   /* Extract output nodes from inside nodegroups. */
915   ntree_shader_output_node_from_group(localtree, SHD_OUTPUT_EEVEE);
916
917   bNode *output = ntreeShaderOutputNode(localtree, SHD_OUTPUT_EEVEE);
918
919   ntree_shader_groups_expand_inputs(localtree);
920
921   /* Perform all needed modifications on the tree in order to support
922    * displacement/bump mapping.
923    */
924   ntree_shader_relink_displacement(localtree, output);
925
926   /* TODO(fclem): consider moving this to the gpu shader tree evaluation. */
927   nTreeTags tags = {
928       .ssr_id = 1.0,
929       .sss_id = 1.0,
930   };
931   ntree_shader_tag_nodes(localtree, output, &tags);
932
933   exec = ntreeShaderBeginExecTree(localtree);
934   ntreeExecGPUNodes(exec, mat, output);
935   ntreeShaderEndExecTree(exec);
936
937   /* EEVEE: Find which material domain was used (volume, surface ...). */
938   *has_surface_output = false;
939   *has_volume_output = false;
940
941   if (output != NULL) {
942     bNodeSocket *surface_sock = ntree_shader_node_find_input(output, "Surface");
943     bNodeSocket *volume_sock = ntree_shader_node_find_input(output, "Volume");
944
945     if (surface_sock != NULL) {
946       *has_surface_output = (nodeCountSocketLinks(localtree, surface_sock) > 0);
947     }
948
949     if (volume_sock != NULL) {
950       *has_volume_output = (nodeCountSocketLinks(localtree, volume_sock) > 0);
951     }
952   }
953 }
954
955 bNodeTreeExec *ntreeShaderBeginExecTree_internal(bNodeExecContext *context,
956                                                  bNodeTree *ntree,
957                                                  bNodeInstanceKey parent_key)
958 {
959   bNodeTreeExec *exec;
960   bNode *node;
961
962   /* ensures only a single output node is enabled */
963   ntreeSetOutput(ntree);
964
965   /* common base initialization */
966   exec = ntree_exec_begin(context, ntree, parent_key);
967
968   /* allocate the thread stack listbase array */
969   exec->threadstack = MEM_callocN(BLENDER_MAX_THREADS * sizeof(ListBase), "thread stack array");
970
971   for (node = exec->nodetree->nodes.first; node; node = node->next) {
972     node->need_exec = 1;
973   }
974
975   return exec;
976 }
977
978 bNodeTreeExec *ntreeShaderBeginExecTree(bNodeTree *ntree)
979 {
980   bNodeExecContext context;
981   bNodeTreeExec *exec;
982
983   /* XXX hack: prevent exec data from being generated twice.
984    * this should be handled by the renderer!
985    */
986   if (ntree->execdata) {
987     return ntree->execdata;
988   }
989
990   context.previews = ntree->previews;
991
992   exec = ntreeShaderBeginExecTree_internal(&context, ntree, NODE_INSTANCE_KEY_BASE);
993
994   /* XXX this should not be necessary, but is still used for cmp/sha/tex nodes,
995    * which only store the ntree pointer. Should be fixed at some point!
996    */
997   ntree->execdata = exec;
998
999   return exec;
1000 }
1001
1002 void ntreeShaderEndExecTree_internal(bNodeTreeExec *exec)
1003 {
1004   bNodeThreadStack *nts;
1005   int a;
1006
1007   if (exec->threadstack) {
1008     for (a = 0; a < BLENDER_MAX_THREADS; a++) {
1009       for (nts = exec->threadstack[a].first; nts; nts = nts->next) {
1010         if (nts->stack) {
1011           MEM_freeN(nts->stack);
1012         }
1013       }
1014       BLI_freelistN(&exec->threadstack[a]);
1015     }
1016
1017     MEM_freeN(exec->threadstack);
1018     exec->threadstack = NULL;
1019   }
1020
1021   ntree_exec_end(exec);
1022 }
1023
1024 void ntreeShaderEndExecTree(bNodeTreeExec *exec)
1025 {
1026   if (exec) {
1027     /* exec may get freed, so assign ntree */
1028     bNodeTree *ntree = exec->nodetree;
1029     ntreeShaderEndExecTree_internal(exec);
1030
1031     /* XXX clear nodetree backpointer to exec data, same problem as noted in ntreeBeginExecTree */
1032     ntree->execdata = NULL;
1033   }
1034 }
1035
1036 /* TODO: left over from Blender Internal, could reuse for new texture nodes. */
1037 bool ntreeShaderExecTree(bNodeTree *ntree, int thread)
1038 {
1039   ShaderCallData scd;
1040   bNodeThreadStack *nts = NULL;
1041   bNodeTreeExec *exec = ntree->execdata;
1042   int compat;
1043
1044   /* ensure execdata is only initialized once */
1045   if (!exec) {
1046     BLI_thread_lock(LOCK_NODES);
1047     if (!ntree->execdata) {
1048       ntree->execdata = ntreeShaderBeginExecTree(ntree);
1049     }
1050     BLI_thread_unlock(LOCK_NODES);
1051
1052     exec = ntree->execdata;
1053   }
1054
1055   nts = ntreeGetThreadStack(exec, thread);
1056   compat = ntreeExecThreadNodes(exec, nts, &scd, thread);
1057   ntreeReleaseThreadStack(nts);
1058
1059   /* if compat is zero, it has been using non-compatible nodes */
1060   return compat;
1061 }