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