style cleanup: nodes
[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 const char *node_group_label(bNode *node)
86 {
87         return (node->id) ? node->id->name + 2 : IFACE_("Missing Datablock");
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         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                 bNodeTree *ngroup = (bNodeTree *)node->id;
182                 group_verify_socket_list(ntree, node, &ngroup->inputs, &node->inputs, SOCK_IN);
183                 group_verify_socket_list(ntree, node, &ngroup->outputs, &node->outputs, SOCK_OUT);
184         }
185 }
186
187 /**** FRAME ****/
188
189 static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node)
190 {
191         NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
192         node->storage = data;
193         
194         data->flag |= NODE_FRAME_SHRINK;
195         
196         data->label_size = 20;
197 }
198
199 void register_node_type_frame(void)
200 {
201         /* frame type is used for all tree types, needs dynamic allocation */
202         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "frame node type");
203
204         node_type_base(ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND | NODE_OPTIONS);
205         node_type_init(ntype, node_frame_init);
206         node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
207         node_type_size(ntype, 150, 100, 0);
208         node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
209         
210         ntype->needs_free = 1;
211         nodeRegisterType(ntype);
212 }
213
214
215 /* **************** REROUTE ******************** */
216
217 /* simple, only a single input and output here */
218 static void node_reroute_update_internal_links(bNodeTree *ntree, bNode *node)
219 {
220         bNodeLink *link;
221
222         /* Security check! */
223         if (!ntree)
224                 return;
225
226         link = MEM_callocN(sizeof(bNodeLink), "internal node link");
227         link->fromnode = node;
228         link->fromsock = node->inputs.first;
229         link->tonode = node;
230         link->tosock = node->outputs.first;
231         /* internal link is always valid */
232         link->flag |= NODE_LINK_VALID;
233         BLI_addtail(&node->internal_links, link);
234 }
235
236 static void node_reroute_init(bNodeTree *ntree, bNode *node)
237 {
238         /* Note: Cannot use socket templates for this, since it would reset the socket type
239          * on each file read via the template verification procedure.
240          */
241         nodeAddStaticSocket(ntree, node, SOCK_IN, SOCK_RGBA, PROP_NONE, "Input", "Input");
242         nodeAddStaticSocket(ntree, node, SOCK_OUT, SOCK_RGBA, PROP_NONE, "Output", "Output");
243 }
244
245 void register_node_type_reroute(void)
246 {
247         /* frame type is used for all tree types, needs dynamic allocation */
248         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "frame node type");
249         
250         node_type_base(ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
251         node_type_init(ntype, node_reroute_init);
252         node_type_internal_links(ntype, node_reroute_update_internal_links);
253         
254         ntype->needs_free = 1;
255         nodeRegisterType(ntype);
256 }
257
258 static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node)
259 {
260         bNodeSocket *input = node->inputs.first;
261         bNodeSocket *output = node->outputs.first;
262         bNodeLink *link;
263         int type = SOCK_FLOAT;
264         
265         /* XXX it would be a little bit more efficient to restrict actual updates
266          * to rerout nodes connected to an updated node, but there's no reliable flag
267          * to indicate updated nodes (node->update is not set on linking).
268          */
269         
270         node->done = 1;
271         
272         /* recursive update */
273         for (link = ntree->links.first; link; link = link->next)
274         {
275                 bNode *fromnode = link->fromnode;
276                 bNode *tonode = link->tonode;
277                 if (!tonode || !fromnode)
278                         continue;
279                 if (nodeLinkIsHidden(link))
280                         continue;
281                 
282                 if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done)
283                         node_reroute_inherit_type_recursive(ntree, fromnode);
284                 
285                 if (fromnode == node && tonode->type == NODE_REROUTE && !tonode->done)
286                         node_reroute_inherit_type_recursive(ntree, tonode);
287         }
288         
289         /* determine socket type from unambiguous input/output connection if possible */
290         if (input->limit == 1 && input->link)
291                 type = input->link->fromsock->type;
292         else if (output->limit == 1 && output->link)
293                 type = output->link->tosock->type;
294         
295         /* arbitrary, could also test output->type, both are the same */
296         if (input->type != type) {
297                 PointerRNA input_ptr, output_ptr;
298                 /* same type for input/output */
299                 RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, input, &input_ptr);
300                 RNA_pointer_create((ID *)ntree, &RNA_NodeSocket, output, &output_ptr);
301                 
302                 RNA_enum_set(&input_ptr, "type", type);
303                 RNA_enum_set(&output_ptr, "type", type);
304         }
305 }
306
307 /* Global update function for Reroute node types.
308  * This depends on connected nodes, so must be done as a tree-wide update.
309  */
310 void ntree_update_reroute_nodes(bNodeTree *ntree)
311 {
312         bNode *node;
313         
314         /* clear tags */
315         for (node = ntree->nodes.first; node; node = node->next)
316                 node->done = 0;
317         
318         for (node = ntree->nodes.first; node; node = node->next)
319                 if (node->type == NODE_REROUTE && !node->done)
320                         node_reroute_inherit_type_recursive(ntree, node);
321 }
322
323 void BKE_node_tree_unlink_id(ID *id, struct bNodeTree *ntree)
324 {
325         bNode *node;
326
327         for (node = ntree->nodes.first; node; node = node->next) {
328                 if (node->id == id) {
329                         node->id = NULL;
330                 }
331         }
332 }
333
334 /**** GROUP_INPUT / GROUP_OUTPUT ****/
335
336 static void node_group_input_init(bNodeTree *ntree, bNode *node)
337 {
338         node_group_input_verify(ntree, node, (ID *)ntree);
339 }
340
341 bNodeSocket *node_group_input_find_socket(bNode *node, const char *identifier)
342 {
343         bNodeSocket *sock;
344         for (sock = node->outputs.first; sock; sock = sock->next)
345                 if (STREQ(sock->identifier, identifier))
346                         return sock;
347         return NULL;
348 }
349
350 void node_group_input_verify(bNodeTree *ntree, bNode *node, ID *id)
351 {
352         /* check inputs and outputs, and remove or insert them */
353         if (id == (ID *)ntree) {
354                 /* value_in_out inverted for interface nodes to get correct socket value_property */
355                 group_verify_socket_list(ntree, node, &ntree->inputs, &node->outputs, SOCK_OUT);
356                 
357                 /* add virtual extension socket */
358                 nodeAddSocket(ntree, node, SOCK_OUT, "NodeSocketVirtual", "__extend__", "");
359         }
360 }
361
362 static void node_group_input_update(bNodeTree *ntree, bNode *node)
363 {
364         bNodeSocket *extsock = node->outputs.last;
365         bNodeLink *link;
366         /* Adding a tree socket and verifying will remove the extension socket!
367          * This list caches the existing links from the extension socket
368          * so they can be recreated after verification.
369          */
370         ListBase tmplinks;
371         
372         /* find links from the extension socket and store them */
373         tmplinks.first = tmplinks.last = NULL;
374         for (link = ntree->links.first; link; link = link->next) {
375                 if (nodeLinkIsHidden(link))
376                         continue;
377                 if (link->fromsock == extsock) {
378                         bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
379                         *tlink = *link;
380                         BLI_addtail(&tmplinks, tlink);
381                 }
382         }
383         
384         if (tmplinks.first) {
385                 bNodeSocket *gsock, *newsock;
386                 /* XXX Multiple sockets can be connected to the extension socket at once,
387                  * in that case the arbitrary first link determines name and type.
388                  * This could be improved by choosing the "best" type among all links,
389                  * whatever that means.
390                  */
391                 bNodeLink *exposelink = tmplinks.first;
392                 
393                 /* XXX what if connecting virtual to virtual socket?? */
394                 gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->tonode, exposelink->tosock);
395                 
396                 node_group_input_verify(ntree, node, (ID *)ntree);
397                 newsock = node_group_input_find_socket(node, gsock->identifier);
398                 
399                 /* redirect links from the extension socket */
400                 for (link = tmplinks.first; link; link = link->next) {
401                         nodeAddLink(ntree, node, newsock, link->tonode, link->tosock);
402                 }
403                 
404                 BLI_freelistN(&tmplinks);
405         }
406 }
407
408 void register_node_type_group_input(void)
409 {
410         /* used for all tree types, needs dynamic allocation */
411         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
412         
413         node_type_base(ntype, NODE_GROUP_INPUT, "Group Input", NODE_CLASS_INTERFACE, NODE_OPTIONS);
414         node_type_size(ntype, 140, 80, 200);
415         node_type_init(ntype, node_group_input_init);
416         node_type_update(ntype, node_group_input_update, node_group_input_verify);
417         node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
418         
419         ntype->needs_free = 1;
420         nodeRegisterType(ntype);
421 }
422
423 static void node_group_output_init(bNodeTree *ntree, bNode *node)
424 {
425         node_group_output_verify(ntree, node, (ID *)ntree);
426 }
427
428 bNodeSocket *node_group_output_find_socket(bNode *node, const char *identifier)
429 {
430         bNodeSocket *sock;
431         for (sock = node->inputs.first; sock; sock = sock->next)
432                 if (STREQ(sock->identifier, identifier))
433                         return sock;
434         return NULL;
435 }
436
437 void node_group_output_verify(bNodeTree *ntree, bNode *node, ID *id)
438 {
439         /* check inputs and outputs, and remove or insert them */
440         if (id == (ID *)ntree) {
441                 /* value_in_out inverted for interface nodes to get correct socket value_property */
442                 group_verify_socket_list(ntree, node, &ntree->outputs, &node->inputs, SOCK_IN);
443                 
444                 /* add virtual extension socket */
445                 nodeAddSocket(ntree, node, SOCK_IN, "NodeSocketVirtual", "__extend__", "");
446         }
447 }
448
449 static void node_group_output_update(bNodeTree *ntree, bNode *node)
450 {
451         bNodeSocket *extsock = node->inputs.last;
452         bNodeLink *link;
453         /* Adding a tree socket and verifying will remove the extension socket!
454          * This list caches the existing links to the extension socket
455          * so they can be recreated after verification.
456          */
457         ListBase tmplinks;
458         
459         /* find links to the extension socket and store them */
460         tmplinks.first = tmplinks.last = NULL;
461         for (link = ntree->links.first; link; link = link->next) {
462                 if (nodeLinkIsHidden(link))
463                         continue;
464                 if (link->tosock == extsock) {
465                         bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");
466                         *tlink = *link;
467                         BLI_addtail(&tmplinks, tlink);
468                 }
469         }
470         
471         if (tmplinks.first) {
472                 bNodeSocket *gsock, *newsock;
473                 /* XXX Multiple sockets can be connected to the extension socket at once,
474                  * in that case the arbitrary first link determines name and type.
475                  * This could be improved by choosing the "best" type among all links,
476                  * whatever that means.
477                  */
478                 bNodeLink *exposelink = tmplinks.first;
479                 
480                 /* XXX what if connecting virtual to virtual socket?? */
481                 gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->fromnode, exposelink->fromsock);
482                 
483                 node_group_output_verify(ntree, node, (ID *)ntree);
484                 newsock = node_group_output_find_socket(node, gsock->identifier);
485                 
486                 /* redirect links to the extension socket */
487                 for (link = tmplinks.first; link; link = link->next) {
488                         nodeAddLink(ntree, link->fromnode, link->fromsock, node, newsock);
489                 }
490                 
491                 BLI_freelistN(&tmplinks);
492         }
493 }
494
495 void register_node_type_group_output(void)
496 {
497         /* used for all tree types, needs dynamic allocation */
498         bNodeType *ntype = MEM_callocN(sizeof(bNodeType), "node type");
499         
500         node_type_base(ntype, NODE_GROUP_OUTPUT, "Group Output", NODE_CLASS_INTERFACE, NODE_OPTIONS);
501         node_type_size(ntype, 140, 80, 200);
502         node_type_init(ntype, node_group_output_init);
503         node_type_update(ntype, node_group_output_update, node_group_output_verify);
504         node_type_compatibility(ntype, NODE_OLD_SHADING | NODE_NEW_SHADING);
505         
506         ntype->needs_free = 1;
507         nodeRegisterType(ntype);
508 }