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