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