source/blender/blenkernel/intern/node.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) 2005 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): Bob Holcomb.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 /** \file blender/blenkernel/intern/node.c
  29  *  \ingroup bke
  30  */
  31
  32 #include "MEM_guardedalloc.h"
  33
  34 #include <stdlib.h>
  35 #include <stddef.h>
  36 #include <string.h>
  37 #include <limits.h>
  38
  39 #include "DNA_action_types.h"
  40 #include "DNA_anim_types.h"
  41 #include "DNA_lamp_types.h"
  42 #include "DNA_material_types.h"
  43 #include "DNA_node_types.h"
  44 #include "DNA_node_types.h"
  45 #include "DNA_scene_types.h"
  46 #include "DNA_texture_types.h"
  47 #include "DNA_world_types.h"
  48
  49 #include "BLI_string.h"
  50 #include "BLI_math.h"
  51 #include "BLI_listbase.h"
  52 #include "BLI_path_util.h"
  53 #include "BLI_utildefines.h"
  54
  55 #include "BLF_translation.h"
  56
  57 #include "BKE_animsys.h"
  58 #include "BKE_action.h"
  59 #include "BKE_fcurve.h"
  60 #include "BKE_global.h"
  61 #include "BKE_idprop.h"
  62 #include "BKE_image.h"
  63 #include "BKE_library.h"
  64 #include "BKE_main.h"
  65 #include "BKE_node.h"
  66
  67 #include "BLI_ghash.h"
  68 #include "RNA_access.h"
  69 #include "RNA_define.h"
  70
  71 #include "NOD_socket.h"
  72 #include "NOD_common.h"
  73 #include "NOD_composite.h"
  74 #include "NOD_shader.h"
  75 #include "NOD_texture.h"
  76
  77 /* Fallback types for undefined tree, nodes, sockets */
  78 bNodeTreeType NodeTreeTypeUndefined;
  79 bNodeType NodeTypeUndefined;
  80 bNodeSocketType NodeSocketTypeUndefined;
  81
  82
  83 static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype)
  84 {
  85         bNodeSocketTemplate *sockdef;
  86         /* bNodeSocket *sock; */ /* UNUSED */
  87
  88         if (ntype->inputs) {
  89                 sockdef = ntype->inputs;
  90                 while (sockdef->type != -1) {
  91                         /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_IN);
  92
  93                         sockdef++;
  94                 }
  95         }
  96         if (ntype->outputs) {
  97                 sockdef = ntype->outputs;
  98                 while (sockdef->type != -1) {
  99                         /* sock = */ node_add_socket_from_template(ntree, node, sockdef, SOCK_OUT);
 100
 101                         sockdef++;
 102                 }
 103         }
 104 }
 105
 106 /* Note: This function is called to initialize node data based on the type.
 107  * The bNodeType may not be registered at creation time of the node,
 108  * so this can be delayed until the node type gets registered.
 109  */
 110 static void node_init(const struct bContext *C, bNodeTree *ntree, bNode *node)
 111 {
 112         bNodeType *ntype = node->typeinfo;
 113         if (ntype == &NodeTypeUndefined)
 114                 return;
 115
 116         /* only do this once */
 117         if (node->flag & NODE_INIT)
 118                 return;
 119
 120         node->flag = NODE_SELECT | NODE_OPTIONS | ntype->flag;
 121         node->width = ntype->width;
 122         node->miniwidth = 42.0f;
 123         node->height = ntype->height;
 124         node->color[0] = node->color[1] = node->color[2] = 0.608;   /* default theme color */
 125
 126         /* initialize the node name with the node label.
 127          * note: do this after the initfunc so nodes get their data set which may be used in naming
 128          * (node groups for example) */
 129         /* XXX Do not use nodeLabel() here, it returns translated content for UI, which should *only* be used
 130          *     in UI, *never* in data... Data have their own translation option!
 131          *     This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler
 132          *     than adding "do_translate" flags to this func (and labelfunc() as well). */
 133         BLI_strncpy(node->name, DATA_(ntype->ui_name), NODE_MAXSTR);
 134         nodeUniqueName(ntree, node);
 135
 136         node_add_sockets_from_type(ntree, node, ntype);
 137
 138         if (ntype->initfunc != NULL)
 139                 ntype->initfunc(ntree, node);
 140
 141         /* extra init callback */
 142         if (ntype->initfunc_api) {
 143                 PointerRNA ptr;
 144                 RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
 145
 146                 /* XXX Warning: context can be NULL in case nodes are added in do_versions.
 147                  * Delayed init is not supported for nodes with context-based initfunc_api atm.
 148                  */
 149                 BLI_assert(C != NULL);
 150                 ntype->initfunc_api(C, &ptr);
 151         }
 152
 153         if (node->id)
 154                 id_us_plus(node->id);
 155
 156         node->flag |= NODE_INIT;
 157 }
 158
 159 static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo)
 160 {
 161         if (typeinfo) {
 162                 ntree->typeinfo = typeinfo;
 163
 164                 /* deprecated integer type */
 165                 ntree->type = typeinfo->type;
 166         }
 167         else {
 168                 ntree->typeinfo = &NodeTreeTypeUndefined;
 169
 170                 ntree->init &= ~NTREE_TYPE_INIT;
 171         }
 172 }
 173
 174 static void node_set_typeinfo(const struct bContext *C, bNodeTree *ntree, bNode *node, bNodeType *typeinfo)
 175 {
 176         if (typeinfo) {
 177                 node->typeinfo = typeinfo;
 178
 179                 /* deprecated integer type */
 180                 node->type = typeinfo->type;
 181
 182                 /* initialize the node if necessary */
 183                 node_init(C, ntree, node);
 184         }
 185         else {
 186                 node->typeinfo = &NodeTypeUndefined;
 187
 188                 ntree->init &= ~NTREE_TYPE_INIT;
 189         }
 190 }
 191
 192 static void node_socket_set_typeinfo(bNodeTree *ntree, bNodeSocket *sock, bNodeSocketType *typeinfo)
 193 {
 194         if (typeinfo) {
 195                 sock->typeinfo = typeinfo;
 196
 197                 /* deprecated integer type */
 198                 sock->type = typeinfo->type;
 199
 200                 if (sock->default_value == NULL) {
 201                         /* initialize the default_value pointer used by standard socket types */
 202                         node_socket_init_default_value(sock);
 203                 }
 204         }
 205         else {
 206                 sock->typeinfo = &NodeSocketTypeUndefined;
 207
 208                 ntree->init &= ~NTREE_TYPE_INIT;
 209         }
 210 }
 211
 212 /* Set specific typeinfo pointers in all node trees on register/unregister */
 213 static void update_typeinfo(Main *bmain, const struct bContext *C, bNodeTreeType *treetype, bNodeType *nodetype, bNodeSocketType *socktype, bool unregister)
 214 {
 215         if (!bmain)
 216                 return;
 217
 218         FOREACH_NODETREE(bmain, ntree, id) {
 219                 bNode *node;
 220                 bNodeSocket *sock;
 221
 222                 ntree->init |= NTREE_TYPE_INIT;
 223
 224                 if (treetype && STREQ(ntree->idname, treetype->idname))
 225                         ntree_set_typeinfo(ntree, unregister ? NULL : treetype);
 226
 227                 /* initialize nodes */
 228                 for (node = ntree->nodes.first; node; node = node->next) {
 229                         if (nodetype && STREQ(node->idname, nodetype->idname))
 230                                 node_set_typeinfo(C, ntree, node, unregister ? NULL : nodetype);
 231
 232                         /* initialize node sockets */
 233                         for (sock = node->inputs.first; sock; sock = sock->next)
 234                                 if (socktype && STREQ(sock->idname, socktype->idname))
 235                                         node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
 236                         for (sock = node->outputs.first; sock; sock = sock->next)
 237                                 if (socktype && STREQ(sock->idname, socktype->idname))
 238                                         node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
 239                 }
 240
 241                 /* initialize tree sockets */
 242                 for (sock = ntree->inputs.first; sock; sock = sock->next)
 243                         if (socktype && STREQ(sock->idname, socktype->idname))
 244                                 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
 245                 for (sock = ntree->outputs.first; sock; sock = sock->next)
 246                         if (socktype && STREQ(sock->idname, socktype->idname))
 247                                 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
 248         }
 249         FOREACH_NODETREE_END
 250 }
 251
 252 /* Try to initialize all typeinfo in a node tree.
 253  * NB: In general undefined typeinfo is a perfectly valid case, the type may just be registered later.
 254  * In that case the update_typeinfo function will set typeinfo on registration
 255  * and do necessary updates.
 256  */
 257 void ntreeSetTypes(const struct bContext *C, bNodeTree *ntree)
 258 {
 259         bNode *node;
 260         bNodeSocket *sock;
 261
 262         ntree->init |= NTREE_TYPE_INIT;
 263
 264         ntree_set_typeinfo(ntree, ntreeTypeFind(ntree->idname));
 265
 266         for (node = ntree->nodes.first; node; node = node->next) {
 267                 node_set_typeinfo(C, ntree, node, nodeTypeFind(node->idname));
 268
 269                 for (sock = node->inputs.first; sock; sock = sock->next)
 270                         node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
 271                 for (sock = node->outputs.first; sock; sock = sock->next)
 272                         node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
 273         }
 274
 275         for (sock = ntree->inputs.first; sock; sock = sock->next)
 276                 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
 277         for (sock = ntree->outputs.first; sock; sock = sock->next)
 278                 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
 279 }
 280
 281
 282 static GHash *nodetreetypes_hash = NULL;
 283 static GHash *nodetypes_hash = NULL;
 284 static GHash *nodesockettypes_hash = NULL;
 285
 286 bNodeTreeType *ntreeTypeFind(const char *idname)
 287 {
 288         bNodeTreeType *nt;
 289
 290         if (idname[0]) {
 291                 nt = BLI_ghash_lookup(nodetreetypes_hash, idname);
 292                 if (nt)
 293                         return nt;
 294         }
 295
 296         return NULL;
 297 }
 298
 299 void ntreeTypeAdd(bNodeTreeType *nt)
 300 {
 301         BLI_ghash_insert(nodetreetypes_hash, (void *)nt->idname, nt);
 302         /* XXX pass Main to register function? */
 303         update_typeinfo(G.main, NULL, nt, NULL, NULL, false);
 304 }
 305
 306 /* callback for hash value free function */
 307 static void ntree_free_type(void *treetype_v)
 308 {
 309         bNodeTreeType *treetype = treetype_v;
 310         /* XXX pass Main to unregister function? */
 311         update_typeinfo(G.main, NULL, treetype, NULL, NULL, true);
 312         MEM_freeN(treetype);
 313 }
 314
 315 void ntreeTypeFreeLink(bNodeTreeType *nt)
 316 {
 317         BLI_ghash_remove(nodetreetypes_hash, nt->idname, NULL, ntree_free_type);
 318 }
 319
 320 bool ntreeIsRegistered(bNodeTree *ntree)
 321 {
 322         return (ntree->typeinfo != &NodeTreeTypeUndefined);
 323 }
 324
 325 GHashIterator *ntreeTypeGetIterator(void)
 326 {
 327         return BLI_ghashIterator_new(nodetreetypes_hash);
 328 }
 329
 330 bNodeType *nodeTypeFind(const char *idname)
 331 {
 332         bNodeType *nt;
 333
 334         if (idname[0]) {
 335                 nt = BLI_ghash_lookup(nodetypes_hash, idname);
 336                 if (nt)
 337                         return nt;
 338         }
 339
 340         return NULL;
 341 }
 342
 343 static void free_dynamic_typeinfo(bNodeType *ntype)
 344 {
 345         if (ntype->type == NODE_DYNAMIC) {
 346                 if (ntype->inputs) {
 347                         MEM_freeN(ntype->inputs);
 348                 }
 349                 if (ntype->outputs) {
 350                         MEM_freeN(ntype->outputs);
 351                 }
 352                 if (ntype->ui_name) {
 353                         MEM_freeN((void *)ntype->ui_name);
 354                 }
 355         }
 356 }
 357
 358 /* callback for hash value free function */
 359 static void node_free_type(void *nodetype_v)
 360 {
 361         bNodeType *nodetype = nodetype_v;
 362         /* XXX pass Main to unregister function? */
 363         update_typeinfo(G.main, NULL, NULL, nodetype, NULL, true);
 364
 365         /* XXX deprecated */
 366         if (nodetype->type == NODE_DYNAMIC)
 367                 free_dynamic_typeinfo(nodetype);
 368
 369         if (nodetype->needs_free)
 370                 MEM_freeN(nodetype);
 371 }
 372
 373 void nodeRegisterType(bNodeType *nt)
 374 {
 375         /* debug only: basic verification of registered types */
 376         BLI_assert(nt->idname[0] != '\0');
 377         BLI_assert(nt->poll != NULL);
 378
 379         BLI_ghash_insert(nodetypes_hash, (void *)nt->idname, nt);
 380         /* XXX pass Main to register function? */
 381         update_typeinfo(G.main, NULL, NULL, nt, NULL, false);
 382 }
 383
 384 void nodeUnregisterType(bNodeType *nt)
 385 {
 386         BLI_ghash_remove(nodetypes_hash, nt->idname, NULL, node_free_type);
 387 }
 388
 389 bool nodeIsRegistered(bNode *node)
 390 {
 391         return (node->typeinfo != &NodeTypeUndefined);
 392 }
 393
 394 GHashIterator *nodeTypeGetIterator(void)
 395 {
 396         return BLI_ghashIterator_new(nodetypes_hash);
 397 }
 398
 399 bNodeSocketType *nodeSocketTypeFind(const char *idname)
 400 {
 401         bNodeSocketType *st;
 402
 403         if (idname[0]) {
 404                 st = BLI_ghash_lookup(nodesockettypes_hash, idname);
 405                 if (st)
 406                         return st;
 407         }
 408
 409         return NULL;
 410 }
 411
 412 /* callback for hash value free function */
 413 static void node_free_socket_type(void *socktype_v)
 414 {
 415         bNodeSocketType *socktype = socktype_v;
 416         /* XXX pass Main to unregister function? */
 417         update_typeinfo(G.main, NULL, NULL, NULL, socktype, true);
 418
 419         MEM_freeN(socktype);
 420 }
 421
 422 void nodeRegisterSocketType(bNodeSocketType *st)
 423 {
 424         BLI_ghash_insert(nodesockettypes_hash, (void *)st->idname, st);
 425         /* XXX pass Main to register function? */
 426         update_typeinfo(G.main, NULL, NULL, NULL, st, false);
 427 }
 428
 429 void nodeUnregisterSocketType(bNodeSocketType *st)
 430 {
 431         BLI_ghash_remove(nodesockettypes_hash, st->idname, NULL, node_free_socket_type);
 432 }
 433
 434 bool nodeSocketIsRegistered(bNodeSocket *sock)
 435 {
 436         return (sock->typeinfo != &NodeSocketTypeUndefined);
 437 }
 438
 439 GHashIterator *nodeSocketTypeGetIterator(void)
 440 {
 441         return BLI_ghashIterator_new(nodesockettypes_hash);
 442 }
 443
 444 struct bNodeSocket *nodeFindSocket(bNode *node, int in_out, const char *identifier)
 445 {
 446         bNodeSocket *sock = (in_out == SOCK_IN ? node->inputs.first : node->outputs.first);
 447         for (; sock; sock = sock->next) {
 448                 if (STREQ(sock->identifier, identifier))
 449                         return sock;
 450         }
 451         return NULL;
 452 }
 453
 454 /* find unique socket identifier */
 455 static bool unique_identifier_check(void *arg, const char *identifier)
 456 {
 457         struct ListBase *lb = arg;
 458         bNodeSocket *sock;
 459         for (sock = lb->first; sock; sock = sock->next) {
 460                 if (STREQ(sock->identifier, identifier))
 461                         return true;
 462         }
 463         return false;
 464 }
 465
 466 static bNodeSocket *make_socket(bNodeTree *ntree, bNode *UNUSED(node), int in_out, ListBase *lb,
 467                                 const char *idname, const char *identifier, const char *name)
 468 {
 469         bNodeSocket *sock;
 470         char auto_identifier[MAX_NAME];
 471
 472         if (identifier && identifier[0] != '\0') {
 473                 /* use explicit identifier */
 474                 BLI_strncpy(auto_identifier, identifier, sizeof(auto_identifier));
 475         }
 476         else {
 477                 /* if no explicit identifier is given, assign a unique identifier based on the name */
 478                 BLI_strncpy(auto_identifier, name, sizeof(auto_identifier));
 479         }
 480         /* make the identifier unique */
 481         BLI_uniquename_cb(unique_identifier_check, lb, "socket", '.', auto_identifier, sizeof(auto_identifier));
 482
 483         sock = MEM_callocN(sizeof(bNodeSocket), "sock");
 484         sock->in_out = in_out;
 485
 486         BLI_strncpy(sock->identifier, auto_identifier, NODE_MAXSTR);
 487         sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
 488
 489         BLI_strncpy(sock->name, name, NODE_MAXSTR);
 490         sock->storage = NULL;
 491         sock->flag |= SOCK_COLLAPSED;
 492         sock->type = SOCK_CUSTOM;       /* int type undefined by default */
 493
 494         BLI_strncpy(sock->idname, idname, sizeof(sock->idname));
 495         node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(idname));
 496
 497         return sock;
 498 }
 499
 500 bNodeSocket *nodeAddSocket(bNodeTree *ntree, bNode *node, int in_out, const char *idname,
 501                            const char *identifier, const char *name)
 502 {
 503         ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs);
 504         bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name);
 505
 506         BLI_remlink(lb, sock);  /* does nothing for new socket */
 507         BLI_addtail(lb, sock);
 508
 509         node->update |= NODE_UPDATE;
 510
 511         return sock;
 512 }
 513
 514 bNodeSocket *nodeInsertSocket(bNodeTree *ntree, bNode *node, int in_out, const char *idname,
 515                               bNodeSocket *next_sock, const char *identifier, const char *name)
 516 {
 517         ListBase *lb = (in_out == SOCK_IN ? &node->inputs : &node->outputs);
 518         bNodeSocket *sock = make_socket(ntree, node, in_out, lb, idname, identifier, name);
 519
 520         BLI_remlink(lb, sock);  /* does nothing for new socket */
 521         BLI_insertlinkbefore(lb, next_sock, sock);
 522
 523         node->update |= NODE_UPDATE;
 524
 525         return sock;
 526 }
 527
 528 const char *nodeStaticSocketType(int type, int subtype)
 529 {
 530         switch (type) {
 531         case SOCK_FLOAT:
 532                 switch (subtype) {
 533                 case PROP_UNSIGNED:
 534                         return "NodeSocketFloatUnsigned";
 535                 case PROP_PERCENTAGE:
 536                         return "NodeSocketFloatPercentage";
 537                 case PROP_FACTOR:
 538                         return "NodeSocketFloatFactor";
 539                 case PROP_ANGLE:
 540                         return "NodeSocketFloatAngle";
 541                 case PROP_TIME:
 542                         return "NodeSocketFloatTime";
 543                 case PROP_NONE:
 544                 default:
 545                         return "NodeSocketFloat";
 546                 }
 547         case SOCK_INT:
 548                 switch (subtype) {
 549                 case PROP_UNSIGNED:
 550                         return "NodeSocketIntUnsigned";
 551                 case PROP_PERCENTAGE:
 552                         return "NodeSocketIntPercentage";
 553                 case PROP_FACTOR:
 554                         return "NodeSocketIntFactor";
 555                 case PROP_NONE:
 556                 default:
 557                         return "NodeSocketInt";
 558                 }
 559         case SOCK_BOOLEAN:
 560                 return "NodeSocketBool";
 561         case SOCK_VECTOR:
 562                 switch (subtype) {
 563                 case PROP_TRANSLATION:
 564                         return "NodeSocketVectorTranslation";
 565                 case PROP_DIRECTION:
 566                         return "NodeSocketVectorDirection";
 567                 case PROP_VELOCITY:
 568                         return "NodeSocketVectorVelocity";
 569                 case PROP_ACCELERATION:
 570                         return "NodeSocketVectorAcceleration";
 571                 case PROP_EULER:
 572                         return "NodeSocketVectorEuler";
 573                 case PROP_XYZ:
 574                         return "NodeSocketVectorXYZ";
 575                 case PROP_NONE:
 576                 default:
 577                         return "NodeSocketVector";
 578                 }
 579         case SOCK_RGBA:
 580                 return "NodeSocketColor";
 581         case SOCK_STRING:
 582                 return "NodeSocketString";
 583         case SOCK_SHADER:
 584                 return "NodeSocketShader";
 585         }
 586         return NULL;
 587 }
 588
 589 const char *nodeStaticSocketInterfaceType(int type, int subtype)
 590 {
 591         switch (type) {
 592         case SOCK_FLOAT:
 593                 switch (subtype) {
 594                 case PROP_UNSIGNED:
 595                         return "NodeSocketInterfaceFloatUnsigned";
 596                 case PROP_PERCENTAGE:
 597                         return "NodeSocketInterfaceFloatPercentage";
 598                 case PROP_FACTOR:
 599                         return "NodeSocketInterfaceFloatFactor";
 600                 case PROP_ANGLE:
 601                         return "NodeSocketInterfaceFloatAngle";
 602                 case PROP_TIME:
 603                         return "NodeSocketInterfaceFloatTime";
 604                 case PROP_NONE:
 605                 default:
 606                         return "NodeSocketInterfaceFloat";
 607                 }
 608         case SOCK_INT:
 609                 switch (subtype) {
 610                 case PROP_UNSIGNED:
 611                         return "NodeSocketInterfaceIntUnsigned";
 612                 case PROP_PERCENTAGE:
 613                         return "NodeSocketInterfaceIntPercentage";
 614                 case PROP_FACTOR:
 615                         return "NodeSocketInterfaceIntFactor";
 616                 case PROP_NONE:
 617                 default:
 618                         return "NodeSocketInterfaceInt";
 619                 }
 620         case SOCK_BOOLEAN:
 621                 return "NodeSocketInterfaceBool";
 622         case SOCK_VECTOR:
 623                 switch (subtype) {
 624                 case PROP_TRANSLATION:
 625                         return "NodeSocketInterfaceVectorTranslation";
 626                 case PROP_DIRECTION:
 627                         return "NodeSocketInterfaceVectorDirection";
 628                 case PROP_VELOCITY:
 629                         return "NodeSocketInterfaceVectorVelocity";
 630                 case PROP_ACCELERATION:
 631                         return "NodeSocketInterfaceVectorAcceleration";
 632                 case PROP_EULER:
 633                         return "NodeSocketInterfaceVectorEuler";
 634                 case PROP_XYZ:
 635                         return "NodeSocketInterfaceVectorXYZ";
 636                 case PROP_NONE:
 637                 default:
 638                         return "NodeSocketInterfaceVector";
 639                 }
 640         case SOCK_RGBA:
 641                 return "NodeSocketInterfaceColor";
 642         case SOCK_STRING:
 643                 return "NodeSocketInterfaceString";
 644         case SOCK_SHADER:
 645                 return "NodeSocketInterfaceShader";
 646         }
 647         return NULL;
 648 }
 649
 650 bNodeSocket *nodeAddStaticSocket(bNodeTree *ntree, bNode *node, int in_out, int type, int subtype,
 651                                  const char *identifier, const char *name)
 652 {
 653         const char *idname = nodeStaticSocketType(type, subtype);
 654         bNodeSocket *sock;
 655
 656         if (!idname) {
 657                 printf("Error: static node socket type %d undefined\n", type);
 658                 return NULL;
 659         }
 660
 661         sock = nodeAddSocket(ntree, node, in_out, idname, identifier, name);
 662         sock->type = type;
 663         return sock;
 664 }
 665
 666 bNodeSocket *nodeInsertStaticSocket(bNodeTree *ntree, bNode *node, int in_out, int type, int subtype,
 667                                     bNodeSocket *next_sock, const char *identifier, const char *name)
 668 {
 669         const char *idname = nodeStaticSocketType(type, subtype);
 670         bNodeSocket *sock;
 671
 672         if (!idname) {
 673                 printf("Error: static node socket type %d undefined\n", type);
 674                 return NULL;
 675         }
 676
 677         sock = nodeInsertSocket(ntree, node, in_out, idname, next_sock, identifier, name);
 678         sock->type = type;
 679         return sock;
 680 }
 681
 682 static void node_socket_free(bNodeTree *UNUSED(ntree), bNodeSocket *sock, bNode *UNUSED(node))
 683 {
 684         if (sock->prop) {
 685                 IDP_FreeProperty(sock->prop);
 686                 MEM_freeN(sock->prop);
 687         }
 688
 689         if (sock->default_value)
 690                 MEM_freeN(sock->default_value);
 691 }
 692
 693 void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock)
 694 {
 695         bNodeLink *link, *next;
 696
 697         for (link = ntree->links.first; link; link = next) {
 698                 next = link->next;
 699                 if (link->fromsock == sock || link->tosock == sock) {
 700                         nodeRemLink(ntree, link);
 701                 }
 702         }
 703
 704         /* this is fast, this way we don't need an in_out argument */
 705         BLI_remlink(&node->inputs, sock);
 706         BLI_remlink(&node->outputs, sock);
 707
 708         node_socket_free(ntree, sock, node);
 709         MEM_freeN(sock);
 710
 711         node->update |= NODE_UPDATE;
 712 }
 713
 714 void nodeRemoveAllSockets(bNodeTree *ntree, bNode *node)
 715 {
 716         bNodeSocket *sock, *sock_next;
 717         bNodeLink *link, *next;
 718
 719         for (link = ntree->links.first; link; link = next) {
 720                 next = link->next;
 721                 if (link->fromnode == node || link->tonode == node) {
 722                         nodeRemLink(ntree, link);
 723                 }
 724         }
 725
 726         for (sock = node->inputs.first; sock; sock = sock_next) {
 727                 sock_next = sock->next;
 728                 node_socket_free(ntree, sock, node);
 729                 MEM_freeN(sock);
 730         }
 731         for (sock = node->outputs.first; sock; sock = sock_next) {
 732                 sock_next = sock->next;
 733                 node_socket_free(ntree, sock, node);
 734                 MEM_freeN(sock);
 735         }
 736
 737         node->update |= NODE_UPDATE;
 738 }
 739
 740 /* finds a node based on its name */
 741 bNode *nodeFindNodebyName(bNodeTree *ntree, const char *name)
 742 {
 743         return BLI_findstring(&ntree->nodes, name, offsetof(bNode, name));
 744 }
 745
 746 /* finds a node based on given socket */
 747 int nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **nodep, int *sockindex)
 748 {
 749         int in_out = sock->in_out;
 750         bNode *node;
 751         bNodeSocket *tsock;
 752         int index = 0;
 753
 754         for (node = ntree->nodes.first; node; node = node->next) {
 755                 tsock = (in_out == SOCK_IN ? node->inputs.first : node->outputs.first);
 756                 for (index = 0; tsock; tsock = tsock->next, index++) {
 757                         if (tsock == sock)
 758                                 break;
 759                 }
 760                 if (tsock)
 761                         break;
 762         }
 763
 764         if (node) {
 765                 *nodep = node;
 766                 if (sockindex) *sockindex = index;
 767                 return 1;
 768         }
 769
 770         *nodep = NULL;
 771         return 0;
 772 }
 773
 774 /* ************** Add stuff ********** */
 775
 776 /* Find the first available, non-duplicate name for a given node */
 777 void nodeUniqueName(bNodeTree *ntree, bNode *node)
 778 {
 779         BLI_uniquename(&ntree->nodes, node, DATA_("Node"), '.', offsetof(bNode, name), sizeof(node->name));
 780 }
 781
 782 bNode *nodeAddNode(const struct bContext *C, bNodeTree *ntree, const char *idname)
 783 {
 784         bNode *node;
 785
 786         node = MEM_callocN(sizeof(bNode), "new node");
 787         BLI_addtail(&ntree->nodes, node);
 788
 789         BLI_strncpy(node->idname, idname, sizeof(node->idname));
 790         node_set_typeinfo(C, ntree, node, nodeTypeFind(idname));
 791
 792         ntree->update |= NTREE_UPDATE_NODES;
 793
 794         return node;
 795 }
 796
 797 bNode *nodeAddStaticNode(const struct bContext *C, bNodeTree *ntree, int type)
 798 {
 799         const char *idname = NULL;
 800
 801         NODE_TYPES_BEGIN(ntype)
 802                 /* do an extra poll here, because some int types are used
 803                  * for multiple node types, this helps find the desired type
 804                  */
 805                 if (ntype->type == type && (!ntype->poll || ntype->poll(ntype, ntree))) {
 806                         idname = ntype->idname;
 807                         break;
 808                 }
 809         NODE_TYPES_END
 810         if (!idname) {
 811                 printf("Error: static node type %d undefined\n", type);
 812                 return NULL;
 813         }
 814         return nodeAddNode(C, ntree, idname);
 815 }
 816
 817 static void node_socket_copy(bNodeSocket *dst, bNodeSocket *src)
 818 {
 819         src->new_sock = dst;
 820
 821         if (src->prop)
 822                 dst->prop = IDP_CopyProperty(src->prop);
 823
 824         if (src->default_value)
 825                 dst->default_value = MEM_dupallocN(src->default_value);
 826
 827         dst->stack_index = 0;
 828         /* XXX some compositor node (e.g. image, render layers) still store
 829          * some persistent buffer data here, need to clear this to avoid dangling pointers.
 830          */
 831         dst->cache = NULL;
 832 }
 833
 834 /* keep socket listorder identical, for copying links */
 835 /* ntree is the target tree */
 836 bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node)
 837 {
 838         bNode *nnode = MEM_callocN(sizeof(bNode), "dupli node");
 839         bNodeSocket *sock, *oldsock;
 840         bNodeLink *link, *oldlink;
 841
 842         *nnode = *node;
 843         /* can be called for nodes outside a node tree (e.g. clipboard) */
 844         if (ntree) {
 845                 nodeUniqueName(ntree, nnode);
 846
 847                 BLI_addtail(&ntree->nodes, nnode);
 848         }
 849
 850         BLI_duplicatelist(&nnode->inputs, &node->inputs);
 851         oldsock = node->inputs.first;
 852         for (sock = nnode->inputs.first; sock; sock = sock->next, oldsock = oldsock->next)
 853                 node_socket_copy(sock, oldsock);
 854
 855         BLI_duplicatelist(&nnode->outputs, &node->outputs);
 856         oldsock = node->outputs.first;
 857         for (sock = nnode->outputs.first; sock; sock = sock->next, oldsock = oldsock->next)
 858                 node_socket_copy(sock, oldsock);
 859
 860         if (node->prop)
 861                 nnode->prop = IDP_CopyProperty(node->prop);
 862
 863         BLI_duplicatelist(&nnode->internal_links, &node->internal_links);
 864         oldlink = node->internal_links.first;
 865         for (link = nnode->internal_links.first; link; link = link->next, oldlink = oldlink->next) {
 866                 link->fromnode = nnode;
 867                 link->tonode = nnode;
 868                 link->fromsock = link->fromsock->new_sock;
 869                 link->tosock = link->tosock->new_sock;
 870         }
 871
 872         /* don't increase node->id users, freenode doesn't decrement either */
 873
 874         if (node->typeinfo->copyfunc)
 875                 node->typeinfo->copyfunc(ntree, nnode, node);
 876
 877         node->new_node = nnode;
 878         nnode->new_node = NULL;
 879
 880         if (nnode->typeinfo->copyfunc_api) {
 881                 PointerRNA ptr;
 882                 RNA_pointer_create((ID *)ntree, &RNA_Node, nnode, &ptr);
 883
 884                 nnode->typeinfo->copyfunc_api(&ptr, node);
 885         }
 886
 887         if (ntree)
 888                 ntree->update |= NTREE_UPDATE_NODES;
 889
 890         return nnode;
 891 }
 892
 893 /* also used via rna api, so we check for proper input output direction */
 894 bNodeLink *nodeAddLink(bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock)
 895 {
 896         bNodeLink *link = NULL;
 897
 898         /* test valid input */
 899         BLI_assert(fromnode);
 900         BLI_assert(tonode);
 901
 902         if (fromsock->in_out == SOCK_OUT && tosock->in_out == SOCK_IN) {
 903                 link = MEM_callocN(sizeof(bNodeLink), "link");
 904                 if (ntree)
 905                         BLI_addtail(&ntree->links, link);
 906                 link->fromnode = fromnode;
 907                 link->fromsock = fromsock;
 908                 link->tonode = tonode;
 909                 link->tosock = tosock;
 910         }
 911         else if (fromsock->in_out == SOCK_IN && tosock->in_out == SOCK_OUT) {
 912                 /* OK but flip */
 913                 link = MEM_callocN(sizeof(bNodeLink), "link");
 914                 if (ntree)
 915                         BLI_addtail(&ntree->links, link);
 916                 link->fromnode = tonode;
 917                 link->fromsock = tosock;
 918                 link->tonode = fromnode;
 919                 link->tosock = fromsock;
 920         }
 921
 922         if (ntree)
 923                 ntree->update |= NTREE_UPDATE_LINKS;
 924
 925         return link;
 926 }
 927
 928 void nodeRemLink(bNodeTree *ntree, bNodeLink *link)
 929 {
 930         /* can be called for links outside a node tree (e.g. clipboard) */
 931         if (ntree)
 932                 BLI_remlink(&ntree->links, link);
 933
 934         if (link->tosock)
 935                 link->tosock->link = NULL;
 936         MEM_freeN(link);
 937
 938         if (ntree)
 939                 ntree->update |= NTREE_UPDATE_LINKS;
 940 }
 941
 942 void nodeRemSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
 943 {
 944         bNodeLink *link, *next;
 945
 946         for (link = ntree->links.first; link; link = next) {
 947                 next = link->next;
 948                 if (link->fromsock == sock || link->tosock == sock) {
 949                         nodeRemLink(ntree, link);
 950                 }
 951         }
 952
 953         ntree->update |= NTREE_UPDATE_LINKS;
 954 }
 955
 956 int nodeLinkIsHidden(bNodeLink *link)
 957 {
 958         return nodeSocketIsHidden(link->fromsock) || nodeSocketIsHidden(link->tosock);
 959 }
 960
 961 void nodeInternalRelink(bNodeTree *ntree, bNode *node)
 962 {
 963         bNodeLink *link, *link_next;
 964
 965         if (node->internal_links.first == NULL)
 966                 return;
 967
 968         /* store link pointers in output sockets, for efficient lookup */
 969         for (link = node->internal_links.first; link; link = link->next)
 970                 link->tosock->link = link;
 971
 972         /* redirect downstream links */
 973         for (link = ntree->links.first; link; link = link_next) {
 974                 link_next = link->next;
 975
 976                 /* do we have internal link? */
 977                 if (link->fromnode == node) {
 978                         if (link->fromsock->link) {
 979                                 /* get the upstream input link */
 980                                 bNodeLink *fromlink = link->fromsock->link->fromsock->link;
 981                                 /* skip the node */
 982                                 if (fromlink) {
 983                                         link->fromnode = fromlink->fromnode;
 984                                         link->fromsock = fromlink->fromsock;
 985
 986                                         /* if the up- or downstream link is invalid,
 987                                          * the replacement link will be invalid too.
 988                                          */
 989                                         if (!(fromlink->flag & NODE_LINK_VALID))
 990                                                 link->flag &= ~NODE_LINK_VALID;
 991
 992                                         ntree->update |= NTREE_UPDATE_LINKS;
 993                                 }
 994                                 else
 995                                         nodeRemLink(ntree, link);
 996                         }
 997                         else
 998                                 nodeRemLink(ntree, link);
 999                 }
1000         }
1001
1002         /* remove remaining upstream links */
1003         for (link = ntree->links.first; link; link = link_next) {
1004                 link_next = link->next;
1005
1006                 if (link->tonode == node)
1007                         nodeRemLink(ntree, link);
1008         }
1009 }
1010
1011 void nodeToView(bNode *node, float x, float y, float *rx, float *ry)
1012 {
1013         if (node->parent) {
1014                 nodeToView(node->parent, x + node->locx, y + node->locy, rx, ry);
1015         }
1016         else {
1017                 *rx = x + node->locx;
1018                 *ry = y + node->locy;
1019         }
1020 }
1021
1022 void nodeFromView(bNode *node, float x, float y, float *rx, float *ry)
1023 {
1024         if (node->parent) {
1025                 nodeFromView(node->parent, x, y, rx, ry);
1026                 *rx -= node->locx;
1027                 *ry -= node->locy;
1028         }
1029         else {
1030                 *rx = x - node->locx;
1031                 *ry = y - node->locy;
1032         }
1033 }
1034
1035 int nodeAttachNodeCheck(bNode *node, bNode *parent)
1036 {
1037         bNode *parent_recurse;
1038         for (parent_recurse = node; parent_recurse; parent_recurse = parent_recurse->parent) {
1039                 if (parent_recurse == parent) {
1040                         return TRUE;
1041                 }
1042         }
1043
1044         return FALSE;
1045 }
1046
1047 void nodeAttachNode(bNode *node, bNode *parent)
1048 {
1049         float locx, locy;
1050
1051         BLI_assert(parent->type == NODE_FRAME);
1052         BLI_assert(nodeAttachNodeCheck(parent, node) == FALSE);
1053
1054         nodeToView(node, 0.0f, 0.0f, &locx, &locy);
1055
1056         node->parent = parent;
1057         /* transform to parent space */
1058         nodeFromView(parent, locx, locy, &node->locx, &node->locy);
1059 }
1060
1061 void nodeDetachNode(struct bNode *node)
1062 {
1063         float locx, locy;
1064
1065         if (node->parent) {
1066
1067                 BLI_assert(node->parent->type == NODE_FRAME);
1068
1069                 /* transform to view space */
1070                 nodeToView(node, 0.0f, 0.0f, &locx, &locy);
1071                 node->locx = locx;
1072                 node->locy = locy;
1073                 node->parent = NULL;
1074         }
1075 }
1076
1077 bNodeTree *ntreeAddTree(Main *bmain, const char *name, const char *idname)
1078 {
1079         bNodeTree *ntree;
1080
1081         /* trees are created as local trees for compositor, material or texture nodes,
1082          * node groups and other tree types are created as library data.
1083          */
1084         if (bmain) {
1085                 ntree = BKE_libblock_alloc(&bmain->nodetree, ID_NT, name);
1086         }
1087         else {
1088                 ntree = MEM_callocN(sizeof(bNodeTree), "new node tree");
1089                 *( (short *)ntree->id.name ) = ID_NT;
1090                 BLI_strncpy(ntree->id.name + 2, name, sizeof(ntree->id.name));
1091         }
1092
1093         /* Types are fully initialized at this point,
1094          * if an undefined node is added later this will be reset.
1095          */
1096         ntree->init |= NTREE_TYPE_INIT;
1097
1098         BLI_strncpy(ntree->idname, idname, sizeof(ntree->idname));
1099         ntree_set_typeinfo(ntree, ntreeTypeFind(idname));
1100
1101         return ntree;
1102 }
1103
1104 /* Warning: this function gets called during some rather unexpected times
1105  *      - this gets called when executing compositing updates (for threaded previews)
1106  *      - when the nodetree datablock needs to be copied (i.e. when users get copied)
1107  *      - for scene duplication use ntreeSwapID() after so we don't have stale pointers.
1108  *
1109  * do_make_extern: keep enabled for general use, only reason _not_ to enable is when
1110  * copying for internal use (threads for eg), where you wont want it to modify the
1111  * scene data.
1112  */
1113 static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_user, const short do_make_extern, const short copy_previews)
1114 {
1115         bNodeTree *newtree;
1116         bNode *node /*, *nnode */ /* UNUSED */, *last;
1117         bNodeSocket *sock, *oldsock;
1118         bNodeLink *link;
1119
1120         if (ntree == NULL) return NULL;
1121
1122         /* is ntree part of library? */
1123         for (newtree = G.main->nodetree.first; newtree; newtree = newtree->id.next)
1124                 if (newtree == ntree) break;
1125         if (newtree) {
1126                 newtree = BKE_libblock_copy(&ntree->id);
1127         }
1128         else {
1129                 newtree = MEM_dupallocN(ntree);
1130                 newtree->id.lib = NULL; /* same as owning datablock id.lib */
1131                 BKE_libblock_copy_data(&newtree->id, &ntree->id, true); /* copy animdata and ID props */
1132         }
1133
1134         id_us_plus((ID *)newtree->gpd);
1135
1136         /* in case a running nodetree is copied */
1137         newtree->execdata = NULL;
1138
1139         newtree->nodes.first = newtree->nodes.last = NULL;
1140         newtree->links.first = newtree->links.last = NULL;
1141
1142         last = ntree->nodes.last;
1143         for (node = ntree->nodes.first; node; node = node->next) {
1144
1145                 /* ntreeUserDecrefID inline */
1146                 if (do_id_user) {
1147                         id_us_plus(node->id);
1148                 }
1149
1150                 if (do_make_extern) {
1151                         id_lib_extern(node->id);
1152                 }
1153
1154                 node->new_node = NULL;
1155                 /* nnode = */ nodeCopyNode(newtree, node);   /* sets node->new */
1156
1157                 /* make sure we don't copy new nodes again! */
1158                 if (node == last)
1159                         break;
1160         }
1161
1162         /* copy links */
1163         BLI_duplicatelist(&newtree->links, &ntree->links);
1164         for (link = newtree->links.first; link; link = link->next) {
1165                 link->fromnode = (link->fromnode ? link->fromnode->new_node : NULL);
1166                 link->fromsock = (link->fromsock ? link->fromsock->new_sock : NULL);
1167                 link->tonode = (link->tonode ? link->tonode->new_node : NULL);
1168                 link->tosock = (link->tosock ? link->tosock->new_sock : NULL);
1169                 /* update the link socket's pointer */
1170                 if (link->tosock)
1171                         link->tosock->link = link;
1172         }
1173
1174         /* copy interface sockets */
1175         BLI_duplicatelist(&newtree->inputs, &ntree->inputs);
1176         oldsock = ntree->inputs.first;
1177         for (sock = newtree->inputs.first; sock; sock = sock->next, oldsock = oldsock->next)
1178                 node_socket_copy(sock, oldsock);
1179
1180         BLI_duplicatelist(&newtree->outputs, &ntree->outputs);
1181         oldsock = ntree->outputs.first;
1182         for (sock = newtree->outputs.first; sock; sock = sock->next, oldsock = oldsock->next)
1183                 node_socket_copy(sock, oldsock);
1184
1185         /* copy preview hash */
1186         if (ntree->previews && copy_previews) {
1187                 bNodeInstanceHashIterator iter;
1188
1189                 newtree->previews = BKE_node_instance_hash_new("node previews");
1190
1191                 NODE_INSTANCE_HASH_ITER(iter, ntree->previews) {
1192                         bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
1193                         bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1194                         BKE_node_instance_hash_insert(newtree->previews, key, BKE_node_preview_copy(preview));
1195                 }
1196         }
1197         else
1198                 newtree->previews = NULL;
1199
1200         /* update node->parent pointers */
1201         for (node = newtree->nodes.first; node; node = node->next) {
1202                 if (node->parent)
1203                         node->parent = node->parent->new_node;
1204         }
1205
1206         /* node tree will generate its own interface type */
1207         ntree->interface_type = NULL;
1208
1209         return newtree;
1210 }
1211
1212 bNodeTree *ntreeCopyTree_ex(bNodeTree *ntree, const short do_id_user)
1213 {
1214         return ntreeCopyTree_internal(ntree, do_id_user, TRUE, TRUE);
1215 }
1216 bNodeTree *ntreeCopyTree(bNodeTree *ntree)
1217 {
1218         return ntreeCopyTree_ex(ntree, TRUE);
1219 }
1220
1221 /* use when duplicating scenes */
1222 void ntreeSwitchID_ex(bNodeTree *ntree, ID *id_from, ID *id_to, const short do_id_user)
1223 {
1224         bNode *node;
1225
1226         if (id_from == id_to) {
1227                 /* should never happen but may as well skip if it does */
1228                 return;
1229         }
1230
1231         /* for scene duplication only */
1232         for (node = ntree->nodes.first; node; node = node->next) {
1233                 if (node->id == id_from) {
1234                         if (do_id_user) {
1235                                 id_us_min(id_from);
1236                                 id_us_plus(id_to);
1237                         }
1238
1239                         node->id = id_to;
1240                 }
1241         }
1242 }
1243 void ntreeSwitchID(bNodeTree *ntree, ID *id_from, ID *id_to)
1244 {
1245         ntreeSwitchID_ex(ntree, id_from, id_to, TRUE);
1246 }
1247
1248 void ntreeUserIncrefID(bNodeTree *ntree)
1249 {
1250         bNode *node;
1251         for (node = ntree->nodes.first; node; node = node->next) {
1252                 id_us_plus(node->id);
1253         }
1254 }
1255 void ntreeUserDecrefID(bNodeTree *ntree)
1256 {
1257         bNode *node;
1258         for (node = ntree->nodes.first; node; node = node->next) {
1259                 id_us_min(node->id);
1260         }
1261 }
1262
1263 /* *************** Node Preview *********** */
1264
1265 /* XXX this should be removed eventually ...
1266  * Currently BKE functions are modelled closely on previous code,
1267  * using BKE_node_preview_init_tree to set up previews for a whole node tree in advance.
1268  * This should be left more to the individual node tree implementations.
1269  */
1270 int BKE_node_preview_used(bNode *node)
1271 {
1272         /* XXX check for closed nodes? */
1273         return (node->typeinfo->flag & NODE_PREVIEW) != 0;
1274 }
1275
1276 bNodePreview *BKE_node_preview_verify(bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, int create)
1277 {
1278         bNodePreview *preview;
1279
1280         preview = BKE_node_instance_hash_lookup(previews, key);
1281         if (!preview) {
1282                 if (create) {
1283                         preview = MEM_callocN(sizeof(bNodePreview), "node preview");
1284                         BKE_node_instance_hash_insert(previews, key, preview);
1285                 }
1286                 else
1287                         return NULL;
1288         }
1289
1290         /* node previews can get added with variable size this way */
1291         if (xsize == 0 || ysize == 0)
1292                 return preview;
1293
1294         /* sanity checks & initialize */
1295         if (preview->rect) {
1296                 if (preview->xsize != xsize || preview->ysize != ysize) {
1297                         MEM_freeN(preview->rect);
1298                         preview->rect = NULL;
1299                 }
1300         }
1301
1302         if (preview->rect == NULL) {
1303                 preview->rect = MEM_callocN(4 * xsize + xsize * ysize * sizeof(char) * 4, "node preview rect");
1304                 preview->xsize = xsize;
1305                 preview->ysize = ysize;
1306         }
1307         /* no clear, makes nicer previews */
1308
1309         return preview;
1310 }
1311
1312 bNodePreview *BKE_node_preview_copy(bNodePreview *preview)
1313 {
1314         bNodePreview *new_preview = MEM_dupallocN(preview);
1315         if (preview->rect)
1316                 new_preview->rect = MEM_dupallocN(preview->rect);
1317         return new_preview;
1318 }
1319
1320 void BKE_node_preview_free(bNodePreview *preview)
1321 {
1322         if (preview->rect)
1323                 MEM_freeN(preview->rect);
1324         MEM_freeN(preview);
1325 }
1326
1327 static void node_preview_init_tree_recursive(bNodeInstanceHash *previews, bNodeTree *ntree, bNodeInstanceKey parent_key, int xsize, int ysize, int create)
1328 {
1329         bNode *node;
1330         for (node = ntree->nodes.first; node; node = node->next) {
1331                 bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
1332
1333                 if (BKE_node_preview_used(node)) {
1334                         node->preview_xsize = xsize;
1335                         node->preview_ysize = ysize;
1336
1337                         BKE_node_preview_verify(previews, key, xsize, ysize, create);
1338                 }
1339
1340                 if (node->type == NODE_GROUP && node->id)
1341                         node_preview_init_tree_recursive(previews, (bNodeTree *)node->id, key, xsize, ysize, create);
1342         }
1343 }
1344
1345 void BKE_node_preview_init_tree(bNodeTree *ntree, int xsize, int ysize, int create_previews)
1346 {
1347         if (!ntree)
1348                 return;
1349
1350         if (!ntree->previews)
1351                 ntree->previews = BKE_node_instance_hash_new("node previews");
1352
1353         node_preview_init_tree_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE, xsize, ysize, create_previews);
1354 }
1355
1356 static void node_preview_tag_used_recursive(bNodeInstanceHash *previews, bNodeTree *ntree, bNodeInstanceKey parent_key)
1357 {
1358         bNode *node;
1359         for (node = ntree->nodes.first; node; node = node->next) {
1360                 bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
1361
1362                 if (BKE_node_preview_used(node))
1363                         BKE_node_instance_hash_tag_key(previews, key);
1364
1365                 if (node->type == NODE_GROUP && node->id)
1366                         node_preview_tag_used_recursive(previews, (bNodeTree *)node->id, key);
1367         }
1368 }
1369
1370 void BKE_node_preview_remove_unused(bNodeTree *ntree)
1371 {
1372         if (!ntree || !ntree->previews)
1373                 return;
1374
1375         /* use the instance hash functions for tagging and removing unused previews */
1376         BKE_node_instance_hash_clear_tags(ntree->previews);
1377         node_preview_tag_used_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE);
1378
1379         BKE_node_instance_hash_remove_untagged(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1380 }
1381
1382 void BKE_node_preview_free_tree(bNodeTree *ntree)
1383 {
1384         if (!ntree)
1385                 return;
1386
1387         if (ntree->previews) {
1388                 BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1389                 ntree->previews = NULL;
1390         }
1391 }
1392
1393 void BKE_node_preview_clear(bNodePreview *preview)
1394 {
1395         if (preview && preview->rect)
1396                 memset(preview->rect, 0, MEM_allocN_len(preview->rect));
1397 }
1398
1399 void BKE_node_preview_clear_tree(bNodeTree *ntree)
1400 {
1401         bNodeInstanceHashIterator iter;
1402
1403         if (!ntree || !ntree->previews)
1404                 return;
1405
1406         NODE_INSTANCE_HASH_ITER(iter, ntree->previews) {
1407                 bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1408                 BKE_node_preview_clear(preview);
1409         }
1410 }
1411
1412 static void node_preview_sync(bNodePreview *to, bNodePreview *from)
1413 {
1414         /* sizes should have been initialized by BKE_node_preview_init_tree */
1415         BLI_assert(to->xsize == from->xsize && to->ysize == from->ysize);
1416
1417         /* copy over contents of previews */
1418         if (to->rect && from->rect) {
1419                 int xsize = to->xsize;
1420                 int ysize = to->ysize;
1421                 memcpy(to->rect, from->rect, 4 * xsize + xsize * ysize * sizeof(char) * 4);
1422         }
1423 }
1424
1425 void BKE_node_preview_sync_tree(bNodeTree *to_ntree, bNodeTree *from_ntree)
1426 {
1427         bNodeInstanceHash *from_previews = from_ntree->previews;
1428         bNodeInstanceHash *to_previews = to_ntree->previews;
1429         bNodeInstanceHashIterator iter;
1430
1431         if (!from_previews || !to_previews)
1432                 return;
1433
1434         NODE_INSTANCE_HASH_ITER(iter, from_previews) {
1435                 bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
1436                 bNodePreview *from = BKE_node_instance_hash_iterator_get_value(&iter);
1437                 bNodePreview *to = BKE_node_instance_hash_lookup(to_previews, key);
1438
1439                 if (from && to)
1440                         node_preview_sync(to, from);
1441         }
1442 }
1443
1444 void BKE_node_preview_merge_tree(bNodeTree *to_ntree, bNodeTree *from_ntree, bool remove_old)
1445 {
1446         if (remove_old || !to_ntree->previews) {
1447                 /* free old previews */
1448                 if (to_ntree->previews)
1449                         BKE_node_instance_hash_free(to_ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1450
1451                 /* transfer previews */
1452                 to_ntree->previews = from_ntree->previews;
1453                 from_ntree->previews = NULL;
1454
1455                 /* clean up, in case any to_ntree nodes have been removed */
1456                 BKE_node_preview_remove_unused(to_ntree);
1457         }
1458         else {
1459                 bNodeInstanceHashIterator iter;
1460
1461                 if (from_ntree->previews) {
1462                         NODE_INSTANCE_HASH_ITER(iter, from_ntree->previews) {
1463                                 bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
1464                                 bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1465
1466                                 /* replace existing previews */
1467                                 BKE_node_instance_hash_remove(to_ntree->previews, key, (bNodeInstanceValueFP)BKE_node_preview_free);
1468                                 BKE_node_instance_hash_insert(to_ntree->previews, key, preview);
1469                         }
1470
1471                         /* Note: NULL free function here, because pointers have already been moved over to to_ntree->previews! */
1472                         BKE_node_instance_hash_free(from_ntree->previews, NULL);
1473                         from_ntree->previews = NULL;
1474                 }
1475         }
1476 }
1477
1478 /* hack warning! this function is only used for shader previews, and
1479  * since it gets called multiple times per pixel for Ztransp we only
1480  * add the color once. Preview gets cleared before it starts render though */
1481 void BKE_node_preview_set_pixel(bNodePreview *preview, const float col[4], int x, int y, int do_manage)
1482 {
1483         if (preview) {
1484                 if (x >= 0 && y >= 0) {
1485                         if (x < preview->xsize && y < preview->ysize) {
1486                                 unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
1487
1488                                 if (do_manage) {
1489                                         linearrgb_to_srgb_uchar4(tar, col);
1490                                 }
1491                                 else {
1492                                         rgba_float_to_uchar(tar, col);
1493                                 }
1494                         }
1495                         //else printf("prv out bound x y %d %d\n", x, y);
1496                 }
1497                 //else printf("prv out bound x y %d %d\n", x, y);
1498         }
1499 }
1500
1501 #if 0
1502 static void nodeClearPreview(bNode *node)
1503 {
1504         if (node->preview && node->preview->rect)
1505                 memset(node->preview->rect, 0, MEM_allocN_len(node->preview->rect));
1506 }
1507
1508 /* use it to enforce clear */
1509 void ntreeClearPreview(bNodeTree *ntree)
1510 {
1511         bNode *node;
1512
1513         if (ntree == NULL)
1514                 return;
1515
1516         for (node = ntree->nodes.first; node; node = node->next) {
1517                 if (node->typeinfo->flag & NODE_PREVIEW)
1518                         nodeClearPreview(node);
1519                 if (node->type == NODE_GROUP)
1520                         ntreeClearPreview((bNodeTree *)node->id);
1521         }
1522 }
1523
1524 /* hack warning! this function is only used for shader previews, and
1525  * since it gets called multiple times per pixel for Ztransp we only
1526  * add the color once. Preview gets cleared before it starts render though */
1527 void nodeAddToPreview(bNode *node, const float col[4], int x, int y, int do_manage)
1528 {
1529         bNodePreview *preview = node->preview;
1530         if (preview) {
1531                 if (x >= 0 && y >= 0) {
1532                         if (x < preview->xsize && y < preview->ysize) {
1533                                 unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
1534
1535                                 if (do_manage) {
1536                                         linearrgb_to_srgb_uchar4(tar, col);
1537                                 }
1538                                 else {
1539                                         rgba_float_to_uchar(tar, col);
1540                                 }
1541                         }
1542                         //else printf("prv out bound x y %d %d\n", x, y);
1543                 }
1544                 //else printf("prv out bound x y %d %d\n", x, y);
1545         }
1546 }
1547 #endif
1548
1549 /* ************** Free stuff ********** */
1550
1551 /* goes over entire tree */
1552 void nodeUnlinkNode(bNodeTree *ntree, bNode *node)
1553 {
1554         bNodeLink *link, *next;
1555         bNodeSocket *sock;
1556         ListBase *lb;
1557
1558         for (link = ntree->links.first; link; link = next) {
1559                 next = link->next;
1560
1561                 if (link->fromnode == node) {
1562                         lb = &node->outputs;
1563                         if (link->tonode)
1564                                 link->tonode->update |= NODE_UPDATE;
1565                 }
1566                 else if (link->tonode == node)
1567                         lb = &node->inputs;
1568                 else
1569                         lb = NULL;
1570
1571                 if (lb) {
1572                         for (sock = lb->first; sock; sock = sock->next) {
1573                                 if (link->fromsock == sock || link->tosock == sock)
1574                                         break;
1575                         }
1576                         if (sock) {
1577                                 nodeRemLink(ntree, link);
1578                         }
1579                 }
1580         }
1581 }
1582
1583 static void node_unlink_attached(bNodeTree *ntree, bNode *parent)
1584 {
1585         bNode *node;
1586         for (node = ntree->nodes.first; node; node = node->next) {
1587                 if (node->parent == parent)
1588                         nodeDetachNode(node);
1589         }
1590 }
1591
1592 /** \note caller needs to manage node->id user */
1593 void nodeFreeNode(bNodeTree *ntree, bNode *node)
1594 {
1595         bNodeSocket *sock, *nextsock;
1596
1597         /* extra free callback */
1598         if (node->typeinfo && node->typeinfo->freefunc_api) {
1599                 PointerRNA ptr;
1600                 RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
1601
1602                 node->typeinfo->freefunc_api(&ptr);
1603         }
1604
1605         /* since it is called while free database, node->id is undefined */
1606
1607         /* can be called for nodes outside a node tree (e.g. clipboard) */
1608         if (ntree) {
1609                 /* remove all references to this node */
1610                 nodeUnlinkNode(ntree, node);
1611                 node_unlink_attached(ntree, node);
1612
1613                 BLI_remlink(&ntree->nodes, node);
1614
1615                 if (ntree->typeinfo && ntree->typeinfo->free_node_cache)
1616                         ntree->typeinfo->free_node_cache(ntree, node);
1617
1618                 /* texture node has bad habit of keeping exec data around */
1619                 if (ntree->type == NTREE_TEXTURE && ntree->execdata) {
1620                         ntreeTexEndExecTree(ntree->execdata);
1621                         ntree->execdata = NULL;
1622                 }
1623
1624                 if (node->typeinfo && node->typeinfo->freefunc)
1625                         node->typeinfo->freefunc(node);
1626         }
1627
1628         for (sock = node->inputs.first; sock; sock = nextsock) {
1629                 nextsock = sock->next;
1630                 node_socket_free(ntree, sock, node);
1631                 MEM_freeN(sock);
1632         }
1633         for (sock = node->outputs.first; sock; sock = nextsock) {
1634                 nextsock = sock->next;
1635                 node_socket_free(ntree, sock, node);
1636                 MEM_freeN(sock);
1637         }
1638
1639         BLI_freelistN(&node->internal_links);
1640
1641         if (node->prop) {
1642                 IDP_FreeProperty(node->prop);
1643                 MEM_freeN(node->prop);
1644         }
1645
1646         MEM_freeN(node);
1647
1648         if (ntree)
1649                 ntree->update |= NTREE_UPDATE_NODES;
1650 }
1651
1652 static void node_socket_interface_free(bNodeTree *UNUSED(ntree), bNodeSocket *sock)
1653 {
1654         if (sock->prop) {
1655                 IDP_FreeProperty(sock->prop);
1656                 MEM_freeN(sock->prop);
1657         }
1658
1659         if (sock->default_value)
1660                 MEM_freeN(sock->default_value);
1661 }
1662
1663 /* do not free ntree itself here, BKE_libblock_free calls this function too */
1664 void ntreeFreeTree_ex(bNodeTree *ntree, const short do_id_user)
1665 {
1666         bNodeTree *tntree;
1667         bNode *node, *next;
1668         bNodeSocket *sock, *nextsock;
1669
1670         if (ntree == NULL) return;
1671
1672         /* XXX hack! node trees should not store execution graphs at all.
1673          * This should be removed when old tree types no longer require it.
1674          * Currently the execution data for texture nodes remains in the tree
1675          * after execution, until the node tree is updated or freed.
1676          */
1677         if (ntree->execdata) {
1678                 switch (ntree->type) {
1679                         case NTREE_SHADER:
1680                                 ntreeShaderEndExecTree(ntree->execdata);
1681                                 break;
1682                         case NTREE_TEXTURE:
1683                                 ntreeTexEndExecTree(ntree->execdata);
1684                                 ntree->execdata = NULL;
1685                                 break;
1686                 }
1687         }
1688
1689         /* unregister associated RNA types */
1690         ntreeInterfaceTypeFree(ntree);
1691
1692         BKE_free_animdata((ID *)ntree);
1693
1694         id_us_min((ID *)ntree->gpd);
1695
1696         BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
1697
1698         for (node = ntree->nodes.first; node; node = next) {
1699                 next = node->next;
1700
1701                 /* ntreeUserIncrefID inline */
1702
1703                 /* XXX, this is correct, however when freeing the entire database
1704                  * this ends up accessing freed data which isn't properly unlinking
1705                  * its self from scene nodes, SO - for now prefer invalid usercounts
1706                  * on free rather then bad memory access - Campbell */
1707 #if 0
1708                 if (do_id_user) {
1709                         id_us_min(node->id);
1710                 }
1711 #else
1712                 (void)do_id_user;
1713 #endif
1714
1715                 nodeFreeNode(ntree, node);
1716         }
1717
1718         /* free interface sockets */
1719         for (sock = ntree->inputs.first; sock; sock = nextsock) {
1720                 nextsock = sock->next;
1721                 node_socket_interface_free(ntree, sock);
1722                 MEM_freeN(sock);
1723         }
1724         for (sock = ntree->outputs.first; sock; sock = nextsock) {
1725                 nextsock = sock->next;
1726                 node_socket_interface_free(ntree, sock);
1727                 MEM_freeN(sock);
1728         }
1729
1730         /* free preview hash */
1731         if (ntree->previews) {
1732                 BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1733         }
1734
1735         /* if ntree is not part of library, free the libblock data explicitly */
1736         for (tntree = G.main->nodetree.first; tntree; tntree = tntree->id.next)
1737                 if (tntree == ntree)
1738                         break;
1739         if (tntree == NULL) {
1740                 BKE_libblock_free_data(&ntree->id);
1741         }
1742 }
1743 /* same as ntreeFreeTree_ex but always manage users */
1744 void ntreeFreeTree(bNodeTree *ntree)
1745 {
1746         ntreeFreeTree_ex(ntree, TRUE);
1747 }
1748
1749 void ntreeFreeCache(bNodeTree *ntree)
1750 {
1751         if (ntree == NULL) return;
1752
1753         if (ntree->typeinfo->free_cache)
1754                 ntree->typeinfo->free_cache(ntree);
1755 }
1756
1757 void ntreeSetOutput(bNodeTree *ntree)
1758 {
1759         bNode *node;
1760
1761         /* find the active outputs, might become tree type dependent handler */
1762         for (node = ntree->nodes.first; node; node = node->next) {
1763                 if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1764                         bNode *tnode;
1765                         int output = 0;
1766
1767                         /* we need a check for which output node should be tagged like this, below an exception */
1768                         if (node->type == CMP_NODE_OUTPUT_FILE)
1769                                 continue;
1770
1771                         /* there is more types having output class, each one is checked */
1772                         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1773                                 if (tnode->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1774
1775                                         if (ntree->type == NTREE_COMPOSIT) {
1776
1777                                                 /* same type, exception for viewer */
1778                                                 if (tnode->type == node->type ||
1779                                                     (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
1780                                                      ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)))
1781                                                 {
1782                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1783                                                                 output++;
1784                                                                 if (output > 1)
1785                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1786                                                         }
1787                                                 }
1788                                         }
1789                                         else {
1790                                                 /* same type */
1791                                                 if (tnode->type == node->type) {
1792                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1793                                                                 output++;
1794                                                                 if (output > 1)
1795                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1796                                                         }
1797                                                 }
1798                                         }
1799                                 }
1800                         }
1801                         if (output == 0)
1802                                 node->flag |= NODE_DO_OUTPUT;
1803                 }
1804
1805                 /* group node outputs use this flag too */
1806                 if (node->type == NODE_GROUP_OUTPUT) {
1807                         bNode *tnode;
1808                         int output = 0;
1809
1810                         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1811                                 if (tnode->type == NODE_GROUP_OUTPUT) {
1812                                         if (tnode->flag & NODE_DO_OUTPUT) {
1813                                                 output++;
1814                                                 if (output > 1)
1815                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1816                                         }
1817                                 }
1818                         }
1819                         if (output == 0)
1820                                 node->flag |= NODE_DO_OUTPUT;
1821                 }
1822         }
1823
1824         /* here we could recursively set which nodes have to be done,
1825          * might be different for editor or for "real" use... */
1826 }
1827
1828 bNodeTree *ntreeFromID(ID *id)
1829 {
1830         switch (GS(id->name)) {
1831                 case ID_MA:  return ((Material *)id)->nodetree;
1832                 case ID_LA:  return ((Lamp *)id)->nodetree;
1833                 case ID_WO:  return ((World *)id)->nodetree;
1834                 case ID_TE:  return ((Tex *)id)->nodetree;
1835                 case ID_SCE: return ((Scene *)id)->nodetree;
1836                 default: return NULL;
1837         }
1838 }
1839
1840 void ntreeMakeLocal(bNodeTree *ntree)
1841 {
1842         Main *bmain = G.main;
1843         int lib = FALSE, local = FALSE;
1844
1845         /* - only lib users: do nothing
1846          * - only local users: set flag
1847          * - mixed: make copy
1848          */
1849
1850         if (ntree->id.lib == NULL) return;
1851         if (ntree->id.us == 1) {
1852                 id_clear_lib_data(bmain, (ID *)ntree);
1853                 return;
1854         }
1855
1856         /* now check users of groups... again typedepending, callback... */
1857         FOREACH_NODETREE(G.main, tntree, owner_id) {
1858                 bNode *node;
1859                 /* find if group is in tree */
1860                 for (node = tntree->nodes.first; node; node = node->next) {
1861                         if (node->id == (ID *)ntree) {
1862                                 if (owner_id->lib)
1863                                         lib = TRUE;
1864                                 else
1865                                         local = TRUE;
1866                         }
1867                 }
1868         } FOREACH_NODETREE_END
1869
1870         /* if all users are local, we simply make tree local */
1871         if (local && !lib) {
1872                 id_clear_lib_data(bmain, (ID *)ntree);
1873         }
1874         else if (local && lib) {
1875                 /* this is the mixed case, we copy the tree and assign it to local users */
1876                 bNodeTree *newtree = ntreeCopyTree(ntree);
1877
1878                 newtree->id.us = 0;
1879
1880                 FOREACH_NODETREE(G.main, tntree, owner_id) {
1881                         bNode *node;
1882                         /* find if group is in tree */
1883                         for (node = tntree->nodes.first; node; node = node->next) {
1884                                 if (node->id == (ID *)ntree) {
1885                                         if (owner_id->lib == NULL) {
1886                                                 node->id = (ID *)newtree;
1887                                                 newtree->id.us++;
1888                                                 ntree->id.us--;
1889                                         }
1890                                 }
1891                         }
1892                 } FOREACH_NODETREE_END
1893         }
1894 }
1895
1896 int ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
1897 {
1898         bNode *node = ntree->nodes.first;
1899         for (; node; node = node->next)
1900                 if (node == testnode)
1901                         return 1;
1902         return 0;
1903 }
1904
1905 int ntreeOutputExists(bNode *node, bNodeSocket *testsock)
1906 {
1907         bNodeSocket *sock = node->outputs.first;
1908         for (; sock; sock = sock->next)
1909                 if (sock == testsock)
1910                         return 1;
1911         return 0;
1912 }
1913
1914 /* returns localized tree for execution in threads */
1915 bNodeTree *ntreeLocalize(bNodeTree *ntree)
1916 {
1917         if (ntree) {
1918                 bNodeTree *ltree;
1919                 bNode *node;
1920
1921                 bAction *action_backup = NULL, *tmpact_backup = NULL;
1922
1923                 /* Workaround for copying an action on each render!
1924                  * set action to NULL so animdata actions don't get copied */
1925                 AnimData *adt = BKE_animdata_from_id(&ntree->id);
1926
1927                 if (adt) {
1928                         action_backup = adt->action;
1929                         tmpact_backup = adt->tmpact;
1930
1931                         adt->action = NULL;
1932                         adt->tmpact = NULL;
1933                 }
1934
1935                 /* Make full copy.
1936                  * Note: previews are not copied here.
1937                  */
1938                 ltree = ntreeCopyTree_internal(ntree, FALSE, FALSE, FALSE);
1939
1940                 if (adt) {
1941                         AnimData *ladt = BKE_animdata_from_id(&ltree->id);
1942
1943                         adt->action = ladt->action = action_backup;
1944                         adt->tmpact = ladt->tmpact = tmpact_backup;
1945
1946                         if (action_backup) action_backup->id.us++;
1947                         if (tmpact_backup) tmpact_backup->id.us++;
1948
1949                 }
1950                 /* end animdata uglyness */
1951
1952                 /* ensures only a single output node is enabled */
1953                 ntreeSetOutput(ntree);
1954
1955                 for (node = ntree->nodes.first; node; node = node->next) {
1956                         /* store new_node pointer to original */
1957                         node->new_node->new_node = node;
1958                 }
1959
1960                 if (ntree->typeinfo->localize)
1961                         ntree->typeinfo->localize(ltree, ntree);
1962
1963                 return ltree;
1964         }
1965         else
1966                 return NULL;
1967 }
1968
1969 /* sync local composite with real tree */
1970 /* local tree is supposed to be running, be careful moving previews! */
1971 /* is called by jobs manager, outside threads, so it doesnt happen during draw */
1972 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
1973 {
1974         if (localtree && ntree) {
1975                 if (ntree->typeinfo->local_sync)
1976                         ntree->typeinfo->local_sync(localtree, ntree);
1977         }
1978 }
1979
1980 /* merge local tree results back, and free local tree */
1981 /* we have to assume the editor already changed completely */
1982 void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
1983 {
1984         if (localtree && ntree) {
1985                 if (ntree->typeinfo->local_merge)
1986                         ntree->typeinfo->local_merge(localtree, ntree);
1987
1988                 ntreeFreeTree_ex(localtree, FALSE);
1989                 MEM_freeN(localtree);
1990         }
1991 }
1992
1993
1994 /* ************ NODE TREE INTERFACE *************** */
1995
1996 static bNodeSocket *make_socket_interface(bNodeTree *ntree, int in_out,
1997                                          const char *idname, const char *name)
1998 {
1999         bNodeSocketType *stype = nodeSocketTypeFind(idname);
2000         bNodeSocket *sock;
2001         int own_index = ntree->cur_index++;
2002
2003         if (stype == NULL) {
2004                 return NULL;
2005         }
2006
2007         sock = MEM_callocN(sizeof(bNodeSocket), "socket template");
2008         BLI_strncpy(sock->idname, stype->idname, sizeof(sock->idname));
2009         node_socket_set_typeinfo(ntree, sock, stype);
2010         sock->in_out = in_out;
2011         sock->type = SOCK_CUSTOM;       /* int type undefined by default */
2012
2013         /* assign new unique index */
2014         own_index = ntree->cur_index++;
2015         /* use the own_index as socket identifier */
2016         if (in_out == SOCK_IN)
2017                 BLI_snprintf(sock->identifier, MAX_NAME, "Input_%d", own_index);
2018         else
2019                 BLI_snprintf(sock->identifier, MAX_NAME, "Output_%d", own_index);
2020 #ifdef USE_NODE_COMPAT_CUSTOMNODES
2021         /* XXX forward compatibility:
2022          * own_index is deprecated, but needs to be set here.
2023          * Node sockets generally use the identifier string instead now,
2024          * but reconstructing own_index in writefile.c would require parsing the identifier string.
2025          */
2026
2027 #if (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406)) || defined(__clang__)
2028 #  pragma GCC diagnostic push
2029 #  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2030 #endif
2031
2032         sock->own_index = own_index;
2033
2034 #if (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406)) || defined(__clang__)
2035 #  pragma GCC diagnostic pop
2036 #endif
2037
2038 #endif  /* USE_NODE_COMPAT_CUSTOMNODES */
2039
2040         sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
2041
2042         BLI_strncpy(sock->name, name, NODE_MAXSTR);
2043         sock->storage = NULL;
2044         sock->flag |= SOCK_COLLAPSED;
2045
2046         return sock;
2047 }
2048
2049 bNodeSocket *ntreeFindSocketInterface(bNodeTree *ntree, int in_out, const char *identifier)
2050 {
2051         bNodeSocket *iosock = (in_out == SOCK_IN ? ntree->inputs.first : ntree->outputs.first);
2052         for (; iosock; iosock = iosock->next)
2053                 if (STREQ(iosock->identifier, identifier))
2054                         return iosock;
2055         return NULL;
2056 }
2057
2058 bNodeSocket *ntreeAddSocketInterface(bNodeTree *ntree, int in_out, const char *idname, const char *name)
2059 {
2060         bNodeSocket *iosock;
2061
2062         iosock = make_socket_interface(ntree, in_out, idname, name);
2063         if (in_out == SOCK_IN) {
2064                 BLI_addtail(&ntree->inputs, iosock);
2065                 ntree->update |= NTREE_UPDATE_GROUP_IN;
2066         }
2067         else if (in_out == SOCK_OUT) {
2068                 BLI_addtail(&ntree->outputs, iosock);
2069                 ntree->update |= NTREE_UPDATE_GROUP_OUT;
2070         }
2071
2072         return iosock;
2073 }
2074
2075 bNodeSocket *ntreeInsertSocketInterface(bNodeTree *ntree, int in_out, const char *idname,
2076                                bNodeSocket *next_sock, const char *name)
2077 {
2078         bNodeSocket *iosock;
2079
2080         iosock = make_socket_interface(ntree, in_out, idname, name);
2081         if (in_out == SOCK_IN) {
2082                 BLI_insertlinkbefore(&ntree->inputs, next_sock, iosock);
2083                 ntree->update |= NTREE_UPDATE_GROUP_IN;
2084         }
2085         else if (in_out == SOCK_OUT) {
2086                 BLI_insertlinkbefore(&ntree->outputs, next_sock, iosock);
2087                 ntree->update |= NTREE_UPDATE_GROUP_OUT;
2088         }
2089
2090         return iosock;
2091 }
2092
2093 struct bNodeSocket *ntreeAddSocketInterfaceFromSocket(bNodeTree *ntree, bNode *from_node, bNodeSocket *from_sock)
2094 {
2095         bNodeSocket *iosock = ntreeAddSocketInterface(ntree, from_sock->in_out, from_sock->idname, from_sock->name);
2096         if (iosock) {
2097                 if (iosock->typeinfo->interface_from_socket)
2098                         iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
2099         }
2100         return iosock;
2101 }
2102
2103 struct bNodeSocket *ntreeInsertSocketInterfaceFromSocket(bNodeTree *ntree, bNodeSocket *next_sock, bNode *from_node, bNodeSocket *from_sock)
2104 {
2105         bNodeSocket *iosock = ntreeInsertSocketInterface(ntree, from_sock->in_out, from_sock->idname, next_sock, from_sock->name);
2106         if (iosock) {
2107                 if (iosock->typeinfo->interface_from_socket)
2108                         iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
2109         }
2110         return iosock;
2111 }
2112
2113 void ntreeRemoveSocketInterface(bNodeTree *ntree, bNodeSocket *sock)
2114 {
2115         /* this is fast, this way we don't need an in_out argument */
2116         BLI_remlink(&ntree->inputs, sock);
2117         BLI_remlink(&ntree->outputs, sock);
2118
2119         node_socket_interface_free(ntree, sock);
2120         MEM_freeN(sock);
2121
2122         ntree->update |= NTREE_UPDATE_GROUP;
2123 }
2124
2125 /* generates a valid RNA identifier from the node tree name */
2126 static void ntree_interface_identifier_base(bNodeTree *ntree, char *base)
2127 {
2128         /* generate a valid RNA identifier */
2129         sprintf(base, "NodeTreeInterface_%s", ntree->id.name + 2);
2130         RNA_identifier_sanitize(base, FALSE);
2131 }
2132
2133 /* check if the identifier is already in use */
2134 static bool ntree_interface_unique_identifier_check(void *UNUSED(data), const char *identifier)
2135 {
2136         return (RNA_struct_find(identifier) != NULL);
2137 }
2138
2139 /* generates the actual unique identifier and ui name and description */
2140 static void ntree_interface_identifier(bNodeTree *ntree, const char *base, char *identifier, int maxlen, char *name, char *description)
2141 {
2142         /* There is a possibility that different node tree names get mapped to the same identifier
2143          * after sanitization (e.g. "SomeGroup_A", "SomeGroup.A" both get sanitized to "SomeGroup_A").
2144          * On top of the sanitized id string add a number suffix if necessary to avoid duplicates.
2145          */
2146         identifier[0] = '\0';
2147         BLI_uniquename_cb(ntree_interface_unique_identifier_check, NULL, base, '_', identifier, maxlen);
2148
2149         sprintf(name, "Node Tree %s Interface", ntree->id.name + 2);
2150         sprintf(description, "Interface properties of node group %s", ntree->id.name + 2);
2151 }
2152
2153 static void ntree_interface_type_create(bNodeTree *ntree)
2154 {
2155         StructRNA *srna;
2156         bNodeSocket *sock;
2157         /* strings are generated from base string + ID name, sizes are sufficient */
2158         char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64], description[MAX_ID_NAME + 64];
2159
2160         /* generate a valid RNA identifier */
2161         ntree_interface_identifier_base(ntree, base);
2162         ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
2163
2164         /* register a subtype of PropertyGroup */
2165         srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_PropertyGroup);
2166         RNA_def_struct_ui_text(srna, name, description);
2167         RNA_def_struct_duplicate_pointers(srna);
2168
2169         /* associate the RNA type with the node tree */
2170         ntree->interface_type = srna;
2171         RNA_struct_blender_type_set(srna, ntree);
2172
2173         /* add socket properties */
2174         for (sock = ntree->inputs.first; sock; sock = sock->next) {
2175                 bNodeSocketType *stype = sock->typeinfo;
2176                 if (stype && stype->interface_register_properties)
2177                         stype->interface_register_properties(ntree, sock, srna);
2178         }
2179         for (sock = ntree->outputs.first; sock; sock = sock->next) {
2180                 bNodeSocketType *stype = sock->typeinfo;
2181                 if (stype && stype->interface_register_properties)
2182                         stype->interface_register_properties(ntree, sock, srna);
2183         }
2184 }
2185
2186 StructRNA *ntreeInterfaceTypeGet(bNodeTree *ntree, int create)
2187 {
2188         if (ntree->interface_type) {
2189                 /* strings are generated from base string + ID name, sizes are sufficient */
2190                 char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64], description[MAX_ID_NAME + 64];
2191
2192                 /* A bit of a hack: when changing the ID name, update the RNA type identifier too,
2193                  * so that the names match. This is not strictly necessary to keep it working,
2194                  * but better for identifying associated NodeTree blocks and RNA types.
2195                  */
2196                 StructRNA *srna = ntree->interface_type;
2197
2198                 ntree_interface_identifier_base(ntree, base);
2199
2200                 /* RNA identifier may have a number suffix, but should start with the idbase string */
2201                 if (strncmp(RNA_struct_identifier(srna), base, sizeof(base)) != 0) {
2202                         /* generate new unique RNA identifier from the ID name */
2203                         ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
2204
2205                         /* rename the RNA type */
2206                         RNA_def_struct_free_pointers(srna);
2207                         RNA_def_struct_identifier(srna, identifier);
2208                         RNA_def_struct_ui_text(srna, name, description);
2209                         RNA_def_struct_duplicate_pointers(srna);
2210                 }
2211         }
2212         else if (create) {
2213                 ntree_interface_type_create(ntree);
2214         }
2215
2216         return ntree->interface_type;
2217 }
2218
2219 void ntreeInterfaceTypeFree(bNodeTree *ntree)
2220 {
2221         if (ntree->interface_type) {
2222                 RNA_struct_free(&BLENDER_RNA, ntree->interface_type);
2223                 ntree->interface_type = NULL;
2224         }
2225 }
2226
2227 void ntreeInterfaceTypeUpdate(bNodeTree *ntree)
2228 {
2229         /* XXX it would be sufficient to just recreate all properties
2230          * instead of re-registering the whole struct type,
2231          * but there is currently no good way to do this in the RNA functions.
2232          * Overhead should be negligible.
2233          */
2234         ntreeInterfaceTypeFree(ntree);
2235         ntree_interface_type_create(ntree);
2236 }
2237
2238
2239 /* ************ find stuff *************** */
2240
2241 int ntreeHasType(bNodeTree *ntree, int type)
2242 {
2243         bNode *node;
2244
2245         if (ntree)
2246                 for (node = ntree->nodes.first; node; node = node->next)
2247                         if (node->type == type)
2248                                 return 1;
2249         return 0;
2250 }
2251
2252 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
2253 {
2254         bNodeLink *link;
2255
2256         for (link = ntree->links.first; link; link = link->next) {
2257                 if (link->fromsock == from && link->tosock == to)
2258                         return link;
2259                 if (link->fromsock == to && link->tosock == from) /* hrms? */
2260                         return link;
2261         }
2262         return NULL;
2263 }
2264
2265 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
2266 {
2267         bNodeLink *link;
2268         int tot = 0;
2269
2270         for (link = ntree->links.first; link; link = link->next) {
2271                 if (link->fromsock == sock || link->tosock == sock)
2272                         tot++;
2273         }
2274         return tot;
2275 }
2276
2277 bNode *nodeGetActive(bNodeTree *ntree)
2278 {
2279         bNode *node;
2280
2281         if (ntree == NULL) return NULL;
2282
2283         for (node = ntree->nodes.first; node; node = node->next)
2284                 if (node->flag & NODE_ACTIVE)
2285                         break;
2286         return node;
2287 }
2288
2289 static bNode *node_get_active_id_recursive(bNodeInstanceKey active_key, bNodeInstanceKey parent_key, bNodeTree *ntree, short idtype)
2290 {
2291         if (parent_key.value == active_key.value) {
2292                 bNode *node;
2293                 for (node = ntree->nodes.first; node; node = node->next)
2294                         if (node->id && GS(node->id->name) == idtype)
2295                                 if (node->flag & NODE_ACTIVE_ID)
2296                                         return node;
2297         }
2298         else {
2299                 bNode *node, *tnode;
2300                 /* no node with active ID in this tree, look inside groups */
2301                 for (node = ntree->nodes.first; node; node = node->next) {
2302                         if (node->type == NODE_GROUP) {
2303                                 bNodeTree *group = (bNodeTree *)node->id;
2304                                 if (group) {
2305                                         bNodeInstanceKey group_key = BKE_node_instance_key(parent_key, ntree, node);
2306                                         tnode = node_get_active_id_recursive(active_key, group_key, group, idtype);
2307                                         if (tnode)
2308                                                 return tnode;
2309                                 }
2310                         }
2311                 }
2312         }
2313
2314         return NULL;
2315 }
2316
2317 /* two active flags, ID nodes have special flag for buttons display */
2318 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
2319 {
2320         if (ntree)
2321                 return node_get_active_id_recursive(ntree->active_viewer_key, NODE_INSTANCE_KEY_BASE, ntree, idtype);
2322         else
2323                 return NULL;
2324 }
2325
2326 bool nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
2327 {
2328         bNode *node;
2329         bool ok = false;
2330
2331         if (ntree == NULL) return ok;
2332
2333         for (node = ntree->nodes.first; node; node = node->next) {
2334                 if (node->id && GS(node->id->name) == idtype) {
2335                         if (id && ok == FALSE && node->id == id) {
2336                                 node->flag |= NODE_ACTIVE_ID;
2337                                 ok = TRUE;
2338                         }
2339                         else {
2340                                 node->flag &= ~NODE_ACTIVE_ID;
2341                         }
2342                 }
2343         }
2344
2345         /* update all groups linked from here
2346          * if active ID node has been found already,
2347          * just pass NULL so other matching nodes are deactivated.
2348          */
2349         for (node = ntree->nodes.first; node; node = node->next) {
2350                 if (node->type == NODE_GROUP)
2351                         ok |= nodeSetActiveID((bNodeTree *)node->id, idtype, (ok == false ? id : NULL));
2352         }
2353
2354         return ok;
2355 }
2356
2357
2358 /* two active flags, ID nodes have special flag for buttons display */
2359 void nodeClearActiveID(bNodeTree *ntree, short idtype)
2360 {
2361         bNode *node;
2362
2363         if (ntree == NULL) return;
2364
2365         for (node = ntree->nodes.first; node; node = node->next)
2366                 if (node->id && GS(node->id->name) == idtype)
2367                         node->flag &= ~NODE_ACTIVE_ID;
2368 }
2369
2370 void nodeSetSelected(bNode *node, int select)
2371 {
2372         if (select) {
2373                 node->flag |= NODE_SELECT;
2374         }
2375         else {
2376                 bNodeSocket *sock;
2377
2378                 node->flag &= ~NODE_SELECT;
2379
2380                 /* deselect sockets too */
2381                 for (sock = node->inputs.first; sock; sock = sock->next)
2382                         sock->flag &= ~NODE_SELECT;
2383                 for (sock = node->outputs.first; sock; sock = sock->next)
2384                         sock->flag &= ~NODE_SELECT;
2385         }
2386 }
2387
2388 void nodeClearActive(bNodeTree *ntree)
2389 {
2390         bNode *node;
2391
2392         if (ntree == NULL) return;
2393
2394         for (node = ntree->nodes.first; node; node = node->next)
2395                 node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_ID);
2396 }
2397
2398 /* two active flags, ID nodes have special flag for buttons display */
2399 void nodeSetActive(bNodeTree *ntree, bNode *node)
2400 {
2401         bNode *tnode;
2402
2403         /* make sure only one node is active, and only one per ID type */
2404         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
2405                 tnode->flag &= ~NODE_ACTIVE;
2406
2407                 if (node->id && tnode->id) {
2408                         if (GS(node->id->name) == GS(tnode->id->name))
2409                                 tnode->flag &= ~NODE_ACTIVE_ID;
2410                 }
2411                 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
2412                         tnode->flag &= ~NODE_ACTIVE_TEXTURE;
2413         }
2414
2415         node->flag |= NODE_ACTIVE;
2416         if (node->id)
2417                 node->flag |= NODE_ACTIVE_ID;
2418         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
2419                 node->flag |= NODE_ACTIVE_TEXTURE;
2420 }
2421
2422 int nodeSocketIsHidden(bNodeSocket *sock)
2423 {
2424         return ((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0);
2425 }
2426
2427 /* ************** Node Clipboard *********** */
2428
2429 #define USE_NODE_CB_VALIDATE
2430
2431 #ifdef USE_NODE_CB_VALIDATE
2432 /**
2433  * This data structure is to validate the node on creation,
2434  * otherwise we may reference missing data.
2435  *
2436  * Currently its only used for ID's, but nodes may one day
2437  * reference other pointers which need validation.
2438  */
2439 typedef struct bNodeClipboardExtraInfo {
2440         struct bNodeClipboardExtraInfo *next, *prev;
2441         ID  *id;
2442         char id_name[MAX_ID_NAME];
2443         char library_name[FILE_MAX];
2444 } bNodeClipboardExtraInfo;
2445 #endif  /* USE_NODE_CB_VALIDATE */
2446
2447
2448 typedef struct bNodeClipboard {
2449         ListBase nodes;
2450
2451 #ifdef USE_NODE_CB_VALIDATE
2452         ListBase nodes_extra_info;
2453 #endif
2454
2455         ListBase links;
2456         int type;
2457 } bNodeClipboard;
2458
2459 static bNodeClipboard node_clipboard = {{NULL}};
2460
2461 void BKE_node_clipboard_init(struct bNodeTree *ntree)
2462 {
2463         node_clipboard.type = ntree->type;
2464 }
2465
2466 void BKE_node_clipboard_clear(void)
2467 {
2468         bNode *node, *node_next;
2469         bNodeLink *link, *link_next;
2470
2471         for (link = node_clipboard.links.first; link; link = link_next) {
2472                 link_next = link->next;
2473                 nodeRemLink(NULL, link);
2474         }
2475         node_clipboard.links.first = node_clipboard.links.last = NULL;
2476
2477         for (node = node_clipboard.nodes.first; node; node = node_next) {
2478                 node_next = node->next;
2479                 nodeFreeNode(NULL, node);
2480         }
2481         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
2482
2483 #ifdef USE_NODE_CB_VALIDATE
2484         BLI_freelistN(&node_clipboard.nodes_extra_info);
2485 #endif
2486 }
2487
2488 /* return FALSE when one or more ID's are lost */
2489 int BKE_node_clipboard_validate(void)
2490 {
2491         int ok = TRUE;
2492
2493 #ifdef USE_NODE_CB_VALIDATE
2494         bNodeClipboardExtraInfo *node_info;
2495         bNode *node;
2496
2497
2498         /* lists must be aligned */
2499         BLI_assert(BLI_countlist(&node_clipboard.nodes) ==
2500                    BLI_countlist(&node_clipboard.nodes_extra_info));
2501
2502         for (node = node_clipboard.nodes.first, node_info = node_clipboard.nodes_extra_info.first;
2503              node;
2504              node = node->next, node_info = node_info->next)
2505         {
2506                 /* validate the node against the stored node info */
2507
2508                 /* re-assign each loop since we may clear,
2509                  * open a new file where the ID is valid, and paste again */
2510                 node->id = node_info->id;
2511
2512                 /* currently only validate the ID */
2513                 if (node->id) {
2514                         ListBase *lb = which_libbase(G.main, GS(node_info->id_name));
2515                         BLI_assert(lb != NULL);
2516
2517                         if (BLI_findindex(lb, node_info->id) == -1) {
2518                                 /* may assign NULL */
2519                                 node->id = BLI_findstring(lb, node_info->id_name + 2, offsetof(ID, name) + 2);
2520
2521                                 if (node->id == NULL) {
2522                                         ok = FALSE;
2523                                 }
2524                         }
2525                 }
2526         }
2527 #endif  /* USE_NODE_CB_VALIDATE */
2528
2529         return ok;
2530 }
2531
2532 void BKE_node_clipboard_add_node(bNode *node)
2533 {
2534 #ifdef USE_NODE_CB_VALIDATE
2535         /* add extra info */
2536         bNodeClipboardExtraInfo *node_info = MEM_mallocN(sizeof(bNodeClipboardExtraInfo), "bNodeClipboardExtraInfo");
2537
2538         node_info->id = node->id;
2539         if (node->id) {
2540                 BLI_strncpy(node_info->id_name, node->id->name, sizeof(node_info->id_name));
2541                 if (node->id->lib) {
2542                         BLI_strncpy(node_info->library_name, node->id->lib->filepath, sizeof(node_info->library_name));
2543                 }
2544                 else {
2545                         node_info->library_name[0] = '\0';
2546                 }
2547         }
2548         else {
2549                 node_info->id_name[0] = '\0';
2550                 node_info->library_name[0] = '\0';
2551         }
2552         BLI_addtail(&node_clipboard.nodes_extra_info, node_info);
2553         /* end extra info */
2554 #endif  /* USE_NODE_CB_VALIDATE */
2555
2556         /* add node */
2557         BLI_addtail(&node_clipboard.nodes, node);
2558
2559 }
2560
2561 void BKE_node_clipboard_add_link(bNodeLink *link)
2562 {
2563         BLI_addtail(&node_clipboard.links, link);
2564 }
2565
2566 const ListBase *BKE_node_clipboard_get_nodes(void)
2567 {
2568         return &node_clipboard.nodes;
2569 }
2570
2571 const ListBase *BKE_node_clipboard_get_links(void)
2572 {
2573         return &node_clipboard.links;
2574 }
2575
2576 int BKE_node_clipboard_get_type(void)
2577 {
2578         return node_clipboard.type;
2579 }
2580
2581
2582 /* Node Instance Hash */
2583
2584 /* magic number for initial hash key */
2585 const bNodeInstanceKey NODE_INSTANCE_KEY_BASE = {5381};
2586 const bNodeInstanceKey NODE_INSTANCE_KEY_NONE = {0};
2587
2588 /* Generate a hash key from ntree and node names
2589  * Uses the djb2 algorithm with xor by Bernstein:
2590  * http://www.cse.yorku.ca/~oz/hash.html
2591  */
2592 static bNodeInstanceKey node_hash_int_str(bNodeInstanceKey hash, const char *str)
2593 {
2594         char c;
2595
2596         while ((c = *str++))
2597                 hash.value = ((hash.value << 5) + hash.value) ^ c; /* (hash * 33) ^ c */
2598
2599         /* separator '\0' character, to avoid ambiguity from concatenated strings */
2600         hash.value = (hash.value << 5) + hash.value; /* hash * 33 */
2601
2602         return hash;
2603 }
2604
2605 bNodeInstanceKey BKE_node_instance_key(bNodeInstanceKey parent_key, bNodeTree *ntree, bNode *node)
2606 {
2607         bNodeInstanceKey key;
2608
2609         key = node_hash_int_str(parent_key, ntree->id.name + 2);
2610
2611         if (node)
2612                 key = node_hash_int_str(key, node->name);
2613
2614         return key;
2615 }
2616
2617 static unsigned int node_instance_hash_key(const void *key)
2618 {
2619         return ((const bNodeInstanceKey *)key)->value;
2620 }
2621
2622 static int node_instance_hash_key_cmp(const void *a, const void *b)
2623 {
2624         unsigned int value_a = ((const bNodeInstanceKey *)a)->value;
2625         unsigned int value_b = ((const bNodeInstanceKey *)b)->value;
2626         if (value_a == value_b)
2627                 return 0;
2628         else if (value_a < value_b)
2629                 return -1;
2630         else
2631                 return 1;
2632 }
2633
2634 bNodeInstanceHash *BKE_node_instance_hash_new(const char *info)
2635 {
2636         bNodeInstanceHash *hash = MEM_mallocN(sizeof(bNodeInstanceHash), info);
2637         hash->ghash = BLI_ghash_new(node_instance_hash_key, node_instance_hash_key_cmp, "node instance hash ghash");
2638         return hash;
2639 }
2640
2641 void BKE_node_instance_hash_free(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
2642 {
2643         BLI_ghash_free(hash->ghash, NULL, (GHashValFreeFP)valfreefp);
2644         MEM_freeN(hash);
2645 }
2646
2647 void BKE_node_instance_hash_insert(bNodeInstanceHash *hash, bNodeInstanceKey key, void *value)
2648 {
2649         bNodeInstanceHashEntry *entry = value;
2650         entry->key = key;
2651         entry->tag = 0;
2652         BLI_ghash_insert(hash->ghash, &entry->key, value);
2653 }
2654
2655 void *BKE_node_instance_hash_lookup(bNodeInstanceHash *hash, bNodeInstanceKey key)
2656 {
2657         return BLI_ghash_lookup(hash->ghash, &key);
2658 }
2659
2660 int BKE_node_instance_hash_remove(bNodeInstanceHash *hash, bNodeInstanceKey key, bNodeInstanceValueFP valfreefp)
2661 {
2662         return BLI_ghash_remove(hash->ghash, &key, NULL, (GHashValFreeFP)valfreefp);
2663 }
2664
2665 void BKE_node_instance_hash_clear(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
2666 {
2667         BLI_ghash_clear(hash->ghash, NULL, (GHashValFreeFP)valfreefp);
2668 }
2669
2670 void *BKE_node_instance_hash_pop(bNodeInstanceHash *hash, bNodeInstanceKey key)
2671 {
2672         return BLI_ghash_pop(hash->ghash, &key, NULL);
2673 }
2674
2675 int BKE_node_instance_hash_haskey(bNodeInstanceHash *hash, bNodeInstanceKey key)
2676 {
2677         return BLI_ghash_haskey(hash->ghash, &key);
2678 }
2679
2680 int BKE_node_instance_hash_size(bNodeInstanceHash *hash)
2681 {
2682         return BLI_ghash_size(hash->ghash);
2683 }
2684
2685 void BKE_node_instance_hash_clear_tags(bNodeInstanceHash *hash)
2686 {
2687         bNodeInstanceHashIterator iter;
2688
2689         NODE_INSTANCE_HASH_ITER(iter, hash) {
2690                 bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter);
2691
2692                 value->tag = 0;
2693         }
2694 }
2695
2696 void BKE_node_instance_hash_tag(bNodeInstanceHash *UNUSED(hash), void *value)
2697 {
2698         bNodeInstanceHashEntry *entry = value;
2699         entry->tag = 1;
2700 }
2701
2702 int BKE_node_instance_hash_tag_key(bNodeInstanceHash *hash, bNodeInstanceKey key)
2703 {
2704         bNodeInstanceHashEntry *entry = BKE_node_instance_hash_lookup(hash, key);
2705
2706         if (entry) {
2707                 entry->tag = 1;
2708                 return TRUE;
2709         }
2710         else
2711                 return FALSE;
2712 }
2713
2714 void BKE_node_instance_hash_remove_untagged(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
2715 {
2716         /* NOTE: Hash must not be mutated during iterating!
2717          * Store tagged entries in a separate list and remove items afterward.
2718          */
2719         bNodeInstanceKey *untagged = MEM_mallocN(sizeof(bNodeInstanceKey) * BKE_node_instance_hash_size(hash), "temporary node instance key list");
2720         bNodeInstanceHashIterator iter;
2721         int num_untagged, i;
2722
2723         num_untagged = 0;
2724         NODE_INSTANCE_HASH_ITER(iter, hash) {
2725                 bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter);
2726
2727                 if (!value->tag)
2728                         untagged[num_untagged++] = BKE_node_instance_hash_iterator_get_key(&iter);
2729         }
2730
2731         for (i = 0; i < num_untagged; ++i) {
2732                 BKE_node_instance_hash_remove(hash, untagged[i], valfreefp);
2733         }
2734
2735         MEM_freeN(untagged);
2736 }
2737
2738
2739 /* ************** dependency stuff *********** */
2740
2741 /* node is guaranteed to be not checked before */
2742 static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort)
2743 {
2744         bNode *fromnode;
2745         bNodeLink *link;
2746         int level = 0xFFF;
2747
2748         node->done = TRUE;
2749
2750         /* check linked nodes */
2751         for (link = ntree->links.first; link; link = link->next) {
2752                 if (link->tonode == node) {
2753                         fromnode = link->fromnode;
2754                         if (fromnode->done == 0)
2755                                 fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort);
2756                         if (fromnode->level <= level)
2757                                 level = fromnode->level - 1;
2758                 }
2759         }
2760
2761         /* check parent node */
2762         if (node->parent) {
2763                 if (node->parent->done == 0)
2764                         node->parent->level = node_get_deplist_recurs(ntree, node->parent, nsort);
2765                 if (node->parent->level <= level)
2766                         level = node->parent->level - 1;
2767         }
2768
2769         if (nsort) {
2770                 **nsort = node;
2771                 (*nsort)++;
2772         }
2773
2774         return level;
2775 }
2776
2777 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
2778 {
2779         bNode *node, **nsort;
2780
2781         *totnodes = 0;
2782
2783         /* first clear data */
2784         for (node = ntree->nodes.first; node; node = node->next) {
2785                 node->done = FALSE;
2786                 (*totnodes)++;
2787         }
2788         if (*totnodes == 0) {
2789                 *deplist = NULL;
2790                 return;
2791         }
2792
2793         nsort = *deplist = MEM_callocN((*totnodes) * sizeof(bNode *), "sorted node array");
2794
2795         /* recursive check */
2796         for (node = ntree->nodes.first; node; node = node->next) {
2797                 if (node->done == 0) {
2798                         node->level = node_get_deplist_recurs(ntree, node, &nsort);
2799                 }
2800         }
2801 }
2802
2803 /* only updates node->level for detecting cycles links */
2804 static void ntree_update_node_level(bNodeTree *ntree)
2805 {
2806         bNode *node;
2807
2808         /* first clear tag */
2809         for (node = ntree->nodes.first; node; node = node->next) {
2810                 node->done = FALSE;
2811         }
2812
2813         /* recursive check */
2814         for (node = ntree->nodes.first; node; node = node->next) {
2815                 if (node->done == 0) {
2816                         node->level = node_get_deplist_recurs(ntree, node, NULL);
2817                 }
2818         }
2819 }
2820
2821 static void ntree_update_link_pointers(bNodeTree *ntree)
2822 {
2823         bNode *node;
2824         bNodeSocket *sock;
2825         bNodeLink *link;
2826
2827         /* first clear data */
2828         for (node = ntree->nodes.first; node; node = node->next) {
2829                 for (sock = node->inputs.first; sock; sock = sock->next) {
2830                         sock->link = NULL;
2831                         sock->flag &= ~SOCK_IN_USE;
2832                 }
2833                 for (sock = node->outputs.first; sock; sock = sock->next) {
2834                         sock->flag &= ~SOCK_IN_USE;
2835                 }
2836         }
2837
2838         for (link = ntree->links.first; link; link = link->next) {
2839                 link->tosock->link = link;
2840
2841                 link->fromsock->flag |= SOCK_IN_USE;
2842                 link->tosock->flag |= SOCK_IN_USE;
2843         }
2844 }
2845
2846 static void ntree_validate_links(bNodeTree *ntree)
2847 {
2848         bNodeLink *link;
2849
2850         for (link = ntree->links.first; link; link = link->next) {
2851                 link->flag |= NODE_LINK_VALID;
2852                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
2853                         link->flag &= ~NODE_LINK_VALID;
2854                 else if (ntree->typeinfo->validate_link) {
2855                         if (!ntree->typeinfo->validate_link(ntree, link))
2856                                 link->flag &= ~NODE_LINK_VALID;
2857                 }
2858         }
2859 }
2860
2861 void ntreeVerifyNodes(struct Main *main, struct ID *id)
2862 {
2863         FOREACH_NODETREE(main, ntree, owner_id) {
2864                 bNode *node;
2865
2866                 for (node = ntree->nodes.first; node; node = node->next)
2867                         if (node->typeinfo->verifyfunc)
2868                                 node->typeinfo->verifyfunc(ntree, node, id);
2869         } FOREACH_NODETREE_END
2870 }
2871
2872 void ntreeUpdateTree(Main *bmain, bNodeTree *ntree)
2873 {
2874         bNode *node;
2875
2876         if (!ntree)
2877                 return;
2878
2879         /* avoid reentrant updates, can be caused by RNA update callbacks */
2880         if (ntree->is_updating)
2881                 return;
2882         ntree->is_updating = TRUE;
2883
2884         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
2885                 /* set the bNodeSocket->link pointers */
2886                 ntree_update_link_pointers(ntree);
2887         }
2888
2889         /* update individual nodes */
2890         for (node = ntree->nodes.first; node; node = node->next) {
2891                 /* node tree update tags override individual node update flags */
2892                 if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
2893                         if (node->typeinfo->updatefunc)
2894                                 node->typeinfo->updatefunc(ntree, node);
2895
2896                         nodeUpdateInternalLinks(ntree, node);
2897                 }
2898         }
2899
2900         /* generic tree update callback */
2901         if (ntree->typeinfo->update)
2902                 ntree->typeinfo->update(ntree);
2903         /* XXX this should be moved into the tree type update callback for tree supporting node groups.
2904          * Currently the node tree interface is still a generic feature of the base NodeTree type.
2905          */
2906         if (ntree->update & NTREE_UPDATE_GROUP)
2907                 ntreeInterfaceTypeUpdate(ntree);
2908
2909         /* XXX hack, should be done by depsgraph!! */
2910         if (bmain)
2911                 ntreeVerifyNodes(bmain, &ntree->id);
2912
2913         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
2914                 /* node updates can change sockets or links, repeat link pointer update afterward */
2915                 ntree_update_link_pointers(ntree);
2916
2917                 /* update the node level from link dependencies */
2918                 ntree_update_node_level(ntree);
2919
2920                 /* check link validity */
2921                 ntree_validate_links(ntree);
2922         }
2923
2924         /* clear update flags */
2925         for (node = ntree->nodes.first; node; node = node->next) {
2926                 node->update = 0;
2927         }
2928         ntree->update = 0;
2929
2930         ntree->is_updating = FALSE;
2931 }
2932
2933 void nodeUpdate(bNodeTree *ntree, bNode *node)
2934 {
2935         /* avoid reentrant updates, can be caused by RNA update callbacks */
2936         if (ntree->is_updating)
2937                 return;
2938         ntree->is_updating = TRUE;
2939
2940         if (node->typeinfo->updatefunc)
2941                 node->typeinfo->updatefunc(ntree, node);
2942
2943         nodeUpdateInternalLinks(ntree, node);
2944
2945         /* clear update flag */
2946         node->update = 0;
2947
2948         ntree->is_updating = FALSE;
2949 }
2950
2951 int nodeUpdateID(bNodeTree *ntree, ID *id)
2952 {
2953         bNode *node;
2954         int change = FALSE;
2955
2956         if (ELEM(NULL, id, ntree))
2957                 return change;
2958
2959         /* avoid reentrant updates, can be caused by RNA update callbacks */
2960         if (ntree->is_updating)
2961                 return change;
2962         ntree->is_updating = TRUE;
2963
2964         for (node = ntree->nodes.first; node; node = node->next) {
2965                 if (node->id == id) {
2966                         change = TRUE;
2967                         node->update |= NODE_UPDATE_ID;
2968                         if (node->typeinfo->updatefunc)
2969                                 node->typeinfo->updatefunc(ntree, node);
2970                         /* clear update flag */
2971                         node->update = 0;
2972                 }
2973         }
2974
2975         for (node = ntree->nodes.first; node; node = node->next) {
2976                 nodeUpdateInternalLinks(ntree, node);
2977         }
2978
2979         ntree->is_updating = FALSE;
2980         return change;
2981 }
2982
2983 void nodeUpdateInternalLinks(bNodeTree *ntree, bNode *node)
2984 {
2985         BLI_freelistN(&node->internal_links);
2986
2987         if (node->typeinfo && node->typeinfo->update_internal_links)
2988                 node->typeinfo->update_internal_links(ntree, node);
2989 }
2990
2991
2992 /* nodes that use ID data get synced with local data */
2993 void nodeSynchronizeID(bNode *node, bool copy_to_id)
2994 {
2995         if (node->id == NULL) return;
2996
2997         if (ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) {
2998                 bNodeSocket *sock;
2999                 Material *ma = (Material *)node->id;
3000                 int a;
3001
3002                 /* hrmf, case in loop isn't super fast, but we don't edit 100s of material at same time either! */
3003                 for (a = 0, sock = node->inputs.first; sock; sock = sock->next, a++) {
3004                         if (!nodeSocketIsHidden(sock)) {
3005                                 if (copy_to_id) {
3006                                         switch (a) {
3007                                                 case MAT_IN_COLOR:
3008                                                         copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
3009                                                 case MAT_IN_SPEC:
3010                                                         copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
3011                                                 case MAT_IN_REFL:
3012                                                         ma->ref = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3013                                                 case MAT_IN_MIR:
3014                                                         copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
3015                                                 case MAT_IN_AMB:
3016                                                         ma->amb = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3017                                                 case MAT_IN_EMIT:
3018                                                         ma->emit = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3019                                                 case MAT_IN_SPECTRA:
3020                                                         ma->spectra = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3021                                                 case MAT_IN_RAY_MIRROR:
3022                                                         ma->ray_mirror = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3023                                                 case MAT_IN_ALPHA:
3024                                                         ma->alpha = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3025                                                 case MAT_IN_TRANSLUCENCY:
3026                                                         ma->translucency = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3027                                         }
3028                                 }
3029                                 else {
3030                                         switch (a) {
3031                                                 case MAT_IN_COLOR:
3032                                                         copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->r); break;
3033                                                 case MAT_IN_SPEC:
3034                                                         copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->specr); break;
3035                                                 case MAT_IN_REFL:
3036                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ref; break;
3037                                                 case MAT_IN_MIR:
3038                                                         copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->mirr); break;
3039                                                 case MAT_IN_AMB:
3040                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->amb; break;
3041                                                 case MAT_IN_EMIT:
3042                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->emit; break;
3043                                                 case MAT_IN_SPECTRA:
3044                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->spectra; break;
3045                                                 case MAT_IN_RAY_MIRROR:
3046                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ray_mirror; break;
3047                                                 case MAT_IN_ALPHA:
3048                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->alpha; break;
3049                                                 case MAT_IN_TRANSLUCENCY:
3050                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->translucency; break;
3051                                         }
3052                                 }
3053                         }
3054                 }
3055         }
3056 }
3057
3058
3059 /* ************* node type access ********** */
3060
3061 const char *nodeLabel(bNode *node)
3062 {
3063         if (node->label[0] != '\0')
3064                 return node->label;
3065         else if (node->typeinfo->labelfunc)
3066                 return node->typeinfo->labelfunc(node);
3067         else
3068                 return IFACE_(node->typeinfo->ui_name);
3069 }
3070
3071 static void node_type_base_defaults(bNodeType *ntype)
3072 {
3073         /* default size values */
3074         node_type_size_preset(ntype, NODE_SIZE_DEFAULT);
3075         ntype->height = 100;
3076         ntype->minheight = 30;
3077         ntype->maxheight = FLT_MAX;
3078 }
3079
3080 /* allow this node for any tree type */
3081 static int node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(ntree))
3082 {
3083         return TRUE;
3084 }
3085
3086 /* use the basic poll function */
3087 static int node_poll_instance_default(bNode *node, bNodeTree *ntree)
3088 {
3089         return node->typeinfo->poll(node->typeinfo, ntree);
3090 }
3091
3092 void node_type_base(bNodeType *ntype, int type, const char *name, short nclass, short flag)
3093 {
3094         /* Use static type info header to map static int type to identifier string and RNA struct type.
3095          * Associate the RNA struct type with the bNodeType.
3096          * Dynamically registered nodes will create an RNA type at runtime
3097          * and call RNA_struct_blender_type_set, so this only needs to be done for old RNA types
3098          * created in makesrna, which can not be associated to a bNodeType immediately,
3099          * since bNodeTypes are registered afterward ...
3100          */
3101         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
3102                 case ID: \
3103                         BLI_strncpy(ntype->idname, #Category #StructName, sizeof(ntype->idname)); \
3104                         ntype->ext.srna = RNA_struct_find(#Category #StructName); \
3105                         BLI_assert(ntype->ext.srna != NULL); \
3106                         RNA_struct_blender_type_set(ntype->ext.srna, ntype); \
3107                         break;
3108
3109         switch (type) {
3110         #include "NOD_static_types.h"
3111         }
3112
3113         /* make sure we have a valid type (everything registered) */
3114         BLI_assert(ntype->idname[0] != '\0');
3115
3116         ntype->type = type;
3117         BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name));
3118         ntype->nclass = nclass;
3119         ntype->flag = flag;
3120
3121         node_type_base_defaults(ntype);
3122
3123         ntype->poll = node_poll_default;
3124         ntype->poll_instance = node_poll_instance_default;
3125 }
3126
3127 void node_type_base_custom(bNodeType *ntype, const char *idname, const char *name, short nclass, short flag)
3128 {
3129         BLI_strncpy(ntype->idname, idname, sizeof(ntype->idname));
3130         ntype->type = NODE_CUSTOM;
3131         BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name));
3132         ntype->nclass = nclass;
3133         ntype->flag = flag;
3134
3135         node_type_base_defaults(ntype);
3136 }
3137
3138 static bool unique_socket_template_identifier_check(void *arg, const char *name)
3139 {
3140         bNodeSocketTemplate *ntemp;
3141         struct {bNodeSocketTemplate *list; bNodeSocketTemplate *ntemp;} *data = arg;
3142
3143         for (ntemp = data->list; ntemp->type >= 0; ++ntemp) {
3144                 if (ntemp != data->ntemp) {
3145                         if (STREQ(ntemp->identifier, name)) {
3146                                 return true;
3147                         }
3148                 }
3149         }
3150
3151         return false;
3152 }
3153
3154 static void unique_socket_template_identifier(bNodeSocketTemplate *list, bNodeSocketTemplate *ntemp, const char defname[], char delim)
3155 {
3156         struct {bNodeSocketTemplate *list; bNodeSocketTemplate *ntemp;} data;
3157         data.list = list;
3158         data.ntemp = ntemp;
3159
3160         BLI_uniquename_cb(unique_socket_template_identifier_check, &data, defname, delim, ntemp->identifier, sizeof(ntemp->identifier));
3161 }
3162
3163 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
3164 {
3165         bNodeSocketTemplate *ntemp;
3166
3167         ntype->inputs = inputs;
3168         ntype->outputs = outputs;
3169
3170         /* automatically generate unique identifiers */
3171         if (inputs) {
3172                 /* clear identifier strings (uninitialized memory) */
3173                 for (ntemp = inputs; ntemp->type >= 0; ++ntemp)
3174                         ntemp->identifier[0] = '\0';
3175
3176                 for (ntemp = inputs; ntemp->type >= 0; ++ntemp) {
3177                         BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier));
3178                         unique_socket_template_identifier(inputs, ntemp, ntemp->identifier, '_');
3179                 }
3180         }
3181         if (outputs) {
3182                 /* clear identifier strings (uninitialized memory) */
3183                 for (ntemp = outputs; ntemp->type >= 0; ++ntemp)
3184                         ntemp->identifier[0] = '\0';
3185
3186                 for (ntemp = outputs; ntemp->type >= 0; ++ntemp) {
3187                         BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier));
3188                         unique_socket_template_identifier(outputs, ntemp, ntemp->identifier, '_');
3189                 }
3190         }
3191 }
3192
3193 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node))
3194 {
3195         ntype->initfunc = initfunc;
3196 }
3197
3198 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
3199 {
3200         ntype->width = width;
3201         ntype->minwidth = minwidth;
3202         if (maxwidth <= minwidth)
3203                 ntype->maxwidth = FLT_MAX;
3204         else
3205                 ntype->maxwidth = maxwidth;
3206 }
3207
3208 void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size)
3209 {
3210         switch (size) {
3211                 case NODE_SIZE_DEFAULT:
3212                         node_type_size(ntype, 140, 100, 320);
3213                         break;
3214                 case NODE_SIZE_SMALL:
3215                         node_type_size(ntype, 100, 80, 320);
3216                         break;
3217                 case NODE_SIZE_MIDDLE:
3218                         node_type_size(ntype, 150, 120, 320);
3219                         break;
3220                 case NODE_SIZE_LARGE:
3221                         node_type_size(ntype, 240, 140, 320);
3222                         break;
3223         }
3224 }
3225
3226 void node_type_storage(bNodeType *ntype,
3227         const char *storagename,
3228         void (*freefunc)(struct bNode *node),
3229         void (*copyfunc)(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node))
3230 {
3231         if (storagename)
3232                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
3233         else
3234                 ntype->storagename[0] = '\0';
3235         ntype->copyfunc = copyfunc;
3236         ntype->freefunc = freefunc;
3237 }
3238
3239 void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *))
3240 {
3241         ntype->labelfunc = labelfunc;
3242 }
3243
3244 void node_type_update(struct bNodeType *ntype,
3245                       void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
3246                       void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id))
3247 {
3248         ntype->updatefunc = updatefunc;
3249         ntype->verifyfunc = verifyfunc;
3250 }
3251
3252 void node_type_exec(struct bNodeType *ntype, NodeInitExecFunction initexecfunc, NodeFreeExecFunction freeexecfunc, NodeExecFunction execfunc)
3253 {
3254         ntype->initexecfunc = initexecfunc;
3255         ntype->freeexecfunc = freeexecfunc;
3256         ntype->execfunc = execfunc;
3257 }
3258
3259 void node_type_gpu(struct bNodeType *ntype, NodeGPUExecFunction gpufunc)
3260 {
3261         ntype->gpufunc = gpufunc;
3262 }
3263
3264 void node_type_internal_links(bNodeType *ntype, void (*update_internal_links)(bNodeTree *, bNode *))
3265 {
3266         ntype->update_internal_links = update_internal_links;
3267 }
3268
3269 void node_type_compatibility(struct bNodeType *ntype, short compatibility)
3270 {
3271         ntype->compatibility = compatibility;
3272 }
3273
3274 /* callbacks for undefined types */
3275
3276 static int node_undefined_poll(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(nodetree))
3277 {
3278         /* this type can not be added deliberately, it's just a placeholder */
3279         return false;
3280 }
3281
3282 /* register fallback types used for undefined tree, nodes, sockets */
3283 static void register_undefined_types(void)
3284 {
3285         /* Note: these types are not registered in the type hashes,
3286          * they are just used as placeholders in case the actual types are not registered.
3287          */
3288
3289         strcpy(NodeTreeTypeUndefined.idname, "NodeTreeUndefined");
3290         strcpy(NodeTreeTypeUndefined.ui_name, "Undefined");
3291         strcpy(NodeTreeTypeUndefined.ui_description, "Undefined Node Tree Type");
3292
3293         node_type_base_custom(&NodeTypeUndefined, "NodeUndefined", "Undefined", 0, 0);
3294         NodeTypeUndefined.poll = node_undefined_poll;
3295
3296         BLI_strncpy(NodeSocketTypeUndefined.idname, "NodeSocketUndefined", sizeof(NodeSocketTypeUndefined.idname));
3297         /* extra type info for standard socket types */
3298         NodeSocketTypeUndefined.type = SOCK_CUSTOM;
3299         NodeSocketTypeUndefined.subtype = PROP_NONE;
3300 }
3301
3302 static void registerCompositNodes(void)
3303 {
3304         register_node_type_cmp_group();
3305
3306         register_node_type_cmp_rlayers();
3307         register_node_type_cmp_image();
3308         register_node_type_cmp_texture();
3309         register_node_type_cmp_value();
3310         register_node_type_cmp_rgb();