Cryptomatte: Manifest Parsing.
[blender.git] / source / blender / nodes / intern / node_exec.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 "DNA_node_types.h"
25
26 #include "BLI_listbase.h"
27 #include "BLI_utildefines.h"
28
29 #include "BKE_global.h"
30 #include "BKE_node.h"
31
32 #include "MEM_guardedalloc.h"
33
34 #include "node_exec.h"
35 #include "node_util.h"
36
37 /* supported socket types in old nodes */
38 int node_exec_socket_use_stack(bNodeSocket *sock)
39 {
40   /* NOTE: INT supported as FLOAT. Only for EEVEE. */
41   return ELEM(sock->type, SOCK_INT, SOCK_FLOAT, SOCK_VECTOR, SOCK_RGBA, SOCK_SHADER);
42 }
43
44 /* for a given socket, find the actual stack entry */
45 bNodeStack *node_get_socket_stack(bNodeStack *stack, bNodeSocket *sock)
46 {
47   if (stack && sock && sock->stack_index >= 0) {
48     return stack + sock->stack_index;
49   }
50   return NULL;
51 }
52
53 void node_get_stack(bNode *node, bNodeStack *stack, bNodeStack **in, bNodeStack **out)
54 {
55   bNodeSocket *sock;
56
57   /* build pointer stack */
58   if (in) {
59     for (sock = node->inputs.first; sock; sock = sock->next) {
60       *(in++) = node_get_socket_stack(stack, sock);
61     }
62   }
63
64   if (out) {
65     for (sock = node->outputs.first; sock; sock = sock->next) {
66       *(out++) = node_get_socket_stack(stack, sock);
67     }
68   }
69 }
70
71 static void node_init_input_index(bNodeSocket *sock, int *index)
72 {
73   /* Only consider existing link if from socket is valid! */
74   if (sock->link && sock->link->fromsock && sock->link->fromsock->stack_index >= 0) {
75     sock->stack_index = sock->link->fromsock->stack_index;
76   }
77   else {
78     if (node_exec_socket_use_stack(sock)) {
79       sock->stack_index = (*index)++;
80     }
81     else {
82       sock->stack_index = -1;
83     }
84   }
85 }
86
87 static void node_init_output_index(bNodeSocket *sock, int *index, ListBase *internal_links)
88 {
89   if (internal_links) {
90     bNodeLink *link;
91     /* copy the stack index from internally connected input to skip the node */
92     for (link = internal_links->first; link; link = link->next) {
93       if (link->tosock == sock) {
94         sock->stack_index = link->fromsock->stack_index;
95         /* set the link pointer to indicate that this socket
96          * should not overwrite the stack value!
97          */
98         sock->link = link;
99         break;
100       }
101     }
102     /* if not internally connected, assign a new stack index anyway to avoid bad stack access */
103     if (!link) {
104       if (node_exec_socket_use_stack(sock)) {
105         sock->stack_index = (*index)++;
106       }
107       else {
108         sock->stack_index = -1;
109       }
110     }
111   }
112   else {
113     if (node_exec_socket_use_stack(sock)) {
114       sock->stack_index = (*index)++;
115     }
116     else {
117       sock->stack_index = -1;
118     }
119   }
120 }
121
122 /* basic preparation of socket stacks */
123 static struct bNodeStack *setup_stack(bNodeStack *stack,
124                                       bNodeTree *ntree,
125                                       bNode *node,
126                                       bNodeSocket *sock)
127 {
128   bNodeStack *ns = node_get_socket_stack(stack, sock);
129   if (!ns) {
130     return NULL;
131   }
132
133   /* don't mess with remote socket stacks, these are initialized by other nodes! */
134   if (sock->link) {
135     return ns;
136   }
137
138   ns->sockettype = sock->type;
139
140   switch (sock->type) {
141     case SOCK_FLOAT:
142       ns->vec[0] = node_socket_get_float(ntree, node, sock);
143       break;
144     case SOCK_VECTOR:
145       node_socket_get_vector(ntree, node, sock, ns->vec);
146       break;
147     case SOCK_RGBA:
148       node_socket_get_color(ntree, node, sock, ns->vec);
149       break;
150   }
151
152   return ns;
153 }
154
155 bNodeTreeExec *ntree_exec_begin(bNodeExecContext *context,
156                                 bNodeTree *ntree,
157                                 bNodeInstanceKey parent_key)
158 {
159   bNodeTreeExec *exec;
160   bNode *node;
161   bNodeExec *nodeexec;
162   bNodeInstanceKey nodekey;
163   bNodeSocket *sock;
164   bNodeStack *ns;
165   int index;
166   bNode **nodelist;
167   int totnodes, n;
168   /* XXX texnodes have threading issues with muting, have to disable it there ... */
169
170   /* ensure all sock->link pointers and node levels are correct */
171   /* Using global main here is likely totally wrong, not sure what to do about that one though...
172    * We cannot even check ntree is in global main,
173    * since most of the time it won't be (thanks to ntree design)!!! */
174   ntreeUpdateTree(G.main, ntree);
175
176   /* get a dependency-sorted list of nodes */
177   ntreeGetDependencyList(ntree, &nodelist, &totnodes);
178
179   /* XXX could let callbacks do this for specialized data */
180   exec = MEM_callocN(sizeof(bNodeTreeExec), "node tree execution data");
181   /* backpointer to node tree */
182   exec->nodetree = ntree;
183
184   /* set stack indices */
185   index = 0;
186   for (n = 0; n < totnodes; n++) {
187     node = nodelist[n];
188
189     /* init node socket stack indexes */
190     for (sock = node->inputs.first; sock; sock = sock->next) {
191       node_init_input_index(sock, &index);
192     }
193
194     if (node->flag & NODE_MUTED || node->type == NODE_REROUTE) {
195       for (sock = node->outputs.first; sock; sock = sock->next) {
196         node_init_output_index(sock, &index, &node->internal_links);
197       }
198     }
199     else {
200       for (sock = node->outputs.first; sock; sock = sock->next) {
201         node_init_output_index(sock, &index, NULL);
202       }
203     }
204   }
205
206   /* allocated exec data pointers for nodes */
207   exec->totnodes = totnodes;
208   exec->nodeexec = MEM_callocN(exec->totnodes * sizeof(bNodeExec), "node execution data");
209   /* allocate data pointer for node stack */
210   exec->stacksize = index;
211   exec->stack = MEM_callocN(exec->stacksize * sizeof(bNodeStack), "bNodeStack");
212
213   /* all non-const results are considered inputs */
214   for (n = 0; n < exec->stacksize; n++) {
215     exec->stack[n].hasinput = 1;
216   }
217
218   /* prepare all nodes for execution */
219   for (n = 0, nodeexec = exec->nodeexec; n < totnodes; n++, nodeexec++) {
220     node = nodeexec->node = nodelist[n];
221     nodeexec->freeexecfunc = node->typeinfo->freeexecfunc;
222
223     /* tag inputs */
224     for (sock = node->inputs.first; sock; sock = sock->next) {
225       /* disable the node if an input link is invalid */
226       if (sock->link && !(sock->link->flag & NODE_LINK_VALID)) {
227         node->need_exec = 0;
228       }
229
230       ns = setup_stack(exec->stack, ntree, node, sock);
231       if (ns) {
232         ns->hasoutput = 1;
233       }
234     }
235
236     /* tag all outputs */
237     for (sock = node->outputs.first; sock; sock = sock->next) {
238       /* ns = */ setup_stack(exec->stack, ntree, node, sock);
239     }
240
241     nodekey = BKE_node_instance_key(parent_key, ntree, node);
242     nodeexec->data.preview = context->previews ?
243                                  BKE_node_instance_hash_lookup(context->previews, nodekey) :
244                                  NULL;
245     if (node->typeinfo->initexecfunc) {
246       nodeexec->data.data = node->typeinfo->initexecfunc(context, node, nodekey);
247     }
248   }
249
250   if (nodelist) {
251     MEM_freeN(nodelist);
252   }
253
254   return exec;
255 }
256
257 void ntree_exec_end(bNodeTreeExec *exec)
258 {
259   bNodeExec *nodeexec;
260   int n;
261
262   if (exec->stack) {
263     MEM_freeN(exec->stack);
264   }
265
266   for (n = 0, nodeexec = exec->nodeexec; n < exec->totnodes; n++, nodeexec++) {
267     if (nodeexec->freeexecfunc) {
268       nodeexec->freeexecfunc(nodeexec->data.data);
269     }
270   }
271
272   if (exec->nodeexec) {
273     MEM_freeN(exec->nodeexec);
274   }
275
276   MEM_freeN(exec);
277 }
278
279 /**** Material/Texture trees ****/
280
281 bNodeThreadStack *ntreeGetThreadStack(bNodeTreeExec *exec, int thread)
282 {
283   ListBase *lb = &exec->threadstack[thread];
284   bNodeThreadStack *nts;
285
286   for (nts = lb->first; nts; nts = nts->next) {
287     if (!nts->used) {
288       nts->used = true;
289       break;
290     }
291   }
292
293   if (!nts) {
294     nts = MEM_callocN(sizeof(bNodeThreadStack), "bNodeThreadStack");
295     nts->stack = MEM_dupallocN(exec->stack);
296     nts->used = true;
297     BLI_addtail(lb, nts);
298   }
299
300   return nts;
301 }
302
303 void ntreeReleaseThreadStack(bNodeThreadStack *nts)
304 {
305   nts->used = 0;
306 }
307
308 bool ntreeExecThreadNodes(bNodeTreeExec *exec, bNodeThreadStack *nts, void *callerdata, int thread)
309 {
310   bNodeStack *nsin[MAX_SOCKET] = {NULL};  /* arbitrary... watch this */
311   bNodeStack *nsout[MAX_SOCKET] = {NULL}; /* arbitrary... watch this */
312   bNodeExec *nodeexec;
313   bNode *node;
314   int n;
315
316   /* nodes are presorted, so exec is in order of list */
317
318   for (n = 0, nodeexec = exec->nodeexec; n < exec->totnodes; n++, nodeexec++) {
319     node = nodeexec->node;
320     if (node->need_exec) {
321       node_get_stack(node, nts->stack, nsin, nsout);
322       /* Handle muted nodes...
323        * If the mute func is not set, assume the node should never be muted,
324        * and hence execute it!
325        */
326       if (node->typeinfo->execfunc && !(node->flag & NODE_MUTED)) {
327         node->typeinfo->execfunc(callerdata, thread, node, &nodeexec->data, nsin, nsout);
328       }
329     }
330   }
331
332   /* signal to that all went OK, for render */
333   return true;
334 }