style cleanup
[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
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 "BLF_translation.h"
42
43 #include "BKE_global.h"
44 #include "BKE_library.h"
45 #include "BKE_main.h"
46 #include "BLI_math.h"
47 #include "BKE_node.h"
48
49 #include "RNA_access.h"
50 #include "RNA_types.h"
51
52 #include "MEM_guardedalloc.h"
53
54 #include "node_common.h"
55 #include "node_util.h"
56 #include "node_exec.h"
57 #include "NOD_socket.h"
58
59 /**** Group ****/
60
61 bNodeSocket *node_group_find_input(bNode *gnode, bNodeSocket *gsock)
62 {
63         bNodeSocket *sock;
64         for (sock=gnode->inputs.first; sock; sock=sock->next)
65                 if (sock->groupsock == gsock)
66                         return sock;
67         return NULL;
68 }
69
70 bNodeSocket *node_group_find_output(bNode *gnode, bNodeSocket *gsock)
71 {
72         bNodeSocket *sock;
73         for (sock=gnode->outputs.first; sock; sock=sock->next)
74                 if (sock->groupsock == gsock)
75                         return sock;
76         return NULL;
77 }
78
79 bNodeSocket *node_group_add_extern_socket(bNodeTree *UNUSED(ntree), ListBase *lb, int in_out, bNodeSocket *gsock)
80 {
81         bNodeSocket *sock;
82         
83         if (gsock->flag & SOCK_INTERNAL)
84                 return NULL;
85         
86         sock= MEM_callocN(sizeof(bNodeSocket), "sock");
87         
88         /* make a copy of the group socket */
89         *sock = *gsock;
90         sock->link = NULL;
91         sock->next = sock->prev = NULL;
92         sock->new_sock = NULL;
93         
94         /* group sockets are dynamically added */
95         sock->flag |= SOCK_DYNAMIC|SOCK_COLLAPSED;
96         
97         sock->own_index = gsock->own_index;
98         sock->groupsock = gsock;
99         sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
100         
101         sock->default_value = node_socket_make_default_value(sock->type);
102         node_socket_copy_default_value(sock->type, sock->default_value, gsock->default_value);
103         
104         if (lb)
105                 BLI_addtail(lb, sock);
106         
107         return sock;
108 }
109
110 bNodeSocket *node_group_add_socket(bNodeTree *ngroup, const char *name, int type, int in_out)
111 {
112         bNodeSocketType *stype = ntreeGetSocketType(type);
113         bNodeSocket *gsock = MEM_callocN(sizeof(bNodeSocket), "bNodeSocket");
114         
115         BLI_strncpy(gsock->name, name, sizeof(gsock->name));
116         gsock->type = type;
117         /* group sockets are dynamically added */
118         gsock->flag |= SOCK_DYNAMIC|SOCK_COLLAPSED;
119
120         gsock->next = gsock->prev = NULL;
121         gsock->new_sock = NULL;
122         gsock->link = NULL;
123         /* assign new unique index */
124         gsock->own_index = ngroup->cur_index++;
125         gsock->limit = (in_out==SOCK_IN ? 0xFFF : 1);
126         
127         if (stype->value_structsize > 0)
128                 gsock->default_value = MEM_callocN(stype->value_structsize, "default socket value");
129         
130         BLI_addtail(in_out==SOCK_IN ? &ngroup->inputs : &ngroup->outputs, gsock);
131         
132         ngroup->update |= (in_out==SOCK_IN ? NTREE_UPDATE_GROUP_IN : NTREE_UPDATE_GROUP_OUT);
133         
134         return gsock;
135 }
136
137 bNodeSocket *node_group_expose_socket(bNodeTree *ngroup, bNodeSocket *sock, int in_out)
138 {
139         bNodeSocket *gsock= node_group_add_socket(ngroup, sock->name, sock->type, in_out);
140         
141         /* initialize the default value. */
142         node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
143         
144         return gsock;
145 }
146
147 void node_group_expose_all_sockets(bNodeTree *ngroup)
148 {
149         bNode *node;
150         bNodeSocket *sock, *gsock;
151         
152         for (node=ngroup->nodes.first; node; node=node->next) {
153                 for (sock=node->inputs.first; sock; sock=sock->next) {
154                         if (!sock->link && !nodeSocketIsHidden(sock)) {
155                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_IN);
156                                 
157                                 /* initialize the default value. */
158                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
159                                 
160                                 sock->link = nodeAddLink(ngroup, NULL, gsock, node, sock);
161                         }
162                 }
163                 for (sock=node->outputs.first; sock; sock=sock->next) {
164                         if (nodeCountSocketLinks(ngroup, sock)==0 && !nodeSocketIsHidden(sock)) {
165                                 gsock = node_group_add_socket(ngroup, sock->name, sock->type, SOCK_OUT);
166                                 
167                                 /* initialize the default value. */
168                                 node_socket_copy_default_value(gsock->type, gsock->default_value, sock->default_value);
169                                 
170                                 gsock->link = nodeAddLink(ngroup, node, sock, NULL, gsock);
171                         }
172                 }
173         }
174 }
175
176 void node_group_remove_socket(bNodeTree *ngroup, bNodeSocket *gsock, int in_out)
177 {
178         nodeRemSocketLinks(ngroup, gsock);
179         
180         switch (in_out) {
181         case SOCK_IN:
182                 BLI_remlink(&ngroup->inputs, gsock);
183                 ngroup->update |= NTREE_UPDATE_GROUP_IN;
184                 break;
185         case SOCK_OUT:
186                 BLI_remlink(&ngroup->outputs, gsock);
187                 ngroup->update |= NTREE_UPDATE_GROUP_OUT;
188                 break;
189         }
190         
191         if (gsock->default_value)
192                 MEM_freeN(gsock->default_value);
193         
194         MEM_freeN(gsock);
195 }
196
197 /* groups display their internal tree name as label */
198 const char *node_group_label(bNode *node)
199 {
200         return (node->id)? node->id->name+2: IFACE_("Missing Datablock");
201 }
202
203 int node_group_valid(bNodeTree *ntree, bNodeTemplate *ntemp)
204 {
205         bNodeTemplate childtemp;
206         bNode *node;
207         
208         /* regular groups cannot be recursive */
209         if (ntree == ntemp->ngroup)
210                 return 0;
211         
212         /* make sure all children are valid */
213         for (node=ntemp->ngroup->nodes.first; node; node=node->next) {
214                 childtemp = nodeMakeTemplate(node);
215                 if (!nodeValid(ntree, &childtemp))
216                         return 0;
217         }
218         
219         return 1;
220 }
221
222 bNodeTemplate node_group_template(bNode *node)
223 {
224         bNodeTemplate ntemp;
225         ntemp.type = NODE_GROUP;
226         ntemp.ngroup = (bNodeTree *)node->id;
227         return ntemp;
228 }
229
230 void node_group_init(bNodeTree *ntree, bNode *node, bNodeTemplate *ntemp)
231 {
232         node->id = (ID *)ntemp->ngroup;
233         
234         /* NB: group socket input/output roles are inverted internally!
235          * Group "inputs" work as outputs in links and vice versa.
236          */
237         if (ntemp->ngroup) {
238                 bNodeSocket *gsock;
239                 for (gsock=ntemp->ngroup->inputs.first; gsock; gsock=gsock->next)
240                         node_group_add_extern_socket(ntree, &node->inputs, SOCK_IN, gsock);
241                 for (gsock=ntemp->ngroup->outputs.first; gsock; gsock=gsock->next)
242                         node_group_add_extern_socket(ntree, &node->outputs, SOCK_OUT, gsock);
243         }
244 }
245
246 static bNodeSocket *group_verify_socket(bNodeTree *ntree, ListBase *lb, int in_out, bNodeSocket *gsock)
247 {
248         bNodeSocket *sock;
249         
250         /* group sockets tagged as internal are not exposed ever */
251         if (gsock->flag & SOCK_INTERNAL)
252                 return NULL;
253         
254         for (sock= lb->first; sock; sock= sock->next) {
255                 if (sock->own_index==gsock->own_index)
256                                 break;
257         }
258         if (sock) {
259                 sock->groupsock = gsock;
260                 
261                 BLI_strncpy(sock->name, gsock->name, sizeof(sock->name));
262                 if (gsock->type != sock->type)
263                         nodeSocketSetType(sock, gsock->type);
264                 
265                 /* XXX hack: group socket input/output roles are inverted internally,
266                  * need to change the limit value when making actual node sockets from them.
267                  */
268                 sock->limit = (in_out==SOCK_IN ? 1 : 0xFFF);
269                 
270                 BLI_remlink(lb, sock);
271                 
272                 return sock;
273         }
274         else {
275                 return node_group_add_extern_socket(ntree, NULL, in_out, gsock);
276         }
277 }
278
279 static void group_verify_socket_list(bNodeTree *ntree, bNode *node, ListBase *lb, int in_out, ListBase *glb)
280 {
281         bNodeSocket *sock, *nextsock, *gsock;
282         
283         /* step by step compare */
284         for (gsock= glb->first; gsock; gsock=gsock->next) {
285                 /* abusing new_sock pointer for verification here! only used inside this function */
286                 gsock->new_sock= group_verify_socket(ntree, lb, in_out, gsock);
287         }
288         /* leftovers are removed */
289         for (sock=lb->first; sock; sock=nextsock) {
290                 nextsock=sock->next;
291                 if (sock->flag & SOCK_DYNAMIC)
292                         nodeRemoveSocket(ntree, node, sock);
293         }
294         /* and we put back the verified sockets */
295         for (gsock= glb->first; gsock; gsock=gsock->next) {
296                 if (gsock->new_sock) {
297                         BLI_addtail(lb, gsock->new_sock);
298                         gsock->new_sock = NULL;
299                 }
300         }
301 }
302
303 /* make sure all group node in ntree, which use ngroup, are sync'd */
304 void node_group_verify(struct bNodeTree *ntree, struct bNode *node, struct ID *id)
305 {
306         /* check inputs and outputs, and remove or insert them */
307         if (node->id==id) {
308                 bNodeTree *ngroup= (bNodeTree *)node->id;
309                 group_verify_socket_list(ntree, node, &node->inputs, SOCK_IN, &ngroup->inputs);
310                 group_verify_socket_list(ntree, node, &node->outputs, SOCK_OUT, &ngroup->outputs);
311         }
312 }
313
314 struct bNodeTree *node_group_edit_get(bNode *node)
315 {
316         if (node->flag & NODE_GROUP_EDIT)
317                 return (bNodeTree *)node->id;
318         else
319                 return NULL;
320 }
321
322 struct bNodeTree *node_group_edit_set(bNode *node, int edit)
323 {
324         if (edit) {
325                 bNodeTree *ngroup= (bNodeTree *)node->id;
326                 if (ngroup) {
327                         if (ngroup->id.lib)
328                                 ntreeMakeLocal(ngroup);
329                         
330                         node->flag |= NODE_GROUP_EDIT;
331                 }
332                 return ngroup;
333         }
334         else {
335                 node->flag &= ~NODE_GROUP_EDIT;
336                 return NULL;
337         }
338 }
339
340 void node_group_edit_clear(bNode *node)
341 {
342         bNodeTree *ngroup= (bNodeTree *)node->id;
343         bNode *inode;
344         
345         node->flag &= ~NODE_GROUP_EDIT;
346         
347         if (ngroup)
348                 for (inode=ngroup->nodes.first; inode; inode=inode->next)
349                         nodeGroupEditClear(inode);
350 }
351
352 static void UNUSED_FUNCTION(node_group_link)(bNodeTree *ntree, bNodeSocket *sock, int in_out)
353 {
354         node_group_expose_socket(ntree, sock, in_out);
355 }
356
357 /**** FRAME ****/
358
359 static void node_frame_init(bNodeTree *UNUSED(ntree), bNode *node, bNodeTemplate *UNUSED(ntemp))
360 {
361         NodeFrame *data = (NodeFrame *)MEM_callocN(sizeof(NodeFrame), "frame node storage");
362         node->storage = data;
363         
364         data->flag |= NODE_FRAME_SHRINK;
365         
366         data->label_size = 20;
367 }
368
369 void register_node_type_frame(bNodeTreeType *ttype)
370 {
371         /* frame type is used for all tree types, needs dynamic allocation */
372         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
373
374         node_type_base(ttype, ntype, NODE_FRAME, "Frame", NODE_CLASS_LAYOUT, NODE_BACKGROUND|NODE_OPTIONS);
375         node_type_init(ntype, node_frame_init);
376         node_type_storage(ntype, "NodeFrame", node_free_standard_storage, node_copy_standard_storage);
377         node_type_size(ntype, 150, 100, 0);
378         node_type_compatibility(ntype, NODE_OLD_SHADING|NODE_NEW_SHADING);
379         
380         ntype->needs_free = 1;
381         nodeRegisterType(ttype, ntype);
382 }
383
384
385 /* **************** REROUTE ******************** */
386
387 /* simple, only a single input and output here */
388 static void node_reroute_update_internal_links(bNodeTree *ntree, bNode *node)
389 {
390         bNodeLink *link;
391
392         /* Security check! */
393         if (!ntree)
394                 return;
395
396         link = MEM_callocN(sizeof(bNodeLink), "internal node link");
397         link->fromnode = node;
398         link->fromsock = node->inputs.first;
399         link->tonode = node;
400         link->tosock = node->outputs.first;
401         /* internal link is always valid */
402         link->flag |= NODE_LINK_VALID;
403         BLI_addtail(&node->internal_links, link);
404 }
405
406 static void node_reroute_init(bNodeTree *ntree, bNode *node, bNodeTemplate *UNUSED(ntemp))
407 {
408         /* Note: Cannot use socket templates for this, since it would reset the socket type
409          * on each file read via the template verification procedure.
410          */
411         nodeAddSocket(ntree, node, SOCK_IN, "Input", SOCK_RGBA);
412         nodeAddSocket(ntree, node, SOCK_OUT, "Output", SOCK_RGBA);
413 }
414
415 void register_node_type_reroute(bNodeTreeType *ttype)
416 {
417         /* frame type is used for all tree types, needs dynamic allocation */
418         bNodeType *ntype= MEM_callocN(sizeof(bNodeType), "frame node type");
419         
420         node_type_base(ttype, ntype, NODE_REROUTE, "Reroute", NODE_CLASS_LAYOUT, 0);
421         node_type_init(ntype, node_reroute_init);
422         node_type_internal_links(ntype, node_reroute_update_internal_links);
423         
424         ntype->needs_free = 1;
425         nodeRegisterType(ttype, ntype);
426 }
427
428 static void node_reroute_inherit_type_recursive(bNodeTree *ntree, bNode *node)
429 {
430         bNodeSocket *input = node->inputs.first;
431         bNodeSocket *output = node->outputs.first;
432         int type = SOCK_FLOAT;
433         bNodeLink *link;
434         
435         /* XXX it would be a little bit more efficient to restrict actual updates
436          * to rerout nodes connected to an updated node, but there's no reliable flag
437          * to indicate updated nodes (node->update is not set on linking).
438          */
439         
440         node->done = 1;
441         
442         /* recursive update */
443         for (link = ntree->links.first; link; link = link->next)
444         {
445                 bNode *fromnode = link->fromnode;
446                 bNode *tonode = link->tonode;
447                 if (!tonode || !fromnode)
448                         continue;
449                 
450                 if (tonode == node && fromnode->type == NODE_REROUTE && !fromnode->done)
451                         node_reroute_inherit_type_recursive(ntree, fromnode);
452                 
453                 if (fromnode == node && tonode->type == NODE_REROUTE && !tonode->done)
454                         node_reroute_inherit_type_recursive(ntree, tonode);
455         }
456         
457         /* determine socket type from unambiguous input/output connection if possible */
458         if (input->limit==1 && input->link)
459                 type = input->link->fromsock->type;
460         else if (output->limit==1 && output->link)
461                 type = output->link->tosock->type;
462         
463         /* arbitrary, could also test output->type, both are the same */
464         if (input->type != type) {
465                 /* same type for input/output */
466                 nodeSocketSetType(input, type);
467                 nodeSocketSetType(output, type);
468         }
469 }
470
471 /* Global update function for Reroute node types.
472  * This depends on connected nodes, so must be done as a tree-wide update.
473  */
474 void ntree_update_reroute_nodes(bNodeTree *ntree)
475 {
476         bNode *node;
477         
478         /* clear tags */
479         for (node = ntree->nodes.first; node; node = node->next)
480                 node->done = 0;
481         
482         for (node = ntree->nodes.first; node; node = node->next)
483                 if (node->type == NODE_REROUTE && !node->done)
484                         node_reroute_inherit_type_recursive(ntree, node);
485 }
486
487 void BKE_node_tree_unlink_id_cb(void *calldata, struct ID *UNUSED(owner_id), struct bNodeTree *ntree)
488 {
489         ID *id = (ID *)calldata;
490         bNode *node;
491
492         for (node = ntree->nodes.first; node; node = node->next) {
493                 if (node->id == id) {
494                         node->id = NULL;
495                 }
496         }
497 }