Blender V5.3
node_edit.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10#include <optional>
11
12#include "MEM_guardedalloc.h"
13
14#include "DNA_layer_types.h"
15#include "DNA_material_types.h"
16#include "DNA_node_types.h"
17#include "DNA_text_types.h"
18#include "DNA_world_types.h"
19
20#include "BKE_callbacks.hh"
21#include "BKE_context.hh"
22#include "BKE_global.hh"
23#include "BKE_image.hh"
24#include "BKE_lib_id.hh"
25#include "BKE_main.hh"
27#include "BKE_material.hh"
28#include "BKE_node.hh"
30#include "BKE_node_runtime.hh"
32#include "BKE_report.hh"
33#include "BKE_scene.hh"
34#include "BKE_scene_runtime.hh"
35#include "BKE_screen.hh"
36
37#include "BLI_listbase.hh"
38#include "BLI_math_vector.hh"
39#include "BLI_math_vector_c.hh"
40#include "BLI_string.hh"
41#include "BLI_string_utf8.hh"
42#include "BLI_utildefines.hh"
43
44#include "BLT_translation.hh"
45
46#include "DEG_depsgraph.hh"
50
52#include "RE_compositor.hh"
53#include "RE_engine.h"
54#include "RE_pipeline.h"
55
56#include "ED_image.hh"
57#include "ED_node.hh" /* own include */
58#include "ED_render.hh"
59#include "ED_screen.hh"
60#include "ED_viewer_path.hh"
61
62#include "RNA_access.hh"
63#include "RNA_define.hh"
64#include "RNA_prototypes.hh"
65
66#include "WM_api.hh"
67#include "WM_types.hh"
68
69#include "UI_view2d.hh"
70
71#include "GPU_material.hh"
72
73#include "IMB_imbuf.hh"
74#include "IMB_imbuf_types.hh"
75
76#include "NOD_composite.hh"
77#include "NOD_geometry.hh"
78#include "NOD_shader.h"
79#include "NOD_socket.hh"
80#include "NOD_texture.h"
81#include "node_intern.hh" /* own include */
82
83namespace blender {
84
85namespace ed::space_node {
86
87/* -------------------------------------------------------------------- */
90
92{
95 if (ED_node_is_compositor(snode)) {
96 return true;
97 }
98 }
99 return false;
100}
101
103{
105 SpaceNode *snode = CTX_wm_space_node(C);
106 if (ED_node_is_compositor(snode)) {
107 return true;
108 }
109 }
110 return false;
111}
112
114
115} // namespace ed::space_node
116
117/* -------------------------------------------------------------------- */
120
122{
123 if (typeinfo) {
124 STRNCPY_UTF8(snode->tree_idname, typeinfo->idname.c_str());
125 }
126 else {
127 snode->tree_idname[0] = '\0';
128 }
129
130 /* Reset members that store tree type-dependant values. */
131 snode->node_tree_sub_type = 0;
132 snode->selected_node_group = nullptr;
133}
134
136{
137 return snode->tree_idname == ntreeType_Composite->idname;
138}
139
141{
142 return snode->tree_idname == ntreeType_Shader->idname;
143}
144
146{
147 return snode->tree_idname == ntreeType_Texture->idname;
148}
149
151{
152 return snode->tree_idname == ntreeType_Geometry->idname;
153}
154
156{
157 return ED_node_is_compositor(snode) ||
158 (USER_EXPERIMENTAL_TEST(&U, use_shader_node_previews) && ED_node_is_shader(snode));
159}
160
162{
163 if (tex->nodetree) {
164 if (G.debug & G_DEBUG) {
165 printf("error in texture initialize\n");
166 }
167 return;
168 }
169
171 nullptr, &tex->id, "Texture Nodetree", ntreeType_Texture->idname.ref());
172
174 out->location[0] = 300.0f;
175 out->location[1] = 300.0f;
176
178 in->location[0] = 10.0f;
179 in->location[1] = 300.0f;
181
182 bNodeSocket *fromsock = in->outputs.first();
183 bNodeSocket *tosock = out->inputs.first();
184 bke::node_add_link(*tex->nodetree, *in, *fromsock, *out, *tosock);
185
187}
188
189namespace ed::space_node {
190
192{
193 /* NOTE: Here we set the active tree(s), even called for each redraw now, so keep it fast :). */
194
195 SpaceNode *snode = CTX_wm_space_node(&C);
197 bNodeTree *ntree = snode->nodetree;
198 ID *id = snode->id, *from = snode->from;
199
200 /* Check the tree type. */
201 if (!treetype || (treetype->poll && !treetype->poll(&C, treetype))) {
202 /* Invalid tree type, skip.
203 * NOTE: not resetting the node path here, invalid #bNodeTreeType
204 * may still be registered at a later point. */
205 return;
206 }
207
208 if (snode->nodetree && !STREQ(snode->nodetree->idname, snode->tree_idname)) {
209 /* Current tree does not match selected type, clear tree path. */
210 ntree = nullptr;
211 id = nullptr;
212 from = nullptr;
213 }
214
215 if (!(snode->flag & SNODE_PIN) || ntree == nullptr) {
216 if (treetype->get_from_context) {
217 /* Reset and update from context. */
218 ntree = nullptr;
219 id = nullptr;
220 from = nullptr;
221
222 treetype->get_from_context(&C, treetype, &ntree, &id, &from);
223 }
224 }
225
226 if (snode->nodetree != ntree || snode->id != id || snode->from != from ||
227 (snode->treepath.last() == nullptr && ntree))
228 {
229 ScrArea *area = CTX_wm_area(&C);
231 ED_node_tree_start(region, snode, ntree, id, from);
232 }
233}
234
235} // namespace ed::space_node
236
238 Main *bmain, SpaceNode *snode, bNodeTree *ntree, bNode *node, bool *r_active_texture_changed)
239{
240 if (r_active_texture_changed) {
241 *r_active_texture_changed = false;
242 }
243
244 bke::node_set_active(*ntree, *node);
245 if (node->type_legacy == NODE_GROUP) {
246 return;
247 }
248
249 const bool was_output = (node->flag & NODE_DO_OUTPUT) != 0;
250 bool do_update = false;
251
252 /* Generic node group output: set node as active output. */
253 if (node->is_group_output()) {
254 for (bNode *node_iter : ntree->all_nodes()) {
255 if (node_iter->is_group_output()) {
256 node_iter->flag &= ~NODE_DO_OUTPUT;
257 }
258 }
259
260 node->flag |= NODE_DO_OUTPUT;
261 if (!was_output) {
262 do_update = true;
264 }
265 }
266
267 /* Tree specific activate calls. */
268 if (ntree->type == NTREE_SHADER) {
269 if (ELEM(node->type_legacy,
274 {
275 for (bNode *node_iter : ntree->all_nodes()) {
276 if (node_iter->type_legacy == node->type_legacy) {
277 node_iter->flag &= ~NODE_DO_OUTPUT;
278 }
279 }
280
281 node->flag |= NODE_DO_OUTPUT;
283 }
284
285 BKE_main_ensure_invariants(*bmain, ntree->id);
286
287 if (node->flag & NODE_ACTIVE_TEXTURE) {
288 /* If active texture changed, free GLSL materials. */
289 for (Material &ma : bmain->materials) {
290 if (ma.nodetree && bke::node_tree_contains_tree(*ma.nodetree, *ntree)) {
291 GPU_material_free(&ma.gpumaterial);
292
293 /* Sync to active texpaint slot, otherwise we can end up painting on a different slot
294 * than we are looking at. */
295 if (ma.texpaintslot) {
296 if (node->id != nullptr && node->id->id_type() == ID_IM) {
297 Image *image = id_cast<Image *>(node->id);
298 for (int i = 0; i < ma.tot_slots; i++) {
299 if (ma.texpaintslot[i].ima == image) {
300 ma.paint_active_slot = i;
302 }
303 }
304 }
305 }
306 }
307 }
308
309 for (World &wo : bmain->worlds) {
310 if (wo.nodetree && bke::node_tree_contains_tree(*wo.nodetree, *ntree)) {
311 GPU_material_free(&wo.gpumaterial);
312 }
313 }
314
315 /* Sync to Image Editor under the following conditions:
316 * - current image is not pinned
317 * - current image is not a Render Result or ViewerNode (want to keep looking at these) */
318 if (node->id != nullptr && node->id->id_type() == ID_IM) {
319 Image *image = id_cast<Image *>(node->id);
320 ED_space_image_sync(bmain, image, true);
321 }
322
323 if (r_active_texture_changed) {
324 *r_active_texture_changed = true;
325 }
326 BKE_main_ensure_invariants(*bmain, ntree->id);
328 }
329
331 }
332 else if (ntree->type == NTREE_COMPOSIT) {
333 /* Make active viewer, currently only one is supported. */
334 if (node->type_legacy == CMP_NODE_VIEWER) {
335 for (bNode *node_iter : ntree->all_nodes()) {
336 if (node_iter->type_legacy == CMP_NODE_VIEWER) {
337 node_iter->flag &= ~NODE_DO_OUTPUT;
338 }
339 }
340
341 node->flag |= NODE_DO_OUTPUT;
342 if (was_output == 0) {
344 BKE_main_ensure_invariants(*bmain, ntree->id);
345 }
346 }
347 else if (do_update) {
348 BKE_main_ensure_invariants(*bmain, ntree->id);
349 }
350 }
351 else if (ntree->type == NTREE_GEOMETRY) {
352 if (node->type_legacy == GEO_NODE_VIEWER) {
353 if ((node->flag & NODE_DO_OUTPUT) == 0) {
354 for (bNode *node_iter : ntree->all_nodes()) {
355 if (node_iter->type_legacy == GEO_NODE_VIEWER) {
356 node_iter->flag &= ~NODE_DO_OUTPUT;
357 }
358 }
359 node->flag |= NODE_DO_OUTPUT;
360 }
362 }
363 }
364}
365
367{
368 /* XXX This does not work due to layout functions relying on node->block,
369 * which only exists during actual drawing. Can we rely on valid draw_bounds rects?
370 */
371 /* make sure nodes have correct bounding boxes after transform */
372 // node_update_nodetree(C, ntree, 0.0f, 0.0f);
373}
374
376
377namespace ed::space_node {
378
379/* -------------------------------------------------------------------- */
382
383static bool socket_is_occluded(const float2 &cursor,
384 const bNodeSocket &socket,
385 const bNode &node_the_socket_belongs_to,
386 const Span<bNode *> sorted_nodes)
387{
388 for (bNode *node : sorted_nodes) {
389 if (node == &node_the_socket_belongs_to) {
390 /* Nodes after this one are underneath and can't occlude the socket. */
391 return false;
392 }
393
394 if (BLI_rctf_isect_pt_v(&node->runtime->draw_bounds, cursor)) {
395 /* The cursor actually hovers over a node in front of the socket. */
396 return true;
397 }
398
399 /* The hit-box of the socket is larger than the socket symbol to make dragging links easier. So
400 * we check if the socket is fully occluded to prevent dragging links from behind nodes.
401 * Subtract some tolerance to avoid picking the socket when it's only barely visible.
402 */
403 const float2 &location = socket.runtime->location;
404 const float tolerance = 0.1f * U.widget_unit;
405 const float half_width = NODE_SOCKSIZE - tolerance;
406 const float half_height = node_socket_calculate_height(socket) - tolerance;
407
408 const rctf socket_bounds = {location.x - half_width,
409 location.x + half_width,
410 location.y - half_height,
411 location.y + half_height};
412
413 if (BLI_rctf_inside_rctf(&node->runtime->draw_bounds, &socket_bounds)) {
414 return true;
415 }
416 }
417 return false;
418}
419
421
422/* -------------------------------------------------------------------- */
425
431
438
440 wmOperator *op,
441 const float2 &cursor,
444{
445 Scene *scene = CTX_data_scene(C);
446 NodeSizeWidget *nsw = MEM_new<NodeSizeWidget>(__func__);
447
448 op->customdata = nsw;
449
450 nsw->mxstart = cursor.x;
451 nsw->mystart = cursor.y;
452
453 for (bNode *node : nodes) {
454 nsw->nodes_data.append(
455 {node, node->location[0], node->location[1], node->width, node->height});
456 }
457
458 nsw->directions = dir;
460
462 /* add modal handler */
464}
465
466static void node_resize_exit(bContext *C, wmOperator *op, bool cancel)
467{
468 NodeSizeWidget *nsw = static_cast<NodeSizeWidget *>(op->customdata);
469
471
472 /* Restore old data on cancel. */
473 if (cancel) {
474 for (const NodeResizeData &rd : nsw->nodes_data) {
475 rd.node->location[0] = rd.oldlocx;
476 rd.node->location[1] = rd.oldlocy;
477 rd.node->width = rd.oldwidth;
478 rd.node->height = rd.oldheight;
479 }
480 }
481
482 MEM_delete(nsw);
483 op->customdata = nullptr;
484}
485
486enum class NodeResizeAction : int {
487 Begin = 0,
488 Cancel = 1,
491};
492
494{
495 static const EnumPropertyItem modal_items[] = {
496 {int(NodeResizeAction::Begin), "BEGIN", 0, "Resize Node", ""},
497 {int(NodeResizeAction::Cancel), "CANCEL", 0, "Cancel", ""},
498 {int(NodeResizeAction::SnapInvertOn), "SNAP_INVERT_ON", 0, "Snap Invert", ""},
499 {int(NodeResizeAction::SnapInvertOff), "SNAP_INVERT_OFF", 0, "Snap Invert", ""},
500 {0, nullptr, 0, nullptr, nullptr},
501 };
502
503 wmKeyMap *keymap = WM_modalkeymap_find(keyconf, "Node Resize Modal Map");
504
505 if (keymap && keymap->modal_items) {
506 return nullptr;
507 }
508
509 keymap = WM_modalkeymap_ensure(keyconf, "Node Resize Modal Map", modal_items);
510
511 WM_modalkeymap_assign(keymap, "NODE_OT_resize");
512
513 return keymap;
514}
515
517{
518 /* Size and location of nodes are independent of UI scale, so grid size should be independent of
519 * UI scale as well. */
520 float grid_size = NODE_GRID_UNIT;
521 float rest = fmod(co, grid_size);
522 float offset = rest - grid_size / 2 >= 0 ? grid_size : 0;
523
524 return co - rest + offset;
525}
526
528{
529 SpaceNode *snode = CTX_wm_space_node(C);
530 ARegion *region = CTX_wm_region(C);
531 NodeSizeWidget *nsw = static_cast<NodeSizeWidget *>(op->customdata);
532
533 if (event->type == EVT_MODAL_MAP) {
534 switch (NodeResizeAction(event->val)) {
537 }
539 node_resize_exit(C, op, true);
540 ED_region_tag_redraw(region);
541 return OPERATOR_CANCELLED;
542 }
545 nsw->snap_to_grid = !nsw->snap_to_grid;
547 }
548 }
549 }
550
551 switch (event->type) {
552 case MOUSEMOVE: {
553 int2 mval;
554 WM_event_drag_start_mval(event, region, mval);
555 float mx, my;
556 ui::view2d_region_to_view(&region->v2d, mval.x, mval.y, &mx, &my);
557 const float dx = (mx - nsw->mxstart) / UI_SCALE_FAC;
558 const float dy = (my - nsw->mystart) / UI_SCALE_FAC;
559
560 for (NodeResizeData &rd : nsw->nodes_data) {
561 bNode *node = rd.node;
562 float *pwidth = &node->width;
563 float *pheight = &node->height;
564 float oldwidth = rd.oldwidth;
565 float widthmin = node->typeinfo->minwidth;
566 float widthmax = node->typeinfo->maxwidth;
567
568 {
569 if (nsw->directions & NODE_RESIZE_RIGHT) {
570 *pwidth = oldwidth + dx;
571
572 if (nsw->snap_to_grid) {
573 *pwidth = nearest_node_grid_coord(*pwidth);
574 }
575 CLAMP(*pwidth, widthmin, widthmax);
576 }
577 if (nsw->directions & NODE_RESIZE_LEFT) {
578 float locmax = rd.oldlocx + oldwidth;
579 *pwidth = oldwidth - dx;
580
581 if (nsw->snap_to_grid) {
582 *pwidth = nearest_node_grid_coord(*pwidth);
583 }
584 CLAMP(*pwidth, widthmin, widthmax);
585 node->location[0] = locmax - *pwidth;
586 }
587 }
588
589 /* Height works the other way round. */
590 if (node->is_frame()) {
591 float heightmin = UI_SCALE_FAC * node->typeinfo->minheight;
592 float heightmax = UI_SCALE_FAC * node->typeinfo->maxheight;
593 if (nsw->directions & NODE_RESIZE_TOP) {
594 float locmin = rd.oldlocy - rd.oldheight;
595 *pheight = rd.oldheight + dy;
596
597 if (nsw->snap_to_grid) {
598 *pheight = nearest_node_grid_coord(*pheight);
599 }
600 CLAMP(*pheight, heightmin, heightmax);
601 node->location[1] = locmin + *pheight;
602 }
603 if (nsw->directions & NODE_RESIZE_BOTTOM) {
604 *pheight = rd.oldheight - dy;
605
606 if (nsw->snap_to_grid) {
607 *pheight = nearest_node_grid_coord(*pheight);
608 }
609 CLAMP(*pheight, heightmin, heightmax);
610 }
611 }
612 }
613
614 ED_region_tag_redraw(region);
615
616 break;
617 }
618 case LEFTMOUSE:
619 case MIDDLEMOUSE:
620 case RIGHTMOUSE: {
621 if (event->val == KM_RELEASE) {
622 node_resize_exit(C, op, false);
624
625 return OPERATOR_FINISHED;
626 }
627 break;
628 }
629 default: {
630 break;
631 }
632 }
633
635}
636
638{
639 SpaceNode *snode = CTX_wm_space_node(C);
640 ARegion *region = CTX_wm_region(C);
641
642 /* Convert mouse coordinates to `v2d` space. */
643 float2 cursor;
644 int2 mval;
645 WM_event_drag_start_mval(event, region, mval);
646 ui::view2d_region_to_view(&region->v2d, mval.x, mval.y, &cursor.x, &cursor.y);
647
648 /* Use the hovered node to determine the resize direction.
649 * This node may not be the active one if multiple nodes are selected. */
650 const bNode *node = node_under_mouse_get(*snode, cursor);
651 if (node == nullptr) {
653 }
654
655 const NodeResizeDirection dir = node_get_resize_direction(*snode, node, cursor.x, cursor.y);
656 if (dir == NODE_RESIZE_NONE) {
658 }
659
660 node_resize_init(C, op, cursor, get_selected_nodes(*snode->edittree), dir);
662}
663
665{
666 node_resize_exit(C, op, true);
667}
668
670{
671 /* identifiers */
672 ot->name = "Resize Node";
673 ot->idname = "NODE_OT_resize";
674 ot->description = "Resize a node";
675
676 /* API callbacks. */
681
682 /* flags */
683 ot->flag = OPTYPE_BLOCKING;
684}
685
687
688/* -------------------------------------------------------------------- */
691
693{
694 for (bNodeSocket &sock : node->inputs) {
695 if (sock.is_user_hidden()) {
696 return true;
697 }
698 }
699 for (bNodeSocket &sock : node->outputs) {
700 if (sock.is_user_hidden()) {
701 return true;
702 }
703 }
704 return false;
705}
706
708{
709 /* The Reroute node is the socket itself, do not hide this. */
710 if (node->is_reroute()) {
711 return;
712 }
713
714 if (set == 0) {
715 for (bNodeSocket &sock : node->inputs) {
716 sock.flag &= ~SOCK_HIDDEN;
717 }
718 for (bNodeSocket &sock : node->outputs) {
719 sock.flag &= ~SOCK_HIDDEN;
720 }
721 }
722 else {
723 /* Hide unused sockets. */
724 for (bNodeSocket &sock : node->inputs) {
725 if (sock.link == nullptr) {
726 sock.flag |= SOCK_HIDDEN;
727 sock.flag &= ~SOCK_SELECT;
728 }
729 }
730 for (bNodeSocket &sock : node->outputs) {
731 if ((sock.flag & SOCK_IS_LINKED) == 0) {
732 sock.flag |= SOCK_HIDDEN;
733 sock.flag &= ~SOCK_SELECT;
734 }
735 }
736 }
737}
738
739bool node_is_previewable(const SpaceNode &snode, const bNodeTree &ntree, const bNode &node)
740{
741 if (!(snode.overlay.flag & SN_OVERLAY_SHOW_OVERLAYS) ||
743 {
744 return false;
745 }
746 if (ntree.type == NTREE_SHADER) {
747 return USER_EXPERIMENTAL_TEST(&U, use_shader_node_previews) && !node.is_frame() &&
749 }
750 return node.typeinfo->flag & NODE_PREVIEW;
751}
752
754{
755 float sock_height = NODE_SOCKSIZE;
756 if (socket.flag & SOCK_MULTI_INPUT) {
757 sock_height += max_ii(NODE_MULTI_INPUT_LINK_GAP * 0.5f * socket.runtime->total_inputs,
759 }
760 return sock_height;
761}
762
764 const int index,
765 const int total_inputs)
766{
767 const float offset = (total_inputs * NODE_MULTI_INPUT_LINK_GAP - NODE_MULTI_INPUT_LINK_GAP) *
768 0.5f;
769 return {socket_position.x, socket_position.y - offset + index * NODE_MULTI_INPUT_LINK_GAP};
770}
771
772static bool cursor_isect_multi_input_socket(const float2 &cursor, const bNodeSocket &socket)
773{
774 const float node_socket_height = node_socket_calculate_height(socket);
775 const float2 location = socket.runtime->location;
776 /* `.xmax = socket->location[0] + NODE_SOCKSIZE * 5.5f`
777 * would be the same behavior as for regular sockets.
778 * But keep it smaller because for multi-input socket you
779 * sometimes want to drag the link to the other side, if you may
780 * accidentally pick the wrong link otherwise. */
781 rctf multi_socket_rect;
782 BLI_rctf_init(&multi_socket_rect,
783 location.x - NODE_SOCKSIZE * 4.0f,
784 location.x + NODE_SOCKSIZE * 2.0f,
785 location.y - node_socket_height,
786 location.y + node_socket_height);
787 if (BLI_rctf_isect_pt(&multi_socket_rect, cursor.x, cursor.y)) {
788 return true;
789 }
790 return false;
791}
792
794 ARegion &region,
795 const float2 &cursor,
796 const eNodeSocketInOut in_out)
797{
798 const float view2d_scale = ui::view2d_scale_get_x(&region.v2d);
799 const float max_distance = NODE_SOCKSIZE + std::clamp(20.0f / view2d_scale, 5.0f, 30.0f);
800 const float padded_socket_size = NODE_SOCKSIZE + 4;
801
802 bNodeTree &tree = *snode.edittree;
803 tree.ensure_topology_cache();
804
805 const Array<bNode *> sorted_nodes = tree_draw_order_calc_nodes_reversed(tree);
806 if (sorted_nodes.is_empty()) {
807 return nullptr;
808 }
809
810 float best_distance = FLT_MAX;
811 bNodeSocket *best_socket = nullptr;
812
813 auto update_best_socket = [&](bNodeSocket *socket, const float distance) {
814 if (socket_is_occluded(cursor, *socket, socket->owner_node(), sorted_nodes)) {
815 return;
816 }
817 if (distance < best_distance) {
818 best_distance = distance;
819 best_socket = socket;
820 }
821 };
822
823 for (bNode *node : sorted_nodes) {
824 const bool node_collapsed = node->flag & NODE_COLLAPSED;
825 if (!node->is_reroute() && !node_collapsed &&
826 node->runtime->draw_bounds.ymax - cursor.y < NODE_DY)
827 {
828 /* Don't pick socket when cursor is over node header. This allows the user to always resize
829 * by dragging on the left and right side of the header. */
830 continue;
831 }
832 if (in_out & SOCK_IN) {
833 for (bNodeSocket *sock : node->input_sockets()) {
834 if (!sock->is_icon_visible()) {
835 continue;
836 }
837 const float2 location = sock->runtime->location;
838 const float distance = math::distance(location, cursor);
839 if (sock->flag & SOCK_MULTI_INPUT && !node_collapsed) {
840 if (cursor_isect_multi_input_socket(cursor, *sock)) {
841 update_best_socket(sock, distance);
842 continue;
843 }
844 }
845 if (distance < max_distance) {
846 if (node_collapsed) {
847 if ((cursor.x - location.x > NODE_SOCKSIZE) ||
848 ((location.x < cursor.x) && (cursor.x - location.x <= padded_socket_size) &&
849 (abs(location.y - cursor.y) > NODE_SOCKSIZE)))
850 {
851 /* Needed to be able to resize collapsed nodes. */
852 continue;
853 }
854 }
855 update_best_socket(sock, distance);
856 }
857 }
858 }
859 if (in_out & SOCK_OUT) {
860 for (bNodeSocket *sock : node->output_sockets()) {
861 if (!sock->is_icon_visible()) {
862 continue;
863 }
864 const float2 location = sock->runtime->location;
865 const float distance = math::distance(location, cursor);
866 if (distance < max_distance) {
867 if (node_collapsed) {
868 if ((location.x - cursor.x > NODE_SOCKSIZE) ||
869 ((location.x > cursor.x) && (location.x - cursor.x <= padded_socket_size) &&
870 (abs(location.y - cursor.y) > NODE_SOCKSIZE)))
871 {
872 /* Needed to be able to resize collapsed nodes. */
873 continue;
874 }
875 }
876 update_best_socket(sock, distance);
877 }
878 }
879 }
880 }
881
882 return best_socket;
883}
884
886
887/* -------------------------------------------------------------------- */
890
891float node_link_dim_factor(const View2D &v2d, const bNodeLink &link)
892{
893 if (link.fromsock == nullptr || link.tosock == nullptr) {
894 return 1.0f;
895 }
897 return 0.2f;
898 }
899
900 const float2 from = link.fromsock->runtime->location;
901 const float2 to = link.tosock->runtime->location;
902
903 const float min_endpoint_distance = std::min(
904 std::max(BLI_rctf_length_x(&v2d.cur, from.x), BLI_rctf_length_y(&v2d.cur, from.y)),
905 std::max(BLI_rctf_length_x(&v2d.cur, to.x), BLI_rctf_length_y(&v2d.cur, to.y)));
906
907 if (min_endpoint_distance == 0.0f) {
908 return 1.0f;
909 }
910 const float viewport_width = BLI_rctf_size_x(&v2d.cur);
911 return std::clamp(1.0f - min_endpoint_distance / viewport_width * 10.0f, 0.05f, 1.0f);
912}
913
914bool node_link_is_hidden_or_dimmed(const View2D &v2d, const bNodeLink &link)
915{
916 return bke::node_link_is_hidden(link) || node_link_dim_factor(v2d, link) < 0.5f;
917}
918
920
921/* -------------------------------------------------------------------- */
924
926 const Map<bNode *, bNode *> &node_map,
927 bNode *node)
928{
929 bNode *parent;
930
931 node->flag |= NODE_TEST;
932
933 /* Find first selected parent. */
934 for (parent = node->parent; parent; parent = parent->parent) {
935 if (parent->is_selected()) {
936 if (!(parent->flag & NODE_TEST)) {
937 node_duplicate_reparent_recursive(ntree, node_map, parent);
938 }
939 break;
940 }
941 }
942 /* Reparent node copy to parent copy. */
943 if (parent) {
944 bke::node_detach_node(*ntree, *node_map.lookup(node));
945 bke::node_attach_node(*ntree, *node_map.lookup(node), *node_map.lookup(parent));
946 }
947}
948
950{
951 /* We don't have the old tree for looking up output nodes by ID,
952 * so we have to build a map first to find copied output nodes in the new tree. */
953 Map<int32_t, bNode *> dst_output_node_map;
954 for (const auto &item : node_map.items()) {
955 if (bke::all_zone_output_node_types().contains(item.key->type_legacy)) {
956 dst_output_node_map.add_new(item.key->identifier, item.value);
957 }
958 }
959
960 for (bNode *dst_node : node_map.values()) {
961 if (bke::all_zone_input_node_types().contains(dst_node->type_legacy)) {
962 const bke::bNodeZoneType &zone_type = *bke::zone_type_by_node_type(dst_node->type_legacy);
963 int &output_node_id = zone_type.get_corresponding_output_id(*dst_node);
964 if (const bNode *output_node = dst_output_node_map.lookup_default(output_node_id, nullptr)) {
965 output_node_id = output_node->identifier;
966 }
967 else {
968 output_node_id = 0;
970 }
971 }
972 }
973}
974
976{
977 Main *bmain = CTX_data_main(C);
978 SpaceNode *snode = CTX_wm_space_node(C);
979 bNodeTree *ntree = snode->edittree;
980 const bool keep_inputs = RNA_boolean_get(op->ptr, "keep_inputs");
981 bool linked = RNA_boolean_get(op->ptr, "linked") || ((U.dupflag & USER_DUP_NTREE) == 0);
982 const bool dupli_node_tree = !linked;
983
985
986 Map<bNode *, bNode *> node_map;
988 Map<const ID *, ID *> duplicated_node_groups;
989
990 node_select_paired(*ntree);
991
992 for (bNode *node : get_selected_nodes(*ntree)) {
994 ntree, *node, LIB_ID_COPY_DEFAULT, std::nullopt, std::nullopt, socket_map);
995 node_map.add_new(node, new_node);
996
997 if (node->id && dupli_node_tree && !ID_IS_LINKED(node->id)) {
998 ID *new_group = duplicated_node_groups.lookup_or_add_cb(node->id, [&]() {
999 ID *new_group = BKE_id_copy(bmain, node->id);
1000 /* Remove user added by copying. */
1001 id_us_min(new_group);
1002 return new_group;
1003 });
1004 id_us_plus(new_group);
1005 id_us_min(new_node->id);
1006 new_node->id = new_group;
1007 }
1008 }
1009
1010 if (node_map.is_empty()) {
1011 return OPERATOR_CANCELLED;
1012 }
1013
1014 /* Copy links between selected nodes. */
1015 bNodeLink *lastlink = ntree->links.last();
1016 for (bNodeLink &link : ntree->links) {
1017 /* This creates new links between copied nodes. If keep_inputs is set, also copies input links
1018 * from unselected (when fromnode is null)! */
1019 if (link.tonode && link.tonode->is_selected() &&
1020 (keep_inputs || (link.fromnode && link.fromnode->is_selected())))
1021 {
1022 bNodeLink *newlink = MEM_new<bNodeLink>("bNodeLink");
1023 newlink->flag = link.flag;
1024 newlink->tonode = node_map.lookup(link.tonode);
1025 newlink->tosock = socket_map.lookup(link.tosock);
1026
1027 if (link.tosock->flag & SOCK_MULTI_INPUT) {
1029 }
1030
1031 if (link.fromnode && link.fromnode->is_selected()) {
1032 newlink->fromnode = node_map.lookup(link.fromnode);
1033 newlink->fromsock = socket_map.lookup(link.fromsock);
1034 }
1035 else {
1036 /* Input node not copied, this keeps the original input linked. */
1037 newlink->fromnode = link.fromnode;
1038 newlink->fromsock = link.fromsock;
1039 }
1040
1041 BLI_addtail(&ntree->links, newlink);
1042 }
1043
1044 /* Make sure we don't copy new links again. */
1045 if (&link == lastlink) {
1046 break;
1047 }
1048 }
1049
1050 for (bNode *node : node_map.values()) {
1052 }
1053
1054 ntree->ensure_topology_cache();
1055 for (bNode *node : node_map.values()) {
1057 }
1058
1059 /* Clear flags for recursive depth-first iteration. */
1060 for (bNode *node : ntree->all_nodes()) {
1061 node->flag &= ~NODE_TEST;
1062 }
1063 /* Reparent copied nodes. */
1064 for (bNode *node : node_map.keys()) {
1065 if (!(node->flag & NODE_TEST)) {
1066 node_duplicate_reparent_recursive(ntree, node_map, node);
1067 }
1068 }
1069
1070 {
1071 /* Use temporary map that has const key, because that's what the function below expects. */
1072 Map<const bNode *, bNode *> const_node_map;
1073 for (const auto item : node_map.items()) {
1074 const_node_map.add(item.key, item.value);
1075 }
1076 remap_node_pairing(*ntree, const_node_map);
1077 }
1078
1079 /* Deselect old nodes, select the copies instead. */
1080 for (const auto item : node_map.items()) {
1081 bNode *src_node = item.key;
1082 bNode *dst_node = item.value;
1083
1084 bke::node_set_selected(*src_node, false);
1085 src_node->flag &= ~(NODE_ACTIVE | NODE_ACTIVE_TEXTURE);
1086 bke::node_set_selected(*dst_node, true);
1087 }
1088
1090 BKE_main_ensure_invariants(*bmain, snode->edittree->id);
1091 return OPERATOR_FINISHED;
1092}
1093
1095{
1096 PropertyRNA *prop;
1097
1098 /* identifiers */
1099 ot->name = "Duplicate Nodes";
1100 ot->description = "Duplicate selected nodes";
1101 ot->idname = "NODE_OT_duplicate";
1102
1103 /* API callbacks. */
1106
1107 /* flags */
1109
1111 ot->srna, "keep_inputs", false, "Keep Inputs", "Keep the input links to duplicated nodes");
1112
1113 prop = RNA_def_boolean(ot->srna,
1114 "linked",
1115 true,
1116 "Linked",
1117 "Duplicate node but not node trees, linking to the original data");
1119}
1120
1121/* Goes over all scenes, reads render layers. */
1123{
1124 Main *bmain = CTX_data_main(C);
1125 SpaceNode *snode = CTX_wm_space_node(C);
1126 Scene *curscene = CTX_data_scene(C);
1127 bNodeTree &edit_tree = *snode->edittree;
1128
1130
1131 /* first tag scenes unread */
1132 for (Scene &scene : bmain->scenes) {
1133 scene.id.tag |= ID_TAG_DOIT;
1134 }
1135
1136 for (bNode *node : edit_tree.all_nodes()) {
1137 if ((node->type_legacy == CMP_NODE_R_LAYERS) ||
1138 (node->type_legacy == CMP_NODE_CRYPTOMATTE &&
1140 {
1141 ID *id = node->id;
1142 if (id == nullptr) {
1143 continue;
1144 }
1145 if (id->tag & ID_TAG_DOIT) {
1146 RE_ReadRenderResult(curscene, id_cast<Scene *>(id));
1147 ntreeCompositTagRender(id_cast<Scene *>(id));
1148 id->tag &= ~ID_TAG_DOIT;
1149 }
1150 }
1151 }
1152
1153 BKE_main_ensure_invariants(*bmain, edit_tree.id);
1154
1155 return OPERATOR_FINISHED;
1156}
1157
1159{
1160 ot->name = "Read View Layers";
1161 ot->idname = "NODE_OT_read_viewlayers";
1162 ot->description = "Read all render layers of all used scenes";
1163
1165
1167}
1168
1170{
1171 Scene *sce = CTX_data_scene(C);
1172
1173 /* This is actually a test whether scene is used by the compositor or not.
1174 * All the nodes are using same render result, so there is no need to do
1175 * anything smart about check how exactly scene is used. */
1176 bNode *node = nullptr;
1177 for (SceneCompositorEffect &effect : sce->compositor_effects) {
1178 if (!effect.node_group || ID_MISSING(effect.node_group)) {
1179 continue;
1180 }
1181 for (bNode *node_iter : effect.node_group->all_nodes()) {
1182 if (node_iter->id == id_cast<ID *>(sce)) {
1183 node = node_iter;
1184 break;
1185 }
1186 }
1187 if (node) {
1188 break;
1189 }
1190 }
1191
1192 if (node) {
1193 ViewLayer *view_layer = static_cast<ViewLayer *>(
1194 BLI_findlink(&sce->view_layers, node->custom1));
1195
1196 if (view_layer) {
1197 PointerRNA op_ptr = WM_operator_properties_create("RENDER_OT_render");
1198 RNA_string_set(&op_ptr, "layer", view_layer->name);
1199 RNA_string_set(&op_ptr, "scene", sce->id.name + 2);
1200
1201 /* To keep keyframe positions. */
1202 sce->r.scemode |= R_NO_FRAME_UPDATE;
1203
1205 C, "RENDER_OT_render", wm::OpCallContext::InvokeDefault, &op_ptr, nullptr);
1206
1208
1209 return OPERATOR_FINISHED;
1210 }
1211 }
1212 return OPERATOR_CANCELLED;
1213}
1214
1216{
1217 ot->name = "Render Changed Layer";
1218 ot->idname = "NODE_OT_render_changed";
1219 ot->description = "Render current scene, when input node's layer has been changed";
1220
1222
1224
1225 /* flags */
1226 ot->flag = 0;
1227}
1228
1230
1231/* -------------------------------------------------------------------- */
1234
1241 eNode_Flag toggle_flag,
1242 const bool tag_update = false)
1243{
1244 int tot_eq = 0, tot_neq = 0;
1245
1246 for (bNode *node : snode->edittree->all_nodes()) {
1247 if (node->is_selected()) {
1248
1249 if (toggle_flag == NODE_PREVIEW && !node_is_previewable(*snode, *snode->edittree, *node)) {
1250 continue;
1251 }
1252 if (toggle_flag == NODE_OPTIONS &&
1253 !(node->typeinfo->draw_buttons || node->typeinfo->draw_buttons_ex))
1254 {
1255 continue;
1256 }
1257
1258 if (node->flag & toggle_flag) {
1259 tot_eq++;
1260 }
1261 else {
1262 tot_neq++;
1263 }
1264 }
1265 }
1266 for (bNode *node : snode->edittree->all_nodes()) {
1267 if (node->is_selected()) {
1268
1269 if (toggle_flag == NODE_PREVIEW && !node_is_previewable(*snode, *snode->edittree, *node)) {
1270 continue;
1271 }
1272 if (toggle_flag == NODE_OPTIONS &&
1273 !(node->typeinfo->draw_buttons || node->typeinfo->draw_buttons_ex))
1274 {
1275 continue;
1276 }
1277
1278 if ((tot_eq && tot_neq) || tot_eq == 0) {
1279 node->flag |= toggle_flag;
1280 }
1281 else {
1282 node->flag &= ~toggle_flag;
1283 }
1284
1285 if (tag_update) {
1287 }
1288 }
1289 }
1290}
1291
1293{
1294 SpaceNode *snode = CTX_wm_space_node(C);
1295
1296 /* Sanity checking (poll callback checks this already). */
1297 if ((snode == nullptr) || (snode->edittree == nullptr)) {
1298 return OPERATOR_CANCELLED;
1299 }
1300
1302
1304
1305 return OPERATOR_FINISHED;
1306}
1307
1309{
1310 /* identifiers */
1311 ot->name = "Collapse";
1313 ot->description = "Toggle collapsing of selected nodes";
1314 ot->idname = "NODE_OT_hide_toggle";
1315
1316 /* callbacks */
1319
1320 /* flags */
1322}
1323
1325{
1326 SpaceNode *snode = CTX_wm_space_node(C);
1327
1328 /* Sanity checking (poll callback checks this already). */
1329 if ((snode == nullptr) || (snode->edittree == nullptr)) {
1330 return OPERATOR_CANCELLED;
1331 }
1332
1333 node_flag_toggle_exec(snode, NODE_PREVIEW, true);
1334
1337
1339
1340 return OPERATOR_FINISHED;
1341}
1342
1344{
1346 SpaceNode *snode = CTX_wm_space_node(C);
1347 if (ED_node_supports_preview(snode)) {
1348 return true;
1349 }
1350 }
1351 return false;
1352}
1353
1355{
1356 /* identifiers */
1357 ot->name = "Toggle Node Preview";
1358 ot->description = "Toggle preview display for selected nodes";
1359 ot->idname = "NODE_OT_preview_toggle";
1360
1361 /* callbacks */
1363 ot->poll = node_previewable;
1364
1365 /* flags */
1367}
1368
1370{
1371 SpaceNode *snode = CTX_wm_space_node(C);
1372 PointerRNA ptr = CTX_data_pointer_get(C, "node");
1373 Main *bmain = CTX_data_main(C);
1374 bNodeTree *ntree = nullptr;
1375 bNode *node = nullptr;
1376
1377 if (ptr) {
1378 node = static_cast<bNode *>(ptr.data);
1379 ntree = reinterpret_cast<bNodeTree *>(ptr.owner_id);
1380 }
1381 else if (snode && snode->edittree) {
1382 ntree = snode->edittree;
1383 node = bke::node_get_active(*ntree);
1384 }
1385
1386 if (!node) {
1387 return OPERATOR_CANCELLED;
1388 }
1389
1390 if (node->is_type("CompositorNodeViewer"_ustr)) {
1391 for (bNode *other_node : ntree->all_nodes()) {
1392 if (other_node->type_legacy == node->type_legacy) {
1393 other_node->flag &= ~NODE_DO_OUTPUT;
1394 }
1395 node->flag |= NODE_DO_OUTPUT;
1396
1399 }
1400 }
1401 else if (node->is_type("GeometryNodeViewer"_ustr)) {
1402 /* Geometry nodes viewers don't rely on NODE_DO_OUTPUT flag alone. */
1403 viewer_path::activate_geometry_node(*bmain, *snode, *node);
1404 }
1405 else {
1406 return OPERATOR_CANCELLED;
1407 }
1408
1410 BKE_main_ensure_invariants(*bmain, snode->edittree->id);
1411 return OPERATOR_FINISHED;
1412}
1413
1415{
1416 ot->name = "Activate Viewer Node";
1417 ot->description = "Activate selected viewer node in compositor and geometry nodes";
1418 ot->idname = "NODE_OT_activate_viewer";
1419
1422
1424}
1425
1427{
1428 SpaceNode &snode = *CTX_wm_space_node(C);
1429 bNodeTree &ntree = *snode.edittree;
1430 Main &bmain = *CTX_data_main(C);
1431
1433 &bmain, (StringRef(ntree.id.name) + " Inlined").c_str(), ntree.idname);
1434
1436 params.allow_preserving_repeat_zones = false;
1437 nodes::inline_shader_node_tree(ntree, *new_tree, params);
1438 bNode *group_node = bke::node_add_node(C, ntree, ntree.typeinfo->group_idname);
1439 group_node->id = &new_tree->id;
1440 node_deselect_all(ntree);
1441 bke::node_set_selected(*group_node, true);
1442 bke::node_set_active(ntree, *group_node);
1443
1445
1446 return OPERATOR_FINISHED;
1447}
1448
1450{
1451 ot->name = "Test Inlining Shader Nodes";
1452 ot->description = "Create a new inlined shader node tree as is consumed by renderers";
1453 ot->idname = "NODE_OT_test_inlining_shader_nodes";
1454
1457
1459}
1460
1462{
1463 SpaceNode &snode = *CTX_wm_space_node(C);
1464 WorkSpace &workspace = *CTX_wm_workspace(C);
1465
1466 bNode *active_viewer = viewer_path::find_geometry_nodes_viewer(workspace.viewer_path, snode);
1467
1468 for (bNode *node : snode.edittree->all_nodes()) {
1469 if (node->type_legacy != GEO_NODE_VIEWER) {
1470 continue;
1471 }
1472 if (node == active_viewer) {
1473 node->flag &= ~NODE_DO_OUTPUT;
1475 /* At most, only one viewer is active so break early. */
1476 break;
1477 }
1478 }
1479
1481
1482 return OPERATOR_FINISHED;
1483}
1484
1486{
1487 /* identifiers */
1488 ot->name = "Deactivate Viewer Node";
1489 ot->description = "Deactivate selected viewer node in geometry nodes";
1490 ot->idname = __func__;
1491
1492 /* callbacks */
1495
1496 /* flags */
1498}
1499
1501{
1502 SpaceNode *snode = CTX_wm_space_node(C);
1503 WorkSpace *workspace = CTX_wm_workspace(C);
1504 PointerRNA ptr = CTX_data_pointer_get(C, "node");
1505 bNode *node = nullptr;
1506 bNodeTree *ntree = nullptr;
1508
1509 if (ptr) {
1510 node = static_cast<bNode *>(ptr.data);
1511 ntree = reinterpret_cast<bNodeTree *>(ptr.owner_id);
1512 }
1513 else if (snode && snode->edittree) {
1514 ntree = snode->edittree;
1515 node = bke::node_get_active(*ntree);
1516 }
1517
1518 if (!node) {
1519 return OPERATOR_CANCELLED;
1520 }
1521
1522 bNode *active_viewer = viewer_path::find_geometry_nodes_viewer(workspace->viewer_path, *snode);
1523 if (node == active_viewer) {
1525 C, "NODE_OT_deactivate_viewer", wm::OpCallContext::InvokeDefault, nullptr, nullptr);
1526 }
1527 else {
1529 C, "NODE_OT_activate_viewer", wm::OpCallContext::InvokeDefault, nullptr, nullptr);
1530 }
1531
1532 return ret;
1533}
1534
1536{
1537 ot->name = "Toggle Viewer Node";
1538 ot->description = "Toggle selected viewer node in compositor and geometry nodes";
1539 ot->idname = "NODE_OT_toggle_viewer";
1540
1543
1545}
1546
1548{
1549 SpaceNode *snode = CTX_wm_space_node(C);
1550
1551 /* Sanity checking (poll callback checks this already). */
1552 if ((snode == nullptr) || (snode->edittree == nullptr)) {
1553 return OPERATOR_CANCELLED;
1554 }
1555
1557
1559
1560 return OPERATOR_FINISHED;
1561}
1562
1564{
1565 /* identifiers */
1566 ot->name = "Toggle Node Options";
1567 ot->description = "Toggle option buttons display for selected nodes";
1568 ot->idname = "NODE_OT_options_toggle";
1569
1570 /* callbacks */
1573
1574 /* flags */
1576}
1577
1579{
1580 SpaceNode *snode = CTX_wm_space_node(C);
1581
1582 /* Sanity checking (poll callback checks this already). */
1583 if ((snode == nullptr) || (snode->edittree == nullptr)) {
1584 return OPERATOR_CANCELLED;
1585 }
1586
1588
1589 /* Toggle for all selected nodes */
1590 bool hidden = false;
1591 for (bNode *node : snode->edittree->all_nodes()) {
1592 if (node->is_selected()) {
1594 hidden = true;
1595 break;
1596 }
1597 }
1598 }
1599
1600 for (bNode *node : snode->edittree->all_nodes()) {
1601 if (node->is_selected()) {
1602 node_set_hidden_sockets(node, !hidden);
1603 }
1604 }
1605
1607
1609 /* Hack to force update of the button state after drawing, see #112462. */
1611
1612 return OPERATOR_FINISHED;
1613}
1614
1616{
1617 /* identifiers */
1618 ot->name = "Toggle Hidden Node Sockets";
1619 ot->description = "Toggle unused node socket display";
1620 ot->idname = "NODE_OT_hide_socket_toggle";
1621
1622 /* callbacks */
1625
1626 /* flags */
1628}
1629
1631
1632/* -------------------------------------------------------------------- */
1635
1637{
1638 Main *bmain = CTX_data_main(C);
1639 SpaceNode *snode = CTX_wm_space_node(C);
1640
1642
1643 for (bNode *node : snode->edittree->all_nodes()) {
1644 if (node->is_selected() && !node->typeinfo->no_muting) {
1645 node->flag ^= NODE_MUTED;
1647 }
1648 }
1649
1650 BKE_main_ensure_invariants(*bmain, snode->edittree->id);
1651
1652 return OPERATOR_FINISHED;
1653}
1654
1656{
1657 /* identifiers */
1658 ot->name = "Toggle Node Mute";
1659 ot->description = "Toggle muting of selected nodes";
1660 ot->idname = "NODE_OT_mute_toggle";
1661
1662 /* callbacks */
1663 ot->exec = node_mute_exec;
1665
1666 /* flags */
1668}
1669
1671
1672/* -------------------------------------------------------------------- */
1675
1677{
1678 SpaceNode &snode = *CTX_wm_space_node(C);
1679 ARegion &region = *CTX_wm_region(C);
1680 const bool use_active = RNA_boolean_get(op->ptr, "use_active");
1681
1682 bNode *node;
1683 if (use_active) {
1685 }
1686 else {
1687 /* Don't interfere when the mouse is interacting with some button. */
1688 if (ISMOUSE_BUTTON(event->type) && ui::but_find_mouse_over(&region, event)) {
1690 }
1691
1692 float2 cursor;
1693 ui::view2d_region_to_view(&region.v2d, event->mval[0], event->mval[1], &cursor.x, &cursor.y);
1694 node = node_under_mouse_get(snode, cursor);
1695 }
1696
1697 if (!node || !node->is_type("NodeComment"_ustr)) {
1698 return OPERATOR_PASS_THROUGH;
1699 }
1700
1701 NodeComment &storage = *static_cast<NodeComment *>(node->storage);
1702 if (bool(storage.flag & NodeCommentFlag::Edit)) {
1703 return OPERATOR_PASS_THROUGH;
1704 }
1705
1709 return OPERATOR_FINISHED;
1710}
1711
1713{
1714 ot->name = "Edit Comment";
1715 ot->description = "Enter edit mode for the comment node under the cursor";
1716 ot->idname = "NODE_OT_comment_edit";
1717
1720
1721 ot->flag = OPTYPE_REGISTER;
1722
1723 PropertyRNA *prop = RNA_def_boolean(ot->srna,
1724 "use_active",
1725 false,
1726 "Use Active",
1727 "Edit the active comment node, rather than the one under "
1728 "the cursor");
1730}
1731
1733
1734/* -------------------------------------------------------------------- */
1737
1739{
1740 Main *bmain = CTX_data_main(C);
1741 SpaceNode *snode = CTX_wm_space_node(C);
1742
1744
1745 /* Delete paired nodes as well. */
1747
1748 /* Ensure child nodes propagate upwards through nested frames, when their parent is deleted. */
1749 for (bNode *node : snode->edittree->all_nodes()) {
1750 if (node->is_selected()) {
1751 /* This node can be skipped, because it will be deleted anyway. */
1752 continue;
1753 }
1754
1755 /* Set the parent of the node to the lowest frame that is not going to be deleted. */
1756 for (bNode *parent = node->parent; parent; parent = parent->parent) {
1757 if (!parent->is_selected()) {
1758 node->parent = parent;
1759 break;
1760 }
1761 }
1762 }
1763
1764 for (bNode &node : snode->edittree->nodes.items_mutable()) {
1765 if (node.is_selected()) {
1766 bke::node_remove_node(bmain, *snode->edittree, node, true);
1767 }
1768 }
1769
1771
1773 BKE_main_ensure_invariants(*bmain, snode->edittree->id);
1775
1776 return OPERATOR_FINISHED;
1777}
1778
1780{
1781 /* identifiers */
1782 ot->name = "Delete";
1783 ot->description = "Remove selected nodes";
1784 ot->idname = "NODE_OT_delete";
1785
1786 /* API callbacks. */
1787 ot->exec = node_delete_exec;
1789
1790 /* flags */
1792}
1793
1795
1796/* -------------------------------------------------------------------- */
1799
1801{
1802 Main *bmain = CTX_data_main(C);
1803 SpaceNode *snode = CTX_wm_space_node(C);
1804
1806
1807 /* Delete paired nodes as well. */
1809
1810 for (bNode &node : snode->edittree->nodes.items_mutable()) {
1811 if (node.is_selected()) {
1813 bke::node_remove_node(bmain, *snode->edittree, node, true);
1814
1815 /* Since this node might have been animated, and that animation data been
1816 * deleted, a notifier call is necessary to redraw any animation editor. */
1818 }
1819 }
1820
1822
1823 BKE_main_ensure_invariants(*bmain, snode->edittree->id);
1824
1825 return OPERATOR_FINISHED;
1826}
1827
1829{
1830 /* identifiers */
1831 ot->name = "Delete with Reconnect";
1832 ot->description = "Remove nodes and reconnect nodes as if deletion was muted";
1833 ot->idname = "NODE_OT_delete_reconnect";
1834
1835 /* API callbacks. */
1838
1839 /* flags */
1841}
1842
1844
1845/* -------------------------------------------------------------------- */
1848
1850{
1851 SpaceNode &snode = *CTX_wm_space_node(C);
1852 bNodeTree &ntree = *snode.edittree;
1853
1854 bNode *active_node = bke::node_get_active(ntree);
1855 if (!active_node) {
1856 return OPERATOR_CANCELLED;
1857 }
1858
1859 for (bNode *node : ntree.all_nodes()) {
1860 if (node->is_selected() && node != active_node) {
1861 if (active_node->flag & NODE_CUSTOM_COLOR) {
1862 node->flag |= NODE_CUSTOM_COLOR;
1863 copy_v3_v3(node->color, active_node->color);
1864 }
1865 else {
1866 node->flag &= ~NODE_CUSTOM_COLOR;
1867 }
1868 }
1869 }
1870
1872
1873 return OPERATOR_FINISHED;
1874}
1875
1877{
1878 /* identifiers */
1879 ot->name = "Copy Color";
1880 ot->description = "Copy color to all selected nodes";
1881 ot->idname = "NODE_OT_node_copy_color";
1882
1883 /* API callbacks. */
1886
1887 /* flags */
1889}
1890
1892
1893/* -------------------------------------------------------------------- */
1896
1898{
1900 SpaceNode *snode = CTX_wm_space_node(C);
1901
1902 /* Test if we have a render engine that supports shaders scripts. */
1903 if (!(type && type->update_script_node)) {
1904 return false;
1905 }
1906
1907 /* See if we have a shader script node in context. */
1908 bNode *node = static_cast<bNode *>(
1909 CTX_data_pointer_get_type(C, "node", RNA_ShaderNodeScript).data);
1910
1911 if (!node && snode && snode->edittree) {
1913 }
1914
1915 if (node && node->type_legacy == SH_NODE_SCRIPT) {
1916 NodeShaderScript *nss = static_cast<NodeShaderScript *>(node->storage);
1917
1918 if (node->id || nss->filepath[0]) {
1920 }
1921 }
1922
1923 return false;
1924}
1925
1927{
1929 SpaceNode *snode = CTX_wm_space_node(C);
1930 PointerRNA nodeptr = CTX_data_pointer_get_type(C, "node", RNA_ShaderNodeScript);
1931
1932 /* setup render engine */
1933 RenderEngine *engine = RE_engine_create(type);
1934 engine->reports = op->reports;
1935
1936 bNodeTree *ntree_base = nullptr;
1937 bNode *node = nullptr;
1938 if (nodeptr) {
1939 ntree_base = id_cast<bNodeTree *>(nodeptr.owner_id);
1940 node = static_cast<bNode *>(nodeptr.data);
1941 }
1942 else if (snode && snode->edittree) {
1943 ntree_base = snode->edittree;
1945 }
1946
1947 /* Update node. */
1948 type->update_script_node(engine, ntree_base, node);
1949
1950 RE_engine_free(engine);
1951
1952 return OPERATOR_FINISHED;
1953}
1954
1956{
1957 /* identifiers */
1958 ot->name = "Script Node Update";
1959 ot->description = "Update shader script node with new sockets and options from the script";
1960 ot->idname = "NODE_OT_shader_script_update";
1961
1962 /* API callbacks. */
1965
1966 /* flags */
1968}
1969
1971
1972/* -------------------------------------------------------------------- */
1975
1977 ARegion *region,
1978 int x,
1979 int y,
1980 int backdrop_width,
1981 int backdrop_height,
1982 float *fx,
1983 float *fy)
1984{
1985 float bufx = backdrop_width * snode->zoom;
1986 float bufy = backdrop_height * snode->zoom;
1987
1988 *fx = (bufx > 0.0f ? (float(x) - 0.5f * region->winx - snode->xof) / bufx + 0.5f : 0.0f);
1989 *fy = (bufy > 0.0f ? (float(y) - 0.5f * region->winy - snode->yof) / bufy + 0.5f : 0.0f);
1990}
1991
1993{
1994 Main *bmain = CTX_data_main(C);
1995 void *lock;
1996
1998
1999 Image *ima = BKE_image_ensure_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
2000 ImBuf *ibuf = BKE_image_acquire_ibuf(ima, nullptr, &lock);
2001
2002 if (ibuf) {
2003 ARegion *region = CTX_wm_region(C);
2004 SpaceNode *snode = CTX_wm_space_node(C);
2005 bNodeTree *btree = snode->nodetree;
2006 rcti rect;
2007 rctf rectf;
2008
2009 /* Get border from operator. */
2011
2012 /* Convert border to unified space within backdrop image. */
2014 snode, region, rect.xmin, rect.ymin, ibuf->x, ibuf->y, &rectf.xmin, &rectf.ymin);
2015
2017 snode, region, rect.xmax, rect.ymax, ibuf->x, ibuf->y, &rectf.xmax, &rectf.ymax);
2018
2019 /* Clamp coordinates. */
2020 rectf.xmin = max_ff(rectf.xmin, 0.0f);
2021 rectf.ymin = max_ff(rectf.ymin, 0.0f);
2022 rectf.xmax = min_ff(rectf.xmax, 1.0f);
2023 rectf.ymax = min_ff(rectf.ymax, 1.0f);
2024
2025 if (rectf.xmin < rectf.xmax && rectf.ymin < rectf.ymax) {
2026 btree->viewer_border = rectf;
2027
2028 if (rectf.xmin == 0.0f && rectf.ymin == 0.0f && rectf.xmax == 1.0f && rectf.ymax == 1.0f) {
2029 btree->flag &= ~NTREE_VIEWER_BORDER;
2030 }
2031 else {
2032 btree->flag |= NTREE_VIEWER_BORDER;
2033 }
2034
2035 BKE_main_ensure_invariants(*bmain, btree->id);
2037 }
2038 else {
2039 btree->flag &= ~NTREE_VIEWER_BORDER;
2040 }
2041 }
2042
2043 BKE_image_release_ibuf(ima, ibuf, lock);
2044
2045 return OPERATOR_FINISHED;
2046}
2047
2049{
2050 /* identifiers */
2051 ot->name = "Viewer Region";
2052 ot->description = "Set the boundaries for viewer operations (Not implemented)";
2053 ot->idname = "NODE_OT_viewer_border";
2054
2055 /* API callbacks. */
2061
2062 /* flags */
2064
2065 /* properties */
2067}
2068
2070{
2071 SpaceNode *snode = CTX_wm_space_node(C);
2072 bNodeTree *btree = snode->nodetree;
2073
2074 btree->flag &= ~NTREE_VIEWER_BORDER;
2077
2078 return OPERATOR_FINISHED;
2079}
2080
2082{
2083 /* identifiers */
2084 ot->name = "Clear Viewer Region";
2085 ot->description = "Clear the boundaries for viewer operations";
2086 ot->idname = "NODE_OT_clear_viewer_border";
2087
2088 /* API callbacks. */
2091
2092 /* flags */
2094}
2095
2097
2098/* -------------------------------------------------------------------- */
2101
2103{
2104 SpaceNode *snode = CTX_wm_space_node(C);
2105 PointerRNA ptr = CTX_data_pointer_get(C, "node");
2106 bNodeTree *ntree = nullptr;
2107 bNode *node = nullptr;
2108
2109 if (ptr) {
2110 node = static_cast<bNode *>(ptr.data);
2111 ntree = id_cast<bNodeTree *>(ptr.owner_id);
2112 }
2113 else if (snode && snode->edittree) {
2114 ntree = snode->edittree;
2116 }
2117
2118 if (!node || node->type_legacy != CMP_NODE_CRYPTOMATTE_LEGACY) {
2119 return OPERATOR_CANCELLED;
2120 }
2121
2123
2126
2127 return OPERATOR_FINISHED;
2128}
2129
2131{
2132 /* identifiers */
2133 ot->name = "Add Cryptomatte Socket";
2134 ot->description = "Add a new input layer to a Cryptomatte node";
2135 ot->idname = "NODE_OT_cryptomatte_layer_add";
2136
2137 /* callbacks */
2140
2141 /* flags */
2143}
2144
2146
2147/* -------------------------------------------------------------------- */
2150
2152{
2153 SpaceNode *snode = CTX_wm_space_node(C);
2154 PointerRNA ptr = CTX_data_pointer_get(C, "node");
2155 bNodeTree *ntree = nullptr;
2156 bNode *node = nullptr;
2157
2158 if (ptr) {
2159 node = static_cast<bNode *>(ptr.data);
2160 ntree = id_cast<bNodeTree *>(ptr.owner_id);
2161 }
2162 else if (snode && snode->edittree) {
2163 ntree = snode->edittree;
2165 }
2166
2167 if (!node || node->type_legacy != CMP_NODE_CRYPTOMATTE_LEGACY) {
2168 return OPERATOR_CANCELLED;
2169 }
2170
2172 return OPERATOR_CANCELLED;
2173 }
2174
2177
2178 return OPERATOR_FINISHED;
2179}
2180
2182{
2183 /* identifiers */
2184 ot->name = "Remove Cryptomatte Socket";
2185 ot->description = "Remove layer from a Cryptomatte node";
2186 ot->idname = "NODE_OT_cryptomatte_layer_remove";
2187
2188 /* callbacks */
2191
2192 /* flags */
2194}
2195
2197
2198} // namespace ed::space_node
2199
2200} // namespace blender
General operations, lookup, etc. for materials.
#define NODE_GROUP
Definition BKE_node.hh:865
#define SH_NODE_OUTPUT_WORLD
#define CMP_NODE_VIEWER
#define CMP_NODE_CRYPTOMATTE
#define GEO_NODE_VIEWER
#define TEX_NODE_CHECKER
#define CMP_NODE_CRYPTOMATTE_LEGACY
#define SH_NODE_OUTPUT_MATERIAL
#define TEX_NODE_OUTPUT
#define CMP_NODE_R_LAYERS
#define SH_NODE_OUTPUT_LIGHT
#define SH_NODE_OUTPUT_LINESTYLE
#define SH_NODE_SCRIPT
#define STRNCPY_UTF8(dst, src)
#define BLT_I18NCONTEXT_OPERATOR_DEFAULT
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define ID_MISSING(_id)
Definition DNA_ID.h:695
#define UI_SCALE_FAC
#define USER_EXPERIMENTAL_TEST(userdef, member)
#define NODE_GRID_UNIT
Definition ED_node_c.hh:31
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define NC_WINDOW
Definition WM_types.hh:388
#define NC_NODE
Definition WM_types.hh:407
#define NC_ANIMATION
Definition WM_types.hh:401
#define ND_DISPLAY
Definition WM_types.hh:534
#define NC_SCENE
Definition WM_types.hh:391
#define ND_NODES
Definition WM_types.hh:455
#define NA_EDITED
Definition WM_types.hh:634
#define NC_MATERIAL
Definition WM_types.hh:393
#define NC_IMAGE
Definition WM_types.hh:397
#define NA_REMOVED
Definition WM_types.hh:637
#define ND_ANIMCHAN
Definition WM_types.hh:539
volatile int lock
#define CLAMP(a, b, c)
#define ELEM(...)
#define STREQ(a, b)
bool is_empty() const
Definition BLI_array.hh:275
ValueIterator values() const &
Definition BLI_map.hh:884
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
Value lookup_default(const Key &key, const Value &default_value) const
Definition BLI_map.hh:570
Value & lookup_or_add_cb(const Key &key, const CreateValueF &create_value)
Definition BLI_map.hh:620
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
KeyIterator keys() const &
Definition BLI_map.hh:875
bool is_empty() const
Definition BLI_map.hh:986
ItemIterator items() const &
Definition BLI_map.hh:902
constexpr StringRef()
const char * c_str() const
StringRefNull ref() const
virtual const int & get_corresponding_output_id(const bNode &input_bnode) const =0
#define FLT_MAX
#define storage(slot, qualifiers)
#define abs
float distance(float, float) RET
ccl_device_inline float2 fmod(const float2 a, const float b)
const bNodeZoneType * zone_type_by_node_type(const int node_type)
void node_attach_node(bNodeTree &ntree, bNode &node, bNode &parent)
Definition node.cc:4883
bNodeTreeType * node_tree_type_find(StringRef idname)
Definition node.cc:2797
bNodeTree * node_tree_add_tree_embedded(Main *bmain, ID *owner_id, StringRefNull name, StringRefNull idname)
Definition node.cc:5005
void node_remove_node(Main *bmain, bNodeTree &ntree, bNode &node, bool do_id_user, bool remove_animation=true)
Definition node.cc:5155
bNode * node_get_active(bNodeTree &ntree)
Definition node.cc:5445
Span< int > all_zone_output_node_types()
bNode * node_add_node(const bContext *C, bNodeTree &ntree, UString idname, std::optional< int > unique_identifier=std::nullopt)
Definition node.cc:4260
void node_internal_relink(bNodeTree &ntree, bNode &node)
Definition node.cc:4812
bool node_set_selected(bNode &node, bool select)
Definition node.cc:5455
bool node_tree_contains_tree(const bNodeTree &tree_to_search_in, const bNodeTree &tree_to_search_for)
Definition node.cc:5423
void node_detach_node(bNodeTree &ntree, bNode &node)
Definition node.cc:4891
bNode * node_add_static_node(const bContext *C, bNodeTree &ntree, int type)
Definition node.cc:4283
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
Span< int > all_zone_input_node_types()
bNodeTree * node_tree_add_tree(Main *bmain, StringRef name, StringRef idname)
Definition node.cc:4992
bNode * node_copy_with_mapping(bNodeTree *dst_tree, const bNode &node_src, int flag, std::optional< StringRefNull > dst_unique_name, std::optional< int > dst_unique_identifier, Map< const bNodeSocket *, bNodeSocket * > &new_socket_map, bool allow_duplicate_names=false)
Definition node.cc:4327
bool node_declaration_ensure(bNodeTree &ntree, bNode &node)
Definition node.cc:5578
void node_set_active(bNodeTree &ntree, bNode &node)
Definition node.cc:5484
bool node_link_is_hidden(const bNodeLink &link)
Definition node.cc:4711
void NODE_OT_test_inlining_shader_nodes(wmOperatorType *ot)
void NODE_OT_delete(wmOperatorType *ot)
void NODE_OT_cryptomatte_layer_add(wmOperatorType *ot)
float node_socket_calculate_height(const bNodeSocket &socket)
Definition node_edit.cc:753
void NODE_OT_read_viewlayers(wmOperatorType *ot)
wmKeyMap * node_resize_modal_keymap(wmKeyConfig *keyconf)
Definition node_edit.cc:493
int node_get_resize_cursor(NodeResizeDirection directions)
void NODE_OT_comment_edit(wmOperatorType *ot)
void tree_draw_order_update(bNodeTree &ntree)
Definition node_draw.cc:265
static bool cursor_isect_multi_input_socket(const float2 &cursor, const bNodeSocket &socket)
Definition node_edit.cc:772
static bool node_shader_script_update_poll(bContext *C)
static void node_resize_exit(bContext *C, wmOperator *op, bool cancel)
Definition node_edit.cc:466
static void node_resize_cancel(bContext *C, wmOperator *op)
Definition node_edit.cc:664
static wmOperatorStatus node_delete_reconnect_exec(bContext *C, wmOperator *)
static wmOperatorStatus node_cryptomatte_remove_socket_exec(bContext *C, wmOperator *)
static bool socket_is_occluded(const float2 &cursor, const bNodeSocket &socket, const bNode &node_the_socket_belongs_to, const Span< bNode * > sorted_nodes)
Definition node_edit.cc:383
static void node_flag_toggle_exec(SpaceNode *snode, eNode_Flag toggle_flag, const bool tag_update=false)
void NODE_OT_node_copy_color(wmOperatorType *ot)
bool composite_node_editable(bContext *C)
Definition node_edit.cc:102
void NODE_OT_viewer_border(wmOperatorType *ot)
void node_select_paired(bNodeTree &node_tree)
void NODE_OT_activate_viewer(wmOperatorType *ot)
bool node_deselect_all(bNodeTree &node_tree)
static wmOperatorStatus node_activate_viewer_exec(bContext *C, wmOperator *)
bNodeSocket * node_find_indicated_socket(SpaceNode &snode, ARegion &region, const float2 &cursor, const eNodeSocketInOut in_out)
Definition node_edit.cc:793
static wmOperatorStatus node_toggle_viewer_exec(bContext *C, wmOperator *)
Array< bNode * > tree_draw_order_calc_nodes_reversed(bNodeTree &ntree)
Definition node_draw.cc:286
void NODE_OT_deactivate_viewer(wmOperatorType *ot)
float2 node_link_calculate_multi_input_position(const float2 &socket_position, const int index, const int total_inputs)
Definition node_edit.cc:763
void NODE_OT_resize(wmOperatorType *ot)
Definition node_edit.cc:669
void NODE_OT_render_changed(wmOperatorType *ot)
static wmOperatorStatus node_cryptomatte_add_socket_exec(bContext *C, wmOperator *)
static wmOperatorStatus node_read_viewlayers_exec(bContext *C, wmOperator *)
static void node_duplicate_reparent_recursive(bNodeTree *ntree, const Map< bNode *, bNode * > &node_map, bNode *node)
Definition node_edit.cc:925
static bool node_previewable(bContext *C)
void NODE_OT_delete_reconnect(wmOperatorType *ot)
void NODE_OT_shader_script_update(wmOperatorType *ot)
void NODE_OT_hide_socket_toggle(wmOperatorType *ot)
void node_set_hidden_sockets(bNode *node, int set)
Definition node_edit.cc:707
bool node_is_previewable(const SpaceNode &snode, const bNodeTree &ntree, const bNode &node)
Definition node_edit.cc:739
void remap_node_pairing(bNodeTree &dst_tree, const Map< const bNode *, bNode * > &node_map)
Definition node_edit.cc:949
float node_link_dim_factor(const View2D &v2d, const bNodeLink &link)
Definition node_edit.cc:891
static wmOperatorStatus node_resize_modal(bContext *C, wmOperator *op, const wmEvent *event)
Definition node_edit.cc:527
static wmOperatorStatus clear_viewer_border_exec(bContext *C, wmOperator *)
static wmOperatorStatus node_copy_color_exec(bContext *C, wmOperator *)
bNode * node_under_mouse_get(const SpaceNode &snode, const float2 mouse)
static void viewer_border_corner_to_backdrop(SpaceNode *snode, ARegion *region, int x, int y, int backdrop_width, int backdrop_height, float *fx, float *fy)
static wmOperatorStatus node_shader_script_update_exec(bContext *C, wmOperator *op)
static wmOperatorStatus node_options_toggle_exec(bContext *C, wmOperator *)
bool node_link_is_hidden_or_dimmed(const View2D &v2d, const bNodeLink &link)
Definition node_edit.cc:914
static wmOperatorStatus node_comment_edit_invoke(bContext *C, wmOperator *op, const wmEvent *event)
VectorSet< bNode * > get_selected_nodes(bNodeTree &node_tree)
static wmOperatorStatus node_socket_toggle_exec(bContext *C, wmOperator *)
void NODE_OT_preview_toggle(wmOperatorType *ot)
void NODE_OT_clear_viewer_border(wmOperatorType *ot)
static void node_resize_init(bContext *C, wmOperator *op, const float2 &cursor, const VectorSet< bNode * > &nodes, NodeResizeDirection dir)
Definition node_edit.cc:439
static wmOperatorStatus node_collapse_toggle_exec(bContext *C, wmOperator *)
void snode_set_context(const bContext &C)
Definition node_edit.cc:191
void NODE_OT_duplicate(wmOperatorType *ot)
NodeResizeDirection node_get_resize_direction(const SpaceNode &snode, const bNode *node, const int x, const int y)
Definition drawnode.cc:211
bool node_has_hidden_sockets(bNode *node)
Definition node_edit.cc:692
static wmOperatorStatus test_inline_shader_nodes_exec(bContext *C, wmOperator *)
void NODE_OT_options_toggle(wmOperatorType *ot)
void NODE_OT_toggle_viewer(wmOperatorType *ot)
static wmOperatorStatus viewer_border_exec(bContext *C, wmOperator *op)
static wmOperatorStatus node_duplicate_exec(bContext *C, wmOperator *op)
Definition node_edit.cc:975
static wmOperatorStatus node_deactivate_viewer_exec(bContext *C, wmOperator *)
bool composite_node_active(bContext *C)
Definition node_edit.cc:91
wmOperatorStatus node_render_changed_exec(bContext *C, wmOperator *)
void NODE_OT_collapse_toggle(wmOperatorType *ot)
static wmOperatorStatus node_resize_invoke(bContext *C, wmOperator *op, const wmEvent *event)
Definition node_edit.cc:637
void update_multi_input_indices_for_removed_links(bNode &node)
static wmOperatorStatus node_delete_exec(bContext *C, wmOperator *)
void NODE_OT_cryptomatte_layer_remove(wmOperatorType *ot)
static wmOperatorStatus node_preview_toggle_exec(bContext *C, wmOperator *)
static wmOperatorStatus node_mute_exec(bContext *C, wmOperator *)
float nearest_node_grid_coord(float co)
Definition node_edit.cc:516
void NODE_OT_mute_toggle(wmOperatorType *ot)
void activate_geometry_node(Main &bmain, SpaceNode &snode, bNode &node, std::optional< int > item_identifier=std::nullopt)
bNode * find_geometry_nodes_viewer(const ViewerPath &viewer_path, SpaceNode &snode)
T distance(const T &a, const T &b)
bool inline_shader_node_tree(const bNodeTree &src_tree, bNodeTree &dst_tree, InlineShaderNodeTreeParams &params)
void update_node_declaration_and_sockets(bNodeTree &ntree, bNode &node, Main *bmain)
Button * but_find_mouse_over(const ARegion *region, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
void view2d_region_to_view(const View2D *v2d, float x, float y, float *r_view_x, float *r_view_y) ATTR_NONNULL()
Definition view2d.cc:1651
float view2d_scale_get_x(const View2D *v2d)
Definition view2d.cc:1902
BMesh Iterators.
MINLINE float min_ff(float a, float b)
void WM_main_add_notifier(uint type, void *reference)
bool ED_node_is_compositor(const SpaceNode *snode)
Definition node_edit.cc:135
UserDef U
Definition blender.cc:58
bool ED_operator_node_active(bContext *C)
ScrArea * CTX_wm_area(const bContext *C)
@ NODE_ACTIVE_TEXTURE
bool ED_node_is_geometry(const SpaceNode *snode)
Definition node_edit.cc:150
float BLI_rctf_length_y(const rctf *rect, float y)
Definition rct.cc:184
void ED_node_texture_default(const bContext *C, Tex *tex)
Definition node_edit.cc:161
bool BLI_rctf_isect_pt_v(const struct rctf *rect, const float xy[2])
wmKeyMap * WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
Definition wm_keymap.cc:999
wmOperatorStatus WM_gesture_box_invoke(bContext *C, wmOperator *op, const wmEvent *event)
MINLINE void copy_v3_v3(float r[3], const float a[3])
WorkSpace * CTX_wm_workspace(const bContext *C)
void ED_space_image_sync(Main *bmain, Image *image, bool ignore_render_viewer)
Definition image_edit.cc:79
void id_us_plus(ID *id)
Definition lib_id.cc:433
void WM_operator_properties_free(PointerRNA *ptr)
void ED_node_set_active(Main *bmain, SpaceNode *snode, bNodeTree *ntree, bNode *node, bool *r_active_texture_changed)
Definition node_edit.cc:237
bke::bNodeTreeType * ntreeType_Geometry
bke::bNodeTreeType * ntreeType_Composite
void RNA_string_set(PointerRNA *ptr, const char *name, const char *value)
bool ED_node_is_shader(SpaceNode *snode)
Definition node_edit.cc:140
void WM_cursor_modal_set(wmWindow *win, int val)
bool ED_operator_node_editable(bContext *C)
wmWindow * CTX_wm_window(const bContext *C)
MINLINE int max_ii(int a, int b)
void ED_node_tree_start(ARegion *region, SpaceNode *snode, bNodeTree *ntree, ID *id, ID *from)
Definition space_node.cc:79
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
RenderEngineType * CTX_data_engine_type(const bContext *C)
@ LIB_ID_COPY_DEFAULT
void RE_engine_free(RenderEngine *engine)
Global G
Definition blender.cc:57
struct bke::bNodeTreeType * ntreeType_Texture
PointerRNA WM_operator_properties_create(const char *opstring)
void GPU_material_free(ListBaseT< LinkData > *gpumaterial)
void ED_preview_kill_jobs(wmWindowManager *wm, Main *bmain)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
void BKE_ntree_update_tag_node_mute(bNodeTree *ntree, bNode *node)
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
bool ntreeCompositCryptomatteRemoveSocket(bNode *node)
void DEG_id_tag_update(ID *id, unsigned int flags)
void ntreeCompositCryptomatteAddSocket(bNode *node)
PointerRNA CTX_data_pointer_get(const bContext *C, const char *member)
bool ED_node_is_texture(SpaceNode *snode)
Definition node_edit.cc:145
wmWindowManager * CTX_wm_manager(const bContext *C)
bool BLI_rctf_isect_pt(const struct rctf *rect, float x, float y)
void BKE_main_ensure_invariants(Main &bmain, std::optional< Span< ID * > > modified_ids=std::nullopt)
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams &params={})
void WM_operator_properties_border_to_rcti(wmOperator *op, rcti *r_rect)
void ED_node_post_apply_transform(bContext *C, bNodeTree *ntree)
Definition node_edit.cc:366
void WM_cursor_modal_restore(wmWindow *win)
bool BLI_rctf_inside_rctf(const rctf *rct_a, const rctf *rct_b)
Definition rct.cc:195
SpaceNode * CTX_wm_space_node(const bContext *C)
void WM_operator_properties_gesture_box(wmOperatorType *ot)
wmOperatorStatus WM_operator_name_call(bContext *C, const char *opstring, wm::OpCallContext context, PointerRNA *properties, const wmEvent *event)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void WM_event_drag_start_mval(const wmEvent *event, const ARegion *region, int r_mval[2])
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
Definition screen.cc:1024
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
struct bke::bNodeTreeType * ntreeType_Shader
wmOperatorStatus WM_gesture_box_modal(bContext *C, wmOperator *op, const wmEvent *event)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
void WM_event_handling_break(const bContext &C)
float BLI_rctf_length_x(const rctf *rect, float x)
Definition rct.cc:173
RenderEngine * RE_engine_create(RenderEngineType *type)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void BKE_ntree_update_tag_node_property(bNodeTree *ntree, bNode *node)
Main * CTX_data_main(const bContext *C)
BLI_INLINE float BLI_rctf_size_x(const struct rctf *rct)
Definition BLI_rect.hh:211
MINLINE float max_ff(float a, float b)
void ED_node_set_active_viewer_key(SpaceNode *snode)
Image * BKE_image_ensure_viewer(Main *bmain, int type, const char *name)
void BKE_ntree_update_tag_active_output_changed(bNodeTree *ntree)
@ ID_RECALC_SYNC_TO_EVAL
Definition DNA_ID.h:1118
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
@ PROP_HIDDEN
Definition RNA_types.hh:408
@ NTREE_VIEWER_BORDER
void ntreeCompositTagRender(Scene *scene)
void WM_gesture_box_cancel(bContext *C, wmOperator *op)
@ ID_TAG_DOIT
Definition DNA_ID.h:1029
@ KM_RELEASE
Definition WM_types.hh:325
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
void ED_node_set_tree_type(SpaceNode *snode, bke::bNodeTreeType *typeinfo)
Definition node_edit.cc:121
Scene * CTX_data_scene(const bContext *C)
wmKeyMap * WM_modalkeymap_ensure(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
Definition wm_keymap.cc:972
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
@ OPTYPE_BLOCKING
Definition WM_types.hh:192
bool ED_node_supports_preview(SpaceNode *snode)
Definition node_edit.cc:155
@ NODE_LINK_INSERT_TARGET_INVALID
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
void WM_event_add_mousemove(wmWindow *win)
@ CMP_NODE_CRYPTOMATTE_SOURCE_RENDER
bool RE_ReadRenderResult(Scene *scene, Scene *scenode)
void id_us_min(ID *id)
Definition lib_id.cc:441
ARegion * CTX_wm_region(const bContext *C)
PointerRNA CTX_data_pointer_get_type(const bContext *C, const char *member, StructRNA *type)
@ SN_OVERLAY_SHOW_OVERLAYS
@ SN_OVERLAY_SHOW_PREVIEWS
void BLI_rctf_init(struct rctf *rect, float xmin, float xmax, float ymin, float ymax)
Definition rct.cc:418
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
#define NODE_MULTI_INPUT_LINK_GAP
#define NODE_SOCKSIZE
#define NODE_DY
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
char name[258]
Definition DNA_ID.h:433
ListBaseT< World > worlds
Definition BKE_main.hh:399
ListBaseT< Material > materials
Definition BKE_main.hh:392
ListBaseT< Scene > scenes
Definition BKE_main.hh:386
void(*) update_script_node(struct RenderEngine *engine, struct bNodeTree *ntree, struct bNode *node)
Definition RE_engine.h:120
struct ReportList * reports
Definition RE_engine.h:154
ListBaseT< ViewLayer > view_layers
ListBaseT< SceneCompositorEffect > compositor_effects
struct RenderData r
struct ToolSettings * toolsettings
eSpaceNodeOverlay_Flag flag
SpaceNodeOverlay overlay
struct bNodeTree * selected_node_group
eSpaceNode_ShaderFrom shaderfrom
struct bNodeTree * edittree
struct bNodeTree * nodetree
ListBaseT< bNodeTreePath > treepath
eSpaceNode_Flag flag
struct bNodeTree * nodetree
struct bNodeLink * link
bke::bNodeSocketRuntime * runtime
ListBaseT< bNodeLink > links
bke::bNodeTreeType * typeinfo
eNodeTree_Type type
eNodeTree_Flag flag
ListBaseT< bNode > nodes
struct bNode * parent
void(*) get_from_context(const bContext *C, bNodeTreeType *ntreetype, bNodeTree **r_ntree, ID **r_id, ID **r_from)
Definition BKE_node.hh:554
bool(*) poll(const bContext *C, bNodeTreeType *ntreetype)
Definition BKE_node.hh:552
Vector< NodeResizeData > nodes_data
Definition node_edit.cc:434
wmEventType type
Definition WM_types.hh:817
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
void(*) cancel(bContext *C, wmOperator *op)
Definition WM_types.hh:1149
const char * translation_context
Definition WM_types.hh:1113
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
struct ReportList * reports
#define ISMOUSE_BUTTON(event_type)