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