Cycles UI: keep node input sockets collapsed by default in the properties editor,
[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_node_types.h"
42 #include "DNA_node_types.h"
43 #include "DNA_scene_types.h"
44
45 #include "BLI_string.h"
46 #include "BLI_math.h"
47 #include "BLI_listbase.h"
48 #include "BLI_path_util.h"
49 #include "BLI_utildefines.h"
50
51 #include "BLF_translation.h"
52
53 #include "BKE_animsys.h"
54 #include "BKE_action.h"
55 #include "BKE_fcurve.h"
56 #include "BKE_global.h"
57 #include "BKE_image.h"
58 #include "BKE_library.h"
59 #include "BKE_main.h"
60 #include "BKE_node.h"
61
62 #include "RNA_access.h"
63
64 #include "NOD_socket.h"
65 #include "NOD_composite.h"
66 #include "NOD_shader.h"
67 #include "NOD_texture.h"
68
69
70 bNodeTreeType *ntreeGetType(int type)
71 {
72         static bNodeTreeType *types[NUM_NTREE_TYPES];
73         static int types_init = 1;
74         if (types_init) {
75                 types[NTREE_SHADER] = &ntreeType_Shader;
76                 types[NTREE_COMPOSIT] = &ntreeType_Composite;
77                 types[NTREE_TEXTURE] = &ntreeType_Texture;
78                 types_init = 0;
79         }
80         
81         if (type >= 0 && type < NUM_NTREE_TYPES) {
82                 return types[type];
83         }
84         else {
85                 return NULL;
86         }
87 }
88
89 static bNodeType *node_get_type(bNodeTree *ntree, int type)
90 {
91         bNodeType *ntype = ntreeGetType(ntree->type)->node_types.first;
92         for (; ntype; ntype = ntype->next)
93                 if (ntype->type == type)
94                         return ntype;
95         
96         return NULL;
97 }
98
99 bNodeType *ntreeGetNodeType(bNodeTree *ntree)
100 {
101         return node_get_type(ntree, ntree->nodetype);
102 }
103
104 bNodeSocketType *ntreeGetSocketType(int type)
105 {
106         static bNodeSocketType *types[NUM_SOCKET_TYPES] = {NULL};
107         static int types_init = 1;
108
109         if (types_init) {
110                 node_socket_type_init(types);
111                 types_init = 0;
112         }
113
114         if (type < NUM_SOCKET_TYPES) {
115                 return types[type];
116         }
117         else {
118                 return NULL;
119         }
120 }
121
122 void ntreeInitTypes(bNodeTree *ntree)
123 {
124         bNode *node, *next;
125         
126         for (node = ntree->nodes.first; node; node = next) {
127                 next = node->next;
128                 
129                 node->typeinfo = node_get_type(ntree, node->type);
130
131                 if (node->typeinfo == NULL) {
132                         printf("Error: Node type %s doesn't exist anymore, removed\n", node->name);
133                         nodeFreeNode(ntree, node);
134                 }
135         }
136                         
137         ntree->init |= NTREE_TYPE_INIT;
138 }
139
140 static bNodeSocket *make_socket(bNodeTree *UNUSED(ntree), int in_out, const char *name, int type)
141 {
142         bNodeSocket *sock;
143         
144         sock = MEM_callocN(sizeof(bNodeSocket), "sock");
145         
146         BLI_strncpy(sock->name, name, NODE_MAXSTR);
147         sock->limit = (in_out == SOCK_IN ? 1 : 0xFFF);
148         sock->type = type;
149         sock->storage = NULL;
150         sock->flag |= SOCK_COLLAPSED;
151         
152         sock->default_value = node_socket_make_default_value(type);
153         node_socket_init_default_value(type, sock->default_value);
154         
155         return sock;
156 }
157
158 bNodeSocket *nodeAddSocket(bNodeTree *ntree, bNode *node, int in_out, const char *name, int type)
159 {
160         bNodeSocket *sock = make_socket(ntree, in_out, name, type);
161         if (in_out == SOCK_IN)
162                 BLI_addtail(&node->inputs, sock);
163         else if (in_out == SOCK_OUT)
164                 BLI_addtail(&node->outputs, sock);
165         
166         node->update |= NODE_UPDATE;
167         
168         return sock;
169 }
170
171 bNodeSocket *nodeInsertSocket(bNodeTree *ntree, bNode *node, int in_out, bNodeSocket *next_sock, const char *name, int type)
172 {
173         bNodeSocket *sock = make_socket(ntree, in_out, name, type);
174         if (in_out == SOCK_IN)
175                 BLI_insertlinkbefore(&node->inputs, next_sock, sock);
176         else if (in_out == SOCK_OUT)
177                 BLI_insertlinkbefore(&node->outputs, next_sock, sock);
178         
179         node->update |= NODE_UPDATE;
180         
181         return sock;
182 }
183
184 void nodeRemoveSocket(bNodeTree *ntree, bNode *node, bNodeSocket *sock)
185 {
186         bNodeLink *link, *next;
187         
188         for (link = ntree->links.first; link; link = next) {
189                 next = link->next;
190                 if (link->fromsock == sock || link->tosock == sock) {
191                         nodeRemLink(ntree, link);
192                 }
193         }
194         
195         /* this is fast, this way we don't need an in_out argument */
196         BLI_remlink(&node->inputs, sock);
197         BLI_remlink(&node->outputs, sock);
198         
199         node_socket_free_default_value(sock->type, sock->default_value);
200         MEM_freeN(sock);
201         
202         node->update |= NODE_UPDATE;
203 }
204
205 void nodeRemoveAllSockets(bNodeTree *ntree, bNode *node)
206 {
207         bNodeSocket *sock;
208         bNodeLink *link, *next;
209         
210         for (link = ntree->links.first; link; link = next) {
211                 next = link->next;
212                 if (link->fromnode == node || link->tonode == node) {
213                         nodeRemLink(ntree, link);
214                 }
215         }
216         
217         for (sock = node->inputs.first; sock; sock = sock->next)
218                 node_socket_free_default_value(sock->type, sock->default_value);
219         BLI_freelistN(&node->inputs);
220         for (sock = node->outputs.first; sock; sock = sock->next)
221                 node_socket_free_default_value(sock->type, sock->default_value);
222         BLI_freelistN(&node->outputs);
223         
224         node->update |= NODE_UPDATE;
225 }
226
227 /* finds a node based on its name */
228 bNode *nodeFindNodebyName(bNodeTree *ntree, const char *name)
229 {
230         return BLI_findstring(&ntree->nodes, name, offsetof(bNode, name));
231 }
232
233 /* finds a node based on given socket */
234 int nodeFindNode(bNodeTree *ntree, bNodeSocket *sock, bNode **nodep, int *sockindex, int *in_out)
235 {
236         bNode *node;
237         bNodeSocket *tsock;
238         int index = 0;
239         
240         for (node = ntree->nodes.first; node; node = node->next) {
241                 for (index = 0, tsock = node->inputs.first; tsock; tsock = tsock->next, index++) {
242                         if (tsock == sock) {
243                                 if (in_out) *in_out = SOCK_IN;
244                                 break;
245                         }
246                 }
247                 if (tsock)
248                         break;
249                 for (index = 0, tsock = node->outputs.first; tsock; tsock = tsock->next, index++) {
250                         if (tsock == sock) {
251                                 if (in_out) *in_out = SOCK_OUT;
252                                 break;
253                         }
254                 }
255                 if (tsock)
256                         break;
257         }
258
259         if (node) {
260                 *nodep = node;
261                 if (sockindex) *sockindex = index;
262                 return 1;
263         }
264         
265         *nodep = NULL;
266         return 0;
267 }
268
269 /* ************** Add stuff ********** */
270 static void node_add_sockets_from_type(bNodeTree *ntree, bNode *node, bNodeType *ntype)
271 {
272         bNodeSocketTemplate *sockdef;
273         /* bNodeSocket *sock; */ /* UNUSED */
274
275         if (ntype->inputs) {
276                 sockdef = ntype->inputs;
277                 while (sockdef->type != -1) {
278                         /* sock = */ node_add_input_from_template(ntree, node, sockdef);
279                         
280                         sockdef++;
281                 }
282         }
283         if (ntype->outputs) {
284                 sockdef = ntype->outputs;
285                 while (sockdef->type != -1) {
286                         /* sock = */ node_add_output_from_template(ntree, node, sockdef);
287                         
288                         sockdef++;
289                 }
290         }
291 }
292
293 /* Find the first available, non-duplicate name for a given node */
294 void nodeUniqueName(bNodeTree *ntree, bNode *node)
295 {
296         BLI_uniquename(&ntree->nodes, node, "Node", '.', offsetof(bNode, name), sizeof(node->name));
297 }
298
299 bNode *nodeAddNode(bNodeTree *ntree, struct bNodeTemplate *ntemp)
300 {
301         bNode *node;
302         bNodeType *ntype;
303         
304         ntype = node_get_type(ntree, ntemp->type);
305         if (ntype == NULL) {
306                 printf("nodeAddNodeType() error: '%d' type invalid\n", ntemp->type);
307                 return NULL;
308         }
309         /* validity check */
310         if (!nodeValid(ntree, ntemp))
311                 return NULL;
312         
313         node = MEM_callocN(sizeof(bNode), "new node");
314         node->type = ntype->type;
315         node->typeinfo = ntype;
316         node->flag = NODE_SELECT | ntype->flag;
317         node->width = ntype->width;
318         node->miniwidth = 42.0f;
319         node->height = ntype->height;
320         node->color[0] = node->color[1] = node->color[2] = 0.608;   /* default theme color */
321         
322         node_add_sockets_from_type(ntree, node, ntype);
323
324         BLI_addtail(&ntree->nodes, node);
325         
326         if (ntype->initfunc != NULL)
327                 ntype->initfunc(ntree, node, ntemp);
328
329         /* initialize the node name with the node label.
330          * note: do this after the initfunc so nodes get their data set which may be used in naming
331          * (node groups for example) */
332         /* XXX Do not use nodeLabel() here, it returns translated content, which should *only* be used
333          *     in UI, *never* in data...
334          *     This solution may be a bit rougher than nodeLabel()'s returned string, but it's simpler
335          *     than adding a "no translate" flag to this func (and labelfunc() as well). */
336         BLI_strncpy(node->name, node->typeinfo->name, NODE_MAXSTR);
337         nodeUniqueName(ntree, node);
338         
339         ntree->update |= NTREE_UPDATE_NODES;
340         
341         return node;
342 }
343
344 /* keep socket listorder identical, for copying links */
345 /* ntree is the target tree */
346 bNode *nodeCopyNode(struct bNodeTree *ntree, struct bNode *node)
347 {
348         bNode *nnode = MEM_callocN(sizeof(bNode), "dupli node");
349         bNodeSocket *sock, *oldsock;
350
351         *nnode = *node;
352         /* can be called for nodes outside a node tree (e.g. clipboard) */
353         if (ntree) {
354                 nodeUniqueName(ntree, nnode);
355
356                 BLI_addtail(&ntree->nodes, nnode);
357         }
358
359         BLI_duplicatelist(&nnode->inputs, &node->inputs);
360         oldsock = node->inputs.first;
361         for (sock = nnode->inputs.first; sock; sock = sock->next, oldsock = oldsock->next) {
362                 oldsock->new_sock = sock;
363                 sock->stack_index = 0;
364                 
365                 sock->default_value = node_socket_make_default_value(oldsock->type);
366                 node_socket_copy_default_value(oldsock->type, sock->default_value, oldsock->default_value);
367                 
368                 /* XXX some compositor node (e.g. image, render layers) still store
369                  * some persistent buffer data here, need to clear this to avoid dangling pointers.
370                  */
371                 sock->cache = NULL;
372         }
373         
374         BLI_duplicatelist(&nnode->outputs, &node->outputs);
375         oldsock = node->outputs.first;
376         for (sock = nnode->outputs.first; sock; sock = sock->next, oldsock = oldsock->next) {
377                 oldsock->new_sock = sock;
378                 sock->stack_index = 0;
379                 
380                 sock->default_value = node_socket_make_default_value(oldsock->type);
381                 node_socket_copy_default_value(oldsock->type, sock->default_value, oldsock->default_value);
382                 
383                 /* XXX some compositor node (e.g. image, render layers) still store
384                  * some persistent buffer data here, need to clear this to avoid dangling pointers.
385                  */
386                 sock->cache = NULL;
387         }
388         
389         /* don't increase node->id users, freenode doesn't decrement either */
390         
391         if (node->typeinfo->copystoragefunc)
392                 node->typeinfo->copystoragefunc(node, nnode);
393         
394         node->new_node = nnode;
395         nnode->new_node = NULL;
396         nnode->preview = NULL;
397         
398         if (ntree)
399                 ntree->update |= NTREE_UPDATE_NODES;
400         
401         return nnode;
402 }
403
404 /* also used via rna api, so we check for proper input output direction */
405 bNodeLink *nodeAddLink(bNodeTree *ntree, bNode *fromnode, bNodeSocket *fromsock, bNode *tonode, bNodeSocket *tosock)
406 {
407         bNodeSocket *sock;
408         bNodeLink *link = NULL;
409         int from = 0, to = 0;
410         
411         if (fromnode) {
412                 /* test valid input */
413                 for (sock = fromnode->outputs.first; sock; sock = sock->next)
414                         if (sock == fromsock)
415                                 break;
416                 if (sock)
417                         from = 1;  /* OK */
418                 else {
419                         for (sock = fromnode->inputs.first; sock; sock = sock->next)
420                                 if (sock == fromsock)
421                                         break;
422                         if (sock)
423                                 from = -1;  /* OK but flip */
424                 }
425         }
426         else if (ntree) {
427                 /* check tree sockets */
428                 for (sock = ntree->inputs.first; sock; sock = sock->next)
429                         if (sock == fromsock)
430                                 break;
431                 if (sock)
432                         from = 1;  /* OK */
433                 else {
434                         for (sock = ntree->outputs.first; sock; sock = sock->next)
435                                 if (sock == fromsock)
436                                         break;
437                         if (sock)
438                                 from = -1;  /* OK but flip */
439                 }
440         }
441         if (tonode) {
442                 for (sock = tonode->inputs.first; sock; sock = sock->next)
443                         if (sock == tosock)
444                                 break;
445                 if (sock)
446                         to = 1;  /* OK */
447                 else {
448                         for (sock = tonode->outputs.first; sock; sock = sock->next)
449                                 if (sock == tosock)
450                                         break;
451                         if (sock)
452                                 to = -1;  /* OK but flip */
453                 }
454         }
455         else if (ntree) {
456                 /* check tree sockets */
457                 for (sock = ntree->outputs.first; sock; sock = sock->next)
458                         if (sock == tosock)
459                                 break;
460                 if (sock)
461                         to = 1;  /* OK */
462                 else {
463                         for (sock = ntree->inputs.first; sock; sock = sock->next)
464                                 if (sock == tosock)
465                                         break;
466                         if (sock)
467                                 to = -1;  /* OK but flip */
468                 }
469         }
470         
471         if (from >= 0 && to >= 0) {
472                 link = MEM_callocN(sizeof(bNodeLink), "link");
473                 if (ntree)
474                         BLI_addtail(&ntree->links, link);
475                 link->fromnode = fromnode;
476                 link->fromsock = fromsock;
477                 link->tonode = tonode;
478                 link->tosock = tosock;
479         }
480         else if (from <= 0 && to <= 0) {
481                 link = MEM_callocN(sizeof(bNodeLink), "link");
482                 if (ntree)
483                         BLI_addtail(&ntree->links, link);
484                 link->fromnode = tonode;
485                 link->fromsock = tosock;
486                 link->tonode = fromnode;
487                 link->tosock = fromsock;
488         }
489         
490         if (ntree)
491                 ntree->update |= NTREE_UPDATE_LINKS;
492         
493         return link;
494 }
495
496 void nodeRemLink(bNodeTree *ntree, bNodeLink *link)
497 {
498         /* can be called for links outside a node tree (e.g. clipboard) */
499         if (ntree)
500                 BLI_remlink(&ntree->links, link);
501
502         if (link->tosock)
503                 link->tosock->link = NULL;
504         MEM_freeN(link);
505         
506         if (ntree)
507                 ntree->update |= NTREE_UPDATE_LINKS;
508 }
509
510 void nodeRemSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
511 {
512         bNodeLink *link, *next;
513         
514         for (link = ntree->links.first; link; link = next) {
515                 next = link->next;
516                 if (link->fromsock == sock || link->tosock == sock) {
517                         nodeRemLink(ntree, link);
518                 }
519         }
520         
521         ntree->update |= NTREE_UPDATE_LINKS;
522 }
523
524 void nodeInternalRelink(bNodeTree *ntree, bNode *node)
525 {
526         bNodeLink *link, *link_next;
527         ListBase intlinks;
528         
529         if (!node->typeinfo->internal_connect)
530                 return;
531         
532         intlinks = node->typeinfo->internal_connect(ntree, node);
533         
534         /* store link pointers in output sockets, for efficient lookup */
535         for (link = intlinks.first; link; link = link->next)
536                 link->tosock->link = link;
537         
538         /* redirect downstream links */
539         for (link = ntree->links.first; link; link = link_next) {
540                 link_next = link->next;
541                 
542                 /* do we have internal link? */
543                 if (link->fromnode == node) {
544                         if (link->fromsock->link) {
545                                 /* get the upstream input link */
546                                 bNodeLink *fromlink = link->fromsock->link->fromsock->link;
547                                 /* skip the node */
548                                 if (fromlink) {
549                                         link->fromnode = fromlink->fromnode;
550                                         link->fromsock = fromlink->fromsock;
551                                         
552                                         ntree->update |= NTREE_UPDATE_LINKS;
553                                 }
554                                 else
555                                         nodeRemLink(ntree, link);
556                         }
557                         else
558                                 nodeRemLink(ntree, link);
559                 }
560         }
561         
562         /* remove remaining upstream links */
563         for (link = ntree->links.first; link; link = link_next) {
564                 link_next = link->next;
565                 
566                 if (link->tonode == node)
567                         nodeRemLink(ntree, link);
568         }
569         
570         BLI_freelistN(&intlinks);
571 }
572
573 void nodeToView(bNode *node, float x, float y, float *rx, float *ry)
574 {
575         if (node->parent) {
576                 nodeToView(node->parent, x + node->locx, y + node->locy, rx, ry);
577         }
578         else {
579                 *rx = x + node->locx;
580                 *ry = y + node->locy;
581         }
582 }
583
584 void nodeFromView(bNode *node, float x, float y, float *rx, float *ry)
585 {
586         if (node->parent) {
587                 nodeFromView(node->parent, x, y, rx, ry);
588                 *rx -= node->locx;
589                 *ry -= node->locy;
590         }
591         else {
592                 *rx = x - node->locx;
593                 *ry = y - node->locy;
594         }
595 }
596
597 int nodeAttachNodeCheck(bNode *node, bNode *parent)
598 {
599         bNode *parent_recurse;
600         for (parent_recurse = node; parent_recurse; parent_recurse = parent_recurse->parent) {
601                 if (parent_recurse == parent) {
602                         return TRUE;
603                 }
604         }
605
606         return FALSE;
607 }
608
609 void nodeAttachNode(bNode *node, bNode *parent)
610 {
611         float locx, locy;
612
613         BLI_assert(parent->type == NODE_FRAME);
614         BLI_assert(nodeAttachNodeCheck(parent, node) == FALSE);
615
616         nodeToView(node, 0.0f, 0.0f, &locx, &locy);
617         
618         node->parent = parent;
619         /* transform to parent space */
620         nodeFromView(parent, locx, locy, &node->locx, &node->locy);
621 }
622
623 void nodeDetachNode(struct bNode *node)
624 {
625         float locx, locy;
626         
627         if (node->parent) {
628
629                 BLI_assert(node->parent->type == NODE_FRAME);
630
631                 /* transform to view space */
632                 nodeToView(node, 0.0f, 0.0f, &locx, &locy);
633                 node->locx = locx;
634                 node->locy = locy;
635                 node->parent = NULL;
636         }
637 }
638
639 bNodeTree *ntreeAddTree(const char *name, int type, int nodetype)
640 {
641         bNodeTree *ntree;
642         bNodeType *ntype;
643         
644         /* trees are created as local trees if they of compositor, material or texture type,
645          * node groups and other tree types are created as library data.
646          */
647         if (ELEM3(type, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE) && nodetype == 0) {
648                 ntree = MEM_callocN(sizeof(bNodeTree), "new node tree");
649                 *( (short *)ntree->id.name) = ID_NT; /* not "type", as that is ntree->type */
650                 BLI_strncpy(ntree->id.name + 2, name, sizeof(ntree->id.name));
651         }
652         else
653                 ntree = BKE_libblock_alloc(&G.main->nodetree, ID_NT, name);
654         
655         ntree->type = type;
656         ntree->nodetype = nodetype;
657         
658         ntreeInitTypes(ntree);
659         
660         ntype = node_get_type(ntree, ntree->nodetype);
661         if (ntype && ntype->inittreefunc)
662                 ntype->inittreefunc(ntree);
663         
664         return ntree;
665 }
666
667 /* Warning: this function gets called during some rather unexpected times
668  *      - this gets called when executing compositing updates (for threaded previews)
669  *      - when the nodetree datablock needs to be copied (i.e. when users get copied)
670  *      - for scene duplication use ntreeSwapID() after so we don't have stale pointers.
671  *
672  * do_make_extern: keep enabled for general use, only reason _not_ to enable is when
673  * copying for internal use (threads for eg), where you wont want it to modify the
674  * scene data.
675  */
676 static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_user, const short do_make_extern)
677 {
678         bNodeTree *newtree;
679         bNode *node /*, *nnode */ /* UNUSED */, *last;
680         bNodeLink *link;
681         bNodeSocket *gsock, *oldgsock;
682         
683         if (ntree == NULL) return NULL;
684         
685         /* is ntree part of library? */
686         for (newtree = G.main->nodetree.first; newtree; newtree = newtree->id.next)
687                 if (newtree == ntree) break;
688         if (newtree) {
689                 newtree = BKE_libblock_copy(&ntree->id);
690         }
691         else {
692                 newtree = MEM_dupallocN(ntree);
693                 BKE_libblock_copy_data(&newtree->id, &ntree->id, TRUE); /* copy animdata and ID props */
694         }
695
696         id_us_plus((ID *)newtree->gpd);
697
698         /* in case a running nodetree is copied */
699         newtree->execdata = NULL;
700         
701         newtree->nodes.first = newtree->nodes.last = NULL;
702         newtree->links.first = newtree->links.last = NULL;
703         
704         last = ntree->nodes.last;
705         for (node = ntree->nodes.first; node; node = node->next) {
706
707                 /* ntreeUserDecrefID inline */
708                 if (do_id_user) {
709                         id_us_plus(node->id);
710                 }
711
712                 if (do_make_extern) {
713                         id_lib_extern(node->id);
714                 }
715
716                 node->new_node = NULL;
717                 /* nnode = */ nodeCopyNode(newtree, node);   /* sets node->new */
718                 
719                 /* make sure we don't copy new nodes again! */
720                 if (node == last)
721                         break;
722         }
723         
724         /* socket definition for group usage */
725         BLI_duplicatelist(&newtree->inputs, &ntree->inputs);
726         for (gsock = newtree->inputs.first, oldgsock = ntree->inputs.first; gsock; gsock = gsock->next, oldgsock = oldgsock->next) {
727                 oldgsock->new_sock = gsock;
728                 gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL);
729                 gsock->default_value = node_socket_make_default_value(oldgsock->type);
730                 node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value);
731         }
732         BLI_duplicatelist(&newtree->outputs, &ntree->outputs);
733         for (gsock = newtree->outputs.first, oldgsock = ntree->outputs.first; gsock; gsock = gsock->next, oldgsock = oldgsock->next) {
734                 oldgsock->new_sock = gsock;
735                 gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL);
736                 gsock->default_value = node_socket_make_default_value(oldgsock->type);
737                 node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value);
738         }
739         
740         /* copy links */
741         BLI_duplicatelist(&newtree->links, &ntree->links);
742         for (link = newtree->links.first; link; link = link->next) {
743                 link->fromnode = (link->fromnode ? link->fromnode->new_node : NULL);
744                 link->fromsock = (link->fromsock ? link->fromsock->new_sock : NULL);
745                 link->tonode = (link->tonode ? link->tonode->new_node : NULL);
746                 link->tosock = (link->tosock ? link->tosock->new_sock : NULL);
747                 /* update the link socket's pointer */
748                 if (link->tosock)
749                         link->tosock->link = link;
750         }
751         
752         /* update node->parent pointers */
753         for (node = newtree->nodes.first; node; node = node->next) {
754                 if (node->parent)
755                         node->parent = node->parent->new_node;
756         }
757         
758         return newtree;
759 }
760
761 bNodeTree *ntreeCopyTree_ex(bNodeTree *ntree, const short do_id_user)
762 {
763         return ntreeCopyTree_internal(ntree, do_id_user, TRUE);
764 }
765 bNodeTree *ntreeCopyTree(bNodeTree *ntree)
766 {
767         return ntreeCopyTree_ex(ntree, TRUE);
768 }
769
770 /* use when duplicating scenes */
771 void ntreeSwitchID_ex(bNodeTree *ntree, ID *id_from, ID *id_to, const short do_id_user)
772 {
773         bNode *node;
774
775         if (id_from == id_to) {
776                 /* should never happen but may as well skip if it does */
777                 return;
778         }
779
780         /* for scene duplication only */
781         for (node = ntree->nodes.first; node; node = node->next) {
782                 if (node->id == id_from) {
783                         if (do_id_user) {
784                                 id_us_min(id_from);
785                                 id_us_plus(id_to);
786                         }
787
788                         node->id = id_to;
789                 }
790         }
791 }
792 void ntreeSwitchID(bNodeTree *ntree, ID *id_from, ID *id_to)
793 {
794         ntreeSwitchID_ex(ntree, id_from, id_to, TRUE);
795 }
796
797 void ntreeUserIncrefID(bNodeTree *ntree)
798 {
799         bNode *node;
800         for (node = ntree->nodes.first; node; node = node->next) {
801                 id_us_plus(node->id);
802         }
803 }
804 void ntreeUserDecrefID(bNodeTree *ntree)
805 {
806         bNode *node;
807         for (node = ntree->nodes.first; node; node = node->next) {
808                 id_us_min(node->id);
809         }
810 }
811
812 /* *************** preview *********** */
813 /* if node->preview, then we assume the rect to exist */
814
815 void nodeFreePreview(bNode *node)
816 {
817         if (node->preview) {
818                 if (node->preview->rect)
819                         MEM_freeN(node->preview->rect);
820                 MEM_freeN(node->preview);
821                 node->preview = NULL;
822         }
823 }
824
825 static void node_init_preview(bNode *node, int xsize, int ysize)
826 {
827         
828         if (node->preview == NULL) {
829                 node->preview = MEM_callocN(sizeof(bNodePreview), "node preview");
830                 //              printf("added preview %s\n", node->name);
831         }
832         
833         /* node previews can get added with variable size this way */
834         if (xsize == 0 || ysize == 0)
835                 return;
836         
837         /* sanity checks & initialize */
838         if (node->preview->rect) {
839                 if (node->preview->xsize != xsize && node->preview->ysize != ysize) {
840                         MEM_freeN(node->preview->rect);
841                         node->preview->rect = NULL;
842                 }
843         }
844         
845         if (node->preview->rect == NULL) {
846                 node->preview->rect = MEM_callocN(4 * xsize + xsize * ysize * sizeof(char) * 4, "node preview rect");
847                 node->preview->xsize = xsize;
848                 node->preview->ysize = ysize;
849         }
850         /* no clear, makes nicer previews */
851 }
852
853 void ntreeInitPreview(bNodeTree *ntree, int xsize, int ysize)
854 {
855         bNode *node;
856         
857         if (ntree == NULL)
858                 return;
859         
860         for (node = ntree->nodes.first; node; node = node->next) {
861                 if (node->typeinfo->flag & NODE_PREVIEW)    /* hrms, check for closed nodes? */
862                         node_init_preview(node, xsize, ysize);
863                 if (node->type == NODE_GROUP && (node->flag & NODE_GROUP_EDIT))
864                         ntreeInitPreview((bNodeTree *)node->id, xsize, ysize);
865         }
866 }
867
868 static void nodeClearPreview(bNode *node)
869 {
870         if (node->preview && node->preview->rect)
871                 memset(node->preview->rect, 0, MEM_allocN_len(node->preview->rect));
872 }
873
874 /* use it to enforce clear */
875 void ntreeClearPreview(bNodeTree *ntree)
876 {
877         bNode *node;
878         
879         if (ntree == NULL)
880                 return;
881         
882         for (node = ntree->nodes.first; node; node = node->next) {
883                 if (node->typeinfo->flag & NODE_PREVIEW)
884                         nodeClearPreview(node);
885                 if (node->type == NODE_GROUP && (node->flag & NODE_GROUP_EDIT))
886                         ntreeClearPreview((bNodeTree *)node->id);
887         }
888 }
889
890 /* hack warning! this function is only used for shader previews, and 
891  * since it gets called multiple times per pixel for Ztransp we only
892  * add the color once. Preview gets cleared before it starts render though */
893 void nodeAddToPreview(bNode *node, const float col[4], int x, int y, int do_manage)
894 {
895         bNodePreview *preview = node->preview;
896         if (preview) {
897                 if (x >= 0 && y >= 0) {
898                         if (x < preview->xsize && y < preview->ysize) {
899                                 unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
900                                 
901                                 if (do_manage) {
902                                         linearrgb_to_srgb_uchar4(tar, col);
903                                 }
904                                 else {
905                                         rgba_float_to_uchar(tar, col);
906                                 }
907                         }
908                         //else printf("prv out bound x y %d %d\n", x, y);
909                 }
910                 //else printf("prv out bound x y %d %d\n", x, y);
911         }
912 }
913
914 /* ************** Free stuff ********** */
915
916 /* goes over entire tree */
917 void nodeUnlinkNode(bNodeTree *ntree, bNode *node)
918 {
919         bNodeLink *link, *next;
920         bNodeSocket *sock;
921         ListBase *lb;
922         
923         for (link = ntree->links.first; link; link = next) {
924                 next = link->next;
925                 
926                 if (link->fromnode == node) {
927                         lb = &node->outputs;
928                         if (link->tonode)
929                                 link->tonode->update |= NODE_UPDATE;
930                 }
931                 else if (link->tonode == node)
932                         lb = &node->inputs;
933                 else
934                         lb = NULL;
935
936                 if (lb) {
937                         for (sock = lb->first; sock; sock = sock->next) {
938                                 if (link->fromsock == sock || link->tosock == sock)
939                                         break;
940                         }
941                         if (sock) {
942                                 nodeRemLink(ntree, link);
943                         }
944                 }
945         }
946 }
947
948 static void node_unlink_attached(bNodeTree *ntree, bNode *parent)
949 {
950         bNode *node;
951         for (node = ntree->nodes.first; node; node = node->next) {
952                 if (node->parent == parent)
953                         nodeDetachNode(node);
954         }
955 }
956
957 /** \note caller needs to manage node->id user */
958 void nodeFreeNode(bNodeTree *ntree, bNode *node)
959 {
960         bNodeSocket *sock, *nextsock;
961         
962         /* can be called for nodes outside a node tree (e.g. clipboard) */
963         if (ntree) {
964                 bNodeTreeType *treetype = ntreeGetType(ntree->type);
965
966                 /* remove all references to this node */
967                 nodeUnlinkNode(ntree, node);
968                 node_unlink_attached(ntree, node);
969
970                 BLI_remlink(&ntree->nodes, node);
971
972                 if (treetype->free_node_cache)
973                         treetype->free_node_cache(ntree, node);
974         }
975         
976         /* since it is called while free database, node->id is undefined */
977         
978         if (node->typeinfo && node->typeinfo->freestoragefunc)
979                 node->typeinfo->freestoragefunc(node);
980         
981         for (sock = node->inputs.first; sock; sock = nextsock) {
982                 nextsock = sock->next;
983                 node_socket_free_default_value(sock->type, sock->default_value);
984                 MEM_freeN(sock);
985         }
986         for (sock = node->outputs.first; sock; sock = nextsock) {
987                 nextsock = sock->next;
988                 node_socket_free_default_value(sock->type, sock->default_value);
989                 MEM_freeN(sock);
990         }
991
992         nodeFreePreview(node);
993
994         MEM_freeN(node);
995         
996         if (ntree)
997                 ntree->update |= NTREE_UPDATE_NODES;
998 }
999
1000 /* do not free ntree itself here, BKE_libblock_free calls this function too */
1001 void ntreeFreeTree_ex(bNodeTree *ntree, const short do_id_user)
1002 {
1003         bNode *node, *next;
1004         bNodeSocket *sock;
1005         
1006         if (ntree == NULL) return;
1007         
1008         /* XXX hack! node trees should not store execution graphs at all.
1009          * This should be removed when old tree types no longer require it.
1010          * Currently the execution data for texture nodes remains in the tree
1011          * after execution, until the node tree is updated or freed.
1012          */
1013         if (ntree->execdata) {
1014                 switch (ntree->type) {
1015                         case NTREE_COMPOSIT:
1016                                 ntreeCompositEndExecTree(ntree->execdata, 1);
1017                                 break;
1018                         case NTREE_SHADER:
1019                                 ntreeShaderEndExecTree(ntree->execdata, 1);
1020                                 break;
1021                         case NTREE_TEXTURE:
1022                                 ntreeTexEndExecTree(ntree->execdata, 1);
1023                                 break;
1024                 }
1025         }
1026         
1027         BKE_free_animdata((ID *)ntree);
1028         
1029         id_us_min((ID *)ntree->gpd);
1030
1031         BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
1032         
1033         for (node = ntree->nodes.first; node; node = next) {
1034                 next = node->next;
1035
1036                 /* ntreeUserIncrefID inline */
1037
1038                 /* XXX, this is correct, however when freeing the entire database
1039                  * this ends up accessing freed data which isn't properly unlinking
1040                  * its self from scene nodes, SO - for now prefer invalid usercounts
1041                  * on free rather then bad memory access - Campbell */
1042 #if 0
1043                 if (do_id_user) {
1044                         id_us_min(node->id);
1045                 }
1046 #else
1047                 (void)do_id_user;
1048 #endif
1049
1050                 nodeFreeNode(ntree, node);
1051         }
1052         
1053         for (sock = ntree->inputs.first; sock; sock = sock->next)
1054                 node_socket_free_default_value(sock->type, sock->default_value);
1055         BLI_freelistN(&ntree->inputs);
1056         for (sock = ntree->outputs.first; sock; sock = sock->next)
1057                 node_socket_free_default_value(sock->type, sock->default_value);
1058         BLI_freelistN(&ntree->outputs);
1059 }
1060 /* same as ntreeFreeTree_ex but always manage users */
1061 void ntreeFreeTree(bNodeTree *ntree)
1062 {
1063         ntreeFreeTree_ex(ntree, TRUE);
1064 }
1065
1066 void ntreeFreeCache(bNodeTree *ntree)
1067 {
1068         bNodeTreeType *treetype;
1069         
1070         if (ntree == NULL) return;
1071         
1072         treetype = ntreeGetType(ntree->type);
1073         if (treetype->free_cache)
1074                 treetype->free_cache(ntree);
1075 }
1076
1077 void ntreeSetOutput(bNodeTree *ntree)
1078 {
1079         bNode *node;
1080
1081         /* find the active outputs, might become tree type dependent handler */
1082         for (node = ntree->nodes.first; node; node = node->next) {
1083                 if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1084                         bNode *tnode;
1085                         int output = 0;
1086                         
1087                         /* we need a check for which output node should be tagged like this, below an exception */
1088                         if (node->type == CMP_NODE_OUTPUT_FILE)
1089                                 continue;
1090
1091                         /* there is more types having output class, each one is checked */
1092                         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1093                                 if (tnode->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1094                                         
1095                                         if (ntree->type == NTREE_COMPOSIT) {
1096                                                         
1097                                                 /* same type, exception for viewer */
1098                                                 if (tnode->type == node->type ||
1099                                                     (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
1100                                                      ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)))
1101                                                 {
1102                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1103                                                                 output++;
1104                                                                 if (output > 1)
1105                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1106                                                         }
1107                                                 }
1108                                         }
1109                                         else {
1110                                                 /* same type */
1111                                                 if (tnode->type == node->type) {
1112                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1113                                                                 output++;
1114                                                                 if (output > 1)
1115                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1116                                                         }
1117                                                 }
1118                                         }
1119                                 }
1120                         }
1121                         if (output == 0)
1122                                 node->flag |= NODE_DO_OUTPUT;
1123                 }
1124         }
1125         
1126         /* here we could recursively set which nodes have to be done,
1127          * might be different for editor or for "real" use... */
1128 }
1129
1130 typedef struct MakeLocalCallData {
1131         ID *group_id;
1132         ID *new_id;
1133         int lib, local;
1134 } MakeLocalCallData;
1135
1136 static void ntreeMakeLocal_CheckLocal(void *calldata, ID *owner_id, bNodeTree *ntree)
1137 {
1138         MakeLocalCallData *cd = (MakeLocalCallData *)calldata;
1139         bNode *node;
1140         
1141         /* find if group is in tree */
1142         for (node = ntree->nodes.first; node; node = node->next) {
1143                 if (node->id == cd->group_id) {
1144                         if (owner_id->lib) {
1145                                 cd->lib = TRUE;
1146                         }
1147                         else {
1148                                 cd->local = TRUE;
1149                         }
1150                 }
1151         }
1152 }
1153
1154 static void ntreeMakeLocal_LinkNew(void *calldata, ID *owner_id, bNodeTree *ntree)
1155 {
1156         MakeLocalCallData *cd = (MakeLocalCallData *)calldata;
1157         bNode *node;
1158         
1159         /* find if group is in tree */
1160         for (node = ntree->nodes.first; node; node = node->next) {
1161                 if (node->id == cd->group_id) {
1162                         if (owner_id->lib == NULL) {
1163                                 node->id = cd->new_id;
1164                                 cd->new_id->us++;
1165                                 cd->group_id->us--;
1166                         }
1167                 }
1168         }
1169 }
1170
1171 void ntreeMakeLocal(bNodeTree *ntree)
1172 {
1173         Main *bmain = G.main;
1174         bNodeTreeType *treetype = ntreeGetType(ntree->type);
1175         MakeLocalCallData cd;
1176         
1177         /* - only lib users: do nothing
1178          * - only local users: set flag
1179          * - mixed: make copy
1180          */
1181         
1182         if (ntree->id.lib == NULL) return;
1183         if (ntree->id.us == 1) {
1184                 id_clear_lib_data(bmain, (ID *)ntree);
1185                 return;
1186         }
1187         
1188         /* now check users of groups... again typedepending, callback... */
1189         cd.group_id = &ntree->id;
1190         cd.new_id = NULL;
1191         cd.local = 0;
1192         cd.lib = 0;
1193         
1194         treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_CheckLocal);
1195         
1196         /* if all users are local, we simply make tree local */
1197         if (cd.local && cd.lib == 0) {
1198                 id_clear_lib_data(bmain, (ID *)ntree);
1199         }
1200         else if (cd.local && cd.lib) {
1201                 /* this is the mixed case, we copy the tree and assign it to local users */
1202                 bNodeTree *newtree = ntreeCopyTree(ntree);
1203                 
1204                 newtree->id.us = 0;
1205                 
1206
1207                 cd.new_id = &newtree->id;
1208                 treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_LinkNew);
1209         }
1210 }
1211
1212 int ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
1213 {
1214         bNode *node = ntree->nodes.first;
1215         for (; node; node = node->next)
1216                 if (node == testnode)
1217                         return 1;
1218         return 0;
1219 }
1220
1221 int ntreeOutputExists(bNode *node, bNodeSocket *testsock)
1222 {
1223         bNodeSocket *sock = node->outputs.first;
1224         for (; sock; sock = sock->next)
1225                 if (sock == testsock)
1226                         return 1;
1227         return 0;
1228 }
1229
1230 /* returns localized tree for execution in threads */
1231 bNodeTree *ntreeLocalize(bNodeTree *ntree)
1232 {
1233         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1234
1235         bNodeTree *ltree;
1236         bNode *node;
1237         
1238         bAction *action_backup = NULL, *tmpact_backup = NULL;
1239         
1240         /* Workaround for copying an action on each render!
1241          * set action to NULL so animdata actions don't get copied */
1242         AnimData *adt = BKE_animdata_from_id(&ntree->id);
1243
1244         if (adt) {
1245                 action_backup = adt->action;
1246                 tmpact_backup = adt->tmpact;
1247
1248                 adt->action = NULL;
1249                 adt->tmpact = NULL;
1250         }
1251
1252         /* node copy func */
1253         ltree = ntreeCopyTree_internal(ntree, FALSE, FALSE);
1254
1255         if (adt) {
1256                 AnimData *ladt = BKE_animdata_from_id(&ltree->id);
1257
1258                 adt->action = ladt->action = action_backup;
1259                 adt->tmpact = ladt->tmpact = tmpact_backup;
1260
1261                 if (action_backup) action_backup->id.us++;
1262                 if (tmpact_backup) tmpact_backup->id.us++;
1263                 
1264         }
1265         /* end animdata uglyness */
1266
1267         /* ensures only a single output node is enabled */
1268         ntreeSetOutput(ntree);
1269
1270         for (node = ntree->nodes.first; node; node = node->next) {
1271                 /* store new_node pointer to original */
1272                 node->new_node->new_node = node;
1273         }
1274
1275         if (ntreetype->localize)
1276                 ntreetype->localize(ltree, ntree);
1277
1278         return ltree;
1279 }
1280
1281 /* sync local composite with real tree */
1282 /* local tree is supposed to be running, be careful moving previews! */
1283 /* is called by jobs manager, outside threads, so it doesnt happen during draw */
1284 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
1285 {
1286         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1287
1288         if (ntreetype->local_sync)
1289                 ntreetype->local_sync(localtree, ntree);
1290 }
1291
1292 /* merge local tree results back, and free local tree */
1293 /* we have to assume the editor already changed completely */
1294 void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
1295 {
1296         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1297         bNode *lnode;
1298         
1299         /* move over the compbufs and previews */
1300         for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) {
1301                 if (ntreeNodeExists(ntree, lnode->new_node)) {
1302                         if (lnode->preview && lnode->preview->rect) {
1303                                 nodeFreePreview(lnode->new_node);
1304                                 lnode->new_node->preview = lnode->preview;
1305                                 lnode->preview = NULL;
1306                         }
1307                 }
1308         }
1309
1310         if (ntreetype->local_merge)
1311                 ntreetype->local_merge(localtree, ntree);
1312
1313         ntreeFreeTree_ex(localtree, FALSE);
1314         MEM_freeN(localtree);
1315 }
1316
1317 /* ************ find stuff *************** */
1318
1319 int ntreeHasType(bNodeTree *ntree, int type)
1320 {
1321         bNode *node;
1322         
1323         if (ntree)
1324                 for (node = ntree->nodes.first; node; node = node->next)
1325                         if (node->type == type)
1326                                 return 1;
1327         return 0;
1328 }
1329
1330 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
1331 {
1332         bNodeLink *link;
1333         
1334         for (link = ntree->links.first; link; link = link->next) {
1335                 if (link->fromsock == from && link->tosock == to)
1336                         return link;
1337                 if (link->fromsock == to && link->tosock == from) /* hrms? */
1338                         return link;
1339         }
1340         return NULL;
1341 }
1342
1343 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
1344 {
1345         bNodeLink *link;
1346         int tot = 0;
1347         
1348         for (link = ntree->links.first; link; link = link->next) {
1349                 if (link->fromsock == sock || link->tosock == sock)
1350                         tot++;
1351         }
1352         return tot;
1353 }
1354
1355 bNode *nodeGetActive(bNodeTree *ntree)
1356 {
1357         bNode *node;
1358         
1359         if (ntree == NULL) return NULL;
1360         
1361         for (node = ntree->nodes.first; node; node = node->next)
1362                 if (node->flag & NODE_ACTIVE)
1363                         break;
1364         return node;
1365 }
1366
1367 /* two active flags, ID nodes have special flag for buttons display */
1368 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
1369 {
1370         bNode *node;
1371         
1372         if (ntree == NULL) return NULL;
1373
1374         /* check for group edit */
1375         for (node = ntree->nodes.first; node; node = node->next)
1376                 if (node->flag & NODE_GROUP_EDIT)
1377                         break;
1378
1379         if (node)
1380                 ntree = (bNodeTree *)node->id;
1381         
1382         /* now find active node with this id */
1383         for (node = ntree->nodes.first; node; node = node->next)
1384                 if (node->id && GS(node->id->name) == idtype)
1385                         if (node->flag & NODE_ACTIVE_ID)
1386                                 break;
1387
1388         return node;
1389 }
1390
1391 int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
1392 {
1393         bNode *node;
1394         int ok = FALSE;
1395
1396         if (ntree == NULL) return ok;
1397
1398         /* check for group edit */
1399         for (node = ntree->nodes.first; node; node = node->next)
1400                 if (node->flag & NODE_GROUP_EDIT)
1401                         break;
1402
1403         if (node)
1404                 ntree = (bNodeTree *)node->id;
1405
1406         /* now find active node with this id */
1407         for (node = ntree->nodes.first; node; node = node->next) {
1408                 if (node->id && GS(node->id->name) == idtype) {
1409                         if (id && ok == FALSE && node->id == id) {
1410                                 node->flag |= NODE_ACTIVE_ID;
1411                                 ok = TRUE;
1412                         }
1413                         else {
1414                                 node->flag &= ~NODE_ACTIVE_ID;
1415                         }
1416                 }
1417         }
1418
1419         return ok;
1420 }
1421
1422
1423 /* two active flags, ID nodes have special flag for buttons display */
1424 void nodeClearActiveID(bNodeTree *ntree, short idtype)
1425 {
1426         bNode *node;
1427         
1428         if (ntree == NULL) return;
1429         
1430         for (node = ntree->nodes.first; node; node = node->next)
1431                 if (node->id && GS(node->id->name) == idtype)
1432                         node->flag &= ~NODE_ACTIVE_ID;
1433 }
1434
1435 void nodeClearActive(bNodeTree *ntree)
1436 {
1437         bNode *node;
1438
1439         if (ntree == NULL) return;
1440
1441         for (node = ntree->nodes.first; node; node = node->next)
1442                 node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_ID);
1443 }
1444
1445
1446 /* two active flags, ID nodes have special flag for buttons display */
1447 void nodeSetActive(bNodeTree *ntree, bNode *node)
1448 {
1449         bNode *tnode;
1450         
1451         /* make sure only one node is active, and only one per ID type */
1452         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1453                 tnode->flag &= ~NODE_ACTIVE;
1454                 
1455                 if (node->id && tnode->id) {
1456                         if (GS(node->id->name) == GS(tnode->id->name))
1457                                 tnode->flag &= ~NODE_ACTIVE_ID;
1458                 }
1459                 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1460                         tnode->flag &= ~NODE_ACTIVE_TEXTURE;
1461         }
1462         
1463         node->flag |= NODE_ACTIVE;
1464         if (node->id)
1465                 node->flag |= NODE_ACTIVE_ID;
1466         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1467                 node->flag |= NODE_ACTIVE_TEXTURE;
1468 }
1469
1470 int nodeSocketIsHidden(bNodeSocket *sock)
1471 {
1472         return ((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0);
1473 }
1474
1475 void nodeSocketSetType(bNodeSocket *sock, int type)
1476 {
1477         int old_type = sock->type;
1478         void *old_default_value = sock->default_value;
1479         
1480         sock->type = type;
1481         
1482         sock->default_value = node_socket_make_default_value(sock->type);
1483         node_socket_init_default_value(type, sock->default_value);
1484         node_socket_convert_default_value(sock->type, sock->default_value, old_type, old_default_value);
1485         node_socket_free_default_value(old_type, old_default_value);
1486 }
1487
1488 /* ************** Node Clipboard *********** */
1489
1490 #define USE_NODE_CB_VALIDATE
1491
1492 #ifdef USE_NODE_CB_VALIDATE
1493 /**
1494  * This data structure is to validate the node on creation,
1495  * otherwise we may reference missing data.
1496  *
1497  * Currently its only used for ID's, but nodes may one day
1498  * reference other pointers which need validation.
1499  */
1500 typedef struct bNodeClipboardExtraInfo {
1501         struct bNodeClipboardExtraInfo *next, *prev;
1502         ID  *id;
1503         char id_name[MAX_ID_NAME];
1504         char library_name[FILE_MAX];
1505 } bNodeClipboardExtraInfo;
1506 #endif  /* USE_NODE_CB_VALIDATE */
1507
1508
1509 typedef struct bNodeClipboard {
1510         ListBase nodes;
1511
1512 #ifdef USE_NODE_CB_VALIDATE
1513         ListBase nodes_extra_info;
1514 #endif
1515
1516         ListBase links;
1517         int type;
1518 } bNodeClipboard;
1519
1520 bNodeClipboard node_clipboard = {{0}};
1521
1522 void BKE_node_clipboard_init(struct bNodeTree *ntree)
1523 {
1524         node_clipboard.type = ntree->type;
1525 }
1526
1527 void BKE_node_clipboard_clear(void)
1528 {
1529         bNode *node, *node_next;
1530         bNodeLink *link, *link_next;
1531         
1532         for (link = node_clipboard.links.first; link; link = link_next) {
1533                 link_next = link->next;
1534                 nodeRemLink(NULL, link);
1535         }
1536         node_clipboard.links.first = node_clipboard.links.last = NULL;
1537         
1538         for (node = node_clipboard.nodes.first; node; node = node_next) {
1539                 node_next = node->next;
1540                 nodeFreeNode(NULL, node);
1541         }
1542         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
1543
1544 #ifdef USE_NODE_CB_VALIDATE
1545         BLI_freelistN(&node_clipboard.nodes_extra_info);
1546 #endif
1547 }
1548
1549 /* return FALSE when one or more ID's are lost */
1550 int BKE_node_clipboard_validate(void)
1551 {
1552         int ok = TRUE;
1553
1554 #ifdef USE_NODE_CB_VALIDATE
1555         bNodeClipboardExtraInfo *node_info;
1556         bNode *node;
1557
1558
1559         /* lists must be aligned */
1560         BLI_assert(BLI_countlist(&node_clipboard.nodes) ==
1561                            BLI_countlist(&node_clipboard.nodes_extra_info));
1562
1563         for (node = node_clipboard.nodes.first, node_info = node_clipboard.nodes_extra_info.first;
1564                  node;
1565                  node = node->next, node_info = node_info->next)
1566         {
1567                 /* validate the node against the stored node info */
1568
1569                 /* re-assign each loop since we may clear,
1570                  * open a new file where the ID is valid, and paste again */
1571                 node->id = node_info->id;
1572
1573                 /* currently only validate the ID */
1574                 if (node->id) {
1575                         ListBase *lb = which_libbase(G.main, GS(node_info->id_name));
1576                         BLI_assert(lb != NULL);
1577
1578                         if (BLI_findindex(lb, node_info->id) == -1) {
1579                                 /* may assign NULL */
1580                                 node->id = BLI_findstring(lb, node_info->id_name + 2, offsetof(ID, name) + 2);
1581
1582                                 if (node->id == NULL) {
1583                                         ok = FALSE;
1584                                 }
1585                         }
1586                 }
1587         }
1588 #endif  /* USE_NODE_CB_VALIDATE */
1589
1590         return ok;
1591 }
1592
1593 void BKE_node_clipboard_add_node(bNode *node)
1594 {
1595 #ifdef USE_NODE_CB_VALIDATE
1596         /* add extra info */
1597         bNodeClipboardExtraInfo *node_info = MEM_mallocN(sizeof(bNodeClipboardExtraInfo), STRINGIFY(bNodeClipboardExtraInfo));
1598
1599         node_info->id = node->id;
1600         if (node->id) {
1601                 BLI_strncpy(node_info->id_name, node->id->name, sizeof(node_info->id_name));
1602                 if (node->id->lib) {
1603                         BLI_strncpy(node_info->library_name, node->id->lib->filepath, sizeof(node_info->library_name));
1604                 }
1605                 else {
1606                         node_info->library_name[0] = '\0';
1607                 }
1608         }
1609         else {
1610                 node_info->id_name[0] = '\0';
1611                 node_info->library_name[0] = '\0';
1612         }
1613         BLI_addtail(&node_clipboard.nodes_extra_info, node_info);
1614         /* end extra info */
1615 #endif  /* USE_NODE_CB_VALIDATE */
1616
1617         /* add node */
1618         BLI_addtail(&node_clipboard.nodes, node);
1619
1620 }
1621
1622 void BKE_node_clipboard_add_link(bNodeLink *link)
1623 {
1624         BLI_addtail(&node_clipboard.links, link);
1625 }
1626
1627 const ListBase *BKE_node_clipboard_get_nodes(void)
1628 {
1629         return &node_clipboard.nodes;
1630 }
1631
1632 const ListBase *BKE_node_clipboard_get_links(void)
1633 {
1634         return &node_clipboard.links;
1635 }
1636
1637 int BKE_node_clipboard_get_type(void)
1638 {
1639         return node_clipboard.type;
1640 }
1641
1642 /* ************** dependency stuff *********** */
1643
1644 /* node is guaranteed to be not checked before */
1645 static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort)
1646 {
1647         bNode *fromnode;
1648         bNodeLink *link;
1649         int level = 0xFFF;
1650         
1651         node->done = TRUE;
1652         
1653         /* check linked nodes */
1654         for (link = ntree->links.first; link; link = link->next) {
1655                 if (link->tonode == node) {
1656                         fromnode = link->fromnode;
1657                         if (fromnode) {
1658                                 if (fromnode->done == 0)
1659                                         fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort);
1660                                 if (fromnode->level <= level)
1661                                         level = fromnode->level - 1;
1662                         }
1663                 }
1664         }
1665         
1666         /* check parent node */
1667         if (node->parent) {
1668                 if (node->parent->done == 0)
1669                         node->parent->level = node_get_deplist_recurs(ntree, node->parent, nsort);
1670                 if (node->parent->level <= level)
1671                         level = node->parent->level - 1;
1672         }
1673         
1674         if (nsort) {
1675                 **nsort = node;
1676                 (*nsort)++;
1677         }
1678         
1679         return level;
1680 }
1681
1682 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
1683 {
1684         bNode *node, **nsort;
1685         
1686         *totnodes = 0;
1687         
1688         /* first clear data */
1689         for (node = ntree->nodes.first; node; node = node->next) {
1690                 node->done = FALSE;
1691                 (*totnodes)++;
1692         }
1693         if (*totnodes == 0) {
1694                 *deplist = NULL;
1695                 return;
1696         }
1697         
1698         nsort = *deplist = MEM_callocN((*totnodes) * sizeof(bNode *), "sorted node array");
1699         
1700         /* recursive check */
1701         for (node = ntree->nodes.first; node; node = node->next) {
1702                 if (node->done == 0) {
1703                         node->level = node_get_deplist_recurs(ntree, node, &nsort);
1704                 }
1705         }
1706 }
1707
1708 /* only updates node->level for detecting cycles links */
1709 static void ntree_update_node_level(bNodeTree *ntree)
1710 {
1711         bNode *node;
1712         
1713         /* first clear tag */
1714         for (node = ntree->nodes.first; node; node = node->next) {
1715                 node->done = FALSE;
1716         }
1717         
1718         /* recursive check */
1719         for (node = ntree->nodes.first; node; node = node->next) {
1720                 if (node->done == 0) {
1721                         node->level = node_get_deplist_recurs(ntree, node, NULL);
1722                 }
1723         }
1724 }
1725
1726 static void ntree_update_link_pointers(bNodeTree *ntree)
1727 {
1728         bNode *node;
1729         bNodeSocket *sock;
1730         bNodeLink *link;
1731         
1732         /* first clear data */
1733         for (node = ntree->nodes.first; node; node = node->next) {
1734                 for (sock = node->inputs.first; sock; sock = sock->next) {
1735                         sock->link = NULL;
1736                         sock->flag &= ~SOCK_IN_USE;
1737                 }
1738                 for (sock = node->outputs.first; sock; sock = sock->next) {
1739                         sock->flag &= ~SOCK_IN_USE;
1740                 }
1741         }
1742         for (sock = ntree->inputs.first; sock; sock = sock->next) {
1743                 sock->flag &= ~SOCK_IN_USE;
1744         }
1745         for (sock = ntree->outputs.first; sock; sock = sock->next) {
1746                 sock->link = NULL;
1747                 sock->flag &= ~SOCK_IN_USE;
1748         }
1749
1750         for (link = ntree->links.first; link; link = link->next) {
1751                 link->tosock->link = link;
1752                 
1753                 link->fromsock->flag |= SOCK_IN_USE;
1754                 link->tosock->flag |= SOCK_IN_USE;
1755         }
1756 }
1757
1758 static void ntree_validate_links(bNodeTree *ntree)
1759 {
1760         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1761         bNodeLink *link;
1762         
1763         for (link = ntree->links.first; link; link = link->next) {
1764                 link->flag |= NODE_LINK_VALID;
1765                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
1766                         link->flag &= ~NODE_LINK_VALID;
1767                 else if (ntreetype->validate_link) {
1768                         if (!ntreetype->validate_link(ntree, link))
1769                                 link->flag &= ~NODE_LINK_VALID;
1770                 }
1771         }
1772 }
1773
1774 static void ntree_verify_nodes_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree)
1775 {
1776         ID *id = (ID *)calldata;
1777         bNode *node;
1778         
1779         for (node = ntree->nodes.first; node; node = node->next)
1780                 if (node->typeinfo->verifyfunc)
1781                         node->typeinfo->verifyfunc(ntree, node, id);
1782 }
1783
1784 void ntreeVerifyNodes(struct Main *main, struct ID *id)
1785 {
1786         bNodeTreeType *ntreetype;
1787         bNodeTree *ntree;
1788         int n;
1789         
1790         for (n = 0; n < NUM_NTREE_TYPES; ++n) {
1791                 ntreetype = ntreeGetType(n);
1792                 if (ntreetype && ntreetype->foreach_nodetree)
1793                         ntreetype->foreach_nodetree(main, id, ntree_verify_nodes_cb);
1794         }
1795         for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
1796                 ntree_verify_nodes_cb(id, NULL, ntree);
1797 }
1798
1799 void ntreeUpdateTree(bNodeTree *ntree)
1800 {
1801         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1802         bNode *node;
1803         
1804         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
1805                 /* set the bNodeSocket->link pointers */
1806                 ntree_update_link_pointers(ntree);
1807                 
1808                 /* update the node level from link dependencies */
1809                 ntree_update_node_level(ntree);
1810         }
1811         
1812         /* update individual nodes */
1813         for (node = ntree->nodes.first; node; node = node->next) {
1814                 /* node tree update tags override individual node update flags */
1815                 if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
1816                         if (ntreetype->update_node)
1817                                 ntreetype->update_node(ntree, node);
1818                         else if (node->typeinfo->updatefunc)
1819                                 node->typeinfo->updatefunc(ntree, node);
1820                 }
1821         }
1822         
1823         /* check link validity */
1824         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES))
1825                 ntree_validate_links(ntree);
1826         
1827         /* generic tree update callback */
1828         if (ntreetype->update)
1829                 ntreetype->update(ntree);
1830         else {
1831                 /* Trees can be associated with a specific node type (i.e. group nodes),
1832                  * in that case a tree update function may be defined by that node type.
1833                  */
1834                 bNodeType *ntype = node_get_type(ntree, ntree->nodetype);
1835                 if (ntype && ntype->updatetreefunc)
1836                         ntype->updatetreefunc(ntree);
1837         }
1838         
1839         /* XXX hack, should be done by depsgraph!! */
1840         ntreeVerifyNodes(G.main, &ntree->id);
1841         
1842         /* clear update flags */
1843         for (node = ntree->nodes.first; node; node = node->next) {
1844                 node->update = 0;
1845         }
1846         ntree->update = 0;
1847 }
1848
1849 void nodeUpdate(bNodeTree *ntree, bNode *node)
1850 {
1851         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1852         
1853         if (ntreetype->update_node)
1854                 ntreetype->update_node(ntree, node);
1855         else if (node->typeinfo->updatefunc)
1856                 node->typeinfo->updatefunc(ntree, node);
1857         /* clear update flag */
1858         node->update = 0;
1859 }
1860
1861 int nodeUpdateID(bNodeTree *ntree, ID *id)
1862 {
1863         bNodeTreeType *ntreetype;
1864         bNode *node;
1865         int change = FALSE;
1866         
1867         if (ELEM(NULL, id, ntree))
1868                 return change;
1869         
1870         ntreetype = ntreeGetType(ntree->type);
1871         
1872         if (ntreetype->update_node) {
1873                 for (node = ntree->nodes.first; node; node = node->next) {
1874                         if (node->id == id) {
1875                                 change = TRUE;
1876                                 node->update |= NODE_UPDATE_ID;
1877                                 ntreetype->update_node(ntree, node);
1878                                 /* clear update flag */
1879                                 node->update = 0;
1880                         }
1881                 }
1882         }
1883         else {
1884                 for (node = ntree->nodes.first; node; node = node->next) {
1885                         if (node->id == id) {
1886                                 change = TRUE;
1887                                 node->update |= NODE_UPDATE_ID;
1888                                 if (node->typeinfo->updatefunc)
1889                                         node->typeinfo->updatefunc(ntree, node);
1890                                 /* clear update flag */
1891                                 node->update = 0;
1892                         }
1893                 }
1894         }
1895         
1896         return change;
1897 }
1898
1899
1900 /* ************* node type access ********** */
1901
1902 int nodeValid(bNodeTree *ntree, bNodeTemplate *ntemp)
1903 {
1904         bNodeType *ntype = node_get_type(ntree, ntemp->type);
1905         if (ntype) {
1906                 if (ntype->validfunc)
1907                         return ntype->validfunc(ntree, ntemp);
1908                 else
1909                         return 1;
1910         }
1911         else
1912                 return 0;
1913 }
1914
1915 const char *nodeLabel(bNode *node)
1916 {
1917         if (node->label[0] != '\0')
1918                 return node->label;
1919         else if (node->typeinfo->labelfunc)
1920                 return node->typeinfo->labelfunc(node);
1921         else
1922                 return IFACE_(node->typeinfo->name);
1923 }
1924
1925 struct bNodeTree *nodeGroupEditGet(struct bNode *node)
1926 {
1927         if (node->typeinfo->group_edit_get)
1928                 return node->typeinfo->group_edit_get(node);
1929         else
1930                 return NULL;
1931 }
1932
1933 struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit)
1934 {
1935         if (node->typeinfo->group_edit_set)
1936                 return node->typeinfo->group_edit_set(node, edit);
1937         else if (node->typeinfo->group_edit_get)
1938                 return node->typeinfo->group_edit_get(node);
1939         else
1940                 return NULL;
1941 }
1942
1943 void nodeGroupEditClear(struct bNode *node)
1944 {
1945         if (node->typeinfo->group_edit_clear)
1946                 node->typeinfo->group_edit_clear(node);
1947 }
1948
1949 struct bNodeTemplate nodeMakeTemplate(struct bNode *node)
1950 {
1951         bNodeTemplate ntemp;
1952         if (node->typeinfo->templatefunc)
1953                 return node->typeinfo->templatefunc(node);
1954         else {
1955                 ntemp.type = node->type;
1956                 return ntemp;
1957         }
1958 }
1959
1960 void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag)
1961 {
1962         memset(ntype, 0, sizeof(bNodeType));
1963
1964         ntype->type = type;
1965         BLI_strncpy(ntype->name, name, sizeof(ntype->name));
1966         ntype->nclass = nclass;
1967         ntype->flag = flag;
1968
1969         /* Default muting stuff. */
1970         if (ttype)
1971                 ntype->internal_connect = ttype->internal_connect;
1972
1973         /* default size values */
1974         ntype->width = 140;
1975         ntype->minwidth = 100;
1976         ntype->maxwidth = 320;
1977         ntype->height = 100;
1978         ntype->minheight = 30;
1979         ntype->maxheight = FLT_MAX;
1980 }
1981
1982 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
1983 {
1984         ntype->inputs = inputs;
1985         ntype->outputs = outputs;
1986 }
1987
1988 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp))
1989 {
1990         ntype->initfunc = initfunc;
1991 }
1992
1993 void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp))
1994 {
1995         ntype->validfunc = validfunc;
1996 }
1997
1998 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
1999 {
2000         ntype->width = width;
2001         ntype->minwidth = minwidth;
2002         if (maxwidth <= minwidth)
2003                 ntype->maxwidth = FLT_MAX;
2004         else
2005                 ntype->maxwidth = maxwidth;
2006 }
2007
2008 void node_type_storage(bNodeType *ntype, const char *storagename, void (*freestoragefunc)(struct bNode *), void (*copystoragefunc)(struct bNode *, struct bNode *))
2009 {
2010         if (storagename)
2011                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
2012         else
2013                 ntype->storagename[0] = '\0';
2014         ntype->copystoragefunc = copystoragefunc;
2015         ntype->freestoragefunc = freestoragefunc;
2016 }
2017
2018 void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *))
2019 {
2020         ntype->labelfunc = labelfunc;
2021 }
2022
2023 void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *))
2024 {
2025         ntype->templatefunc = templatefunc;
2026 }
2027
2028 void node_type_update(struct bNodeType *ntype,
2029                       void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
2030                       void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id))
2031 {
2032         ntype->updatefunc = updatefunc;
2033         ntype->verifyfunc = verifyfunc;
2034 }
2035
2036 void node_type_tree(struct bNodeType *ntype, void (*inittreefunc)(struct bNodeTree *), void (*updatetreefunc)(struct bNodeTree *))
2037 {
2038         ntype->inittreefunc = inittreefunc;
2039         ntype->updatetreefunc = updatetreefunc;
2040 }
2041
2042 void node_type_group_edit(struct bNodeType *ntype,
2043                           struct bNodeTree *(*group_edit_get)(struct bNode *node),
2044                           struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit),
2045                           void (*group_edit_clear)(struct bNode *node))
2046 {
2047         ntype->group_edit_get = group_edit_get;
2048         ntype->group_edit_set = group_edit_set;
2049         ntype->group_edit_clear = group_edit_clear;
2050 }
2051
2052 void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **))
2053 {
2054         ntype->execfunc = execfunc;
2055 }
2056
2057 void node_type_exec_new(struct bNodeType *ntype,
2058                         void *(*initexecfunc)(struct bNode *node),
2059                         void (*freeexecfunc)(struct bNode *node, void *nodedata),
2060                         void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **))
2061 {
2062         ntype->initexecfunc = initexecfunc;
2063         ntype->freeexecfunc = freeexecfunc;
2064         ntype->newexecfunc = newexecfunc;
2065 }
2066
2067 void node_type_internal_connect(bNodeType *ntype, ListBase (*internal_connect)(bNodeTree *, bNode *))
2068 {
2069         ntype->internal_connect = internal_connect;
2070 }
2071
2072 void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out))
2073 {
2074         ntype->gpufunc = gpufunc;
2075 }
2076
2077 void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out))
2078 {
2079         ntype->gpuextfunc = gpuextfunc;
2080 }
2081
2082 void node_type_compatibility(struct bNodeType *ntype, short compatibility)
2083 {
2084         ntype->compatibility = compatibility;
2085 }
2086
2087 static bNodeType *is_nodetype_registered(ListBase *typelist, int type) 
2088 {
2089         bNodeType *ntype = typelist->first;
2090         
2091         for (; ntype; ntype = ntype->next)
2092                 if (ntype->type == type)
2093                         return ntype;
2094         
2095         return NULL;
2096 }
2097
2098 void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype) 
2099 {
2100         ListBase *typelist = &(ttype->node_types);
2101         bNodeType *found = is_nodetype_registered(typelist, ntype->type);
2102         
2103         if (found == NULL)
2104                 BLI_addtail(typelist, ntype);
2105 }
2106
2107 static void registerCompositNodes(bNodeTreeType *ttype)
2108 {
2109         register_node_type_frame(ttype);
2110         register_node_type_reroute(ttype);
2111         
2112         register_node_type_cmp_group(ttype);
2113 //      register_node_type_cmp_forloop(ttype);
2114 //      register_node_type_cmp_whileloop(ttype);
2115         
2116         register_node_type_cmp_rlayers(ttype);
2117         register_node_type_cmp_image(ttype);
2118         register_node_type_cmp_texture(ttype);
2119         register_node_type_cmp_value(ttype);
2120         register_node_type_cmp_rgb(ttype);
2121         register_node_type_cmp_curve_time(ttype);
2122         register_node_type_cmp_movieclip(ttype);
2123         
2124         register_node_type_cmp_composite(ttype);
2125         register_node_type_cmp_viewer(ttype);
2126         register_node_type_cmp_splitviewer(ttype);
2127         register_node_type_cmp_output_file(ttype);
2128         register_node_type_cmp_view_levels(ttype);
2129         
2130         register_node_type_cmp_curve_rgb(ttype);
2131         register_node_type_cmp_mix_rgb(ttype);
2132         register_node_type_cmp_hue_sat(ttype);
2133         register_node_type_cmp_brightcontrast(ttype);
2134         register_node_type_cmp_gamma(ttype);
2135         register_node_type_cmp_invert(ttype);
2136         register_node_type_cmp_alphaover(ttype);
2137         register_node_type_cmp_zcombine(ttype);
2138         register_node_type_cmp_colorbalance(ttype);
2139         register_node_type_cmp_huecorrect(ttype);
2140         
2141         register_node_type_cmp_normal(ttype);
2142         register_node_type_cmp_curve_vec(ttype);
2143         register_node_type_cmp_map_value(ttype);
2144         register_node_type_cmp_normalize(ttype);
2145         
2146         register_node_type_cmp_filter(ttype);
2147         register_node_type_cmp_blur(ttype);
2148         register_node_type_cmp_dblur(ttype);
2149         register_node_type_cmp_bilateralblur(ttype);
2150         register_node_type_cmp_vecblur(ttype);
2151         register_node_type_cmp_dilateerode(ttype);
2152         register_node_type_cmp_inpaint(ttype);
2153         register_node_type_cmp_despeckle(ttype);
2154         register_node_type_cmp_defocus(ttype);
2155         
2156         register_node_type_cmp_valtorgb(ttype);
2157         register_node_type_cmp_rgbtobw(ttype);
2158         register_node_type_cmp_setalpha(ttype);
2159         register_node_type_cmp_idmask(ttype);
2160         register_node_type_cmp_math(ttype);
2161         register_node_type_cmp_seprgba(ttype);
2162         register_node_type_cmp_combrgba(ttype);
2163         register_node_type_cmp_sephsva(ttype);
2164         register_node_type_cmp_combhsva(ttype);
2165         register_node_type_cmp_sepyuva(ttype);
2166         register_node_type_cmp_combyuva(ttype);
2167         register_node_type_cmp_sepycca(ttype);
2168         register_node_type_cmp_combycca(ttype);
2169         register_node_type_cmp_premulkey(ttype);
2170         
2171         register_node_type_cmp_diff_matte(ttype);
2172         register_node_type_cmp_distance_matte(ttype);
2173         register_node_type_cmp_chroma_matte(ttype);
2174         register_node_type_cmp_color_matte(ttype);
2175         register_node_type_cmp_channel_matte(ttype);
2176         register_node_type_cmp_color_spill(ttype);
2177         register_node_type_cmp_luma_matte(ttype);
2178         register_node_type_cmp_doubleedgemask(ttype);
2179         register_node_type_cmp_keyingscreen(ttype);
2180         register_node_type_cmp_keying(ttype);
2181
2182         register_node_type_cmp_translate(ttype);
2183         register_node_type_cmp_rotate(ttype);
2184         register_node_type_cmp_scale(ttype);
2185         register_node_type_cmp_flip(ttype);
2186         register_node_type_cmp_crop(ttype);
2187         register_node_type_cmp_displace(ttype);
2188         register_node_type_cmp_mapuv(ttype);
2189         register_node_type_cmp_glare(ttype);
2190         register_node_type_cmp_tonemap(ttype);
2191         register_node_type_cmp_lensdist(ttype);
2192         register_node_type_cmp_transform(ttype);
2193         register_node_type_cmp_stabilize2d(ttype);
2194         register_node_type_cmp_moviedistortion(ttype);
2195
2196         register_node_type_cmp_colorcorrection(ttype);
2197         register_node_type_cmp_boxmask(ttype);
2198         register_node_type_cmp_ellipsemask(ttype);
2199         register_node_type_cmp_bokehimage(ttype);
2200         register_node_type_cmp_bokehblur(ttype);
2201         register_node_type_cmp_switch(ttype);
2202         register_node_type_cmp_pixelate(ttype);
2203
2204         register_node_type_cmp_mask(ttype);
2205         register_node_type_cmp_trackpos(ttype);
2206 }
2207
2208 static void registerShaderNodes(bNodeTreeType *ttype) 
2209 {
2210         register_node_type_frame(ttype);
2211         register_node_type_reroute(ttype);
2212         
2213         register_node_type_sh_group(ttype);
2214         //register_node_type_sh_forloop(ttype);
2215         //register_node_type_sh_whileloop(ttype);
2216
2217         register_node_type_sh_output(ttype);
2218         register_node_type_sh_material(ttype);
2219         register_node_type_sh_camera(ttype);
2220         register_node_type_sh_gamma(ttype);
2221         register_node_type_sh_brightcontrast(ttype);
2222         register_node_type_sh_value(ttype);
2223         register_node_type_sh_rgb(ttype);
2224         register_node_type_sh_mix_rgb(ttype);
2225         register_node_type_sh_valtorgb(ttype);
2226         register_node_type_sh_rgbtobw(ttype);
2227         register_node_type_sh_texture(ttype);
2228         register_node_type_sh_normal(ttype);
2229         register_node_type_sh_geom(ttype);
2230         register_node_type_sh_mapping(ttype);
2231         register_node_type_sh_curve_vec(ttype);
2232         register_node_type_sh_curve_rgb(ttype);
2233         register_node_type_sh_math(ttype);
2234         register_node_type_sh_vect_math(ttype);
2235         register_node_type_sh_squeeze(ttype);
2236         register_node_type_sh_material_ext(ttype);
2237         register_node_type_sh_invert(ttype);
2238         register_node_type_sh_seprgb(ttype);
2239         register_node_type_sh_combrgb(ttype);
2240         register_node_type_sh_hue_sat(ttype);
2241
2242         register_node_type_sh_attribute(ttype);
2243         register_node_type_sh_geometry(ttype);
2244         register_node_type_sh_light_path(ttype);
2245         register_node_type_sh_light_falloff(ttype);
2246         register_node_type_sh_object_info(ttype);
2247         register_node_type_sh_fresnel(ttype);
2248         register_node_type_sh_layer_weight(ttype);
2249         register_node_type_sh_tex_coord(ttype);
2250         register_node_type_sh_particle_info(ttype);
2251         register_node_type_sh_bump(ttype);
2252
2253         register_node_type_sh_background(ttype);
2254         register_node_type_sh_bsdf_anisotropic(ttype);
2255         register_node_type_sh_bsdf_diffuse(ttype);
2256         register_node_type_sh_bsdf_glossy(ttype);
2257         register_node_type_sh_bsdf_glass(ttype);
2258         register_node_type_sh_bsdf_translucent(ttype);
2259         register_node_type_sh_bsdf_transparent(ttype);
2260         register_node_type_sh_bsdf_velvet(ttype);
2261         register_node_type_sh_emission(ttype);
2262         register_node_type_sh_holdout(ttype);
2263         //register_node_type_sh_volume_transparent(ttype);
2264         //register_node_type_sh_volume_isotropic(ttype);
2265         register_node_type_sh_mix_shader(ttype);
2266         register_node_type_sh_add_shader(ttype);
2267
2268         register_node_type_sh_output_lamp(ttype);
2269         register_node_type_sh_output_material(ttype);
2270         register_node_type_sh_output_world(ttype);
2271
2272         register_node_type_sh_tex_image(ttype);
2273         register_node_type_sh_tex_environment(ttype);
2274         register_node_type_sh_tex_sky(ttype);
2275         register_node_type_sh_tex_noise(ttype);
2276         register_node_type_sh_tex_wave(ttype);
2277         register_node_type_sh_tex_voronoi(ttype);
2278         register_node_type_sh_tex_musgrave(ttype);
2279         register_node_type_sh_tex_gradient(ttype);
2280         register_node_type_sh_tex_magic(ttype);
2281         register_node_type_sh_tex_checker(ttype);
2282         register_node_type_sh_tex_brick(ttype);
2283 }
2284
2285 static void registerTextureNodes(bNodeTreeType *ttype)
2286 {
2287         register_node_type_frame(ttype);
2288         register_node_type_reroute(ttype);
2289         
2290         register_node_type_tex_group(ttype);
2291 //      register_node_type_tex_forloop(ttype);
2292 //      register_node_type_tex_whileloop(ttype);
2293         
2294         register_node_type_tex_math(ttype);
2295         register_node_type_tex_mix_rgb(ttype);
2296         register_node_type_tex_valtorgb(ttype);
2297         register_node_type_tex_rgbtobw(ttype);
2298         register_node_type_tex_valtonor(ttype);
2299         register_node_type_tex_curve_rgb(ttype);
2300         register_node_type_tex_curve_time(ttype);
2301         register_node_type_tex_invert(ttype);
2302         register_node_type_tex_hue_sat(ttype);
2303         register_node_type_tex_coord(ttype);
2304         register_node_type_tex_distance(ttype);
2305         register_node_type_tex_compose(ttype);
2306         register_node_type_tex_decompose(ttype);
2307         
2308         register_node_type_tex_output(ttype);
2309         register_node_type_tex_viewer(ttype);
2310         
2311         register_node_type_tex_checker(ttype);
2312         register_node_type_tex_texture(ttype);
2313         register_node_type_tex_bricks(ttype);
2314         register_node_type_tex_image(ttype);
2315         
2316         register_node_type_tex_rotate(ttype);
2317         register_node_type_tex_translate(ttype);
2318         register_node_type_tex_scale(ttype);
2319         register_node_type_tex_at(ttype);
2320         
2321         register_node_type_tex_proc_voronoi(ttype);
2322         register_node_type_tex_proc_blend(ttype);
2323         register_node_type_tex_proc_magic(ttype);
2324         register_node_type_tex_proc_marble(ttype);
2325         register_node_type_tex_proc_clouds(ttype);
2326         register_node_type_tex_proc_wood(ttype);
2327         register_node_type_tex_proc_musgrave(ttype);
2328         register_node_type_tex_proc_noise(ttype);
2329         register_node_type_tex_proc_stucci(ttype);
2330         register_node_type_tex_proc_distnoise(ttype);
2331 }
2332
2333 static void free_typeinfos(ListBase *list)
2334 {
2335         bNodeType *ntype, *next;
2336         for (ntype = list->first; ntype; ntype = next) {
2337                 next = ntype->next;
2338
2339                 if (ntype->needs_free)
2340                         MEM_freeN(ntype);
2341         }
2342 }
2343
2344 void init_nodesystem(void) 
2345 {
2346         /* init clipboard */
2347         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
2348         node_clipboard.links.first = node_clipboard.links.last = NULL;
2349         
2350         registerCompositNodes(ntreeGetType(NTREE_COMPOSIT));
2351         registerShaderNodes(ntreeGetType(NTREE_SHADER));
2352         registerTextureNodes(ntreeGetType(NTREE_TEXTURE));
2353 }
2354
2355 void free_nodesystem(void) 
2356 {
2357         free_typeinfos(&ntreeGetType(NTREE_COMPOSIT)->node_types);
2358         free_typeinfos(&ntreeGetType(NTREE_SHADER)->node_types);
2359         free_typeinfos(&ntreeGetType(NTREE_TEXTURE)->node_types);
2360 }
2361
2362 /* called from BKE_scene_unlink, when deleting a scene goes over all scenes
2363  * other than the input, checks if they have render layer nodes referencing
2364  * the to-be-deleted scene, and resets them to NULL. */
2365
2366 /* XXX needs to get current scene then! */
2367 void clear_scene_in_nodes(Main *bmain, Scene *sce)
2368 {
2369         Scene *sce1;
2370         bNode *node;
2371
2372         for (sce1 = bmain->scene.first; sce1; sce1 = sce1->id.next) {
2373                 if (sce1 != sce) {
2374                         if (sce1->nodetree) {
2375                                 for (node = sce1->nodetree->nodes.first; node; node = node->next) {
2376                                         if (node->type == CMP_NODE_R_LAYERS) {
2377                                                 Scene *nodesce = (Scene *)node->id;
2378                                                 
2379                                                 if (nodesce == sce) node->id = NULL;
2380                                         }
2381                                 }
2382                         }
2383                 }
2384         }
2385 }