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