c465f7a9be51b7194e2916a06a6b389922d54c3d
[blender.git] / source / blender / nodes / intern / node_common.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) 2007 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Lukas Toenne.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/nodes/intern/node_common.c
29  *  \ingroup nodes
30  */
31
32 #include <string.h>
33 #include <stddef.h>
34
35 #include "DNA_node_types.h"
36
37 #include "BLI_listbase.h"
38 #include "BLI_string.h"
39 #include "BLI_utildefines.h"
40
41 #include "BLT_translation.h"
42
43 #include "BKE_node.h"
44
45 #include "RNA_types.h"
46
47 #include "MEM_guardedalloc.h"
48
49 #include "node_common.h"
50 #include "node_util.h"
51 #include "NOD_common.h"
52
53 enum {
54         REFINE_FORWARD  = 1 << 0,
55         REFINE_BACKWARD = 1 << 1,
56 };
57
58 /**** Group ****/
59
60 bNodeSocket *node_group_find_input_socket(bNode *groupnode, const char *identifier)
61 {
62         bNodeSocket *sock;
63         for (sock = groupnode->inputs.first; sock; sock = sock->next)
64                 if (STREQ(sock->identifier, identifier))
65                         return sock;
66         return NULL;
67 }
68
69 bNodeSocket *node_group_find_output_socket(bNode *groupnode, const char *identifier)
70 {
71         bNodeSocket *sock;
72         for (sock = groupnode->outputs.first; sock; sock = sock->next)
73                 if (STREQ(sock->identifier, identifier))
74                         return sock;
75         return NULL;
76 }
77
78 /* groups display their internal tree name as label */
79 void node_group_label(bNodeTree *UNUSED(ntree), bNode *node, char *label, int maxlen)
80 {
81         BLI_strncpy(label, (node->id) ? node->id->name + 2 : IFACE_("Missing Data-Block"), maxlen);
82 }
83
84 int node_group_poll_instance(bNode *node, bNodeTree *nodetree)
85 {
86         if (node->typeinfo->poll(node->typeinfo, nodetree)) {
87                 bNodeTree *grouptree = (bNodeTree *)node->id;
88                 if (grouptree)
89                         return nodeGroupPoll(nodetree, grouptree);
90                 else
91                         return true;    /* without a linked node tree, group node is always ok */
92         }
93         else
94                 return false;
95 }
96
97 int nodeGroupPoll(bNodeTree *nodetree, bNodeTree *grouptree)
98 {
99         bNode *node;
100         int valid = 1;
101         
102         /* unspecified node group, generally allowed
103          * (if anything, should be avoided on operator level)
104          */
105         if (grouptree == NULL)
106                 return 1;
107         
108         if (nodetree == grouptree)
109                 return 0;
110         
111         for (node = grouptree->nodes.first; node; node = node->next) {
112                 if (node->typeinfo->poll_instance && !node->typeinfo->poll_instance(node, nodetree)) {
113                         valid = 0;
114                         break;
115                 }
116         }
117         return valid;
118 }
119
120 /* used for both group nodes and interface nodes */
121 static bNodeSocket *group_verify_socket(bNodeTree *ntree, bNode *gnode, bNodeSocket *iosock, ListBase *verify_lb, int in_out)
122 {
123         bNodeSocket *sock;
124         
125         for (sock = verify_lb->first; sock; sock = sock->next) {
126                 if (STREQ(sock->identifier, iosock->identifier))
127                         break;
128         }
129         if (sock) {
130                 strcpy(sock->name, iosock->name);
131                 
132                 if (iosock->typeinfo->interface_verify_socket)
133                         iosock->typeinfo->interface_verify_socket(ntree, iosock, gnode, sock, "interface");
134         }
135         else {
136                 sock = nodeAddSocket(ntree, gnode, in_out, iosock->idname, iosock->identifier, iosock->name);
137                 
138                 if (iosock->typeinfo->interface_init_socket)
139                         iosock->typeinfo->interface_init_socket(ntree, iosock, gnode, sock, "interface");
140         }
141         
142         /* remove from list temporarily, to distinguish from orphaned sockets */
143         BLI_remlink(verify_lb, sock);
144         
145         return sock;
146 }
147
148 /* used for both group nodes and interface nodes */
149 static void group_verify_socket_list(bNodeTree *ntree, bNode *gnode,
150                                      ListBase *iosock_lb, ListBase *verify_lb, int in_out)
151 {
152         bNodeSocket *iosock, *sock, *nextsock;
153         
154         /* step by step compare */
155         
156         iosock = iosock_lb->first;
157         for (; iosock; iosock = iosock->next) {
158                 /* abusing new_sock pointer for verification here! only used inside this function */
159                 iosock->new_sock = group_verify_socket(ntree, gnode, iosock, verify_lb, in_out);
160         }
161         /* leftovers are removed */
162         for (sock = verify_lb->first; sock; sock = nextsock) {
163                 nextsock = sock->next;
164                 nodeRemoveSocket(ntree, gnode, sock);
165         }
166         /* and we put back the verified sockets */
167         iosock = iosock_lb->first;
168         for (; iosock; iosock = iosock->next) {
169                 if (iosock->new_sock) {
170                         BLI_addtail(verify_lb, iosock->new_sock);
171                         iosock->new_sock = NULL;
172                 }
173         }
174 }
175
176 /* make sure all group node in ntree, which use ngroup, are sync'd */
177 void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id)
178 {
179         /* check inputs and outputs, and remove or insert them */
180         if (id == node->id) {
181                 if (id == NULL) {
182                         nodeRemoveAllSockets(ntree, node);
183                 }
184                 else {
185                         bNodeTree *ngroup = (bNodeTree *)node->id;
186                         group_verify_socket_list(ntree, node, &ngroup->inputs, &node->inputs, SOCK_IN);
187                         group_verify_socket_list(ntree, node, &ngroup->outputs, &node->outputs, SOCK_OUT);
188                 }
189         }
190 }
191
192 /**** FRAME ****/
193
194 static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node)
195 {
196         NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
197         node->storage = data;
198         
199         data->flag |= NODE_FRAME_SHRINK;
200         
201         data->label_size = 20;
202 }
203
204 void register_node_type_frame(void)
205 {
206         /* frame type is used for all tree types, needs dynamic allocation */
207         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "frame node type");
208
209         node_type_base(ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND);
210         node_type_init(ntype, node_frame_init);
211         node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
212         node_type_size(ntype, 150, 100, 0);
213         node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
214         
215         ntype->needs_free = 1;
216         nodeRegisterType(ntype);
217 }
218
219
220 /* **************** REROUTE ******************** */
221
222 /* simple, only a single input and output here */
223 static void node_reroute_update_internal_links(bNodeTree *ntree, bNode *node)
224 {
225         bNodeLink *link;
226
227         /* Security check! */
228         if (!ntree)
229                 return;
230
231         link = MEM_callocN(sizeof(bNodeLink), "internal node link");
232         link->fromnode = node;
233         link->fromsock = node->inputs.first;
234         link->tonode = node;
235         link->tosock = node->outputs.first;
236         /* internal link is always valid */
237         link->flag |= NODE_LINK_VALID;
238         BLI_addtail(&node->internal_links, link);
239 }
240
241 static void node_reroute_init(bNodeTree *ntree, bNode *node)
242 {
243         /* Note: Cannot use socket templates for this, since it would reset the socket type
244          * on each file read via the template verification procedure.
245          */
246         nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "Input", "Input");
247         nodeAddStaticSocket(ntree, node, SOCK_OUT, SOCK_RGBA, PROP_NONE, "Output", "Output");
248 }
249
250 void register_node_type_reroute(void)
251 {
252         /* frame type is used for all tree types, needs dynamic allocation */
253         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "frame node type");
254         
255         node_type_base(ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
256         node_type_init(ntype, node_reroute_init);
257         node_type_internal_links(ntype, node_reroute_update_internal_links);
258         
259         ntype->needs_free = 1;
260         nodeRegisterType(ntype);
261 }
262
263 static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node, int flag)
264 {
265         bNodeSocket *input = node->inputs.first;
266         bNodeSocket *output = node->outputs.first;
267         bNodeLink *link;
268         int type = SOCK_FLOAT;
269         const char *type_idname = nodeStaticSocketType(type, PROP_NONE);
270         
271         /* XXX it would be a little bit more efficient to restrict actual updates
272          * to rerout nodes connected to an updated node, but there's no reliable flag
273          * to indicate updated nodes (node->update is not set on linking).
274          */
275         
276         node->done = 1;
277         
278         /* recursive update */
279         for (link = ntree->links.first; link; link = link->next) {
280                 bNode *fromnode = link->fromnode;
281                 bNode *tonode = link->tonode;
282                 if (!tonode || !fromnode)
283                         continue;
284                 if (nodeLinkIsHidden(link))
285                         continue;
286                 
287                 if (flag & REFINE_FORWARD) {
288                         if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done)
289                                 node_reroute_inherit_type_recursive(ntree, fromnode, REFINE_FORWARD);
290                 }
291                 if (flag & REFINE_BACKWARD) {
292                         if (fromnode == node && tonode->type == NODE_REROUTE && !tonode->done)
293                                 node_reroute_inherit_type_recursive(ntree, tonode, REFINE_BACKWARD);
294                 }
295         }
296         
297         /* determine socket type from unambiguous input/output connection if possible */
298         if (input->limit == 1 && input->link) {
299                 type = input->link->fromsock->type;
300                 type_idname = nodeStaticSocketType(type, PROP_NONE);
301         }
302         else if (output->limit == 1 && output->link) {
303                 type = output->link->tosock->type;
304                 type_idname = nodeStaticSocketType(type, PROP_NONE);
305         }
306         
307         if (input->type != type) {
308                 bNodeSocket *ninput = nodeAddSocket(ntree, node, SOCK_IN, type_idname, "input", "Input");
309                 for (link = ntree->links.first; link; link = link->next) {
310                         if (link->tosock == input) {
311                                 link->tosock = ninput;
312                                 ninput->link = link;
313                         }
314                 }
315                 nodeRemoveSocket(ntree, node, input);
316         }
317         
318         if (output->type != type) {
319                 bNodeSocket *noutput = nodeAddSocket(ntree, node, SOCK_OUT, type_idname, "output", "Output");
320                 for (link = ntree->links.first; link; link = link->next) {
321                         if (link->fromsock == output) {
322                                 link->fromsock = noutput;
323                         }
324                 }
325                 nodeRemoveSocket(ntree, node, output);
326         }
327         
328         nodeUpdateInternalLinks(ntree, node);
329 }
330
331 /* Global update function for Reroute node types.
332  * This depends on connected nodes, so must be done as a tree-wide update.
333  */
334 void ntree_update_reroute_nodes(bNodeTree *ntree)
335 {
336         bNode *node;
337         
338         /* clear tags */
339         for (node = ntree->nodes.first; node; node = node->next)
340                 node->done = 0;
341         
342         for (node = ntree->nodes.first; node; node = node->next)
343                 if (node->type == NODE_REROUTE && !node->done)
344                         node_reroute_inherit_type_recursive(ntree, node, REFINE_FORWARD | REFINE_BACKWARD);
345 }
346
347 static bool node_is_connected_to_output_recursive(bNodeTree *ntree, bNode *node)
348 {
349         bNodeLink *link;
350
351         /* avoid redundant checks, and infinite loops in case of cyclic node links */
352         if (node->done)
353                 return false;
354         node->done = 1;
355
356         /* main test, done before child loop so it catches output nodes themselves as well */
357         if (node->typeinfo->nclass == NODE_CLASS_OUTPUT && node->flag & NODE_DO_OUTPUT)
358                 return true;
359
360         /* test all connected nodes, first positive find is sufficient to return true */
361         for (link = ntree->links.first; link; link = link->next) {
362                 if (link->fromnode == node) {
363                         if (node_is_connected_to_output_recursive(ntree, link->tonode))
364                                 return true;
365                 }
366         }
367         return false;
368 }
369
370 bool BKE_node_is_connected_to_output(bNodeTree *ntree, bNode *node)
371 {
372         bNode *tnode;
373
374         /* clear flags */
375         for (tnode = ntree->nodes.first; tnode; tnode = tnode->next)
376                 tnode->done = 0;
377
378         return node_is_connected_to_output_recursive(ntree, node);
379 }
380
381 void BKE_node_tree_unlink_id(ID *id, struct bNodeTree *ntree)
382 {
383         bNode *node;
384
385         for (node = ntree->nodes.first; node; node = node->next) {
386                 if (node->id == id) {
387                         node->id = NULL;
388                 }
389         }
390 }
391
392 /**** GROUP_INPUT / GROUP_OUTPUT ****/
393
394 static void node_group_input_init(bNodeTree *ntree, bNode *node)
395 {
396         node_group_input_verify(ntree, node, (ID *)ntree);
397 }
398
399 bNodeSocket *node_group_input_find_socket(bNode *node, const char *identifier)
400 {
401         bNodeSocket *sock;
402         for (sock = node->outputs.first; sock; sock = sock->next)
403                 if (STREQ(sock->identifier, identifier))
404                         return sock;
405         return NULL;
406 }
407
408 void node_group_input_verify(bNodeTree *ntree, bNode *node, ID *id)
409 {
410         /* check inputs and outputs, and remove or insert them */
411         if (id == (ID *)ntree) {
412                 /* value_in_out inverted for interface nodes to get correct socket value_property */
413                 group_verify_socket_list(ntree, node, &ntree->inputs, &node->outputs, SOCK_OUT);
414                 
415                 /* add virtual extension socket */
416                 nodeAddSocket(ntree, node, SOCK_OUT, "NodeSocketVirtual", "__extend__", "");
417         }
418 }
419
420 static void node_group_input_update(bNodeTree *ntree, bNode *node)
421 {
422         bNodeSocket *extsock = node->outputs.last;
423         bNodeLink *link, *linknext, *exposelink;
424         /* Adding a tree socket and verifying will remove the extension socket!
425          * This list caches the existing links from the extension socket
426          * so they can be recreated after verification.
427          */
428         ListBase tmplinks;
429         
430         /* find links from the extension socket and store them */
431         BLI_listbase_clear(&tmplinks);
432         for (link = ntree->links.first; link; link = linknext) {
433                 linknext = link->next;
434                 if (nodeLinkIsHidden(link))
435                         continue;
436                 
437                 if (link->fromsock == extsock) {
438                         bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
439                         *tlink = *link;
440                         BLI_addtail(&tmplinks, tlink);
441                         
442                         nodeRemLink(ntree, link);
443                 }
444         }
445         
446         /* find valid link to expose */
447         exposelink = NULL;
448         for (link = tmplinks.first; link; link = link->next) {
449                 /* XXX Multiple sockets can be connected to the extension socket at once,
450                  * in that case the arbitrary first link determines name and type.
451                  * This could be improved by choosing the "best" type among all links,
452                  * whatever that means.
453                  */
454                 if (link->tosock->type != SOCK_CUSTOM) {
455                         exposelink = link;
456                         break;
457                 }
458         }
459         
460         if (exposelink) {
461                 bNodeSocket *gsock, *newsock;
462                 
463                 gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->tonode, exposelink->tosock);
464                 
465                 node_group_input_verify(ntree, node, (ID *)ntree);
466                 newsock = node_group_input_find_socket(node, gsock->identifier);
467                 
468                 /* redirect links from the extension socket */
469                 for (link = tmplinks.first; link; link = link->next) {
470                         nodeAddLink(ntree, node, newsock, link->tonode, link->tosock);
471                 }
472                 
473         }
474         
475         BLI_freelistN(&tmplinks);
476 }
477
478 void register_node_type_group_input(void)
479 {
480         /* used for all tree types, needs dynamic allocation */
481         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
482         
483         node_type_base(ntype, NODE_GROUP_INPUT, "Group Input", NODE_CLASS_INTERFACE, 0);
484         node_type_size(ntype, 140, 80, 400);
485         node_type_init(ntype, node_group_input_init);
486         node_type_update(ntype, node_group_input_update, node_group_input_verify);
487         node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
488         
489         ntype->needs_free = 1;
490         nodeRegisterType(ntype);
491 }
492
493 static void node_group_output_init(bNodeTree *ntree, bNode *node)
494 {
495         node_group_output_verify(ntree, node, (ID *)ntree);
496 }
497
498 bNodeSocket *node_group_output_find_socket(bNode *node, const char *identifier)
499 {
500         bNodeSocket *sock;
501         for (sock = node->inputs.first; sock; sock = sock->next)
502                 if (STREQ(sock->identifier, identifier))
503                         return sock;
504         return NULL;
505 }
506
507 void node_group_output_verify(bNodeTree *ntree, bNode *node, ID *id)
508 {
509         /* check inputs and outputs, and remove or insert them */
510         if (id == (ID *)ntree) {
511                 /* value_in_out inverted for interface nodes to get correct socket value_property */
512                 group_verify_socket_list(ntree, node, &ntree->outputs, &node->inputs, SOCK_IN);
513                 
514                 /* add virtual extension socket */
515                 nodeAddSocket(ntree, node, SOCK_IN, "NodeSocketVirtual", "__extend__", "");
516         }
517 }
518
519 static void node_group_output_update(bNodeTree *ntree, bNode *node)
520 {
521         bNodeSocket *extsock = node->inputs.last;
522         bNodeLink *link, *linknext, *exposelink;
523         /* Adding a tree socket and verifying will remove the extension socket!
524          * This list caches the existing links to the extension socket
525          * so they can be recreated after verification.
526          */
527         ListBase tmplinks;
528         
529         /* find links to the extension socket and store them */
530         BLI_listbase_clear(&tmplinks);
531         for (link = ntree->links.first; link; link = linknext) {
532                 linknext = link->next;
533                 if (nodeLinkIsHidden(link))
534                         continue;
535                 
536                 if (link->tosock == extsock) {
537                         bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
538                         *tlink = *link;
539                         BLI_addtail(&tmplinks, tlink);
540                         
541                         nodeRemLink(ntree, link);
542                 }
543         }
544         
545         /* find valid link to expose */
546         exposelink = NULL;
547         for (link = tmplinks.first; link; link = link->next) {
548                 /* XXX Multiple sockets can be connected to the extension socket at once,
549                  * in that case the arbitrary first link determines name and type.
550                  * This could be improved by choosing the "best" type among all links,
551                  * whatever that means.
552                  */
553                 if (link->fromsock->type != SOCK_CUSTOM) {
554                         exposelink = link;
555                         break;
556                 }
557         }
558         
559         if (exposelink) {
560                 bNodeSocket *gsock, *newsock;
561                 
562                 /* XXX what if connecting virtual to virtual socket?? */
563                 gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->fromnode, exposelink->fromsock);
564                 
565                 node_group_output_verify(ntree, node, (ID *)ntree);
566                 newsock = node_group_output_find_socket(node, gsock->identifier);
567                 
568                 /* redirect links to the extension socket */
569                 for (link = tmplinks.first; link; link = link->next) {
570                         nodeAddLink(ntree, link->fromnode, link->fromsock, node, newsock);
571                 }
572         }
573         
574         BLI_freelistN(&tmplinks);
575 }
576
577 void register_node_type_group_output(void)
578 {
579         /* used for all tree types, needs dynamic allocation */
580         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
581         
582         node_type_base(ntype, NODE_GROUP_OUTPUT, "Group Output", NODE_CLASS_INTERFACE, 0);
583         node_type_size(ntype, 140, 80, 400);
584         node_type_init(ntype, node_group_output_init);
585         node_type_update(ntype, node_group_output_update, node_group_output_verify);
586         node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
587         
588         ntype->needs_free = 1;
589         nodeRegisterType(ntype);
590 }