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