d441b1037435de889c0a64146d8e22c5c0bb718f
[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 | NODE_OPTIONS | ntype->flag;
121         node->width = ntype->width;
122         node->miniwidth = 42.0f;
123         node->height = ntype->height;
124         node->color[0] = node->color[1] = node->color[2] = 0.608;   /* default theme color */
125         
126         /* initialize the node name with the node label.
127          * note: do this after the initfunc so nodes get their data set which may be used in naming
128          * (node groups for example) */
129         /* XXX Do not use nodeLabel() here, it returns translated content for UI, which should *only* be used
130          *     in UI, *never* in data... Data have their own translation option!
131          *     This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler
132          *     than adding "do_translate" flags to this func (and labelfunc() as well). */
133         BLI_strncpy(node->name, DATA_(ntype->ui_name), NODE_MAXSTR);
134         nodeUniqueName(ntree, node);
135         
136         node_add_sockets_from_type(ntree, node, ntype);
137         
138         if (ntype->initfunc != NULL)
139                 ntype->initfunc(ntree, node);
140         
141         /* extra init callback */
142         if (ntype->initfunc_api) {
143                 PointerRNA ptr;
144                 RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
145                 
146                 /* XXX Warning: context can be NULL in case nodes are added in do_versions.
147                  * Delayed init is not supported for nodes with context-based initfunc_api atm.
148                  */
149                 BLI_assert(C != NULL);
150                 ntype->initfunc_api(C, &ptr);
151         }
152         
153         if (node->id)
154                 id_us_plus(node->id);
155         
156         node->flag |= NODE_INIT;
157 }
158
159 static void ntree_set_typeinfo(bNodeTree *ntree, bNodeTreeType *typeinfo)
160 {
161         if (typeinfo) {
162                 ntree->typeinfo = typeinfo;
163                 
164                 /* deprecated integer type */
165                 ntree->type = typeinfo->type;
166         }
167         else {
168                 ntree->typeinfo = &NodeTreeTypeUndefined;
169                 
170                 ntree->init &= ~NTREE_TYPE_INIT;
171         }
172 }
173
174 static void node_set_typeinfo(const struct bContext *C, bNodeTree *ntree, bNode *node, bNodeType *typeinfo)
175 {
176         if (typeinfo) {
177                 node->typeinfo = typeinfo;
178                 
179                 /* deprecated integer type */
180                 node->type = typeinfo->type;
181                 
182                 /* initialize the node if necessary */
183                 node_init(C, ntree, node);
184         }
185         else {
186                 node->typeinfo = &NodeTypeUndefined;
187                 
188                 ntree->init &= ~NTREE_TYPE_INIT;
189         }
190 }
191
192 static void node_socket_set_typeinfo(bNodeTree *ntree, bNodeSocket *sock, bNodeSocketType *typeinfo)
193 {
194         if (typeinfo) {
195                 sock->typeinfo = typeinfo;
196                 
197                 /* deprecated integer type */
198                 sock->type = typeinfo->type;
199                 
200                 if (sock->default_value == NULL) {
201                         /* initialize the default_value pointer used by standard socket types */
202                         node_socket_init_default_value(sock);
203                 }
204         }
205         else {
206                 sock->typeinfo = &NodeSocketTypeUndefined;
207                 
208                 ntree->init &= ~NTREE_TYPE_INIT;
209         }
210 }
211
212 /* Set specific typeinfo pointers in all node trees on register/unregister */
213 static void update_typeinfo(Main *bmain, const struct bContext *C, bNodeTreeType *treetype, bNodeType *nodetype, bNodeSocketType *socktype, bool unregister)
214 {
215         if (!bmain)
216                 return;
217         
218         FOREACH_NODETREE(bmain, ntree, id) {
219                 bNode *node;
220                 bNodeSocket *sock;
221                 
222                 ntree->init |= NTREE_TYPE_INIT;
223                 
224                 if (treetype && STREQ(ntree->idname, treetype->idname))
225                         ntree_set_typeinfo(ntree, unregister ? NULL : treetype);
226                 
227                 /* initialize nodes */
228                 for (node = ntree->nodes.first; node; node = node->next) {
229                         if (nodetype && STREQ(node->idname, nodetype->idname))
230                                 node_set_typeinfo(C, ntree, node, unregister ? NULL : nodetype);
231                         
232                         /* initialize node sockets */
233                         for (sock = node->inputs.first; sock; sock = sock->next)
234                                 if (socktype && STREQ(sock->idname, socktype->idname))
235                                         node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
236                         for (sock = node->outputs.first; sock; sock = sock->next)
237                                 if (socktype && STREQ(sock->idname, socktype->idname))
238                                         node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
239                 }
240                 
241                 /* initialize tree sockets */
242                 for (sock = ntree->inputs.first; sock; sock = sock->next)
243                         if (socktype && STREQ(sock->idname, socktype->idname))
244                                 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
245                 for (sock = ntree->outputs.first; sock; sock = sock->next)
246                         if (socktype && STREQ(sock->idname, socktype->idname))
247                                 node_socket_set_typeinfo(ntree, sock, unregister ? NULL : socktype);
248         }
249         FOREACH_NODETREE_END
250 }
251
252 /* Try to initialize all typeinfo in a node tree.
253  * NB: In general undefined typeinfo is a perfectly valid case, the type may just be registered later.
254  * In that case the update_typeinfo function will set typeinfo on registration
255  * and do necessary updates.
256  */
257 void ntreeSetTypes(const struct bContext *C, bNodeTree *ntree)
258 {
259         bNode *node;
260         bNodeSocket *sock;
261         
262         ntree->init |= NTREE_TYPE_INIT;
263         
264         ntree_set_typeinfo(ntree, ntreeTypeFind(ntree->idname));
265         
266         for (node = ntree->nodes.first; node; node = node->next) {
267                 node_set_typeinfo(C, ntree, node, nodeTypeFind(node->idname));
268                 
269                 for (sock = node->inputs.first; sock; sock = sock->next)
270                         node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
271                 for (sock = node->outputs.first; sock; sock = sock->next)
272                         node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
273         }
274         
275         for (sock = ntree->inputs.first; sock; sock = sock->next)
276                 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
277         for (sock = ntree->outputs.first; sock; sock = sock->next)
278                 node_socket_set_typeinfo(ntree, sock, nodeSocketTypeFind(sock->idname));
279 }
280
281
282 static GHash *nodetreetypes_hash = NULL;
283 static GHash *nodetypes_hash = NULL;
284 static GHash *nodesockettypes_hash = NULL;
285
286 bNodeTreeType *ntreeTypeFind(const char *idname)
287 {
288         bNodeTreeType *nt;
289
290         if (idname[0]) {
291                 nt = BLI_ghash_lookup(nodetreetypes_hash, idname);
292                 if (nt)
293                         return nt;
294         }
295
296         return NULL;
297 }
298
299 void ntreeTypeAdd(bNodeTreeType *nt)
300 {
301         BLI_ghash_insert(nodetreetypes_hash, (void *)nt->idname, nt);
302         /* XXX pass Main to register function? */
303         update_typeinfo(G.main, NULL, nt, NULL, NULL, false);
304 }
305
306 /* callback for hash value free function */
307 static void ntree_free_type(void *treetype_v)
308 {
309         bNodeTreeType *treetype = treetype_v;
310         /* XXX pass Main to unregister function? */
311         update_typeinfo(G.main, NULL, treetype, NULL, NULL, true);
312         MEM_freeN(treetype);
313 }
314
315 void ntreeTypeFreeLink(bNodeTreeType *nt)
316 {
317         BLI_ghash_remove(nodetreetypes_hash, nt->idname, NULL, ntree_free_type);
318 }
319
320 bool ntreeIsRegistered(bNodeTree *ntree)
321 {
322         return (ntree->typeinfo != &NodeTreeTypeUndefined);
323 }
324
325 GHashIterator *ntreeTypeGetIterator(void)
326 {
327         return BLI_ghashIterator_new(nodetreetypes_hash);
328 }
329
330 bNodeType *nodeTypeFind(const char *idname)
331 {
332         bNodeType *nt;
333
334         if (idname[0]) {
335                 nt = BLI_ghash_lookup(nodetypes_hash, idname);
336                 if (nt)
337                         return nt;
338         }
339
340         return NULL;
341 }
342
343 static void free_dynamic_typeinfo(bNodeType *ntype)
344 {
345         if (ntype->type == NODE_DYNAMIC) {
346                 if (ntype->inputs) {
347                         MEM_freeN(ntype->inputs);
348                 }
349                 if (ntype->outputs) {
350                         MEM_freeN(ntype->outputs);
351                 }
352         }
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, "socket", '.', 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         /* store link pointers in output sockets, for efficient lookup */
963         for (link = node->internal_links.first; link; link = link->next)
964                 link->tosock->link = link;
965         
966         /* redirect downstream links */
967         for (link = ntree->links.first; link; link = link_next) {
968                 link_next = link->next;
969                 
970                 /* do we have internal link? */
971                 if (link->fromnode == node) {
972                         if (link->fromsock->link) {
973                                 /* get the upstream input link */
974                                 bNodeLink *fromlink = link->fromsock->link->fromsock->link;
975                                 /* skip the node */
976                                 if (fromlink) {
977                                         link->fromnode = fromlink->fromnode;
978                                         link->fromsock = fromlink->fromsock;
979                                         
980                                         /* if the up- or downstream link is invalid,
981                                          * the replacement link will be invalid too.
982                                          */
983                                         if (!(fromlink->flag & NODE_LINK_VALID))
984                                                 link->flag &= ~NODE_LINK_VALID;
985                                         
986                                         ntree->update |= NTREE_UPDATE_LINKS;
987                                 }
988                                 else
989                                         nodeRemLink(ntree, link);
990                         }
991                         else
992                                 nodeRemLink(ntree, link);
993                 }
994         }
995         
996         /* remove remaining upstream links */
997         for (link = ntree->links.first; link; link = link_next) {
998                 link_next = link->next;
999                 
1000                 if (link->tonode == node)
1001                         nodeRemLink(ntree, link);
1002         }
1003 }
1004
1005 void nodeToView(bNode *node, float x, float y, float *rx, float *ry)
1006 {
1007         if (node->parent) {
1008                 nodeToView(node->parent, x + node->locx, y + node->locy, rx, ry);
1009         }
1010         else {
1011                 *rx = x + node->locx;
1012                 *ry = y + node->locy;
1013         }
1014 }
1015
1016 void nodeFromView(bNode *node, float x, float y, float *rx, float *ry)
1017 {
1018         if (node->parent) {
1019                 nodeFromView(node->parent, x, y, rx, ry);
1020                 *rx -= node->locx;
1021                 *ry -= node->locy;
1022         }
1023         else {
1024                 *rx = x - node->locx;
1025                 *ry = y - node->locy;
1026         }
1027 }
1028
1029 int nodeAttachNodeCheck(bNode *node, bNode *parent)
1030 {
1031         bNode *parent_recurse;
1032         for (parent_recurse = node; parent_recurse; parent_recurse = parent_recurse->parent) {
1033                 if (parent_recurse == parent) {
1034                         return TRUE;
1035                 }
1036         }
1037
1038         return FALSE;
1039 }
1040
1041 void nodeAttachNode(bNode *node, bNode *parent)
1042 {
1043         float locx, locy;
1044
1045         BLI_assert(parent->type == NODE_FRAME);
1046         BLI_assert(nodeAttachNodeCheck(parent, node) == FALSE);
1047
1048         nodeToView(node, 0.0f, 0.0f, &locx, &locy);
1049         
1050         node->parent = parent;
1051         /* transform to parent space */
1052         nodeFromView(parent, locx, locy, &node->locx, &node->locy);
1053 }
1054
1055 void nodeDetachNode(struct bNode *node)
1056 {
1057         float locx, locy;
1058         
1059         if (node->parent) {
1060
1061                 BLI_assert(node->parent->type == NODE_FRAME);
1062
1063                 /* transform to view space */
1064                 nodeToView(node, 0.0f, 0.0f, &locx, &locy);
1065                 node->locx = locx;
1066                 node->locy = locy;
1067                 node->parent = NULL;
1068         }
1069 }
1070
1071 bNodeTree *ntreeAddTree(Main *bmain, const char *name, const char *idname)
1072 {
1073         bNodeTree *ntree;
1074         
1075         /* trees are created as local trees for compositor, material or texture nodes,
1076          * node groups and other tree types are created as library data.
1077          */
1078         if (bmain) {
1079                 ntree = BKE_libblock_alloc(&bmain->nodetree, ID_NT, name);
1080         }
1081         else {
1082                 ntree = MEM_callocN(sizeof(bNodeTree), "new node tree");
1083                 *( (short *)ntree->id.name ) = ID_NT;
1084                 BLI_strncpy(ntree->id.name + 2, name, sizeof(ntree->id.name));
1085         }
1086         
1087         /* Types are fully initialized at this point,
1088          * if an undefined node is added later this will be reset.
1089          */
1090         ntree->init |= NTREE_TYPE_INIT;
1091         
1092         BLI_strncpy(ntree->idname, idname, sizeof(ntree->idname));
1093         ntree_set_typeinfo(ntree, ntreeTypeFind(idname));
1094         
1095         return ntree;
1096 }
1097
1098 /* Warning: this function gets called during some rather unexpected times
1099  *      - this gets called when executing compositing updates (for threaded previews)
1100  *      - when the nodetree datablock needs to be copied (i.e. when users get copied)
1101  *      - for scene duplication use ntreeSwapID() after so we don't have stale pointers.
1102  *
1103  * do_make_extern: keep enabled for general use, only reason _not_ to enable is when
1104  * copying for internal use (threads for eg), where you wont want it to modify the
1105  * scene data.
1106  */
1107 static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, Main *bmain, bool do_id_user, bool do_make_extern, bool copy_previews)
1108 {
1109         bNodeTree *newtree;
1110         bNode *node /*, *nnode */ /* UNUSED */, *last;
1111         bNodeSocket *sock, *oldsock;
1112         bNodeLink *link;
1113         
1114         if (ntree == NULL) return NULL;
1115         
1116         if (bmain) {
1117                 /* is ntree part of library? */
1118                 if (BLI_findindex(&bmain->nodetree, ntree) != -1)
1119                         newtree = BKE_libblock_copy(&ntree->id);
1120                 else
1121                         newtree = NULL;
1122         }
1123         else
1124                 newtree = NULL;
1125         
1126         if (newtree == NULL) {
1127                 newtree = MEM_dupallocN(ntree);
1128                 newtree->id.lib = NULL; /* same as owning datablock id.lib */
1129                 BKE_libblock_copy_data(&newtree->id, &ntree->id, true); /* copy animdata and ID props */
1130         }
1131
1132         id_us_plus((ID *)newtree->gpd);
1133
1134         /* in case a running nodetree is copied */
1135         newtree->execdata = NULL;
1136         
1137         newtree->nodes.first = newtree->nodes.last = NULL;
1138         newtree->links.first = newtree->links.last = NULL;
1139         
1140         last = ntree->nodes.last;
1141         for (node = ntree->nodes.first; node; node = node->next) {
1142
1143                 /* ntreeUserDecrefID inline */
1144                 if (do_id_user) {
1145                         id_us_plus(node->id);
1146                 }
1147
1148                 if (do_make_extern) {
1149                         id_lib_extern(node->id);
1150                 }
1151
1152                 node->new_node = NULL;
1153                 /* nnode = */ nodeCopyNode(newtree, node);   /* sets node->new */
1154                 
1155                 /* make sure we don't copy new nodes again! */
1156                 if (node == last)
1157                         break;
1158         }
1159         
1160         /* copy links */
1161         BLI_duplicatelist(&newtree->links, &ntree->links);
1162         for (link = newtree->links.first; link; link = link->next) {
1163                 link->fromnode = (link->fromnode ? link->fromnode->new_node : NULL);
1164                 link->fromsock = (link->fromsock ? link->fromsock->new_sock : NULL);
1165                 link->tonode = (link->tonode ? link->tonode->new_node : NULL);
1166                 link->tosock = (link->tosock ? link->tosock->new_sock : NULL);
1167                 /* update the link socket's pointer */
1168                 if (link->tosock)
1169                         link->tosock->link = link;
1170         }
1171         
1172         /* copy interface sockets */
1173         BLI_duplicatelist(&newtree->inputs, &ntree->inputs);
1174         oldsock = ntree->inputs.first;
1175         for (sock = newtree->inputs.first; sock; sock = sock->next, oldsock = oldsock->next)
1176                 node_socket_copy(sock, oldsock);
1177         
1178         BLI_duplicatelist(&newtree->outputs, &ntree->outputs);
1179         oldsock = ntree->outputs.first;
1180         for (sock = newtree->outputs.first; sock; sock = sock->next, oldsock = oldsock->next)
1181                 node_socket_copy(sock, oldsock);
1182         
1183         /* copy preview hash */
1184         if (ntree->previews && copy_previews) {
1185                 bNodeInstanceHashIterator iter;
1186                 
1187                 newtree->previews = BKE_node_instance_hash_new("node previews");
1188                 
1189                 NODE_INSTANCE_HASH_ITER(iter, ntree->previews) {
1190                         bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
1191                         bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1192                         BKE_node_instance_hash_insert(newtree->previews, key, BKE_node_preview_copy(preview));
1193                 }
1194         }
1195         else
1196                 newtree->previews = NULL;
1197         
1198         /* update node->parent pointers */
1199         for (node = newtree->nodes.first; node; node = node->next) {
1200                 if (node->parent)
1201                         node->parent = node->parent->new_node;
1202         }
1203         
1204         /* node tree will generate its own interface type */
1205         ntree->interface_type = NULL;
1206         
1207         return newtree;
1208 }
1209
1210 bNodeTree *ntreeCopyTree_ex(bNodeTree *ntree, const short do_id_user)
1211 {
1212         return ntreeCopyTree_internal(ntree, G.main, do_id_user, TRUE, TRUE);
1213 }
1214 bNodeTree *ntreeCopyTree(bNodeTree *ntree)
1215 {
1216         return ntreeCopyTree_ex(ntree, TRUE);
1217 }
1218
1219 /* use when duplicating scenes */
1220 void ntreeSwitchID_ex(bNodeTree *ntree, ID *id_from, ID *id_to, const short do_id_user)
1221 {
1222         bNode *node;
1223
1224         if (id_from == id_to) {
1225                 /* should never happen but may as well skip if it does */
1226                 return;
1227         }
1228
1229         /* for scene duplication only */
1230         for (node = ntree->nodes.first; node; node = node->next) {
1231                 if (node->id == id_from) {
1232                         if (do_id_user) {
1233                                 id_us_min(id_from);
1234                                 id_us_plus(id_to);
1235                         }
1236
1237                         node->id = id_to;
1238                 }
1239         }
1240 }
1241 void ntreeSwitchID(bNodeTree *ntree, ID *id_from, ID *id_to)
1242 {
1243         ntreeSwitchID_ex(ntree, id_from, id_to, TRUE);
1244 }
1245
1246 void ntreeUserIncrefID(bNodeTree *ntree)
1247 {
1248         bNode *node;
1249         for (node = ntree->nodes.first; node; node = node->next) {
1250                 id_us_plus(node->id);
1251         }
1252 }
1253 void ntreeUserDecrefID(bNodeTree *ntree)
1254 {
1255         bNode *node;
1256         for (node = ntree->nodes.first; node; node = node->next) {
1257                 id_us_min(node->id);
1258         }
1259 }
1260
1261 /* *************** Node Preview *********** */
1262
1263 /* XXX this should be removed eventually ...
1264  * Currently BKE functions are modelled closely on previous code,
1265  * using BKE_node_preview_init_tree to set up previews for a whole node tree in advance.
1266  * This should be left more to the individual node tree implementations.
1267  */
1268 int BKE_node_preview_used(bNode *node)
1269 {
1270         /* XXX check for closed nodes? */
1271         return (node->typeinfo->flag & NODE_PREVIEW) != 0;
1272 }
1273
1274 bNodePreview *BKE_node_preview_verify(bNodeInstanceHash *previews, bNodeInstanceKey key, int xsize, int ysize, int create)
1275 {
1276         bNodePreview *preview;
1277         
1278         preview = BKE_node_instance_hash_lookup(previews, key);
1279         if (!preview) {
1280                 if (create) {
1281                         preview = MEM_callocN(sizeof(bNodePreview), "node preview");
1282                         BKE_node_instance_hash_insert(previews, key, preview);
1283                 }
1284                 else
1285                         return NULL;
1286         }
1287         
1288         /* node previews can get added with variable size this way */
1289         if (xsize == 0 || ysize == 0)
1290                 return preview;
1291         
1292         /* sanity checks & initialize */
1293         if (preview->rect) {
1294                 if (preview->xsize != xsize || preview->ysize != ysize) {
1295                         MEM_freeN(preview->rect);
1296                         preview->rect = NULL;
1297                 }
1298         }
1299         
1300         if (preview->rect == NULL) {
1301                 preview->rect = MEM_callocN(4 * xsize + xsize * ysize * sizeof(char) * 4, "node preview rect");
1302                 preview->xsize = xsize;
1303                 preview->ysize = ysize;
1304         }
1305         /* no clear, makes nicer previews */
1306         
1307         return preview;
1308 }
1309
1310 bNodePreview *BKE_node_preview_copy(bNodePreview *preview)
1311 {
1312         bNodePreview *new_preview = MEM_dupallocN(preview);
1313         if (preview->rect)
1314                 new_preview->rect = MEM_dupallocN(preview->rect);
1315         return new_preview;
1316 }
1317
1318 void BKE_node_preview_free(bNodePreview *preview)
1319 {
1320         if (preview->rect)
1321                 MEM_freeN(preview->rect);
1322         MEM_freeN(preview);
1323 }
1324
1325 static void node_preview_init_tree_recursive(bNodeInstanceHash *previews, bNodeTree *ntree, bNodeInstanceKey parent_key, int xsize, int ysize, int create)
1326 {
1327         bNode *node;
1328         for (node = ntree->nodes.first; node; node = node->next) {
1329                 bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
1330                 
1331                 if (BKE_node_preview_used(node)) {
1332                         node->preview_xsize = xsize;
1333                         node->preview_ysize = ysize;
1334                         
1335                         BKE_node_preview_verify(previews, key, xsize, ysize, create);
1336                 }
1337                 
1338                 if (node->type == NODE_GROUP && node->id)
1339                         node_preview_init_tree_recursive(previews, (bNodeTree *)node->id, key, xsize, ysize, create);
1340         }
1341 }
1342
1343 void BKE_node_preview_init_tree(bNodeTree *ntree, int xsize, int ysize, int create_previews)
1344 {
1345         if (!ntree)
1346                 return;
1347         
1348         if (!ntree->previews)
1349                 ntree->previews = BKE_node_instance_hash_new("node previews");
1350         
1351         node_preview_init_tree_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE, xsize, ysize, create_previews);
1352 }
1353
1354 static void node_preview_tag_used_recursive(bNodeInstanceHash *previews, bNodeTree *ntree, bNodeInstanceKey parent_key)
1355 {
1356         bNode *node;
1357         for (node = ntree->nodes.first; node; node = node->next) {
1358                 bNodeInstanceKey key = BKE_node_instance_key(parent_key, ntree, node);
1359                 
1360                 if (BKE_node_preview_used(node))
1361                         BKE_node_instance_hash_tag_key(previews, key);
1362                 
1363                 if (node->type == NODE_GROUP && node->id)
1364                         node_preview_tag_used_recursive(previews, (bNodeTree *)node->id, key);
1365         }
1366 }
1367
1368 void BKE_node_preview_remove_unused(bNodeTree *ntree)
1369 {
1370         if (!ntree || !ntree->previews)
1371                 return;
1372         
1373         /* use the instance hash functions for tagging and removing unused previews */
1374         BKE_node_instance_hash_clear_tags(ntree->previews);
1375         node_preview_tag_used_recursive(ntree->previews, ntree, NODE_INSTANCE_KEY_BASE);
1376         
1377         BKE_node_instance_hash_remove_untagged(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1378 }
1379
1380 void BKE_node_preview_free_tree(bNodeTree *ntree)
1381 {
1382         if (!ntree)
1383                 return;
1384         
1385         if (ntree->previews) {
1386                 BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1387                 ntree->previews = NULL;
1388         }
1389 }
1390
1391 void BKE_node_preview_clear(bNodePreview *preview)
1392 {
1393         if (preview && preview->rect)
1394                 memset(preview->rect, 0, MEM_allocN_len(preview->rect));
1395 }
1396
1397 void BKE_node_preview_clear_tree(bNodeTree *ntree)
1398 {
1399         bNodeInstanceHashIterator iter;
1400         
1401         if (!ntree || !ntree->previews)
1402                 return;
1403         
1404         NODE_INSTANCE_HASH_ITER(iter, ntree->previews) {
1405                 bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1406                 BKE_node_preview_clear(preview);
1407         }
1408 }
1409
1410 static void node_preview_sync(bNodePreview *to, bNodePreview *from)
1411 {
1412         /* sizes should have been initialized by BKE_node_preview_init_tree */
1413         BLI_assert(to->xsize == from->xsize && to->ysize == from->ysize);
1414         
1415         /* copy over contents of previews */
1416         if (to->rect && from->rect) {
1417                 int xsize = to->xsize;
1418                 int ysize = to->ysize;
1419                 memcpy(to->rect, from->rect, 4 * xsize + xsize * ysize * sizeof(char) * 4);
1420         }
1421 }
1422
1423 void BKE_node_preview_sync_tree(bNodeTree *to_ntree, bNodeTree *from_ntree)
1424 {
1425         bNodeInstanceHash *from_previews = from_ntree->previews;
1426         bNodeInstanceHash *to_previews = to_ntree->previews;
1427         bNodeInstanceHashIterator iter;
1428         
1429         if (!from_previews || !to_previews)
1430                 return;
1431         
1432         NODE_INSTANCE_HASH_ITER(iter, from_previews) {
1433                 bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
1434                 bNodePreview *from = BKE_node_instance_hash_iterator_get_value(&iter);
1435                 bNodePreview *to = BKE_node_instance_hash_lookup(to_previews, key);
1436                 
1437                 if (from && to)
1438                         node_preview_sync(to, from);
1439         }
1440 }
1441
1442 void BKE_node_preview_merge_tree(bNodeTree *to_ntree, bNodeTree *from_ntree, bool remove_old)
1443 {
1444         if (remove_old || !to_ntree->previews) {
1445                 /* free old previews */
1446                 if (to_ntree->previews)
1447                         BKE_node_instance_hash_free(to_ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1448                 
1449                 /* transfer previews */
1450                 to_ntree->previews = from_ntree->previews;
1451                 from_ntree->previews = NULL;
1452                 
1453                 /* clean up, in case any to_ntree nodes have been removed */
1454                 BKE_node_preview_remove_unused(to_ntree);
1455         }
1456         else {
1457                 bNodeInstanceHashIterator iter;
1458                 
1459                 if (from_ntree->previews) {
1460                         NODE_INSTANCE_HASH_ITER(iter, from_ntree->previews) {
1461                                 bNodeInstanceKey key = BKE_node_instance_hash_iterator_get_key(&iter);
1462                                 bNodePreview *preview = BKE_node_instance_hash_iterator_get_value(&iter);
1463                                 
1464                                 /* replace existing previews */
1465                                 BKE_node_instance_hash_remove(to_ntree->previews, key, (bNodeInstanceValueFP)BKE_node_preview_free);
1466                                 BKE_node_instance_hash_insert(to_ntree->previews, key, preview);
1467                         }
1468                         
1469                         /* Note: NULL free function here, because pointers have already been moved over to to_ntree->previews! */
1470                         BKE_node_instance_hash_free(from_ntree->previews, NULL);
1471                         from_ntree->previews = NULL;
1472                 }
1473         }
1474 }
1475
1476 /* hack warning! this function is only used for shader previews, and 
1477  * since it gets called multiple times per pixel for Ztransp we only
1478  * add the color once. Preview gets cleared before it starts render though */
1479 void BKE_node_preview_set_pixel(bNodePreview *preview, const float col[4], int x, int y, int do_manage)
1480 {
1481         if (preview) {
1482                 if (x >= 0 && y >= 0) {
1483                         if (x < preview->xsize && y < preview->ysize) {
1484                                 unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
1485                                 
1486                                 if (do_manage) {
1487                                         linearrgb_to_srgb_uchar4(tar, col);
1488                                 }
1489                                 else {
1490                                         rgba_float_to_uchar(tar, col);
1491                                 }
1492                         }
1493                         //else printf("prv out bound x y %d %d\n", x, y);
1494                 }
1495                 //else printf("prv out bound x y %d %d\n", x, y);
1496         }
1497 }
1498
1499 #if 0
1500 static void nodeClearPreview(bNode *node)
1501 {
1502         if (node->preview && node->preview->rect)
1503                 memset(node->preview->rect, 0, MEM_allocN_len(node->preview->rect));
1504 }
1505
1506 /* use it to enforce clear */
1507 void ntreeClearPreview(bNodeTree *ntree)
1508 {
1509         bNode *node;
1510         
1511         if (ntree == NULL)
1512                 return;
1513         
1514         for (node = ntree->nodes.first; node; node = node->next) {
1515                 if (node->typeinfo->flag & NODE_PREVIEW)
1516                         nodeClearPreview(node);
1517                 if (node->type == NODE_GROUP)
1518                         ntreeClearPreview((bNodeTree *)node->id);
1519         }
1520 }
1521
1522 /* hack warning! this function is only used for shader previews, and 
1523  * since it gets called multiple times per pixel for Ztransp we only
1524  * add the color once. Preview gets cleared before it starts render though */
1525 void nodeAddToPreview(bNode *node, const float col[4], int x, int y, int do_manage)
1526 {
1527         bNodePreview *preview = node->preview;
1528         if (preview) {
1529                 if (x >= 0 && y >= 0) {
1530                         if (x < preview->xsize && y < preview->ysize) {
1531                                 unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
1532                                 
1533                                 if (do_manage) {
1534                                         linearrgb_to_srgb_uchar4(tar, col);
1535                                 }
1536                                 else {
1537                                         rgba_float_to_uchar(tar, col);
1538                                 }
1539                         }
1540                         //else printf("prv out bound x y %d %d\n", x, y);
1541                 }
1542                 //else printf("prv out bound x y %d %d\n", x, y);
1543         }
1544 }
1545 #endif
1546
1547 /* ************** Free stuff ********** */
1548
1549 /* goes over entire tree */
1550 void nodeUnlinkNode(bNodeTree *ntree, bNode *node)
1551 {
1552         bNodeLink *link, *next;
1553         bNodeSocket *sock;
1554         ListBase *lb;
1555         
1556         for (link = ntree->links.first; link; link = next) {
1557                 next = link->next;
1558                 
1559                 if (link->fromnode == node) {
1560                         lb = &node->outputs;
1561                         if (link->tonode)
1562                                 link->tonode->update |= NODE_UPDATE;
1563                 }
1564                 else if (link->tonode == node)
1565                         lb = &node->inputs;
1566                 else
1567                         lb = NULL;
1568
1569                 if (lb) {
1570                         for (sock = lb->first; sock; sock = sock->next) {
1571                                 if (link->fromsock == sock || link->tosock == sock)
1572                                         break;
1573                         }
1574                         if (sock) {
1575                                 nodeRemLink(ntree, link);
1576                         }
1577                 }
1578         }
1579 }
1580
1581 static void node_unlink_attached(bNodeTree *ntree, bNode *parent)
1582 {
1583         bNode *node;
1584         for (node = ntree->nodes.first; node; node = node->next) {
1585                 if (node->parent == parent)
1586                         nodeDetachNode(node);
1587         }
1588 }
1589
1590 /** \note caller needs to manage node->id user */
1591 void nodeFreeNode(bNodeTree *ntree, bNode *node)
1592 {
1593         bNodeSocket *sock, *nextsock;
1594         char propname_esc[MAX_IDPROP_NAME * 2];
1595         char prefix[MAX_IDPROP_NAME * 2];
1596         
1597         /* extra free callback */
1598         if (node->typeinfo && node->typeinfo->freefunc_api) {
1599                 PointerRNA ptr;
1600                 RNA_pointer_create((ID *)ntree, &RNA_Node, node, &ptr);
1601                 
1602                 node->typeinfo->freefunc_api(&ptr);
1603         }
1604         
1605         /* since it is called while free database, node->id is undefined */
1606         
1607         /* can be called for nodes outside a node tree (e.g. clipboard) */
1608         if (ntree) {
1609                 /* remove all references to this node */
1610                 nodeUnlinkNode(ntree, node);
1611                 node_unlink_attached(ntree, node);
1612                 
1613                 BLI_remlink(&ntree->nodes, node);
1614                 
1615                 BLI_strescape(propname_esc, node->name, sizeof(propname_esc));
1616                 BLI_snprintf(prefix, sizeof(prefix), "nodes[\"%s\"]", propname_esc);
1617
1618                 BKE_animdata_fix_paths_remove((ID *)ntree, prefix);
1619
1620                 if (ntree->typeinfo && ntree->typeinfo->free_node_cache)
1621                         ntree->typeinfo->free_node_cache(ntree, node);
1622                 
1623                 /* texture node has bad habit of keeping exec data around */
1624                 if (ntree->type == NTREE_TEXTURE && ntree->execdata) {
1625                         ntreeTexEndExecTree(ntree->execdata);
1626                         ntree->execdata = NULL;
1627                 }
1628                 
1629                 if (node->typeinfo && node->typeinfo->freefunc)
1630                         node->typeinfo->freefunc(node);
1631         }
1632         
1633         for (sock = node->inputs.first; sock; sock = nextsock) {
1634                 nextsock = sock->next;
1635                 node_socket_free(ntree, sock, node);
1636                 MEM_freeN(sock);
1637         }
1638         for (sock = node->outputs.first; sock; sock = nextsock) {
1639                 nextsock = sock->next;
1640                 node_socket_free(ntree, sock, node);
1641                 MEM_freeN(sock);
1642         }
1643
1644         BLI_freelistN(&node->internal_links);
1645
1646         if (node->prop) {
1647                 IDP_FreeProperty(node->prop);
1648                 MEM_freeN(node->prop);
1649         }
1650
1651         MEM_freeN(node);
1652         
1653         if (ntree)
1654                 ntree->update |= NTREE_UPDATE_NODES;
1655 }
1656
1657 static void node_socket_interface_free(bNodeTree *UNUSED(ntree), bNodeSocket *sock)
1658 {
1659         if (sock->prop) {
1660                 IDP_FreeProperty(sock->prop);
1661                 MEM_freeN(sock->prop);
1662         }
1663         
1664         if (sock->default_value)
1665                 MEM_freeN(sock->default_value);
1666 }
1667
1668 static void free_localized_node_groups(bNodeTree *ntree)
1669 {
1670         bNode *node;
1671         
1672         for (node = ntree->nodes.first; node; node = node->next) {
1673                 if (node->type == NODE_GROUP && node->id) {
1674                         bNodeTree *ngroup = (bNodeTree *)node->id;
1675                         if (ngroup->flag & NTREE_IS_LOCALIZED) {
1676                                 /* ntree is a localized copy: free it */
1677                                 ntreeFreeTree_ex(ngroup, false);
1678                                 MEM_freeN(ngroup);
1679                         }
1680                 }
1681         }
1682 }
1683
1684 /* do not free ntree itself here, BKE_libblock_free calls this function too */
1685 void ntreeFreeTree_ex(bNodeTree *ntree, const short do_id_user)
1686 {
1687         bNodeTree *tntree;
1688         bNode *node, *next;
1689         bNodeSocket *sock, *nextsock;
1690         
1691         if (ntree == NULL) return;
1692         
1693         /* XXX hack! node trees should not store execution graphs at all.
1694          * This should be removed when old tree types no longer require it.
1695          * Currently the execution data for texture nodes remains in the tree
1696          * after execution, until the node tree is updated or freed.
1697          */
1698         if (ntree->execdata) {
1699                 switch (ntree->type) {
1700                         case NTREE_SHADER:
1701                                 ntreeShaderEndExecTree(ntree->execdata);
1702                                 break;
1703                         case NTREE_TEXTURE:
1704                                 ntreeTexEndExecTree(ntree->execdata);
1705                                 ntree->execdata = NULL;
1706                                 break;
1707                 }
1708         }
1709         
1710         /* XXX not nice, but needed to free localized node groups properly */
1711         free_localized_node_groups(ntree);
1712         
1713         /* unregister associated RNA types */
1714         ntreeInterfaceTypeFree(ntree);
1715         
1716         BKE_free_animdata((ID *)ntree);
1717         
1718         id_us_min((ID *)ntree->gpd);
1719
1720         BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
1721         
1722         for (node = ntree->nodes.first; node; node = next) {
1723                 next = node->next;
1724
1725                 /* ntreeUserIncrefID inline */
1726
1727                 /* XXX, this is correct, however when freeing the entire database
1728                  * this ends up accessing freed data which isn't properly unlinking
1729                  * its self from scene nodes, SO - for now prefer invalid usercounts
1730                  * on free rather then bad memory access - Campbell */
1731 #if 0
1732                 if (do_id_user) {
1733                         id_us_min(node->id);
1734                 }
1735 #else
1736                 (void)do_id_user;
1737 #endif
1738
1739                 nodeFreeNode(ntree, node);
1740         }
1741
1742         /* free interface sockets */
1743         for (sock = ntree->inputs.first; sock; sock = nextsock) {
1744                 nextsock = sock->next;
1745                 node_socket_interface_free(ntree, sock);
1746                 MEM_freeN(sock);
1747         }
1748         for (sock = ntree->outputs.first; sock; sock = nextsock) {
1749                 nextsock = sock->next;
1750                 node_socket_interface_free(ntree, sock);
1751                 MEM_freeN(sock);
1752         }
1753         
1754         /* free preview hash */
1755         if (ntree->previews) {
1756                 BKE_node_instance_hash_free(ntree->previews, (bNodeInstanceValueFP)BKE_node_preview_free);
1757         }
1758         
1759         /* if ntree is not part of library, free the libblock data explicitly */
1760         for (tntree = G.main->nodetree.first; tntree; tntree = tntree->id.next)
1761                 if (tntree == ntree)
1762                         break;
1763         if (tntree == NULL) {
1764                 BKE_libblock_free_data(&ntree->id);
1765         }
1766 }
1767 /* same as ntreeFreeTree_ex but always manage users */
1768 void ntreeFreeTree(bNodeTree *ntree)
1769 {
1770         ntreeFreeTree_ex(ntree, TRUE);
1771 }
1772
1773 void ntreeFreeCache(bNodeTree *ntree)
1774 {
1775         if (ntree == NULL) return;
1776         
1777         if (ntree->typeinfo->free_cache)
1778                 ntree->typeinfo->free_cache(ntree);
1779 }
1780
1781 void ntreeSetOutput(bNodeTree *ntree)
1782 {
1783         bNode *node;
1784
1785         /* find the active outputs, might become tree type dependent handler */
1786         for (node = ntree->nodes.first; node; node = node->next) {
1787                 if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1788                         bNode *tnode;
1789                         int output = 0;
1790                         
1791                         /* we need a check for which output node should be tagged like this, below an exception */
1792                         if (node->type == CMP_NODE_OUTPUT_FILE)
1793                                 continue;
1794
1795                         /* there is more types having output class, each one is checked */
1796                         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1797                                 if (tnode->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1798                                         
1799                                         if (ntree->type == NTREE_COMPOSIT) {
1800                                                         
1801                                                 /* same type, exception for viewer */
1802                                                 if (tnode->type == node->type ||
1803                                                     (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
1804                                                      ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)))
1805                                                 {
1806                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1807                                                                 output++;
1808                                                                 if (output > 1)
1809                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1810                                                         }
1811                                                 }
1812                                         }
1813                                         else {
1814                                                 /* same type */
1815                                                 if (tnode->type == node->type) {
1816                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1817                                                                 output++;
1818                                                                 if (output > 1)
1819                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1820                                                         }
1821                                                 }
1822                                         }
1823                                 }
1824                         }
1825                         if (output == 0)
1826                                 node->flag |= NODE_DO_OUTPUT;
1827                 }
1828                 
1829                 /* group node outputs use this flag too */
1830                 if (node->type == NODE_GROUP_OUTPUT) {
1831                         bNode *tnode;
1832                         int output = 0;
1833                         
1834                         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1835                                 if (tnode->type == NODE_GROUP_OUTPUT) {
1836                                         if (tnode->flag & NODE_DO_OUTPUT) {
1837                                                 output++;
1838                                                 if (output > 1)
1839                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1840                                         }
1841                                 }
1842                         }
1843                         if (output == 0)
1844                                 node->flag |= NODE_DO_OUTPUT;
1845                 }
1846         }
1847         
1848         /* here we could recursively set which nodes have to be done,
1849          * might be different for editor or for "real" use... */
1850 }
1851
1852 bNodeTree *ntreeFromID(ID *id)
1853 {
1854         switch (GS(id->name)) {
1855                 case ID_MA:  return ((Material *)id)->nodetree;
1856                 case ID_LA:  return ((Lamp *)id)->nodetree;
1857                 case ID_WO:  return ((World *)id)->nodetree;
1858                 case ID_TE:  return ((Tex *)id)->nodetree;
1859                 case ID_SCE: return ((Scene *)id)->nodetree;
1860                 default: return NULL;
1861         }
1862 }
1863
1864 void ntreeMakeLocal(bNodeTree *ntree)
1865 {
1866         Main *bmain = G.main;
1867         int lib = FALSE, local = FALSE;
1868         
1869         /* - only lib users: do nothing
1870          * - only local users: set flag
1871          * - mixed: make copy
1872          */
1873         
1874         if (ntree->id.lib == NULL) return;
1875         if (ntree->id.us == 1) {
1876                 id_clear_lib_data(bmain, (ID *)ntree);
1877                 return;
1878         }
1879         
1880         /* now check users of groups... again typedepending, callback... */
1881         FOREACH_NODETREE(G.main, tntree, owner_id) {
1882                 bNode *node;
1883                 /* find if group is in tree */
1884                 for (node = tntree->nodes.first; node; node = node->next) {
1885                         if (node->id == (ID *)ntree) {
1886                                 if (owner_id->lib)
1887                                         lib = TRUE;
1888                                 else
1889                                         local = TRUE;
1890                         }
1891                 }
1892         } FOREACH_NODETREE_END
1893         
1894         /* if all users are local, we simply make tree local */
1895         if (local && !lib) {
1896                 id_clear_lib_data(bmain, (ID *)ntree);
1897         }
1898         else if (local && lib) {
1899                 /* this is the mixed case, we copy the tree and assign it to local users */
1900                 bNodeTree *newtree = ntreeCopyTree(ntree);
1901                 
1902                 newtree->id.us = 0;
1903                 
1904                 FOREACH_NODETREE(G.main, tntree, owner_id) {
1905                         bNode *node;
1906                         /* find if group is in tree */
1907                         for (node = tntree->nodes.first; node; node = node->next) {
1908                                 if (node->id == (ID *)ntree) {
1909                                         if (owner_id->lib == NULL) {
1910                                                 node->id = (ID *)newtree;
1911                                                 newtree->id.us++;
1912                                                 ntree->id.us--;
1913                                         }
1914                                 }
1915                         }
1916                 } FOREACH_NODETREE_END
1917         }
1918 }
1919
1920 int ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
1921 {
1922         bNode *node = ntree->nodes.first;
1923         for (; node; node = node->next)
1924                 if (node == testnode)
1925                         return 1;
1926         return 0;
1927 }
1928
1929 int ntreeOutputExists(bNode *node, bNodeSocket *testsock)
1930 {
1931         bNodeSocket *sock = node->outputs.first;
1932         for (; sock; sock = sock->next)
1933                 if (sock == testsock)
1934                         return 1;
1935         return 0;
1936 }
1937
1938 /* returns localized tree for execution in threads */
1939 bNodeTree *ntreeLocalize(bNodeTree *ntree)
1940 {
1941         if (ntree) {
1942                 bNodeTree *ltree;
1943                 bNode *node;
1944                 
1945                 bAction *action_backup = NULL, *tmpact_backup = NULL;
1946                 
1947                 /* Workaround for copying an action on each render!
1948                  * set action to NULL so animdata actions don't get copied */
1949                 AnimData *adt = BKE_animdata_from_id(&ntree->id);
1950         
1951                 if (adt) {
1952                         action_backup = adt->action;
1953                         tmpact_backup = adt->tmpact;
1954         
1955                         adt->action = NULL;
1956                         adt->tmpact = NULL;
1957                 }
1958         
1959                 /* Make full copy.
1960                  * Note: previews are not copied here.
1961                  */
1962                 ltree = ntreeCopyTree_internal(ntree, NULL, FALSE, FALSE, FALSE);
1963                 ltree->flag |= NTREE_IS_LOCALIZED;
1964                 
1965                 for (node = ltree->nodes.first; node; node = node->next) {
1966                         if (node->type == NODE_GROUP && node->id) {
1967                                 node->id = (ID *)ntreeLocalize((bNodeTree *)node->id);
1968                         }
1969                 }
1970                 
1971                 if (adt) {
1972                         AnimData *ladt = BKE_animdata_from_id(&ltree->id);
1973         
1974                         adt->action = ladt->action = action_backup;
1975                         adt->tmpact = ladt->tmpact = tmpact_backup;
1976         
1977                         if (action_backup) action_backup->id.us++;
1978                         if (tmpact_backup) tmpact_backup->id.us++;
1979                         
1980                 }
1981                 /* end animdata uglyness */
1982         
1983                 /* ensures only a single output node is enabled */
1984                 ntreeSetOutput(ntree);
1985         
1986                 for (node = ntree->nodes.first; node; node = node->next) {
1987                         /* store new_node pointer to original */
1988                         node->new_node->new_node = node;
1989                 }
1990         
1991                 if (ntree->typeinfo->localize)
1992                         ntree->typeinfo->localize(ltree, ntree);
1993         
1994                 return ltree;
1995         }
1996         else
1997                 return NULL;
1998 }
1999
2000 /* sync local composite with real tree */
2001 /* local tree is supposed to be running, be careful moving previews! */
2002 /* is called by jobs manager, outside threads, so it doesnt happen during draw */
2003 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
2004 {
2005         if (localtree && ntree) {
2006                 if (ntree->typeinfo->local_sync)
2007                         ntree->typeinfo->local_sync(localtree, ntree);
2008         }
2009 }
2010
2011 /* merge local tree results back, and free local tree */
2012 /* we have to assume the editor already changed completely */
2013 void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
2014 {
2015         if (ntree && localtree) {
2016                 if (ntree->typeinfo->local_merge)
2017                         ntree->typeinfo->local_merge(localtree, ntree);
2018                 
2019                 ntreeFreeTree_ex(localtree, FALSE);
2020                 MEM_freeN(localtree);
2021         }
2022 }
2023
2024
2025 /* ************ NODE TREE INTERFACE *************** */
2026
2027 static bNodeSocket *make_socket_interface(bNodeTree *ntree, int in_out,
2028                                          const char *idname, const char *name)
2029 {
2030         bNodeSocketType *stype = nodeSocketTypeFind(idname);
2031         bNodeSocket *sock;
2032         int own_index = ntree->cur_index++;
2033
2034         if (stype == NULL) {
2035                 return NULL;
2036         }
2037
2038         sock = MEM_callocN(sizeof(bNodeSocket), "socket template");
2039         BLI_strncpy(sock->idname, stype->idname, sizeof(sock->idname));
2040         node_socket_set_typeinfo(ntree, sock, stype);
2041         sock->in_out = in_out;
2042         sock->type = SOCK_CUSTOM;       /* int type undefined by default */
2043         
2044         /* assign new unique index */
2045         own_index = ntree->cur_index++;
2046         /* use the own_index as socket identifier */
2047         if (in_out == SOCK_IN)
2048                 BLI_snprintf(sock->identifier, MAX_NAME, "Input_%d", own_index);
2049         else
2050                 BLI_snprintf(sock->identifier, MAX_NAME, "Output_%d", own_index);
2051 #ifdef USE_NODE_COMPAT_CUSTOMNODES
2052         /* XXX forward compatibility:
2053          * own_index is deprecated, but needs to be set here.
2054          * Node sockets generally use the identifier string instead now,
2055          * but reconstructing own_index in writefile.c would require parsing the identifier string.
2056          */
2057
2058 #if (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406)) || defined(__clang__)
2059 #  pragma GCC diagnostic push
2060 #  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2061 #endif
2062
2063         sock->own_index = own_index;
2064
2065 #if (defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 406)) || defined(__clang__)
2066 #  pragma GCC diagnostic pop
2067 #endif
2068
2069 #endif  /* USE_NODE_COMPAT_CUSTOMNODES */
2070         
2071         sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
2072         
2073         BLI_strncpy(sock->name, name, NODE_MAXSTR);
2074         sock->storage = NULL;
2075         sock->flag |= SOCK_COLLAPSED;
2076         
2077         return sock;
2078 }
2079
2080 bNodeSocket *ntreeFindSocketInterface(bNodeTree *ntree, int in_out, const char *identifier)
2081 {
2082         bNodeSocket *iosock = (in_out == SOCK_IN ? ntree->inputs.first : ntree->outputs.first);
2083         for (; iosock; iosock = iosock->next)
2084                 if (STREQ(iosock->identifier, identifier))
2085                         return iosock;
2086         return NULL;
2087 }
2088
2089 bNodeSocket *ntreeAddSocketInterface(bNodeTree *ntree, int in_out, const char *idname, const char *name)
2090 {
2091         bNodeSocket *iosock;
2092         
2093         iosock = make_socket_interface(ntree, in_out, idname, name);
2094         if (in_out == SOCK_IN) {
2095                 BLI_addtail(&ntree->inputs, iosock);
2096                 ntree->update |= NTREE_UPDATE_GROUP_IN;
2097         }
2098         else if (in_out == SOCK_OUT) {
2099                 BLI_addtail(&ntree->outputs, iosock);
2100                 ntree->update |= NTREE_UPDATE_GROUP_OUT;
2101         }
2102         
2103         return iosock;
2104 }
2105
2106 bNodeSocket *ntreeInsertSocketInterface(bNodeTree *ntree, int in_out, const char *idname,
2107                                bNodeSocket *next_sock, const char *name)
2108 {
2109         bNodeSocket *iosock;
2110         
2111         iosock = make_socket_interface(ntree, in_out, idname, name);
2112         if (in_out == SOCK_IN) {
2113                 BLI_insertlinkbefore(&ntree->inputs, next_sock, iosock);
2114                 ntree->update |= NTREE_UPDATE_GROUP_IN;
2115         }
2116         else if (in_out == SOCK_OUT) {
2117                 BLI_insertlinkbefore(&ntree->outputs, next_sock, iosock);
2118                 ntree->update |= NTREE_UPDATE_GROUP_OUT;
2119         }
2120         
2121         return iosock;
2122 }
2123
2124 struct bNodeSocket *ntreeAddSocketInterfaceFromSocket(bNodeTree *ntree, bNode *from_node, bNodeSocket *from_sock)
2125 {
2126         bNodeSocket *iosock = ntreeAddSocketInterface(ntree, from_sock->in_out, from_sock->idname, from_sock->name);
2127         if (iosock) {
2128                 if (iosock->typeinfo->interface_from_socket)
2129                         iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
2130         }
2131         return iosock;
2132 }
2133
2134 struct bNodeSocket *ntreeInsertSocketInterfaceFromSocket(bNodeTree *ntree, bNodeSocket *next_sock, bNode *from_node, bNodeSocket *from_sock)
2135 {
2136         bNodeSocket *iosock = ntreeInsertSocketInterface(ntree, from_sock->in_out, from_sock->idname, next_sock, from_sock->name);
2137         if (iosock) {
2138                 if (iosock->typeinfo->interface_from_socket)
2139                         iosock->typeinfo->interface_from_socket(ntree, iosock, from_node, from_sock);
2140         }
2141         return iosock;
2142 }
2143
2144 void ntreeRemoveSocketInterface(bNodeTree *ntree, bNodeSocket *sock)
2145 {
2146         /* this is fast, this way we don't need an in_out argument */
2147         BLI_remlink(&ntree->inputs, sock);
2148         BLI_remlink(&ntree->outputs, sock);
2149         
2150         node_socket_interface_free(ntree, sock);
2151         MEM_freeN(sock);
2152         
2153         ntree->update |= NTREE_UPDATE_GROUP;
2154 }
2155
2156 /* generates a valid RNA identifier from the node tree name */
2157 static void ntree_interface_identifier_base(bNodeTree *ntree, char *base)
2158 {
2159         /* generate a valid RNA identifier */
2160         sprintf(base, "NodeTreeInterface_%s", ntree->id.name + 2);
2161         RNA_identifier_sanitize(base, FALSE);
2162 }
2163
2164 /* check if the identifier is already in use */
2165 static bool ntree_interface_unique_identifier_check(void *UNUSED(data), const char *identifier)
2166 {
2167         return (RNA_struct_find(identifier) != NULL);
2168 }
2169
2170 /* generates the actual unique identifier and ui name and description */
2171 static void ntree_interface_identifier(bNodeTree *ntree, const char *base, char *identifier, int maxlen, char *name, char *description)
2172 {
2173         /* There is a possibility that different node tree names get mapped to the same identifier
2174          * after sanitization (e.g. "SomeGroup_A", "SomeGroup.A" both get sanitized to "SomeGroup_A").
2175          * On top of the sanitized id string add a number suffix if necessary to avoid duplicates.
2176          */
2177         identifier[0] = '\0';
2178         BLI_uniquename_cb(ntree_interface_unique_identifier_check, NULL, base, '_', identifier, maxlen);
2179         
2180         sprintf(name, "Node Tree %s Interface", ntree->id.name + 2);
2181         sprintf(description, "Interface properties of node group %s", ntree->id.name + 2);
2182 }
2183
2184 static void ntree_interface_type_create(bNodeTree *ntree)
2185 {
2186         StructRNA *srna;
2187         bNodeSocket *sock;
2188         /* strings are generated from base string + ID name, sizes are sufficient */
2189         char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64], description[MAX_ID_NAME + 64];
2190         
2191         /* generate a valid RNA identifier */
2192         ntree_interface_identifier_base(ntree, base);
2193         ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
2194         
2195         /* register a subtype of PropertyGroup */
2196         srna = RNA_def_struct_ptr(&BLENDER_RNA, identifier, &RNA_PropertyGroup);
2197         RNA_def_struct_ui_text(srna, name, description);
2198         RNA_def_struct_duplicate_pointers(srna);
2199         
2200         /* associate the RNA type with the node tree */
2201         ntree->interface_type = srna;
2202         RNA_struct_blender_type_set(srna, ntree);
2203         
2204         /* add socket properties */
2205         for (sock = ntree->inputs.first; sock; sock = sock->next) {
2206                 bNodeSocketType *stype = sock->typeinfo;
2207                 if (stype && stype->interface_register_properties)
2208                         stype->interface_register_properties(ntree, sock, srna);
2209         }
2210         for (sock = ntree->outputs.first; sock; sock = sock->next) {
2211                 bNodeSocketType *stype = sock->typeinfo;
2212                 if (stype && stype->interface_register_properties)
2213                         stype->interface_register_properties(ntree, sock, srna);
2214         }
2215 }
2216
2217 StructRNA *ntreeInterfaceTypeGet(bNodeTree *ntree, int create)
2218 {
2219         if (ntree->interface_type) {
2220                 /* strings are generated from base string + ID name, sizes are sufficient */
2221                 char base[MAX_ID_NAME + 64], identifier[MAX_ID_NAME + 64], name[MAX_ID_NAME + 64], description[MAX_ID_NAME + 64];
2222                 
2223                 /* A bit of a hack: when changing the ID name, update the RNA type identifier too,
2224                  * so that the names match. This is not strictly necessary to keep it working,
2225                  * but better for identifying associated NodeTree blocks and RNA types.
2226                  */
2227                 StructRNA *srna = ntree->interface_type;
2228                 
2229                 ntree_interface_identifier_base(ntree, base);
2230                 
2231                 /* RNA identifier may have a number suffix, but should start with the idbase string */
2232                 if (strncmp(RNA_struct_identifier(srna), base, sizeof(base)) != 0) {
2233                         /* generate new unique RNA identifier from the ID name */
2234                         ntree_interface_identifier(ntree, base, identifier, sizeof(identifier), name, description);
2235                         
2236                         /* rename the RNA type */
2237                         RNA_def_struct_free_pointers(srna);
2238                         RNA_def_struct_identifier(srna, identifier);
2239                         RNA_def_struct_ui_text(srna, name, description);
2240                         RNA_def_struct_duplicate_pointers(srna);
2241                 }
2242         }
2243         else if (create) {
2244                 ntree_interface_type_create(ntree);
2245         }
2246         
2247         return ntree->interface_type;
2248 }
2249
2250 void ntreeInterfaceTypeFree(bNodeTree *ntree)
2251 {
2252         if (ntree->interface_type) {
2253                 RNA_struct_free(&BLENDER_RNA, ntree->interface_type);
2254                 ntree->interface_type = NULL;
2255         }
2256 }
2257
2258 void ntreeInterfaceTypeUpdate(bNodeTree *ntree)
2259 {
2260         /* XXX it would be sufficient to just recreate all properties
2261          * instead of re-registering the whole struct type,
2262          * but there is currently no good way to do this in the RNA functions.
2263          * Overhead should be negligible.
2264          */
2265         ntreeInterfaceTypeFree(ntree);
2266         ntree_interface_type_create(ntree);
2267 }
2268
2269
2270 /* ************ find stuff *************** */
2271
2272 int ntreeHasType(bNodeTree *ntree, int type)
2273 {
2274         bNode *node;
2275         
2276         if (ntree)
2277                 for (node = ntree->nodes.first; node; node = node->next)
2278                         if (node->type == type)
2279                                 return 1;
2280         return 0;
2281 }
2282
2283 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
2284 {
2285         bNodeLink *link;
2286         
2287         for (link = ntree->links.first; link; link = link->next) {
2288                 if (link->fromsock == from && link->tosock == to)
2289                         return link;
2290                 if (link->fromsock == to && link->tosock == from) /* hrms? */
2291                         return link;
2292         }
2293         return NULL;
2294 }
2295
2296 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
2297 {
2298         bNodeLink *link;
2299         int tot = 0;
2300         
2301         for (link = ntree->links.first; link; link = link->next) {
2302                 if (link->fromsock == sock || link->tosock == sock)
2303                         tot++;
2304         }
2305         return tot;
2306 }
2307
2308 bNode *nodeGetActive(bNodeTree *ntree)
2309 {
2310         bNode *node;
2311         
2312         if (ntree == NULL) return NULL;
2313         
2314         for (node = ntree->nodes.first; node; node = node->next)
2315                 if (node->flag & NODE_ACTIVE)
2316                         break;
2317         return node;
2318 }
2319
2320 static bNode *node_get_active_id_recursive(bNodeInstanceKey active_key, bNodeInstanceKey parent_key, bNodeTree *ntree, short idtype)
2321 {
2322         if (parent_key.value == active_key.value || active_key.value == 0) {
2323                 bNode *node;
2324                 for (node = ntree->nodes.first; node; node = node->next)
2325                         if (node->id && GS(node->id->name) == idtype)
2326                                 if (node->flag & NODE_ACTIVE_ID)
2327                                         return node;
2328         }
2329         else {
2330                 bNode *node, *tnode;
2331                 /* no node with active ID in this tree, look inside groups */
2332                 for (node = ntree->nodes.first; node; node = node->next) {
2333                         if (node->type == NODE_GROUP) {
2334                                 bNodeTree *group = (bNodeTree *)node->id;
2335                                 if (group) {
2336                                         bNodeInstanceKey group_key = BKE_node_instance_key(parent_key, ntree, node);
2337                                         tnode = node_get_active_id_recursive(active_key, group_key, group, idtype);
2338                                         if (tnode)
2339                                                 return tnode;
2340                                 }
2341                         }
2342                 }
2343         }
2344         
2345         return NULL;
2346 }
2347
2348 /* two active flags, ID nodes have special flag for buttons display */
2349 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
2350 {
2351         if (ntree)
2352                 return node_get_active_id_recursive(ntree->active_viewer_key, NODE_INSTANCE_KEY_BASE, ntree, idtype);
2353         else
2354                 return NULL;
2355 }
2356
2357 bool nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
2358 {
2359         bNode *node;
2360         bool ok = false;
2361
2362         if (ntree == NULL) return ok;
2363
2364         for (node = ntree->nodes.first; node; node = node->next) {
2365                 if (node->id && GS(node->id->name) == idtype) {
2366                         if (id && ok == FALSE && node->id == id) {
2367                                 node->flag |= NODE_ACTIVE_ID;
2368                                 ok = TRUE;
2369                         }
2370                         else {
2371                                 node->flag &= ~NODE_ACTIVE_ID;
2372                         }
2373                 }
2374         }
2375
2376         /* update all groups linked from here
2377          * if active ID node has been found already,
2378          * just pass NULL so other matching nodes are deactivated.
2379          */
2380         for (node = ntree->nodes.first; node; node = node->next) {
2381                 if (node->type == NODE_GROUP)
2382                         ok |= nodeSetActiveID((bNodeTree *)node->id, idtype, (ok == false ? id : NULL));
2383         }
2384
2385         return ok;
2386 }
2387
2388
2389 /* two active flags, ID nodes have special flag for buttons display */
2390 void nodeClearActiveID(bNodeTree *ntree, short idtype)
2391 {
2392         bNode *node;
2393         
2394         if (ntree == NULL) return;
2395         
2396         for (node = ntree->nodes.first; node; node = node->next)
2397                 if (node->id && GS(node->id->name) == idtype)
2398                         node->flag &= ~NODE_ACTIVE_ID;
2399 }
2400
2401 void nodeSetSelected(bNode *node, int select)
2402 {
2403         if (select) {
2404                 node->flag |= NODE_SELECT;
2405         }
2406         else {
2407                 bNodeSocket *sock;
2408                 
2409                 node->flag &= ~NODE_SELECT;
2410                 
2411                 /* deselect sockets too */
2412                 for (sock = node->inputs.first; sock; sock = sock->next)
2413                         sock->flag &= ~NODE_SELECT;
2414                 for (sock = node->outputs.first; sock; sock = sock->next)
2415                         sock->flag &= ~NODE_SELECT;
2416         }
2417 }
2418
2419 void nodeClearActive(bNodeTree *ntree)
2420 {
2421         bNode *node;
2422
2423         if (ntree == NULL) return;
2424
2425         for (node = ntree->nodes.first; node; node = node->next)
2426                 node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_ID);
2427 }
2428
2429 /* two active flags, ID nodes have special flag for buttons display */
2430 void nodeSetActive(bNodeTree *ntree, bNode *node)
2431 {
2432         bNode *tnode;
2433         
2434         /* make sure only one node is active, and only one per ID type */
2435         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
2436                 tnode->flag &= ~NODE_ACTIVE;
2437                 
2438                 if (node->id && tnode->id) {
2439                         if (GS(node->id->name) == GS(tnode->id->name))
2440                                 tnode->flag &= ~NODE_ACTIVE_ID;
2441                 }
2442                 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
2443                         tnode->flag &= ~NODE_ACTIVE_TEXTURE;
2444         }
2445         
2446         node->flag |= NODE_ACTIVE;
2447         if (node->id)
2448                 node->flag |= NODE_ACTIVE_ID;
2449         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
2450                 node->flag |= NODE_ACTIVE_TEXTURE;
2451 }
2452
2453 int nodeSocketIsHidden(bNodeSocket *sock)
2454 {
2455         return ((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0);
2456 }
2457
2458 /* ************** Node Clipboard *********** */
2459
2460 #define USE_NODE_CB_VALIDATE
2461
2462 #ifdef USE_NODE_CB_VALIDATE
2463 /**
2464  * This data structure is to validate the node on creation,
2465  * otherwise we may reference missing data.
2466  *
2467  * Currently its only used for ID's, but nodes may one day
2468  * reference other pointers which need validation.
2469  */
2470 typedef struct bNodeClipboardExtraInfo {
2471         struct bNodeClipboardExtraInfo *next, *prev;
2472         ID  *id;
2473         char id_name[MAX_ID_NAME];
2474         char library_name[FILE_MAX];
2475 } bNodeClipboardExtraInfo;
2476 #endif  /* USE_NODE_CB_VALIDATE */
2477
2478
2479 typedef struct bNodeClipboard {
2480         ListBase nodes;
2481
2482 #ifdef USE_NODE_CB_VALIDATE
2483         ListBase nodes_extra_info;
2484 #endif
2485
2486         ListBase links;
2487         int type;
2488 } bNodeClipboard;
2489
2490 static bNodeClipboard node_clipboard = {{NULL}};
2491
2492 void BKE_node_clipboard_init(struct bNodeTree *ntree)
2493 {
2494         node_clipboard.type = ntree->type;
2495 }
2496
2497 void BKE_node_clipboard_clear(void)
2498 {
2499         bNode *node, *node_next;
2500         bNodeLink *link, *link_next;
2501         
2502         for (link = node_clipboard.links.first; link; link = link_next) {
2503                 link_next = link->next;
2504                 nodeRemLink(NULL, link);
2505         }
2506         node_clipboard.links.first = node_clipboard.links.last = NULL;
2507         
2508         for (node = node_clipboard.nodes.first; node; node = node_next) {
2509                 node_next = node->next;
2510                 nodeFreeNode(NULL, node);
2511         }
2512         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
2513
2514 #ifdef USE_NODE_CB_VALIDATE
2515         BLI_freelistN(&node_clipboard.nodes_extra_info);
2516 #endif
2517 }
2518
2519 /* return FALSE when one or more ID's are lost */
2520 int BKE_node_clipboard_validate(void)
2521 {
2522         int ok = TRUE;
2523
2524 #ifdef USE_NODE_CB_VALIDATE
2525         bNodeClipboardExtraInfo *node_info;
2526         bNode *node;
2527
2528
2529         /* lists must be aligned */
2530         BLI_assert(BLI_countlist(&node_clipboard.nodes) ==
2531                    BLI_countlist(&node_clipboard.nodes_extra_info));
2532
2533         for (node = node_clipboard.nodes.first, node_info = node_clipboard.nodes_extra_info.first;
2534              node;
2535              node = node->next, node_info = node_info->next)
2536         {
2537                 /* validate the node against the stored node info */
2538
2539                 /* re-assign each loop since we may clear,
2540                  * open a new file where the ID is valid, and paste again */
2541                 node->id = node_info->id;
2542
2543                 /* currently only validate the ID */
2544                 if (node->id) {
2545                         ListBase *lb = which_libbase(G.main, GS(node_info->id_name));
2546                         BLI_assert(lb != NULL);
2547
2548                         if (BLI_findindex(lb, node_info->id) == -1) {
2549                                 /* may assign NULL */
2550                                 node->id = BLI_findstring(lb, node_info->id_name + 2, offsetof(ID, name) + 2);
2551
2552                                 if (node->id == NULL) {
2553                                         ok = FALSE;
2554                                 }
2555                         }
2556                 }
2557         }
2558 #endif  /* USE_NODE_CB_VALIDATE */
2559
2560         return ok;
2561 }
2562
2563 void BKE_node_clipboard_add_node(bNode *node)
2564 {
2565 #ifdef USE_NODE_CB_VALIDATE
2566         /* add extra info */
2567         bNodeClipboardExtraInfo *node_info = MEM_mallocN(sizeof(bNodeClipboardExtraInfo), "bNodeClipboardExtraInfo");
2568
2569         node_info->id = node->id;
2570         if (node->id) {
2571                 BLI_strncpy(node_info->id_name, node->id->name, sizeof(node_info->id_name));
2572                 if (node->id->lib) {
2573                         BLI_strncpy(node_info->library_name, node->id->lib->filepath, sizeof(node_info->library_name));
2574                 }
2575                 else {
2576                         node_info->library_name[0] = '\0';
2577                 }
2578         }
2579         else {
2580                 node_info->id_name[0] = '\0';
2581                 node_info->library_name[0] = '\0';
2582         }
2583         BLI_addtail(&node_clipboard.nodes_extra_info, node_info);
2584         /* end extra info */
2585 #endif  /* USE_NODE_CB_VALIDATE */
2586
2587         /* add node */
2588         BLI_addtail(&node_clipboard.nodes, node);
2589
2590 }
2591
2592 void BKE_node_clipboard_add_link(bNodeLink *link)
2593 {
2594         BLI_addtail(&node_clipboard.links, link);
2595 }
2596
2597 const ListBase *BKE_node_clipboard_get_nodes(void)
2598 {
2599         return &node_clipboard.nodes;
2600 }
2601
2602 const ListBase *BKE_node_clipboard_get_links(void)
2603 {
2604         return &node_clipboard.links;
2605 }
2606
2607 int BKE_node_clipboard_get_type(void)
2608 {
2609         return node_clipboard.type;
2610 }
2611
2612
2613 /* Node Instance Hash */
2614
2615 /* magic number for initial hash key */
2616 const bNodeInstanceKey NODE_INSTANCE_KEY_BASE = {5381};
2617 const bNodeInstanceKey NODE_INSTANCE_KEY_NONE = {0};
2618
2619 /* Generate a hash key from ntree and node names
2620  * Uses the djb2 algorithm with xor by Bernstein:
2621  * http://www.cse.yorku.ca/~oz/hash.html
2622  */
2623 static bNodeInstanceKey node_hash_int_str(bNodeInstanceKey hash, const char *str)
2624 {
2625         char c;
2626         
2627         while ((c = *str++))
2628                 hash.value = ((hash.value << 5) + hash.value) ^ c; /* (hash * 33) ^ c */
2629         
2630         /* separator '\0' character, to avoid ambiguity from concatenated strings */
2631         hash.value = (hash.value << 5) + hash.value; /* hash * 33 */
2632         
2633         return hash;
2634 }
2635
2636 bNodeInstanceKey BKE_node_instance_key(bNodeInstanceKey parent_key, bNodeTree *ntree, bNode *node)
2637 {
2638         bNodeInstanceKey key;
2639         
2640         key = node_hash_int_str(parent_key, ntree->id.name + 2);
2641         
2642         if (node)
2643                 key = node_hash_int_str(key, node->name);
2644         
2645         return key;
2646 }
2647
2648 static unsigned int node_instance_hash_key(const void *key)
2649 {
2650         return ((const bNodeInstanceKey *)key)->value;
2651 }
2652
2653 static int node_instance_hash_key_cmp(const void *a, const void *b)
2654 {
2655         unsigned int value_a = ((const bNodeInstanceKey *)a)->value;
2656         unsigned int value_b = ((const bNodeInstanceKey *)b)->value;
2657         if (value_a == value_b)
2658                 return 0;
2659         else if (value_a < value_b)
2660                 return -1;
2661         else
2662                 return 1;
2663 }
2664
2665 bNodeInstanceHash *BKE_node_instance_hash_new(const char *info)
2666 {
2667         bNodeInstanceHash *hash = MEM_mallocN(sizeof(bNodeInstanceHash), info);
2668         hash->ghash = BLI_ghash_new(node_instance_hash_key, node_instance_hash_key_cmp, "node instance hash ghash");
2669         return hash;
2670 }
2671
2672 void BKE_node_instance_hash_free(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
2673 {
2674         BLI_ghash_free(hash->ghash, NULL, (GHashValFreeFP)valfreefp);
2675         MEM_freeN(hash);
2676 }
2677
2678 void BKE_node_instance_hash_insert(bNodeInstanceHash *hash, bNodeInstanceKey key, void *value)
2679 {
2680         bNodeInstanceHashEntry *entry = value;
2681         entry->key = key;
2682         entry->tag = 0;
2683         BLI_ghash_insert(hash->ghash, &entry->key, value);
2684 }
2685
2686 void *BKE_node_instance_hash_lookup(bNodeInstanceHash *hash, bNodeInstanceKey key)
2687 {
2688         return BLI_ghash_lookup(hash->ghash, &key);
2689 }
2690
2691 int BKE_node_instance_hash_remove(bNodeInstanceHash *hash, bNodeInstanceKey key, bNodeInstanceValueFP valfreefp)
2692 {
2693         return BLI_ghash_remove(hash->ghash, &key, NULL, (GHashValFreeFP)valfreefp);
2694 }
2695
2696 void BKE_node_instance_hash_clear(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
2697 {
2698         BLI_ghash_clear(hash->ghash, NULL, (GHashValFreeFP)valfreefp);
2699 }
2700
2701 void *BKE_node_instance_hash_pop(bNodeInstanceHash *hash, bNodeInstanceKey key)
2702 {
2703         return BLI_ghash_popkey(hash->ghash, &key, NULL);
2704 }
2705
2706 int BKE_node_instance_hash_haskey(bNodeInstanceHash *hash, bNodeInstanceKey key)
2707 {
2708         return BLI_ghash_haskey(hash->ghash, &key);
2709 }
2710
2711 int BKE_node_instance_hash_size(bNodeInstanceHash *hash)
2712 {
2713         return BLI_ghash_size(hash->ghash);
2714 }
2715
2716 void BKE_node_instance_hash_clear_tags(bNodeInstanceHash *hash)
2717 {
2718         bNodeInstanceHashIterator iter;
2719         
2720         NODE_INSTANCE_HASH_ITER(iter, hash) {
2721                 bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter);
2722                 
2723                 value->tag = 0;
2724         }
2725 }
2726
2727 void BKE_node_instance_hash_tag(bNodeInstanceHash *UNUSED(hash), void *value)
2728 {
2729         bNodeInstanceHashEntry *entry = value;
2730         entry->tag = 1;
2731 }
2732
2733 int BKE_node_instance_hash_tag_key(bNodeInstanceHash *hash, bNodeInstanceKey key)
2734 {
2735         bNodeInstanceHashEntry *entry = BKE_node_instance_hash_lookup(hash, key);
2736         
2737         if (entry) {
2738                 entry->tag = 1;
2739                 return TRUE;
2740         }
2741         else
2742                 return FALSE;
2743 }
2744
2745 void BKE_node_instance_hash_remove_untagged(bNodeInstanceHash *hash, bNodeInstanceValueFP valfreefp)
2746 {
2747         /* NOTE: Hash must not be mutated during iterating!
2748          * Store tagged entries in a separate list and remove items afterward.
2749          */
2750         bNodeInstanceKey *untagged = MEM_mallocN(sizeof(bNodeInstanceKey) * BKE_node_instance_hash_size(hash), "temporary node instance key list");
2751         bNodeInstanceHashIterator iter;
2752         int num_untagged, i;
2753         
2754         num_untagged = 0;
2755         NODE_INSTANCE_HASH_ITER(iter, hash) {
2756                 bNodeInstanceHashEntry *value = BKE_node_instance_hash_iterator_get_value(&iter);
2757                 
2758                 if (!value->tag)
2759                         untagged[num_untagged++] = BKE_node_instance_hash_iterator_get_key(&iter);
2760         }
2761         
2762         for (i = 0; i < num_untagged; ++i) {
2763                 BKE_node_instance_hash_remove(hash, untagged[i], valfreefp);
2764         }
2765         
2766         MEM_freeN(untagged);
2767 }
2768
2769
2770 /* ************** dependency stuff *********** */
2771
2772 /* node is guaranteed to be not checked before */
2773 static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort)
2774 {
2775         bNode *fromnode;
2776         bNodeLink *link;
2777         int level = 0xFFF;
2778         
2779         node->done = TRUE;
2780         
2781         /* check linked nodes */
2782         for (link = ntree->links.first; link; link = link->next) {
2783                 if (link->tonode == node) {
2784                         fromnode = link->fromnode;
2785                         if (fromnode->done == 0)
2786                                 fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort);
2787                         if (fromnode->level <= level)
2788                                 level = fromnode->level - 1;
2789                 }
2790         }
2791         
2792         /* check parent node */
2793         if (node->parent) {
2794                 if (node->parent->done == 0)
2795                         node->parent->level = node_get_deplist_recurs(ntree, node->parent, nsort);
2796                 if (node->parent->level <= level)
2797                         level = node->parent->level - 1;
2798         }
2799         
2800         if (nsort) {
2801                 **nsort = node;
2802                 (*nsort)++;
2803         }
2804         
2805         return level;
2806 }
2807
2808 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
2809 {
2810         bNode *node, **nsort;
2811         
2812         *totnodes = 0;
2813         
2814         /* first clear data */
2815         for (node = ntree->nodes.first; node; node = node->next) {
2816                 node->done = FALSE;
2817                 (*totnodes)++;
2818         }
2819         if (*totnodes == 0) {
2820                 *deplist = NULL;
2821                 return;
2822         }
2823         
2824         nsort = *deplist = MEM_callocN((*totnodes) * sizeof(bNode *), "sorted node array");
2825         
2826         /* recursive check */
2827         for (node = ntree->nodes.first; node; node = node->next) {
2828                 if (node->done == 0) {
2829                         node->level = node_get_deplist_recurs(ntree, node, &nsort);
2830                 }
2831         }
2832 }
2833
2834 /* only updates node->level for detecting cycles links */
2835 static void ntree_update_node_level(bNodeTree *ntree)
2836 {
2837         bNode *node;
2838         
2839         /* first clear tag */
2840         for (node = ntree->nodes.first; node; node = node->next) {
2841                 node->done = FALSE;
2842         }
2843         
2844         /* recursive check */
2845         for (node = ntree->nodes.first; node; node = node->next) {
2846                 if (node->done == 0) {
2847                         node->level = node_get_deplist_recurs(ntree, node, NULL);
2848                 }
2849         }
2850 }
2851
2852 static void ntree_update_link_pointers(bNodeTree *ntree)
2853 {
2854         bNode *node;
2855         bNodeSocket *sock;
2856         bNodeLink *link;
2857         
2858         /* first clear data */
2859         for (node = ntree->nodes.first; node; node = node->next) {
2860                 for (sock = node->inputs.first; sock; sock = sock->next) {
2861                         sock->link = NULL;
2862                         sock->flag &= ~SOCK_IN_USE;
2863                 }
2864                 for (sock = node->outputs.first; sock; sock = sock->next) {
2865                         sock->flag &= ~SOCK_IN_USE;
2866                 }
2867         }
2868
2869         for (link = ntree->links.first; link; link = link->next) {
2870                 link->tosock->link = link;
2871                 
2872                 link->fromsock->flag |= SOCK_IN_USE;
2873                 link->tosock->flag |= SOCK_IN_USE;
2874         }
2875 }
2876
2877 static void ntree_validate_links(bNodeTree *ntree)
2878 {
2879         bNodeLink *link;
2880         
2881         for (link = ntree->links.first; link; link = link->next) {
2882                 link->flag |= NODE_LINK_VALID;
2883                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
2884                         link->flag &= ~NODE_LINK_VALID;
2885                 else if (ntree->typeinfo->validate_link) {
2886                         if (!ntree->typeinfo->validate_link(ntree, link))
2887                                 link->flag &= ~NODE_LINK_VALID;
2888                 }
2889         }
2890 }
2891
2892 void ntreeVerifyNodes(struct Main *main, struct ID *id)
2893 {
2894         FOREACH_NODETREE(main, ntree, owner_id) {
2895                 bNode *node;
2896                 
2897                 for (node = ntree->nodes.first; node; node = node->next)
2898                         if (node->typeinfo->verifyfunc)
2899                                 node->typeinfo->verifyfunc(ntree, node, id);
2900         } FOREACH_NODETREE_END
2901 }
2902
2903 void ntreeUpdateTree(Main *bmain, bNodeTree *ntree)
2904 {
2905         bNode *node;
2906         
2907         if (!ntree)
2908                 return;
2909         
2910         /* avoid reentrant updates, can be caused by RNA update callbacks */
2911         if (ntree->is_updating)
2912                 return;
2913         ntree->is_updating = TRUE;
2914         
2915         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
2916                 /* set the bNodeSocket->link pointers */
2917                 ntree_update_link_pointers(ntree);
2918         }
2919         
2920         /* update individual nodes */
2921         for (node = ntree->nodes.first; node; node = node->next) {
2922                 /* node tree update tags override individual node update flags */
2923                 if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
2924                         if (node->typeinfo->updatefunc)
2925                                 node->typeinfo->updatefunc(ntree, node);
2926                         
2927                         nodeUpdateInternalLinks(ntree, node);
2928                 }
2929         }
2930         
2931         /* generic tree update callback */
2932         if (ntree->typeinfo->update)
2933                 ntree->typeinfo->update(ntree);
2934         /* XXX this should be moved into the tree type update callback for tree supporting node groups.
2935          * Currently the node tree interface is still a generic feature of the base NodeTree type.
2936          */
2937         if (ntree->update & NTREE_UPDATE_GROUP)
2938                 ntreeInterfaceTypeUpdate(ntree);
2939         
2940         /* XXX hack, should be done by depsgraph!! */
2941         if (bmain)
2942                 ntreeVerifyNodes(bmain, &ntree->id);
2943         
2944         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
2945                 /* node updates can change sockets or links, repeat link pointer update afterward */
2946                 ntree_update_link_pointers(ntree);
2947                 
2948                 /* update the node level from link dependencies */
2949                 ntree_update_node_level(ntree);
2950                 
2951                 /* check link validity */
2952                 ntree_validate_links(ntree);
2953         }
2954         
2955         /* clear update flags */
2956         for (node = ntree->nodes.first; node; node = node->next) {
2957                 node->update = 0;
2958         }
2959         ntree->update = 0;
2960         
2961         ntree->is_updating = FALSE;
2962 }
2963
2964 void nodeUpdate(bNodeTree *ntree, bNode *node)
2965 {
2966         /* avoid reentrant updates, can be caused by RNA update callbacks */
2967         if (ntree->is_updating)
2968                 return;
2969         ntree->is_updating = TRUE;
2970         
2971         if (node->typeinfo->updatefunc)
2972                 node->typeinfo->updatefunc(ntree, node);
2973         
2974         nodeUpdateInternalLinks(ntree, node);
2975         
2976         /* clear update flag */
2977         node->update = 0;
2978         
2979         ntree->is_updating = FALSE;
2980 }
2981
2982 int nodeUpdateID(bNodeTree *ntree, ID *id)
2983 {
2984         bNode *node;
2985         int change = FALSE;
2986         
2987         if (ELEM(NULL, id, ntree))
2988                 return change;
2989         
2990         /* avoid reentrant updates, can be caused by RNA update callbacks */
2991         if (ntree->is_updating)
2992                 return change;
2993         ntree->is_updating = TRUE;
2994         
2995         for (node = ntree->nodes.first; node; node = node->next) {
2996                 if (node->id == id) {
2997                         change = TRUE;
2998                         node->update |= NODE_UPDATE_ID;
2999                         if (node->typeinfo->updatefunc)
3000                                 node->typeinfo->updatefunc(ntree, node);
3001                         /* clear update flag */
3002                         node->update = 0;
3003                 }
3004         }
3005         
3006         for (node = ntree->nodes.first; node; node = node->next) {
3007                 nodeUpdateInternalLinks(ntree, node);
3008         }
3009         
3010         ntree->is_updating = FALSE;
3011         return change;
3012 }
3013
3014 void nodeUpdateInternalLinks(bNodeTree *ntree, bNode *node)
3015 {
3016         BLI_freelistN(&node->internal_links);
3017         
3018         if (node->typeinfo && node->typeinfo->update_internal_links)
3019                 node->typeinfo->update_internal_links(ntree, node);
3020 }
3021
3022
3023 /* nodes that use ID data get synced with local data */
3024 void nodeSynchronizeID(bNode *node, bool copy_to_id)
3025 {
3026         if (node->id == NULL) return;
3027         
3028         if (ELEM(node->type, SH_NODE_MATERIAL, SH_NODE_MATERIAL_EXT)) {
3029                 bNodeSocket *sock;
3030                 Material *ma = (Material *)node->id;
3031                 int a;
3032                 
3033                 /* hrmf, case in loop isn't super fast, but we don't edit 100s of material at same time either! */
3034                 for (a = 0, sock = node->inputs.first; sock; sock = sock->next, a++) {
3035                         if (!nodeSocketIsHidden(sock)) {
3036                                 if (copy_to_id) {
3037                                         switch (a) {
3038                                                 case MAT_IN_COLOR:
3039                                                         copy_v3_v3(&ma->r, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
3040                                                 case MAT_IN_SPEC:
3041                                                         copy_v3_v3(&ma->specr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
3042                                                 case MAT_IN_REFL:
3043                                                         ma->ref = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3044                                                 case MAT_IN_MIR:
3045                                                         copy_v3_v3(&ma->mirr, ((bNodeSocketValueRGBA *)sock->default_value)->value); break;
3046                                                 case MAT_IN_AMB:
3047                                                         ma->amb = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3048                                                 case MAT_IN_EMIT:
3049                                                         ma->emit = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3050                                                 case MAT_IN_SPECTRA:
3051                                                         ma->spectra = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3052                                                 case MAT_IN_RAY_MIRROR:
3053                                                         ma->ray_mirror = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3054                                                 case MAT_IN_ALPHA:
3055                                                         ma->alpha = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3056                                                 case MAT_IN_TRANSLUCENCY:
3057                                                         ma->translucency = ((bNodeSocketValueFloat *)sock->default_value)->value; break;
3058                                         }
3059                                 }
3060                                 else {
3061                                         switch (a) {
3062                                                 case MAT_IN_COLOR:
3063                                                         copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->r); break;
3064                                                 case MAT_IN_SPEC:
3065                                                         copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->specr); break;
3066                                                 case MAT_IN_REFL:
3067                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ref; break;
3068                                                 case MAT_IN_MIR:
3069                                                         copy_v3_v3(((bNodeSocketValueRGBA *)sock->default_value)->value, &ma->mirr); break;
3070                                                 case MAT_IN_AMB:
3071                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->amb; break;
3072                                                 case MAT_IN_EMIT:
3073                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->emit; break;
3074                                                 case MAT_IN_SPECTRA:
3075                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->spectra; break;
3076                                                 case MAT_IN_RAY_MIRROR:
3077                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->ray_mirror; break;
3078                                                 case MAT_IN_ALPHA:
3079                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->alpha; break;
3080                                                 case MAT_IN_TRANSLUCENCY:
3081                                                         ((bNodeSocketValueFloat *)sock->default_value)->value = ma->translucency; break;
3082                                         }
3083                                 }
3084                         }
3085                 }
3086         }
3087 }
3088
3089
3090 /* ************* node type access ********** */
3091
3092 void nodeLabel(bNode *node, char *label, int maxlen)
3093 {
3094         if (node->label[0] != '\0')
3095                 BLI_strncpy(label, node->label, maxlen);
3096         else if (node->typeinfo->labelfunc)
3097                 node->typeinfo->labelfunc(node, label, maxlen);
3098         else
3099                 BLI_strncpy(label, IFACE_(node->typeinfo->ui_name), maxlen);
3100 }
3101
3102 static void node_type_base_defaults(bNodeType *ntype)
3103 {
3104         /* default size values */
3105         node_type_size_preset(ntype, NODE_SIZE_DEFAULT);
3106         ntype->height = 100;
3107         ntype->minheight = 30;
3108         ntype->maxheight = FLT_MAX;
3109 }
3110
3111 /* allow this node for any tree type */
3112 static int node_poll_default(bNodeType *UNUSED(ntype), bNodeTree *UNUSED(ntree))
3113 {
3114         return TRUE;
3115 }
3116
3117 /* use the basic poll function */
3118 static int node_poll_instance_default(bNode *node, bNodeTree *ntree)
3119 {
3120         return node->typeinfo->poll(node->typeinfo, ntree);
3121 }
3122
3123 void node_type_base(bNodeType *ntype, int type, const char *name, short nclass, short flag)
3124 {
3125         /* Use static type info header to map static int type to identifier string and RNA struct type.
3126          * Associate the RNA struct type with the bNodeType.
3127          * Dynamically registered nodes will create an RNA type at runtime
3128          * and call RNA_struct_blender_type_set, so this only needs to be done for old RNA types
3129          * created in makesrna, which can not be associated to a bNodeType immediately,
3130          * since bNodeTypes are registered afterward ...
3131          */
3132         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
3133                 case ID: \
3134                         BLI_strncpy(ntype->idname, #Category #StructName, sizeof(ntype->idname)); \
3135                         ntype->ext.srna = RNA_struct_find(#Category #StructName); \
3136                         BLI_assert(ntype->ext.srna != NULL); \
3137                         RNA_struct_blender_type_set(ntype->ext.srna, ntype); \
3138                         break;
3139         
3140         switch (type) {
3141         #include "NOD_static_types.h"
3142         }
3143         
3144         /* make sure we have a valid type (everything registered) */
3145         BLI_assert(ntype->idname[0] != '\0');
3146         
3147         ntype->type = type;
3148         BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name));
3149         ntype->nclass = nclass;
3150         ntype->flag = flag;
3151
3152         node_type_base_defaults(ntype);
3153
3154         ntype->poll = node_poll_default;
3155         ntype->poll_instance = node_poll_instance_default;
3156 }
3157
3158 void node_type_base_custom(bNodeType *ntype, const char *idname, const char *name, short nclass, short flag)
3159 {
3160         BLI_strncpy(ntype->idname, idname, sizeof(ntype->idname));
3161         ntype->type = NODE_CUSTOM;
3162         BLI_strncpy(ntype->ui_name, name, sizeof(ntype->ui_name));
3163         ntype->nclass = nclass;
3164         ntype->flag = flag;
3165
3166         node_type_base_defaults(ntype);
3167 }
3168
3169 static bool unique_socket_template_identifier_check(void *arg, const char *name)
3170 {
3171         bNodeSocketTemplate *ntemp;
3172         struct {bNodeSocketTemplate *list; bNodeSocketTemplate *ntemp;} *data = arg;
3173         
3174         for (ntemp = data->list; ntemp->type >= 0; ++ntemp) {
3175                 if (ntemp != data->ntemp) {
3176                         if (STREQ(ntemp->identifier, name)) {
3177                                 return true;
3178                         }
3179                 }
3180         }
3181         
3182         return false;
3183 }
3184
3185 static void unique_socket_template_identifier(bNodeSocketTemplate *list, bNodeSocketTemplate *ntemp, const char defname[], char delim)
3186 {
3187         struct {bNodeSocketTemplate *list; bNodeSocketTemplate *ntemp;} data;
3188         data.list = list;
3189         data.ntemp = ntemp;
3190
3191         BLI_uniquename_cb(unique_socket_template_identifier_check, &data, defname, delim, ntemp->identifier, sizeof(ntemp->identifier));
3192 }
3193
3194 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
3195 {
3196         bNodeSocketTemplate *ntemp;
3197         
3198         ntype->inputs = inputs;
3199         ntype->outputs = outputs;
3200         
3201         /* automatically generate unique identifiers */
3202         if (inputs) {
3203                 /* clear identifier strings (uninitialized memory) */
3204                 for (ntemp = inputs; ntemp->type >= 0; ++ntemp)
3205                         ntemp->identifier[0] = '\0';
3206                 
3207                 for (ntemp = inputs; ntemp->type >= 0; ++ntemp) {
3208                         BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier));
3209                         unique_socket_template_identifier(inputs, ntemp, ntemp->identifier, '_');
3210                 }
3211         }
3212         if (outputs) {
3213                 /* clear identifier strings (uninitialized memory) */
3214                 for (ntemp = outputs; ntemp->type >= 0; ++ntemp)
3215                         ntemp->identifier[0] = '\0';
3216                 
3217                 for (ntemp = outputs; ntemp->type >= 0; ++ntemp) {
3218                         BLI_strncpy(ntemp->identifier, ntemp->name, sizeof(ntemp->identifier));
3219                         unique_socket_template_identifier(outputs, ntemp, ntemp->identifier, '_');
3220                 }
3221         }
3222 }
3223
3224 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node))
3225 {
3226         ntype->initfunc = initfunc;
3227 }
3228
3229 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
3230 {
3231         ntype->width = width;
3232         ntype->minwidth = minwidth;
3233         if (maxwidth <= minwidth)
3234                 ntype->maxwidth = FLT_MAX;
3235         else
3236                 ntype->maxwidth = maxwidth;
3237 }
3238
3239 void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size)
3240 {
3241         switch (size) {
3242                 case NODE_SIZE_DEFAULT:
3243                         node_type_size(ntype, 140, 100, 320);
3244                         break;
3245                 case NODE_SIZE_SMALL:
3246                         node_type_size(ntype, 100, 80, 320);
3247                         break;
3248                 case NODE_SIZE_MIDDLE:
3249                         node_type_size(ntype, 150, 120, 320);
3250                         break;
3251                 case NODE_SIZE_LARGE:
3252                         node_type_size(ntype, 240, 140, 320);
3253                         break;
3254         }
3255 }
3256
3257 void node_type_storage(bNodeType *ntype,
3258         const char *storagename,
3259         void (*freefunc)(struct bNode *node),
3260         void (*copyfunc)(struct bNodeTree *dest_ntree, struct bNode *dest_node, struct bNode *src_node))
3261 {
3262         if (storagename)
3263                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
3264         else
3265                 ntype->storagename[0] = '\0';