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