GPencil: Primitive: Polyline Tool
[blender.git] / source / blender / editors / space_node / drawnode.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2005 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spnode
22  * \brief lower level node drawing for nodes (boarders, headers etc), also node layout.
23  */
24
25 #include "BLI_blenlib.h"
26 #include "BLI_math.h"
27 #include "BLI_system.h"
28
29 #include "DNA_node_types.h"
30 #include "DNA_object_types.h"
31 #include "DNA_space_types.h"
32 #include "DNA_screen_types.h"
33 #include "DNA_userdef_types.h"
34 #include "DNA_text_types.h"
35
36 #include "BKE_context.h"
37 #include "BKE_curve.h"
38 #include "BKE_image.h"
39 #include "BKE_main.h"
40 #include "BKE_node.h"
41 #include "BKE_tracking.h"
42
43 #include "BLF_api.h"
44 #include "BLT_translation.h"
45
46 #include "BIF_glutil.h"
47
48 #include "GPU_batch.h"
49 #include "GPU_batch_presets.h"
50 #include "GPU_platform.h"
51 #include "GPU_immediate.h"
52 #include "GPU_matrix.h"
53 #include "GPU_state.h"
54
55 #include "RNA_access.h"
56 #include "RNA_define.h"
57
58 #include "ED_node.h"
59 #include "ED_space_api.h"
60
61 #include "WM_api.h"
62 #include "WM_types.h"
63
64 #include "UI_resources.h"
65 #include "UI_view2d.h"
66
67 #include "IMB_colormanagement.h"
68 #include "IMB_imbuf_types.h"
69
70 #include "node_intern.h" /* own include */
71 #include "NOD_composite.h"
72 #include "NOD_shader.h"
73 #include "NOD_texture.h"
74
75 /* ****************** SOCKET BUTTON DRAW FUNCTIONS ***************** */
76
77 static void node_socket_button_label(bContext *UNUSED(C),
78                                      uiLayout *layout,
79                                      PointerRNA *UNUSED(ptr),
80                                      PointerRNA *UNUSED(node_ptr),
81                                      const char *text)
82 {
83   uiItemL(layout, text, 0);
84 }
85
86 /* ****************** BUTTON CALLBACKS FOR ALL TREES ***************** */
87
88 static void node_buts_value(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
89 {
90   bNode *node = ptr->data;
91   /* first output stores value */
92   bNodeSocket *output = node->outputs.first;
93   PointerRNA sockptr;
94   RNA_pointer_create(ptr->owner_id, &RNA_NodeSocket, output, &sockptr);
95
96   uiItemR(layout, &sockptr, "default_value", 0, "", ICON_NONE);
97 }
98
99 static void node_buts_rgb(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
100 {
101   bNode *node = ptr->data;
102   /* first output stores value */
103   bNodeSocket *output = node->outputs.first;
104   PointerRNA sockptr;
105   uiLayout *col;
106   RNA_pointer_create(ptr->owner_id, &RNA_NodeSocket, output, &sockptr);
107
108   col = uiLayoutColumn(layout, false);
109   uiTemplateColorPicker(col, &sockptr, "default_value", 1, 0, 0, 0);
110   uiItemR(col, &sockptr, "default_value", UI_ITEM_R_SLIDER, "", ICON_NONE);
111 }
112
113 static void node_buts_mix_rgb(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
114 {
115   uiLayout *row, *col;
116
117   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
118
119   col = uiLayoutColumn(layout, false);
120   row = uiLayoutRow(col, true);
121   uiItemR(row, ptr, "blend_type", 0, "", ICON_NONE);
122   if (ELEM(ntree->type, NTREE_COMPOSIT, NTREE_TEXTURE)) {
123     uiItemR(row, ptr, "use_alpha", 0, "", ICON_IMAGE_RGB_ALPHA);
124   }
125
126   uiItemR(col, ptr, "use_clamp", 0, NULL, ICON_NONE);
127 }
128
129 static void node_buts_time(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
130 {
131   uiLayout *row;
132 #if 0
133   /* XXX no context access here .. */
134   bNode *node = ptr->data;
135   CurveMapping *cumap = node->storage;
136
137   if (cumap) {
138     cumap->flag |= CUMA_DRAW_CFRA;
139     if (node->custom1 < node->custom2) {
140       cumap->sample[0] = (float)(CFRA - node->custom1) / (float)(node->custom2 - node->custom1);
141     }
142   }
143 #endif
144
145   uiTemplateCurveMapping(layout, ptr, "curve", 's', false, false, false, false);
146
147   row = uiLayoutRow(layout, true);
148   uiItemR(row, ptr, "frame_start", 0, IFACE_("Sta"), ICON_NONE);
149   uiItemR(row, ptr, "frame_end", 0, IFACE_("End"), ICON_NONE);
150 }
151
152 static void node_buts_colorramp(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
153 {
154   uiTemplateColorRamp(layout, ptr, "color_ramp", 0);
155 }
156
157 static void node_buts_curvevec(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
158 {
159   uiTemplateCurveMapping(layout, ptr, "mapping", 'v', false, false, false, false);
160 }
161
162 #define SAMPLE_FLT_ISNONE FLT_MAX
163 /* bad bad, 2.5 will do better?... no it won't... */
164 static float _sample_col[4] = {SAMPLE_FLT_ISNONE};
165 void ED_node_sample_set(const float col[4])
166 {
167   if (col) {
168     copy_v4_v4(_sample_col, col);
169   }
170   else {
171     copy_v4_fl(_sample_col, SAMPLE_FLT_ISNONE);
172   }
173 }
174
175 static void node_buts_curvecol(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
176 {
177   bNode *node = ptr->data;
178   CurveMapping *cumap = node->storage;
179
180   if (_sample_col[0] != SAMPLE_FLT_ISNONE) {
181     cumap->flag |= CUMA_DRAW_SAMPLE;
182     copy_v3_v3(cumap->sample, _sample_col);
183   }
184   else {
185     cumap->flag &= ~CUMA_DRAW_SAMPLE;
186   }
187
188   uiTemplateCurveMapping(layout, ptr, "mapping", 'c', false, false, false, true);
189 }
190
191 static void node_buts_normal(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
192 {
193   bNode *node = ptr->data;
194   /* first output stores normal */
195   bNodeSocket *output = node->outputs.first;
196   PointerRNA sockptr;
197   RNA_pointer_create(ptr->owner_id, &RNA_NodeSocket, output, &sockptr);
198
199   uiItemR(layout, &sockptr, "default_value", 0, "", ICON_NONE);
200 }
201
202 #if 0 /* not used in 2.5x yet */
203 static void node_browse_tex_cb(bContext *C, void *ntree_v, void *node_v)
204 {
205   Main *bmain = CTX_data_main(C);
206   bNodeTree *ntree = ntree_v;
207   bNode *node = node_v;
208   Tex *tex;
209
210   if (node->menunr < 1) {
211     return;
212   }
213
214   if (node->id) {
215     id_us_min(node->id);
216     node->id = NULL;
217   }
218   tex = BLI_findlink(&bmain->tex, node->menunr - 1);
219
220   node->id = &tex->id;
221   id_us_plus(node->id);
222   BLI_strncpy(node->name, node->id->name + 2, sizeof(node->name));
223
224   nodeSetActive(ntree, node);
225
226   if (ntree->type == NTREE_TEXTURE) {
227     ntreeTexCheckCyclics(ntree);
228   }
229
230   // allqueue(REDRAWBUTSSHADING, 0);
231   // allqueue(REDRAWNODE, 0);
232   NodeTagChanged(ntree, node);
233
234   node->menunr = 0;
235 }
236 #endif
237
238 static void node_buts_texture(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
239 {
240   bNode *node = ptr->data;
241
242   short multi = (node->id && ((Tex *)node->id)->use_nodes && (node->type != CMP_NODE_TEXTURE) &&
243                  (node->type != TEX_NODE_TEXTURE));
244
245   uiItemR(layout, ptr, "texture", 0, "", ICON_NONE);
246
247   if (multi) {
248     /* Number Drawing not optimal here, better have a list*/
249     uiItemR(layout, ptr, "node_output", 0, "", ICON_NONE);
250   }
251 }
252
253 static void node_buts_map_range(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
254 {
255   uiItemR(layout, ptr, "clamp", 0, NULL, ICON_NONE);
256 }
257
258 static void node_buts_math(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
259 {
260   uiItemR(layout, ptr, "operation", 0, "", ICON_NONE);
261   uiItemR(layout, ptr, "use_clamp", 0, NULL, ICON_NONE);
262 }
263
264 static int node_resize_area_default(bNode *node, int x, int y)
265 {
266   if (node->flag & NODE_HIDDEN) {
267     rctf totr = node->totr;
268     /* right part of node */
269     totr.xmin = node->totr.xmax - 20.0f;
270     if (BLI_rctf_isect_pt(&totr, x, y)) {
271       return NODE_RESIZE_RIGHT;
272     }
273     else {
274       return 0;
275     }
276   }
277   else {
278     const float size = NODE_RESIZE_MARGIN;
279     rctf totr = node->totr;
280     int dir = 0;
281
282     if (x >= totr.xmax - size && x < totr.xmax && y >= totr.ymin && y < totr.ymax) {
283       dir |= NODE_RESIZE_RIGHT;
284     }
285     if (x >= totr.xmin && x < totr.xmin + size && y >= totr.ymin && y < totr.ymax) {
286       dir |= NODE_RESIZE_LEFT;
287     }
288     return dir;
289   }
290 }
291
292 /* ****************** BUTTON CALLBACKS FOR COMMON NODES ***************** */
293
294 static void node_draw_buttons_group(uiLayout *layout, bContext *C, PointerRNA *ptr)
295 {
296   uiTemplateIDBrowse(layout, C, ptr, "node_tree", NULL, NULL, NULL, UI_TEMPLATE_ID_FILTER_ALL);
297 }
298
299 /* XXX Does a bounding box update by iterating over all children.
300  * Not ideal to do this in every draw call, but doing as transform callback doesn't work,
301  * since the child node totr rects are not updated properly at that point.
302  */
303 static void node_draw_frame_prepare(const bContext *UNUSED(C), bNodeTree *ntree, bNode *node)
304 {
305   const float margin = 1.5f * U.widget_unit;
306   NodeFrame *data = (NodeFrame *)node->storage;
307   bool bbinit;
308   bNode *tnode;
309   rctf rect, noderect;
310   float xmax, ymax;
311
312   /* init rect from current frame size */
313   node_to_view(node, node->offsetx, node->offsety, &rect.xmin, &rect.ymax);
314   node_to_view(
315       node, node->offsetx + node->width, node->offsety - node->height, &rect.xmax, &rect.ymin);
316
317   /* frame can be resized manually only if shrinking is disabled or no children are attached */
318   data->flag |= NODE_FRAME_RESIZEABLE;
319   /* for shrinking bbox, initialize the rect from first child node */
320   bbinit = (data->flag & NODE_FRAME_SHRINK);
321   /* fit bounding box to all children */
322   for (tnode = ntree->nodes.first; tnode; tnode = tnode->next) {
323     if (tnode->parent != node) {
324       continue;
325     }
326
327     /* add margin to node rect */
328     noderect = tnode->totr;
329     noderect.xmin -= margin;
330     noderect.xmax += margin;
331     noderect.ymin -= margin;
332     noderect.ymax += margin;
333
334     /* first child initializes frame */
335     if (bbinit) {
336       bbinit = 0;
337       rect = noderect;
338       data->flag &= ~NODE_FRAME_RESIZEABLE;
339     }
340     else {
341       BLI_rctf_union(&rect, &noderect);
342     }
343   }
344
345   /* now adjust the frame size from view-space bounding box */
346   node_from_view(node, rect.xmin, rect.ymax, &node->offsetx, &node->offsety);
347   node_from_view(node, rect.xmax, rect.ymin, &xmax, &ymax);
348   node->width = xmax - node->offsetx;
349   node->height = -ymax + node->offsety;
350
351   node->totr = rect;
352 }
353
354 static void node_draw_frame_label(bNodeTree *ntree, bNode *node, const float aspect)
355 {
356   /* XXX font id is crap design */
357   const int fontid = UI_style_get()->widgetlabel.uifont_id;
358   NodeFrame *data = (NodeFrame *)node->storage;
359   rctf *rct = &node->totr;
360   int color_id = node_get_colorid(node);
361   char label[MAX_NAME];
362   /* XXX a bit hacky, should use separate align values for x and y */
363   float width, ascender;
364   float x, y;
365   const int font_size = data->label_size / aspect;
366   const float margin = (float)(NODE_DY / 4);
367   int label_height;
368   unsigned char color[3];
369
370   nodeLabel(ntree, node, label, sizeof(label));
371
372   BLF_enable(fontid, BLF_ASPECT);
373   BLF_aspect(fontid, aspect, aspect, 1.0f);
374   /* clamp otherwise it can suck up a LOT of memory */
375   BLF_size(fontid, MIN2(24, font_size), U.dpi);
376
377   /* title color */
378   UI_GetThemeColorBlendShade3ubv(TH_TEXT, color_id, 0.4f, 10, color);
379   BLF_color3ubv(fontid, color);
380
381   width = BLF_width(fontid, label, sizeof(label));
382   ascender = BLF_ascender(fontid);
383   label_height = ((margin / aspect) + (ascender * aspect));
384
385   /* 'x' doesn't need aspect correction */
386   x = BLI_rctf_cent_x(rct) - (0.5f * width);
387   y = rct->ymax - label_height;
388
389   BLF_position(fontid, x, y, 0);
390   BLF_draw(fontid, label, BLF_DRAW_STR_DUMMY_MAX);
391
392   /* draw text body */
393   if (node->id) {
394     Text *text = (Text *)node->id;
395     TextLine *line;
396     const int line_height_max = BLF_height_max(fontid);
397     const float line_spacing = (line_height_max * aspect);
398     const float line_width = (BLI_rctf_size_x(rct) - margin) / aspect;
399     int y_min;
400
401     /* 'x' doesn't need aspect correction */
402     x = rct->xmin + margin;
403     y = rct->ymax - (label_height + line_spacing);
404     /* early exit */
405     y_min = y + ((margin * 2) - (y - rct->ymin));
406
407     BLF_enable(fontid, BLF_CLIPPING | BLF_WORD_WRAP);
408     BLF_clipping(fontid,
409                  rct->xmin,
410                  /* round to avoid clipping half-way through a line */
411                  y - (floorf(((y - rct->ymin) - (margin * 2)) / line_spacing) * line_spacing),
412                  rct->xmin + line_width,
413                  rct->ymax);
414
415     BLF_wordwrap(fontid, line_width);
416
417     for (line = text->lines.first; line; line = line->next) {
418       struct ResultBLF info;
419       if (line->line[0]) {
420         BLF_position(fontid, x, y, 0);
421         BLF_draw_ex(fontid, line->line, line->len, &info);
422         y -= line_spacing * info.lines;
423       }
424       else {
425         y -= line_spacing;
426       }
427       if (y < y_min) {
428         break;
429       }
430     }
431
432     BLF_disable(fontid, BLF_CLIPPING | BLF_WORD_WRAP);
433   }
434
435   BLF_disable(fontid, BLF_ASPECT);
436 }
437
438 static void node_draw_frame(const bContext *C,
439                             ARegion *ar,
440                             SpaceNode *snode,
441                             bNodeTree *ntree,
442                             bNode *node,
443                             bNodeInstanceKey UNUSED(key))
444 {
445   rctf *rct = &node->totr;
446   int color_id = node_get_colorid(node);
447   float color[4];
448   float alpha;
449
450   /* skip if out of view */
451   if (BLI_rctf_isect(&node->totr, &ar->v2d.cur, NULL) == false) {
452     UI_block_end(C, node->block);
453     node->block = NULL;
454     return;
455   }
456
457   UI_GetThemeColor4fv(TH_NODE_FRAME, color);
458   alpha = color[3];
459
460   /* shadow */
461   node_draw_shadow(snode, node, BASIS_RAD, alpha);
462
463   /* body */
464   if (node->flag & NODE_CUSTOM_COLOR) {
465     rgba_float_args_set(color, node->color[0], node->color[1], node->color[2], alpha);
466   }
467   else {
468     UI_GetThemeColor4fv(TH_NODE_FRAME, color);
469   }
470
471   UI_draw_roundbox_corner_set(UI_CNR_ALL);
472   UI_draw_roundbox_aa(true, rct->xmin, rct->ymin, rct->xmax, rct->ymax, BASIS_RAD, color);
473
474   /* outline active and selected emphasis */
475   if (node->flag & SELECT) {
476     if (node->flag & NODE_ACTIVE) {
477       UI_GetThemeColorShadeAlpha4fv(TH_ACTIVE, 0, -40, color);
478     }
479     else {
480       UI_GetThemeColorShadeAlpha4fv(TH_SELECT, 0, -40, color);
481     }
482
483     UI_draw_roundbox_aa(false, rct->xmin, rct->ymin, rct->xmax, rct->ymax, BASIS_RAD, color);
484   }
485
486   /* label */
487   node_draw_frame_label(ntree, node, snode->aspect);
488
489   UI_ThemeClearColor(color_id);
490
491   UI_block_end(C, node->block);
492   UI_block_draw(C, node->block);
493   node->block = NULL;
494 }
495
496 static int node_resize_area_frame(bNode *node, int x, int y)
497 {
498   const float size = 10.0f;
499   NodeFrame *data = (NodeFrame *)node->storage;
500   rctf totr = node->totr;
501   int dir = 0;
502
503   /* shrinking frame size is determined by child nodes */
504   if (!(data->flag & NODE_FRAME_RESIZEABLE)) {
505     return 0;
506   }
507
508   if (x >= totr.xmax - size && x < totr.xmax && y >= totr.ymin && y < totr.ymax) {
509     dir |= NODE_RESIZE_RIGHT;
510   }
511   if (x >= totr.xmin && x < totr.xmin + size && y >= totr.ymin && y < totr.ymax) {
512     dir |= NODE_RESIZE_LEFT;
513   }
514   if (x >= totr.xmin && x < totr.xmax && y >= totr.ymax - size && y < totr.ymax) {
515     dir |= NODE_RESIZE_TOP;
516   }
517   if (x >= totr.xmin && x < totr.xmax && y >= totr.ymin && y < totr.ymin + size) {
518     dir |= NODE_RESIZE_BOTTOM;
519   }
520
521   return dir;
522 }
523
524 static void node_buts_frame_ex(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
525 {
526   uiItemR(layout, ptr, "label_size", 0, IFACE_("Label Size"), ICON_NONE);
527   uiItemR(layout, ptr, "shrink", 0, IFACE_("Shrink"), ICON_NONE);
528   uiItemR(layout, ptr, "text", 0, NULL, ICON_NONE);
529 }
530
531 #define NODE_REROUTE_SIZE 8.0f
532
533 static void node_draw_reroute_prepare(const bContext *UNUSED(C),
534                                       bNodeTree *UNUSED(ntree),
535                                       bNode *node)
536 {
537   bNodeSocket *nsock;
538   float locx, locy;
539   float size = NODE_REROUTE_SIZE;
540
541   /* get "global" coords */
542   node_to_view(node, 0.0f, 0.0f, &locx, &locy);
543
544   /* reroute node has exactly one input and one output, both in the same place */
545   nsock = node->outputs.first;
546   nsock->locx = locx;
547   nsock->locy = locy;
548
549   nsock = node->inputs.first;
550   nsock->locx = locx;
551   nsock->locy = locy;
552
553   node->width = size * 2;
554   node->totr.xmin = locx - size;
555   node->totr.xmax = locx + size;
556   node->totr.ymax = locy + size;
557   node->totr.ymin = locy - size;
558 }
559
560 static void node_draw_reroute(const bContext *C,
561                               ARegion *ar,
562                               SpaceNode *UNUSED(snode),
563                               bNodeTree *ntree,
564                               bNode *node,
565                               bNodeInstanceKey UNUSED(key))
566 {
567   char showname[128]; /* 128 used below */
568   rctf *rct = &node->totr;
569
570   /* skip if out of view */
571   if (node->totr.xmax < ar->v2d.cur.xmin || node->totr.xmin > ar->v2d.cur.xmax ||
572       node->totr.ymax < ar->v2d.cur.ymin || node->totr.ymin > ar->v2d.cur.ymax) {
573     UI_block_end(C, node->block);
574     node->block = NULL;
575     return;
576   }
577
578   /* XXX only kept for debugging
579    * selection state is indicated by socket outline below!
580    */
581 #if 0
582   float size = NODE_REROUTE_SIZE;
583
584   /* body */
585   float debug_color[4];
586   UI_draw_roundbox_corner_set(UI_CNR_ALL);
587   UI_GetThemeColor4fv(TH_NODE, debug_color);
588   UI_draw_roundbox_aa(true, rct->xmin, rct->ymin, rct->xmax, rct->ymax, size, debug_color);
589
590   /* outline active and selected emphasis */
591   if (node->flag & SELECT) {
592     GPU_blend(true);
593     GPU_line_smooth(true);
594     /* using different shades of TH_TEXT_HI for the empasis, like triangle */
595     if (node->flag & NODE_ACTIVE) {
596       UI_GetThemeColorShadeAlpha4fv(TH_TEXT_HI, 0, -40, debug_color);
597     }
598     else {
599       UI_GetThemeColorShadeAlpha4fv(TH_TEXT_HI, -20, -120, debug_color);
600     }
601     UI_draw_roundbox_4fv(false, rct->xmin, rct->ymin, rct->xmax, rct->ymax, size, debug_color);
602
603     GPU_line_smooth(false);
604     GPU_blend(false);
605   }
606 #endif
607
608   if (node->label[0] != '\0') {
609     /* draw title (node label) */
610     BLI_strncpy(showname, node->label, sizeof(showname));
611     uiDefBut(node->block,
612              UI_BTYPE_LABEL,
613              0,
614              showname,
615              (int)(rct->xmin - NODE_DYS),
616              (int)(rct->ymax),
617              (short)512,
618              (short)NODE_DY,
619              NULL,
620              0,
621              0,
622              0,
623              0,
624              NULL);
625   }
626
627   /* only draw input socket. as they all are placed on the same position.
628    * highlight also if node itself is selected, since we don't display the node body separately!
629    */
630   node_draw_sockets(&ar->v2d, C, ntree, node, false, node->flag & SELECT);
631
632   UI_block_end(C, node->block);
633   UI_block_draw(C, node->block);
634   node->block = NULL;
635 }
636
637 /* Special tweak area for reroute node.
638  * Since this node is quite small, we use a larger tweak area for grabbing than for selection.
639  */
640 static int node_tweak_area_reroute(bNode *node, int x, int y)
641 {
642   /* square of tweak radius */
643   const float tweak_radius_sq = SQUARE(24);
644
645   bNodeSocket *sock = node->inputs.first;
646   float dx = sock->locx - x;
647   float dy = sock->locy - y;
648   return (dx * dx + dy * dy <= tweak_radius_sq);
649 }
650
651 static void node_common_set_butfunc(bNodeType *ntype)
652 {
653   switch (ntype->type) {
654     case NODE_GROUP:
655       ntype->draw_buttons = node_draw_buttons_group;
656       break;
657     case NODE_FRAME:
658       ntype->draw_nodetype = node_draw_frame;
659       ntype->draw_nodetype_prepare = node_draw_frame_prepare;
660       ntype->draw_buttons_ex = node_buts_frame_ex;
661       ntype->resize_area_func = node_resize_area_frame;
662       break;
663     case NODE_REROUTE:
664       ntype->draw_nodetype = node_draw_reroute;
665       ntype->draw_nodetype_prepare = node_draw_reroute_prepare;
666       ntype->tweak_area_func = node_tweak_area_reroute;
667       break;
668   }
669 }
670
671 /* ****************** BUTTON CALLBACKS FOR SHADER NODES ***************** */
672
673 static void node_buts_image_user(uiLayout *layout,
674                                  bContext *C,
675                                  PointerRNA *ptr,
676                                  PointerRNA *imaptr,
677                                  PointerRNA *iuserptr,
678                                  bool compositor)
679 {
680   uiLayout *col;
681   int source;
682
683   if (!imaptr->data) {
684     return;
685   }
686
687   col = uiLayoutColumn(layout, false);
688
689   uiItemR(col, imaptr, "source", 0, "", ICON_NONE);
690
691   source = RNA_enum_get(imaptr, "source");
692
693   if (source == IMA_SRC_SEQUENCE) {
694     /* don't use iuser->framenr directly
695      * because it may not be updated if auto-refresh is off */
696     Scene *scene = CTX_data_scene(C);
697     ImageUser *iuser = iuserptr->data;
698     /* Image *ima = imaptr->data; */ /* UNUSED */
699
700     char numstr[32];
701     const int framenr = BKE_image_user_frame_get(iuser, CFRA, NULL);
702     BLI_snprintf(numstr, sizeof(numstr), IFACE_("Frame: %d"), framenr);
703     uiItemL(layout, numstr, ICON_NONE);
704   }
705
706   if (ELEM(source, IMA_SRC_SEQUENCE, IMA_SRC_MOVIE)) {
707     col = uiLayoutColumn(layout, true);
708     uiItemR(col, ptr, "frame_duration", 0, NULL, ICON_NONE);
709     uiItemR(col, ptr, "frame_start", 0, NULL, ICON_NONE);
710     uiItemR(col, ptr, "frame_offset", 0, NULL, ICON_NONE);
711     uiItemR(col, ptr, "use_cyclic", 0, NULL, ICON_NONE);
712     uiItemR(col, ptr, "use_auto_refresh", 0, NULL, ICON_NONE);
713   }
714
715   if (compositor && RNA_enum_get(imaptr, "type") == IMA_TYPE_MULTILAYER &&
716       RNA_boolean_get(ptr, "has_layers")) {
717     col = uiLayoutColumn(layout, false);
718     uiItemR(col, ptr, "layer", 0, NULL, ICON_NONE);
719   }
720
721   uiLayout *split = uiLayoutSplit(layout, 0.5f, true);
722   PointerRNA colorspace_settings_ptr = RNA_pointer_get(imaptr, "colorspace_settings");
723   uiItemL(split, IFACE_("Color Space"), ICON_NONE);
724   uiItemR(split, &colorspace_settings_ptr, "name", 0, "", ICON_NONE);
725
726   /* Avoid losing changes image is painted. */
727   if (BKE_image_is_dirty(imaptr->data)) {
728     uiLayoutSetEnabled(split, false);
729   }
730 }
731
732 static void node_shader_buts_mapping(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
733 {
734   uiItemR(layout, ptr, "vector_type", 0, NULL, ICON_NONE);
735 }
736
737 static void node_shader_buts_vect_math(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
738 {
739   uiItemR(layout, ptr, "operation", 0, "", ICON_NONE);
740 }
741
742 static void node_shader_buts_vect_transform(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
743 {
744   uiItemR(layout, ptr, "vector_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
745   uiItemR(layout, ptr, "convert_from", 0, "", ICON_NONE);
746   uiItemR(layout, ptr, "convert_to", 0, "", ICON_NONE);
747 }
748
749 static void node_shader_buts_attribute(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
750 {
751   uiItemR(layout, ptr, "attribute_name", 0, IFACE_("Name"), ICON_NONE);
752 }
753
754 static void node_shader_buts_wireframe(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
755 {
756   uiItemR(layout, ptr, "use_pixel_size", 0, NULL, 0);
757 }
758
759 static void node_shader_buts_tex_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
760 {
761   PointerRNA imaptr = RNA_pointer_get(ptr, "image");
762   PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
763
764   uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
765   uiTemplateID(layout,
766                C,
767                ptr,
768                "image",
769                "IMAGE_OT_new",
770                "IMAGE_OT_open",
771                NULL,
772                UI_TEMPLATE_ID_FILTER_ALL,
773                false);
774   uiItemR(layout, ptr, "interpolation", 0, "", ICON_NONE);
775   uiItemR(layout, ptr, "projection", 0, "", ICON_NONE);
776
777   if (RNA_enum_get(ptr, "projection") == SHD_PROJ_BOX) {
778     uiItemR(layout, ptr, "projection_blend", 0, "Blend", ICON_NONE);
779   }
780
781   uiItemR(layout, ptr, "extension", 0, "", ICON_NONE);
782
783   /* note: image user properties used directly here, unlike compositor image node,
784    * which redefines them in the node struct RNA to get proper updates.
785    */
786   node_buts_image_user(layout, C, &iuserptr, &imaptr, &iuserptr, false);
787 }
788
789 static void node_shader_buts_tex_image_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
790 {
791   PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
792   uiTemplateImage(layout, C, ptr, "image", &iuserptr, 0, 0);
793 }
794
795 static void node_shader_buts_tex_environment(uiLayout *layout, bContext *C, PointerRNA *ptr)
796 {
797   PointerRNA imaptr = RNA_pointer_get(ptr, "image");
798   PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
799
800   uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
801   uiTemplateID(layout,
802                C,
803                ptr,
804                "image",
805                "IMAGE_OT_new",
806                "IMAGE_OT_open",
807                NULL,
808                UI_TEMPLATE_ID_FILTER_ALL,
809                false);
810
811   uiItemR(layout, ptr, "interpolation", 0, "", ICON_NONE);
812   uiItemR(layout, ptr, "projection", 0, "", ICON_NONE);
813
814   node_buts_image_user(layout, C, &iuserptr, &imaptr, &iuserptr, false);
815 }
816
817 static void node_shader_buts_tex_environment_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
818 {
819   PointerRNA iuserptr = RNA_pointer_get(ptr, "image_user");
820   uiTemplateImage(layout, C, ptr, "image", &iuserptr, 0, 0);
821
822   uiItemR(layout, ptr, "interpolation", 0, IFACE_("Interpolation"), ICON_NONE);
823   uiItemR(layout, ptr, "projection", 0, IFACE_("Projection"), ICON_NONE);
824 }
825
826 static void node_shader_buts_tex_sky(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
827 {
828   uiItemR(layout, ptr, "sky_type", 0, "", ICON_NONE);
829   uiItemR(layout, ptr, "sun_direction", 0, "", ICON_NONE);
830   uiItemR(layout, ptr, "turbidity", 0, NULL, ICON_NONE);
831
832   if (RNA_enum_get(ptr, "sky_type") == SHD_SKY_NEW) {
833     uiItemR(layout, ptr, "ground_albedo", 0, NULL, ICON_NONE);
834   }
835 }
836
837 static void node_shader_buts_tex_gradient(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
838 {
839   uiItemR(layout, ptr, "gradient_type", 0, "", ICON_NONE);
840 }
841
842 static void node_shader_buts_tex_magic(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
843 {
844   uiItemR(layout, ptr, "turbulence_depth", 0, NULL, ICON_NONE);
845 }
846
847 static void node_shader_buts_tex_brick(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
848 {
849   uiLayout *col;
850
851   col = uiLayoutColumn(layout, true);
852   uiItemR(col, ptr, "offset", UI_ITEM_R_SLIDER, IFACE_("Offset"), ICON_NONE);
853   uiItemR(col, ptr, "offset_frequency", 0, IFACE_("Frequency"), ICON_NONE);
854
855   col = uiLayoutColumn(layout, true);
856   uiItemR(col, ptr, "squash", 0, IFACE_("Squash"), ICON_NONE);
857   uiItemR(col, ptr, "squash_frequency", 0, IFACE_("Frequency"), ICON_NONE);
858 }
859
860 static void node_shader_buts_tex_wave(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
861 {
862   uiItemR(layout, ptr, "wave_type", 0, "", ICON_NONE);
863   uiItemR(layout, ptr, "wave_profile", 0, "", ICON_NONE);
864 }
865
866 static void node_shader_buts_tex_musgrave(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
867 {
868   uiItemR(layout, ptr, "musgrave_dimensions", 0, "", ICON_NONE);
869   uiItemR(layout, ptr, "musgrave_type", 0, "", ICON_NONE);
870 }
871
872 static void node_shader_buts_tex_voronoi(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
873 {
874   uiItemR(layout, ptr, "voronoi_dimensions", 0, "", ICON_NONE);
875   uiItemR(layout, ptr, "feature", 0, "", ICON_NONE);
876   int feature = RNA_enum_get(ptr, "feature");
877   if (!ELEM(feature, SHD_VORONOI_DISTANCE_TO_EDGE, SHD_VORONOI_N_SPHERE_RADIUS) &&
878       RNA_enum_get(ptr, "voronoi_dimensions") != 1) {
879     uiItemR(layout, ptr, "distance", 0, "", ICON_NONE);
880   }
881 }
882
883 static void node_shader_buts_tex_noise(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
884 {
885   uiItemR(layout, ptr, "noise_dimensions", 0, "", ICON_NONE);
886 }
887
888 static void node_shader_buts_tex_pointdensity(uiLayout *layout,
889                                               bContext *UNUSED(C),
890                                               PointerRNA *ptr)
891 {
892   bNode *node = ptr->data;
893   NodeShaderTexPointDensity *shader_point_density = node->storage;
894   Object *ob = (Object *)node->id;
895   PointerRNA ob_ptr, obdata_ptr;
896
897   RNA_id_pointer_create((ID *)ob, &ob_ptr);
898   RNA_id_pointer_create(ob ? (ID *)ob->data : NULL, &obdata_ptr);
899
900   uiItemR(layout, ptr, "point_source", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
901   uiItemR(layout, ptr, "object", 0, NULL, ICON_NONE);
902
903   if (node->id && shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_PSYS) {
904     PointerRNA dataptr;
905     RNA_id_pointer_create((ID *)node->id, &dataptr);
906     uiItemPointerR(layout, ptr, "particle_system", &dataptr, "particle_systems", NULL, ICON_NONE);
907   }
908
909   uiItemR(layout, ptr, "space", 0, NULL, ICON_NONE);
910   uiItemR(layout, ptr, "radius", 0, NULL, ICON_NONE);
911   uiItemR(layout, ptr, "interpolation", 0, NULL, ICON_NONE);
912   uiItemR(layout, ptr, "resolution", 0, NULL, ICON_NONE);
913   if (shader_point_density->point_source == SHD_POINTDENSITY_SOURCE_PSYS) {
914     uiItemR(layout, ptr, "particle_color_source", 0, NULL, ICON_NONE);
915   }
916   else {
917     uiItemR(layout, ptr, "vertex_color_source", 0, NULL, ICON_NONE);
918     if (shader_point_density->ob_color_source == SHD_POINTDENSITY_COLOR_VERTWEIGHT) {
919       if (ob_ptr.data) {
920         uiItemPointerR(
921             layout, ptr, "vertex_attribute_name", &ob_ptr, "vertex_groups", "", ICON_NONE);
922       }
923     }
924     if (shader_point_density->ob_color_source == SHD_POINTDENSITY_COLOR_VERTCOL) {
925       if (obdata_ptr.data) {
926         uiItemPointerR(
927             layout, ptr, "vertex_attribute_name", &obdata_ptr, "vertex_colors", "", ICON_NONE);
928       }
929     }
930   }
931 }
932
933 static void node_shader_buts_tex_coord(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
934 {
935   uiItemR(layout, ptr, "object", 0, NULL, 0);
936   uiItemR(layout, ptr, "from_instancer", 0, NULL, 0);
937 }
938
939 static void node_shader_buts_bump(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
940 {
941   uiItemR(layout, ptr, "invert", 0, NULL, 0);
942 }
943
944 static void node_shader_buts_uvmap(uiLayout *layout, bContext *C, PointerRNA *ptr)
945 {
946   uiItemR(layout, ptr, "from_instancer", 0, NULL, 0);
947
948   if (!RNA_boolean_get(ptr, "from_instancer")) {
949     PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
950
951     if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
952       PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
953       uiItemPointerR(layout, ptr, "uv_map", &dataptr, "uv_layers", "", ICON_NONE);
954     }
955   }
956 }
957
958 static void node_shader_buts_vertex_color(uiLayout *layout, bContext *C, PointerRNA *ptr)
959 {
960   PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
961   if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
962     PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
963     uiItemPointerR(layout, ptr, "layer_name", &dataptr, "vertex_colors", "", ICON_GROUP_VCOL);
964   }
965   else {
966     uiItemL(layout, "No mesh in active object.", ICON_ERROR);
967   }
968 }
969
970 static void node_shader_buts_uvalongstroke(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
971 {
972   uiItemR(layout, ptr, "use_tips", 0, NULL, 0);
973 }
974
975 static void node_shader_buts_normal_map(uiLayout *layout, bContext *C, PointerRNA *ptr)
976 {
977   uiItemR(layout, ptr, "space", 0, "", 0);
978
979   if (RNA_enum_get(ptr, "space") == SHD_SPACE_TANGENT) {
980     PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
981
982     if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
983       PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
984       uiItemPointerR(layout, ptr, "uv_map", &dataptr, "uv_layers", "", ICON_NONE);
985     }
986     else {
987       uiItemR(layout, ptr, "uv_map", 0, "", 0);
988     }
989   }
990 }
991
992 static void node_shader_buts_displacement(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
993 {
994   uiItemR(layout, ptr, "space", 0, "", 0);
995 }
996
997 static void node_shader_buts_tangent(uiLayout *layout, bContext *C, PointerRNA *ptr)
998 {
999   uiLayout *split, *row;
1000
1001   split = uiLayoutSplit(layout, 0.0f, false);
1002
1003   uiItemR(split, ptr, "direction_type", 0, "", 0);
1004
1005   row = uiLayoutRow(split, false);
1006
1007   if (RNA_enum_get(ptr, "direction_type") == SHD_TANGENT_UVMAP) {
1008     PointerRNA obptr = CTX_data_pointer_get(C, "active_object");
1009
1010     if (obptr.data && RNA_enum_get(&obptr, "type") == OB_MESH) {
1011       PointerRNA dataptr = RNA_pointer_get(&obptr, "data");
1012       uiItemPointerR(row, ptr, "uv_map", &dataptr, "uv_layers", "", ICON_NONE);
1013     }
1014     else {
1015       uiItemR(row, ptr, "uv_map", 0, "", 0);
1016     }
1017   }
1018   else {
1019     uiItemR(row, ptr, "axis", UI_ITEM_R_EXPAND, NULL, 0);
1020   }
1021 }
1022
1023 static void node_shader_buts_glossy(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1024 {
1025   uiItemR(layout, ptr, "distribution", 0, "", ICON_NONE);
1026 }
1027
1028 static void node_shader_buts_principled(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1029 {
1030   uiItemR(layout, ptr, "distribution", 0, "", ICON_NONE);
1031   uiItemR(layout, ptr, "subsurface_method", 0, "", ICON_NONE);
1032 }
1033
1034 static void node_shader_buts_anisotropic(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1035 {
1036   uiItemR(layout, ptr, "distribution", 0, "", ICON_NONE);
1037 }
1038
1039 static void node_shader_buts_subsurface(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1040 {
1041   uiItemR(layout, ptr, "falloff", 0, "", ICON_NONE);
1042 }
1043
1044 static void node_shader_buts_toon(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1045 {
1046   uiItemR(layout, ptr, "component", 0, "", ICON_NONE);
1047 }
1048
1049 static void node_shader_buts_hair(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1050 {
1051   uiItemR(layout, ptr, "component", 0, "", ICON_NONE);
1052 }
1053
1054 static void node_shader_buts_principled_hair(uiLayout *layout,
1055                                              bContext *UNUSED(C),
1056                                              PointerRNA *ptr)
1057 {
1058   uiItemR(layout, ptr, "parametrization", 0, "", ICON_NONE);
1059 }
1060
1061 static void node_shader_buts_ies(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1062 {
1063   uiLayout *row;
1064
1065   row = uiLayoutRow(layout, false);
1066   uiItemR(row, ptr, "mode", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1067
1068   row = uiLayoutRow(layout, true);
1069
1070   if (RNA_enum_get(ptr, "mode") == NODE_IES_INTERNAL) {
1071     uiItemR(row, ptr, "ies", 0, "", ICON_NONE);
1072   }
1073   else {
1074     uiItemR(row, ptr, "filepath", 0, "", ICON_NONE);
1075   }
1076 }
1077
1078 static void node_shader_buts_script(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1079 {
1080   uiLayout *row;
1081
1082   row = uiLayoutRow(layout, false);
1083   uiItemR(row, ptr, "mode", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1084
1085   row = uiLayoutRow(layout, true);
1086
1087   if (RNA_enum_get(ptr, "mode") == NODE_SCRIPT_INTERNAL) {
1088     uiItemR(row, ptr, "script", 0, "", ICON_NONE);
1089   }
1090   else {
1091     uiItemR(row, ptr, "filepath", 0, "", ICON_NONE);
1092   }
1093
1094   uiItemO(row, "", ICON_FILE_REFRESH, "node.shader_script_update");
1095 }
1096
1097 static void node_shader_buts_script_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
1098 {
1099   uiItemS(layout);
1100
1101   node_shader_buts_script(layout, C, ptr);
1102
1103 #if 0 /* not implemented yet */
1104   if (RNA_enum_get(ptr, "mode") == NODE_SCRIPT_EXTERNAL) {
1105     uiItemR(layout, ptr, "use_auto_update", 0, NULL, ICON_NONE);
1106   }
1107 #endif
1108 }
1109
1110 static void node_buts_output_shader(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1111 {
1112   uiItemR(layout, ptr, "target", 0, "", ICON_NONE);
1113 }
1114
1115 static void node_buts_output_linestyle(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1116 {
1117   uiLayout *row, *col;
1118
1119   col = uiLayoutColumn(layout, false);
1120   row = uiLayoutRow(col, true);
1121   uiItemR(row, ptr, "blend_type", 0, "", ICON_NONE);
1122   uiItemR(col, ptr, "use_clamp", 0, NULL, ICON_NONE);
1123 }
1124
1125 static void node_shader_buts_bevel(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1126 {
1127   uiItemR(layout, ptr, "samples", 0, NULL, ICON_NONE);
1128 }
1129
1130 static void node_shader_buts_ambient_occlusion(uiLayout *layout,
1131                                                bContext *UNUSED(C),
1132                                                PointerRNA *ptr)
1133 {
1134   uiItemR(layout, ptr, "samples", 0, NULL, ICON_NONE);
1135   uiItemR(layout, ptr, "inside", 0, NULL, ICON_NONE);
1136   uiItemR(layout, ptr, "only_local", 0, NULL, ICON_NONE);
1137 }
1138
1139 static void node_shader_buts_white_noise(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1140 {
1141   uiItemR(layout, ptr, "noise_dimensions", 0, "", ICON_NONE);
1142 }
1143
1144 /* only once called */
1145 static void node_shader_set_butfunc(bNodeType *ntype)
1146 {
1147   switch (ntype->type) {
1148     case SH_NODE_NORMAL:
1149       ntype->draw_buttons = node_buts_normal;
1150       break;
1151     case SH_NODE_CURVE_VEC:
1152       ntype->draw_buttons = node_buts_curvevec;
1153       break;
1154     case SH_NODE_CURVE_RGB:
1155       ntype->draw_buttons = node_buts_curvecol;
1156       break;
1157     case SH_NODE_MAPPING:
1158       ntype->draw_buttons = node_shader_buts_mapping;
1159       break;
1160     case SH_NODE_VALUE:
1161       ntype->draw_buttons = node_buts_value;
1162       break;
1163     case SH_NODE_RGB:
1164       ntype->draw_buttons = node_buts_rgb;
1165       break;
1166     case SH_NODE_MIX_RGB:
1167       ntype->draw_buttons = node_buts_mix_rgb;
1168       break;
1169     case SH_NODE_VALTORGB:
1170       ntype->draw_buttons = node_buts_colorramp;
1171       break;
1172     case SH_NODE_MAP_RANGE:
1173       ntype->draw_buttons = node_buts_map_range;
1174       break;
1175     case SH_NODE_MATH:
1176       ntype->draw_buttons = node_buts_math;
1177       break;
1178     case SH_NODE_VECTOR_MATH:
1179       ntype->draw_buttons = node_shader_buts_vect_math;
1180       break;
1181     case SH_NODE_VECT_TRANSFORM:
1182       ntype->draw_buttons = node_shader_buts_vect_transform;
1183       break;
1184     case SH_NODE_ATTRIBUTE:
1185       ntype->draw_buttons = node_shader_buts_attribute;
1186       break;
1187     case SH_NODE_WIREFRAME:
1188       ntype->draw_buttons = node_shader_buts_wireframe;
1189       break;
1190     case SH_NODE_TEX_SKY:
1191       ntype->draw_buttons = node_shader_buts_tex_sky;
1192       break;
1193     case SH_NODE_TEX_IMAGE:
1194       ntype->draw_buttons = node_shader_buts_tex_image;
1195       ntype->draw_buttons_ex = node_shader_buts_tex_image_ex;
1196       break;
1197     case SH_NODE_TEX_ENVIRONMENT:
1198       ntype->draw_buttons = node_shader_buts_tex_environment;
1199       ntype->draw_buttons_ex = node_shader_buts_tex_environment_ex;
1200       break;
1201     case SH_NODE_TEX_GRADIENT:
1202       ntype->draw_buttons = node_shader_buts_tex_gradient;
1203       break;
1204     case SH_NODE_TEX_MAGIC:
1205       ntype->draw_buttons = node_shader_buts_tex_magic;
1206       break;
1207     case SH_NODE_TEX_BRICK:
1208       ntype->draw_buttons = node_shader_buts_tex_brick;
1209       break;
1210     case SH_NODE_TEX_WAVE:
1211       ntype->draw_buttons = node_shader_buts_tex_wave;
1212       break;
1213     case SH_NODE_TEX_MUSGRAVE:
1214       ntype->draw_buttons = node_shader_buts_tex_musgrave;
1215       break;
1216     case SH_NODE_TEX_VORONOI:
1217       ntype->draw_buttons = node_shader_buts_tex_voronoi;
1218       break;
1219     case SH_NODE_TEX_NOISE:
1220       ntype->draw_buttons = node_shader_buts_tex_noise;
1221       break;
1222     case SH_NODE_TEX_POINTDENSITY:
1223       ntype->draw_buttons = node_shader_buts_tex_pointdensity;
1224       break;
1225     case SH_NODE_TEX_COORD:
1226       ntype->draw_buttons = node_shader_buts_tex_coord;
1227       break;
1228     case SH_NODE_BUMP:
1229       ntype->draw_buttons = node_shader_buts_bump;
1230       break;
1231     case SH_NODE_NORMAL_MAP:
1232       ntype->draw_buttons = node_shader_buts_normal_map;
1233       break;
1234     case SH_NODE_DISPLACEMENT:
1235     case SH_NODE_VECTOR_DISPLACEMENT:
1236       ntype->draw_buttons = node_shader_buts_displacement;
1237       break;
1238     case SH_NODE_TANGENT:
1239       ntype->draw_buttons = node_shader_buts_tangent;
1240       break;
1241     case SH_NODE_BSDF_GLOSSY:
1242     case SH_NODE_BSDF_GLASS:
1243     case SH_NODE_BSDF_REFRACTION:
1244       ntype->draw_buttons = node_shader_buts_glossy;
1245       break;
1246     case SH_NODE_BSDF_PRINCIPLED:
1247       ntype->draw_buttons = node_shader_buts_principled;
1248       break;
1249     case SH_NODE_BSDF_ANISOTROPIC:
1250       ntype->draw_buttons = node_shader_buts_anisotropic;
1251       break;
1252     case SH_NODE_SUBSURFACE_SCATTERING:
1253       ntype->draw_buttons = node_shader_buts_subsurface;
1254       break;
1255     case SH_NODE_BSDF_TOON:
1256       ntype->draw_buttons = node_shader_buts_toon;
1257       break;
1258     case SH_NODE_BSDF_HAIR:
1259       ntype->draw_buttons = node_shader_buts_hair;
1260       break;
1261     case SH_NODE_BSDF_HAIR_PRINCIPLED:
1262       ntype->draw_buttons = node_shader_buts_principled_hair;
1263       break;
1264     case SH_NODE_SCRIPT:
1265       ntype->draw_buttons = node_shader_buts_script;
1266       ntype->draw_buttons_ex = node_shader_buts_script_ex;
1267       break;
1268     case SH_NODE_UVMAP:
1269       ntype->draw_buttons = node_shader_buts_uvmap;
1270       break;
1271     case SH_NODE_VERTEX_COLOR:
1272       ntype->draw_buttons = node_shader_buts_vertex_color;
1273       break;
1274     case SH_NODE_UVALONGSTROKE:
1275       ntype->draw_buttons = node_shader_buts_uvalongstroke;
1276       break;
1277     case SH_NODE_OUTPUT_MATERIAL:
1278     case SH_NODE_OUTPUT_LIGHT:
1279     case SH_NODE_OUTPUT_WORLD:
1280       ntype->draw_buttons = node_buts_output_shader;
1281       break;
1282     case SH_NODE_OUTPUT_LINESTYLE:
1283       ntype->draw_buttons = node_buts_output_linestyle;
1284       break;
1285     case SH_NODE_TEX_IES:
1286       ntype->draw_buttons = node_shader_buts_ies;
1287       break;
1288     case SH_NODE_BEVEL:
1289       ntype->draw_buttons = node_shader_buts_bevel;
1290       break;
1291     case SH_NODE_AMBIENT_OCCLUSION:
1292       ntype->draw_buttons = node_shader_buts_ambient_occlusion;
1293       break;
1294     case SH_NODE_TEX_WHITE_NOISE:
1295       ntype->draw_buttons = node_shader_buts_white_noise;
1296       break;
1297   }
1298 }
1299
1300 /* ****************** BUTTON CALLBACKS FOR COMPOSITE NODES ***************** */
1301
1302 static void node_buts_image_views(uiLayout *layout,
1303                                   bContext *UNUSED(C),
1304                                   PointerRNA *ptr,
1305                                   PointerRNA *imaptr)
1306 {
1307   uiLayout *col;
1308
1309   if (!imaptr->data) {
1310     return;
1311   }
1312
1313   col = uiLayoutColumn(layout, false);
1314
1315   if (RNA_boolean_get(ptr, "has_views")) {
1316     if (RNA_enum_get(ptr, "view") == 0) {
1317       uiItemR(col, ptr, "view", 0, NULL, ICON_CAMERA_STEREO);
1318     }
1319     else {
1320       uiItemR(col, ptr, "view", 0, NULL, ICON_SCENE);
1321     }
1322   }
1323 }
1324
1325 static void node_composit_buts_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
1326 {
1327   bNode *node = ptr->data;
1328   PointerRNA imaptr, iuserptr;
1329
1330   RNA_pointer_create(ptr->owner_id, &RNA_ImageUser, node->storage, &iuserptr);
1331   uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
1332   uiTemplateID(layout,
1333                C,
1334                ptr,
1335                "image",
1336                "IMAGE_OT_new",
1337                "IMAGE_OT_open",
1338                NULL,
1339                UI_TEMPLATE_ID_FILTER_ALL,
1340                false);
1341   if (!node->id) {
1342     return;
1343   }
1344
1345   imaptr = RNA_pointer_get(ptr, "image");
1346
1347   node_buts_image_user(layout, C, ptr, &imaptr, &iuserptr, true);
1348
1349   node_buts_image_views(layout, C, ptr, &imaptr);
1350 }
1351
1352 static void node_composit_buts_image_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
1353 {
1354   bNode *node = ptr->data;
1355   PointerRNA iuserptr;
1356
1357   RNA_pointer_create(ptr->owner_id, &RNA_ImageUser, node->storage, &iuserptr);
1358   uiLayoutSetContextPointer(layout, "image_user", &iuserptr);
1359   uiTemplateImage(layout, C, ptr, "image", &iuserptr, 0, 1);
1360 }
1361
1362 static void node_composit_buts_viewlayers(uiLayout *layout, bContext *C, PointerRNA *ptr)
1363 {
1364   bNode *node = ptr->data;
1365   uiLayout *col, *row;
1366   PointerRNA op_ptr;
1367   PointerRNA scn_ptr;
1368   PropertyRNA *prop;
1369   const char *layer_name;
1370   char scene_name[MAX_ID_NAME - 2];
1371
1372   uiTemplateID(layout, C, ptr, "scene", NULL, NULL, NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
1373
1374   if (!node->id) {
1375     return;
1376   }
1377
1378   col = uiLayoutColumn(layout, false);
1379   row = uiLayoutRow(col, true);
1380   uiItemR(row, ptr, "layer", 0, "", ICON_NONE);
1381
1382   prop = RNA_struct_find_property(ptr, "layer");
1383   if (!(RNA_property_enum_identifier(
1384           C, ptr, prop, RNA_property_enum_get(ptr, prop), &layer_name))) {
1385     return;
1386   }
1387
1388   scn_ptr = RNA_pointer_get(ptr, "scene");
1389   RNA_string_get(&scn_ptr, "name", scene_name);
1390
1391   uiItemFullO(
1392       row, "RENDER_OT_render", "", ICON_RENDER_STILL, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
1393   RNA_string_set(&op_ptr, "layer", layer_name);
1394   RNA_string_set(&op_ptr, "scene", scene_name);
1395 }
1396
1397 static void node_composit_buts_blur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1398 {
1399   uiLayout *col, *row;
1400   int reference;
1401   int filter;
1402
1403   col = uiLayoutColumn(layout, false);
1404   filter = RNA_enum_get(ptr, "filter_type");
1405   reference = RNA_boolean_get(ptr, "use_variable_size");
1406
1407   uiItemR(col, ptr, "filter_type", 0, "", ICON_NONE);
1408   if (filter != R_FILTER_FAST_GAUSS) {
1409     uiItemR(col, ptr, "use_variable_size", 0, NULL, ICON_NONE);
1410     if (!reference) {
1411       uiItemR(col, ptr, "use_bokeh", 0, NULL, ICON_NONE);
1412     }
1413     uiItemR(col, ptr, "use_gamma_correction", 0, NULL, ICON_NONE);
1414   }
1415
1416   uiItemR(col, ptr, "use_relative", 0, NULL, ICON_NONE);
1417
1418   if (RNA_boolean_get(ptr, "use_relative")) {
1419     uiItemL(col, IFACE_("Aspect Correction"), ICON_NONE);
1420     row = uiLayoutRow(layout, true);
1421     uiItemR(row, ptr, "aspect_correction", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1422
1423     col = uiLayoutColumn(layout, true);
1424     uiItemR(col, ptr, "factor_x", 0, IFACE_("X"), ICON_NONE);
1425     uiItemR(col, ptr, "factor_y", 0, IFACE_("Y"), ICON_NONE);
1426   }
1427   else {
1428     col = uiLayoutColumn(layout, true);
1429     uiItemR(col, ptr, "size_x", 0, IFACE_("X"), ICON_NONE);
1430     uiItemR(col, ptr, "size_y", 0, IFACE_("Y"), ICON_NONE);
1431   }
1432   uiItemR(col, ptr, "use_extended_bounds", 0, NULL, ICON_NONE);
1433 }
1434
1435 static void node_composit_buts_dblur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1436 {
1437   uiLayout *col;
1438
1439   uiItemR(layout, ptr, "iterations", 0, NULL, ICON_NONE);
1440   uiItemR(layout, ptr, "use_wrap", 0, NULL, ICON_NONE);
1441
1442   col = uiLayoutColumn(layout, true);
1443   uiItemL(col, IFACE_("Center:"), ICON_NONE);
1444   uiItemR(col, ptr, "center_x", 0, IFACE_("X"), ICON_NONE);
1445   uiItemR(col, ptr, "center_y", 0, IFACE_("Y"), ICON_NONE);
1446
1447   uiItemS(layout);
1448
1449   col = uiLayoutColumn(layout, true);
1450   uiItemR(col, ptr, "distance", 0, NULL, ICON_NONE);
1451   uiItemR(col, ptr, "angle", 0, NULL, ICON_NONE);
1452
1453   uiItemS(layout);
1454
1455   uiItemR(layout, ptr, "spin", 0, NULL, ICON_NONE);
1456   uiItemR(layout, ptr, "zoom", 0, NULL, ICON_NONE);
1457 }
1458
1459 static void node_composit_buts_bilateralblur(uiLayout *layout,
1460                                              bContext *UNUSED(C),
1461                                              PointerRNA *ptr)
1462 {
1463   uiLayout *col;
1464
1465   col = uiLayoutColumn(layout, true);
1466   uiItemR(col, ptr, "iterations", 0, NULL, ICON_NONE);
1467   uiItemR(col, ptr, "sigma_color", 0, NULL, ICON_NONE);
1468   uiItemR(col, ptr, "sigma_space", 0, NULL, ICON_NONE);
1469 }
1470
1471 static void node_composit_buts_defocus(uiLayout *layout, bContext *C, PointerRNA *ptr)
1472 {
1473   uiLayout *sub, *col;
1474
1475   col = uiLayoutColumn(layout, false);
1476   uiItemL(col, IFACE_("Bokeh Type:"), ICON_NONE);
1477   uiItemR(col, ptr, "bokeh", 0, "", ICON_NONE);
1478   uiItemR(col, ptr, "angle", 0, NULL, ICON_NONE);
1479
1480   uiItemR(layout, ptr, "use_gamma_correction", 0, NULL, ICON_NONE);
1481
1482   col = uiLayoutColumn(layout, false);
1483   uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_zbuffer") == true);
1484   uiItemR(col, ptr, "f_stop", 0, NULL, ICON_NONE);
1485
1486   uiItemR(layout, ptr, "blur_max", 0, NULL, ICON_NONE);
1487   uiItemR(layout, ptr, "threshold", 0, NULL, ICON_NONE);
1488
1489   col = uiLayoutColumn(layout, false);
1490   uiItemR(col, ptr, "use_preview", 0, NULL, ICON_NONE);
1491
1492   uiTemplateID(layout, C, ptr, "scene", NULL, NULL, NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
1493
1494   col = uiLayoutColumn(layout, false);
1495   uiItemR(col, ptr, "use_zbuffer", 0, NULL, ICON_NONE);
1496   sub = uiLayoutColumn(col, false);
1497   uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_zbuffer") == false);
1498   uiItemR(sub, ptr, "z_scale", 0, NULL, ICON_NONE);
1499 }
1500
1501 /* qdn: glare node */
1502 static void node_composit_buts_glare(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1503 {
1504   uiItemR(layout, ptr, "glare_type", 0, "", ICON_NONE);
1505   uiItemR(layout, ptr, "quality", 0, "", ICON_NONE);
1506
1507   if (RNA_enum_get(ptr, "glare_type") != 1) {
1508     uiItemR(layout, ptr, "iterations", 0, NULL, ICON_NONE);
1509
1510     if (RNA_enum_get(ptr, "glare_type") != 0) {
1511       uiItemR(layout, ptr, "color_modulation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1512     }
1513   }
1514
1515   uiItemR(layout, ptr, "mix", 0, NULL, ICON_NONE);
1516   uiItemR(layout, ptr, "threshold", 0, NULL, ICON_NONE);
1517
1518   if (RNA_enum_get(ptr, "glare_type") == 2) {
1519     uiItemR(layout, ptr, "streaks", 0, NULL, ICON_NONE);
1520     uiItemR(layout, ptr, "angle_offset", 0, NULL, ICON_NONE);
1521   }
1522   if (RNA_enum_get(ptr, "glare_type") == 0 || RNA_enum_get(ptr, "glare_type") == 2) {
1523     uiItemR(layout, ptr, "fade", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1524
1525     if (RNA_enum_get(ptr, "glare_type") == 0) {
1526       uiItemR(layout, ptr, "use_rotate_45", 0, NULL, ICON_NONE);
1527     }
1528   }
1529   if (RNA_enum_get(ptr, "glare_type") == 1) {
1530     uiItemR(layout, ptr, "size", 0, NULL, ICON_NONE);
1531   }
1532 }
1533
1534 static void node_composit_buts_tonemap(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1535 {
1536   uiLayout *col;
1537
1538   col = uiLayoutColumn(layout, false);
1539   uiItemR(col, ptr, "tonemap_type", 0, "", ICON_NONE);
1540   if (RNA_enum_get(ptr, "tonemap_type") == 0) {
1541     uiItemR(col, ptr, "key", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1542     uiItemR(col, ptr, "offset", 0, NULL, ICON_NONE);
1543     uiItemR(col, ptr, "gamma", 0, NULL, ICON_NONE);
1544   }
1545   else {
1546     uiItemR(col, ptr, "intensity", 0, NULL, ICON_NONE);
1547     uiItemR(col, ptr, "contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1548     uiItemR(col, ptr, "adaptation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1549     uiItemR(col, ptr, "correction", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1550   }
1551 }
1552
1553 static void node_composit_buts_lensdist(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1554 {
1555   uiLayout *col;
1556
1557   col = uiLayoutColumn(layout, false);
1558   uiItemR(col, ptr, "use_projector", 0, NULL, ICON_NONE);
1559
1560   col = uiLayoutColumn(col, false);
1561   uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_projector") == false);
1562   uiItemR(col, ptr, "use_jitter", 0, NULL, ICON_NONE);
1563   uiItemR(col, ptr, "use_fit", 0, NULL, ICON_NONE);
1564 }
1565
1566 static void node_composit_buts_vecblur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1567 {
1568   uiLayout *col;
1569
1570   col = uiLayoutColumn(layout, false);
1571   uiItemR(col, ptr, "samples", 0, NULL, ICON_NONE);
1572   uiItemR(col, ptr, "factor", 0, IFACE_("Blur"), ICON_NONE);
1573
1574   col = uiLayoutColumn(layout, true);
1575   uiItemL(col, IFACE_("Speed:"), ICON_NONE);
1576   uiItemR(col, ptr, "speed_min", 0, IFACE_("Min"), ICON_NONE);
1577   uiItemR(col, ptr, "speed_max", 0, IFACE_("Max"), ICON_NONE);
1578
1579   uiItemR(layout, ptr, "use_curved", 0, NULL, ICON_NONE);
1580 }
1581
1582 static void node_composit_buts_filter(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1583 {
1584   uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
1585 }
1586
1587 static void node_composit_buts_flip(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1588 {
1589   uiItemR(layout, ptr, "axis", 0, "", ICON_NONE);
1590 }
1591
1592 static void node_composit_buts_crop(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1593 {
1594   uiLayout *col;
1595
1596   uiItemR(layout, ptr, "use_crop_size", 0, NULL, ICON_NONE);
1597   uiItemR(layout, ptr, "relative", 0, NULL, ICON_NONE);
1598
1599   col = uiLayoutColumn(layout, true);
1600   if (RNA_boolean_get(ptr, "relative")) {
1601     uiItemR(col, ptr, "rel_min_x", 0, IFACE_("Left"), ICON_NONE);
1602     uiItemR(col, ptr, "rel_max_x", 0, IFACE_("Right"), ICON_NONE);
1603     uiItemR(col, ptr, "rel_min_y", 0, IFACE_("Up"), ICON_NONE);
1604     uiItemR(col, ptr, "rel_max_y", 0, IFACE_("Down"), ICON_NONE);
1605   }
1606   else {
1607     uiItemR(col, ptr, "min_x", 0, IFACE_("Left"), ICON_NONE);
1608     uiItemR(col, ptr, "max_x", 0, IFACE_("Right"), ICON_NONE);
1609     uiItemR(col, ptr, "min_y", 0, IFACE_("Up"), ICON_NONE);
1610     uiItemR(col, ptr, "max_y", 0, IFACE_("Down"), ICON_NONE);
1611   }
1612 }
1613
1614 static void node_composit_buts_splitviewer(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1615 {
1616   uiLayout *row, *col;
1617
1618   col = uiLayoutColumn(layout, false);
1619   row = uiLayoutRow(col, false);
1620   uiItemR(row, ptr, "axis", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1621   uiItemR(col, ptr, "factor", 0, NULL, ICON_NONE);
1622 }
1623
1624 static void node_composit_buts_double_edge_mask(uiLayout *layout,
1625                                                 bContext *UNUSED(C),
1626                                                 PointerRNA *ptr)
1627 {
1628   uiLayout *col;
1629
1630   col = uiLayoutColumn(layout, false);
1631
1632   uiItemL(col, IFACE_("Inner Edge:"), ICON_NONE);
1633   uiItemR(col, ptr, "inner_mode", 0, "", ICON_NONE);
1634   uiItemL(col, IFACE_("Buffer Edge:"), ICON_NONE);
1635   uiItemR(col, ptr, "edge_mode", 0, "", ICON_NONE);
1636 }
1637
1638 static void node_composit_buts_map_range(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1639 {
1640   uiLayout *col;
1641
1642   col = uiLayoutColumn(layout, true);
1643   uiItemR(col, ptr, "use_clamp", 0, NULL, ICON_NONE);
1644 }
1645
1646 static void node_composit_buts_map_value(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1647 {
1648   uiLayout *sub, *col;
1649
1650   col = uiLayoutColumn(layout, true);
1651   uiItemR(col, ptr, "offset", 0, NULL, ICON_NONE);
1652   uiItemR(col, ptr, "size", 0, NULL, ICON_NONE);
1653
1654   col = uiLayoutColumn(layout, true);
1655   uiItemR(col, ptr, "use_min", 0, NULL, ICON_NONE);
1656   sub = uiLayoutColumn(col, false);
1657   uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_min"));
1658   uiItemR(sub, ptr, "min", 0, "", ICON_NONE);
1659
1660   col = uiLayoutColumn(layout, true);
1661   uiItemR(col, ptr, "use_max", 0, NULL, ICON_NONE);
1662   sub = uiLayoutColumn(col, false);
1663   uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_max"));
1664   uiItemR(sub, ptr, "max", 0, "", ICON_NONE);
1665 }
1666
1667 static void node_composit_buts_alphaover(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1668 {
1669   uiLayout *col;
1670
1671   col = uiLayoutColumn(layout, true);
1672   uiItemR(col, ptr, "use_premultiply", 0, NULL, ICON_NONE);
1673   uiItemR(col, ptr, "premul", 0, NULL, ICON_NONE);
1674 }
1675
1676 static void node_composit_buts_zcombine(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1677 {
1678   uiLayout *col;
1679
1680   col = uiLayoutColumn(layout, true);
1681   uiItemR(col, ptr, "use_alpha", 0, NULL, ICON_NONE);
1682   uiItemR(col, ptr, "use_antialias_z", 0, NULL, ICON_NONE);
1683 }
1684
1685 static void node_composit_buts_dilateerode(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1686 {
1687   uiItemR(layout, ptr, "mode", 0, NULL, ICON_NONE);
1688   uiItemR(layout, ptr, "distance", 0, NULL, ICON_NONE);
1689   switch (RNA_enum_get(ptr, "mode")) {
1690     case CMP_NODE_DILATEERODE_DISTANCE_THRESH:
1691       uiItemR(layout, ptr, "edge", 0, NULL, ICON_NONE);
1692       break;
1693     case CMP_NODE_DILATEERODE_DISTANCE_FEATHER:
1694       uiItemR(layout, ptr, "falloff", 0, NULL, ICON_NONE);
1695       break;
1696   }
1697 }
1698
1699 static void node_composit_buts_inpaint(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1700 {
1701   uiItemR(layout, ptr, "distance", 0, NULL, ICON_NONE);
1702 }
1703
1704 static void node_composit_buts_despeckle(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1705 {
1706   uiLayout *col;
1707
1708   col = uiLayoutColumn(layout, false);
1709   uiItemR(col, ptr, "threshold", 0, NULL, ICON_NONE);
1710   uiItemR(col, ptr, "threshold_neighbor", 0, NULL, ICON_NONE);
1711 }
1712
1713 static void node_composit_buts_diff_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1714 {
1715   uiLayout *col;
1716
1717   col = uiLayoutColumn(layout, true);
1718   uiItemR(col, ptr, "tolerance", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1719   uiItemR(col, ptr, "falloff", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1720 }
1721
1722 static void node_composit_buts_distance_matte(uiLayout *layout,
1723                                               bContext *UNUSED(C),
1724                                               PointerRNA *ptr)
1725 {
1726   uiLayout *col, *row;
1727
1728   col = uiLayoutColumn(layout, true);
1729
1730   uiItemL(layout, IFACE_("Color Space:"), ICON_NONE);
1731   row = uiLayoutRow(layout, false);
1732   uiItemR(row, ptr, "channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1733
1734   uiItemR(col, ptr, "tolerance", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1735   uiItemR(col, ptr, "falloff", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1736 }
1737
1738 static void node_composit_buts_color_spill(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1739 {
1740   uiLayout *row, *col;
1741
1742   uiItemL(layout, IFACE_("Despill Channel:"), ICON_NONE);
1743   row = uiLayoutRow(layout, false);
1744   uiItemR(row, ptr, "channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1745
1746   col = uiLayoutColumn(layout, false);
1747   uiItemR(col, ptr, "limit_method", 0, NULL, ICON_NONE);
1748
1749   if (RNA_enum_get(ptr, "limit_method") == 0) {
1750     uiItemL(col, IFACE_("Limiting Channel:"), ICON_NONE);
1751     row = uiLayoutRow(col, false);
1752     uiItemR(row, ptr, "limit_channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1753   }
1754
1755   uiItemR(col, ptr, "ratio", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1756   uiItemR(col, ptr, "use_unspill", 0, NULL, ICON_NONE);
1757   if (RNA_boolean_get(ptr, "use_unspill") == true) {
1758     uiItemR(col, ptr, "unspill_red", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1759     uiItemR(col, ptr, "unspill_green", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1760     uiItemR(col, ptr, "unspill_blue", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1761   }
1762 }
1763
1764 static void node_composit_buts_chroma_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1765 {
1766   uiLayout *col;
1767
1768   col = uiLayoutColumn(layout, false);
1769   uiItemR(col, ptr, "tolerance", 0, NULL, ICON_NONE);
1770   uiItemR(col, ptr, "threshold", 0, NULL, ICON_NONE);
1771
1772   col = uiLayoutColumn(layout, true);
1773   /*uiItemR(col, ptr, "lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);  Removed for now */
1774   uiItemR(col, ptr, "gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1775   /*uiItemR(col, ptr, "shadow_adjust", UI_ITEM_R_SLIDER, NULL, ICON_NONE);  Removed for now*/
1776 }
1777
1778 static void node_composit_buts_color_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1779 {
1780   uiLayout *col;
1781
1782   col = uiLayoutColumn(layout, true);
1783   uiItemR(col, ptr, "color_hue", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1784   uiItemR(col, ptr, "color_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1785   uiItemR(col, ptr, "color_value", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1786 }
1787
1788 static void node_composit_buts_channel_matte(uiLayout *layout,
1789                                              bContext *UNUSED(C),
1790                                              PointerRNA *ptr)
1791 {
1792   uiLayout *col, *row;
1793
1794   uiItemL(layout, IFACE_("Color Space:"), ICON_NONE);
1795   row = uiLayoutRow(layout, false);
1796   uiItemR(row, ptr, "color_space", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1797
1798   col = uiLayoutColumn(layout, false);
1799   uiItemL(col, IFACE_("Key Channel:"), ICON_NONE);
1800   row = uiLayoutRow(col, false);
1801   uiItemR(row, ptr, "matte_channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1802
1803   col = uiLayoutColumn(layout, false);
1804
1805   uiItemR(col, ptr, "limit_method", 0, NULL, ICON_NONE);
1806   if (RNA_enum_get(ptr, "limit_method") == 0) {
1807     uiItemL(col, IFACE_("Limiting Channel:"), ICON_NONE);
1808     row = uiLayoutRow(col, false);
1809     uiItemR(row, ptr, "limit_channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1810   }
1811
1812   uiItemR(col, ptr, "limit_max", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1813   uiItemR(col, ptr, "limit_min", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1814 }
1815
1816 static void node_composit_buts_luma_matte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1817 {
1818   uiLayout *col;
1819
1820   col = uiLayoutColumn(layout, true);
1821   uiItemR(col, ptr, "limit_max", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1822   uiItemR(col, ptr, "limit_min", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
1823 }
1824
1825 static void node_composit_buts_map_uv(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1826 {
1827   uiItemR(layout, ptr, "alpha", 0, NULL, ICON_NONE);
1828 }
1829
1830 static void node_composit_buts_id_mask(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1831 {
1832   uiItemR(layout, ptr, "index", 0, NULL, ICON_NONE);
1833   uiItemR(layout, ptr, "use_antialiasing", 0, NULL, ICON_NONE);
1834 }
1835
1836 static void node_composit_buts_file_output(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1837 {
1838   PointerRNA imfptr = RNA_pointer_get(ptr, "format");
1839   const bool multilayer = RNA_enum_get(&imfptr, "file_format") == R_IMF_IMTYPE_MULTILAYER;
1840
1841   if (multilayer) {
1842     uiItemL(layout, IFACE_("Path:"), ICON_NONE);
1843   }
1844   else {
1845     uiItemL(layout, IFACE_("Base Path:"), ICON_NONE);
1846   }
1847   uiItemR(layout, ptr, "base_path", 0, "", ICON_NONE);
1848 }
1849 static void node_composit_buts_file_output_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
1850 {
1851   Scene *scene = CTX_data_scene(C);
1852   PointerRNA imfptr = RNA_pointer_get(ptr, "format");
1853   PointerRNA active_input_ptr, op_ptr;
1854   wmOperatorType *ot;
1855   uiLayout *row, *col;
1856   int active_index;
1857   const bool multilayer = RNA_enum_get(&imfptr, "file_format") == R_IMF_IMTYPE_MULTILAYER;
1858   const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
1859
1860   node_composit_buts_file_output(layout, C, ptr);
1861   uiTemplateImageSettings(layout, &imfptr, false);
1862
1863   /* disable stereo output for multilayer, too much work for something that no one will use */
1864   /* if someone asks for that we can implement it */
1865   if (is_multiview) {
1866     uiTemplateImageFormatViews(layout, &imfptr, NULL);
1867   }
1868
1869   uiItemS(layout);
1870
1871   uiItemO(layout, IFACE_("Add Input"), ICON_ADD, "NODE_OT_output_file_add_socket");
1872
1873   row = uiLayoutRow(layout, false);
1874   col = uiLayoutColumn(row, true);
1875
1876   active_index = RNA_int_get(ptr, "active_input_index");
1877   /* using different collection properties if multilayer format is enabled */
1878   if (multilayer) {
1879     uiTemplateList(col,
1880                    C,
1881                    "UI_UL_list",
1882                    "file_output_node",
1883                    ptr,
1884                    "layer_slots",
1885                    ptr,
1886                    "active_input_index",
1887                    NULL,
1888                    0,
1889                    0,
1890                    0,
1891                    0,
1892                    false,
1893                    false);
1894     RNA_property_collection_lookup_int(
1895         ptr, RNA_struct_find_property(ptr, "layer_slots"), active_index, &active_input_ptr);
1896   }
1897   else {
1898     uiTemplateList(col,
1899                    C,
1900                    "UI_UL_list",
1901                    "file_output_node",
1902                    ptr,
1903                    "file_slots",
1904                    ptr,
1905                    "active_input_index",
1906                    NULL,
1907                    0,
1908                    0,
1909                    0,
1910                    0,
1911                    false,
1912                    false);
1913     RNA_property_collection_lookup_int(
1914         ptr, RNA_struct_find_property(ptr, "file_slots"), active_index, &active_input_ptr);
1915   }
1916   /* XXX collection lookup does not return the ID part of the pointer,
1917    * setting this manually here */
1918   active_input_ptr.owner_id = ptr->owner_id;
1919
1920   col = uiLayoutColumn(row, true);
1921   ot = WM_operatortype_find("NODE_OT_output_file_move_active_socket", false);
1922   uiItemFullO_ptr(col, ot, "", ICON_TRIA_UP, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
1923   RNA_enum_set(&op_ptr, "direction", 1);
1924   uiItemFullO_ptr(col, ot, "", ICON_TRIA_DOWN, NULL, WM_OP_INVOKE_DEFAULT, 0, &op_ptr);
1925   RNA_enum_set(&op_ptr, "direction", 2);
1926
1927   if (active_input_ptr.data) {
1928     if (multilayer) {
1929       col = uiLayoutColumn(layout, true);
1930
1931       uiItemL(col, IFACE_("Layer:"), ICON_NONE);
1932       row = uiLayoutRow(col, false);
1933       uiItemR(row, &active_input_ptr, "name", 0, "", ICON_NONE);
1934       uiItemFullO(row,
1935                   "NODE_OT_output_file_remove_active_socket",
1936                   "",
1937                   ICON_X,
1938                   NULL,
1939                   WM_OP_EXEC_DEFAULT,
1940                   UI_ITEM_R_ICON_ONLY,
1941                   NULL);
1942     }
1943     else {
1944       col = uiLayoutColumn(layout, true);
1945
1946       uiItemL(col, IFACE_("File Subpath:"), ICON_NONE);
1947       row = uiLayoutRow(col, false);
1948       uiItemR(row, &active_input_ptr, "path", 0, "", ICON_NONE);
1949       uiItemFullO(row,
1950                   "NODE_OT_output_file_remove_active_socket",
1951                   "",
1952                   ICON_X,
1953                   NULL,
1954                   WM_OP_EXEC_DEFAULT,
1955                   UI_ITEM_R_ICON_ONLY,
1956                   NULL);
1957
1958       /* format details for individual files */
1959       imfptr = RNA_pointer_get(&active_input_ptr, "format");
1960
1961       col = uiLayoutColumn(layout, true);
1962       uiItemL(col, IFACE_("Format:"), ICON_NONE);
1963       uiItemR(col, &active_input_ptr, "use_node_format", 0, NULL, ICON_NONE);
1964
1965       col = uiLayoutColumn(layout, false);
1966       uiLayoutSetActive(col, RNA_boolean_get(&active_input_ptr, "use_node_format") == false);
1967       uiTemplateImageSettings(col, &imfptr, false);
1968
1969       if (is_multiview) {
1970         uiTemplateImageFormatViews(layout, &imfptr, NULL);
1971       }
1972     }
1973   }
1974 }
1975
1976 static void node_composit_buts_scale(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1977 {
1978   uiItemR(layout, ptr, "space", 0, "", ICON_NONE);
1979
1980   if (RNA_enum_get(ptr, "space") == CMP_SCALE_RENDERPERCENT) {
1981     uiLayout *row;
1982     uiItemR(layout, ptr, "frame_method", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
1983     row = uiLayoutRow(layout, true);
1984     uiItemR(row, ptr, "offset_x", 0, "X", ICON_NONE);
1985     uiItemR(row, ptr, "offset_y", 0, "Y", ICON_NONE);
1986   }
1987 }
1988
1989 static void node_composit_buts_rotate(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1990 {
1991   uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
1992 }
1993
1994 static void node_composit_buts_invert(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
1995 {
1996   uiLayout *col;
1997
1998   col = uiLayoutColumn(layout, false);
1999   uiItemR(col, ptr, "invert_rgb", 0, NULL, ICON_NONE);
2000   uiItemR(col, ptr, "invert_alpha", 0, NULL, ICON_NONE);
2001 }
2002
2003 static void node_composit_buts_premulkey(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2004 {
2005   uiItemR(layout, ptr, "mapping", 0, "", ICON_NONE);
2006 }
2007
2008 static void node_composit_buts_view_levels(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2009 {
2010   uiItemR(layout, ptr, "channel", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2011 }
2012
2013 static void node_composit_buts_colorbalance(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2014 {
2015   uiLayout *split, *col, *row;
2016
2017   uiItemR(layout, ptr, "correction_method", 0, NULL, ICON_NONE);
2018
2019   if (RNA_enum_get(ptr, "correction_method") == 0) {
2020
2021     split = uiLayoutSplit(layout, 0.0f, false);
2022     col = uiLayoutColumn(split, false);
2023     uiTemplateColorPicker(col, ptr, "lift", 1, 1, 0, 1);
2024     row = uiLayoutRow(col, false);
2025     uiItemR(row, ptr, "lift", 0, NULL, ICON_NONE);
2026
2027     col = uiLayoutColumn(split, false);
2028     uiTemplateColorPicker(col, ptr, "gamma", 1, 1, 1, 1);
2029     row = uiLayoutRow(col, false);
2030     uiItemR(row, ptr, "gamma", 0, NULL, ICON_NONE);
2031
2032     col = uiLayoutColumn(split, false);
2033     uiTemplateColorPicker(col, ptr, "gain", 1, 1, 1, 1);
2034     row = uiLayoutRow(col, false);
2035     uiItemR(row, ptr, "gain", 0, NULL, ICON_NONE);
2036   }
2037   else {
2038
2039     split = uiLayoutSplit(layout, 0.0f, false);
2040     col = uiLayoutColumn(split, false);
2041     uiTemplateColorPicker(col, ptr, "offset", 1, 1, 0, 1);
2042     row = uiLayoutRow(col, false);
2043     uiItemR(row, ptr, "offset", 0, NULL, ICON_NONE);
2044     uiItemR(col, ptr, "offset_basis", 0, NULL, ICON_NONE);
2045
2046     col = uiLayoutColumn(split, false);
2047     uiTemplateColorPicker(col, ptr, "power", 1, 1, 0, 1);
2048     row = uiLayoutRow(col, false);
2049     uiItemR(row, ptr, "power", 0, NULL, ICON_NONE);
2050
2051     col = uiLayoutColumn(split, false);
2052     uiTemplateColorPicker(col, ptr, "slope", 1, 1, 0, 1);
2053     row = uiLayoutRow(col, false);
2054     uiItemR(row, ptr, "slope", 0, NULL, ICON_NONE);
2055   }
2056 }
2057 static void node_composit_buts_colorbalance_ex(uiLayout *layout,
2058                                                bContext *UNUSED(C),
2059                                                PointerRNA *ptr)
2060 {
2061   uiItemR(layout, ptr, "correction_method", 0, NULL, ICON_NONE);
2062
2063   if (RNA_enum_get(ptr, "correction_method") == 0) {
2064
2065     uiTemplateColorPicker(layout, ptr, "lift", 1, 1, 0, 1);
2066     uiItemR(layout, ptr, "lift", 0, NULL, ICON_NONE);
2067
2068     uiTemplateColorPicker(layout, ptr, "gamma", 1, 1, 1, 1);
2069     uiItemR(layout, ptr, "gamma", 0, NULL, ICON_NONE);
2070
2071     uiTemplateColorPicker(layout, ptr, "gain", 1, 1, 1, 1);
2072     uiItemR(layout, ptr, "gain", 0, NULL, ICON_NONE);
2073   }
2074   else {
2075     uiTemplateColorPicker(layout, ptr, "offset", 1, 1, 0, 1);
2076     uiItemR(layout, ptr, "offset", 0, NULL, ICON_NONE);
2077
2078     uiTemplateColorPicker(layout, ptr, "power", 1, 1, 0, 1);
2079     uiItemR(layout, ptr, "power", 0, NULL, ICON_NONE);
2080
2081     uiTemplateColorPicker(layout, ptr, "slope", 1, 1, 0, 1);
2082     uiItemR(layout, ptr, "slope", 0, NULL, ICON_NONE);
2083   }
2084 }
2085
2086 static void node_composit_buts_huecorrect(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2087 {
2088   bNode *node = ptr->data;
2089   CurveMapping *cumap = node->storage;
2090
2091   if (_sample_col[0] != SAMPLE_FLT_ISNONE) {
2092     cumap->flag |= CUMA_DRAW_SAMPLE;
2093     copy_v3_v3(cumap->sample, _sample_col);
2094   }
2095   else {
2096     cumap->flag &= ~CUMA_DRAW_SAMPLE;
2097   }
2098
2099   uiTemplateCurveMapping(layout, ptr, "mapping", 'h', false, false, false, false);
2100 }
2101
2102 static void node_composit_buts_ycc(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2103 {
2104   uiItemR(layout, ptr, "mode", 0, "", ICON_NONE);
2105 }
2106
2107 static void node_composit_buts_movieclip(uiLayout *layout, bContext *C, PointerRNA *ptr)
2108 {
2109   uiTemplateID(
2110       layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2111 }
2112
2113 static void node_composit_buts_movieclip_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
2114 {
2115   bNode *node = ptr->data;
2116   PointerRNA clipptr;
2117
2118   uiTemplateID(
2119       layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2120
2121   if (!node->id) {
2122     return;
2123   }
2124
2125   clipptr = RNA_pointer_get(ptr, "clip");
2126
2127   uiTemplateColorspaceSettings(layout, &clipptr, "colorspace_settings");
2128 }
2129
2130 static void node_composit_buts_stabilize2d(uiLayout *layout, bContext *C, PointerRNA *ptr)
2131 {
2132   bNode *node = ptr->data;
2133
2134   uiTemplateID(
2135       layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2136
2137   if (!node->id) {
2138     return;
2139   }
2140
2141   uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
2142   uiItemR(layout, ptr, "invert", 0, NULL, ICON_NONE);
2143 }
2144
2145 static void node_composit_buts_translate(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2146 {
2147   uiItemR(layout, ptr, "use_relative", 0, NULL, ICON_NONE);
2148   uiItemR(layout, ptr, "wrap_axis", 0, NULL, ICON_NONE);
2149 }
2150
2151 static void node_composit_buts_transform(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2152 {
2153   uiItemR(layout, ptr, "filter_type", 0, "", ICON_NONE);
2154 }
2155
2156 static void node_composit_buts_moviedistortion(uiLayout *layout, bContext *C, PointerRNA *ptr)
2157 {
2158   bNode *node = ptr->data;
2159
2160   uiTemplateID(
2161       layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2162
2163   if (!node->id) {
2164     return;
2165   }
2166
2167   uiItemR(layout, ptr, "distortion_type", 0, "", ICON_NONE);
2168 }
2169
2170 static void node_composit_buts_colorcorrection(uiLayout *layout,
2171                                                bContext *UNUSED(C),
2172                                                PointerRNA *ptr)
2173 {
2174   uiLayout *row;
2175
2176   row = uiLayoutRow(layout, false);
2177   uiItemR(row, ptr, "red", 0, NULL, ICON_NONE);
2178   uiItemR(row, ptr, "green", 0, NULL, ICON_NONE);
2179   uiItemR(row, ptr, "blue", 0, NULL, ICON_NONE);
2180
2181   row = uiLayoutRow(layout, false);
2182   uiItemL(row, "", ICON_NONE);
2183   uiItemL(row, IFACE_("Saturation"), ICON_NONE);
2184   uiItemL(row, IFACE_("Contrast"), ICON_NONE);
2185   uiItemL(row, IFACE_("Gamma"), ICON_NONE);
2186   uiItemL(row, IFACE_("Gain"), ICON_NONE);
2187   uiItemL(row, IFACE_("Lift"), ICON_NONE);
2188
2189   row = uiLayoutRow(layout, false);
2190   uiItemL(row, IFACE_("Master"), ICON_NONE);
2191   uiItemR(row, ptr, "master_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2192   uiItemR(row, ptr, "master_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2193   uiItemR(row, ptr, "master_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2194   uiItemR(row, ptr, "master_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2195   uiItemR(row, ptr, "master_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2196
2197   row = uiLayoutRow(layout, false);
2198   uiItemL(row, IFACE_("Highlights"), ICON_NONE);
2199   uiItemR(row, ptr, "highlights_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2200   uiItemR(row, ptr, "highlights_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2201   uiItemR(row, ptr, "highlights_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2202   uiItemR(row, ptr, "highlights_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2203   uiItemR(row, ptr, "highlights_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2204
2205   row = uiLayoutRow(layout, false);
2206   uiItemL(row, IFACE_("Midtones"), ICON_NONE);
2207   uiItemR(row, ptr, "midtones_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2208   uiItemR(row, ptr, "midtones_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2209   uiItemR(row, ptr, "midtones_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2210   uiItemR(row, ptr, "midtones_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2211   uiItemR(row, ptr, "midtones_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2212
2213   row = uiLayoutRow(layout, false);
2214   uiItemL(row, IFACE_("Shadows"), ICON_NONE);
2215   uiItemR(row, ptr, "shadows_saturation", UI_ITEM_R_SLIDER, "", ICON_NONE);
2216   uiItemR(row, ptr, "shadows_contrast", UI_ITEM_R_SLIDER, "", ICON_NONE);
2217   uiItemR(row, ptr, "shadows_gamma", UI_ITEM_R_SLIDER, "", ICON_NONE);
2218   uiItemR(row, ptr, "shadows_gain", UI_ITEM_R_SLIDER, "", ICON_NONE);
2219   uiItemR(row, ptr, "shadows_lift", UI_ITEM_R_SLIDER, "", ICON_NONE);
2220
2221   row = uiLayoutRow(layout, false);
2222   uiItemR(row, ptr, "midtones_start", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2223   uiItemR(row, ptr, "midtones_end", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2224 }
2225
2226 static void node_composit_buts_colorcorrection_ex(uiLayout *layout,
2227                                                   bContext *UNUSED(C),
2228                                                   PointerRNA *ptr)
2229 {
2230   uiLayout *row;
2231
2232   row = uiLayoutRow(layout, false);
2233   uiItemR(row, ptr, "red", 0, NULL, ICON_NONE);
2234   uiItemR(row, ptr, "green", 0, NULL, ICON_NONE);
2235   uiItemR(row, ptr, "blue", 0, NULL, ICON_NONE);
2236   row = layout;
2237   uiItemL(row, IFACE_("Saturation"), ICON_NONE);
2238   uiItemR(row, ptr, "master_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2239   uiItemR(row, ptr, "highlights_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2240   uiItemR(row, ptr, "midtones_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2241   uiItemR(row, ptr, "shadows_saturation", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2242
2243   uiItemL(row, IFACE_("Contrast"), ICON_NONE);
2244   uiItemR(row, ptr, "master_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2245   uiItemR(row, ptr, "highlights_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2246   uiItemR(row, ptr, "midtones_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2247   uiItemR(row, ptr, "shadows_contrast", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2248
2249   uiItemL(row, IFACE_("Gamma"), ICON_NONE);
2250   uiItemR(row, ptr, "master_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2251   uiItemR(row, ptr, "highlights_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2252   uiItemR(row, ptr, "midtones_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2253   uiItemR(row, ptr, "shadows_gamma", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2254
2255   uiItemL(row, IFACE_("Gain"), ICON_NONE);
2256   uiItemR(row, ptr, "master_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2257   uiItemR(row, ptr, "highlights_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2258   uiItemR(row, ptr, "midtones_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2259   uiItemR(row, ptr, "shadows_gain", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2260
2261   uiItemL(row, IFACE_("Lift"), ICON_NONE);
2262   uiItemR(row, ptr, "master_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2263   uiItemR(row, ptr, "highlights_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2264   uiItemR(row, ptr, "midtones_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2265   uiItemR(row, ptr, "shadows_lift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2266
2267   row = uiLayoutRow(layout, false);
2268   uiItemR(row, ptr, "midtones_start", 0, NULL, ICON_NONE);
2269   uiItemR(row, ptr, "midtones_end", 0, NULL, ICON_NONE);
2270 }
2271
2272 static void node_composit_buts_switch(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2273 {
2274   uiItemR(layout, ptr, "check", 0, NULL, ICON_NONE);
2275 }
2276
2277 static void node_composit_buts_switch_view_ex(uiLayout *layout,
2278                                               bContext *UNUSED(C),
2279                                               PointerRNA *UNUSED(ptr))
2280 {
2281   uiItemFullO(layout,
2282               "NODE_OT_switch_view_update",
2283               "Update Views",
2284               ICON_FILE_REFRESH,
2285               NULL,
2286               WM_OP_INVOKE_DEFAULT,
2287               0,
2288               NULL);
2289 }
2290
2291 static void node_composit_buts_boxmask(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2292 {
2293   uiLayout *row;
2294
2295   row = uiLayoutRow(layout, true);
2296   uiItemR(row, ptr, "x", 0, NULL, ICON_NONE);
2297   uiItemR(row, ptr, "y", 0, NULL, ICON_NONE);
2298
2299   row = uiLayoutRow(layout, true);
2300   uiItemR(row, ptr, "width", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2301   uiItemR(row, ptr, "height", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2302
2303   uiItemR(layout, ptr, "rotation", 0, NULL, ICON_NONE);
2304   uiItemR(layout, ptr, "mask_type", 0, NULL, ICON_NONE);
2305 }
2306
2307 static void node_composit_buts_bokehimage(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2308 {
2309   uiItemR(layout, ptr, "flaps", 0, NULL, ICON_NONE);
2310   uiItemR(layout, ptr, "angle", 0, NULL, ICON_NONE);
2311   uiItemR(layout, ptr, "rounding", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2312   uiItemR(layout, ptr, "catadioptric", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2313   uiItemR(layout, ptr, "shift", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2314 }
2315
2316 static void node_composit_buts_bokehblur(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2317 {
2318   uiItemR(layout, ptr, "use_variable_size", 0, NULL, ICON_NONE);
2319   // uiItemR(layout, ptr, "f_stop", 0, NULL, ICON_NONE);  // UNUSED
2320   uiItemR(layout, ptr, "blur_max", 0, NULL, ICON_NONE);
2321   uiItemR(layout, ptr, "use_extended_bounds", 0, NULL, ICON_NONE);
2322 }
2323
2324 static void node_composit_backdrop_viewer(
2325     SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
2326 {
2327   //  node_composit_backdrop_canvas(snode, backdrop, node, x, y);
2328   if (node->custom1 == 0) {
2329     const float backdropWidth = backdrop->x;
2330     const float backdropHeight = backdrop->y;
2331     const float cx = x + snode->zoom * backdropWidth * node->custom3;
2332     const float cy = y + snode->zoom * backdropHeight * node->custom4;
2333     const float cross_size = 12 * U.pixelsize;
2334
2335     GPUVertFormat *format = immVertexFormat();
2336     uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2337
2338     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2339
2340     immUniformColor3f(1.0f, 1.0f, 1.0f);
2341
2342     immBegin(GPU_PRIM_LINES, 4);
2343     immVertex2f(pos, cx - cross_size, cy - cross_size);
2344     immVertex2f(pos, cx + cross_size, cy + cross_size);
2345     immVertex2f(pos, cx + cross_size, cy - cross_size);
2346     immVertex2f(pos, cx - cross_size, cy + cross_size);
2347     immEnd();
2348
2349     immUnbindProgram();
2350   }
2351 }
2352
2353 static void node_composit_backdrop_boxmask(
2354     SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
2355 {
2356   NodeBoxMask *boxmask = node->storage;
2357   const float backdropWidth = backdrop->x;
2358   const float backdropHeight = backdrop->y;
2359   const float aspect = backdropWidth / backdropHeight;
2360   const float rad = -boxmask->rotation;
2361   const float cosine = cosf(rad);
2362   const float sine = sinf(rad);
2363   const float halveBoxWidth = backdropWidth * (boxmask->width / 2.0f);
2364   const float halveBoxHeight = backdropHeight * (boxmask->height / 2.0f) * aspect;
2365
2366   float cx, cy, x1, x2, x3, x4;
2367   float y1, y2, y3, y4;
2368
2369   cx = x + snode->zoom * backdropWidth * boxmask->x;
2370   cy = y + snode->zoom * backdropHeight * boxmask->y;
2371
2372   x1 = cx - (cosine * halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2373   x2 = cx - (cosine * -halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2374   x3 = cx - (cosine * -halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2375   x4 = cx - (cosine * halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2376   y1 = cy - (-sine * halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2377   y2 = cy - (-sine * -halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2378   y3 = cy - (-sine * -halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2379   y4 = cy - (-sine * halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2380
2381   GPUVertFormat *format = immVertexFormat();
2382   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2383
2384   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2385
2386   immUniformColor3f(1.0f, 1.0f, 1.0f);
2387
2388   immBegin(GPU_PRIM_LINE_LOOP, 4);
2389   immVertex2f(pos, x1, y1);
2390   immVertex2f(pos, x2, y2);
2391   immVertex2f(pos, x3, y3);
2392   immVertex2f(pos, x4, y4);
2393   immEnd();
2394
2395   immUnbindProgram();
2396 }
2397
2398 static void node_composit_backdrop_ellipsemask(
2399     SpaceNode *snode, ImBuf *backdrop, bNode *node, int x, int y)
2400 {
2401   NodeEllipseMask *ellipsemask = node->storage;
2402   const float backdropWidth = backdrop->x;
2403   const float backdropHeight = backdrop->y;
2404   const float aspect = backdropWidth / backdropHeight;
2405   const float rad = -ellipsemask->rotation;
2406   const float cosine = cosf(rad);
2407   const float sine = sinf(rad);
2408   const float halveBoxWidth = backdropWidth * (ellipsemask->width / 2.0f);
2409   const float halveBoxHeight = backdropHeight * (ellipsemask->height / 2.0f) * aspect;
2410
2411   float cx, cy, x1, x2, x3, x4;
2412   float y1, y2, y3, y4;
2413
2414   cx = x + snode->zoom * backdropWidth * ellipsemask->x;
2415   cy = y + snode->zoom * backdropHeight * ellipsemask->y;
2416
2417   x1 = cx - (cosine * halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2418   x2 = cx - (cosine * -halveBoxWidth + sine * halveBoxHeight) * snode->zoom;
2419   x3 = cx - (cosine * -halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2420   x4 = cx - (cosine * halveBoxWidth + sine * -halveBoxHeight) * snode->zoom;
2421   y1 = cy - (-sine * halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2422   y2 = cy - (-sine * -halveBoxWidth + cosine * halveBoxHeight) * snode->zoom;
2423   y3 = cy - (-sine * -halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2424   y4 = cy - (-sine * halveBoxWidth + cosine * -halveBoxHeight) * snode->zoom;
2425
2426   GPUVertFormat *format = immVertexFormat();
2427   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2428
2429   immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2430
2431   immUniformColor3f(1.0f, 1.0f, 1.0f);
2432
2433   immBegin(GPU_PRIM_LINE_LOOP, 4);
2434   immVertex2f(pos, x1, y1);
2435   immVertex2f(pos, x2, y2);
2436   immVertex2f(pos, x3, y3);
2437   immVertex2f(pos, x4, y4);
2438   immEnd();
2439
2440   immUnbindProgram();
2441 }
2442
2443 static void node_composit_buts_ellipsemask(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2444 {
2445   uiLayout *row;
2446   row = uiLayoutRow(layout, true);
2447   uiItemR(row, ptr, "x", 0, NULL, ICON_NONE);
2448   uiItemR(row, ptr, "y", 0, NULL, ICON_NONE);
2449   row = uiLayoutRow(layout, true);
2450   uiItemR(row, ptr, "width", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2451   uiItemR(row, ptr, "height", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2452
2453   uiItemR(layout, ptr, "rotation", 0, NULL, ICON_NONE);
2454   uiItemR(layout, ptr, "mask_type", 0, NULL, ICON_NONE);
2455 }
2456
2457 static void node_composit_buts_composite(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2458 {
2459   uiItemR(layout, ptr, "use_alpha", 0, NULL, ICON_NONE);
2460 }
2461
2462 static void node_composit_buts_viewer(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2463 {
2464   uiItemR(layout, ptr, "use_alpha", 0, NULL, ICON_NONE);
2465 }
2466
2467 static void node_composit_buts_viewer_ex(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2468 {
2469   uiLayout *col;
2470
2471   uiItemR(layout, ptr, "use_alpha", 0, NULL, ICON_NONE);
2472   uiItemR(layout, ptr, "tile_order", 0, NULL, ICON_NONE);
2473   if (RNA_enum_get(ptr, "tile_order") == 0) {
2474     col = uiLayoutColumn(layout, true);
2475     uiItemR(col, ptr, "center_x", 0, NULL, ICON_NONE);
2476     uiItemR(col, ptr, "center_y", 0, NULL, ICON_NONE);
2477   }
2478 }
2479
2480 static void node_composit_buts_mask(uiLayout *layout, bContext *C, PointerRNA *ptr)
2481 {
2482   bNode *node = ptr->data;
2483
2484   uiTemplateID(layout, C, ptr, "mask", NULL, NULL, NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2485   uiItemR(layout, ptr, "use_feather", 0, NULL, ICON_NONE);
2486
2487   uiItemR(layout, ptr, "size_source", 0, "", ICON_NONE);
2488
2489   if (node->custom1 & (CMP_NODEFLAG_MASK_FIXED | CMP_NODEFLAG_MASK_FIXED_SCENE)) {
2490     uiItemR(layout, ptr, "size_x", 0, NULL, ICON_NONE);
2491     uiItemR(layout, ptr, "size_y", 0, NULL, ICON_NONE);
2492   }
2493
2494   uiItemR(layout, ptr, "use_motion_blur", 0, NULL, ICON_NONE);
2495   if (node->custom1 & CMP_NODEFLAG_MASK_MOTION_BLUR) {
2496     uiItemR(layout, ptr, "motion_blur_samples", 0, NULL, ICON_NONE);
2497     uiItemR(layout, ptr, "motion_blur_shutter", 0, NULL, ICON_NONE);
2498   }
2499 }
2500
2501 static void node_composit_buts_keyingscreen(uiLayout *layout, bContext *C, PointerRNA *ptr)
2502 {
2503   bNode *node = ptr->data;
2504
2505   uiTemplateID(layout, C, ptr, "clip", NULL, NULL, NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2506
2507   if (node->id) {
2508     MovieClip *clip = (MovieClip *)node->id;
2509     uiLayout *col;
2510     PointerRNA tracking_ptr;
2511
2512     RNA_pointer_create(&clip->id, &RNA_MovieTracking, &clip->tracking, &tracking_ptr);
2513
2514     col = uiLayoutColumn(layout, true);
2515     uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
2516   }
2517 }
2518
2519 static void node_composit_buts_keying(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2520 {
2521   /* bNode *node = ptr->data; */ /* UNUSED */
2522
2523   uiItemR(layout, ptr, "blur_pre", 0, NULL, ICON_NONE);
2524   uiItemR(layout, ptr, "screen_balance", 0, NULL, ICON_NONE);
2525   uiItemR(layout, ptr, "despill_factor", 0, NULL, ICON_NONE);
2526   uiItemR(layout, ptr, "despill_balance", 0, NULL, ICON_NONE);
2527   uiItemR(layout, ptr, "edge_kernel_radius", 0, NULL, ICON_NONE);
2528   uiItemR(layout, ptr, "edge_kernel_tolerance", 0, NULL, ICON_NONE);
2529   uiItemR(layout, ptr, "clip_black", 0, NULL, ICON_NONE);
2530   uiItemR(layout, ptr, "clip_white", 0, NULL, ICON_NONE);
2531   uiItemR(layout, ptr, "dilate_distance", 0, NULL, ICON_NONE);
2532   uiItemR(layout, ptr, "feather_falloff", 0, NULL, ICON_NONE);
2533   uiItemR(layout, ptr, "feather_distance", 0, NULL, ICON_NONE);
2534   uiItemR(layout, ptr, "blur_post", 0, NULL, ICON_NONE);
2535 }
2536
2537 static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRNA *ptr)
2538 {
2539   bNode *node = ptr->data;
2540
2541   uiTemplateID(
2542       layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2543
2544   if (node->id) {
2545     MovieClip *clip = (MovieClip *)node->id;
2546     MovieTracking *tracking = &clip->tracking;
2547     MovieTrackingObject *object;
2548     uiLayout *col;
2549     PointerRNA tracking_ptr;
2550     NodeTrackPosData *data = node->storage;
2551
2552     RNA_pointer_create(&clip->id, &RNA_MovieTracking, tracking, &tracking_ptr);
2553
2554     col = uiLayoutColumn(layout, false);
2555     uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
2556
2557     object = BKE_tracking_object_get_named(tracking, data->tracking_object);
2558     if (object) {
2559       PointerRNA object_ptr;
2560
2561       RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr);
2562
2563       uiItemPointerR(col, ptr, "track_name", &object_ptr, "tracks", "", ICON_ANIM_DATA);
2564     }
2565     else {
2566       uiItemR(layout, ptr, "track_name", 0, "", ICON_ANIM_DATA);
2567     }
2568
2569     uiItemR(layout, ptr, "position", 0, NULL, ICON_NONE);
2570
2571     if (ELEM(node->custom1, CMP_TRACKPOS_RELATIVE_FRAME, CMP_TRACKPOS_ABSOLUTE_FRAME)) {
2572       uiItemR(layout, ptr, "frame_relative", 0, NULL, ICON_NONE);
2573     }
2574   }
2575 }
2576
2577 static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, PointerRNA *ptr)
2578 {
2579   bNode *node = ptr->data;
2580   NodePlaneTrackDeformData *data = node->storage;
2581
2582   uiTemplateID(
2583       layout, C, ptr, "clip", NULL, "CLIP_OT_open", NULL, UI_TEMPLATE_ID_FILTER_ALL, false);
2584
2585   if (node->id) {
2586     MovieClip *clip = (MovieClip *)node->id;
2587     MovieTracking *tracking = &clip->tracking;
2588     MovieTrackingObject *object;
2589     uiLayout *col;
2590     PointerRNA tracking_ptr;
2591
2592     RNA_pointer_create(&clip->id, &RNA_MovieTracking, tracking, &tracking_ptr);
2593
2594     col = uiLayoutColumn(layout, false);
2595     uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
2596
2597     object = BKE_tracking_object_get_named(tracking, data->tracking_object);
2598     if (object) {
2599       PointerRNA object_ptr;
2600
2601       RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr);
2602
2603       uiItemPointerR(
2604           col, ptr, "plane_track_name", &object_ptr, "plane_tracks", "", ICON_ANIM_DATA);
2605     }
2606     else {
2607       uiItemR(layout, ptr, "plane_track_name", 0, "", ICON_ANIM_DATA);
2608     }
2609   }
2610
2611   uiItemR(layout, ptr, "use_motion_blur", 0, NULL, ICON_NONE);
2612   if (data->flag & CMP_NODEFLAG_PLANETRACKDEFORM_MOTION_BLUR) {
2613     uiItemR(layout, ptr, "motion_blur_samples", 0, NULL, ICON_NONE);
2614     uiItemR(layout, ptr, "motion_blur_shutter", 0, NULL, ICON_NONE);
2615   }
2616 }
2617
2618 static void node_composit_buts_cornerpin(uiLayout *UNUSED(layout),
2619                                          bContext *UNUSED(C),
2620                                          PointerRNA *UNUSED(ptr))
2621 {
2622 }
2623
2624 static void node_composit_buts_sunbeams(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2625 {
2626   uiItemR(layout, ptr, "source", UI_ITEM_R_EXPAND, "", ICON_NONE);
2627   uiItemR(layout, ptr, "ray_length", UI_ITEM_R_SLIDER, NULL, ICON_NONE);
2628 }
2629
2630 static void node_composit_buts_cryptomatte(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2631 {
2632   uiLayout *col = uiLayoutColumn(layout, true);
2633
2634   uiItemL(col, IFACE_("Matte Objects:"), ICON_NONE);
2635
2636   uiLayout *row = uiLayoutRow(col, true);
2637   uiTemplateCryptoPicker(row, ptr, "add");
2638   uiTemplateCryptoPicker(row, ptr, "remove");
2639
2640   uiItemR(col, ptr, "matte_id", 0, "", ICON_NONE);
2641 }
2642
2643 static void node_composit_buts_cryptomatte_ex(uiLayout *layout,
2644                                               bContext *UNUSED(C),
2645                                               PointerRNA *UNUSED(ptr))
2646 {
2647   uiItemO(layout, IFACE_("Add Crypto Layer"), ICON_ADD, "NODE_OT_cryptomatte_layer_add");
2648   uiItemO(layout, IFACE_("Remove Crypto Layer"), ICON_REMOVE, "NODE_OT_cryptomatte_layer_remove");
2649 }
2650
2651 static void node_composit_buts_brightcontrast(uiLayout *layout,
2652                                               bContext *UNUSED(C),
2653                                               PointerRNA *ptr)
2654 {
2655   uiItemR(layout, ptr, "use_premultiply", 0, NULL, ICON_NONE);
2656 }
2657
2658 static void node_composit_buts_denoise(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2659 {
2660 #ifndef WITH_OPENIMAGEDENOISE
2661   uiItemL(layout, IFACE_("Disabled, built without OpenImageDenoise"), ICON_ERROR);
2662 #else
2663   if (!BLI_cpu_support_sse41()) {
2664     uiItemL(layout, IFACE_("Disabled, CPU with SSE4.1 is required"), ICON_ERROR);
2665   }
2666 #endif
2667
2668   uiItemR(layout, ptr, "use_hdr", 0, NULL, ICON_NONE);
2669 }
2670
2671 /* only once called */
2672 static void node_composit_set_butfunc(bNodeType *ntype)
2673 {
2674   switch (ntype->type) {
2675     case CMP_NODE_IMAGE:
2676       ntype->draw_buttons = node_composit_buts_image;
2677       ntype->draw_buttons_ex = node_composit_buts_image_ex;
2678       break;
2679     case CMP_NODE_R_LAYERS:
2680       ntype->draw_buttons = node_composit_buts_viewlayers;
2681       break;
2682     case CMP_NODE_NORMAL:
2683       ntype->draw_buttons = node_buts_normal;
2684       break;
2685     case CMP_NODE_CURVE_VEC:
2686       ntype->draw_buttons = node_buts_curvevec;
2687       break;
2688     case CMP_NODE_CURVE_RGB:
2689       ntype->draw_buttons = node_buts_curvecol;
2690       break;
2691     case CMP_NODE_VALUE:
2692       ntype->draw_buttons = node_buts_value;
2693       break;
2694     case CMP_NODE_RGB:
2695       ntype->draw_buttons = node_buts_rgb;
2696       break;
2697     case CMP_NODE_FLIP:
2698       ntype->draw_buttons = node_composit_buts_flip;
2699       break;
2700     case CMP_NODE_SPLITVIEWER:
2701       ntype->draw_buttons = node_composit_buts_splitviewer;
2702       break;
2703     case CMP_NODE_MIX_RGB:
2704       ntype->draw_buttons = node_buts_mix_rgb;
2705       break;
2706     case CMP_NODE_VALTORGB:
2707       ntype->draw_buttons = node_buts_colorramp;
2708       break;
2709     case CMP_NODE_CROP:
2710       ntype->draw_buttons = node_composit_buts_crop;
2711       break;
2712     case CMP_NODE_BLUR:
2713       ntype->draw_buttons = node_composit_buts_blur;
2714       break;
2715     case CMP_NODE_DBLUR:
2716       ntype->draw_buttons = node_composit_buts_dblur;
2717       break;
2718     case CMP_NODE_BILATERALBLUR:
2719       ntype->draw_buttons = node_composit_buts_bilateralblur;
2720       break;
2721     case CMP_NODE_DEFOCUS:
2722       ntype->draw_buttons = node_composit_buts_defocus;
2723       break;
2724     case CMP_NODE_GLARE:
2725       ntype->draw_buttons = node_composit_buts_glare;
2726       break;
2727     case CMP_NODE_TONEMAP:
2728       ntype->draw_buttons = node_composit_buts_tonemap;
2729       break;
2730     case CMP_NODE_LENSDIST:
2731       ntype->draw_buttons = node_composit_buts_lensdist;
2732       break;
2733     case CMP_NODE_VECBLUR:
2734       ntype->draw_buttons = node_composit_buts_vecblur;
2735       break;
2736     case CMP_NODE_FILTER:
2737       ntype->draw_buttons = node_composit_buts_filter;
2738       break;
2739     case CMP_NODE_MAP_VALUE:
2740       ntype->draw_buttons = node_composit_buts_map_value;
2741       break;
2742     case CMP_NODE_MAP_RANGE:
2743       ntype->draw_buttons = node_composit_buts_map_range;
2744       break;
2745     case CMP_NODE_TIME:
2746       ntype->draw_buttons = node_buts_time;
2747       break;
2748     case CMP_NODE_ALPHAOVER:
2749       ntype->draw_buttons = node_composit_buts_alphaover;
2750       break;
2751     case CMP_NODE_TEXTURE:
2752       ntype->draw_buttons = node_buts_texture;
2753       break;
2754     case CMP_NODE_DILATEERODE:
2755       ntype->draw_buttons = node_composit_buts_dilateerode;
2756       break;
2757     case CMP_NODE_INPAINT:
2758       ntype->draw_buttons = node_composit_buts_inpaint;
2759       break;
2760     case CMP_NODE_DESPECKLE:
2761       ntype->draw_buttons = node_composit_buts_despeckle;
2762       break;
2763     case CMP_NODE_OUTPUT_FILE:
2764       ntype->draw_buttons = node_composit_buts_file_output;
2765       ntype->draw_buttons_ex = node_composit_buts_file_output_ex;
2766       break;
2767     case CMP_NODE_DIFF_MATTE:
2768       ntype->draw_buttons = node_composit_buts_diff_matte;
2769       break;
2770     case CMP_NODE_DIST_MATTE:
2771       ntype->draw_buttons = node_composit_buts_distance_matte;
2772       break;
2773     case CMP_NODE_COLOR_SPILL:
2774       ntype->draw_buttons = node_composit_buts_color_spill;
2775       break;
2776     case CMP_NODE_CHROMA_MATTE:
2777       ntype->draw_buttons = node_composit_buts_chroma_matte;
2778       break;
2779     case CMP_NODE_COLOR_MATTE:
2780       ntype->draw_buttons = node_composit_buts_color_matte;
2781       break;
2782     case CMP_NODE_SCALE:
2783       ntype->draw_buttons = node_composit_buts_scale;
2784       break;
2785     case CMP_NODE_ROTATE:
2786       ntype->draw_buttons = node_composit_buts_rotate;
2787       break;
2788     case CMP_NODE_CHANNEL_MATTE:
2789       ntype->draw_buttons = node_composit_buts_channel_matte;
2790       break;
2791     case CMP_NODE_LUMA_MATTE:
2792       ntype->draw_buttons = node_composit_buts_luma_matte;
2793       break;
2794     case CMP_NODE_MAP_UV:
2795       ntype->draw_buttons = node_composit_buts_map_uv;
2796       break;
2797     case CMP_NODE_ID_MASK:
2798       ntype->draw_buttons = node_composit_buts_id_mask;
2799       break;
2800     case CMP_NODE_DOUBLEEDGEMASK:
2801       ntype->draw_buttons = node_composit_buts_double_edge_mask;
2802       break;
2803     case CMP_NODE_MATH:
2804       ntype->draw_buttons = node_buts_math;
2805       break;
2806     case CMP_NODE_INVERT:
2807       ntype->draw_buttons = node_composit_buts_invert;
2808       break;
2809     case CMP_NODE_PREMULKEY:
2810       ntype->draw_buttons = node_composit_buts_premulkey;
2811       break;
2812     case CMP_NODE_VIEW_LEVELS:
2813       ntype->draw_buttons = node_composit_buts_view_levels;
2814       break;
2815     case CMP_NODE_COLORBALANCE:
2816       ntype->draw_buttons = node_composit_buts_colorbalance;
2817       ntype->draw_buttons_ex = node_composit_buts_colorbalance_ex;
2818       break;
2819     case CMP_NODE_HUECORRECT:
2820       ntype->draw_buttons = node_composit_buts_huecorrect;
2821       break;
2822     case CMP_NODE_ZCOMBINE:
2823       ntype->draw_buttons = node_composit_buts_zcombine;
2824       break;
2825     case CMP_NODE_COMBYCCA:
2826     case CMP_NODE_SEPYCCA:
2827       ntype->draw_buttons = node_composit_buts_ycc;
2828       break;
2829     case CMP_NODE_MOVIECLIP:
2830       ntype->draw_buttons = node_composit_buts_movieclip;
2831       ntype->draw_buttons_ex = node_composit_buts_movieclip_ex;
2832       break;
2833     case CMP_NODE_STABILIZE2D:
2834       ntype->draw_buttons = node_composit_buts_stabilize2d;
2835       break;
2836     case CMP_NODE_TRANSFORM:
2837       ntype->draw_buttons = node_composit_buts_transform;
2838       break;
2839     case CMP_NODE_TRANSLATE:
2840       ntype->draw_buttons = node_composit_buts_translate;
2841       break;
2842     case CMP_NODE_MOVIEDISTORTION:
2843       ntype->draw_buttons = node_composit_buts_moviedistortion;
2844       break;
2845     case CMP_NODE_COLORCORRECTION:
2846       ntype->draw_buttons = node_composit_buts_colorcorrection;
2847       ntype->draw_buttons_ex = node_composit_buts_colorcorrection_ex;
2848       break;
2849     case CMP_NODE_SWITCH:
2850       ntype->draw_buttons = node_composit_buts_switch;
2851       break;
2852     case CMP_NODE_SWITCH_VIEW:
2853       ntype->draw_buttons_ex = node_composit_buts_switch_view_ex;
2854       break;
2855     case CMP_NODE_MASK_BOX:
2856       ntype->draw_buttons = node_composit_buts_boxmask;
2857       ntype->draw_backdrop = node_composit_backdrop_boxmask;
2858       break;
2859     case CMP_NODE_MASK_ELLIPSE:
2860       ntype->draw_buttons = node_composit_buts_ellipsemask;
2861       ntype->draw_backdrop = node_composit_backdrop_ellipsemask;
2862       break;
2863     case CMP_NODE_BOKEHIMAGE:
2864       ntype->draw_buttons = node_composit_buts_bokehimage;
2865       break;
2866     case CMP_NODE_BOKEHBLUR:
2867       ntype->draw_buttons = node_composit_buts_bokehblur;
2868       break;
2869     case CMP_NODE_VIEWER:
2870       ntype->draw_buttons = node_composit_buts_viewer;
2871       ntype->draw_buttons_ex = node_composit_buts_viewer_ex;
2872       ntype->draw_backdrop = node_composit_backdrop_viewer;
2873       break;
2874     case CMP_NODE_COMPOSITE:
2875       ntype->draw_buttons = node_composit_buts_composite;
2876       break;
2877     case CMP_NODE_MASK:
2878       ntype->draw_buttons = node_composit_buts_mask;
2879       break;
2880     case CMP_NODE_KEYINGSCREEN:
2881       ntype->draw_buttons = node_composit_buts_keyingscreen;
2882       break;
2883     case CMP_NODE_KEYING:
2884       ntype->draw_buttons = node_composit_buts_keying;
2885       break;
2886     case CMP_NODE_TRACKPOS:
2887       ntype->draw_buttons = node_composit_buts_trackpos;
2888       break;
2889     case CMP_NODE_PLANETRACKDEFORM:
2890       ntype->draw_buttons = node_composit_buts_planetrackdeform;
2891       break;
2892     case CMP_NODE_CORNERPIN:
2893       ntype->draw_buttons = node_composit_buts_cornerpin;
2894       break;
2895     case CMP_NODE_SUNBEAMS:
2896       ntype->draw_buttons = node_composit_buts_sunbeams;
2897       break;
2898     case CMP_NODE_CRYPTOMATTE:
2899       ntype->draw_buttons = node_composit_buts_cryptomatte;
2900       ntype->draw_buttons_ex = node_composit_buts_cryptomatte_ex;
2901       break;
2902     case CMP_NODE_BRIGHTCONTRAST:
2903       ntype->draw_buttons = node_composit_buts_brightcontrast;
2904       break;
2905     case CMP_NODE_DENOISE:
2906       ntype->draw_buttons = node_composit_buts_denoise;
2907       break;
2908   }
2909 }
2910
2911 /* ****************** BUTTON CALLBACKS FOR TEXTURE NODES ***************** */
2912
2913 static void node_texture_buts_bricks(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2914 {
2915   uiLayout *col;
2916
2917   col = uiLayoutColumn(layout, true);
2918   uiItemR(col, ptr, "offset", UI_ITEM_R_SLIDER, IFACE_("Offset"), ICON_NONE);
2919   uiItemR(col, ptr, "offset_frequency", 0, IFACE_("Frequency"), ICON_NONE);
2920
2921   col = uiLayoutColumn(layout, true);
2922   uiItemR(col, ptr, "squash", 0, IFACE_("Squash"), ICON_NONE);
2923   uiItemR(col, ptr, "squash_frequency", 0, IFACE_("Frequency"), ICON_NONE);
2924 }
2925
2926 static void node_texture_buts_proc(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
2927 {
2928   PointerRNA tex_ptr;
2929   bNode *node = ptr->data;
2930   ID *id = ptr->owner_id;
2931   Tex *tex = (Tex *)node->storage;
2932   uiLayout *col, *row;
2933
2934   RNA_pointer_create(id, &RNA_Texture, tex, &tex_ptr);
2935
2936   col = uiLayoutColumn(layout, false);
2937
2938   switch (tex->type) {
2939     case TEX_BLEND:
2940       uiItemR(col, &tex_ptr, "progression", 0, "", ICON_NONE);
2941       row = uiLayoutRow(col, false);
2942       uiItemR(row, &tex_ptr, "use_flip_axis", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2943       break;
2944
2945     case TEX_MARBLE:
2946       row = uiLayoutRow(col, false);
2947       uiItemR(row, &tex_ptr, "marble_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2948       row = uiLayoutRow(col, false);
2949       uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2950       row = uiLayoutRow(col, false);
2951       uiItemR(row, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2952       row = uiLayoutRow(col, false);
2953       uiItemR(row, &tex_ptr, "noise_basis_2", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2954       break;
2955
2956     case TEX_MAGIC:
2957       uiItemR(col, &tex_ptr, "noise_depth", 0, NULL, ICON_NONE);
2958       break;
2959
2960     case TEX_STUCCI:
2961       row = uiLayoutRow(col, false);
2962       uiItemR(row, &tex_ptr, "stucci_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2963       row = uiLayoutRow(col, false);
2964       uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2965       uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2966       break;
2967
2968     case TEX_WOOD:
2969       uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2970       uiItemR(col, &tex_ptr, "wood_type", 0, "", ICON_NONE);
2971       row = uiLayoutRow(col, false);
2972       uiItemR(row, &tex_ptr, "noise_basis_2", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2973       row = uiLayoutRow(col, false);
2974       uiLayoutSetActive(row, !(ELEM(tex->stype, TEX_BAND, TEX_RING)));
2975       uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2976       break;
2977
2978     case TEX_CLOUDS:
2979       uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2980       row = uiLayoutRow(col, false);
2981       uiItemR(row, &tex_ptr, "cloud_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2982       row = uiLayoutRow(col, false);
2983       uiItemR(row, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND, NULL, ICON_NONE);
2984       uiItemR(col, &tex_ptr, "noise_depth", UI_ITEM_R_EXPAND, IFACE_("Depth"), ICON_NONE);
2985       break;
2986
2987     case TEX_DISTNOISE:
2988       uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2989       uiItemR(col, &tex_ptr, "noise_distortion", 0, "", ICON_NONE);
2990       break;
2991
2992     case TEX_MUSGRAVE:
2993       uiItemR(col, &tex_ptr, "musgrave_type", 0, "", ICON_NONE);
2994       uiItemR(col, &tex_ptr, "noise_basis", 0, "", ICON_NONE);
2995       break;
2996     case TEX_VORONOI:
2997       uiItemR(col, &tex_ptr, "distance_metric", 0, "", ICON_NONE);
2998       if (tex->vn_distm == TEX_MINKOVSKY) {
2999         uiItemR(col, &tex_ptr, "minkovsky_exponent", 0, NULL, ICON_NONE);
3000       }
3001       uiItemR(col, &tex_ptr, "color_mode", 0, "", ICON_NONE);
3002       break;
3003   }
3004 }
3005
3006 static void node_texture_buts_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
3007 {
3008   uiTemplateID(layout,
3009                C,
3010                ptr,
3011                "image",
3012                "IMAGE_OT_new",
3013                "IMAGE_OT_open",
3014                NULL,
3015                UI_TEMPLATE_ID_FILTER_ALL,
3016                false);
3017 }
3018
3019 static void node_texture_buts_image_ex(uiLayout *layout, bContext *C, PointerRNA *ptr)
3020 {
3021   bNode *node = ptr->data;
3022   PointerRNA iuserptr;
3023
3024   RNA_pointer_create(ptr->owner_id, &RNA_ImageUser, node->storage, &iuserptr);
3025   uiTemplateImage(layout, C, ptr, "image", &iuserptr, 0, 0);
3026 }
3027
3028 static void node_texture_buts_output(uiLayout *layout, bContext *UNUSED(C), PointerRNA *ptr)
3029 {
3030   uiItemR(layout, ptr, "filepath", 0, "", ICON_NONE);
3031 }
3032
3033 /* only once called */
3034 static void node_texture_set_butfunc(bNodeType *ntype)
3035 {
3036   if (ntype->type >= TEX_NODE_PROC && ntype->type < TEX_NODE_PROC_MAX) {
3037     ntype->draw_buttons = node_texture_buts_proc;
3038   }
3039   else {
3040     switch (ntype->type) {
3041
3042       case TEX_NODE_MATH:
3043         ntype->draw_buttons = node_buts_math;
3044         break;
3045
3046       case TEX_NODE_MIX_RGB:
3047         ntype->draw_buttons = node_buts_mix_rgb;
3048         break;
3049
3050       case TEX_NODE_VALTORGB:
3051         ntype->draw_buttons = node_buts_colorramp;
3052         break;
3053
3054       case TEX_NODE_CURVE_RGB:
3055         ntype->draw_buttons = node_buts_curvecol;
3056         break;
3057
3058       case TEX_NODE_CURVE_TIME:
3059         ntype->draw_buttons = node_buts_time;
3060         break;
3061
3062       case TEX_NODE_TEXTURE:
3063         ntype->draw_buttons = node_buts_texture;
3064         break;
3065
3066       case TEX_NODE_BRICKS:
3067         ntype->draw_buttons = node_texture_buts_bricks;
3068         break;
3069
3070       case TEX_NODE_IMAGE:
3071         ntype->draw_buttons = node_texture_buts_image;
3072         ntype->draw_buttons_ex = node_texture_buts_image_ex;
3073         break;
3074
3075       case TEX_NODE_OUTPUT:
3076         ntype->draw_buttons = node_texture_buts_output;
3077         break;
3078     }
3079   }
3080 }
3081
3082 /* ****** init draw callbacks for all tree types, only called in usiblender.c, once ************ */
3083
3084 static void node_property_update_default(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
3085 {
3086   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3087   bNode *node = ptr->data;
3088   ED_node_tag_update_nodetree(bmain, ntree, node);
3089 }
3090
3091 static void node_socket_template_properties_update(bNodeType *ntype, bNodeSocketTemplate *stemp)
3092 {
3093   StructRNA *srna = ntype->ext.srna;
3094   PropertyRNA *prop = RNA_struct_type_find_property(srna, stemp->identifier);
3095
3096   if (prop) {
3097     RNA_def_property_update_runtime(prop, node_property_update_default);
3098   }
3099 }
3100
3101 static void node_template_properties_update(bNodeType *ntype)
3102 {
3103   bNodeSocketTemplate *stemp;
3104
3105   if (ntype->inputs) {
3106     for (stemp = ntype->inputs; stemp->type >= 0; stemp++) {
3107       node_socket_template_properties_update(ntype, stemp);
3108     }
3109   }
3110   if (ntype->outputs) {
3111     for (stemp = ntype->outputs; stemp->type >= 0; stemp++) {
3112       node_socket_template_properties_update(ntype, stemp);
3113     }
3114   }
3115 }
3116
3117 static void node_socket_undefined_draw(bContext *UNUSED(C),
3118                                        uiLayout *layout,
3119                                        PointerRNA *UNUSED(ptr),
3120                                        PointerRNA *UNUSED(node_ptr),
3121                                        const char *UNUSED(text))
3122 {
3123   uiItemL(layout, IFACE_("Undefined Socket Type"), ICON_ERROR);
3124 }
3125
3126 static void node_socket_undefined_draw_color(bContext *UNUSED(C),
3127                                              PointerRNA *UNUSED(ptr),
3128                                              PointerRNA *UNUSED(node_ptr),
3129                                              float *r_color)
3130 {
3131   r_color[0] = 1.0f;
3132   r_color[1] = 0.0f;
3133   r_color[2] = 0.0f;
3134   r_color[3] = 1.0f;
3135 }
3136
3137 static void node_socket_undefined_interface_draw(bContext *UNUSED(C),
3138                                                  uiLayout *layout,
3139                                                  PointerRNA *UNUSED(ptr))
3140 {
3141   uiItemL(layout, IFACE_("Undefined Socket Type"), ICON_ERROR);
3142 }
3143
3144 static void node_socket_undefined_interface_draw_color(bContext *UNUSED(C),
3145                                                        PointerRNA *UNUSED(ptr),
3146                                                        float *r_color)
3147 {
3148   r_color[0] = 1.0f;
3149   r_color[1] = 0.0f;
3150   r_color[2] = 0.0f;
3151   r_color[3] = 1.0f;
3152 }
3153
3154 void ED_node_init_butfuncs(void)
3155 {
3156   /* Fallback types for undefined tree, nodes, sockets
3157    * Defined in blenkernel, but not registered in type hashes.
3158    */
3159
3160   /* default ui functions */
3161   NodeTypeUndefined.draw_nodetype = node_draw_default;
3162   NodeTypeUndefined.draw_nodetype_prepare = node_update_default;
3163   NodeTypeUndefined.select_area_func = node_select_area_default;
3164   NodeTypeUndefined.tweak_area_func = node_tweak_area_default;
3165   NodeTypeUndefined.draw_buttons = NULL;
3166   NodeTypeUndefined.draw_buttons_ex = NULL;
3167   NodeTypeUndefined.resize_area_func = node_resize_area_default;
3168
3169   NodeSocketTypeUndefined.draw = node_socket_undefined_draw;
3170   NodeSocketTypeUndefined.draw_color = node_socket_undefined_draw_color;
3171   NodeSocketTypeUndefined.interface_draw = node_socket_undefined_interface_draw;
3172   NodeSocketTypeUndefined.interface_draw_color = node_socket_undefined_interface_draw_color;
3173
3174   /* node type ui functions */
3175   NODE_TYPES_BEGIN (ntype) {
3176     /* default ui functions */
3177     ntype->draw_nodetype = node_draw_default;
3178     ntype->draw_nodetype_prepare = node_update_default;
3179     ntype->select_area_func = node_select_area_default;
3180     ntype->tweak_area_func = node_tweak_area_default;
3181     ntype->draw_buttons = NULL;
3182     ntype->draw_buttons_ex = NULL;
3183     ntype->resize_area_func = node_resize_area_default;
3184
3185     node_common_set_butfunc(ntype);
3186
3187     node_composit_set_butfunc(ntype);
3188     node_shader_set_butfunc(ntype);
3189     node_texture_set_butfunc(ntype);
3190
3191     /* define update callbacks for socket properties */
3192     node_template_properties_update(ntype);
3193   }
3194   NODE_TYPES_END;
3195
3196   /* tree type icons */
3197   ntreeType_Composite->ui_icon = ICON_NODE_COMPOSITING;
3198   ntreeType_Shader->ui_icon = ICON_NODE_MATERIAL;
3199   ntreeType_Texture->ui_icon = ICON_NODE_TEXTURE;
3200 }
3201
3202 void ED_init_custom_node_type(bNodeType *ntype)
3203 {
3204   /* default ui functions */
3205   ntype->draw_nodetype = node_draw_default;
3206   ntype->draw_nodetype_prepare = node_update_default;
3207   ntype->resize_area_func = node_resize_area_default;
3208   ntype->select_area_func = node_select_area_default;
3209   ntype->tweak_area_func = node_tweak_area_default;
3210 }
3211
3212 void ED_init_custom_node_socket_type(bNodeSocketType *stype)
3213 {
3214   /* default ui functions */
3215   stype->draw = node_socket_button_label;
3216 }
3217
3218 /* maps standard socket integer type to a color */
3219 static const float std_node_socket_colors[][4] = {
3220     {0.63, 0.63, 0.63, 1.0}, /* SOCK_FLOAT */
3221     {0.39, 0.39, 0.78, 1.0}, /* SOCK_VECTOR */
3222     {0.78, 0.78, 0.16, 1.0}, /* SOCK_RGBA */
3223     {0.39, 0.78, 0.39, 1.0}, /* SOCK_SHADER */
3224     {0.70, 0.65, 0.19, 1.0}, /* SOCK_BOOLEAN */
3225     {0.0, 0.0, 0.0, 1.0},    /*__SOCK_MESH (deprecated) */
3226     {0.06, 0.52, 0.15, 1.0}, /* SOCK_INT */
3227     {0.39, 0.39, 0.39, 1.0}, /* SOCK_STRING */
3228 };
3229
3230 /* common color callbacks for standard types */
3231 static void std_node_socket_draw_color(bContext *UNUSED(C),
3232                                        PointerRNA *ptr,
3233                                        PointerRNA *UNUSED(node_ptr),
3234                                        float *r_color)
3235 {
3236   bNodeSocket *sock = ptr->data;
3237   int type = sock->typeinfo->type;
3238   copy_v4_v4(r_color, std_node_socket_colors[type]);
3239 }
3240 static void std_node_socket_interface_draw_color(bContext *UNUSED(C),
3241                                                  PointerRNA *ptr,
3242                                                  float *r_color)
3243 {
3244   bNodeSocket *sock = ptr->data;
3245   int type = sock->typeinfo->type;
3246   copy_v4_v4(r_color, std_node_socket_colors[type]);
3247 }
3248
3249 /* draw function for file output node sockets,
3250  * displays only sub-path and format, no value button */
3251 static void node_file_output_socket_draw(bContext *C,
3252                                          uiLayout *layout,
3253                                          PointerRNA *ptr,
3254                                          PointerRNA *node_ptr)
3255 {
3256   bNodeTree *ntree = (bNodeTree *)ptr->owner_id;
3257   bNodeSocket *sock = ptr->data;
3258   uiLayout *row;
3259   PointerRNA inputptr, imfptr;
3260   int imtype;
3261
3262   row = uiLayoutRow(layout, false);
3263
3264   imfptr = RNA_pointer_get(node_ptr, "format");
3265   imtype = RNA_enum_get(&imfptr, "file_format");
3266
3267   if (imtype == R_IMF_IMTYPE_MULTILAYER) {
3268     NodeImageMultiFileSocket *input = sock->storage;
3269     RNA_pointer_create(&ntree->id, &RNA_NodeOutputFileSlotLayer, input, &inputptr);
3270
3271     uiItemL(row, input->layer, ICON_NONE);
3272   }
3273   else {
3274     NodeImageMultiFileSocket *input = sock->storage;
3275     PropertyRNA *imtype_prop;
3276     const char *imtype_name;
3277     uiBlock *block;
3278     RNA_pointer_create(&ntree->id, &RNA_NodeOutputFileSlotFile, input, &inputptr);
3279
3280     uiItemL(row, input->path, ICON_NONE);
3281
3282     if (!RNA_boolean_get(&inputptr, "use_node_format")) {
3283       imfptr = RNA_pointer_get(&inputptr, "format");
3284     }
3285
3286     imtype_prop = RNA_struct_find_property(&imfptr, "file_format");
3287     RNA_property_enum_name((bContext *)C,
3288                            &imfptr,
3289                            imtype_prop,
3290                            RNA_property_enum_get(&imfptr, imtype_prop),
3291                            &imtype_name);
3292     block = uiLayoutGetBlock(row);
3293     UI_block_emboss_set(block, UI_EMBOSS_PULLDOWN);
3294     uiItemL(row, imtype_name, ICON_NONE);
3295     UI_block_emboss_set(block, UI_EMBOSS_NONE);
3296   }
3297 }
3298
3299 static void std_node_socket_draw(
3300     bContext *C, uiLayout *layout, PointerRNA *ptr, PointerRNA *node_ptr, const char *text)
3301 {
3302   bNode *node = node_ptr->data;
3303   bNodeSocket *sock = ptr->data;
3304   int type = sock->typeinfo->type;
3305   /*int subtype = sock->typeinfo->subtype;*/
3306
3307   /* XXX not nice, eventually give this node its own socket type ... */
3308   if (node->type == CMP_NODE_OUTPUT_FILE) {
3309     node_file_output_socket_draw(C, layout, ptr, node_ptr);
3310     return;
3311   }
3312
3313   if ((sock->in_out == SOCK_OUT) || (sock->flag & SOCK_IN_USE) || (sock->flag & SOCK_HIDE_VALUE)) {
3314     node_socket_button_label(C, layout, ptr, node_ptr, text);
3315     return;
3316   }
3317
3318   switch (type) {
3319     case SOCK_FLOAT:
3320     case SOCK_INT:
3321     case SOCK_BOOLEAN:
3322       uiItemR(layout, ptr, "default_value", 0, text, 0);
3323       break;
3324     case SOCK_VECTOR:
3325       if (sock->flag & SOCK_COMPACT) {
3326         uiTemplateComponentMenu(layout, ptr, "default_value", text);
3327       }
3328       else {
3329         if (sock->typeinfo->subtype == PROP_DIRECTION) {
3330           uiItemR(layout, ptr, "default_value", 0, "", ICON_NONE);
3331         }
3332         else {
3333           uiLayout *column = uiLayoutColumn(layout, true);
3334           uiItemR(column, ptr, "default_value", 0, text, ICON_NONE);
3335         }
3336       }
3337       break;
3338     case SOCK_RGBA:
3339     case SOCK_STRING: {
3340       uiLayout *row = uiLayoutSplit(layout, 0.5f, false);
3341       uiItemL(row, text, 0);
3342       uiItemR(row, ptr, "default_value", 0, "", 0);
3343       break;
3344     }
3345     default:
3346       node_socket_button_label(C, layout, ptr, node_ptr, text);
3347       break;
3348   }
3349 }
3350
3351 static void std_node_socket_interface_draw(bContext *UNUSED(C), uiLayout *layout, PointerRNA *ptr)
3352 {
3353   bNodeSocket *sock = ptr->data;
3354   int type = sock->typeinfo->type;
3355   /*int subtype = sock->typeinfo->subtype;*/
3356
3357   switch (type) {
3358     case SOCK_FLOAT: {
3359       uiLayout *row;
3360       uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3361       row = uiLayoutRow(layout, true);
3362       uiItemR(row, ptr, "min_value", 0, IFACE_("Min"), 0);
3363       uiItemR(row, ptr, "max_value", 0, IFACE_("Max"), 0);
3364       break;
3365     }
3366     case SOCK_INT: {
3367       uiLayout *row;
3368       uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3369       row = uiLayoutRow(layout, true);
3370       uiItemR(row, ptr, "min_value", 0, IFACE_("Min"), 0);
3371       uiItemR(row, ptr, "max_value", 0, IFACE_("Max"), 0);
3372       break;
3373     }
3374     case SOCK_VECTOR: {
3375       uiLayout *row;
3376       uiItemR(layout, ptr, "default_value", UI_ITEM_R_EXPAND, NULL, 0);
3377       row = uiLayoutRow(layout, true);
3378       uiItemR(row, ptr, "min_value", 0, IFACE_("Min"), 0);
3379       uiItemR(row, ptr, "max_value", 0, IFACE_("Max"), 0);
3380       break;
3381     }
3382     case SOCK_BOOLEAN:
3383     case SOCK_RGBA:
3384     case SOCK_STRING: {
3385       uiItemR(layout, ptr, "default_value", 0, NULL, 0);
3386       break;
3387     }
3388   }
3389 }
3390
3391 void ED_init_standard_node_socket_type(bNodeSocketType *stype)
3392 {
3393   stype->draw = std_node_socket_draw;
3394   stype->draw_color = std_node_socket_draw_color;
3395   stype->interface_draw = std_node_socket_interface_draw;
3396   stype->interface_draw_color = std_node_socket_interface_draw_color;
3397 }
3398
3399 static void node_socket_virtual_draw_color(bContext *UNUSED(C),
3400                                            PointerRNA *UNUSED(ptr),
3401                                            PointerRNA *UNUSED(node_ptr),
3402                                            float *r_color)
3403 {
3404   /* alpha = 0, empty circle */
3405   zero_v4(r_color);
3406 }
3407
3408 void ED_init_node_socket_type_virtual(bNodeSocketType *stype)
3409 {
3410   stype->draw = node_socket_button_label;
3411   stype->draw_color = node_socket_virtual_draw_color;
3412 }
3413
3414 /* ************** Generic drawing ************** */
3415
3416 void draw_nodespace_back_pix(const bContext *C,
3417                              ARegion *ar,
3418                              SpaceNode *snode,
3419                              bNodeInstanceKey parent_key)
3420 {
3421   Main *bmain = CTX_data_main(C);
3422   bNodeInstanceKey active_viewer_key = (snode->nodetree ? snode->nodetree->active_viewer_key :
3423                                                           NODE_INSTANCE_KEY_NONE);
3424   float shuffle[4] = {0.0f, 0.0f, 0.0f, 0.0f};
3425   Image *ima;
3426   void *lock;
3427   ImBuf *ibuf;
3428
3429   GPU_matrix_push_projection();
3430   GPU_matrix_push();
3431   wmOrtho2_region_pixelspace(ar);
3432   GPU_matrix_identity_set();
3433   ED_region_draw_cb_draw(C, ar, REGION_DRAW_BACKDROP);
3434   GPU_matrix_pop_projection();
3435   GPU_matrix_pop();
3436
3437   if (!(snode->flag & SNODE_BACKDRAW) || !ED_node_is_compositor(snode)) {
3438     return;
3439   }
3440
3441   if (parent_key.value != active_viewer_key.value) {
3442     return;
3443   }
3444
3445   ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
3446   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
3447   if (ibuf) {
3448     float x, y;
3449
3450     GPU_matrix_push_projection();
3451     GPU_matrix_push();
3452
3453     /* somehow the offset has to be calculated inverse */
3454     wmOrtho2_region_pixelspace(ar);
3455
3456     x = (ar->winx - snode->zoom * ibuf->x) / 2 + snode->xof;
3457     y = (ar->winy - snode->zoom * ibuf->y) / 2 + snode->yof;
3458
3459     if (ibuf->rect || ibuf->rect_float) {
3460       unsigned char *display_buffer = NULL;
3461       void *cache_handle = NULL;
3462
3463       if (snode->flag & (SNODE_SHOW_R | SNODE_SHOW_G | SNODE_SHOW_B | SNODE_SHOW_ALPHA)) {
3464
3465         display_buffer = IMB_display_buffer_acquire_ctx(C, ibuf, &cache_handle);
3466
3467         if (snode->flag & SNODE_SHOW_R) {
3468           shuffle[0] = 1.0f;
3469         }
3470         else if (snode->flag & SNODE_SHOW_G) {
3471           shuffle[1] = 1.0f;
3472         }
3473         else if (snode->flag & SNODE_SHOW_B) {
3474           shuffle[2] = 1.0f;
3475         }
3476         else {
3477           shuffle[3] = 1.0f;
3478         }
3479
3480         IMMDrawPixelsTexState state = immDrawPixelsTexSetup(GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR);
3481         GPU_shader_uniform_vector(
3482             state.shader, GPU_shader_get_uniform_ensure(state.shader, "shuffle"), 4, 1, shuffle);
3483
3484         immDrawPixelsTex(&state,
3485                          x,
3486                          y,
3487                          ibuf->x,
3488                          ibuf->y,
3489                          GL_RGBA,
3490                          GL_UNSIGNED_BYTE,
3491                          GL_NEAREST,
3492                          display_buffer,
3493                          snode->zoom,
3494                          snode->zoom,
3495                          NULL);
3496
3497         GPU_shader_unbind();
3498       }
3499       else if (snode->flag & SNODE_USE_ALPHA) {
3500         GPU_blend(true);
3501         GPU_blend_set_func_separate(
3502             GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
3503
3504         ED_draw_imbuf_ctx(C, ibuf, x, y, GL_NEAREST, snode->zoom, snode->zoom);
3505
3506         GPU_blend(false);
3507       }
3508       else {
3509         ED_draw_imbuf_ctx(C, ibuf, x, y, GL_NEAREST, snode->zoom, snode->zoom);
3510       }
3511
3512       if (cache_handle) {
3513         IMB_display_buffer_release(cache_handle);
3514       }
3515     }
3516
3517     /** \note draw selected info on backdrop */
3518     if (snode->edittree) {
3519       bNode *node = snode->edittree->nodes.first;
3520       rctf *viewer_border = &snode->nodetree->viewer_border;
3521       while (node) {
3522         if (node->flag & NODE_SELECT) {
3523           if (node->typeinfo->draw_backdrop) {
3524             node->typeinfo->draw_backdrop(snode, ibuf, node, x, y);
3525           }
3526         }
3527         node = node->next;
3528       }
3529
3530       if ((snode->nodetree->flag & NTREE_VIEWER_BORDER) &&
3531           viewer_border->xmin < viewer_border->xmax && viewer_border->ymin < viewer_border->ymax) {
3532         rcti pixel_border;
3533         BLI_rcti_init(&pixel_border,
3534                       x + snode->zoom * viewer_border->xmin * ibuf->x,
3535                       x + snode->zoom * viewer_border->xmax * ibuf->x,
3536                       y + snode->zoom * viewer_border->ymin * ibuf->y,
3537                       y + snode->zoom * viewer_border->ymax * ibuf->y);
3538
3539         uint pos = GPU_vertformat_attr_add(
3540             immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3541         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
3542         immUniformThemeColor(TH_ACTIVE);
3543
3544         immDrawBorderCorners(pos, &pixel_border, 1.0f, 1.0f);
3545
3546         immUnbindProgram();
3547       }
3548     }
3549
3550     GPU_matrix_pop_projection();
3551     GPU_matrix_pop();
3552   }
3553
3554   BKE_image_release_ibuf(ima, ibuf, lock);
3555 }
3556
3557 /* return quadratic beziers points for a given nodelink and clip if v2d is not NULL. */
3558 static bool node_link_bezier_handles(View2D *v2d,
3559                                      SpaceNode *snode,
3560                                      bNodeLink *link,
3561                                      float vec[4][2])
3562 {
3563   float dist;
3564   float deltax, deltay;
3565   float cursor[2] = {0.0f, 0.0f};
3566   int toreroute, fromreroute;
3567
3568   /* this function can be called with snode null (via cut_links_intersect) */
3569   /* XXX map snode->cursor back to view space */
3570   if (snode) {
3571     cursor[0] = snode->cursor[0] * UI_DPI_FAC;
3572     cursor[1] = snode->cursor[1] * UI_DPI_FAC;
3573   }
3574
3575   /* in v0 and v3 we put begin/end points */
3576   if (link->fromsock) {
3577     vec[0][0] = link->fromsock->locx;
3578     vec[0][1] = link->fromsock->locy;
3579     fromreroute = (link->fromnode && link->fromnode->type == NODE_REROUTE);
3580   }
3581   else {
3582     if (snode == NULL) {
3583       return 0;
3584     }
3585     copy_v2_v2(vec[0], cursor);
3586     fromreroute = 0;
3587   }
3588   if (link->tosock) {
3589     vec[3][0] = link->tosock->locx;
3590     vec[3][1] = link->tosock->locy;
3591     toreroute = (link->tonode && link->tonode->type == NODE_REROUTE);
3592   }
3593   else {
3594     if (snode == NULL) {
3595       return 0;
3596     }
3597     copy_v2_v2(vec[3], cursor);
3598     toreroute = 0;
3599   }
3600
3601   /* may be called outside of drawing (so pass spacetype) */
3602   int curving = UI_GetThemeValueType(TH_NODE_CURVING, SPACE_NODE);
3603
3604   if (curving == 0) {
3605     /* Straight line: align all points. */
3606     mid_v2_v2v2(vec[1], vec[0], vec[3]);
3607     mid_v2_v2v2(vec[2], vec[1], vec[3]);
3608     return 1;
3609   }
3610
3611   dist = curving * 0.10f * fabsf(vec[0][0] - vec[3][0]);
3612   deltax = vec[3][0] - vec[0][0];
3613   deltay = vec[3][1] - vec[0][1];
3614   /* check direction later, for top sockets */
3615   if (fromreroute) {
3616     if (ABS(deltax) > ABS(deltay)) {
3617       vec[1][1] = vec[0][1];
3618       vec[1][0] = vec[0][0] + (deltax > 0 ? dist : -dist);
3619     }
3620     else {
3621       vec[1][0] = vec[0][0];
3622       vec[1][1] = vec[0][1] + (deltay > 0 ? dist : -dist);
3623     }
3624   }
3625   else {
3626     vec[1][0] = vec[0][0] + dist;
3627     vec[1][1] = vec[0][1];
3628   }
3629   if (toreroute) {
3630     if (ABS(deltax) > ABS(deltay)) {
3631       vec[2][1] = vec[3][1];
3632       vec[2][0] = vec[3][0] + (deltax > 0 ? -dist : dist);
3633     }
3634     else {
3635       vec[2][0] = vec[3][0];
3636       vec[2][1] = vec[3][1] + (deltay > 0 ? -dist : dist);
3637     }
3638   }
3639   else {
3640     vec[2][0] = vec[3][0] - dist;
3641     vec[2][1] = vec[3][1];
3642   }
3643
3644   if (v2d && min_ffff(vec[0][0], vec[1][0], vec[2][0], vec[3][0]) > v2d->cur.xmax) {
3645     return 0; /* clipped */
3646   }
3647   else if (v2d && max_ffff(vec[0][0], vec[1][0], vec[2][0], vec[3][0]) < v2d->cur.xmin) {
3648     return 0; /* clipped */
3649   }
3650
3651   return 1;
3652 }
3653
3654 /* if v2d not NULL, it clips and returns 0 if not visible */
3655 bool node_link_bezier_points(
3656     View2D *v2d, SpaceNode *snode, bNodeLink *link, float coord_array[][2], int resol)
3657 {
3658   float vec[4][2];
3659
3660   if (node_link_bezier_handles(v2d, snode, link, vec)) {
3661     /* always do all three, to prevent data hanging around */
3662     BKE_curve_forward_diff_bezier(
3663         vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0] + 0, resol, sizeof(float) * 2);
3664     BKE_curve_forward_diff_bezier(
3665         vec[0][1], vec[1][1], vec[2][1], vec[3][1], coord_array[0] + 1, resol, sizeof(float) * 2);
3666
3667     return 1;
3668   }
3669   return 0;
3670 }
3671
3672 #define NODELINK_GROUP_SIZE 256
3673 #define LINK_RESOL 24
3674 #define LINK_WIDTH (2.5f * UI_DPI_FAC)
3675 #define ARROW_SIZE (7 * UI_DPI_FAC)
3676
3677 static float arrow_verts[3][2] = {{-1.0f, 1.0f}, {0.0f, 0.0f}, {-1.0f, -1.0f}};
3678 static float arrow_expand_axis[3][2] = {{0.7071f, 0.7071f}, {M_SQRT2, 0.0f}, {0.7071f, -0.7071f}};
3679
3680 static struct {
3681   GPUBatch *batch;        /* for batching line together */
3682   GPUBatch *batch_single; /* for single line */
3683   GPUVertBuf *inst_vbo;
3684   unsigned int p0_id, p1_id, p2_id, p3_id;
3685   unsigned int colid_id;
3686   GPUVertBufRaw p0_step, p1_step, p2_step, p3_step;
3687   GPUVertBufRaw colid_step;
3688   unsigned int count;
3689   bool enabled;
3690 } g_batch_link = {0};
3691
3692 static void nodelink_batch_reset(void)
3693 {
3694   GPU_vertbuf_attr_get_raw_data(g_batch_link.inst_vbo, g_batch_link.p0_id, &g_batch_link.p0_step);
3695   GPU_vertbuf_attr_get_raw_data(g_batch_link.inst_vbo, g_batch_link.p1_id, &g_batch_link.p1_step);
3696   GPU_vertbuf_attr_get_raw_data(g_batch_link.inst_vbo, g_batch_link.p2_id, &g_batch_link.p2_step);
3697   GPU_vertbuf_attr_get_raw_data(g_batch_link.inst_vbo, g_batch_link.p3_id, &g_batch_link.p3_step);
3698   GPU_vertbuf_attr_get_raw_data(
3699       g_batch_link.inst_vbo, g_batch_link.colid_id, &g_batch_link.colid_step);
3700   g_batch_link.count = 0;
3701 }
3702
3703 static void set_nodelink_vertex(GPUVertBuf *vbo,
3704                                 unsigned int uv_id,
3705                                 unsigned int pos_id,
3706                                 unsigned int exp_id,
3707                                 unsigned int v,
3708                                 const unsigned char uv[2],
3709                                 const float pos[2],
3710                                 const float exp[2])
3711 {
3712   GPU_vertbuf_attr_set(vbo, uv_id, v, uv);
3713   GPU_vertbuf_attr_set(vbo, pos_id, v, pos);
3714   GPU_vertbuf_attr_set(vbo, exp_id, v, exp);
3715 }
3716
3717 static void nodelink_batch_init(void)
3718 {
3719   GPUVertFormat format = {0};
3720   uint uv_id = GPU_vertformat_attr_add(&format, "uv", GPU_COMP_U8, 2, GPU_FETCH_INT_TO_FLOAT_UNIT);
3721   uint pos_id = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3722   uint expand_id = GPU_vertformat_attr_add(&format, "expand", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3723   GPUVertBuf *vbo = GPU_vertbuf_create_with_format_ex(&format, GPU_USAGE_STATIC);
3724   int vcount = LINK_RESOL * 2; /* curve */
3725   vcount += 2;                 /* restart strip */
3726   vcount += 3 * 2;             /* arrow */
3727   vcount *= 2;                 /* shadow */
3728   vcount += 2;                 /* restart strip */
3729   GPU_vertbuf_data_alloc(vbo, vcount);
3730   int v = 0;
3731
3732   for (int k = 0; k < 2; k++) {
3733     unsigned char uv[2] = {0, 0};
3734     float pos[2] = {0.0f, 0.0f};
3735     float exp[2] = {0.0f, 1.0f};
3736
3737     /* restart */
3738     if (k == 1) {
3739       set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3740     }
3741
3742     /* curve strip */
3743     for (int i = 0; i < LINK_RESOL; i++) {
3744       uv[0] = 255 * (i / (float)(LINK_RESOL - 1));
3745       uv[1] = 0;
3746       set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3747       uv[1] = 255;
3748       set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3749     }
3750     /* restart */
3751     set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3752
3753     uv[0] = 127;
3754     uv[1] = 0;
3755     copy_v2_v2(pos, arrow_verts[0]);
3756     copy_v2_v2(exp, arrow_expand_axis[0]);
3757     set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3758     /* arrow */
3759     for (int i = 0; i < 3; i++) {
3760       uv[1] = 0;
3761       copy_v2_v2(pos, arrow_verts[i]);
3762       copy_v2_v2(exp, arrow_expand_axis[i]);
3763       set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3764
3765       uv[1] = 255;
3766       set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3767     }
3768
3769     /* restart */
3770     if (k == 0) {
3771       set_nodelink_vertex(vbo, uv_id, pos_id, expand_id, v++, uv, pos, exp);
3772     }
3773   }
3774
3775   g_batch_link.batch = GPU_batch_create_ex(GPU_PRIM_TRI_STRIP, vbo, NULL, GPU_BATCH_OWNS_VBO);
3776   gpu_batch_presets_register(g_batch_link.batch);
3777
3778   g_batch_link.batch_single = GPU_batch_create_ex(GPU_PRIM_TRI_STRIP, vbo, NULL, 0);
3779   gpu_batch_presets_register(g_batch_link.batch_single);
3780
3781   /* Instances data */
3782   GPUVertFormat format_inst = {0};
3783   g_batch_link.p0_id = GPU_vertformat_attr_add(
3784       &format_inst, "P0", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3785   g_batch_link.p1_id = GPU_vertformat_attr_add(
3786       &format_inst, "P1", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3787   g_batch_link.p2_id = GPU_vertformat_attr_add(
3788       &format_inst, "P2", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3789   g_batch_link.p3_id = GPU_vertformat_attr_add(
3790       &format_inst, "P3", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
3791   g_batch_link.colid_id = GPU_vertformat_attr_add(
3792       &format_inst, "colid_doarrow", GPU_COMP_U8, 4, GPU_FETCH_INT);
3793   g_batch_link.inst_vbo = GPU_vertbuf_create_with_format_ex(&format_inst, GPU_USAGE_STREAM);
3794   /* Alloc max count but only draw the range we need. */
3795   GPU_vertbuf_data_alloc(g_batch_link.inst_vbo, NODELINK_GROUP_SIZE);
3796
3797   GPU_batch_instbuf_set(g_batch_link.batch, g_batch_link.inst_vbo, true);
3798
3799   nodelink_batch_reset();
3800 }
3801
3802 static char nodelink_get_color_id(int th_col)
3803 {
3804   switch (th_col) {
3805     case TH_WIRE:
3806       return 1;
3807     case TH_WIRE_INNER:
3808       return 2;
3809     case TH_ACTIVE:
3810       return 3;
3811     case TH_EDGE_SELECT:
3812       return 4;
3813     case TH_REDALERT:
3814       return 5;
3815   }
3816   return 0;
3817 }
3818
3819 static void nodelink_batch_draw(SpaceNode *snode)
3820 {
3821   if (g_batch_link.count == 0) {
3822     return;
3823   }
3824
3825   GPU_blend(true);
3826
3827   float colors[6][4] = {{0.0f}};
3828   UI_GetThemeColor4fv(TH_WIRE_INNER, colors[nodelink_get_color_id(TH_WIRE_INNER)]);
3829   UI_GetThemeColor4fv(TH_WIRE, colors[nodelink_get_color_id(TH_WIRE)]);
3830   UI_GetThemeColor4fv(TH_ACTIVE, colors[nodelink_get_color_id(TH_ACTIVE)]);
3831   UI_GetThemeColor4fv(TH_EDGE_SELECT, colors[nodelink_get_color_id(TH_EDGE_SELECT)]);
3832   UI_GetThemeColor4fv(TH_REDALERT, colors[nodelink_get_color_id(TH_REDALERT)]);
3833
3834   GPU_vertbuf_data_len_set(g_batch_link.inst_vbo, g_batch_link.count);
3835   GPU_vertbuf_use(g_batch_link.inst_vbo); /* force update. */
3836
3837   GPU_batch_program_set_builtin(g_batch_link.batch, GPU_SHADER_2D_NODELINK_INST);
3838   GPU_batch_uniform_4fv_array(g_batch_link.batch, "colors", 6, (float *)colors);
3839   GPU_batch_uniform_1f(g_batch_link.batch, "expandSize", snode->aspect * LINK_WIDTH);
3840   GPU_batch_uniform_1f(g_batch_link.batch, "arrowSize", ARROW_SIZE);
3841   GPU_batch_draw(g_batch_link.batch);
3842
3843   nodelink_batch_reset();
3844
3845   GPU_blend(false);
3846 }
3847
3848 void nodelink_batch_start(SpaceNode *UNUSED(snode))
3849 {
3850   g_batch_link.enabled = true;
3851 }
3852
3853 void nodelink_batch_end(SpaceNode *snode)
3854 {
3855   nodelink_batch_draw(snode);
3856   g_batch_link.enabled = false;
3857 }
3858
3859 static void nodelink_batch_add_link(SpaceNode *snode,
3860                                     const float p0[2],
3861                                     const float p1[2],
3862                                     const float p2[2],
3863                                     const float p3[2],
3864                                     int th_col1,
3865                                     int th_col2,
3866                                     int th_col3,
3867                                     bool drawarrow)
3868 {
3869   /* Only allow these colors. If more is needed, you need to modify the shader accordingly. */
3870   BLI_assert(ELEM(th_col1, TH_WIRE_INNER, TH_WIRE, TH_ACTIVE, TH_EDGE_SELECT, TH_REDALERT));
3871   BLI_assert(ELEM(th_col2, TH_WIRE_INNER, TH_WIRE, TH_ACTIVE, TH_EDGE_SELECT, TH_REDALERT));
3872   BLI_assert(ELEM(th_col3, TH_WIRE, -1));
3873
3874   g_batch_link.count++;
3875   copy_v2_v2(GPU_vertbuf_raw_step(&g_batch_link.p0_step), p0);
3876   copy_v2_v2(GPU_vertbuf_raw_step(&g_batch_link.p1_step), p1);
3877   copy_v2_v2(GPU_vertbuf_raw_step(&g_batch_link.p2_step), p2);
3878   copy_v2_v2(GPU_vertbuf_raw_step(&g_batch_link.p3_step), p3);
3879   char *colid = GPU_vertbuf_raw_step(&g_batch_link.colid_step);
3880   colid[0] = nodelink_get_color_id(th_col1);
3881   colid[1] = nodelink_get_color_id(th_col2);
3882   colid[2] = nodelink_get_color_id(th_col3);
3883   colid[3] = drawarrow;
3884
3885   if (g_batch_link.count == NODELINK_GROUP_SIZE) {
3886     nodelink_batch_draw(snode);
3887   }
3888 }
3889
3890 /* don't do shadows if th_col3 is -1. */
3891 void node_draw_link_bezier(
3892     View2D *v2d, SpaceNode *snode, bNodeLink *link, int th_col1, int th_col2, int th_col3)
3893 {
3894   float vec[4][2];
3895
3896   if (node_link_bezier_handles(v2d, snode, link, vec)) {
3897     int drawarrow = ((link->tonode && (link->tonode->type == NODE_REROUTE)) &&
3898                      (link->fromnode && (link->fromnode->type == NODE_REROUTE)));
3899
3900     if (g_batch_link.batch == NULL) {
3901       nodelink_batch_init();
3902     }
3903
3904     if (g_batch_link.enabled) {
3905       /* Add link to batch. */
3906       nodelink_batch_add_link(
3907           snode, vec[0], vec[1], vec[2], vec[3], th_col1, th_col2, th_col3, drawarrow);
3908     }
3909     else {
3910       /* Draw single link. */
3911       float colors[3][4] = {{0.0f}};
3912       if (th_col3 != -1) {
3913         UI_GetThemeColor4fv(th_col3, colors[0]);
3914       }
3915       UI_GetThemeColor4fv(th_col1, colors[1]);
3916       UI_GetThemeColor4fv(th_col2, colors[2]);
3917
3918       GPUBatch *batch = g_batch_link.batch_single;
3919       GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_NODELINK);
3920       GPU_batch_uniform_2fv_array(batch, "bezierPts", 4, (float *)vec);
3921       GPU_batch_uniform_4fv_array(batch, "colors", 3, (float *)colors);
3922       GPU_batch_uniform_1f(batch, "expandSize", snode->aspect * LINK_WIDTH);
3923       GPU_batch_uniform_1f(batch, "arrowSize", ARROW_SIZE);
3924       GPU_batch_uniform_1i(batch, "doArrow", drawarrow);
3925       GPU_batch_draw(batch);
3926     }
3927   }
3928 }
3929
3930 /* note; this is used for fake links in groups too */
3931 void node_draw_link(View2D *v2d, SpaceNode *snode, bNodeLink *link)
3932 {
3933   int th_col1 = TH_WIRE_INNER, th_col2 = TH_WIRE_INNER, th_col3 = TH_WIRE;
3934
3935   if (link->fromsock == NULL && link->tosock == NULL) {
3936     return;
3937   }
3938
3939   /* new connection */
3940   if (!link->fromsock || !link->tosock) {
3941     th_col1 = th_col2 = TH_ACTIVE;
3942   }
3943   else {
3944     /* going to give issues once... */
3945     if (link->tosock->flag & SOCK_UNAVAIL) {
3946       return;
3947     }
3948     if (link->fromsock->flag & SOCK_UNAVAIL) {
3949       return;
3950     }
3951
3952     if (link->flag & NODE_LINK_VALID) {
3953       /* special indicated link, on drop-node */
3954       if (link->flag & NODE_LINKFLAG_HILITE) {
3955         th_col1 = th_col2 = TH_ACTIVE;
3956       }
3957       else {
3958         /* regular link */
3959         if (link->fromnode && link->fromnode->flag & SELECT) {
3960           th_col1 = TH_EDGE_SELECT;
3961         }
3962         if (link->tonode && link->tonode->flag & SELECT) {
3963           th_col2 = TH_EDGE_SELECT;
3964         }
3965       }
3966     }
3967     else {
3968       th_col1 = th_col2 = TH_REDALERT;
3969       // th_col3 = -1; /* no shadow */
3970     }
3971   }
3972
3973   node_draw_link_bezier(v2d, snode, link, th_col1, th_col2, th_col3);
3974   //  node_draw_link_straight(v2d, snode, link, th_col1, do_shaded, th_col2, do_triple, th_col3);
3975 }
3976
3977 void ED_node_draw_snap(
3978     View2D *v2d, const float cent[2], float size, NodeBorder border, unsigned pos)
3979 {
3980   immBegin(GPU_PRIM_LINES, 4);
3981
3982   if (border & (NODE_LEFT | NODE_RIGHT)) {
3983     immVertex2f(pos, cent[0], v2d->cur.ymin);
3984     immVertex2f(pos, cent[0], v2d->cur.ymax);
3985   }
3986   else {
3987     immVertex2f(pos, cent[0], cent[1] - size);
3988     immVertex2f(pos, cent[0], cent[1] + size);
3989   }
3990
3991   if (border & (NODE_TOP | NODE_BOTTOM)) {
3992     immVertex2f(pos, v2d->cur.xmin, cent[1]);
3993     immVertex2f(pos, v2d->cur.xmax, cent[1]);
3994   }
3995   else {
3996     immVertex2f(pos, cent[0] - size, cent[1]);
3997     immVertex2f(pos, cent[0] + size, cent[1]);
3998   }
3999
4000   immEnd();
4001 }