source/blender/nodes/intern/node_common.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2007 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): Lukas Toenne.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 /** \file blender/nodes/intern/node_common.c
  29  *  \ingroup nodes
  30  */
  31
  32
  33 #include <string.h>
  34
  35 #include "DNA_action_types.h"
  36 #include "DNA_anim_types.h"
  37 #include "DNA_node_types.h"
  38
  39 #include "BLI_listbase.h"
  40 #include "BLI_string.h"
  41 #include "BLI_utildefines.h"
  42
  43 #include "BLF_translation.h"
  44
  45 #include "BKE_action.h"
  46 #include "BKE_animsys.h"
  47 #include "BKE_global.h"
  48 #include "BKE_library.h"
  49 #include "BKE_main.h"
  50 #include "BLI_math.h"
  51 #include "BKE_node.h"
  52 #include "BKE_utildefines.h"
  53
  54 #include "RNA_access.h"
  55 #include "RNA_types.h"
  56
  57 #include "MEM_guardedalloc.h"
  58
  59 #include "node_common.h"
  60 #include "node_util.h"
  61 #include "node_exec.h"
  62 #include "NOD_socket.h"
  63
  64 /**** Group ****/
  65
  66 bNodeSocket *node_group_find_input(bNode *gnode, bNodeSocket *gsock)
  67 {
  68         bNodeSocket *sock;
  69         for (sock=gnode->inputs.first; sock; sock=sock->next)
  70                 if (sock->groupsock == gsock)
  71                         return sock;
  72         return NULL;
  73 }
  74
  75 bNodeSocket *node_group_find_output(bNode *gnode, bNodeSocket *gsock)
  76 {
  77         bNodeSocket *sock;
  78         for (sock=gnode->outputs.first; sock; sock=sock->next)
  79                 if (sock->groupsock == gsock)
  80                         return sock;
  81         return NULL;
  82 }
  83
  84 bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, bNodeSocket *gsock)
  85 {
  86         bNodeSocket *sock;
  87
  88         if (gsock->flag & SOCK_INTERNAL)
  89                 return NULL;
  90
  91         sock= MEM_callocN(sizeof(bNodeSocket), "sock");
  92
  93         /* make a copy of the group socket */
  94         *sock = *gsock;
  95         sock->link = NULL;
  96         sock->next = sock->prev = NULL;
  97         sock->new_sock = NULL;
  98
  99         /* group sockets are dynamically added */
 100         sock->flag |= SOCK_DYNAMIC;
 101
 102         sock->own_index = gsock->own_index;
 103         sock->groupsock = gsock;
 104         sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
 105
 106         sock->default_value = node_socket_make_default_value(sock->type);
 107         node_socket_copy_default_value(sock->type, sock->default_value, gsock->default_value);
 108
 109         if (lb)
 110                 BLI_addtail(lb, sock);
 111
 112         return sock;
 113 }
 114
 115 bNode *node_group_make_from_selected(bNodeTree *ntree)
 116 {
 117         bNodeLink *link, *linkn;
 118         bNode *node, *gnode, *nextn;
 119         bNodeTree *ngroup;
 120         bNodeSocket *gsock;
 121         ListBase anim_basepaths = {NULL, NULL};
 122         float min[2], max[2];
 123         int totnode=0;
 124         bNodeTemplate ntemp;
 125
 126         INIT_MINMAX2(min, max);
 127
 128         /* is there something to group? also do some clearing */
 129         for (node= ntree->nodes.first; node; node= node->next) {
 130                 if (node->flag & NODE_SELECT) {
 131                         /* no groups in groups */
 132                         if (node->type==NODE_GROUP)
 133                                 return NULL;
 134                         DO_MINMAX2((&node->locx), min, max);
 135                         totnode++;
 136                 }
 137                 node->done = FALSE;
 138         }
 139         if (totnode==0) return NULL;
 140
 141         /* check if all connections are OK, no unselected node has both
 142          * inputs and outputs to a selection */
 143         for (link= ntree->links.first; link; link= link->next) {
 144                 if (link->fromnode && link->tonode && link->fromnode->flag & NODE_SELECT)
 145                         link->tonode->done |= 1;
 146                 if (link->fromnode && link->tonode && link->tonode->flag & NODE_SELECT)
 147                         link->fromnode->done |= 2;
 148         }
 149
 150         for (node= ntree->nodes.first; node; node= node->next) {
 151                 if ((node->flag & NODE_SELECT)==0)
 152                         if (node->done==3)
 153                                 break;
 154         }
 155         if (node)
 156                 return NULL;
 157
 158         /* OK! new nodetree */
 159         ngroup= ntreeAddTree("NodeGroup", ntree->type, NODE_GROUP);
 160
 161         /* move nodes over */
 162         for (node= ntree->nodes.first; node; node= nextn) {
 163                 nextn= node->next;
 164                 if (node->flag & NODE_SELECT) {
 165                         /* keep track of this node's RNA "base" path (the part of the pat identifying the node)
 166                          * if the old nodetree has animation data which potentially covers this node
 167                          */
 168                         if (ntree->adt) {
 169                                 PointerRNA ptr;
 170                                 char *path;
 171
 172                                 RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
 173                                 path = RNA_path_from_ID_to_struct(&ptr);
 174
 175                                 if (path)
 176                                         BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
 177                         }
 178
 179                         /* ensure valid parent pointers, detach if parent stays outside the group */
 180                         if (node->parent && !(node->parent->flag & NODE_SELECT))
 181                                 nodeDetachNode(node);
 182
 183                         /* change node-collection membership */
 184                         BLI_remlink(&ntree->nodes, node);
 185                         BLI_addtail(&ngroup->nodes, node);
 186
 187                         node->locx-= 0.5f*(min[0]+max[0]);
 188                         node->locy-= 0.5f*(min[1]+max[1]);
 189                 }
 190         }
 191
 192         /* move animation data over */
 193         if (ntree->adt) {
 194                 LinkData *ld, *ldn=NULL;
 195
 196                 BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths);
 197
 198                 /* paths + their wrappers need to be freed */
 199                 for (ld = anim_basepaths.first; ld; ld = ldn) {
 200                         ldn = ld->next;
 201
 202                         MEM_freeN(ld->data);
 203                         BLI_freelinkN(&anim_basepaths, ld);
 204                 }
 205         }
 206
 207         /* node groups don't use internal cached data */
 208         ntreeFreeCache(ngroup);
 209
 210         /* make group node */
 211         ntemp.type = NODE_GROUP;
 212         ntemp.ngroup = ngroup;
 213         gnode= nodeAddNode(ntree, &ntemp);
 214         gnode->locx= 0.5f*(min[0]+max[0]);
 215         gnode->locy= 0.5f*(min[1]+max[1]);
 216
 217         /* relink external sockets */
 218         for (link= ntree->links.first; link; link= linkn) {
 219                 linkn= link->next;
 220
 221                 if (link->fromnode && link->tonode && (link->fromnode->flag & link->tonode->flag & NODE_SELECT)) {
 222                         BLI_remlink(&ntree->links, link);
 223                         BLI_addtail(&ngroup->links, link);
 224                 }
 225                 else if (link->tonode && (link->tonode->flag & NODE_SELECT)) {
 226                         gsock = node_group_expose_socket(ngroup, link->tosock, SOCK_IN);
 227                         link->tosock->link = nodeAddLink(ngroup, NULL, gsock, link->tonode, link->tosock);
 228                         link->tosock = node_group_add_extern_socket(ntree, &gnode->inputs, SOCK_IN, gsock);
 229                         link->tonode = gnode;
 230                 }
 231                 else if (link->fromnode && (link->fromnode->flag & NODE_SELECT)) {
 232                         /* search for existing group node socket */
 233                         for (gsock=ngroup->outputs.first; gsock; gsock=gsock->next)
 234                                 if (gsock->link && gsock->link->fromsock==link->fromsock)
 235                                         break;
 236                         if (!gsock) {
 237                                 gsock = node_group_expose_socket(ngroup, link->fromsock, SOCK_OUT);
 238                                 gsock->link = nodeAddLink(ngroup, link->fromnode, link->fromsock, NULL, gsock);
 239                                 link->fromsock = node_group_add_extern_socket(ntree, &gnode->outputs, SOCK_OUT, gsock);
 240                         }
 241                         else
 242                                 link->fromsock = node_group_find_output(gnode, gsock);
 243                         link->fromnode = gnode;
 244                 }
 245         }
 246
 247         /* update of the group tree */
 248         ngroup->update |= NTREE_UPDATE;
 249         ntreeUpdateTree(ngroup);
 250         /* update of the tree containing the group instance node */
 251         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
 252         ntreeUpdateTree(ntree);
 253
 254         return gnode;
 255 }
 256
 257 /* returns 1 if its OK */
 258 int node_group_ungroup(bNodeTree *ntree, bNode *gnode)
 259 {
 260         bNodeLink *link, *linkn;
 261         bNode *node, *nextn;
 262         bNodeTree *ngroup, *wgroup;
 263         ListBase anim_basepaths = {NULL, NULL};
 264
 265         ngroup= (bNodeTree *)gnode->id;
 266         if (ngroup==NULL) return 0;
 267
 268         /* clear new pointers, set in copytree */
 269         for (node= ntree->nodes.first; node; node= node->next)
 270                 node->new_node= NULL;
 271
 272         /* wgroup is a temporary copy of the NodeTree we're merging in
 273          *      - all of wgroup's nodes are transferred across to their new home
 274          *      - ngroup (i.e. the source NodeTree) is left unscathed
 275          */
 276         wgroup= ntreeCopyTree(ngroup);
 277
 278         /* add the nodes into the ntree */
 279         for (node= wgroup->nodes.first; node; node= nextn) {
 280                 nextn= node->next;
 281
 282                 /* keep track of this node's RNA "base" path (the part of the pat identifying the node)
 283                  * if the old nodetree has animation data which potentially covers this node
 284                  */
 285                 if (wgroup->adt) {
 286                         PointerRNA ptr;
 287                         char *path;
 288
 289                         RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr);
 290                         path = RNA_path_from_ID_to_struct(&ptr);
 291
 292                         if (path)
 293                                 BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
 294                 }
 295
 296                 /* migrate node */
 297                 BLI_remlink(&wgroup->nodes, node);
 298                 BLI_addtail(&ntree->nodes, node);
 299
 300                 node->locx += gnode->locx;
 301                 node->locy += gnode->locy;
 302
 303                 node->flag |= NODE_SELECT;
 304         }
 305
 306         /* restore external links to and from the gnode */
 307         for (link= ntree->links.first; link; link= link->next) {
 308                 if (link->fromnode==gnode) {
 309                         if (link->fromsock->groupsock) {
 310                                 bNodeSocket *gsock= link->fromsock->groupsock;
 311                                 if (gsock->link) {
 312                                         if (gsock->link->fromnode) {
 313                                                 /* NB: using the new internal copies here! the groupsock pointer still maps to the old tree */
 314                                                 link->fromnode = (gsock->link->fromnode ? gsock->link->fromnode->new_node : NULL);
 315                                                 link->fromsock = gsock->link->fromsock->new_sock;
 316                                         }
 317                                         else {
 318                                                 /* group output directly maps to group input */
 319                                                 bNodeSocket *insock= node_group_find_input(gnode, gsock->link->fromsock);
 320                                                 if (insock->link) {
 321                                                         link->fromnode = insock->link->fromnode;
 322                                                         link->fromsock = insock->link->fromsock;
 323                                                 }
 324                                         }
 325                                 }
 326                                 else {
 327                                         /* copy the default input value from the group socket default to the external socket */
 328                                         node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, gsock->type, gsock->default_value);
 329                                 }
 330                         }
 331                 }
 332         }
 333         /* remove internal output links, these are not used anymore */
 334         for (link=wgroup->links.first; link; link= linkn) {
 335                 linkn = link->next;
 336                 if (!link->tonode)
 337                         nodeRemLink(wgroup, link);
 338         }
 339         /* restore links from internal nodes */
 340         for (link= wgroup->links.first; link; link= link->next) {
 341                 /* indicates link to group input */
 342                 if (!link->fromnode) {
 343                         /* NB: can't use find_group_node_input here,
 344                          * because gnode sockets still point to the old tree!
 345                          */
 346                         bNodeSocket *insock;
 347                         for (insock= gnode->inputs.first; insock; insock= insock->next)
 348                                 if (insock->groupsock->new_sock == link->fromsock)
 349                                         break;
 350                         if (insock->link) {
 351                                 link->fromnode = insock->link->fromnode;
 352                                 link->fromsock = insock->link->fromsock;
 353                         }
 354                         else {
 355                                 /* copy the default input value from the group node socket default to the internal socket */
 356                                 node_socket_convert_default_value(link->tosock->type, link->tosock->default_value, insock->type, insock->default_value);
 357                                 nodeRemLink(wgroup, link);
 358                         }
 359                 }
 360         }
 361
 362         /* add internal links to the ntree */
 363         for (link= wgroup->links.first; link; link= linkn) {
 364                 linkn= link->next;
 365                 BLI_remlink(&wgroup->links, link);
 366                 BLI_addtail(&ntree->links, link);
 367         }
 368
 369         /* and copy across the animation,
 370          * note that the animation data's action can be NULL here */
 371         if (wgroup->adt) {
 372                 LinkData *ld, *ldn=NULL;
 373                 bAction *waction;
 374
 375                 /* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */
 376                 waction = wgroup->adt->action = BKE_action_copy(wgroup->adt->action);
 377
 378                 /* now perform the moving */
 379                 BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths);
 380
 381                 /* paths + their wrappers need to be freed */
 382                 for (ld = anim_basepaths.first; ld; ld = ldn) {
 383                         ldn = ld->next;
 384
 385                         MEM_freeN(ld->data);
 386                         BLI_freelinkN(&anim_basepaths, ld);
 387                 }
 388
 389                 /* free temp action too */
 390                 if (waction) {
 391                         BKE_libblock_free(&G.main->action, waction);
 392                 }
 393         }
 394
 395         /* delete the group instance. this also removes old input links! */
 396         nodeFreeNode(ntree, gnode);
 397
 398         /* free the group tree (takes care of user count) */
 399         BKE_libblock_free(&G.main->nodetree, wgroup);
 400
 401         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
 402         ntreeUpdateTree(ntree);
 403
 404         return 1;
 405 }
 406
 407 bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out)
 408 {
 409         bNodeSocketType *stype = ntreeGetSocketType(type);
 410         bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket");
 411
 412         BLI_strncpy(gsock->name, name, sizeof(gsock->name));
 413         gsock->type = type;
 414         /* group sockets are dynamically added */
 415         gsock->flag |= SOCK_DYNAMIC;
 416
 417         gsock->next = gsock->prev = NULL;
 418         gsock->new_sock = NULL;
 419         gsock->link = NULL;
 420         /* assign new unique index */
 421         gsock->own_index = ngroup->cur_index++;
 422         gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1);
 423
 424         if (stype->value_structsize > 0)
 425                 gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value");
 426
 427         BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock);
 428
 429         ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT);
 430
 431         return gsock;
 432 }
 433
 434 bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out)
 435 {
 436         bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out);
 437
 438         /* initialize the default value. */
 439         node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
 440
 441         return gsock;
 442 }
 443
 444 void node_group_expose_all_sockets(bNodeTree *ngroup)
 445 {
 446         bNode *node;
 447         bNodeSocket *sock, *gsock;
 448
 449         for (node=ngroup->nodes.first; node; node=node->next) {
 450                 for (sock=node->inputs.first; sock; sock=sock->next) {
 451                         if (!sock->link && !nodeSocketIsHidden(sock)) {
 452                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN);
 453
 454                                 /* initialize the default value. */
 455                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
 456
 457                                 sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock);
 458                         }
 459                 }
 460                 for (sock=node->outputs.first; sock; sock=sock->next) {
 461                         if (nodeCountSocketLinks(ngroup, sock)==0 && !nodeSocketIsHidden(sock)) {
 462                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT);
 463
 464                                 /* initialize the default value. */
 465                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
 466
 467                                 gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock);
 468                         }
 469                 }
 470         }
 471 }
 472
 473 void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out)
 474 {
 475         nodeRemSocketLinks(ngroup, gsock);
 476
 477         switch (in_out) {
 478         case SOCK_IN:
 479                 BLI_remlink(&ngroup->inputs, gsock);
 480                 ngroup->update |= NTREE_UPDATE_GROUP_IN;
 481                 break;
 482         case SOCK_OUT:
 483                 BLI_remlink(&ngroup->outputs, gsock);
 484                 ngroup->update |= NTREE_UPDATE_GROUP_OUT;
 485                 break;
 486         }
 487
 488         if (gsock->default_value)
 489                 MEM_freeN(gsock->default_value);
 490
 491         MEM_freeN(gsock);
 492 }
 493
 494 /* groups display their internal tree name as label */
 495 const char *node_group_label(bNode *node)
 496 {
 497         return (node->id)? node->id->name+2: IFACE_("Missing Datablock");
 498 }
 499
 500 int node_group_valid(bNodeTree *ntree, bNodeTemplate *ntemp)
 501 {
 502         bNodeTemplate childtemp;
 503         bNode *node;
 504
 505         /* regular groups cannot be recursive */
 506         if (ntree == ntemp->ngroup)
 507                 return 0;
 508
 509         /* make sure all children are valid */
 510         for (node=ntemp->ngroup->nodes.first; node; node=node->next) {
 511                 childtemp = nodeMakeTemplate(node);
 512                 if (!nodeValid(ntree, &childtemp))
 513                         return 0;
 514         }
 515
 516         return 1;
 517 }
 518
 519 bNodeTemplate node_group_template(bNode *node)
 520 {
 521         bNodeTemplate ntemp;
 522         ntemp.type = NODE_GROUP;
 523         ntemp.ngroup = (bNodeTree*)node->id;
 524         return ntemp;
 525 }
 526
 527 void node_group_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
 528 {
 529         node->id = (ID*)ntemp->ngroup;
 530
 531         /* NB: group socket input/output roles are inverted internally!
 532          * Group "inputs" work as outputs in links and vice versa.
 533          */
 534         if (ntemp->ngroup) {
 535                 bNodeSocket *gsock;
 536                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
 537                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
 538                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
 539                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
 540         }
 541 }
 542
 543 static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock)
 544 {
 545         bNodeSocket *sock;
 546
 547         /* group sockets tagged as internal are not exposed ever */
 548         if (gsock->flag & SOCK_INTERNAL)
 549                 return NULL;
 550
 551         for (sock= lb->first; sock; sock= sock->next) {
 552                 if (sock->own_index==gsock->own_index)
 553                                 break;
 554         }
 555         if (sock) {
 556                 sock->groupsock = gsock;
 557
 558                 BLI_strncpy(sock->name, gsock->name, sizeof(sock->name));
 559                 if (gsock->type != sock->type)
 560                         nodeSocketSetType(sock, gsock->type);
 561
 562                 /* XXX hack: group socket input/output roles are inverted internally,
 563                  * need to change the limit value when making actual node sockets from them.
 564                  */
 565                 sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
 566
 567                 BLI_remlink(lb, sock);
 568
 569                 return sock;
 570         }
 571         else {
 572                 return node_group_add_extern_socket(ntree, NULL, in_out, gsock);
 573         }
 574 }
 575
 576 static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb)
 577 {
 578         bNodeSocket *sock, *nextsock, *gsock;
 579
 580         /* step by step compare */
 581         for (gsock= glb->first; gsock; gsock=gsock->next) {
 582                 /* abusing new_sock pointer for verification here! only used inside this function */
 583                 gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock);
 584         }
 585         /* leftovers are removed */
 586         for (sock=lb->first; sock; sock=nextsock) {
 587                 nextsock=sock->next;
 588                 if (sock->flag & SOCK_DYNAMIC)
 589                         nodeRemoveSocket(ntree, node, sock);
 590         }
 591         /* and we put back the verified sockets */
 592         for (gsock= glb->first; gsock; gsock=gsock->next) {
 593                 if (gsock->new_sock) {
 594                         BLI_addtail(lb, gsock->new_sock);
 595                         gsock->new_sock = NULL;
 596                 }
 597         }
 598 }
 599
 600 /* make sure all group node in ntree, which use ngroup, are sync'd */
 601 void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id)
 602 {
 603         /* check inputs and outputs, and remove or insert them */
 604         if (node->id==id) {
 605                 bNodeTree *ngroup= (bNodeTree*)node->id;
 606                 group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs);
 607                 group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs);
 608         }
 609 }
 610
 611 struct bNodeTree *node_group_edit_get(bNode *node)
 612 {
 613         if (node->flag & NODE_GROUP_EDIT)
 614                 return (bNodeTree*)node->id;
 615         else
 616                 return NULL;
 617 }
 618
 619 struct bNodeTree *node_group_edit_set(bNode *node, int edit)
 620 {
 621         if (edit) {
 622                 bNodeTree *ngroup= (bNodeTree*)node->id;
 623                 if (ngroup) {
 624                         if (ngroup->id.lib)
 625                                 ntreeMakeLocal(ngroup);
 626
 627                         node->flag |= NODE_GROUP_EDIT;
 628                 }
 629                 return ngroup;
 630         }
 631         else {
 632                 node->flag &= ~NODE_GROUP_EDIT;
 633                 return NULL;
 634         }
 635 }
 636
 637 void node_group_edit_clear(bNode *node)
 638 {
 639         bNodeTree *ngroup= (bNodeTree*)node->id;
 640         bNode *inode;
 641
 642         node->flag &= ~NODE_GROUP_EDIT;
 643
 644         if (ngroup)
 645                 for (inode=ngroup->nodes.first; inode; inode=inode->next)
 646                         nodeGroupEditClear(inode);
 647 }
 648
 649 void node_group_link(bNodeTree *ntree, bNodeSocket *sock, int in_out)
 650 {
 651         node_group_expose_socket(ntree, sock, in_out);
 652 }
 653
 654 /**** For Loop ****/
 655
 656 /* Essentially a group node with slightly different behavior.
 657  * The internal tree is executed several times, with each output being re-used
 658  * as an input in the next iteration. For this purpose, input and output socket
 659  * lists are kept identical!
 660  */
 661
 662 bNodeTemplate node_forloop_template(bNode *node)
 663 {
 664         bNodeTemplate ntemp;
 665         ntemp.type = NODE_FORLOOP;
 666         ntemp.ngroup = (bNodeTree*)node->id;
 667         return ntemp;
 668 }
 669
 670 void node_forloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
 671 {
 672         bNodeSocket *sock;
 673
 674         node->id = (ID*)ntemp->ngroup;
 675
 676         sock = nodeAddSocket(ntree, node, SOCK_IN, "Iterations", SOCK_FLOAT);
 677         node_socket_set_default_value_float(sock->default_value, PROP_UNSIGNED, 1, 0, 10000);
 678
 679         /* NB: group socket input/output roles are inverted internally!
 680          * Group "inputs" work as outputs in links and vice versa.
 681          */
 682         if (ntemp->ngroup) {
 683                 bNodeSocket *gsock;
 684                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
 685                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
 686                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
 687                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
 688         }
 689 }
 690
 691 void node_forloop_init_tree(bNodeTree *ntree)
 692 {
 693         bNodeSocket *sock;
 694         sock = node_group_add_socket(ntree, "Iteration", SOCK_FLOAT, SOCK_IN);
 695         sock->flag |= SOCK_INTERNAL;
 696 }
 697
 698 static void loop_sync(bNodeTree *ntree, int sync_in_out)
 699 {
 700         bNodeSocket *sock, *sync, *nsync, *mirror;
 701         ListBase *sync_lb;
 702
 703         if (sync_in_out==SOCK_IN) {
 704                 sock = ntree->outputs.first;
 705
 706                 sync = ntree->inputs.first;
 707                 sync_lb = &ntree->inputs;
 708         }
 709         else {
 710                 sock = ntree->inputs.first;
 711
 712                 sync = ntree->outputs.first;
 713                 sync_lb = &ntree->outputs;
 714         }
 715
 716         /* NB: the sock->storage pointer is used here directly to store the own_index int
 717          * out the mirrored socket counterpart!
 718          */
 719
 720         while (sock) {
 721                 /* skip static and internal sockets on the sync side (preserves socket order!) */
 722                 while (sync && ((sync->flag & SOCK_INTERNAL) || !(sync->flag & SOCK_DYNAMIC)))
 723                         sync = sync->next;
 724
 725                 if (sync && !(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC)) {
 726                         if (sock->storage==NULL) {
 727                                 /* if mirror index is 0, the sockets is newly added and a new mirror must be created. */
 728                                 mirror = node_group_expose_socket(ntree, sock, sync_in_out);
 729                                 /* store the mirror index */
 730                                 sock->storage = SET_INT_IN_POINTER(mirror->own_index);
 731                                 mirror->storage = SET_INT_IN_POINTER(sock->own_index);
 732                                 /* move mirror to the right place */
 733                                 BLI_remlink(sync_lb, mirror);
 734                                 if (sync)
 735                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
 736                                 else
 737                                         BLI_addtail(sync_lb, mirror);
 738                         }
 739                         else {
 740                                 /* look up the mirror socket */
 741                                 for (mirror=sync; mirror; mirror=mirror->next)
 742                                         if (mirror->own_index == GET_INT_FROM_POINTER(sock->storage))
 743                                                 break;
 744                                 /* make sure the name is the same (only for identification by user, no deeper meaning) */
 745                                 BLI_strncpy(mirror->name, sock->name, sizeof(mirror->name));
 746                                 /* fix the socket order if necessary */
 747                                 if (mirror != sync) {
 748                                         BLI_remlink(sync_lb, mirror);
 749                                         BLI_insertlinkbefore(sync_lb, sync, mirror);
 750                                 }
 751                                 else
 752                                         sync = sync->next;
 753                         }
 754                 }
 755
 756                 sock = sock->next;
 757         }
 758
 759         /* remaining sockets in sync_lb are leftovers from deleted sockets, remove them */
 760         while (sync) {
 761                 nsync = sync->next;
 762                 if (!(sync->flag & SOCK_INTERNAL) && (sync->flag & SOCK_DYNAMIC))
 763                         node_group_remove_socket(ntree, sync, sync_in_out);
 764                 sync = nsync;
 765         }
 766 }
 767
 768 void node_loop_update_tree(bNodeTree *ngroup)
 769 {
 770         /* make sure inputs & outputs are identical */
 771         if (ngroup->update & NTREE_UPDATE_GROUP_IN)
 772                 loop_sync(ngroup, SOCK_OUT);
 773         if (ngroup->update & NTREE_UPDATE_GROUP_OUT)
 774                 loop_sync(ngroup, SOCK_IN);
 775 }
 776
 777 void node_whileloop_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
 778 {
 779         bNodeSocket *sock;
 780
 781         node->id = (ID*)ntemp->ngroup;
 782
 783         sock = nodeAddSocket(ntree, node, SOCK_IN, "Condition", SOCK_FLOAT);
 784         node_socket_set_default_value_float(sock->default_value, PROP_NONE, 1, 0, 1);
 785
 786         /* max iterations */
 787         node->custom1 = 10000;
 788
 789         /* NB: group socket input/output roles are inverted internally!
 790          * Group "inputs" work as outputs in links and vice versa.
 791          */
 792         if (ntemp->ngroup) {
 793                 bNodeSocket *gsock;
 794                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
 795                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
 796                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
 797                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
 798         }
 799 }
 800
 801 void node_whileloop_init_tree(bNodeTree *ntree)
 802 {
 803         bNodeSocket *sock;
 804         sock = node_group_add_socket(ntree, "Condition", SOCK_FLOAT, SOCK_OUT);
 805         sock->flag |= SOCK_INTERNAL;
 806 }
 807
 808 bNodeTemplate node_whileloop_template(bNode *node)
 809 {
 810         bNodeTemplate ntemp;
 811         ntemp.type = NODE_WHILELOOP;
 812         ntemp.ngroup = (bNodeTree*)node->id;
 813         return ntemp;
 814 }
 815
 816 /**** FRAME ****/
 817
 818 static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp))
 819 {
 820         NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
 821         node->storage = data;
 822
 823         data->flag |= NODE_FRAME_SHRINK;
 824
 825         data->label_size = 20;
 826 }
 827
 828 void register_node_type_frame(bNodeTreeType *ttype)
 829 {
 830         /* frame type is used for all tree types, needs dynamic allocation */
 831         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
 832
 833         node_type_base(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS);
 834         node_type_init(ntype, node_frame_init);
 835         node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
 836         node_type_size(ntype, 150, 100, 0);
 837         node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
 838
 839         ntype->needs_free = 1;
 840         nodeRegisterType(ttype, ntype);
 841 }
 842
 843
 844 /* **************** REROUTE ******************** */
 845
 846 static bNodeSocketTemplate node_reroute_in[]= {
 847         {       SOCK_RGBA, 1, "Input",                  0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
 848         {       -1, 0, ""       }
 849 };
 850 static bNodeSocketTemplate node_reroute_out[]= {
 851         {       SOCK_RGBA, 0, "Output",                 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f},
 852         {       -1, 0, ""       }
 853 };
 854
 855 /* simple, only a single input and output here */
 856 ListBase node_reroute_internal_connect(bNodeTree *ntree, bNode *node)
 857 {
 858         bNodeLink *link;
 859         ListBase ret;
 860
 861         ret.first = ret.last = NULL;
 862
 863         /* Security check! */
 864         if (!ntree)
 865                 return ret;
 866
 867         link = MEM_callocN(sizeof(bNodeLink), "internal node link");
 868         link->fromnode = node;
 869         link->fromsock = node->inputs.first;
 870         link->tonode = node;
 871         link->tosock = node->outputs.first;
 872         /* internal link is always valid */
 873         link->flag |= NODE_LINK_VALID;
 874         BLI_addtail(&ret, link);
 875
 876         return ret;
 877 }
 878
 879 void register_node_type_reroute(bNodeTreeType *ttype)
 880 {
 881         /* frame type is used for all tree types, needs dynamic allocation */
 882         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
 883
 884         node_type_base(ttype, ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
 885         node_type_socket_templates(ntype, node_reroute_in, node_reroute_out);
 886         node_type_internal_connect(ntype, node_reroute_internal_connect);
 887
 888         ntype->needs_free = 1;
 889         nodeRegisterType(ttype, ntype);
 890 }