Patch #34204: [Render Animation] Fails with "Error: Specified sample_fmt is not suppo...
[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                                         /* if the up- or downstream link is invalid,
575                                          * the replacement link will be invalid too.
576                                          */
577                                         if (!(fromlink->flag & NODE_LINK_VALID))
578                                                 link->flag &= ~NODE_LINK_VALID;
579                                         
580                                         ntree->update |= NTREE_UPDATE_LINKS;
581                                 }
582                                 else
583                                         nodeRemLink(ntree, link);
584                         }
585                         else
586                                 nodeRemLink(ntree, link);
587                 }
588         }
589         
590         /* remove remaining upstream links */
591         for (link = ntree->links.first; link; link = link_next) {
592                 link_next = link->next;
593                 
594                 if (link->tonode == node)
595                         nodeRemLink(ntree, link);
596         }
597 }
598
599 void nodeToView(bNode *node, float x, float y, float *rx, float *ry)
600 {
601         if (node->parent) {
602                 nodeToView(node->parent, x + node->locx, y + node->locy, rx, ry);
603         }
604         else {
605                 *rx = x + node->locx;
606                 *ry = y + node->locy;
607         }
608 }
609
610 void nodeFromView(bNode *node, float x, float y, float *rx, float *ry)
611 {
612         if (node->parent) {
613                 nodeFromView(node->parent, x, y, rx, ry);
614                 *rx -= node->locx;
615                 *ry -= node->locy;
616         }
617         else {
618                 *rx = x - node->locx;
619                 *ry = y - node->locy;
620         }
621 }
622
623 int nodeAttachNodeCheck(bNode *node, bNode *parent)
624 {
625         bNode *parent_recurse;
626         for (parent_recurse = node; parent_recurse; parent_recurse = parent_recurse->parent) {
627                 if (parent_recurse == parent) {
628                         return TRUE;
629                 }
630         }
631
632         return FALSE;
633 }
634
635 void nodeAttachNode(bNode *node, bNode *parent)
636 {
637         float locx, locy;
638
639         BLI_assert(parent->type == NODE_FRAME);
640         BLI_assert(nodeAttachNodeCheck(parent, node) == FALSE);
641
642         nodeToView(node, 0.0f, 0.0f, &locx, &locy);
643         
644         node->parent = parent;
645         /* transform to parent space */
646         nodeFromView(parent, locx, locy, &node->locx, &node->locy);
647 }
648
649 void nodeDetachNode(struct bNode *node)
650 {
651         float locx, locy;
652         
653         if (node->parent) {
654
655                 BLI_assert(node->parent->type == NODE_FRAME);
656
657                 /* transform to view space */
658                 nodeToView(node, 0.0f, 0.0f, &locx, &locy);
659                 node->locx = locx;
660                 node->locy = locy;
661                 node->parent = NULL;
662         }
663 }
664
665 bNodeTree *ntreeAddTree(Main *bmain, const char *name, int type, int nodetype)
666 {
667         bNodeTree *ntree;
668         bNodeType *ntype;
669         
670         /* trees are created as local trees if they of compositor, material or texture type,
671          * node groups and other tree types are created as library data.
672          */
673         if (ELEM3(type, NTREE_COMPOSIT, NTREE_SHADER, NTREE_TEXTURE) && nodetype == 0) {
674                 ntree = MEM_callocN(sizeof(bNodeTree), "new node tree");
675                 *( (short *)ntree->id.name) = ID_NT; /* not "type", as that is ntree->type */
676                 BLI_strncpy(ntree->id.name + 2, name, sizeof(ntree->id.name));
677         }
678         else
679                 ntree = BKE_libblock_alloc(&bmain->nodetree, ID_NT, name);
680         
681         ntree->type = type;
682         ntree->nodetype = nodetype;
683         
684         ntreeInitTypes(ntree);
685         
686         ntype = node_get_type(ntree, ntree->nodetype);
687         if (ntype && ntype->inittreefunc)
688                 ntype->inittreefunc(ntree);
689         
690         return ntree;
691 }
692
693 /* Warning: this function gets called during some rather unexpected times
694  *      - this gets called when executing compositing updates (for threaded previews)
695  *      - when the nodetree datablock needs to be copied (i.e. when users get copied)
696  *      - for scene duplication use ntreeSwapID() after so we don't have stale pointers.
697  *
698  * do_make_extern: keep enabled for general use, only reason _not_ to enable is when
699  * copying for internal use (threads for eg), where you wont want it to modify the
700  * scene data.
701  */
702 static bNodeTree *ntreeCopyTree_internal(bNodeTree *ntree, const short do_id_user, const short do_make_extern)
703 {
704         bNodeTree *newtree;
705         bNode *node /*, *nnode */ /* UNUSED */, *last;
706         bNodeLink *link;
707         bNodeSocket *gsock, *oldgsock;
708         
709         if (ntree == NULL) return NULL;
710         
711         /* is ntree part of library? */
712         for (newtree = G.main->nodetree.first; newtree; newtree = newtree->id.next)
713                 if (newtree == ntree) break;
714         if (newtree) {
715                 newtree = BKE_libblock_copy(&ntree->id);
716         }
717         else {
718                 newtree = MEM_dupallocN(ntree);
719                 BKE_libblock_copy_data(&newtree->id, &ntree->id, true); /* copy animdata and ID props */
720         }
721
722         id_us_plus((ID *)newtree->gpd);
723
724         /* in case a running nodetree is copied */
725         newtree->execdata = NULL;
726         
727         newtree->nodes.first = newtree->nodes.last = NULL;
728         newtree->links.first = newtree->links.last = NULL;
729         
730         last = ntree->nodes.last;
731         for (node = ntree->nodes.first; node; node = node->next) {
732
733                 /* ntreeUserDecrefID inline */
734                 if (do_id_user) {
735                         id_us_plus(node->id);
736                 }
737
738                 if (do_make_extern) {
739                         id_lib_extern(node->id);
740                 }
741
742                 node->new_node = NULL;
743                 /* nnode = */ nodeCopyNode(newtree, node);   /* sets node->new */
744                 
745                 /* make sure we don't copy new nodes again! */
746                 if (node == last)
747                         break;
748         }
749         
750         /* socket definition for group usage */
751         BLI_duplicatelist(&newtree->inputs, &ntree->inputs);
752         for (gsock = newtree->inputs.first, oldgsock = ntree->inputs.first; gsock; gsock = gsock->next, oldgsock = oldgsock->next) {
753                 oldgsock->new_sock = gsock;
754                 gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL);
755                 gsock->default_value = node_socket_make_default_value(oldgsock->type);
756                 node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value);
757         }
758         BLI_duplicatelist(&newtree->outputs, &ntree->outputs);
759         for (gsock = newtree->outputs.first, oldgsock = ntree->outputs.first; gsock; gsock = gsock->next, oldgsock = oldgsock->next) {
760                 oldgsock->new_sock = gsock;
761                 gsock->groupsock = (oldgsock->groupsock ? oldgsock->groupsock->new_sock : NULL);
762                 gsock->default_value = node_socket_make_default_value(oldgsock->type);
763                 node_socket_copy_default_value(oldgsock->type, gsock->default_value, oldgsock->default_value);
764         }
765         
766         /* copy links */
767         BLI_duplicatelist(&newtree->links, &ntree->links);
768         for (link = newtree->links.first; link; link = link->next) {
769                 link->fromnode = (link->fromnode ? link->fromnode->new_node : NULL);
770                 link->fromsock = (link->fromsock ? link->fromsock->new_sock : NULL);
771                 link->tonode = (link->tonode ? link->tonode->new_node : NULL);
772                 link->tosock = (link->tosock ? link->tosock->new_sock : NULL);
773                 /* update the link socket's pointer */
774                 if (link->tosock)
775                         link->tosock->link = link;
776         }
777         
778         /* update node->parent pointers */
779         for (node = newtree->nodes.first; node; node = node->next) {
780                 if (node->parent)
781                         node->parent = node->parent->new_node;
782         }
783         
784         return newtree;
785 }
786
787 bNodeTree *ntreeCopyTree_ex(bNodeTree *ntree, const short do_id_user)
788 {
789         return ntreeCopyTree_internal(ntree, do_id_user, TRUE);
790 }
791 bNodeTree *ntreeCopyTree(bNodeTree *ntree)
792 {
793         return ntreeCopyTree_ex(ntree, TRUE);
794 }
795
796 /* use when duplicating scenes */
797 void ntreeSwitchID_ex(bNodeTree *ntree, ID *id_from, ID *id_to, const short do_id_user)
798 {
799         bNode *node;
800
801         if (id_from == id_to) {
802                 /* should never happen but may as well skip if it does */
803                 return;
804         }
805
806         /* for scene duplication only */
807         for (node = ntree->nodes.first; node; node = node->next) {
808                 if (node->id == id_from) {
809                         if (do_id_user) {
810                                 id_us_min(id_from);
811                                 id_us_plus(id_to);
812                         }
813
814                         node->id = id_to;
815                 }
816         }
817 }
818 void ntreeSwitchID(bNodeTree *ntree, ID *id_from, ID *id_to)
819 {
820         ntreeSwitchID_ex(ntree, id_from, id_to, TRUE);
821 }
822
823 void ntreeUserIncrefID(bNodeTree *ntree)
824 {
825         bNode *node;
826         for (node = ntree->nodes.first; node; node = node->next) {
827                 id_us_plus(node->id);
828         }
829 }
830 void ntreeUserDecrefID(bNodeTree *ntree)
831 {
832         bNode *node;
833         for (node = ntree->nodes.first; node; node = node->next) {
834                 id_us_min(node->id);
835         }
836 }
837
838 /* *************** preview *********** */
839 /* if node->preview, then we assume the rect to exist */
840
841 void nodeFreePreview(bNode *node)
842 {
843         if (node->preview) {
844                 if (node->preview->rect)
845                         MEM_freeN(node->preview->rect);
846                 MEM_freeN(node->preview);
847                 node->preview = NULL;
848         }
849 }
850
851 static void node_init_preview(bNode *node, int xsize, int ysize)
852 {
853         
854         if (node->preview == NULL) {
855                 node->preview = MEM_callocN(sizeof(bNodePreview), "node preview");
856                 //              printf("added preview %s\n", node->name);
857         }
858         
859         /* node previews can get added with variable size this way */
860         if (xsize == 0 || ysize == 0)
861                 return;
862         
863         /* sanity checks & initialize */
864         if (node->preview->rect) {
865                 if (node->preview->xsize != xsize && node->preview->ysize != ysize) {
866                         MEM_freeN(node->preview->rect);
867                         node->preview->rect = NULL;
868                 }
869         }
870         
871         if (node->preview->rect == NULL) {
872                 node->preview->rect = MEM_callocN(4 * xsize + xsize * ysize * sizeof(char) * 4, "node preview rect");
873                 node->preview->xsize = xsize;
874                 node->preview->ysize = ysize;
875         }
876         /* no clear, makes nicer previews */
877 }
878
879 void ntreeInitPreview(bNodeTree *ntree, int xsize, int ysize)
880 {
881         bNode *node;
882         
883         if (ntree == NULL)
884                 return;
885         
886         for (node = ntree->nodes.first; node; node = node->next) {
887                 if (node->typeinfo->flag & NODE_PREVIEW)    /* hrms, check for closed nodes? */
888                         node_init_preview(node, xsize, ysize);
889                 if (node->type == NODE_GROUP && (node->flag & NODE_GROUP_EDIT))
890                         ntreeInitPreview((bNodeTree *)node->id, xsize, ysize);
891         }
892 }
893
894 static void nodeClearPreview(bNode *node)
895 {
896         if (node->preview && node->preview->rect)
897                 memset(node->preview->rect, 0, MEM_allocN_len(node->preview->rect));
898 }
899
900 /* use it to enforce clear */
901 void ntreeClearPreview(bNodeTree *ntree)
902 {
903         bNode *node;
904         
905         if (ntree == NULL)
906                 return;
907         
908         for (node = ntree->nodes.first; node; node = node->next) {
909                 if (node->typeinfo->flag & NODE_PREVIEW)
910                         nodeClearPreview(node);
911                 if (node->type == NODE_GROUP && (node->flag & NODE_GROUP_EDIT))
912                         ntreeClearPreview((bNodeTree *)node->id);
913         }
914 }
915
916 /* hack warning! this function is only used for shader previews, and 
917  * since it gets called multiple times per pixel for Ztransp we only
918  * add the color once. Preview gets cleared before it starts render though */
919 void nodeAddToPreview(bNode *node, const float col[4], int x, int y, int do_manage)
920 {
921         bNodePreview *preview = node->preview;
922         if (preview) {
923                 if (x >= 0 && y >= 0) {
924                         if (x < preview->xsize && y < preview->ysize) {
925                                 unsigned char *tar = preview->rect + 4 * ((preview->xsize * y) + x);
926                                 
927                                 if (do_manage) {
928                                         linearrgb_to_srgb_uchar4(tar, col);
929                                 }
930                                 else {
931                                         rgba_float_to_uchar(tar, col);
932                                 }
933                         }
934                         //else printf("prv out bound x y %d %d\n", x, y);
935                 }
936                 //else printf("prv out bound x y %d %d\n", x, y);
937         }
938 }
939
940 /* ************** Free stuff ********** */
941
942 /* goes over entire tree */
943 void nodeUnlinkNode(bNodeTree *ntree, bNode *node)
944 {
945         bNodeLink *link, *next;
946         bNodeSocket *sock;
947         ListBase *lb;
948         
949         for (link = ntree->links.first; link; link = next) {
950                 next = link->next;
951                 
952                 if (link->fromnode == node) {
953                         lb = &node->outputs;
954                         if (link->tonode)
955                                 link->tonode->update |= NODE_UPDATE;
956                 }
957                 else if (link->tonode == node)
958                         lb = &node->inputs;
959                 else
960                         lb = NULL;
961
962                 if (lb) {
963                         for (sock = lb->first; sock; sock = sock->next) {
964                                 if (link->fromsock == sock || link->tosock == sock)
965                                         break;
966                         }
967                         if (sock) {
968                                 nodeRemLink(ntree, link);
969                         }
970                 }
971         }
972 }
973
974 static void node_unlink_attached(bNodeTree *ntree, bNode *parent)
975 {
976         bNode *node;
977         for (node = ntree->nodes.first; node; node = node->next) {
978                 if (node->parent == parent)
979                         nodeDetachNode(node);
980         }
981 }
982
983 /** \note caller needs to manage node->id user */
984 void nodeFreeNode(bNodeTree *ntree, bNode *node)
985 {
986         bNodeSocket *sock, *nextsock;
987         
988         /* can be called for nodes outside a node tree (e.g. clipboard) */
989         if (ntree) {
990                 bNodeTreeType *treetype = ntreeGetType(ntree->type);
991
992                 /* remove all references to this node */
993                 nodeUnlinkNode(ntree, node);
994                 node_unlink_attached(ntree, node);
995
996                 BLI_remlink(&ntree->nodes, node);
997
998                 if (treetype->free_node_cache)
999                         treetype->free_node_cache(ntree, node);
1000                 
1001                 /* texture node has bad habit of keeping exec data around */
1002                 if (ntree->type == NTREE_TEXTURE && ntree->execdata) {
1003                         ntreeTexEndExecTree(ntree->execdata, 1);
1004                         ntree->execdata = NULL;
1005                 }
1006         }
1007         
1008         /* since it is called while free database, node->id is undefined */
1009         
1010         if (node->typeinfo && node->typeinfo->freestoragefunc)
1011                 node->typeinfo->freestoragefunc(node);
1012         
1013         for (sock = node->inputs.first; sock; sock = nextsock) {
1014                 nextsock = sock->next;
1015                 node_socket_free_default_value(sock->type, sock->default_value);
1016                 MEM_freeN(sock);
1017         }
1018         for (sock = node->outputs.first; sock; sock = nextsock) {
1019                 nextsock = sock->next;
1020                 node_socket_free_default_value(sock->type, sock->default_value);
1021                 MEM_freeN(sock);
1022         }
1023
1024         BLI_freelistN(&node->internal_links);
1025
1026         nodeFreePreview(node);
1027
1028         MEM_freeN(node);
1029         
1030         if (ntree)
1031                 ntree->update |= NTREE_UPDATE_NODES;
1032 }
1033
1034 /* do not free ntree itself here, BKE_libblock_free calls this function too */
1035 void ntreeFreeTree_ex(bNodeTree *ntree, const short do_id_user)
1036 {
1037         bNodeTree *tntree;
1038         bNode *node, *next;
1039         bNodeSocket *sock;
1040         
1041         if (ntree == NULL) return;
1042         
1043         /* XXX hack! node trees should not store execution graphs at all.
1044          * This should be removed when old tree types no longer require it.
1045          * Currently the execution data for texture nodes remains in the tree
1046          * after execution, until the node tree is updated or freed.
1047          */
1048         if (ntree->execdata) {
1049                 switch (ntree->type) {
1050                         case NTREE_SHADER:
1051                                 ntreeShaderEndExecTree(ntree->execdata, 1);
1052                                 break;
1053                         case NTREE_TEXTURE:
1054                                 ntreeTexEndExecTree(ntree->execdata, 1);
1055                                 ntree->execdata = NULL;
1056                                 break;
1057                 }
1058         }
1059         
1060         BKE_free_animdata((ID *)ntree);
1061         
1062         id_us_min((ID *)ntree->gpd);
1063
1064         BLI_freelistN(&ntree->links);   /* do first, then unlink_node goes fast */
1065         
1066         for (node = ntree->nodes.first; node; node = next) {
1067                 next = node->next;
1068
1069                 /* ntreeUserIncrefID inline */
1070
1071                 /* XXX, this is correct, however when freeing the entire database
1072                  * this ends up accessing freed data which isn't properly unlinking
1073                  * its self from scene nodes, SO - for now prefer invalid usercounts
1074                  * on free rather then bad memory access - Campbell */
1075 #if 0
1076                 if (do_id_user) {
1077                         id_us_min(node->id);
1078                 }
1079 #else
1080                 (void)do_id_user;
1081 #endif
1082
1083                 nodeFreeNode(ntree, node);
1084         }
1085         
1086         for (sock = ntree->inputs.first; sock; sock = sock->next)
1087                 node_socket_free_default_value(sock->type, sock->default_value);
1088         BLI_freelistN(&ntree->inputs);
1089         for (sock = ntree->outputs.first; sock; sock = sock->next)
1090                 node_socket_free_default_value(sock->type, sock->default_value);
1091         BLI_freelistN(&ntree->outputs);
1092         
1093         /* if ntree is not part of library, free the libblock data explicitly */
1094         for (tntree = G.main->nodetree.first; tntree; tntree = tntree->id.next)
1095                 if (tntree == ntree)
1096                         break;
1097         if (tntree == NULL) {
1098                 BKE_libblock_free_data(&ntree->id);
1099         }
1100 }
1101 /* same as ntreeFreeTree_ex but always manage users */
1102 void ntreeFreeTree(bNodeTree *ntree)
1103 {
1104         ntreeFreeTree_ex(ntree, TRUE);
1105 }
1106
1107 void ntreeFreeCache(bNodeTree *ntree)
1108 {
1109         bNodeTreeType *treetype;
1110         
1111         if (ntree == NULL) return;
1112         
1113         treetype = ntreeGetType(ntree->type);
1114         if (treetype->free_cache)
1115                 treetype->free_cache(ntree);
1116 }
1117
1118 void ntreeSetOutput(bNodeTree *ntree)
1119 {
1120         bNode *node;
1121
1122         /* find the active outputs, might become tree type dependent handler */
1123         for (node = ntree->nodes.first; node; node = node->next) {
1124                 if (node->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1125                         bNode *tnode;
1126                         int output = 0;
1127                         
1128                         /* we need a check for which output node should be tagged like this, below an exception */
1129                         if (node->type == CMP_NODE_OUTPUT_FILE)
1130                                 continue;
1131
1132                         /* there is more types having output class, each one is checked */
1133                         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1134                                 if (tnode->typeinfo->nclass == NODE_CLASS_OUTPUT) {
1135                                         
1136                                         if (ntree->type == NTREE_COMPOSIT) {
1137                                                         
1138                                                 /* same type, exception for viewer */
1139                                                 if (tnode->type == node->type ||
1140                                                     (ELEM(tnode->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER) &&
1141                                                      ELEM(node->type, CMP_NODE_VIEWER, CMP_NODE_SPLITVIEWER)))
1142                                                 {
1143                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1144                                                                 output++;
1145                                                                 if (output > 1)
1146                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1147                                                         }
1148                                                 }
1149                                         }
1150                                         else {
1151                                                 /* same type */
1152                                                 if (tnode->type == node->type) {
1153                                                         if (tnode->flag & NODE_DO_OUTPUT) {
1154                                                                 output++;
1155                                                                 if (output > 1)
1156                                                                         tnode->flag &= ~NODE_DO_OUTPUT;
1157                                                         }
1158                                                 }
1159                                         }
1160                                 }
1161                         }
1162                         if (output == 0)
1163                                 node->flag |= NODE_DO_OUTPUT;
1164                 }
1165         }
1166         
1167         /* here we could recursively set which nodes have to be done,
1168          * might be different for editor or for "real" use... */
1169 }
1170
1171 bNodeTree *ntreeFromID(ID *id)
1172 {
1173         switch (GS(id->name)) {
1174                 case ID_MA:  return ((Material *)id)->nodetree;
1175                 case ID_LA:  return ((Lamp *)id)->nodetree;
1176                 case ID_WO:  return ((World *)id)->nodetree;
1177                 case ID_TE:  return ((Tex *)id)->nodetree;
1178                 case ID_SCE: return ((Scene *)id)->nodetree;
1179                 default: return NULL;
1180         }
1181 }
1182
1183 typedef struct MakeLocalCallData {
1184         ID *group_id;
1185         ID *new_id;
1186         int lib, local;
1187 } MakeLocalCallData;
1188
1189 static void ntreeMakeLocal_CheckLocal(void *calldata, ID *owner_id, bNodeTree *ntree)
1190 {
1191         MakeLocalCallData *cd = (MakeLocalCallData *)calldata;
1192         bNode *node;
1193         
1194         /* find if group is in tree */
1195         for (node = ntree->nodes.first; node; node = node->next) {
1196                 if (node->id == cd->group_id) {
1197                         if (owner_id->lib) {
1198                                 cd->lib = TRUE;
1199                         }
1200                         else {
1201                                 cd->local = TRUE;
1202                         }
1203                 }
1204         }
1205 }
1206
1207 static void ntreeMakeLocal_LinkNew(void *calldata, ID *owner_id, bNodeTree *ntree)
1208 {
1209         MakeLocalCallData *cd = (MakeLocalCallData *)calldata;
1210         bNode *node;
1211         
1212         /* find if group is in tree */
1213         for (node = ntree->nodes.first; node; node = node->next) {
1214                 if (node->id == cd->group_id) {
1215                         if (owner_id->lib == NULL) {
1216                                 node->id = cd->new_id;
1217                                 cd->new_id->us++;
1218                                 cd->group_id->us--;
1219                         }
1220                 }
1221         }
1222 }
1223
1224 void ntreeMakeLocal(bNodeTree *ntree)
1225 {
1226         Main *bmain = G.main;
1227         bNodeTreeType *treetype = ntreeGetType(ntree->type);
1228         MakeLocalCallData cd;
1229         
1230         /* - only lib users: do nothing
1231          * - only local users: set flag
1232          * - mixed: make copy
1233          */
1234         
1235         if (ntree->id.lib == NULL) return;
1236         if (ntree->id.us == 1) {
1237                 id_clear_lib_data(bmain, (ID *)ntree);
1238                 return;
1239         }
1240         
1241         /* now check users of groups... again typedepending, callback... */
1242         cd.group_id = &ntree->id;
1243         cd.new_id = NULL;
1244         cd.local = 0;
1245         cd.lib = 0;
1246         
1247         treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_CheckLocal);
1248         
1249         /* if all users are local, we simply make tree local */
1250         if (cd.local && cd.lib == 0) {
1251                 id_clear_lib_data(bmain, (ID *)ntree);
1252         }
1253         else if (cd.local && cd.lib) {
1254                 /* this is the mixed case, we copy the tree and assign it to local users */
1255                 bNodeTree *newtree = ntreeCopyTree(ntree);
1256                 
1257                 newtree->id.us = 0;
1258                 
1259
1260                 cd.new_id = &newtree->id;
1261                 treetype->foreach_nodetree(G.main, &cd, &ntreeMakeLocal_LinkNew);
1262         }
1263 }
1264
1265 int ntreeNodeExists(bNodeTree *ntree, bNode *testnode)
1266 {
1267         bNode *node = ntree->nodes.first;
1268         for (; node; node = node->next)
1269                 if (node == testnode)
1270                         return 1;
1271         return 0;
1272 }
1273
1274 int ntreeOutputExists(bNode *node, bNodeSocket *testsock)
1275 {
1276         bNodeSocket *sock = node->outputs.first;
1277         for (; sock; sock = sock->next)
1278                 if (sock == testsock)
1279                         return 1;
1280         return 0;
1281 }
1282
1283 /* returns localized tree for execution in threads */
1284 bNodeTree *ntreeLocalize(bNodeTree *ntree)
1285 {
1286         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1287
1288         bNodeTree *ltree;
1289         bNode *node;
1290         
1291         bAction *action_backup = NULL, *tmpact_backup = NULL;
1292         
1293         /* Workaround for copying an action on each render!
1294          * set action to NULL so animdata actions don't get copied */
1295         AnimData *adt = BKE_animdata_from_id(&ntree->id);
1296
1297         if (adt) {
1298                 action_backup = adt->action;
1299                 tmpact_backup = adt->tmpact;
1300
1301                 adt->action = NULL;
1302                 adt->tmpact = NULL;
1303         }
1304
1305         /* node copy func */
1306         ltree = ntreeCopyTree_internal(ntree, FALSE, FALSE);
1307
1308         if (adt) {
1309                 AnimData *ladt = BKE_animdata_from_id(&ltree->id);
1310
1311                 adt->action = ladt->action = action_backup;
1312                 adt->tmpact = ladt->tmpact = tmpact_backup;
1313
1314                 if (action_backup) action_backup->id.us++;
1315                 if (tmpact_backup) tmpact_backup->id.us++;
1316                 
1317         }
1318         /* end animdata uglyness */
1319
1320         /* ensures only a single output node is enabled */
1321         ntreeSetOutput(ntree);
1322
1323         for (node = ntree->nodes.first; node; node = node->next) {
1324                 /* store new_node pointer to original */
1325                 node->new_node->new_node = node;
1326         }
1327
1328         if (ntreetype->localize)
1329                 ntreetype->localize(ltree, ntree);
1330
1331         return ltree;
1332 }
1333
1334 /* sync local composite with real tree */
1335 /* local tree is supposed to be running, be careful moving previews! */
1336 /* is called by jobs manager, outside threads, so it doesnt happen during draw */
1337 void ntreeLocalSync(bNodeTree *localtree, bNodeTree *ntree)
1338 {
1339         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1340
1341         if (ntreetype->local_sync)
1342                 ntreetype->local_sync(localtree, ntree);
1343 }
1344
1345 /* merge local tree results back, and free local tree */
1346 /* we have to assume the editor already changed completely */
1347 void ntreeLocalMerge(bNodeTree *localtree, bNodeTree *ntree)
1348 {
1349         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1350         bNode *lnode;
1351         
1352         /* move over the compbufs and previews */
1353         for (lnode = localtree->nodes.first; lnode; lnode = lnode->next) {
1354                 if (ntreeNodeExists(ntree, lnode->new_node)) {
1355                         if (lnode->preview && lnode->preview->rect) {
1356                                 nodeFreePreview(lnode->new_node);
1357                                 lnode->new_node->preview = lnode->preview;
1358                                 lnode->preview = NULL;
1359                         }
1360                 }
1361         }
1362
1363         if (ntreetype->local_merge)
1364                 ntreetype->local_merge(localtree, ntree);
1365
1366         ntreeFreeTree_ex(localtree, FALSE);
1367         MEM_freeN(localtree);
1368 }
1369
1370 /* ************ find stuff *************** */
1371
1372 int ntreeHasType(bNodeTree *ntree, int type)
1373 {
1374         bNode *node;
1375         
1376         if (ntree)
1377                 for (node = ntree->nodes.first; node; node = node->next)
1378                         if (node->type == type)
1379                                 return 1;
1380         return 0;
1381 }
1382
1383 bNodeLink *nodeFindLink(bNodeTree *ntree, bNodeSocket *from, bNodeSocket *to)
1384 {
1385         bNodeLink *link;
1386         
1387         for (link = ntree->links.first; link; link = link->next) {
1388                 if (link->fromsock == from && link->tosock == to)
1389                         return link;
1390                 if (link->fromsock == to && link->tosock == from) /* hrms? */
1391                         return link;
1392         }
1393         return NULL;
1394 }
1395
1396 int nodeCountSocketLinks(bNodeTree *ntree, bNodeSocket *sock)
1397 {
1398         bNodeLink *link;
1399         int tot = 0;
1400         
1401         for (link = ntree->links.first; link; link = link->next) {
1402                 if (link->fromsock == sock || link->tosock == sock)
1403                         tot++;
1404         }
1405         return tot;
1406 }
1407
1408 bNode *nodeGetActive(bNodeTree *ntree)
1409 {
1410         bNode *node;
1411         
1412         if (ntree == NULL) return NULL;
1413         
1414         for (node = ntree->nodes.first; node; node = node->next)
1415                 if (node->flag & NODE_ACTIVE)
1416                         break;
1417         return node;
1418 }
1419
1420 /* two active flags, ID nodes have special flag for buttons display */
1421 bNode *nodeGetActiveID(bNodeTree *ntree, short idtype)
1422 {
1423         bNode *node;
1424         
1425         if (ntree == NULL) return NULL;
1426
1427         /* check for group edit */
1428         for (node = ntree->nodes.first; node; node = node->next)
1429                 if (node->flag & NODE_GROUP_EDIT)
1430                         break;
1431
1432         if (node)
1433                 ntree = (bNodeTree *)node->id;
1434         
1435         /* now find active node with this id */
1436         for (node = ntree->nodes.first; node; node = node->next)
1437                 if (node->id && GS(node->id->name) == idtype)
1438                         if (node->flag & NODE_ACTIVE_ID)
1439                                 break;
1440
1441         return node;
1442 }
1443
1444 int nodeSetActiveID(bNodeTree *ntree, short idtype, ID *id)
1445 {
1446         bNode *node;
1447         int ok = FALSE;
1448
1449         if (ntree == NULL) return ok;
1450
1451         /* check for group edit */
1452         for (node = ntree->nodes.first; node; node = node->next)
1453                 if (node->flag & NODE_GROUP_EDIT)
1454                         break;
1455
1456         if (node)
1457                 ntree = (bNodeTree *)node->id;
1458
1459         /* now find active node with this id */
1460         for (node = ntree->nodes.first; node; node = node->next) {
1461                 if (node->id && GS(node->id->name) == idtype) {
1462                         if (id && ok == FALSE && node->id == id) {
1463                                 node->flag |= NODE_ACTIVE_ID;
1464                                 ok = TRUE;
1465                         }
1466                         else {
1467                                 node->flag &= ~NODE_ACTIVE_ID;
1468                         }
1469                 }
1470         }
1471
1472         return ok;
1473 }
1474
1475
1476 /* two active flags, ID nodes have special flag for buttons display */
1477 void nodeClearActiveID(bNodeTree *ntree, short idtype)
1478 {
1479         bNode *node;
1480         
1481         if (ntree == NULL) return;
1482         
1483         for (node = ntree->nodes.first; node; node = node->next)
1484                 if (node->id && GS(node->id->name) == idtype)
1485                         node->flag &= ~NODE_ACTIVE_ID;
1486 }
1487
1488 void nodeClearActive(bNodeTree *ntree)
1489 {
1490         bNode *node;
1491
1492         if (ntree == NULL) return;
1493
1494         for (node = ntree->nodes.first; node; node = node->next)
1495                 node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_ID);
1496 }
1497
1498
1499 /* two active flags, ID nodes have special flag for buttons display */
1500 void nodeSetActive(bNodeTree *ntree, bNode *node)
1501 {
1502         bNode *tnode;
1503         
1504         /* make sure only one node is active, and only one per ID type */
1505         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
1506                 tnode->flag &= ~NODE_ACTIVE;
1507                 
1508                 if (node->id && tnode->id) {
1509                         if (GS(node->id->name) == GS(tnode->id->name))
1510                                 tnode->flag &= ~NODE_ACTIVE_ID;
1511                 }
1512                 if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1513                         tnode->flag &= ~NODE_ACTIVE_TEXTURE;
1514         }
1515         
1516         node->flag |= NODE_ACTIVE;
1517         if (node->id)
1518                 node->flag |= NODE_ACTIVE_ID;
1519         if (node->typeinfo->nclass == NODE_CLASS_TEXTURE)
1520                 node->flag |= NODE_ACTIVE_TEXTURE;
1521 }
1522
1523 int nodeSocketIsHidden(bNodeSocket *sock)
1524 {
1525         return ((sock->flag & (SOCK_HIDDEN | SOCK_UNAVAIL)) != 0);
1526 }
1527
1528 void nodeSocketSetType(bNodeSocket *sock, int type)
1529 {
1530         int old_type = sock->type;
1531         void *old_default_value = sock->default_value;
1532         
1533         sock->type = type;
1534         
1535         sock->default_value = node_socket_make_default_value(sock->type);
1536         node_socket_init_default_value(type, sock->default_value);
1537         node_socket_convert_default_value(sock->type, sock->default_value, old_type, old_default_value);
1538         node_socket_free_default_value(old_type, old_default_value);
1539 }
1540
1541 /* ************** Node Clipboard *********** */
1542
1543 #define USE_NODE_CB_VALIDATE
1544
1545 #ifdef USE_NODE_CB_VALIDATE
1546 /**
1547  * This data structure is to validate the node on creation,
1548  * otherwise we may reference missing data.
1549  *
1550  * Currently its only used for ID's, but nodes may one day
1551  * reference other pointers which need validation.
1552  */
1553 typedef struct bNodeClipboardExtraInfo {
1554         struct bNodeClipboardExtraInfo *next, *prev;
1555         ID  *id;
1556         char id_name[MAX_ID_NAME];
1557         char library_name[FILE_MAX];
1558 } bNodeClipboardExtraInfo;
1559 #endif  /* USE_NODE_CB_VALIDATE */
1560
1561
1562 typedef struct bNodeClipboard {
1563         ListBase nodes;
1564
1565 #ifdef USE_NODE_CB_VALIDATE
1566         ListBase nodes_extra_info;
1567 #endif
1568
1569         ListBase links;
1570         int type;
1571 } bNodeClipboard;
1572
1573 bNodeClipboard node_clipboard = {{0}};
1574
1575 void BKE_node_clipboard_init(struct bNodeTree *ntree)
1576 {
1577         node_clipboard.type = ntree->type;
1578 }
1579
1580 void BKE_node_clipboard_clear(void)
1581 {
1582         bNode *node, *node_next;
1583         bNodeLink *link, *link_next;
1584         
1585         for (link = node_clipboard.links.first; link; link = link_next) {
1586                 link_next = link->next;
1587                 nodeRemLink(NULL, link);
1588         }
1589         node_clipboard.links.first = node_clipboard.links.last = NULL;
1590         
1591         for (node = node_clipboard.nodes.first; node; node = node_next) {
1592                 node_next = node->next;
1593                 nodeFreeNode(NULL, node);
1594         }
1595         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
1596
1597 #ifdef USE_NODE_CB_VALIDATE
1598         BLI_freelistN(&node_clipboard.nodes_extra_info);
1599 #endif
1600 }
1601
1602 /* return FALSE when one or more ID's are lost */
1603 int BKE_node_clipboard_validate(void)
1604 {
1605         int ok = TRUE;
1606
1607 #ifdef USE_NODE_CB_VALIDATE
1608         bNodeClipboardExtraInfo *node_info;
1609         bNode *node;
1610
1611
1612         /* lists must be aligned */
1613         BLI_assert(BLI_countlist(&node_clipboard.nodes) ==
1614                    BLI_countlist(&node_clipboard.nodes_extra_info));
1615
1616         for (node = node_clipboard.nodes.first, node_info = node_clipboard.nodes_extra_info.first;
1617              node;
1618              node = node->next, node_info = node_info->next)
1619         {
1620                 /* validate the node against the stored node info */
1621
1622                 /* re-assign each loop since we may clear,
1623                  * open a new file where the ID is valid, and paste again */
1624                 node->id = node_info->id;
1625
1626                 /* currently only validate the ID */
1627                 if (node->id) {
1628                         ListBase *lb = which_libbase(G.main, GS(node_info->id_name));
1629                         BLI_assert(lb != NULL);
1630
1631                         if (BLI_findindex(lb, node_info->id) == -1) {
1632                                 /* may assign NULL */
1633                                 node->id = BLI_findstring(lb, node_info->id_name + 2, offsetof(ID, name) + 2);
1634
1635                                 if (node->id == NULL) {
1636                                         ok = FALSE;
1637                                 }
1638                         }
1639                 }
1640         }
1641 #endif  /* USE_NODE_CB_VALIDATE */
1642
1643         return ok;
1644 }
1645
1646 void BKE_node_clipboard_add_node(bNode *node)
1647 {
1648 #ifdef USE_NODE_CB_VALIDATE
1649         /* add extra info */
1650         bNodeClipboardExtraInfo *node_info = MEM_mallocN(sizeof(bNodeClipboardExtraInfo), "bNodeClipboardExtraInfo");
1651
1652         node_info->id = node->id;
1653         if (node->id) {
1654                 BLI_strncpy(node_info->id_name, node->id->name, sizeof(node_info->id_name));
1655                 if (node->id->lib) {
1656                         BLI_strncpy(node_info->library_name, node->id->lib->filepath, sizeof(node_info->library_name));
1657                 }
1658                 else {
1659                         node_info->library_name[0] = '\0';
1660                 }
1661         }
1662         else {
1663                 node_info->id_name[0] = '\0';
1664                 node_info->library_name[0] = '\0';
1665         }
1666         BLI_addtail(&node_clipboard.nodes_extra_info, node_info);
1667         /* end extra info */
1668 #endif  /* USE_NODE_CB_VALIDATE */
1669
1670         /* add node */
1671         BLI_addtail(&node_clipboard.nodes, node);
1672
1673 }
1674
1675 void BKE_node_clipboard_add_link(bNodeLink *link)
1676 {
1677         BLI_addtail(&node_clipboard.links, link);
1678 }
1679
1680 const ListBase *BKE_node_clipboard_get_nodes(void)
1681 {
1682         return &node_clipboard.nodes;
1683 }
1684
1685 const ListBase *BKE_node_clipboard_get_links(void)
1686 {
1687         return &node_clipboard.links;
1688 }
1689
1690 int BKE_node_clipboard_get_type(void)
1691 {
1692         return node_clipboard.type;
1693 }
1694
1695 /* ************** dependency stuff *********** */
1696
1697 /* node is guaranteed to be not checked before */
1698 static int node_get_deplist_recurs(bNodeTree *ntree, bNode *node, bNode ***nsort)
1699 {
1700         bNode *fromnode;
1701         bNodeLink *link;
1702         int level = 0xFFF;
1703         
1704         node->done = TRUE;
1705         
1706         /* check linked nodes */
1707         for (link = ntree->links.first; link; link = link->next) {
1708                 if (link->tonode == node) {
1709                         fromnode = link->fromnode;
1710                         if (fromnode) {
1711                                 if (fromnode->done == 0)
1712                                         fromnode->level = node_get_deplist_recurs(ntree, fromnode, nsort);
1713                                 if (fromnode->level <= level)
1714                                         level = fromnode->level - 1;
1715                         }
1716                 }
1717         }
1718         
1719         /* check parent node */
1720         if (node->parent) {
1721                 if (node->parent->done == 0)
1722                         node->parent->level = node_get_deplist_recurs(ntree, node->parent, nsort);
1723                 if (node->parent->level <= level)
1724                         level = node->parent->level - 1;
1725         }
1726         
1727         if (nsort) {
1728                 **nsort = node;
1729                 (*nsort)++;
1730         }
1731         
1732         return level;
1733 }
1734
1735 void ntreeGetDependencyList(struct bNodeTree *ntree, struct bNode ***deplist, int *totnodes)
1736 {
1737         bNode *node, **nsort;
1738         
1739         *totnodes = 0;
1740         
1741         /* first clear data */
1742         for (node = ntree->nodes.first; node; node = node->next) {
1743                 node->done = FALSE;
1744                 (*totnodes)++;
1745         }
1746         if (*totnodes == 0) {
1747                 *deplist = NULL;
1748                 return;
1749         }
1750         
1751         nsort = *deplist = MEM_callocN((*totnodes) * sizeof(bNode *), "sorted node array");
1752         
1753         /* recursive check */
1754         for (node = ntree->nodes.first; node; node = node->next) {
1755                 if (node->done == 0) {
1756                         node->level = node_get_deplist_recurs(ntree, node, &nsort);
1757                 }
1758         }
1759 }
1760
1761 /* only updates node->level for detecting cycles links */
1762 static void ntree_update_node_level(bNodeTree *ntree)
1763 {
1764         bNode *node;
1765         
1766         /* first clear tag */
1767         for (node = ntree->nodes.first; node; node = node->next) {
1768                 node->done = FALSE;
1769         }
1770         
1771         /* recursive check */
1772         for (node = ntree->nodes.first; node; node = node->next) {
1773                 if (node->done == 0) {
1774                         node->level = node_get_deplist_recurs(ntree, node, NULL);
1775                 }
1776         }
1777 }
1778
1779 static void ntree_update_link_pointers(bNodeTree *ntree)
1780 {
1781         bNode *node;
1782         bNodeSocket *sock;
1783         bNodeLink *link;
1784         
1785         /* first clear data */
1786         for (node = ntree->nodes.first; node; node = node->next) {
1787                 for (sock = node->inputs.first; sock; sock = sock->next) {
1788                         sock->link = NULL;
1789                         sock->flag &= ~SOCK_IN_USE;
1790                 }
1791                 for (sock = node->outputs.first; sock; sock = sock->next) {
1792                         sock->flag &= ~SOCK_IN_USE;
1793                 }
1794         }
1795         for (sock = ntree->inputs.first; sock; sock = sock->next) {
1796                 sock->flag &= ~SOCK_IN_USE;
1797         }
1798         for (sock = ntree->outputs.first; sock; sock = sock->next) {
1799                 sock->link = NULL;
1800                 sock->flag &= ~SOCK_IN_USE;
1801         }
1802
1803         for (link = ntree->links.first; link; link = link->next) {
1804                 link->tosock->link = link;
1805                 
1806                 link->fromsock->flag |= SOCK_IN_USE;
1807                 link->tosock->flag |= SOCK_IN_USE;
1808         }
1809 }
1810
1811 static void ntree_validate_links(bNodeTree *ntree)
1812 {
1813         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1814         bNodeLink *link;
1815         
1816         for (link = ntree->links.first; link; link = link->next) {
1817                 link->flag |= NODE_LINK_VALID;
1818                 if (link->fromnode && link->tonode && link->fromnode->level <= link->tonode->level)
1819                         link->flag &= ~NODE_LINK_VALID;
1820                 else if (ntreetype->validate_link) {
1821                         if (!ntreetype->validate_link(ntree, link))
1822                                 link->flag &= ~NODE_LINK_VALID;
1823                 }
1824         }
1825 }
1826
1827 static void ntree_verify_nodes_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree)
1828 {
1829         ID *id = (ID *)calldata;
1830         bNode *node;
1831         
1832         for (node = ntree->nodes.first; node; node = node->next)
1833                 if (node->typeinfo->verifyfunc)
1834                         node->typeinfo->verifyfunc(ntree, node, id);
1835 }
1836
1837 void ntreeVerifyNodes(struct Main *main, struct ID *id)
1838 {
1839         bNodeTreeType *ntreetype;
1840         bNodeTree *ntree;
1841         int n;
1842         
1843         for (n = 0; n < NUM_NTREE_TYPES; ++n) {
1844                 ntreetype = ntreeGetType(n);
1845                 if (ntreetype && ntreetype->foreach_nodetree)
1846                         ntreetype->foreach_nodetree(main, id, ntree_verify_nodes_cb);
1847         }
1848         for (ntree = main->nodetree.first; ntree; ntree = ntree->id.next)
1849                 ntree_verify_nodes_cb(id, NULL, ntree);
1850 }
1851
1852 void ntreeUpdateTree(bNodeTree *ntree)
1853 {
1854         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1855         bNode *node;
1856         
1857         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES)) {
1858                 /* set the bNodeSocket->link pointers */
1859                 ntree_update_link_pointers(ntree);
1860                 
1861                 /* update the node level from link dependencies */
1862                 ntree_update_node_level(ntree);
1863         }
1864         
1865         /* update individual nodes */
1866         for (node = ntree->nodes.first; node; node = node->next) {
1867                 /* node tree update tags override individual node update flags */
1868                 if ((node->update & NODE_UPDATE) || (ntree->update & NTREE_UPDATE)) {
1869                         if (ntreetype->update_node)
1870                                 ntreetype->update_node(ntree, node);
1871                         else if (node->typeinfo->updatefunc)
1872                                 node->typeinfo->updatefunc(ntree, node);
1873                         
1874                         nodeUpdateInternalLinks(ntree, node);
1875                 }
1876         }
1877         
1878         /* check link validity */
1879         if (ntree->update & (NTREE_UPDATE_LINKS | NTREE_UPDATE_NODES))
1880                 ntree_validate_links(ntree);
1881         
1882         /* generic tree update callback */
1883         if (ntreetype->update)
1884                 ntreetype->update(ntree);
1885         else {
1886                 /* Trees can be associated with a specific node type (i.e. group nodes),
1887                  * in that case a tree update function may be defined by that node type.
1888                  */
1889                 bNodeType *ntype = node_get_type(ntree, ntree->nodetype);
1890                 if (ntype && ntype->updatetreefunc)
1891                         ntype->updatetreefunc(ntree);
1892         }
1893         
1894         /* XXX hack, should be done by depsgraph!! */
1895         ntreeVerifyNodes(G.main, &ntree->id);
1896         
1897         /* clear update flags */
1898         for (node = ntree->nodes.first; node; node = node->next) {
1899                 node->update = 0;
1900         }
1901         ntree->update = 0;
1902 }
1903
1904 void nodeUpdate(bNodeTree *ntree, bNode *node)
1905 {
1906         bNodeTreeType *ntreetype = ntreeGetType(ntree->type);
1907         
1908         if (ntreetype->update_node)
1909                 ntreetype->update_node(ntree, node);
1910         else if (node->typeinfo->updatefunc)
1911                 node->typeinfo->updatefunc(ntree, node);
1912         
1913         nodeUpdateInternalLinks(ntree, node);
1914         
1915         /* clear update flag */
1916         node->update = 0;
1917 }
1918
1919 int nodeUpdateID(bNodeTree *ntree, ID *id)
1920 {
1921         bNodeTreeType *ntreetype;
1922         bNode *node;
1923         int change = FALSE;
1924         
1925         if (ELEM(NULL, id, ntree))
1926                 return change;
1927         
1928         ntreetype = ntreeGetType(ntree->type);
1929         
1930         if (ntreetype->update_node) {
1931                 for (node = ntree->nodes.first; node; node = node->next) {
1932                         if (node->id == id) {
1933                                 change = TRUE;
1934                                 node->update |= NODE_UPDATE_ID;
1935                                 ntreetype->update_node(ntree, node);
1936                                 /* clear update flag */
1937                                 node->update = 0;
1938                         }
1939                 }
1940         }
1941         else {
1942                 for (node = ntree->nodes.first; node; node = node->next) {
1943                         if (node->id == id) {
1944                                 change = TRUE;
1945                                 node->update |= NODE_UPDATE_ID;
1946                                 if (node->typeinfo->updatefunc)
1947                                         node->typeinfo->updatefunc(ntree, node);
1948                                 /* clear update flag */
1949                                 node->update = 0;
1950                         }
1951                 }
1952         }
1953         
1954         for (node = ntree->nodes.first; node; node = node->next) {
1955                 nodeUpdateInternalLinks(ntree, node);
1956         }
1957         
1958         return change;
1959 }
1960
1961 void nodeUpdateInternalLinks(bNodeTree *ntree, bNode *node)
1962 {
1963         BLI_freelistN(&node->internal_links);
1964         
1965         if (node->typeinfo && node->typeinfo->update_internal_links)
1966                 node->typeinfo->update_internal_links(ntree, node);
1967 }
1968
1969
1970 /* ************* node type access ********** */
1971
1972 int nodeValid(bNodeTree *ntree, bNodeTemplate *ntemp)
1973 {
1974         bNodeType *ntype = node_get_type(ntree, ntemp->type);
1975         if (ntype) {
1976                 if (ntype->validfunc)
1977                         return ntype->validfunc(ntree, ntemp);
1978                 else
1979                         return 1;
1980         }
1981         else
1982                 return 0;
1983 }
1984
1985 const char *nodeLabel(bNode *node)
1986 {
1987         if (node->label[0] != '\0')
1988                 return node->label;
1989         else if (node->typeinfo->labelfunc)
1990                 return node->typeinfo->labelfunc(node);
1991         else
1992                 return IFACE_(node->typeinfo->name);
1993 }
1994
1995 struct bNodeTree *nodeGroupEditGet(struct bNode *node)
1996 {
1997         if (node->typeinfo->group_edit_get)
1998                 return node->typeinfo->group_edit_get(node);
1999         else
2000                 return NULL;
2001 }
2002
2003 struct bNodeTree *nodeGroupEditSet(struct bNode *node, int edit)
2004 {
2005         if (node->typeinfo->group_edit_set)
2006                 return node->typeinfo->group_edit_set(node, edit);
2007         else if (node->typeinfo->group_edit_get)
2008                 return node->typeinfo->group_edit_get(node);
2009         else
2010                 return NULL;
2011 }
2012
2013 void nodeGroupEditClear(struct bNode *node)
2014 {
2015         if (node->typeinfo->group_edit_clear)
2016                 node->typeinfo->group_edit_clear(node);
2017 }
2018
2019 struct bNodeTemplate nodeMakeTemplate(struct bNode *node)
2020 {
2021         bNodeTemplate ntemp;
2022         if (node->typeinfo->templatefunc)
2023                 return node->typeinfo->templatefunc(node);
2024         else {
2025                 ntemp.type = node->type;
2026                 return ntemp;
2027         }
2028 }
2029
2030 void node_type_base(bNodeTreeType *ttype, bNodeType *ntype, int type, const char *name, short nclass, short flag)
2031 {
2032         memset(ntype, 0, sizeof(bNodeType));
2033
2034         ntype->type = type;
2035         BLI_strncpy(ntype->name, name, sizeof(ntype->name));
2036         ntype->nclass = nclass;
2037         ntype->flag = flag;
2038
2039         /* Default muting stuff. */
2040         if (ttype)
2041                 ntype->update_internal_links = ttype->update_internal_links;
2042
2043         /* default size values */
2044         node_type_size_preset(ntype, NODE_SIZE_DEFAULT);
2045         
2046         ntype->height = 100;
2047         ntype->minheight = 30;
2048         ntype->maxheight = FLT_MAX;
2049 }
2050
2051 void node_type_socket_templates(struct bNodeType *ntype, struct bNodeSocketTemplate *inputs, struct bNodeSocketTemplate *outputs)
2052 {
2053         ntype->inputs = inputs;
2054         ntype->outputs = outputs;
2055 }
2056
2057 void node_type_init(struct bNodeType *ntype, void (*initfunc)(struct bNodeTree *ntree, struct bNode *node, struct bNodeTemplate *ntemp))
2058 {
2059         ntype->initfunc = initfunc;
2060 }
2061
2062 void node_type_valid(struct bNodeType *ntype, int (*validfunc)(struct bNodeTree *ntree, struct bNodeTemplate *ntemp))
2063 {
2064         ntype->validfunc = validfunc;
2065 }
2066
2067 void node_type_size(struct bNodeType *ntype, int width, int minwidth, int maxwidth)
2068 {
2069         ntype->width = width;
2070         ntype->minwidth = minwidth;
2071         if (maxwidth <= minwidth)
2072                 ntype->maxwidth = FLT_MAX;
2073         else
2074                 ntype->maxwidth = maxwidth;
2075 }
2076
2077 void node_type_size_preset(struct bNodeType *ntype, eNodeSizePreset size)
2078 {
2079         switch (size) {
2080                 case NODE_SIZE_DEFAULT:
2081                         node_type_size(ntype, 140, 100, 320);
2082                         break;
2083                 case NODE_SIZE_SMALL:
2084                         node_type_size(ntype, 100, 80, 320);
2085                         break;
2086                 case NODE_SIZE_LARGE:
2087                         node_type_size(ntype, 140, 120, 500);
2088                         break;
2089         }
2090 }
2091
2092 void node_type_storage(bNodeType *ntype, const char *storagename, void (*freestoragefunc)(struct bNode *), void (*copystoragefunc)(struct bNode *, struct bNode *))
2093 {
2094         if (storagename)
2095                 BLI_strncpy(ntype->storagename, storagename, sizeof(ntype->storagename));
2096         else
2097                 ntype->storagename[0] = '\0';
2098         ntype->copystoragefunc = copystoragefunc;
2099         ntype->freestoragefunc = freestoragefunc;
2100 }
2101
2102 void node_type_label(struct bNodeType *ntype, const char *(*labelfunc)(struct bNode *))
2103 {
2104         ntype->labelfunc = labelfunc;
2105 }
2106
2107 void node_type_template(struct bNodeType *ntype, struct bNodeTemplate (*templatefunc)(struct bNode *))
2108 {
2109         ntype->templatefunc = templatefunc;
2110 }
2111
2112 void node_type_update(struct bNodeType *ntype,
2113                       void (*updatefunc)(struct bNodeTree *ntree, struct bNode *node),
2114                       void (*verifyfunc)(struct bNodeTree *ntree, struct bNode *node, struct ID *id))
2115 {
2116         ntype->updatefunc = updatefunc;
2117         ntype->verifyfunc = verifyfunc;
2118 }
2119
2120 void node_type_tree(struct bNodeType *ntype, void (*inittreefunc)(struct bNodeTree *), void (*updatetreefunc)(struct bNodeTree *))
2121 {
2122         ntype->inittreefunc = inittreefunc;
2123         ntype->updatetreefunc = updatetreefunc;
2124 }
2125
2126 void node_type_group_edit(struct bNodeType *ntype,
2127                           struct bNodeTree *(*group_edit_get)(struct bNode *node),
2128                           struct bNodeTree *(*group_edit_set)(struct bNode *node, int edit),
2129                           void (*group_edit_clear)(struct bNode *node))
2130 {
2131         ntype->group_edit_get = group_edit_get;
2132         ntype->group_edit_set = group_edit_set;
2133         ntype->group_edit_clear = group_edit_clear;
2134 }
2135
2136 void node_type_exec(struct bNodeType *ntype, void (*execfunc)(void *data, struct bNode *, struct bNodeStack **, struct bNodeStack **))
2137 {
2138         ntype->execfunc = execfunc;
2139 }
2140
2141 void node_type_exec_new(struct bNodeType *ntype,
2142                         void *(*initexecfunc)(struct bNode *node),
2143                         void (*freeexecfunc)(struct bNode *node, void *nodedata),
2144                         void (*newexecfunc)(void *data, int thread, struct bNode *, void *nodedata, struct bNodeStack **, struct bNodeStack **))
2145 {
2146         ntype->initexecfunc = initexecfunc;
2147         ntype->freeexecfunc = freeexecfunc;
2148         ntype->newexecfunc = newexecfunc;
2149 }
2150
2151 void node_type_internal_links(bNodeType *ntype, void (*update_internal_links)(bNodeTree *, bNode *))
2152 {
2153         ntype->update_internal_links = update_internal_links;
2154 }
2155
2156 void node_type_gpu(struct bNodeType *ntype, int (*gpufunc)(struct GPUMaterial *mat, struct bNode *node, struct GPUNodeStack *in, struct GPUNodeStack *out))
2157 {
2158         ntype->gpufunc = gpufunc;
2159 }
2160
2161 void node_type_gpu_ext(struct bNodeType *ntype, int (*gpuextfunc)(struct GPUMaterial *mat, struct bNode *node, void *nodedata, struct GPUNodeStack *in, struct GPUNodeStack *out))
2162 {
2163         ntype->gpuextfunc = gpuextfunc;
2164 }
2165
2166 void node_type_compatibility(struct bNodeType *ntype, short compatibility)
2167 {
2168         ntype->compatibility = compatibility;
2169 }
2170
2171 static bNodeType *is_nodetype_registered(ListBase *typelist, int type) 
2172 {
2173         bNodeType *ntype = typelist->first;
2174         
2175         for (; ntype; ntype = ntype->next)
2176                 if (ntype->type == type)
2177                         return ntype;
2178         
2179         return NULL;
2180 }
2181
2182 void nodeRegisterType(bNodeTreeType *ttype, bNodeType *ntype) 
2183 {
2184         ListBase *typelist = &(ttype->node_types);
2185         bNodeType *found = is_nodetype_registered(typelist, ntype->type);
2186         
2187         if (found == NULL)
2188                 BLI_addtail(typelist, ntype);
2189         
2190         /* Associate the RNA struct type with the bNodeType.
2191          * Dynamically registered nodes will create an RNA type at runtime
2192          * and call RNA_struct_blender_type_set, so this only needs to be done for old RNA types
2193          * created in makesrna, which can not be associated to a bNodeType immediately,
2194          * since bNodeTypes are registered afterward ...
2195          */
2196         #define DefNode(Category, ID, DefFunc, EnumName, StructName, UIName, UIDesc) \
2197         if (ID == ntype->type) { \
2198                 StructRNA *srna = RNA_struct_find(STRINGIFY_ARG(Category##StructName)); \
2199                 BLI_assert(srna != NULL); \
2200                 RNA_struct_blender_type_set(srna, ntype); \
2201         }
2202         
2203         /* XXX hack, this file will be moved to the nodes folder in customnodes branch,
2204          * then this stupid include path is not needed any more.
2205          */
2206         #include "intern/rna_nodetree_types.h"
2207 }
2208
2209 static void registerCompositNodes(bNodeTreeType *ttype)
2210 {
2211         register_node_type_frame(ttype);
2212         register_node_type_reroute(ttype);
2213         
2214         register_node_type_cmp_group(ttype);
2215         
2216         register_node_type_cmp_rlayers(ttype);
2217         register_node_type_cmp_image(ttype);
2218         register_node_type_cmp_texture(ttype);
2219         register_node_type_cmp_value(ttype);
2220         register_node_type_cmp_rgb(ttype);
2221         register_node_type_cmp_curve_time(ttype);
2222         register_node_type_cmp_movieclip(ttype);
2223         
2224         register_node_type_cmp_composite(ttype);
2225         register_node_type_cmp_viewer(ttype);
2226         register_node_type_cmp_splitviewer(ttype);
2227         register_node_type_cmp_output_file(ttype);
2228         register_node_type_cmp_view_levels(ttype);
2229         
2230         register_node_type_cmp_curve_rgb(ttype);
2231         register_node_type_cmp_mix_rgb(ttype);
2232         register_node_type_cmp_hue_sat(ttype);
2233         register_node_type_cmp_brightcontrast(ttype);
2234         register_node_type_cmp_gamma(ttype);
2235         register_node_type_cmp_invert(ttype);
2236         register_node_type_cmp_alphaover(ttype);
2237         register_node_type_cmp_zcombine(ttype);
2238         register_node_type_cmp_colorbalance(ttype);
2239         register_node_type_cmp_huecorrect(ttype);
2240         
2241         register_node_type_cmp_normal(ttype);
2242         register_node_type_cmp_curve_vec(ttype);
2243         register_node_type_cmp_map_value(ttype);
2244         register_node_type_cmp_map_range(ttype);
2245         register_node_type_cmp_normalize(ttype);
2246         
2247         register_node_type_cmp_filter(ttype);
2248         register_node_type_cmp_blur(ttype);
2249         register_node_type_cmp_dblur(ttype);
2250         register_node_type_cmp_bilateralblur(ttype);
2251         register_node_type_cmp_vecblur(ttype);
2252         register_node_type_cmp_dilateerode(ttype);
2253         register_node_type_cmp_inpaint(ttype);
2254         register_node_type_cmp_despeckle(ttype);
2255         register_node_type_cmp_defocus(ttype);
2256         
2257         register_node_type_cmp_valtorgb(ttype);
2258         register_node_type_cmp_rgbtobw(ttype);
2259         register_node_type_cmp_setalpha(ttype);
2260         register_node_type_cmp_idmask(ttype);
2261         register_node_type_cmp_math(ttype);
2262         register_node_type_cmp_seprgba(ttype);
2263         register_node_type_cmp_combrgba(ttype);
2264         register_node_type_cmp_sephsva(ttype);
2265         register_node_type_cmp_combhsva(ttype);
2266         register_node_type_cmp_sepyuva(ttype);
2267         register_node_type_cmp_combyuva(ttype);
2268         register_node_type_cmp_sepycca(ttype);
2269         register_node_type_cmp_combycca(ttype);
2270         register_node_type_cmp_premulkey(ttype);
2271         
2272         register_node_type_cmp_diff_matte(ttype);
2273         register_node_type_cmp_distance_matte(ttype);
2274         register_node_type_cmp_chroma_matte(ttype);
2275         register_node_type_cmp_color_matte(ttype);
2276         register_node_type_cmp_channel_matte(ttype);
2277         register_node_type_cmp_color_spill(ttype);
2278         register_node_type_cmp_luma_matte(ttype);
2279         register_node_type_cmp_doubleedgemask(ttype);
2280         register_node_type_cmp_keyingscreen(ttype);
2281         register_node_type_cmp_keying(ttype);
2282
2283         register_node_type_cmp_translate(ttype);
2284         register_node_type_cmp_rotate(ttype);
2285         register_node_type_cmp_scale(ttype);
2286         register_node_type_cmp_flip(ttype);
2287         register_node_type_cmp_crop(ttype);
2288         register_node_type_cmp_displace(ttype);
2289         register_node_type_cmp_mapuv(ttype);
2290         register_node_type_cmp_glare(ttype);
2291         register_node_type_cmp_tonemap(ttype);
2292         register_node_type_cmp_lensdist(ttype);
2293         register_node_type_cmp_transform(ttype);
2294         register_node_type_cmp_stabilize2d(ttype);
2295         register_node_type_cmp_moviedistortion(ttype);
2296
2297         register_node_type_cmp_colorcorrection(ttype);
2298         register_node_type_cmp_boxmask(ttype);
2299         register_node_type_cmp_ellipsemask(ttype);
2300         register_node_type_cmp_bokehimage(ttype);
2301         register_node_type_cmp_bokehblur(ttype);
2302         register_node_type_cmp_switch(ttype);
2303         register_node_type_cmp_pixelate(ttype);
2304
2305         register_node_type_cmp_mask(ttype);
2306         register_node_type_cmp_trackpos(ttype);
2307 }
2308
2309 static void registerShaderNodes(bNodeTreeType *ttype) 
2310 {
2311         register_node_type_frame(ttype);
2312         register_node_type_reroute(ttype);
2313         
2314         register_node_type_sh_group(ttype);
2315
2316         register_node_type_sh_output(ttype);
2317         register_node_type_sh_material(ttype);
2318         register_node_type_sh_camera(ttype);
2319         register_node_type_sh_gamma(ttype);
2320         register_node_type_sh_brightcontrast(ttype);
2321         register_node_type_sh_value(ttype);
2322         register_node_type_sh_rgb(ttype);
2323         register_node_type_sh_mix_rgb(ttype);
2324         register_node_type_sh_valtorgb(ttype);
2325         register_node_type_sh_rgbtobw(ttype);
2326         register_node_type_sh_texture(ttype);
2327         register_node_type_sh_normal(ttype);
2328         register_node_type_sh_geom(ttype);
2329         register_node_type_sh_mapping(ttype);
2330         register_node_type_sh_curve_vec(ttype);
2331         register_node_type_sh_curve_rgb(ttype);
2332         register_node_type_sh_math(ttype);
2333         register_node_type_sh_vect_math(ttype);
2334         register_node_type_sh_squeeze(ttype);
2335         register_node_type_sh_material_ext(ttype);
2336         register_node_type_sh_invert(ttype);
2337         register_node_type_sh_seprgb(ttype);
2338         register_node_type_sh_combrgb(ttype);
2339         register_node_type_sh_hue_sat(ttype);
2340
2341         register_node_type_sh_attribute(ttype);
2342         register_node_type_sh_geometry(ttype);
2343         register_node_type_sh_light_path(ttype);
2344         register_node_type_sh_light_falloff(ttype);
2345         register_node_type_sh_object_info(ttype);
2346         register_node_type_sh_fresnel(ttype);
2347         register_node_type_sh_layer_weight(ttype);
2348         register_node_type_sh_tex_coord(ttype);
2349         register_node_type_sh_particle_info(ttype);
2350         register_node_type_sh_hair_info(ttype);
2351         register_node_type_sh_bump(ttype);
2352         register_node_type_sh_script(ttype);
2353         register_node_type_sh_tangent(ttype);
2354         register_node_type_sh_normal_map(ttype);
2355
2356         register_node_type_sh_background(ttype);
2357         register_node_type_sh_bsdf_anisotropic(ttype);
2358         register_node_type_sh_bsdf_diffuse(ttype);
2359         register_node_type_sh_bsdf_glossy(ttype);
2360         register_node_type_sh_bsdf_glass(ttype);
2361         register_node_type_sh_bsdf_refraction(ttype);
2362         register_node_type_sh_bsdf_translucent(ttype);
2363         register_node_type_sh_bsdf_transparent(ttype);
2364         register_node_type_sh_bsdf_velvet(ttype);
2365         register_node_type_sh_emission(ttype);
2366         register_node_type_sh_holdout(ttype);
2367         register_node_type_sh_ambient_occlusion(ttype);
2368         //register_node_type_sh_volume_transparent(ttype);
2369         //register_node_type_sh_volume_isotropic(ttype);
2370         register_node_type_sh_mix_shader(ttype);
2371         register_node_type_sh_add_shader(ttype);
2372
2373         register_node_type_sh_output_lamp(ttype);
2374         register_node_type_sh_output_material(ttype);
2375         register_node_type_sh_output_world(ttype);
2376
2377         register_node_type_sh_tex_image(ttype);
2378         register_node_type_sh_tex_environment(ttype);
2379         register_node_type_sh_tex_sky(ttype);
2380         register_node_type_sh_tex_noise(ttype);
2381         register_node_type_sh_tex_wave(ttype);
2382         register_node_type_sh_tex_voronoi(ttype);
2383         register_node_type_sh_tex_musgrave(ttype);
2384         register_node_type_sh_tex_gradient(ttype);
2385         register_node_type_sh_tex_magic(ttype);
2386         register_node_type_sh_tex_checker(ttype);
2387         register_node_type_sh_tex_brick(ttype);
2388 }
2389
2390 static void registerTextureNodes(bNodeTreeType *ttype)
2391 {
2392         register_node_type_frame(ttype);
2393         register_node_type_reroute(ttype);
2394         
2395         register_node_type_tex_group(ttype);
2396         
2397         register_node_type_tex_math(ttype);
2398         register_node_type_tex_mix_rgb(ttype);
2399         register_node_type_tex_valtorgb(ttype);
2400         register_node_type_tex_rgbtobw(ttype);
2401         register_node_type_tex_valtonor(ttype);
2402         register_node_type_tex_curve_rgb(ttype);
2403         register_node_type_tex_curve_time(ttype);
2404         register_node_type_tex_invert(ttype);
2405         register_node_type_tex_hue_sat(ttype);
2406         register_node_type_tex_coord(ttype);
2407         register_node_type_tex_distance(ttype);
2408         register_node_type_tex_compose(ttype);
2409         register_node_type_tex_decompose(ttype);
2410         
2411         register_node_type_tex_output(ttype);
2412         register_node_type_tex_viewer(ttype);
2413         
2414         register_node_type_tex_checker(ttype);
2415         register_node_type_tex_texture(ttype);
2416         register_node_type_tex_bricks(ttype);
2417         register_node_type_tex_image(ttype);
2418         
2419         register_node_type_tex_rotate(ttype);
2420         register_node_type_tex_translate(ttype);
2421         register_node_type_tex_scale(ttype);
2422         register_node_type_tex_at(ttype);
2423         
2424         register_node_type_tex_proc_voronoi(ttype);
2425         register_node_type_tex_proc_blend(ttype);
2426         register_node_type_tex_proc_magic(ttype);
2427         register_node_type_tex_proc_marble(ttype);
2428         register_node_type_tex_proc_clouds(ttype);
2429         register_node_type_tex_proc_wood(ttype);
2430         register_node_type_tex_proc_musgrave(ttype);
2431         register_node_type_tex_proc_noise(ttype);
2432         register_node_type_tex_proc_stucci(ttype);
2433         register_node_type_tex_proc_distnoise(ttype);
2434 }
2435
2436 static void free_typeinfos(ListBase *list)
2437 {
2438         bNodeType *ntype, *next;
2439         for (ntype = list->first; ntype; ntype = next) {
2440                 next = ntype->next;
2441
2442                 if (ntype->needs_free)
2443                         MEM_freeN(ntype);
2444         }
2445 }
2446
2447 void init_nodesystem(void) 
2448 {
2449         /* init clipboard */
2450         node_clipboard.nodes.first = node_clipboard.nodes.last = NULL;
2451         node_clipboard.links.first = node_clipboard.links.last = NULL;
2452         
2453         registerCompositNodes(ntreeGetType(NTREE_COMPOSIT));
2454         registerShaderNodes(ntreeGetType(NTREE_SHADER));
2455         registerTextureNodes(ntreeGetType(NTREE_TEXTURE));
2456 }
2457
2458 void free_nodesystem(void) 
2459 {
2460         free_typeinfos(&ntreeGetType(NTREE_COMPOSIT)->node_types);
2461         free_typeinfos(&ntreeGetType(NTREE_SHADER)->node_types);
2462         free_typeinfos(&ntreeGetType(NTREE_TEXTURE)->node_types);
2463 }
2464
2465 /* called from BKE_scene_unlink, when deleting a scene goes over all scenes
2466  * other than the input, checks if they have render layer nodes referencing
2467  * the to-be-deleted scene, and resets them to NULL. */
2468
2469 /* XXX needs to get current scene then! */
2470 void clear_scene_in_nodes(Main *bmain, Scene *sce)
2471 {
2472         Scene *sce1;
2473         bNode *node;
2474
2475         for (sce1 = bmain->scene.first; sce1; sce1 = sce1->id.next) {
2476                 if (sce1 != sce) {
2477                         if (sce1->nodetree) {
2478                                 for (node = sce1->nodetree->nodes.first; node; node = node->next) {
2479                                         if (node->type == CMP_NODE_R_LAYERS) {
2480                                                 Scene *nodesce = (Scene *)node->id;
2481                                                 
2482                                                 if (nodesce == sce) node->id = NULL;
2483                                         }
2484                                 }
2485                         }
2486                 }
2487         }
2488 }