source/blender/nodes/intern/node_common.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 <stddef.h>
  25 #include <string.h>
  26
  27 #include "DNA_node_types.h"
  28
  29 #include "BLI_listbase.h"
  30 #include "BLI_string.h"
  31 #include "BLI_utildefines.h"
  32
  33 #include "BLT_translation.h"
  34
  35 #include "BKE_node.h"
  36
  37 #include "RNA_types.h"
  38
  39 #include "MEM_guardedalloc.h"
  40
  41 #include "NOD_common.h"
  42 #include "node_common.h"
  43 #include "node_util.h"
  44
  45 enum {
  46   REFINE_FORWARD = 1 << 0,
  47   REFINE_BACKWARD = 1 << 1,
  48 };
  49
  50 /* -------------------------------------------------------------------- */
  51 /** \name Node Group
  52  * \{ */
  53
  54 bNodeSocket *node_group_find_input_socket(bNode *groupnode, const char *identifier)
  55 {
  56   bNodeSocket *sock;
  57   for (sock = groupnode->inputs.first; sock; sock = sock->next) {
  58     if (STREQ(sock->identifier, identifier)) {
  59       return sock;
  60     }
  61   }
  62   return NULL;
  63 }
  64
  65 bNodeSocket *node_group_find_output_socket(bNode *groupnode, const char *identifier)
  66 {
  67   bNodeSocket *sock;
  68   for (sock = groupnode->outputs.first; sock; sock = sock->next) {
  69     if (STREQ(sock->identifier, identifier)) {
  70       return sock;
  71     }
  72   }
  73   return NULL;
  74 }
  75
  76 /* groups display their internal tree name as label */
  77 void node_group_label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
  78 {
  79   BLI_strncpy(label, (node->id) ? node->id->name + 2 : IFACE_("Missing Data-Block"), maxlen);
  80 }
  81
  82 bool node_group_poll_instance(bNode *node, bNodeTree *nodetree)
  83 {
  84   if (node->typeinfo->poll(node->typeinfo, nodetree)) {
  85     bNodeTree *grouptree = (bNodeTree *)node->id;
  86     if (grouptree) {
  87       return nodeGroupPoll(nodetree, grouptree);
  88     }
  89
  90     return true; /* without a linked node tree, group node is always ok */
  91   }
  92
  93   return false;
  94 }
  95
  96 int nodeGroupPoll(bNodeTree *nodetree, bNodeTree *grouptree)
  97 {
  98   bNode *node;
  99   int valid = 1;
 100
 101   /* unspecified node group, generally allowed
 102    * (if anything, should be avoided on operator level)
 103    */
 104   if (grouptree == NULL) {
 105     return 1;
 106   }
 107
 108   if (nodetree == grouptree) {
 109     return 0;
 110   }
 111
 112   for (node = grouptree->nodes.first; node; node = node->next) {
 113     if (node->typeinfo->poll_instance && !node->typeinfo->poll_instance(node, nodetree)) {
 114       valid = 0;
 115       break;
 116     }
 117   }
 118   return valid;
 119 }
 120
 121 /* used for both group nodes and interface nodes */
 122 static bNodeSocket *group_verify_socket(
 123     bNodeTree *ntree, bNode *gnode, bNodeSocket *iosock, ListBase *verify_lb, int in_out)
 124 {
 125   bNodeSocket *sock;
 126
 127   for (sock = verify_lb->first; sock; sock = sock->next) {
 128     if (sock->typeinfo == iosock->typeinfo && STREQ(sock->identifier, iosock->identifier)) {
 129       break;
 130     }
 131   }
 132   if (sock) {
 133     strcpy(sock->name, iosock->name);
 134
 135     const int mask = SOCK_HIDE_VALUE;
 136     sock->flag = (sock->flag & ~mask) | (iosock->flag & mask);
 137
 138     if (iosock->typeinfo->interface_verify_socket) {
 139       iosock->typeinfo->interface_verify_socket(ntree, iosock, gnode, sock, "interface");
 140     }
 141   }
 142   else {
 143     sock = nodeAddSocket(ntree, gnode, in_out, iosock->idname, iosock->identifier, iosock->name);
 144
 145     if (iosock->typeinfo->interface_init_socket) {
 146       iosock->typeinfo->interface_init_socket(ntree, iosock, gnode, sock, "interface");
 147     }
 148   }
 149
 150   /* remove from list temporarily, to distinguish from orphaned sockets */
 151   BLI_remlink(verify_lb, sock);
 152
 153   return sock;
 154 }
 155
 156 /* used for both group nodes and interface nodes */
 157 static void group_verify_socket_list(
 158     bNodeTree *ntree, bNode *gnode, ListBase *iosock_lb, ListBase *verify_lb, int in_out)
 159 {
 160   bNodeSocket *iosock, *sock, *nextsock;
 161
 162   /* step by step compare */
 163
 164   iosock = iosock_lb->first;
 165   for (; iosock; iosock = iosock->next) {
 166     /* abusing new_sock pointer for verification here! only used inside this function */
 167     iosock->new_sock = group_verify_socket(ntree, gnode, iosock, verify_lb, in_out);
 168   }
 169   /* leftovers are removed */
 170   for (sock = verify_lb->first; sock; sock = nextsock) {
 171     nextsock = sock->next;
 172     nodeRemoveSocket(ntree, gnode, sock);
 173   }
 174   /* and we put back the verified sockets */
 175   iosock = iosock_lb->first;
 176   for (; iosock; iosock = iosock->next) {
 177     if (iosock->new_sock) {
 178       BLI_addtail(verify_lb, iosock->new_sock);
 179       iosock->new_sock = NULL;
 180     }
 181   }
 182 }
 183
 184 /* make sure all group node in ntree, which use ngroup, are sync'd */
 185 void node_group_update(struct bNodeTree *ntree, struct bNode *node)
 186 {
 187   /* check inputs and outputs, and remove or insert them */
 188   if (node->id == NULL) {
 189     nodeRemoveAllSockets(ntree, node);
 190   }
 191   else if ((ID_IS_LINKED(node->id) && (node->id->tag & LIB_TAG_MISSING))) {
 192     /* Missing datablock, leave sockets unchanged so that when it comes back
 193      * the links remain valid. */
 194   }
 195   else {
 196     bNodeTree *ngroup = (bNodeTree *)node->id;
 197     group_verify_socket_list(ntree, node, &ngroup->inputs, &node->inputs, SOCK_IN);
 198     group_verify_socket_list(ntree, node, &ngroup->outputs, &node->outputs, SOCK_OUT);
 199   }
 200 }
 201
 202 /** \} */
 203
 204 /* -------------------------------------------------------------------- */
 205 /** \name Node Frame
 206  * \{ */
 207
 208 static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node)
 209 {
 210   NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
 211   node->storage = data;
 212
 213   data->flag |= NODE_FRAME_SHRINK;
 214
 215   data->label_size = 20;
 216 }
 217
 218 void register_node_type_frame(void)
 219 {
 220   /* frame type is used for all tree types, needs dynamic allocation */
 221   bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "frame node type");
 222   ntype->free_self = (void (*)(bNodeType *))MEM_freeN;
 223
 224   node_type_base(ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND);
 225   node_type_init(ntype, node_frame_init);
 226   node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
 227   node_type_size(ntype, 150, 100, 0);
 228
 229   nodeRegisterType(ntype);
 230 }
 231
 232 /** \} */
 233
 234 /* -------------------------------------------------------------------- */
 235 /** \name Node Re-Route
 236  * \{ */
 237
 238 /* simple, only a single input and output here */
 239 static void node_reroute_update_internal_links(bNodeTree *ntree, bNode *node)
 240 {
 241   bNodeLink *link;
 242
 243   /* Security check! */
 244   if (!ntree) {
 245     return;
 246   }
 247
 248   link = MEM_callocN(sizeof(bNodeLink), "internal node link");
 249   link->fromnode = node;
 250   link->fromsock = node->inputs.first;
 251   link->tonode = node;
 252   link->tosock = node->outputs.first;
 253   /* internal link is always valid */
 254   link->flag |= NODE_LINK_VALID;
 255   BLI_addtail(&node->internal_links, link);
 256 }
 257
 258 static void node_reroute_init(bNodeTree *ntree, bNode *node)
 259 {
 260   /* Note: Cannot use socket templates for this, since it would reset the socket type
 261    * on each file read via the template verification procedure.
 262    */
 263   nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "Input", "Input");
 264   nodeAddStaticSocket(ntree, node, SOCK_OUT, SOCK_RGBA, PROP_NONE, "Output", "Output");
 265 }
 266
 267 void register_node_type_reroute(void)
 268 {
 269   /* frame type is used for all tree types, needs dynamic allocation */
 270   bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "frame node type");
 271   ntype->free_self = (void (*)(bNodeType *))MEM_freeN;
 272
 273   node_type_base(ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
 274   node_type_init(ntype, node_reroute_init);
 275   node_type_internal_links(ntype, node_reroute_update_internal_links);
 276
 277   nodeRegisterType(ntype);
 278 }
 279
 280 static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, int flag)
 281 {
 282   bNodeSocket *input = node->inputs.first;
 283   bNodeSocket *output = node->outputs.first;
 284   bNodeLink *link;
 285   int type = SOCK_FLOAT;
 286   const char *type_idname = nodeStaticSocketType(type, PROP_NONE);
 287
 288   /* XXX it would be a little bit more efficient to restrict actual updates
 289    * to reroute nodes connected to an updated node, but there's no reliable flag
 290    * to indicate updated nodes (node->update is not set on linking).
 291    */
 292
 293   node->done = 1;
 294
 295   /* recursive update */
 296   for (link = ntree->links.first; link; link = link->next) {
 297     bNode *fromnode = link->fromnode;
 298     bNode *tonode = link->tonode;
 299     if (!tonode || !fromnode) {
 300       continue;
 301     }
 302     if (nodeLinkIsHidden(link)) {
 303       continue;
 304     }
 305
 306     if (flag & REFINE_FORWARD) {
 307       if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done) {
 308         node_reroute_inherit_type_recursive(ntree, fromnode, REFINE_FORWARD);
 309       }
 310     }
 311     if (flag & REFINE_BACKWARD) {
 312       if (fromnode == node && tonode->type == NODE_REROUTE && !tonode->done) {
 313         node_reroute_inherit_type_recursive(ntree, tonode, REFINE_BACKWARD);
 314       }
 315     }
 316   }
 317
 318   /* determine socket type from unambiguous input/output connection if possible */
 319   if (nodeSocketLinkLimit(input) == 1 && input->link) {
 320     type = input->link->fromsock->type;
 321     type_idname = nodeStaticSocketType(type, PROP_NONE);
 322   }
 323   else if (nodeSocketLinkLimit(output) == 1 && output->link) {
 324     type = output->link->tosock->type;
 325     type_idname = nodeStaticSocketType(type, PROP_NONE);
 326   }
 327
 328   if (input->type != type) {
 329     bNodeSocket *ninput = nodeAddSocket(ntree, node, SOCK_IN, type_idname, "input", "Input");
 330     for (link = ntree->links.first; link; link = link->next) {
 331       if (link->tosock == input) {
 332         link->tosock = ninput;
 333         ninput->link = link;
 334       }
 335     }
 336     nodeRemoveSocket(ntree, node, input);
 337   }
 338
 339   if (output->type != type) {
 340     bNodeSocket *noutput = nodeAddSocket(ntree, node, SOCK_OUT, type_idname, "output", "Output");
 341     for (link = ntree->links.first; link; link = link->next) {
 342       if (link->fromsock == output) {
 343         link->fromsock = noutput;
 344       }
 345     }
 346     nodeRemoveSocket(ntree, node, output);
 347   }
 348
 349   nodeUpdateInternalLinks(ntree, node);
 350 }
 351
 352 /* Global update function for Reroute node types.
 353  * This depends on connected nodes, so must be done as a tree-wide update.
 354  */
 355 void ntree_update_reroute_nodes(bNodeTree *ntree)
 356 {
 357   bNode *node;
 358
 359   /* clear tags */
 360   for (node = ntree->nodes.first; node; node = node->next) {
 361     node->done = 0;
 362   }
 363
 364   for (node = ntree->nodes.first; node; node = node->next) {
 365     if (node->type == NODE_REROUTE && !node->done) {
 366       node_reroute_inherit_type_recursive(ntree, node, REFINE_FORWARD | REFINE_BACKWARD);
 367     }
 368   }
 369 }
 370
 371 static bool node_is_connected_to_output_recursive(bNodeTree *ntree, bNode *node)
 372 {
 373   bNodeLink *link;
 374
 375   /* avoid redundant checks, and infinite loops in case of cyclic node links */
 376   if (node->done) {
 377     return false;
 378   }
 379   node->done = 1;
 380
 381   /* main test, done before child loop so it catches output nodes themselves as well */
 382   if (node->typeinfo->nclass == NODE_CLASS_OUTPUT && node->flag & NODE_DO_OUTPUT) {
 383     return true;
 384   }
 385
 386   /* test all connected nodes, first positive find is sufficient to return true */
 387   for (link = ntree->links.first; link; link = link->next) {
 388     if (link->fromnode == node) {
 389       if (node_is_connected_to_output_recursive(ntree, link->tonode)) {
 390         return true;
 391       }
 392     }
 393   }
 394   return false;
 395 }
 396
 397 bool BKE_node_is_connected_to_output(bNodeTree *ntree, bNode *node)
 398 {
 399   bNode *tnode;
 400
 401   /* clear flags */
 402   for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
 403     tnode->done = 0;
 404   }
 405
 406   return node_is_connected_to_output_recursive(ntree, node);
 407 }
 408
 409 void BKE_node_tree_unlink_id(ID *id, struct bNodeTree *ntree)
 410 {
 411   bNode *node;
 412
 413   for (node = ntree->nodes.first; node; node = node->next) {
 414     if (node->id == id) {
 415       node->id = NULL;
 416     }
 417   }
 418 }
 419
 420 /** \} */
 421
 422 /* -------------------------------------------------------------------- */
 423 /** \name Node #GROUP_INPUT / #GROUP_OUTPUT
 424  * \{ */
 425
 426 static void node_group_input_init(bNodeTree *ntree, bNode *node)
 427 {
 428   node_group_input_update(ntree, node);
 429 }
 430
 431 bNodeSocket *node_group_input_find_socket(bNode *node, const char *identifier)
 432 {
 433   bNodeSocket *sock;
 434   for (sock = node->outputs.first; sock; sock = sock->next) {
 435     if (STREQ(sock->identifier, identifier)) {
 436       return sock;
 437     }
 438   }
 439   return NULL;
 440 }
 441
 442 void node_group_input_update(bNodeTree *ntree, bNode *node)
 443 {
 444   bNodeSocket *extsock = node->outputs.last;
 445   bNodeLink *link, *linknext, *exposelink;
 446   /* Adding a tree socket and verifying will remove the extension socket!
 447    * This list caches the existing links from the extension socket
 448    * so they can be recreated after verification.
 449    */
 450   ListBase tmplinks;
 451
 452   /* find links from the extension socket and store them */
 453   BLI_listbase_clear(&tmplinks);
 454   for (link = ntree->links.first; link; link = linknext) {
 455     linknext = link->next;
 456     if (nodeLinkIsHidden(link)) {
 457       continue;
 458     }
 459
 460     if (link->fromsock == extsock) {
 461       bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
 462       *tlink = *link;
 463       BLI_addtail(&tmplinks, tlink);
 464
 465       nodeRemLink(ntree, link);
 466     }
 467   }
 468
 469   /* find valid link to expose */
 470   exposelink = NULL;
 471   for (link = tmplinks.first; link; link = link->next) {
 472     /* XXX Multiple sockets can be connected to the extension socket at once,
 473      * in that case the arbitrary first link determines name and type.
 474      * This could be improved by choosing the "best" type among all links,
 475      * whatever that means.
 476      */
 477     if (link->tosock->type != SOCK_CUSTOM) {
 478       exposelink = link;
 479       break;
 480     }
 481   }
 482
 483   if (exposelink) {
 484     bNodeSocket *gsock, *newsock;
 485
 486     gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->tonode, exposelink->tosock);
 487
 488     node_group_input_update(ntree, node);
 489     newsock = node_group_input_find_socket(node, gsock->identifier);
 490
 491     /* redirect links from the extension socket */
 492     for (link = tmplinks.first; link; link = link->next) {
 493       nodeAddLink(ntree, node, newsock, link->tonode, link->tosock);
 494     }
 495   }
 496
 497   BLI_freelistN(&tmplinks);
 498
 499   /* check inputs and outputs, and remove or insert them */
 500   {
 501     /* value_in_out inverted for interface nodes to get correct socket value_property */
 502     group_verify_socket_list(ntree, node, &ntree->inputs, &node->outputs, SOCK_OUT);
 503
 504     /* add virtual extension socket */
 505     nodeAddSocket(ntree, node, SOCK_OUT, "NodeSocketVirtual", "__extend__", "");
 506   }
 507 }
 508
 509 void register_node_type_group_input(void)
 510 {
 511   /* used for all tree types, needs dynamic allocation */
 512   bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
 513   ntype->free_self = (void (*)(bNodeType *))MEM_freeN;
 514
 515   node_type_base(ntype, NODE_GROUP_INPUT, "Group Input", NODE_CLASS_INTERFACE, 0);
 516   node_type_size(ntype, 140, 80, 400);
 517   node_type_init(ntype, node_group_input_init);
 518   node_type_update(ntype, node_group_input_update);
 519
 520   nodeRegisterType(ntype);
 521 }
 522
 523 static void node_group_output_init(bNodeTree *ntree, bNode *node)
 524 {
 525   node_group_output_update(ntree, node);
 526 }
 527
 528 bNodeSocket *node_group_output_find_socket(bNode *node, const char *identifier)
 529 {
 530   bNodeSocket *sock;
 531   for (sock = node->inputs.first; sock; sock = sock->next) {
 532     if (STREQ(sock->identifier, identifier)) {
 533       return sock;
 534     }
 535   }
 536   return NULL;
 537 }
 538
 539 void node_group_output_update(bNodeTree *ntree, bNode *node)
 540 {
 541   bNodeSocket *extsock = node->inputs.last;
 542   bNodeLink *link, *linknext, *exposelink;
 543   /* Adding a tree socket and verifying will remove the extension socket!
 544    * This list caches the existing links to the extension socket
 545    * so they can be recreated after verification.
 546    */
 547   ListBase tmplinks;
 548
 549   /* find links to the extension socket and store them */
 550   BLI_listbase_clear(&tmplinks);
 551   for (link = ntree->links.first; link; link = linknext) {
 552     linknext = link->next;
 553     if (nodeLinkIsHidden(link)) {
 554       continue;
 555     }
 556
 557     if (link->tosock == extsock) {
 558       bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
 559       *tlink = *link;
 560       BLI_addtail(&tmplinks, tlink);
 561
 562       nodeRemLink(ntree, link);
 563     }
 564   }
 565
 566   /* find valid link to expose */
 567   exposelink = NULL;
 568   for (link = tmplinks.first; link; link = link->next) {
 569     /* XXX Multiple sockets can be connected to the extension socket at once,
 570      * in that case the arbitrary first link determines name and type.
 571      * This could be improved by choosing the "best" type among all links,
 572      * whatever that means.
 573      */
 574     if (link->fromsock->type != SOCK_CUSTOM) {
 575       exposelink = link;
 576       break;
 577     }
 578   }
 579
 580   if (exposelink) {
 581     bNodeSocket *gsock, *newsock;
 582
 583     /* XXX what if connecting virtual to virtual socket?? */
 584     gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->fromnode, exposelink->fromsock);
 585
 586     node_group_output_update(ntree, node);
 587     newsock = node_group_output_find_socket(node, gsock->identifier);
 588
 589     /* redirect links to the extension socket */
 590     for (link = tmplinks.first; link; link = link->next) {
 591       nodeAddLink(ntree, link->fromnode, link->fromsock, node, newsock);
 592     }
 593   }
 594
 595   BLI_freelistN(&tmplinks);
 596
 597   /* check inputs and outputs, and remove or insert them */
 598   {
 599     /* value_in_out inverted for interface nodes to get correct socket value_property */
 600     group_verify_socket_list(ntree, node, &ntree->outputs, &node->inputs, SOCK_IN);
 601
 602     /* add virtual extension socket */
 603     nodeAddSocket(ntree, node, SOCK_IN, "NodeSocketVirtual", "__extend__", "");
 604   }
 605 }
 606
 607 void register_node_type_group_output(void)
 608 {
 609   /* used for all tree types, needs dynamic allocation */
 610   bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
 611   ntype->free_self = (void (*)(bNodeType *))MEM_freeN;
 612
 613   node_type_base(ntype, NODE_GROUP_OUTPUT, "Group Output", NODE_CLASS_INTERFACE, 0);
 614   node_type_size(ntype, 140, 80, 400);
 615   node_type_init(ntype, node_group_output_init);
 616   node_type_update(ntype, node_group_output_update);
 617
 618   nodeRegisterType(ntype);
 619 }
 620
 621 /** \} */