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