source/blender/editors/space_node/drawnode.c

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