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