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