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 }