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