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