LookDev: Move lookdev balls when menu switches
[blender.git] / source / blender / editors / space_node / node_group.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) 2005 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): David Millan Escriva, Juho Vepsäläinen, Nathan Letwory
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/space_node/node_group.c
29  *  \ingroup spnode
30  */
31
32 #include <stdlib.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "DNA_node_types.h"
37 #include "DNA_anim_types.h"
38
39 #include "BLI_listbase.h"
40 #include "BLI_linklist.h"
41 #include "BLI_math.h"
42
43 #include "BLT_translation.h"
44
45 #include "BKE_action.h"
46 #include "BKE_animsys.h"
47 #include "BKE_context.h"
48 #include "BKE_global.h"
49 #include "BKE_library.h"
50 #include "BKE_main.h"
51 #include "BKE_report.h"
52
53 #include "ED_node.h"  /* own include */
54 #include "ED_screen.h"
55 #include "ED_render.h"
56
57 #include "RNA_access.h"
58 #include "RNA_define.h"
59
60 #include "WM_api.h"
61 #include "WM_types.h"
62
63 #include "UI_resources.h"
64
65 #include "node_intern.h"  /* own include */
66 #include "NOD_common.h"
67
68 static int node_group_operator_active(bContext *C)
69 {
70         if (ED_operator_node_active(C)) {
71                 SpaceNode *snode = CTX_wm_space_node(C);
72
73                 /* Group operators only defined for standard node tree types.
74                  * Disabled otherwise to allow pynodes define their own operators
75                  * with same keymap.
76                  */
77                 if (STREQ(snode->tree_idname, "ShaderNodeTree") ||
78                     STREQ(snode->tree_idname, "CompositorNodeTree") ||
79                     STREQ(snode->tree_idname, "TextureNodeTree"))
80                 {
81                         return true;
82                 }
83         }
84         return false;
85 }
86
87 static int node_group_operator_editable(bContext *C)
88 {
89         if (ED_operator_node_editable(C)) {
90                 SpaceNode *snode = CTX_wm_space_node(C);
91
92                 /* Group operators only defined for standard node tree types.
93                  * Disabled otherwise to allow pynodes define their own operators
94                  * with same keymap.
95                  */
96                 if (ED_node_is_shader(snode) ||
97                     ED_node_is_compositor(snode) ||
98                     ED_node_is_texture(snode))
99                 {
100                         return true;
101                 }
102         }
103         return false;
104 }
105
106 static const char *group_ntree_idname(bContext *C)
107 {
108         SpaceNode *snode = CTX_wm_space_node(C);
109         return snode->tree_idname;
110 }
111
112 static const char *group_node_idname(bContext *C)
113 {
114         SpaceNode *snode = CTX_wm_space_node(C);
115
116         if (ED_node_is_shader(snode))
117                 return "ShaderNodeGroup";
118         else if (ED_node_is_compositor(snode))
119                 return "CompositorNodeGroup";
120         else if (ED_node_is_texture(snode))
121                 return "TextureNodeGroup";
122
123         return "";
124 }
125
126 static bNode *node_group_get_active(bContext *C, const char *node_idname)
127 {
128         SpaceNode *snode = CTX_wm_space_node(C);
129         bNode *node = nodeGetActive(snode->edittree);
130
131         if (node && STREQ(node->idname, node_idname))
132                 return node;
133         else
134                 return NULL;
135 }
136
137 /* ***************** Edit Group operator ************* */
138
139 static int node_group_edit_exec(bContext *C, wmOperator *op)
140 {
141         SpaceNode *snode = CTX_wm_space_node(C);
142         const char *node_idname = group_node_idname(C);
143         bNode *gnode;
144         const bool exit = RNA_boolean_get(op->ptr, "exit");
145
146         ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
147
148         gnode = node_group_get_active(C, node_idname);
149
150         if (gnode && !exit) {
151                 bNodeTree *ngroup = (bNodeTree *)gnode->id;
152
153                 if (ngroup)
154                         ED_node_tree_push(snode, ngroup, gnode);
155         }
156         else
157                 ED_node_tree_pop(snode);
158
159         WM_event_add_notifier(C, NC_SCENE | ND_NODES, NULL);
160
161         return OPERATOR_FINISHED;
162 }
163
164 void NODE_OT_group_edit(wmOperatorType *ot)
165 {
166         /* identifiers */
167         ot->name = "Edit Group";
168         ot->description = "Edit node group";
169         ot->idname = "NODE_OT_group_edit";
170
171         /* api callbacks */
172         ot->exec = node_group_edit_exec;
173         ot->poll = node_group_operator_active;
174
175         /* flags */
176         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
177
178         RNA_def_boolean(ot->srna, "exit", false, "Exit", "");
179 }
180
181 /* ******************** Ungroup operator ********************** */
182
183 /* returns 1 if its OK */
184 static int node_group_ungroup(Main *bmain, bNodeTree *ntree, bNode *gnode)
185 {
186         bNodeLink *link, *linkn, *tlink;
187         bNode *node, *nextnode;
188         bNodeTree *ngroup, *wgroup;
189         ListBase anim_basepaths = {NULL, NULL};
190         LinkNode *nodes_delayed_free = NULL;
191
192         ngroup = (bNodeTree *)gnode->id;
193
194         /* clear new pointers, set in copytree */
195         for (node = ntree->nodes.first; node; node = node->next)
196                 node->new_node = NULL;
197
198         /* wgroup is a temporary copy of the NodeTree we're merging in
199          * - all of wgroup's nodes are transferred across to their new home
200          * - ngroup (i.e. the source NodeTree) is left unscathed
201          * - temp copy. don't change ID usercount
202          */
203         wgroup = ntreeCopyTree_ex(ngroup, bmain, false);
204
205         /* Add the nodes into the ntree */
206         for (node = wgroup->nodes.first; node; node = nextnode) {
207                 nextnode = node->next;
208
209                 /* Remove interface nodes.
210                  * This also removes remaining links to and from interface nodes.
211                  */
212                 if (ELEM(node->type, NODE_GROUP_INPUT, NODE_GROUP_OUTPUT)) {
213                         /* We must delay removal since sockets will reference this node. see: T52092 */
214                         BLI_linklist_prepend(&nodes_delayed_free, node);
215                 }
216
217                 /* keep track of this node's RNA "base" path (the part of the path identifying the node)
218                  * if the old nodetree has animation data which potentially covers this node
219                  */
220                 if (wgroup->adt) {
221                         PointerRNA ptr;
222                         char *path;
223
224                         RNA_pointer_create(&wgroup->id, &RNA_Node, node, &ptr);
225                         path = RNA_path_from_ID_to_struct(&ptr);
226
227                         if (path)
228                                 BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
229                 }
230
231                 /* migrate node */
232                 BLI_remlink(&wgroup->nodes, node);
233                 BLI_addtail(&ntree->nodes, node);
234
235                 /* ensure unique node name in the node tree */
236                 nodeUniqueName(ntree, node);
237
238                 if (!node->parent) {
239                         node->locx += gnode->locx;
240                         node->locy += gnode->locy;
241                 }
242
243                 node->flag |= NODE_SELECT;
244         }
245
246         /* Add internal links to the ntree */
247         for (link = wgroup->links.first; link; link = linkn) {
248                 linkn = link->next;
249                 BLI_remlink(&wgroup->links, link);
250                 BLI_addtail(&ntree->links, link);
251         }
252
253         /* and copy across the animation,
254          * note that the animation data's action can be NULL here */
255         if (wgroup->adt) {
256                 LinkData *ld, *ldn = NULL;
257                 bAction *waction;
258
259                 /* firstly, wgroup needs to temporary dummy action that can be destroyed, as it shares copies */
260                 waction = wgroup->adt->action = BKE_action_copy(bmain, wgroup->adt->action);
261
262                 /* now perform the moving */
263                 BKE_animdata_separate_by_basepath(&wgroup->id, &ntree->id, &anim_basepaths);
264
265                 /* paths + their wrappers need to be freed */
266                 for (ld = anim_basepaths.first; ld; ld = ldn) {
267                         ldn = ld->next;
268
269                         MEM_freeN(ld->data);
270                         BLI_freelinkN(&anim_basepaths, ld);
271                 }
272
273                 /* free temp action too */
274                 if (waction) {
275                         BKE_libblock_free(bmain, waction);
276                         wgroup->adt->action = NULL;
277                 }
278         }
279
280         /* free the group tree (takes care of user count) */
281         BKE_libblock_free(bmain, wgroup);
282
283         /* restore external links to and from the gnode */
284         /* note: the nodes have been copied to intermediate wgroup first (so need to use new_node),
285          *       then transferred to ntree (new_node pointers remain valid).
286          */
287
288         /* input links */
289         for (link = ngroup->links.first; link; link = link->next) {
290                 if (link->fromnode->type == NODE_GROUP_INPUT) {
291                         const char *identifier = link->fromsock->identifier;
292                         int num_external_links = 0;
293
294                         /* find external links to this input */
295                         for (tlink = ntree->links.first; tlink; tlink = tlink->next) {
296                                 if (tlink->tonode == gnode && STREQ(tlink->tosock->identifier, identifier)) {
297                                         nodeAddLink(ntree, tlink->fromnode, tlink->fromsock, link->tonode->new_node, link->tosock->new_sock);
298                                         ++num_external_links;
299                                 }
300                         }
301
302                         /* if group output is not externally linked,
303                          * convert the constant input value to ensure somewhat consistent behavior */
304                         if (num_external_links == 0) {
305                                 /* XXX TODO bNodeSocket *sock = node_group_find_input_socket(gnode, identifier);
306                                 BLI_assert(sock);*/
307
308                                 /* XXX TODO nodeSocketCopy(ntree, link->tosock->new_sock, link->tonode->new_node, ntree, sock, gnode);*/
309                         }
310                 }
311         }
312
313         /* output links */
314         for (link = ntree->links.first; link; link = link->next) {
315                 if (link->fromnode == gnode) {
316                         const char *identifier = link->fromsock->identifier;
317                         int num_internal_links = 0;
318
319                         /* find internal links to this output */
320                         for (tlink = ngroup->links.first; tlink; tlink = tlink->next) {
321                                 /* only use active output node */
322                                 if (tlink->tonode->type == NODE_GROUP_OUTPUT && (tlink->tonode->flag & NODE_DO_OUTPUT)) {
323                                         if (STREQ(tlink->tosock->identifier, identifier)) {
324                                                 nodeAddLink(ntree, tlink->fromnode->new_node, tlink->fromsock->new_sock, link->tonode, link->tosock);
325                                                 ++num_internal_links;
326                                         }
327                                 }
328                         }
329
330                         /* if group output is not internally linked,
331                          * convert the constant output value to ensure somewhat consistent behavior */
332                         if (num_internal_links == 0) {
333                                 /* XXX TODO bNodeSocket *sock = node_group_find_output_socket(gnode, identifier);
334                                 BLI_assert(sock);*/
335
336                                 /* XXX TODO nodeSocketCopy(ntree, link->tosock, link->tonode, ntree, sock, gnode); */
337                         }
338                 }
339         }
340
341         while (nodes_delayed_free) {
342                 node = BLI_linklist_pop(&nodes_delayed_free);
343                 nodeFreeNode(ntree, node);
344         }
345
346         /* delete the group instance */
347         nodeFreeNode(ntree, gnode);
348
349         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
350
351         return 1;
352 }
353
354
355 static int node_group_ungroup_exec(bContext *C, wmOperator *op)
356 {
357         Main *bmain = CTX_data_main(C);
358         SpaceNode *snode = CTX_wm_space_node(C);
359         const char *node_idname = group_node_idname(C);
360         bNode *gnode;
361
362         ED_preview_kill_jobs(CTX_wm_manager(C), bmain);
363
364         gnode = node_group_get_active(C, node_idname);
365         if (!gnode)
366                 return OPERATOR_CANCELLED;
367
368         if (gnode->id && node_group_ungroup(bmain, snode->edittree, gnode)) {
369                 ntreeUpdateTree(bmain, snode->nodetree);
370         }
371         else {
372                 BKE_report(op->reports, RPT_WARNING, "Cannot ungroup");
373                 return OPERATOR_CANCELLED;
374         }
375
376         snode_notify(C, snode);
377         snode_dag_update(C, snode);
378
379         return OPERATOR_FINISHED;
380 }
381
382 void NODE_OT_group_ungroup(wmOperatorType *ot)
383 {
384         /* identifiers */
385         ot->name = "Ungroup";
386         ot->description = "Ungroup selected nodes";
387         ot->idname = "NODE_OT_group_ungroup";
388
389         /* api callbacks */
390         ot->exec = node_group_ungroup_exec;
391         ot->poll = node_group_operator_editable;
392
393         /* flags */
394         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
395 }
396
397 /* ******************** Separate operator ********************** */
398
399 /* returns 1 if its OK */
400 static int node_group_separate_selected(bNodeTree *ntree, bNodeTree *ngroup, float offx, float offy, int make_copy)
401 {
402         bNodeLink *link, *link_next;
403         bNode *node, *node_next, *newnode;
404         ListBase anim_basepaths = {NULL, NULL};
405
406         /* deselect all nodes in the target tree */
407         for (node = ntree->nodes.first; node; node = node->next)
408                 nodeSetSelected(node, false);
409
410         /* clear new pointers, set in nodeCopyNode */
411         for (node = ngroup->nodes.first; node; node = node->next)
412                 node->new_node = NULL;
413
414         /* add selected nodes into the ntree */
415         for (node = ngroup->nodes.first; node; node = node_next) {
416                 node_next = node->next;
417                 if (!(node->flag & NODE_SELECT))
418                         continue;
419
420                 /* ignore interface nodes */
421                 if (ELEM(node->type, NODE_GROUP_INPUT, NODE_GROUP_OUTPUT)) {
422                         nodeSetSelected(node, false);
423                         continue;
424                 }
425
426                 if (make_copy) {
427                         /* make a copy */
428                         newnode = nodeCopyNode(ngroup, node);
429                 }
430                 else {
431                         /* use the existing node */
432                         newnode = node;
433                 }
434
435                 /* keep track of this node's RNA "base" path (the part of the path identifying the node)
436                  * if the old nodetree has animation data which potentially covers this node
437                  */
438                 if (ngroup->adt) {
439                         PointerRNA ptr;
440                         char *path;
441
442                         RNA_pointer_create(&ngroup->id, &RNA_Node, newnode, &ptr);
443                         path = RNA_path_from_ID_to_struct(&ptr);
444
445                         if (path)
446                                 BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
447                 }
448
449                 /* ensure valid parent pointers, detach if parent stays inside the group */
450                 if (newnode->parent && !(newnode->parent->flag & NODE_SELECT))
451                         nodeDetachNode(newnode);
452
453                 /* migrate node */
454                 BLI_remlink(&ngroup->nodes, newnode);
455                 BLI_addtail(&ntree->nodes, newnode);
456
457                 /* ensure unique node name in the node tree */
458                 nodeUniqueName(ntree, newnode);
459
460                 if (!newnode->parent) {
461                         newnode->locx += offx;
462                         newnode->locy += offy;
463                 }
464         }
465
466         /* add internal links to the ntree */
467         for (link = ngroup->links.first; link; link = link_next) {
468                 const bool fromselect = (link->fromnode && (link->fromnode->flag & NODE_SELECT));
469                 const bool toselect = (link->tonode && (link->tonode->flag & NODE_SELECT));
470                 link_next = link->next;
471
472                 if (make_copy) {
473                         /* make a copy of internal links */
474                         if (fromselect && toselect)
475                                 nodeAddLink(ntree, link->fromnode->new_node, link->fromsock->new_sock, link->tonode->new_node, link->tosock->new_sock);
476                 }
477                 else {
478                         /* move valid links over, delete broken links */
479                         if (fromselect && toselect) {
480                                 BLI_remlink(&ngroup->links, link);
481                                 BLI_addtail(&ntree->links, link);
482                         }
483                         else if (fromselect || toselect) {
484                                 nodeRemLink(ngroup, link);
485                         }
486                 }
487         }
488
489         /* and copy across the animation,
490          * note that the animation data's action can be NULL here */
491         if (ngroup->adt) {
492                 LinkData *ld, *ldn = NULL;
493
494                 /* now perform the moving */
495                 BKE_animdata_separate_by_basepath(&ngroup->id, &ntree->id, &anim_basepaths);
496
497                 /* paths + their wrappers need to be freed */
498                 for (ld = anim_basepaths.first; ld; ld = ldn) {
499                         ldn = ld->next;
500
501                         MEM_freeN(ld->data);
502                         BLI_freelinkN(&anim_basepaths, ld);
503                 }
504         }
505
506         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
507         if (!make_copy)
508                 ngroup->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
509
510         return 1;
511 }
512
513 typedef enum eNodeGroupSeparateType {
514         NODE_GS_COPY,
515         NODE_GS_MOVE
516 } eNodeGroupSeparateType;
517
518 /* Operator Property */
519 static const EnumPropertyItem node_group_separate_types[] = {
520         {NODE_GS_COPY, "COPY", 0, "Copy", "Copy to parent node tree, keep group intact"},
521         {NODE_GS_MOVE, "MOVE", 0, "Move", "Move to parent node tree, remove from group"},
522         {0, NULL, 0, NULL, NULL}
523 };
524
525 static int node_group_separate_exec(bContext *C, wmOperator *op)
526 {
527         SpaceNode *snode = CTX_wm_space_node(C);
528         bNodeTree *ngroup, *nparent;
529         int type = RNA_enum_get(op->ptr, "type");
530         float offx, offy;
531
532         ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
533
534         /* are we inside of a group? */
535         ngroup = snode->edittree;
536         nparent = ED_node_tree_get(snode, 1);
537         if (!nparent) {
538                 BKE_report(op->reports, RPT_WARNING, "Not inside node group");
539                 return OPERATOR_CANCELLED;
540         }
541         /* get node tree offset */
542         snode_group_offset(snode, &offx, &offy);
543
544         switch (type) {
545                 case NODE_GS_COPY:
546                         if (!node_group_separate_selected(nparent, ngroup, offx, offy, 1)) {
547                                 BKE_report(op->reports, RPT_WARNING, "Cannot separate nodes");
548                                 return OPERATOR_CANCELLED;
549                         }
550                         break;
551                 case NODE_GS_MOVE:
552                         if (!node_group_separate_selected(nparent, ngroup, offx, offy, 0)) {
553                                 BKE_report(op->reports, RPT_WARNING, "Cannot separate nodes");
554                                 return OPERATOR_CANCELLED;
555                         }
556                         break;
557         }
558
559         /* switch to parent tree */
560         ED_node_tree_pop(snode);
561
562         ntreeUpdateTree(CTX_data_main(C), snode->nodetree);
563
564         snode_notify(C, snode);
565         snode_dag_update(C, snode);
566
567         return OPERATOR_FINISHED;
568 }
569
570 static int node_group_separate_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *UNUSED(event))
571 {
572         uiPopupMenu *pup = UI_popup_menu_begin(C, CTX_IFACE_(BLT_I18NCONTEXT_OPERATOR_DEFAULT, "Separate"), ICON_NONE);
573         uiLayout *layout = UI_popup_menu_layout(pup);
574
575         uiLayoutSetOperatorContext(layout, WM_OP_EXEC_DEFAULT);
576         uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_COPY);
577         uiItemEnumO(layout, "NODE_OT_group_separate", NULL, 0, "type", NODE_GS_MOVE);
578
579         UI_popup_menu_end(C, pup);
580
581         return OPERATOR_INTERFACE;
582 }
583
584 void NODE_OT_group_separate(wmOperatorType *ot)
585 {
586         /* identifiers */
587         ot->name = "Separate";
588         ot->description = "Separate selected nodes from the node group";
589         ot->idname = "NODE_OT_group_separate";
590
591         /* api callbacks */
592         ot->invoke = node_group_separate_invoke;
593         ot->exec = node_group_separate_exec;
594         ot->poll = node_group_operator_editable;
595
596         /* flags */
597         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
598
599         RNA_def_enum(ot->srna, "type", node_group_separate_types, NODE_GS_COPY, "Type", "");
600 }
601
602 /* ****************** Make Group operator ******************* */
603
604 static bool node_group_make_use_node(bNode *node, bNode *gnode)
605 {
606         return (node != gnode &&
607                 !ELEM(node->type, NODE_GROUP_INPUT, NODE_GROUP_OUTPUT) &&
608                 (node->flag & NODE_SELECT));
609 }
610
611 static bool node_group_make_test_selected(bNodeTree *ntree, bNode *gnode, const char *ntree_idname, struct ReportList *reports)
612 {
613         bNodeTree *ngroup;
614         bNode *node;
615         bNodeLink *link;
616         int ok = true;
617
618         /* make a local pseudo node tree to pass to the node poll functions */
619         ngroup = ntreeAddTree(NULL, "Pseudo Node Group", ntree_idname);
620
621         /* check poll functions for selected nodes */
622         for (node = ntree->nodes.first; node; node = node->next) {
623                 if (node_group_make_use_node(node, gnode)) {
624                         if (node->typeinfo->poll_instance && !node->typeinfo->poll_instance(node, ngroup)) {
625                                 BKE_reportf(reports, RPT_WARNING, "Can not add node '%s' in a group", node->name);
626                                 ok = false;
627                                 break;
628                         }
629                 }
630
631                 node->done = 0;
632         }
633
634         /* free local pseudo node tree again */
635         ntreeFreeTree(ngroup);
636         MEM_freeN(ngroup);
637         if (!ok)
638                 return false;
639
640         /* check if all connections are OK, no unselected node has both
641          * inputs and outputs to a selection */
642         for (link = ntree->links.first; link; link = link->next) {
643                 if (node_group_make_use_node(link->fromnode, gnode))
644                         link->tonode->done |= 1;
645                 if (node_group_make_use_node(link->tonode, gnode))
646                         link->fromnode->done |= 2;
647         }
648         for (node = ntree->nodes.first; node; node = node->next) {
649                 if (!(node->flag & NODE_SELECT) &&
650                     node != gnode &&
651                     node->done == 3)
652                 {
653                         return false;
654                 }
655         }
656         return true;
657 }
658
659 static int node_get_selected_minmax(bNodeTree *ntree, bNode *gnode, float *min, float *max)
660 {
661         bNode *node;
662         float loc[2];
663         int totselect = 0;
664
665         INIT_MINMAX2(min, max);
666         for (node = ntree->nodes.first; node; node = node->next) {
667                 if (node_group_make_use_node(node, gnode)) {
668                         nodeToView(node, 0.0f, 0.0f, &loc[0], &loc[1]);
669                         minmax_v2v2_v2(min, max, loc);
670                         ++totselect;
671                 }
672         }
673
674         /* sane min/max if no selected nodes */
675         if (totselect == 0) {
676                 min[0] = min[1] = max[0] = max[1] = 0.0f;
677         }
678
679         return totselect;
680 }
681
682 static void node_group_make_insert_selected(const bContext *C, bNodeTree *ntree, bNode *gnode)
683 {
684         bNodeTree *ngroup = (bNodeTree *)gnode->id;
685         bNodeLink *link, *linkn;
686         bNode *node, *nextn;
687         bNodeSocket *sock;
688         ListBase anim_basepaths = {NULL, NULL};
689         float min[2], max[2], center[2];
690         int totselect;
691         bool expose_all = false;
692         bNode *input_node, *output_node;
693
694         /* XXX rough guess, not nice but we don't have access to UI constants here ... */
695         static const float offsetx = 200;
696         static const float offsety = 0.0f;
697
698         /* deselect all nodes in the target tree */
699         for (node = ngroup->nodes.first; node; node = node->next)
700                 nodeSetSelected(node, false);
701
702         totselect = node_get_selected_minmax(ntree, gnode, min, max);
703         add_v2_v2v2(center, min, max);
704         mul_v2_fl(center, 0.5f);
705
706         /* auto-add interface for "solo" nodes */
707         if (totselect == 1)
708                 expose_all = true;
709
710         /* move nodes over */
711         for (node = ntree->nodes.first; node; node = nextn) {
712                 nextn = node->next;
713                 if (node_group_make_use_node(node, gnode)) {
714                         /* keep track of this node's RNA "base" path (the part of the pat identifying the node)
715                          * if the old nodetree has animation data which potentially covers this node
716                          */
717                         if (ntree->adt) {
718                                 PointerRNA ptr;
719                                 char *path;
720
721                                 RNA_pointer_create(&ntree->id, &RNA_Node, node, &ptr);
722                                 path = RNA_path_from_ID_to_struct(&ptr);
723
724                                 if (path)
725                                         BLI_addtail(&anim_basepaths, BLI_genericNodeN(path));
726                         }
727
728                         /* ensure valid parent pointers, detach if parent stays outside the group */
729                         if (node->parent && !(node->parent->flag & NODE_SELECT))
730                                 nodeDetachNode(node);
731
732                         /* change node-collection membership */
733                         BLI_remlink(&ntree->nodes, node);
734                         BLI_addtail(&ngroup->nodes, node);
735
736                         /* ensure unique node name in the ngroup */
737                         nodeUniqueName(ngroup, node);
738                 }
739         }
740
741         /* move animation data over */
742         if (ntree->adt) {
743                 LinkData *ld, *ldn = NULL;
744
745                 BKE_animdata_separate_by_basepath(&ntree->id, &ngroup->id, &anim_basepaths);
746
747                 /* paths + their wrappers need to be freed */
748                 for (ld = anim_basepaths.first; ld; ld = ldn) {
749                         ldn = ld->next;
750
751                         MEM_freeN(ld->data);
752                         BLI_freelinkN(&anim_basepaths, ld);
753                 }
754         }
755
756         /* node groups don't use internal cached data */
757         ntreeFreeCache(ngroup);
758
759         /* create input node */
760         input_node = nodeAddStaticNode(C, ngroup, NODE_GROUP_INPUT);
761         input_node->locx = min[0] - center[0] - offsetx;
762         input_node->locy = -offsety;
763
764         /* create output node */
765         output_node = nodeAddStaticNode(C, ngroup, NODE_GROUP_OUTPUT);
766         output_node->locx = max[0] - center[0] + offsetx;
767         output_node->locy = -offsety;
768
769         /* relink external sockets */
770         for (link = ntree->links.first; link; link = linkn) {
771                 int fromselect = node_group_make_use_node(link->fromnode, gnode);
772                 int toselect = node_group_make_use_node(link->tonode, gnode);
773
774                 linkn = link->next;
775
776                 if ((fromselect && link->tonode == gnode) || (toselect && link->fromnode == gnode)) {
777                         /* remove all links to/from the gnode.
778                          * this can remove link information, but there's no general way to preserve it.
779                          */
780                         nodeRemLink(ntree, link);
781                 }
782                 else if (fromselect && toselect) {
783                         BLI_remlink(&ntree->links, link);
784                         BLI_addtail(&ngroup->links, link);
785                 }
786                 else if (toselect) {
787                         bNodeSocket *iosock = ntreeAddSocketInterfaceFromSocket(ngroup, link->tonode, link->tosock);
788                         bNodeSocket *input_sock;
789
790                         /* update the group node and interface node sockets,
791                          * so the new interface socket can be linked.
792                          */
793                         node_group_verify(ntree, gnode, (ID *)ngroup);
794                         node_group_input_verify(ngroup, input_node, (ID *)ngroup);
795
796                         /* create new internal link */
797                         input_sock = node_group_input_find_socket(input_node, iosock->identifier);
798                         nodeAddLink(ngroup, input_node, input_sock, link->tonode, link->tosock);
799
800                         /* redirect external link */
801                         link->tonode = gnode;
802                         link->tosock = node_group_find_input_socket(gnode, iosock->identifier);
803                 }
804                 else if (fromselect) {
805                         /* First check whether the source of this link is already connected to an output.
806                          * If yes, reuse that output instead of duplicating it. */
807                         bool connected = false;
808                         bNodeLink *olink;
809                         for (olink = ngroup->links.first; olink; olink = olink->next) {
810                                 if (olink->fromsock == link->fromsock && olink->tonode == output_node) {
811                                         bNodeSocket *output_sock = node_group_find_output_socket(gnode, olink->tosock->identifier);
812                                         link->fromnode = gnode;
813                                         link->fromsock = output_sock;
814                                         connected = true;
815                                 }
816                         }
817
818                         if (!connected) {
819                                 bNodeSocket *iosock = ntreeAddSocketInterfaceFromSocket(ngroup, link->fromnode, link->fromsock);
820                                 bNodeSocket *output_sock;
821
822                                 /* update the group node and interface node sockets,
823                                  * so the new interface socket can be linked.
824                                  */
825                                 node_group_verify(ntree, gnode, (ID *)ngroup);
826                                 node_group_output_verify(ngroup, output_node, (ID *)ngroup);
827
828                                 /* create new internal link */
829                                 output_sock = node_group_output_find_socket(output_node, iosock->identifier);
830                                 nodeAddLink(ngroup, link->fromnode, link->fromsock, output_node, output_sock);
831
832                                 /* redirect external link */
833                                 link->fromnode = gnode;
834                                 link->fromsock = node_group_find_output_socket(gnode, iosock->identifier);
835                         }
836                 }
837         }
838
839         /* move nodes in the group to the center */
840         for (node = ngroup->nodes.first; node; node = node->next) {
841                 if (node_group_make_use_node(node, gnode) && !node->parent) {
842                         node->locx -= center[0];
843                         node->locy -= center[1];
844                 }
845         }
846
847         /* expose all unlinked sockets too */
848         if (expose_all) {
849                 for (node = ngroup->nodes.first; node; node = node->next) {
850                         if (node_group_make_use_node(node, gnode)) {
851                                 for (sock = node->inputs.first; sock; sock = sock->next) {
852                                         bNodeSocket *iosock, *input_sock;
853                                         bool skip = false;
854                                         for (link = ngroup->links.first; link; link = link->next) {
855                                                 if (link->tosock == sock) {
856                                                         skip = true;
857                                                         break;
858                                                 }
859                                         }
860                                         if (skip)
861                                                 continue;
862
863                                         iosock = ntreeAddSocketInterfaceFromSocket(ngroup, node, sock);
864
865                                         node_group_input_verify(ngroup, input_node, (ID *)ngroup);
866
867                                         /* create new internal link */
868                                         input_sock = node_group_input_find_socket(input_node, iosock->identifier);
869                                         nodeAddLink(ngroup, input_node, input_sock, node, sock);
870                                 }
871
872                                 for (sock = node->outputs.first; sock; sock = sock->next) {
873                                         bNodeSocket *iosock, *output_sock;
874                                         bool skip = false;
875                                         for (link = ngroup->links.first; link; link = link->next)
876                                                 if (link->fromsock == sock)
877                                                         skip = true;
878                                         if (skip)
879                                                 continue;
880
881                                         iosock = ntreeAddSocketInterfaceFromSocket(ngroup, node, sock);
882
883                                         node_group_output_verify(ngroup, output_node, (ID *)ngroup);
884
885                                         /* create new internal link */
886                                         output_sock = node_group_output_find_socket(output_node, iosock->identifier);
887                                         nodeAddLink(ngroup, node, sock, output_node, output_sock);
888                                 }
889                         }
890                 }
891         }
892
893         /* update of the group tree */
894         ngroup->update |= NTREE_UPDATE | NTREE_UPDATE_LINKS;
895         /* update of the tree containing the group instance node */
896         ntree->update |= NTREE_UPDATE_NODES | NTREE_UPDATE_LINKS;
897 }
898
899 static bNode *node_group_make_from_selected(const bContext *C, bNodeTree *ntree, const char *ntype, const char *ntreetype)
900 {
901         Main *bmain = CTX_data_main(C);
902         bNode *gnode;
903         bNodeTree *ngroup;
904         float min[2], max[2];
905         int totselect;
906
907         totselect = node_get_selected_minmax(ntree, NULL, min, max);
908         /* don't make empty group */
909         if (totselect == 0)
910                 return NULL;
911
912         /* new nodetree */
913         ngroup = ntreeAddTree(bmain, "NodeGroup", ntreetype);
914
915         /* make group node */
916         gnode = nodeAddNode(C, ntree, ntype);
917         gnode->id = (ID *)ngroup;
918
919         gnode->locx = 0.5f * (min[0] + max[0]);
920         gnode->locy = 0.5f * (min[1] + max[1]);
921
922         node_group_make_insert_selected(C, ntree, gnode);
923
924         /* update of the tree containing the group instance node */
925         ntree->update |= NTREE_UPDATE_NODES;
926
927         return gnode;
928 }
929
930 static int node_group_make_exec(bContext *C, wmOperator *op)
931 {
932         SpaceNode *snode = CTX_wm_space_node(C);
933         bNodeTree *ntree = snode->edittree;
934         const char *ntree_idname = group_ntree_idname(C);
935         const char *node_idname = group_node_idname(C);
936         bNodeTree *ngroup;
937         bNode *gnode;
938         Main *bmain = CTX_data_main(C);
939
940         ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
941
942         if (!node_group_make_test_selected(ntree, NULL, ntree_idname, op->reports))
943                 return OPERATOR_CANCELLED;
944
945         gnode = node_group_make_from_selected(C, ntree, node_idname, ntree_idname);
946
947         if (gnode) {
948                 ngroup = (bNodeTree *)gnode->id;
949
950                 nodeSetActive(ntree, gnode);
951                 if (ngroup) {
952                         ED_node_tree_push(snode, ngroup, gnode);
953                         ntreeUpdateTree(bmain, ngroup);
954                 }
955         }
956
957         ntreeUpdateTree(bmain, ntree);
958
959         snode_notify(C, snode);
960         snode_dag_update(C, snode);
961
962         return OPERATOR_FINISHED;
963 }
964
965 void NODE_OT_group_make(wmOperatorType *ot)
966 {
967         /* identifiers */
968         ot->name = "Make Group";
969         ot->description = "Make group from selected nodes";
970         ot->idname = "NODE_OT_group_make";
971
972         /* api callbacks */
973         ot->exec = node_group_make_exec;
974         ot->poll = node_group_operator_editable;
975
976         /* flags */
977         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
978 }
979
980 /* ****************** Group Insert operator ******************* */
981
982 static int node_group_insert_exec(bContext *C, wmOperator *op)
983 {
984         SpaceNode *snode = CTX_wm_space_node(C);
985         bNodeTree *ntree = snode->edittree;
986         bNodeTree *ngroup;
987         const char *node_idname = group_node_idname(C);
988         bNode *gnode;
989         Main *bmain = CTX_data_main(C);
990
991         ED_preview_kill_jobs(CTX_wm_manager(C), CTX_data_main(C));
992
993         gnode = node_group_get_active(C, node_idname);
994
995         if (!gnode || !gnode->id)
996                 return OPERATOR_CANCELLED;
997
998         ngroup = (bNodeTree *)gnode->id;
999         if (!node_group_make_test_selected(ntree, gnode, ngroup->idname, op->reports))
1000                 return OPERATOR_CANCELLED;
1001
1002         node_group_make_insert_selected(C, ntree, gnode);
1003
1004         nodeSetActive(ntree, gnode);
1005         ED_node_tree_push(snode, ngroup, gnode);
1006         ntreeUpdateTree(bmain, ngroup);
1007
1008         ntreeUpdateTree(bmain, ntree);
1009
1010         snode_notify(C, snode);
1011         snode_dag_update(C, snode);
1012
1013         return OPERATOR_FINISHED;
1014 }
1015
1016 void NODE_OT_group_insert(wmOperatorType *ot)
1017 {
1018         /* identifiers */
1019         ot->name = "Group Insert";
1020         ot->description = "Insert selected nodes into a node group";
1021         ot->idname = "NODE_OT_group_insert";
1022
1023         /* api callbacks */
1024         ot->exec = node_group_insert_exec;
1025         ot->poll = node_group_operator_editable;
1026
1027         /* flags */
1028         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1029 }