Simple preset function for setting common node sizes based on enum instead of explici...
[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(Main *bmain, 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(&bmain->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_SHADER:
1039                                 ntreeShaderEndExecTree(ntree->execdata, 1);
1040                                 break;
1041                         case NTREE_TEXTURE:
1042                                 ntreeTexEndExecTree(ntree->execdata, 1);
1043                                 break;
1044                 }
1045         }
1046         
1047         BKE_free_animdata((ID *)ntree);
1048         
1049         id_us_min((ID *)ntree->gpd);
1050
1051         BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
1052         
1053         for (node = ntree->nodes.first; node; node = next) {
1054                 next = node->next;
1055
1056                 /* ntreeUserIncrefID inline */
1057
1058                 /* XXX, this is correct, however when freeing the entire database
1059                  * this ends up accessing freed data which isn't properly unlinking
1060                  * its self from scene nodes, SO - for now prefer invalid usercounts
1061                  * on free rather then bad memory access - Campbell */
1062 #if 0
1063                 if (do_id_user) {
1064                         id_us_min(node->id);
1065                 }
1066 #else
1067                 (void)do_id_user;
1068 #endif
1069
1070                 nodeFreeNode(ntree, node);
1071         }
1072         
1073         for (sock = ntree->inputs.first; sock; sock = sock->next)
1074                 node_socket_free_default_value(sock->type, sock->default_value);
1075         BLI_freelistN(&ntree->inputs);
1076         for (sock = ntree->outputs.first; sock; sock = sock->next)
1077                 node_socket_free_default_value(sock->type, sock->default_value);
1078         BLI_freelistN(&ntree->outputs);
1079         
1080         /* if ntree is not part of library, free the libblock data explicitly */
1081         for (tntree = G.main->nodetree.first; tntree; tntree = tntree->id.next)
1082                 if (tntree == ntree)
1083                         break;
1084         if (tntree == NULL) {
1085                 BKE_libblock_free_data(&ntree->id);
1086         }
1087 }
1088 /* same as ntreeFreeTree_ex but always manage users */
1089 void ntreeFreeTree(bNodeTree *ntree)
1090 {
1091         ntreeFreeTree_ex(ntree, TRUE);
1092 }
1093
1094 void ntreeFreeCache(bNodeTree *ntree)
1095 {
1096         bNodeTreeType *treetype;
1097         
1098         if (ntree == NULL) return;
1099         
1100         treetype = ntreeGetType(ntree->type);
1101         if (treetype->free_cache)
1102                 treetype->free_cache(ntree);
1103 }
1104
1105 void ntreeSetOutput(bNodeTree *ntree)
1106 {
1107         bNode *node;
1108
1109         /* find the active outputs, might become tree type dependent handler */
1110         for (node = ntree->nodes.first; node; node = node->next) {
1111                 if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1112                         bNode *tnode;
1113                         int output = 0;
1114                         
1115                         /* we need a check for which output node should be tagged like this, below an exception */
1116                         if (node->type == CMP_NODE_OUTPUT_FILE)
1117                                 continue;
1118
1119                         /* there is more types having output class, each one is checked */
1120                         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1121                                 if (tnode->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1122                                         
1123                                         if (ntree->type == NTREE_COMPOSIT) {
1124                                                         
1125                                                 /* same type, exception for viewer */
1126                                                 if (tnode->type == node->type ||
1127                                                     (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
1128                                                      ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)))
1129                                                 {
1130                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1131                                                                 output++;
1132                                                                 if (output > 1)
1133                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1134                                                         }
1135                                                 }
1136                                         }
1137                                         else {
1138                                                 /* same type */
1139                                                 if (tnode->type == node->type) {
1140                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1141                                                                 output++;
1142                                                                 if (output > 1)
1143                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1144                                                         }
1145                                                 }
1146                                         }
1147                                 }
1148                         }
1149                         if (output == 0)
1150                                 node->flag |= NODE_DO_OUTPUT;
1151                 }
1152         }
1153         
1154         /* here we could recursively set which nodes have to be done,
1155          * might be different for editor or for "real" use... */
1156 }
1157
1158 bNodeTree *ntreeFromID(ID *id)
1159 {
1160         switch (GS(id->name)) {
1161                 case ID_MA:  return ((Material *)id)->nodetree;
1162                 case ID_LA:  return ((Lamp *)id)->nodetree;
1163                 case ID_WO:  return ((World *)id)->nodetree;
1164                 case ID_TE:  return ((Tex *)id)->nodetree;
1165                 case ID_SCE: return ((Scene *)id)->nodetree;
1166                 default: return NULL;
1167         }
1168 }
1169
1170 typedef struct MakeLocalCallData {
1171         ID *group_id;
1172         ID *new_id;
1173         int lib, local;
1174 } MakeLocalCallData;
1175
1176 static void ntreeMakeLocal_CheckLocal(void *calldata, ID *owner_id, bNodeTree *ntree)
1177 {
1178         MakeLocalCallData *cd = (MakeLocalCallData *)calldata;
1179         bNode *node;
1180         
1181         /* find if group is in tree */
1182         for (node = ntree->nodes.first; node; node = node->next) {
1183                 if (node->id == cd->group_id) {
1184                         if (owner_id->lib) {
1185                                 cd->lib = TRUE;
1186                         }
1187                         else {
1188                                 cd->local = TRUE;
1189                         }
1190                 }
1191         }
1192 }
1193
1194 static void ntreeMakeLocal_LinkNew(void *calldata, ID *owner_id, bNodeTree *ntree)
1195 {
1196         MakeLocalCallData *cd = (MakeLocalCallData *)calldata;
1197         bNode *node;
1198         
1199         /* find if group is in tree */
1200         for (node = ntree->nodes.first; node; node = node->next) {
1201                 if (node->id == cd->group_id) {
1202                         if (owner_id->lib == NULL) {
1203                                 node->id = cd->new_id;
1204                                 cd->new_id->us++;
1205                                 cd->group_id->us--;
1206                         }
1207                 }
1208         }
1209 }
1210
1211 void ntreeMakeLocal(bNodeTree *ntree)
1212 {
1213         Main *bmain = G.main;
1214         bNodeTreeType *treetype = ntreeGetType(ntree->type);
1215         MakeLocalCallData cd;
1216         
1217         /* - only lib users: do nothing
1218          * - only local users: set flag
1219          * - mixed: make copy
1220          */
1221         
1222         if (ntree->id.lib == NULL) return;
1223         if (ntree->id.us == 1) {
1224                 id_clear_lib_data(bmain, (ID *)ntree);
1225                 return;
1226         }
1227         
1228         /* now check users of groups... again typedepending, callback... */
1229         cd.group_id = &ntree->id;
1230         cd.new_id = NULL;
1231         cd.local = 0;
1232         cd.lib = 0;
1233         
1234         treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_CheckLocal);
1235         
1236         /* if all users are local, we simply make tree local */
1237         if (cd.local && cd.lib == 0) {
1238                 id_clear_lib_data(bmain, (ID *)ntree);
1239         }
1240         else if (cd.local && cd.lib) {
1241                 /* this is the mixed case, we copy the tree and assign it to local users */
1242                 bNodeTree *newtree = ntreeCopyTree(ntree);
1243                 
1244                 newtree->id.us = 0;
1245                 
1246
1247                 cd.new_id = &newtree->id;
1248                 treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_LinkNew);
1249         }
1250 }
1251
1252 int ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
1253 {
1254         bNode *node = ntree->nodes.first;
1255         for (; node; node = node->next)
1256                 if (node == testnode)
1257                         return 1;
1258         return 0;
1259 }
1260
1261 int ntreeOutputExists(bNode *node, bNodeSocket *testsock)
1262 {
1263         bNodeSocket *sock = node->outputs.first;
1264         for (; sock; sock = sock->next)
1265                 if (sock == testsock)
1266                         return 1;
1267         return 0;
1268 }
1269
1270 /* returns localized tree for execution in threads */
1271 bNodeTree *ntreeLocalize(bNodeTree *ntree)
1272 {
1273         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1274
1275         bNodeTree *ltree;
1276         bNode *node;
1277         
1278         bAction *action_backup = NULL, *tmpact_backup = NULL;
1279         
1280         /* Workaround for copying an action on each render!
1281          * set action to NULL so animdata actions don't get copied */
1282         AnimData *adt = BKE_animdata_from_id(&ntree->id);
1283
1284         if (adt) {
1285                 action_backup = adt->action;
1286                 tmpact_backup = adt->tmpact;
1287
1288                 adt->action = NULL;
1289                 adt->tmpact = NULL;
1290         }
1291
1292         /* node copy func */
1293         ltree = ntreeCopyTree_internal(ntree, FALSE, FALSE);
1294
1295         if (adt) {
1296                 AnimData *ladt = BKE_animdata_from_id(&ltree->id);
1297
1298                 adt->action = ladt->action = action_backup;
1299                 adt->tmpact = ladt->tmpact = tmpact_backup;
1300
1301                 if (action_backup) action_backup->id.us++;
1302                 if (tmpact_backup) tmpact_backup->id.us++;
1303                 
1304         }
1305         /* end animdata uglyness */
1306
1307         /* ensures only a single output node is enabled */
1308         ntreeSetOutput(ntree);
1309
1310         for (node = ntree->nodes.first; node; node = node->next) {
1311                 /* store new_node pointer to original */
1312                 node->new_node->new_node = node;
1313         }
1314
1315         if (ntreetype->localize)
1316                 ntreetype->localize(ltree, ntree);
1317
1318         return ltree;
1319 }
1320
1321 /* sync local composite with real tree */
1322 /* local tree is supposed to be running, be careful moving previews! */
1323 /* is called by jobs manager, outside threads, so it doesnt happen during draw */
1324 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
1325 {
1326         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1327
1328         if (ntreetype->local_sync)
1329                 ntreetype->local_sync(localtree, ntree);
1330 }
1331
1332 /* merge local tree results back, and free local tree */
1333 /* we have to assume the editor already changed completely */
1334 void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
1335 {
1336         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1337         bNode *lnode;
1338         
1339         /* move over the compbufs and previews */
1340         for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) {
1341                 if (ntreeNodeExists(ntree, lnode->new_node)) {
1342                         if (lnode->preview && lnode->preview->rect) {
1343                                 nodeFreePreview(lnode->new_node);
1344                                 lnode->new_node->preview = lnode->preview;
1345                                 lnode->preview = NULL;
1346                         }
1347                 }
1348         }
1349
1350         if (ntreetype->local_merge)
1351                 ntreetype->local_merge(localtree, ntree);
1352
1353         ntreeFreeTree_ex(localtree, FALSE);
1354         MEM_freeN(localtree);
1355 }
1356
1357 /* ************ find stuff *************** */
1358
1359 int ntreeHasType(bNodeTree *ntree, int type)
1360 {
1361         bNode *node;
1362         
1363         if (ntree)
1364                 for (node = ntree->nodes.first; node; node = node->next)
1365                         if (node->type == type)
1366                                 return 1;
1367         return 0;
1368 }
1369
1370 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
1371 {
1372         bNodeLink *link;
1373         
1374         for (link = ntree->links.first; link; link = link->next) {
1375                 if (link->fromsock == from && link->tosock == to)
1376                         return link;
1377                 if (link->fromsock == to && link->tosock == from) /* hrms? */
1378                         return link;
1379         }
1380         return NULL;
1381 }
1382
1383 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
1384 {
1385         bNodeLink *link;
1386         int tot = 0;
1387         
1388         for (link = ntree->links.first; link; link = link->next) {
1389                 if (link->fromsock == sock || link->tosock == sock)
1390                         tot++;
1391         }
1392         return tot;
1393 }
1394
1395 bNode *nodeGetActive(bNodeTree *ntree)
1396 {
1397         bNode *node;
1398         
1399         if (ntree == NULL) return NULL;
1400         
1401         for (node = ntree->nodes.first; node; node = node->next)
1402                 if (node->flag & NODE_ACTIVE)
1403                         break;
1404         return node;
1405 }
1406
1407 /* two active flags, ID nodes have special flag for buttons display */
1408 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
1409 {
1410         bNode *node;
1411         
1412         if (ntree == NULL) return NULL;
1413
1414         /* check for group edit */
1415         for (node = ntree->nodes.first; node; node = node->next)
1416                 if (node->flag & NODE_GROUP_EDIT)
1417                         break;
1418
1419         if (node)
1420                 ntree = (bNodeTree *)node->id;
1421         
1422         /* now find active node with this id */
1423         for (node = ntree->nodes.first; node; node = node->next)
1424                 if (node->id && GS(node->id->name) == idtype)
1425                         if (node->flag & NODE_ACTIVE_ID)
1426                                 break;
1427
1428         return node;
1429 }
1430
1431 int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
1432 {
1433         bNode *node;
1434         int ok = FALSE;
1435
1436         if (ntree == NULL) return ok;
1437
1438         /* check for group edit */
1439         for (node = ntree->nodes.first; node; node = node->next)
1440                 if (node->flag & NODE_GROUP_EDIT)
1441                         break;
1442
1443         if (node)
1444                 ntree = (bNodeTree *)node->id;
1445
1446         /* now find active node with this id */
1447         for (node = ntree->nodes.first; node; node = node->next) {
1448                 if (node->id && GS(node->id->name) == idtype) {
1449                         if (id && ok == FALSE && node->id == id) {
1450                                 node->flag |= NODE_ACTIVE_ID;
1451                                 ok = TRUE;
1452                         }
1453                         else {
1454                                 node->flag &= ~NODE_ACTIVE_ID;
1455                         }
1456                 }
1457         }
1458
1459         return ok;
1460 }
1461
1462
1463 /* two active flags, ID nodes have special flag for buttons display */
1464 void nodeClearActiveID(bNodeTree *ntree, short idtype)
1465 {
1466         bNode *node;
1467         
1468         if (ntree == NULL) return;
1469         
1470         for (node = ntree->nodes.first; node; node = node->next)
1471                 if (node->id && GS(node->id->name) == idtype)
1472                         node->flag &= ~NODE_ACTIVE_ID;
1473 }
1474
1475 void nodeClearActive(bNodeTree *ntree)
1476 {
1477         bNode *node;
1478
1479         if (ntree == NULL) return;
1480
1481         for (node = ntree->nodes.first; node; node = node->next)
1482                 node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_ID);
1483 }
1484
1485
1486 /* two active flags, ID nodes have special flag for buttons display */
1487 void nodeSetActive(bNodeTree *ntree, bNode *node)
1488 {
1489         bNode *tnode;
1490         
1491         /* make sure only one node is active, and only one per ID type */
1492         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1493                 tnode->flag &= ~NODE_ACTIVE;
1494                 
1495                 if (node->id && tnode->id) {
1496                         if (GS(node->id->name) == GS(tnode->id->name))
1497                                 tnode->flag &= ~NODE_ACTIVE_ID;
1498                 }
1499                 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1500                         tnode->flag &= ~NODE_ACTIVE_TEXTURE;
1501         }
1502         
1503         node->flag |= NODE_ACTIVE;
1504         if (node->id)
1505                 node->flag |= NODE_ACTIVE_ID;
1506         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1507                 node->flag |= NODE_ACTIVE_TEXTURE;
1508 }
1509
1510 int nodeSocketIsHidden(bNodeSocket *sock)
1511 {
1512         return ((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0);
1513 }
1514
1515 void nodeSocketSetType(bNodeSocket *sock, int type)
1516 {
1517         int old_type = sock->type;
1518         void *old_default_value = sock->default_value;
1519         
1520         sock->type = type;
1521         
1522         sock->default_value = node_socket_make_default_value(sock->type);
1523         node_socket_init_default_value(type, sock->default_value);
1524         node_socket_convert_default_value(sock->type, sock->default_value, old_type, old_default_value);
1525         node_socket_free_default_value(old_type, old_default_value);
1526 }
1527
1528 /* ************** Node Clipboard *********** */
1529
1530 #define USE_NODE_CB_VALIDATE
1531
1532 #ifdef USE_NODE_CB_VALIDATE
1533 /**
1534  * This data structure is to validate the node on creation,
1535  * otherwise we may reference missing data.
1536  *
1537  * Currently its only used for ID's, but nodes may one day
1538  * reference other pointers which need validation.
1539  */
1540 typedef struct bNodeClipboardExtraInfo {
1541         struct bNodeClipboardExtraInfo *next, *prev;
1542         ID  *id;
1543         char id_name[MAX_ID_NAME];
1544         char library_name[FILE_MAX];
1545 } bNodeClipboardExtraInfo;
1546 #endif  /* USE_NODE_CB_VALIDATE */
1547
1548
1549 typedef struct bNodeClipboard {
1550         ListBase nodes;
1551
1552 #ifdef USE_NODE_CB_VALIDATE
1553         ListBase nodes_extra_info;
1554 #endif
1555
1556         ListBase links;
1557         int type;
1558 } bNodeClipboard;
1559
1560 bNodeClipboard node_clipboard = {{0}};
1561
1562 void BKE_node_clipboard_init(struct bNodeTree *ntree)
1563 {
1564         node_clipboard.type = ntree->type;
1565 }
1566
1567 void BKE_node_clipboard_clear(void)
1568 {
1569         bNode *node, *node_next;
1570         bNodeLink *link, *link_next;
1571         
1572         for (link = node_clipboard.links.first; link; link = link_next) {
1573                 link_next = link->next;
1574                 nodeRemLink(NULL, link);
1575         }
1576         node_clipboard.links.first = node_clipboard.links.last = NULL;
1577         
1578         for (node = node_clipboard.nodes.first; node; node = node_next) {
1579                 node_next = node->next;
1580                 nodeFreeNode(NULL, node);
1581         }
1582         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
1583
1584 #ifdef USE_NODE_CB_VALIDATE
1585         BLI_freelistN(&node_clipboard.nodes_extra_info);
1586 #endif
1587 }
1588
1589 /* return FALSE when one or more ID's are lost */
1590 int BKE_node_clipboard_validate(void)
1591 {
1592         int ok = TRUE;
1593
1594 #ifdef USE_NODE_CB_VALIDATE
1595         bNodeClipboardExtraInfo *node_info;
1596         bNode *node;
1597
1598
1599         /* lists must be aligned */
1600         BLI_assert(BLI_countlist(&node_clipboard.nodes) ==
1601                    BLI_countlist(&node_clipboard.nodes_extra_info));
1602
1603         for (node = node_clipboard.nodes.first, node_info = node_clipboard.nodes_extra_info.first;
1604              node;
1605              node = node->next, node_info = node_info->next)
1606         {
1607                 /* validate the node against the stored node info */
1608
1609                 /* re-assign each loop since we may clear,
1610                  * open a new file where the ID is valid, and paste again */
1611                 node->id = node_info->id;
1612
1613                 /* currently only validate the ID */
1614                 if (node->id) {
1615                         ListBase *lb = which_libbase(G.main, GS(node_info->id_name));
1616                         BLI_assert(lb != NULL);
1617
1618                         if (BLI_findindex(lb, node_info->id) == -1) {
1619                                 /* may assign NULL */
1620                                 node->id = BLI_findstring(lb, node_info->id_name + 2, offsetof(ID, name) + 2);
1621
1622                                 if (node->id == NULL) {
1623                                         ok = FALSE;
1624                                 }
1625                         }
1626                 }
1627         }
1628 #endif  /* USE_NODE_CB_VALIDATE */
1629
1630         return ok;
1631 }
1632
1633 void BKE_node_clipboard_add_node(bNode *node)
1634 {
1635 #ifdef USE_NODE_CB_VALIDATE
1636         /* add extra info */
1637         bNodeClipboardExtraInfo *node_info = MEM_mallocN(sizeof(bNodeClipboardExtraInfo), "bNodeClipboardExtraInfo");
1638
1639         node_info->id = node->id;
1640         if (node->id) {
1641                 BLI_strncpy(node_info->id_name, node->id->name, sizeof(node_info->id_name));
1642                 if (node->id->lib) {
1643                         BLI_strncpy(node_info->library_name, node->id->lib->filepath, sizeof(node_info->library_name));
1644                 }
1645                 else {
1646                         node_info->library_name[0] = '\0';
1647                 }
1648         }
1649         else {
1650                 node_info->id_name[0] = '\0';
1651                 node_info->library_name[0] = '\0';
1652         }
1653         BLI_addtail(&node_clipboard.nodes_extra_info, node_info);
1654         /* end extra info */
1655 #endif  /* USE_NODE_CB_VALIDATE */
1656
1657         /* add node */
1658         BLI_addtail(&node_clipboard.nodes, node);
1659
1660 }
1661
1662 void BKE_node_clipboard_add_link(bNodeLink *link)
1663 {
1664         BLI_addtail(&node_clipboard.links, link);
1665 }
1666
1667 const ListBase *BKE_node_clipboard_get_nodes(void)
1668 {
1669         return &node_clipboard.nodes;
1670 }
1671
1672 const ListBase *BKE_node_clipboard_get_links(void)
1673 {
1674         return &node_clipboard.links;
1675 }
1676
1677 int BKE_node_clipboard_get_type(void)
1678 {
1679         return node_clipboard.type;
1680 }
1681
1682 /* ************** dependency stuff *********** */
1683
1684 /* node is guaranteed to be not checked before */
1685 static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort)
1686 {
1687         bNode *fromnode;
1688         bNodeLink *link;
1689         int level = 0xFFF;
1690         
1691         node->done = TRUE;
1692         
1693         /* check linked nodes */
1694         for (link = ntree->links.first; link; link = link->next) {
1695                 if (link->tonode == node) {
1696                         fromnode = link->fromnode;
1697                         if (fromnode) {
1698                                 if (fromnode->done == 0)
1699                                         fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort);
1700                                 if (fromnode->level <= level)
1701                                         level = fromnode->level - 1;
1702                         }
1703                 }
1704         }
1705         
1706         /* check parent node */
1707         if (node->parent) {
1708                 if (node->parent->done == 0)
1709                         node->parent->level = node_get_deplist_recurs(ntree, node->parent, nsort);
1710                 if (node->parent->level <= level)
1711                         level = node->parent->level - 1;
1712         }
1713         
1714         if (nsort) {
1715                 **nsort = node;
1716                 (*nsort)++;
1717         }
1718         
1719         return level;
1720 }
1721
1722 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
1723 {
1724         bNode *node, **nsort;
1725         
1726         *totnodes = 0;
1727         
1728         /* first clear data */
1729         for (node = ntree->nodes.first; node; node = node->next) {
1730                 node->done = FALSE;
1731                 (*totnodes)++;
1732         }
1733         if (*totnodes == 0) {
1734                 *deplist = NULL;
1735                 return;
1736         }
1737         
1738         nsort = *deplist = MEM_callocN((*totnodes) * sizeof(bNode *), "sorted node array");
1739         
1740         /* recursive check */
1741         for (node = ntree->nodes.first; node; node = node->next) {
1742                 if (node->done == 0) {
1743                         node->level = node_get_deplist_recurs(ntree, node, &nsort);
1744                 }
1745         }
1746 }
1747
1748 /* only updates node->level for detecting cycles links */
1749 static void ntree_update_node_level(bNodeTree *ntree)
1750 {
1751         bNode *node;
1752         
1753         /* first clear tag */
1754         for (node = ntree->nodes.first; node; node = node->next) {
1755                 node->done = FALSE;
1756         }
1757         
1758         /* recursive check */
1759         for (node = ntree->nodes.first; node; node = node->next) {
1760                 if (node->done == 0) {
1761                         node->level = node_get_deplist_recurs(ntree, node, NULL);
1762                 }
1763         }
1764 }
1765
1766 static void ntree_update_link_pointers(bNodeTree *ntree)
1767 {
1768         bNode *node;
1769         bNodeSocket *sock;
1770         bNodeLink *link;
1771         
1772         /* first clear data */
1773         for (node = ntree->nodes.first; node; node = node->next) {
1774                 for (sock = node->inputs.first; sock; sock = sock->next) {
1775                         sock->link = NULL;
1776                         sock->flag &= ~SOCK_IN_USE;
1777                 }
1778                 for (sock = node->outputs.first; sock; sock = sock->next) {
1779                         sock->flag &= ~SOCK_IN_USE;
1780                 }
1781         }
1782         for (sock = ntree->inputs.first; sock; sock = sock->next) {
1783                 sock->flag &= ~SOCK_IN_USE;
1784         }
1785         for (sock = ntree->outputs.first; sock; sock = sock->next) {
1786                 sock->link = NULL;
1787                 sock->flag &= ~SOCK_IN_USE;
1788         }
1789
1790         for (link = ntree->links.first; link; link = link->next) {
1791                 link->tosock->link = link;
1792                 
1793                 link->fromsock->flag |= SOCK_IN_USE;
1794                 link->tosock->flag |= SOCK_IN_USE;
1795         }
1796 }
1797
1798 static void ntree_validate_links(bNodeTree *ntree)
1799 {
1800         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1801         bNodeLink *link;
1802         
1803         for (link = ntree->links.first; link; link = link->next) {
1804                 link->flag |= NODE_LINK_VALID;
1805                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
1806                         link->flag &= ~NODE_LINK_VALID;
1807                 else if (ntreetype->validate_link) {
1808                         if (!ntreetype->validate_link(ntree, link))
1809                                 link->flag &= ~NODE_LINK_VALID;
1810                 }
1811         }
1812 }
1813
1814 static void ntree_verify_nodes_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree)
1815 {
1816         ID *id = (ID *)calldata;
1817         bNode *node;
1818         
1819         for (node = ntree->nodes.first; node; node = node->next)
1820                 if (node->typeinfo->verifyfunc)
1821                         node->typeinfo->verifyfunc(ntree, node, id);
1822 }
1823
1824 void ntreeVerifyNodes(struct Main *main, struct ID *id)
1825 {
1826         bNodeTreeType *ntreetype;
1827         bNodeTree *ntree;
1828         int n;
1829         
1830         for (n = 0; n < NUM_NTREE_TYPES; ++n) {
1831                 ntreetype = ntreeGetType(n);
1832                 if (ntreetype && ntreetype->foreach_nodetree)
1833                         ntreetype->foreach_nodetree(main, id, ntree_verify_nodes_cb);
1834         }
1835         for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
1836                 ntree_verify_nodes_cb(id, NULL, ntree);
1837 }
1838
1839 void ntreeUpdateTree(bNodeTree *ntree)
1840 {
1841         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1842         bNode *node;
1843         
1844         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
1845                 /* set the bNodeSocket->link pointers */
1846                 ntree_update_link_pointers(ntree);
1847                 
1848                 /* update the node level from link dependencies */
1849                 ntree_update_node_level(ntree);
1850         }
1851         
1852         /* update individual nodes */
1853         for (node = ntree->nodes.first; node; node = node->next) {
1854                 /* node tree update tags override individual node update flags */
1855                 if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
1856                         if (ntreetype->update_node)
1857                                 ntreetype->update_node(ntree, node);
1858                         else if (node->typeinfo->updatefunc)
1859                                 node->typeinfo->updatefunc(ntree, node);
1860                         
1861                         nodeUpdateInternalLinks(ntree, node);
1862                 }
1863         }
1864         
1865         /* check link validity */
1866         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES))
1867                 ntree_validate_links(ntree);
1868         
1869         /* generic tree update callback */
1870         if (ntreetype->update)
1871                 ntreetype->update(ntree);
1872         else {
1873                 /* Trees can be associated with a specific node type (i.e. group nodes),
1874                  * in that case a tree update function may be defined by that node type.
1875                  */
1876                 bNodeType *ntype = node_get_type(ntree, ntree->nodetype);
1877                 if (ntype && ntype->updatetreefunc)
1878                         ntype->updatetreefunc(ntree);
1879         }
1880         
1881         /* XXX hack, should be done by depsgraph!! */
1882         ntreeVerifyNodes(G.main, &ntree->id);
1883         
1884         /* clear update flags */
1885         for (node = ntree->nodes.first; node; node = node->next) {
1886                 node->update = 0;
1887         }
1888         ntree->update = 0;
1889 }
1890
1891 void nodeUpdate(bNodeTree *ntree, bNode *node)
1892 {
1893         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1894         
1895         if (ntreetype->update_node)
1896                 ntreetype->update_node(ntree, node);
1897         else if (node->typeinfo->updatefunc)
1898                 node->typeinfo->updatefunc(ntree, node);
1899         
1900         nodeUpdateInternalLinks(ntree, node);
1901         
1902         /* clear update flag */
1903         node->update = 0;
1904 }
1905
1906 int nodeUpdateID(bNodeTree *ntree, ID *id)
1907 {
1908         bNodeTreeType *ntreetype;
1909         bNode *node;
1910         int change = FALSE;
1911         
1912         if (ELEM(NULL, id, ntree))
1913                 return change;
1914         
1915         ntreetype = ntreeGetType(ntree->type);
1916         
1917         if (ntreetype->update_node) {
1918                 for (node = ntree->nodes.first; node; node = node->next) {
1919                         if (node->id == id) {
1920                                 change = TRUE;
1921                                 node->update |= NODE_UPDATE_ID;
1922                                 ntreetype->update_node(ntree, node);
1923                                 /* clear update flag */
1924                                 node->update = 0;
1925                         }
1926                 }
1927         }
1928         else {
1929                 for (node = ntree->nodes.first; node; node = node->next) {
1930                         if (node->id == id) {
1931                                 change = TRUE;
1932                                 node->update |= NODE_UPDATE_ID;
1933                                 if (node->typeinfo->updatefunc)
1934                                         node->typeinfo->updatefunc(ntree, node);
1935                                 /* clear update flag */
1936                                 node->update = 0;
1937                         }
1938                 }
1939         }
1940         
1941         for (node = ntree->nodes.first; node; node = node->next) {
1942                 nodeUpdateInternalLinks(ntree, node);
1943         }
1944         
1945         return change;
1946 }
1947
1948 void nodeUpdateInternalLinks(bNodeTree *ntree, bNode *node)
1949 {
1950         BLI_freelistN(&node->internal_links);
1951         
1952         if (node->typeinfo && node->typeinfo->update_internal_links)
1953                 node->typeinfo->update_internal_links(ntree, node);
1954 }
1955
1956
1957 /* ************* node type access ********** */
1958
1959 int nodeValid(bNodeTree *ntree, bNodeTemplate *ntemp)
1960 {
1961         bNodeType *ntype = node_get_type(ntree, ntemp->type);
1962         if (ntype) {
1963                 if (ntype->validfunc)
1964                         return ntype->validfunc(ntree, ntemp);
1965                 else
1966                         return 1;
1967         }
1968         else
1969                 return 0;
1970 }
1971
1972 const char *nodeLabel(bNode *node)
1973 {
1974         if (node->label[0] != '\0')
1975                 return node->label;
1976         else if (node->typeinfo->labelfunc)
1977                 return node->typeinfo->labelfunc(node);
1978         else
1979                 return IFACE_(node->typeinfo->name);
1980 }
1981
1982 struct bNodeTree *nodeGroupEditGet(struct bNode *node)
1983 {
1984         if (node->typeinfo->group_edit_get)
1985                 return node->typeinfo->group_edit_get(node);
1986         else
1987                 return NULL;
1988 }
1989
1990 struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit)
1991 {
1992         if (node->typeinfo->group_edit_set)
1993                 return node->typeinfo->group_edit_set(node, edit);
1994         else if (node->typeinfo->group_edit_get)
1995                 return node->typeinfo->group_edit_get(node);
1996         else
1997                 return NULL;
1998 }
1999
2000 void nodeGroupEditClear(struct bNode *node)
2001 {
2002         if (node->typeinfo->group_edit_clear)
2003                 node->typeinfo->group_edit_clear(node);
2004 }
2005
2006 struct bNodeTemplate nodeMakeTemplate(struct bNode *node)
2007 {
2008         bNodeTemplate ntemp;
2009         if (node->typeinfo->templatefunc)
2010                 return node->typeinfo->templatefunc(node);
2011         else {
2012                 ntemp.type = node->type;
2013                 return ntemp;
2014         }
2015 }
2016
2017 void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag)
2018 {
2019         memset(ntype, 0, sizeof(bNodeType));
2020
2021         ntype->type = type;
2022         BLI_strncpy(ntype->name, name, sizeof(ntype->name));
2023         ntype->nclass = nclass;
2024         ntype->flag = flag;
2025
2026         /* Default muting stuff. */
2027         if (ttype)
2028                 ntype->update_internal_links = ttype->update_internal_links;
2029
2030         /* default size values */
2031         node_type_size_preset(ntype, NODE_SIZE_DEFAULT);
2032         
2033         ntype->height = 100;
2034         ntype->minheight = 30;
2035         ntype->maxheight = FLT_MAX;
2036 }
2037
2038 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
2039 {
2040         ntype->inputs = inputs;
2041         ntype->outputs = outputs;
2042 }
2043
2044 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp))
2045 {
2046         ntype->initfunc = initfunc;
2047 }
2048
2049 void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp))
2050 {
2051         ntype->validfunc = validfunc;
2052 }
2053
2054 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
2055 {
2056         ntype->width = width;
2057         ntype->minwidth = minwidth;
2058         if (maxwidth <= minwidth)
2059                 ntype->maxwidth = FLT_MAX;
2060         else
2061                 ntype->maxwidth = maxwidth;
2062 }
2063
2064 void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size)
2065 {
2066         switch (size) {
2067                 case NODE_SIZE_DEFAULT:
2068                         node_type_size(ntype, 140, 100, 320);
2069                         break;
2070                 case NODE_SIZE_SMALL:
2071                         node_type_size(ntype, 100, 80, 320);
2072                         break;
2073                 case NODE_SIZE_LARGE:
2074                         node_type_size(ntype, 140, 120, 500);
2075                         break;
2076         }
2077 }
2078
2079 void node_type_storage(bNodeType *ntype, const char *storagename, void (*freestoragefunc)(struct bNode *), void (*copystoragefunc)(struct bNode *, struct bNode *))
2080 {
2081         if (storagename)
2082                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
2083         else
2084                 ntype->storagename[0] = '\0';
2085         ntype->copystoragefunc = copystoragefunc;
2086         ntype->freestoragefunc = freestoragefunc;
2087 }
2088
2089 void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *))
2090 {
2091         ntype->labelfunc = labelfunc;
2092 }
2093
2094 void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *))
2095 {
2096         ntype->templatefunc = templatefunc;
2097 }
2098
2099 void node_type_update(struct bNodeType *ntype,
2100                       void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
2101                       void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id))
2102 {
2103         ntype->updatefunc = updatefunc;
2104         ntype->verifyfunc = verifyfunc;
2105 }
2106
2107 void node_type_tree(struct bNodeType *ntype, void (*inittreefunc)(struct bNodeTree *), void (*updatetreefunc)(struct bNodeTree *))
2108 {
2109         ntype->inittreefunc = inittreefunc;
2110         ntype->updatetreefunc = updatetreefunc;
2111 }
2112
2113 void node_type_group_edit(struct bNodeType *ntype,
2114                           struct bNodeTree *(*group_edit_get)(struct bNode *node),
2115                           struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit),
2116                           void (*group_edit_clear)(struct bNode *node))
2117 {
2118         ntype->group_edit_get = group_edit_get;
2119         ntype->group_edit_set = group_edit_set;
2120         ntype->group_edit_clear = group_edit_clear;
2121 }
2122
2123 void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **))
2124 {
2125         ntype->execfunc = execfunc;
2126 }
2127
2128 void node_type_exec_new(struct bNodeType *ntype,
2129                         void *(*initexecfunc)(struct bNode *node),
2130                         void (*freeexecfunc)(struct bNode *node, void *nodedata),
2131                         void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **))
2132 {
2133         ntype->initexecfunc = initexecfunc;
2134         ntype->freeexecfunc = freeexecfunc;
2135         ntype->newexecfunc = newexecfunc;
2136 }
2137
2138 void node_type_internal_links(bNodeType *ntype, void (*update_internal_links)(bNodeTree *, bNode *))
2139 {
2140         ntype->update_internal_links = update_internal_links;
2141 }
2142
2143 void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out))
2144 {
2145         ntype->gpufunc = gpufunc;
2146 }
2147
2148 void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out))
2149 {
2150         ntype->gpuextfunc = gpuextfunc;
2151 }
2152
2153 void node_type_compatibility(struct bNodeType *ntype, short compatibility)
2154 {
2155         ntype->compatibility = compatibility;
2156 }
2157
2158 static bNodeType *is_nodetype_registered(ListBase *typelist, int type) 
2159 {
2160         bNodeType *ntype = typelist->first;
2161         
2162         for (; ntype; ntype = ntype->next)
2163                 if (ntype->type == type)
2164                         return ntype;
2165         
2166         return NULL;
2167 }
2168
2169 void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype) 
2170 {
2171         ListBase *typelist = &(ttype->node_types);
2172         bNodeType *found = is_nodetype_registered(typelist, ntype->type);
2173         
2174         if (found == NULL)
2175                 BLI_addtail(typelist, ntype);
2176         
2177         /* Associate the RNA struct type with the bNodeType.
2178          * Dynamically registered nodes will create an RNA type at runtime
2179          * and call RNA_struct_blender_type_set, so this only needs to be done for old RNA types
2180          * created in makesrna, which can not be associated to a bNodeType immediately,
2181          * since bNodeTypes are registered afterward ...
2182          */
2183         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
2184         if (ID == ntype->type) { \
2185                 StructRNA *srna = RNA_struct_find(STRINGIFY_ARG(Category##StructName)); \
2186                 BLI_assert(srna != NULL); \
2187                 RNA_struct_blender_type_set(srna, ntype); \
2188         }
2189         
2190         /* XXX hack, this file will be moved to the nodes folder in customnodes branch,
2191          * then this stupid include path is not needed any more.
2192          */
2193         #include "intern/rna_nodetree_types.h"
2194 }
2195
2196 static void registerCompositNodes(bNodeTreeType *ttype)
2197 {
2198         register_node_type_frame(ttype);
2199         register_node_type_reroute(ttype);
2200         
2201         register_node_type_cmp_group(ttype);
2202         
2203         register_node_type_cmp_rlayers(ttype);
2204         register_node_type_cmp_image(ttype);
2205         register_node_type_cmp_texture(ttype);
2206         register_node_type_cmp_value(ttype);
2207         register_node_type_cmp_rgb(ttype);
2208         register_node_type_cmp_curve_time(ttype);
2209         register_node_type_cmp_movieclip(ttype);
2210         
2211         register_node_type_cmp_composite(ttype);
2212         register_node_type_cmp_viewer(ttype);
2213         register_node_type_cmp_splitviewer(ttype);
2214         register_node_type_cmp_output_file(ttype);
2215         register_node_type_cmp_view_levels(ttype);
2216         
2217         register_node_type_cmp_curve_rgb(ttype);
2218         register_node_type_cmp_mix_rgb(ttype);
2219         register_node_type_cmp_hue_sat(ttype);
2220         register_node_type_cmp_brightcontrast(ttype);
2221         register_node_type_cmp_gamma(ttype);
2222         register_node_type_cmp_invert(ttype);
2223         register_node_type_cmp_alphaover(ttype);
2224         register_node_type_cmp_zcombine(ttype);
2225         register_node_type_cmp_colorbalance(ttype);
2226         register_node_type_cmp_huecorrect(ttype);
2227         
2228         register_node_type_cmp_normal(ttype);
2229         register_node_type_cmp_curve_vec(ttype);
2230         register_node_type_cmp_map_value(ttype);
2231         register_node_type_cmp_map_range(ttype);
2232         register_node_type_cmp_normalize(ttype);
2233         
2234         register_node_type_cmp_filter(ttype);
2235         register_node_type_cmp_blur(ttype);
2236         register_node_type_cmp_dblur(ttype);
2237         register_node_type_cmp_bilateralblur(ttype);
2238         register_node_type_cmp_vecblur(ttype);
2239         register_node_type_cmp_dilateerode(ttype);
2240         register_node_type_cmp_inpaint(ttype);
2241         register_node_type_cmp_despeckle(ttype);
2242         register_node_type_cmp_defocus(ttype);
2243         
2244         register_node_type_cmp_valtorgb(ttype);
2245         register_node_type_cmp_rgbtobw(ttype);
2246         register_node_type_cmp_setalpha(ttype);
2247         register_node_type_cmp_idmask(ttype);
2248         register_node_type_cmp_math(ttype);
2249         register_node_type_cmp_seprgba(ttype);
2250         register_node_type_cmp_combrgba(ttype);
2251         register_node_type_cmp_sephsva(ttype);
2252         register_node_type_cmp_combhsva(ttype);
2253         register_node_type_cmp_sepyuva(ttype);
2254         register_node_type_cmp_combyuva(ttype);
2255         register_node_type_cmp_sepycca(ttype);
2256         register_node_type_cmp_combycca(ttype);
2257         register_node_type_cmp_premulkey(ttype);
2258         
2259         register_node_type_cmp_diff_matte(ttype);
2260         register_node_type_cmp_distance_matte(ttype);
2261         register_node_type_cmp_chroma_matte(ttype);
2262         register_node_type_cmp_color_matte(ttype);
2263         register_node_type_cmp_channel_matte(ttype);
2264         register_node_type_cmp_color_spill(ttype);
2265         register_node_type_cmp_luma_matte(ttype);
2266         register_node_type_cmp_doubleedgemask(ttype);
2267         register_node_type_cmp_keyingscreen(ttype);
2268         register_node_type_cmp_keying(ttype);
2269
2270         register_node_type_cmp_translate(ttype);
2271         register_node_type_cmp_rotate(ttype);
2272         register_node_type_cmp_scale(ttype);
2273         register_node_type_cmp_flip(ttype);
2274         register_node_type_cmp_crop(ttype);
2275         register_node_type_cmp_displace(ttype);
2276         register_node_type_cmp_mapuv(ttype);
2277         register_node_type_cmp_glare(ttype);
2278         register_node_type_cmp_tonemap(ttype);
2279         register_node_type_cmp_lensdist(ttype);
2280         register_node_type_cmp_transform(ttype);
2281         register_node_type_cmp_stabilize2d(ttype);
2282         register_node_type_cmp_moviedistortion(ttype);
2283
2284         register_node_type_cmp_colorcorrection(ttype);
2285         register_node_type_cmp_boxmask(ttype);
2286         register_node_type_cmp_ellipsemask(ttype);
2287         register_node_type_cmp_bokehimage(ttype);
2288         register_node_type_cmp_bokehblur(ttype);
2289         register_node_type_cmp_switch(ttype);
2290         register_node_type_cmp_pixelate(ttype);
2291
2292         register_node_type_cmp_mask(ttype);
2293         register_node_type_cmp_trackpos(ttype);
2294 }
2295
2296 static void registerShaderNodes(bNodeTreeType *ttype) 
2297 {
2298         register_node_type_frame(ttype);
2299         register_node_type_reroute(ttype);
2300         
2301         register_node_type_sh_group(ttype);
2302
2303         register_node_type_sh_output(ttype);
2304         register_node_type_sh_material(ttype);
2305         register_node_type_sh_camera(ttype);
2306         register_node_type_sh_gamma(ttype);
2307         register_node_type_sh_brightcontrast(ttype);
2308         register_node_type_sh_value(ttype);
2309         register_node_type_sh_rgb(ttype);
2310         register_node_type_sh_mix_rgb(ttype);
2311         register_node_type_sh_valtorgb(ttype);
2312         register_node_type_sh_rgbtobw(ttype);
2313         register_node_type_sh_texture(ttype);
2314         register_node_type_sh_normal(ttype);
2315         register_node_type_sh_geom(ttype);
2316         register_node_type_sh_mapping(ttype);
2317         register_node_type_sh_curve_vec(ttype);
2318         register_node_type_sh_curve_rgb(ttype);
2319         register_node_type_sh_math(ttype);
2320         register_node_type_sh_vect_math(ttype);
2321         register_node_type_sh_squeeze(ttype);
2322         register_node_type_sh_material_ext(ttype);
2323         register_node_type_sh_invert(ttype);
2324         register_node_type_sh_seprgb(ttype);
2325         register_node_type_sh_combrgb(ttype);
2326         register_node_type_sh_hue_sat(ttype);
2327
2328         register_node_type_sh_attribute(ttype);
2329         register_node_type_sh_geometry(ttype);
2330         register_node_type_sh_light_path(ttype);
2331         register_node_type_sh_light_falloff(ttype);
2332         register_node_type_sh_object_info(ttype);
2333         register_node_type_sh_fresnel(ttype);
2334         register_node_type_sh_layer_weight(ttype);
2335         register_node_type_sh_tex_coord(ttype);
2336         register_node_type_sh_particle_info(ttype);
2337         register_node_type_sh_hair_info(ttype);
2338         register_node_type_sh_bump(ttype);
2339         register_node_type_sh_script(ttype);
2340         register_node_type_sh_tangent(ttype);
2341         register_node_type_sh_normal_map(ttype);
2342
2343         register_node_type_sh_background(ttype);
2344         register_node_type_sh_bsdf_anisotropic(ttype);
2345         register_node_type_sh_bsdf_diffuse(ttype);
2346         register_node_type_sh_bsdf_glossy(ttype);
2347         register_node_type_sh_bsdf_glass(ttype);
2348         register_node_type_sh_bsdf_refraction(ttype);
2349         register_node_type_sh_bsdf_translucent(ttype);
2350         register_node_type_sh_bsdf_transparent(ttype);
2351         register_node_type_sh_bsdf_velvet(ttype);
2352         register_node_type_sh_emission(ttype);
2353         register_node_type_sh_holdout(ttype);
2354         register_node_type_sh_ambient_occlusion(ttype);
2355         //register_node_type_sh_volume_transparent(ttype);
2356         //register_node_type_sh_volume_isotropic(ttype);
2357         register_node_type_sh_mix_shader(ttype);
2358         register_node_type_sh_add_shader(ttype);
2359
2360         register_node_type_sh_output_lamp(ttype);
2361         register_node_type_sh_output_material(ttype);
2362         register_node_type_sh_output_world(ttype);
2363
2364         register_node_type_sh_tex_image(ttype);
2365         register_node_type_sh_tex_environment(ttype);
2366         register_node_type_sh_tex_sky(ttype);
2367         register_node_type_sh_tex_noise(ttype);
2368         register_node_type_sh_tex_wave(ttype);
2369         register_node_type_sh_tex_voronoi(ttype);
2370         register_node_type_sh_tex_musgrave(ttype);
2371         register_node_type_sh_tex_gradient(ttype);
2372         register_node_type_sh_tex_magic(ttype);
2373         register_node_type_sh_tex_checker(ttype);
2374         register_node_type_sh_tex_brick(ttype);
2375 }
2376
2377 static void registerTextureNodes(bNodeTreeType *ttype)
2378 {
2379         register_node_type_frame(ttype);
2380         register_node_type_reroute(ttype);
2381         
2382         register_node_type_tex_group(ttype);
2383         
2384         register_node_type_tex_math(ttype);
2385         register_node_type_tex_mix_rgb(ttype);
2386         register_node_type_tex_valtorgb(ttype);
2387         register_node_type_tex_rgbtobw(ttype);
2388         register_node_type_tex_valtonor(ttype);
2389         register_node_type_tex_curve_rgb(ttype);
2390         register_node_type_tex_curve_time(ttype);
2391         register_node_type_tex_invert(ttype);
2392         register_node_type_tex_hue_sat(ttype);
2393         register_node_type_tex_coord(ttype);
2394         register_node_type_tex_distance(ttype);
2395         register_node_type_tex_compose(ttype);
2396         register_node_type_tex_decompose(ttype);
2397         
2398         register_node_type_tex_output(ttype);
2399         register_node_type_tex_viewer(ttype);
2400         
2401         register_node_type_tex_checker(ttype);
2402         register_node_type_tex_texture(ttype);
2403         register_node_type_tex_bricks(ttype);
2404         register_node_type_tex_image(ttype);
2405         
2406         register_node_type_tex_rotate(ttype);
2407         register_node_type_tex_translate(ttype);
2408         register_node_type_tex_scale(ttype);
2409         register_node_type_tex_at(ttype);
2410         
2411         register_node_type_tex_proc_voronoi(ttype);
2412         register_node_type_tex_proc_blend(ttype);
2413         register_node_type_tex_proc_magic(ttype);
2414         register_node_type_tex_proc_marble(ttype);
2415         register_node_type_tex_proc_clouds(ttype);
2416         register_node_type_tex_proc_wood(ttype);
2417         register_node_type_tex_proc_musgrave(ttype);
2418         register_node_type_tex_proc_noise(ttype);
2419         register_node_type_tex_proc_stucci(ttype);
2420         register_node_type_tex_proc_distnoise(ttype);
2421 }
2422
2423 static void free_typeinfos(ListBase *list)
2424 {
2425         bNodeType *ntype, *next;
2426         for (ntype = list->first; ntype; ntype = next) {
2427                 next = ntype->next;
2428
2429                 if (ntype->needs_free)
2430                         MEM_freeN(ntype);
2431         }
2432 }
2433
2434 void init_nodesystem(void) 
2435 {
2436         /* init clipboard */
2437         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
2438         node_clipboard.links.first = node_clipboard.links.last = NULL;
2439         
2440         registerCompositNodes(ntreeGetType(NTREE_COMPOSIT));
2441         registerShaderNodes(ntreeGetType(NTREE_SHADER));
2442         registerTextureNodes(ntreeGetType(NTREE_TEXTURE));
2443 }
2444
2445 void free_nodesystem(void) 
2446 {
2447         free_typeinfos(&ntreeGetType(NTREE_COMPOSIT)->node_types);
2448         free_typeinfos(&ntreeGetType(NTREE_SHADER)->node_types);
2449         free_typeinfos(&ntreeGetType(NTREE_TEXTURE)->node_types);
2450 }
2451
2452 /* called from BKE_scene_unlink, when deleting a scene goes over all scenes
2453  * other than the input, checks if they have render layer nodes referencing
2454  * the to-be-deleted scene, and resets them to NULL. */
2455
2456 /* XXX needs to get current scene then! */
2457 void clear_scene_in_nodes(Main *bmain, Scene *sce)
2458 {
2459         Scene *sce1;
2460         bNode *node;
2461
2462         for (sce1 = bmain->scene.first; sce1; sce1 = sce1->id.next) {
2463                 if (sce1 != sce) {
2464                         if (sce1->nodetree) {
2465                                 for (node = sce1->nodetree->nodes.first; node; node = node->next) {
2466                                         if (node->type == CMP_NODE_R_LAYERS) {
2467                                                 Scene *nodesce = (Scene *)node->id;
2468                                                 
2469                                                 if (nodesce == sce) node->id = NULL;
2470                                         }
2471                                 }
2472                         }
2473                 }
2474         }
2475 }