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