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