Got rid of some dead code
[blender-staging.git] / source / blender / editors / space_node / drawnode.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2005 Blender Foundation.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): David Millan Escriva, Juho Vepsäläinen, Bob Holcomb, Thomas Dinges
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <math.h>
31 #include <stdio.h>
32 #include <string.h>
33
34 #include "BLI_blenlib.h"
35 #include "BLI_math.h"
36
37 #include "DNA_ID.h"
38 #include "DNA_node_types.h"
39 #include "DNA_image_types.h"
40 #include "DNA_material_types.h"
41 #include "DNA_mesh_types.h"
42 #include "DNA_action_types.h"
43 #include "DNA_color_types.h"
44 #include "DNA_customdata_types.h"
45 #include "DNA_gpencil_types.h"
46 #include "DNA_ipo_types.h"
47 #include "DNA_object_types.h"
48 #include "DNA_scene_types.h"
49 #include "DNA_space_types.h"
50 #include "DNA_screen_types.h"
51 #include "DNA_texture_types.h"
52 #include "DNA_text_types.h"
53 #include "DNA_userdef_types.h"
54
55 #include "BKE_context.h"
56 #include "BKE_curve.h"
57 #include "BKE_global.h"
58 #include "BKE_image.h"
59 #include "BKE_library.h"
60 #include "BKE_main.h"
61 #include "BKE_material.h"
62 #include "BKE_node.h"
63 #include "BKE_object.h"
64 #include "BKE_texture.h"
65 #include "BKE_text.h"
66 #include "BKE_utildefines.h"
67
68 #include "CMP_node.h"
69 #include "SHD_node.h"
70
71 #include "BIF_gl.h"
72 #include "BIF_glutil.h"
73
74 #include "MEM_guardedalloc.h"
75
76 #include "ED_node.h"
77 #include "ED_space_api.h"
78 #include "ED_screen.h"
79 #include "ED_types.h"
80
81 #include "RNA_access.h"
82 #include "RNA_define.h"
83
84 #include "WM_api.h"
85 #include "WM_types.h"
86
87 #include "UI_view2d.h"
88 #include "UI_interface.h"
89 #include "UI_resources.h"
90
91 #include "RE_pipeline.h"
92 #include "IMB_imbuf.h"
93 #include "IMB_imbuf_types.h"
94
95 #include "node_intern.h"
96
97 /* ****************** GENERAL CALLBACKS FOR NODES ***************** */
98
99 #if 0
100 /* XXX not used yet, make compiler happy :) */
101 static void node_group_alone_cb(bContext *C, void *node_v, void *unused_v)
102 {
103         bNode *node= node_v;
104         
105         nodeCopyGroup(node);
106
107         // allqueue(REDRAWNODE, 0);
108 }
109
110 /* ****************** BUTTON CALLBACKS FOR ALL TREES ***************** */
111
112 static void node_buts_group(uiLayout *layout, bContext *C, PointerRNA *ptr)
113 {
114         uiBlock *block= uiLayoutAbsoluteBlock(layout);
115         bNode *node= ptr->data;
116         rctf *butr= &node->butr;
117
118         if(node->id) {
119                 uiBut *bt;
120                 short width;
121                 
122                 uiBlockBeginAlign(block);
123                 
124                 /* name button */
125                 width= (short)(butr->xmax-butr->xmin - (node->id->us>1?19.0f:0.0f));
126                 bt= uiDefBut(block, TEX, B_NOP, "NT:",
127                                          (short)butr->xmin, (short)butr->ymin, width, 19, 
128                                          node->id->name+2, 0.0, 19.0, 0, 0, "NodeTree name");
129                 uiButSetFunc(bt, node_ID_title_cb, node, NULL);
130                 
131                 /* user amount */
132                 if(node->id->us>1) {
133                         char str1[32];
134                         sprintf(str1, "%d", node->id->us);
135                         bt= uiDefBut(block, BUT, B_NOP, str1, 
136                                                  (short)butr->xmax-19, (short)butr->ymin, 19, 19, 
137                                                  NULL, 0, 0, 0, 0, "Displays number of users.");
138                         uiButSetFunc(bt, node_group_alone_cb, node, NULL);
139                 }
140                 
141                 uiBlockEndAlign(block);
142         }       
143 }
144 #endif
145
146 static void node_buts_value(uiLayout *layout, bContext *C, PointerRNA *ptr)
147 {
148         PointerRNA sockptr;
149         PropertyRNA *prop;
150         
151         /* first socket stores value */
152         prop = RNA_struct_find_property(ptr, "outputs");
153         RNA_property_collection_lookup_int(ptr, prop, 0, &sockptr);
154         
155         uiItemR(layout, "", 0, &sockptr, "default_value", 0);
156 }
157
158 static void node_buts_rgb(uiLayout *layout, bContext *C, PointerRNA *ptr)
159 {
160         uiLayout *col;
161         PointerRNA sockptr;
162         PropertyRNA *prop;
163         
164         /* first socket stores value */
165         prop = RNA_struct_find_property(ptr, "outputs");
166         RNA_property_collection_lookup_int(ptr, prop, 0, &sockptr);
167         
168         col = uiLayoutColumn(layout, 0);
169         uiItemR(col, "", 0, &sockptr, "default_value", 0);
170 }
171
172 static void node_buts_mix_rgb(uiLayout *layout, bContext *C, PointerRNA *ptr)
173 {       
174         uiLayout *row;
175
176         bNodeTree *ntree= (bNodeTree*)ptr->id.data;
177
178         row= uiLayoutRow(layout, 1);
179         uiItemR(row, "", 0, ptr, "blend_type", 0);
180         if(ntree->type == NTREE_COMPOSIT)
181                 uiItemR(row, "", ICON_IMAGE_RGB_ALPHA, ptr, "alpha", 0);
182 }
183
184 static void node_buts_time(uiLayout *layout, bContext *C, PointerRNA *ptr)
185 {
186         uiLayout *row;
187 #if 0
188         /* XXX no context access here .. */
189         bNode *node= ptr->data;
190         CurveMapping *cumap= node->storage;
191         
192         if(cumap) {
193                 cumap->flag |= CUMA_DRAW_CFRA;
194                 if(node->custom1<node->custom2)
195                         cumap->sample[0]= (float)(CFRA - node->custom1)/(float)(node->custom2-node->custom1);
196         }
197 #endif
198
199         uiTemplateCurveMapping(layout, ptr, "curve", 's', 0);
200
201         row= uiLayoutRow(layout, 1);
202         uiItemR(row, "Sta", 0, ptr, "start", 0);
203         uiItemR(row, "End", 0, ptr, "end", 0);
204 }
205
206 static void node_buts_colorramp(uiLayout *layout, bContext *C, PointerRNA *ptr)
207 {
208         uiTemplateColorRamp(layout, ptr, "color_ramp", 0);
209 }
210
211 static void node_buts_curvevec(uiLayout *layout, bContext *C, PointerRNA *ptr)
212 {
213         uiTemplateCurveMapping(layout, ptr, "mapping", 'v', 0);
214 }
215
216 static float *_sample_col= NULL;        // bad bad, 2.5 will do better?
217 void node_curvemap_sample(float *col)
218 {
219         _sample_col= col;
220 }
221
222 static void node_buts_curvecol(uiLayout *layout, bContext *C, PointerRNA *ptr)
223 {
224         bNode *node= ptr->data;
225         CurveMapping *cumap= node->storage;
226
227         if(_sample_col) {
228                 cumap->flag |= CUMA_DRAW_SAMPLE;
229                 VECCOPY(cumap->sample, _sample_col);
230         }
231         else 
232                 cumap->flag &= ~CUMA_DRAW_SAMPLE;
233
234         uiTemplateCurveMapping(layout, ptr, "mapping", 'c', 0);
235 }
236
237 static void node_buts_normal(uiLayout *layout, bContext *C, PointerRNA *ptr)
238 {
239         uiBlock *block= uiLayoutAbsoluteBlock(layout);
240         bNode *node= ptr->data;
241         rctf *butr= &node->butr;
242         bNodeSocket *sock= node->outputs.first;         /* first socket stores normal */
243         
244         uiDefButF(block, BUT_NORMAL, B_NODE_EXEC, "", 
245                           (short)butr->xmin, (short)butr->xmin, butr->xmax-butr->xmin, butr->xmax-butr->xmin, 
246                           sock->ns.vec, 0.0f, 1.0f, 0, 0, "");
247 }
248 #if 0 // not used in 2.5x yet
249 static void node_browse_tex_cb(bContext *C, void *ntree_v, void *node_v)
250 {
251         bNodeTree *ntree= ntree_v;
252         bNode *node= node_v;
253         Tex *tex;
254         
255         if(node->menunr<1) return;
256         
257         if(node->id) {
258                 node->id->us--;
259                 node->id= NULL;
260         }
261         tex= BLI_findlink(&G.main->tex, node->menunr-1);
262
263         node->id= &tex->id;
264         id_us_plus(node->id);
265         BLI_strncpy(node->name, node->id->name+2, 21);
266         
267         nodeSetActive(ntree, node);
268         
269         if( ntree->type == NTREE_TEXTURE )
270                 ntreeTexCheckCyclics( ntree );
271         
272         // allqueue(REDRAWBUTSSHADING, 0);
273         // allqueue(REDRAWNODE, 0);
274         NodeTagChanged(ntree, node); 
275         
276         node->menunr= 0;
277 }
278 #endif
279 static void node_dynamic_update_cb(bContext *C, void *ntree_v, void *node_v)
280 {
281         Material *ma;
282         bNode *node= (bNode *)node_v;
283         ID *id= node->id;
284         int error= 0;
285
286         if (BTST(node->custom1, NODE_DYNAMIC_ERROR)) error= 1;
287
288         /* Users only have to press the "update" button in one pynode
289          * and we also update all others sharing the same script */
290         for (ma= G.main->mat.first; ma; ma= ma->id.next) {
291                 if (ma->nodetree) {
292                         bNode *nd;
293                         for (nd= ma->nodetree->nodes.first; nd; nd= nd->next) {
294                                 if ((nd->type == NODE_DYNAMIC) && (nd->id == id)) {
295                                         nd->custom1= 0;
296                                         nd->custom1= BSET(nd->custom1, NODE_DYNAMIC_REPARSE);
297                                         nd->menunr= 0;
298                                         if (error)
299                                                 nd->custom1= BSET(nd->custom1, NODE_DYNAMIC_ERROR);
300                                 }
301                         }
302                 }
303         }
304
305         // allqueue(REDRAWBUTSSHADING, 0);
306         // allqueue(REDRAWNODE, 0);
307         // XXX BIF_preview_changed(ID_MA);
308 }
309
310 static void node_buts_texture(uiLayout *layout, bContext *C, PointerRNA *ptr)
311 {
312         bNode *node= ptr->data;
313
314         short multi = (
315                 node->id &&
316                 ((Tex*)node->id)->use_nodes &&
317                 (node->type != CMP_NODE_TEXTURE) &&
318                 (node->type != TEX_NODE_TEXTURE)
319         );
320         
321         uiItemR(layout, "", 0, ptr, "texture", 0);
322         
323         if(multi) {
324                 /* Number Drawing not optimal here, better have a list*/
325                 uiItemR(layout, "", 0, ptr, "node_output", 0);
326         }
327 }
328
329 static void node_buts_math(uiLayout *layout, bContext *C, PointerRNA *ptr)
330
331         uiItemR(layout, "", 0, ptr, "operation", 0);
332 }
333
334 /* ****************** BUTTON CALLBACKS FOR SHADER NODES ***************** */
335
336 static void node_browse_text_cb(bContext *C, void *ntree_v, void *node_v)
337 {
338         bNodeTree *ntree= ntree_v;
339         bNode *node= node_v;
340         ID *oldid;
341         
342         if(node->menunr<1) return;
343         
344         if(node->id) {
345                 node->id->us--;
346         }
347         oldid= node->id;
348         node->id= BLI_findlink(&G.main->text, node->menunr-1);
349         id_us_plus(node->id);
350         BLI_strncpy(node->name, node->id->name+2, 21); /* huh? why 21? */
351
352         node->custom1= BSET(node->custom1, NODE_DYNAMIC_NEW);
353         
354         nodeSetActive(ntree, node);
355
356         // allqueue(REDRAWBUTSSHADING, 0);
357         // allqueue(REDRAWNODE, 0);
358
359         node->menunr= 0;
360 }
361
362 static void node_shader_buts_material(uiLayout *layout, bContext *C, PointerRNA *ptr)
363 {
364         bNode *node= ptr->data;
365         uiLayout *col;
366         
367         uiTemplateID(layout, C, ptr, "material", "MATERIAL_OT_new", NULL, NULL);
368         
369         if(!node->id) return;
370         
371         col= uiLayoutColumn(layout, 0);
372         uiItemR(col, NULL, 0, ptr, "diffuse", 0);
373         uiItemR(col, NULL, 0, ptr, "specular", 0);
374         uiItemR(col, NULL, 0, ptr, "invert_normal", 0);
375 }
376
377 static void node_shader_buts_mapping(uiLayout *layout, bContext *C, PointerRNA *ptr)
378 {
379         uiLayout *row;
380         
381         uiItemL(layout, "Location:", 0);
382         row= uiLayoutRow(layout, 1);
383         uiItemR(row, "", 0, ptr, "location", 0);
384         
385         uiItemL(layout, "Rotation:", 0);
386         row= uiLayoutRow(layout, 1);
387         uiItemR(row, "", 0, ptr, "rotation", 0);
388         
389         uiItemL(layout, "Scale:", 0);
390         row= uiLayoutRow(layout, 1);
391         uiItemR(row, "", 0, ptr, "scale", 0);
392         
393         row= uiLayoutRow(layout, 1);
394         uiItemR(row, "Min", 0, ptr, "clamp_minimum", 0);
395         uiItemR(row, "", 0, ptr, "minimum", 0);
396         
397         row= uiLayoutRow(layout, 1);
398         uiItemR(row, "Max", 0, ptr, "clamp_maximum", 0);
399         uiItemR(row, "", 0, ptr, "maximum", 0);
400         
401 }
402
403 static void node_shader_buts_vect_math(uiLayout *layout, bContext *C, PointerRNA *ptr)
404
405         uiItemR(layout, "", 0, ptr, "operation", 0);
406 }
407
408 static void node_shader_buts_geometry(uiLayout *layout, bContext *C, PointerRNA *ptr)
409 {
410         uiLayout *col;
411         
412         col= uiLayoutColumn(layout, 0);
413         uiItemR(col, "UV", 0, ptr, "uv_layer", 0);
414         uiItemR(col, "VCol", 0, ptr, "color_layer", 0);
415 }
416
417 static void node_shader_buts_dynamic(uiLayout *layout, bContext *C, PointerRNA *ptr)
418
419         uiBlock *block= uiLayoutAbsoluteBlock(layout);
420         bNode *node= ptr->data;
421         bNodeTree *ntree= ptr->id.data;
422         rctf *butr= &node->butr;
423         uiBut *bt;
424         // XXX SpaceNode *snode= curarea->spacedata.first;
425         short dy= (short)butr->ymin;
426         int xoff=0;
427
428         /* B_NODE_EXEC is handled in butspace.c do_node_buts */
429         if(!node->id) {
430                         char *strp;
431                         IDnames_to_pupstring(&strp, NULL, "", &(G.main->text), NULL, NULL);
432                         node->menunr= 0;
433                         bt= uiDefButS(block, MENU, B_NODE_EXEC/*+node->nr*/, strp, 
434                                                         butr->xmin, dy, 19, 19, 
435                                                         &node->menunr, 0, 0, 0, 0, "Browses existing choices");
436                         uiButSetFunc(bt, node_browse_text_cb, ntree, node);
437                         xoff=19;
438                         if(strp) MEM_freeN(strp);       
439         }
440         else {
441                 bt = uiDefBut(block, BUT, B_NOP, "Update",
442                                 butr->xmin+xoff, butr->ymin+20, 50, 19,
443                                 &node->menunr, 0.0, 19.0, 0, 0, "Refresh this node (and all others that use the same script)");
444                 uiButSetFunc(bt, node_dynamic_update_cb, ntree, node);
445
446                 if (BTST(node->custom1, NODE_DYNAMIC_ERROR)) {
447                         // UI_ThemeColor(TH_REDALERT);
448                         // XXX ui_rasterpos_safe(butr->xmin + xoff, butr->ymin + 5, snode->aspect);
449                         // XXX snode_drawstring(snode, "Error! Check console...", butr->xmax - butr->xmin);
450                         ;
451                 }
452         }
453 }
454
455 /* only once called */
456 static void node_shader_set_butfunc(bNodeType *ntype)
457 {
458         switch(ntype->type) {
459                 /* case NODE_GROUP:      note, typeinfo for group is generated... see "XXX ugly hack" */
460
461                 case SH_NODE_MATERIAL:
462                 case SH_NODE_MATERIAL_EXT:
463                         ntype->uifunc= node_shader_buts_material;
464                         break;
465                 case SH_NODE_TEXTURE:
466                         ntype->uifunc= node_buts_texture;
467                         break;
468                 case SH_NODE_NORMAL:
469                         ntype->uifunc= node_buts_normal;
470                         break;
471                 case SH_NODE_CURVE_VEC:
472                         ntype->uifunc= node_buts_curvevec;
473                         break;
474                 case SH_NODE_CURVE_RGB:
475                         ntype->uifunc= node_buts_curvecol;
476                         break;
477                 case SH_NODE_MAPPING:
478                         ntype->uifunc= node_shader_buts_mapping;
479                         break;
480                 case SH_NODE_VALUE:
481                         ntype->uifunc= node_buts_value;
482                         break;
483                 case SH_NODE_RGB:
484                         ntype->uifunc= node_buts_rgb;
485                         break;
486                 case SH_NODE_MIX_RGB:
487                         ntype->uifunc= node_buts_mix_rgb;
488                         break;
489                 case SH_NODE_VALTORGB:
490                         ntype->uifunc= node_buts_colorramp;
491                         break;
492                 case SH_NODE_MATH: 
493                         ntype->uifunc= node_buts_math;
494                         break; 
495                 case SH_NODE_VECT_MATH: 
496                         ntype->uifunc= node_shader_buts_vect_math;
497                         break; 
498                 case SH_NODE_GEOMETRY:
499                         ntype->uifunc= node_shader_buts_geometry;
500                         break;
501                 case NODE_DYNAMIC:
502                         ntype->uifunc= node_shader_buts_dynamic;
503                         break;
504                 default:
505                         ntype->uifunc= NULL;
506         }
507 }
508
509 /* ****************** BUTTON CALLBACKS FOR COMPOSITE NODES ***************** */
510
511 static void node_composit_buts_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
512 {
513         uiLayout *col;
514         bNode *node= ptr->data;
515         PointerRNA imaptr;
516         PropertyRNA *prop;
517         
518         uiTemplateID(layout, C, ptr, "image", NULL, "IMAGE_OT_open", NULL);
519         
520         if(!node->id) return;
521         
522         prop = RNA_struct_find_property(ptr, "image");
523         if (!prop || RNA_property_type(prop) != PROP_POINTER) return;
524         imaptr= RNA_property_pointer_get(ptr, prop);
525         
526         col= uiLayoutColumn(layout, 0);
527         
528         uiItemR(col, NULL, 0, &imaptr, "source", 0);
529         
530         if (ELEM(RNA_enum_get(&imaptr, "source"), IMA_SRC_SEQUENCE, IMA_SRC_MOVIE)) {
531                 col= uiLayoutColumn(layout, 1);
532                 uiItemR(col, NULL, 0, ptr, "frames", 0);
533                 uiItemR(col, NULL, 0, ptr, "start", 0);
534                 uiItemR(col, NULL, 0, ptr, "offset", 0);
535                 uiItemR(col, NULL, 0, ptr, "cyclic", 0);
536                 uiItemR(col, NULL, 0, ptr, "auto_refresh", UI_ITEM_R_ICON_ONLY);
537         }
538
539         col= uiLayoutColumn(layout, 0);
540         
541         if (RNA_enum_get(&imaptr, "type")== IMA_TYPE_MULTILAYER)
542                 uiItemR(col, NULL, 0, ptr, "layer", 0);
543 }
544
545 static void node_composit_buts_renderlayers(uiLayout *layout, bContext *C, PointerRNA *ptr)
546 {
547         bNode *node= ptr->data;
548         uiLayout *col;
549
550         uiTemplateID(layout, C, ptr, "scene", NULL, NULL, NULL);
551         
552         if(!node->id) return;
553
554         col= uiLayoutColumn(layout, 0);
555         uiItemR(col, "", 0, ptr, "layer", 0);
556         
557         /* XXX Missing 're-render this layer' button - needs completely new implementation */
558 }
559
560
561 static void node_composit_buts_blur(uiLayout *layout, bContext *C, PointerRNA *ptr)
562 {
563         uiLayout *col;
564         
565         col= uiLayoutColumn(layout, 0);
566         
567         uiItemR(col, "", 0, ptr, "filter_type", 0);
568         if (RNA_enum_get(ptr, "filter_type")!= R_FILTER_FAST_GAUSS) {
569                 uiItemR(col, NULL, 0, ptr, "bokeh", 0);
570                 uiItemR(col, NULL, 0, ptr, "gamma", 0);
571         }
572         
573         uiItemR(col, NULL, 0, ptr, "relative", 0);
574         col= uiLayoutColumn(layout, 1);
575         if (RNA_boolean_get(ptr, "relative")) {
576                 uiItemR(col, "X", 0, ptr, "factor_x", 0);
577                 uiItemR(col, "Y", 0, ptr, "factor_y", 0);
578         }
579         else {
580                 uiItemR(col, "X", 0, ptr, "sizex", 0);
581                 uiItemR(col, "Y", 0, ptr, "sizey", 0);
582         }
583 }
584
585 static void node_composit_buts_dblur(uiLayout *layout, bContext *C, PointerRNA *ptr)
586 {
587         uiLayout *col;
588         
589         uiItemR(layout, NULL, 0, ptr, "iterations", 0);
590         uiItemR(layout, NULL, 0, ptr, "wrap", 0);
591         
592         col= uiLayoutColumn(layout, 1);
593         uiItemL(col, "Center:", 0);
594         uiItemR(col, "X", 0, ptr, "center_x", 0);
595         uiItemR(col, "Y", 0, ptr, "center_y", 0);
596         
597         uiItemS(layout);
598         
599         col= uiLayoutColumn(layout, 1);
600         uiItemR(col, NULL, 0, ptr, "distance", 0);
601         uiItemR(col, NULL, 0, ptr, "angle", 0);
602         
603         uiItemS(layout);
604         
605         uiItemR(layout, NULL, 0, ptr, "spin", 0);
606         uiItemR(layout, NULL, 0, ptr, "zoom", 0);
607 }
608
609 static void node_composit_buts_bilateralblur(uiLayout *layout, bContext *C, PointerRNA *ptr)
610 {       
611         uiLayout *col;
612         
613         col= uiLayoutColumn(layout, 1);
614         uiItemR(col, NULL, 0, ptr, "iterations", 0);
615         uiItemR(col, NULL, 0, ptr, "sigma_color", 0);
616         uiItemR(col, NULL, 0, ptr, "sigma_space", 0);
617 }
618
619 static void node_composit_buts_defocus(uiLayout *layout, bContext *C, PointerRNA *ptr)
620 {
621         uiLayout *sub, *col;
622         
623         col= uiLayoutColumn(layout, 0);
624         uiItemL(col, "Bokeh Type:", 0);
625         uiItemR(col, "", 0, ptr, "bokeh", 0);
626         uiItemR(col, NULL, 0, ptr, "angle", 0);
627
628         uiItemR(layout, NULL, 0, ptr, "gamma_correction", 0);
629
630         col = uiLayoutColumn(layout, 0);
631         uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_zbuffer")==1);
632         uiItemR(col, NULL, 0, ptr, "f_stop", 0);
633
634         uiItemR(layout, NULL, 0, ptr, "max_blur", 0);
635         uiItemR(layout, NULL, 0, ptr, "threshold", 0);
636
637         col = uiLayoutColumn(layout, 0);
638         uiItemR(col, NULL, 0, ptr, "preview", 0);
639         sub = uiLayoutColumn(col, 0);
640         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "preview"));
641         uiItemR(sub, NULL, 0, ptr, "samples", 0);
642         
643         col = uiLayoutColumn(layout, 0);
644         uiItemR(col, NULL, 0, ptr, "use_zbuffer", 0);
645         sub = uiLayoutColumn(col, 0);
646         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_zbuffer")==0);
647         uiItemR(sub, NULL, 0, ptr, "z_scale", 0);
648 }
649
650 /* qdn: glare node */
651 static void node_composit_buts_glare(uiLayout *layout, bContext *C, PointerRNA *ptr)
652 {       
653         uiItemR(layout, "", 0, ptr, "glare_type", 0);
654         uiItemR(layout, "", 0, ptr, "quality", 0);
655
656         if (RNA_enum_get(ptr, "glare_type")!= 1) {
657                 uiItemR(layout, NULL, 0, ptr, "iterations", 0);
658         
659                 if (RNA_enum_get(ptr, "glare_type")!= 0) 
660                         uiItemR(layout, NULL, 0, ptr, "color_modulation", UI_ITEM_R_SLIDER);
661         }
662         
663         uiItemR(layout, NULL, 0, ptr, "mix", 0);                
664         uiItemR(layout, NULL, 0, ptr, "threshold", 0);
665
666         if (RNA_enum_get(ptr, "glare_type")== 2) {
667                 uiItemR(layout, NULL, 0, ptr, "streaks", 0);            
668                 uiItemR(layout, NULL, 0, ptr, "angle_offset", 0);
669         }
670         if (RNA_enum_get(ptr, "glare_type")== 0 || RNA_enum_get(ptr, "glare_type")== 2) {
671                 uiItemR(layout, NULL, 0, ptr, "fade", UI_ITEM_R_SLIDER);
672                 
673                 if (RNA_enum_get(ptr, "glare_type")== 0) 
674                         uiItemR(layout, NULL, 0, ptr, "rotate_45", 0);
675         }
676         if (RNA_enum_get(ptr, "glare_type")== 1) {
677                 uiItemR(layout, NULL, 0, ptr, "size", 0);
678         }
679 }
680
681 static void node_composit_buts_tonemap(uiLayout *layout, bContext *C, PointerRNA *ptr)
682 {       
683         uiLayout *col;
684
685         col = uiLayoutColumn(layout, 0);
686         uiItemR(col, "", 0, ptr, "tonemap_type", 0);
687         if (RNA_enum_get(ptr, "tonemap_type")== 0) {
688                 uiItemR(col, NULL, 0, ptr, "key", UI_ITEM_R_SLIDER);
689                 uiItemR(col, NULL, 0, ptr, "offset", 0);
690                 uiItemR(col, NULL, 0, ptr, "gamma", 0);
691         }
692         else {
693                 uiItemR(col, NULL, 0, ptr, "intensity", 0);
694                 uiItemR(col, NULL, 0, ptr, "contrast", UI_ITEM_R_SLIDER);
695                 uiItemR(col, NULL, 0, ptr, "adaptation", UI_ITEM_R_SLIDER);
696                 uiItemR(col, NULL, 0, ptr, "correction", UI_ITEM_R_SLIDER);
697         }
698 }
699
700 static void node_composit_buts_lensdist(uiLayout *layout, bContext *C, PointerRNA *ptr)
701 {
702         uiLayout *col;
703
704         col= uiLayoutColumn(layout, 0);
705         uiItemR(col, NULL, 0, ptr, "projector", 0);
706
707         col = uiLayoutColumn(col, 0);
708         uiLayoutSetActive(col, RNA_boolean_get(ptr, "projector")==0);
709         uiItemR(col, NULL, 0, ptr, "jitter", 0);
710         uiItemR(col, NULL, 0, ptr, "fit", 0);
711 }
712
713 static void node_composit_buts_vecblur(uiLayout *layout, bContext *C, PointerRNA *ptr)
714 {
715         uiLayout *col;
716         
717         col= uiLayoutColumn(layout, 0);
718         uiItemR(col, NULL, 0, ptr, "samples", 0);
719         uiItemR(col, "Blur", 0, ptr, "factor", 0);
720         
721         col= uiLayoutColumn(layout, 1);
722         uiItemL(col, "Speed:", 0);
723         uiItemR(col, "Min", 0, ptr, "min_speed", 0);
724         uiItemR(col, "Max", 0, ptr, "max_speed", 0);
725
726         uiItemR(layout, NULL, 0, ptr, "curved", 0);
727 }
728
729 static void node_composit_buts_filter(uiLayout *layout, bContext *C, PointerRNA *ptr)
730 {
731         uiItemR(layout, "", 0, ptr, "filter_type", 0);
732 }
733
734 static void node_composit_buts_flip(uiLayout *layout, bContext *C, PointerRNA *ptr)
735 {
736         uiItemR(layout, "", 0, ptr, "axis", 0);
737 }
738
739 static void node_composit_buts_crop(uiLayout *layout, bContext *C, PointerRNA *ptr)
740 {
741         uiLayout *col;
742         
743         uiItemR(layout, NULL, 0, ptr, "crop_size", 0);
744         
745         col= uiLayoutColumn(layout, 1);
746         uiItemR(col, "Left", 0, ptr, "x1", 0);
747         uiItemR(col, "Right", 0, ptr, "x2", 0);
748         uiItemR(col, "Up", 0, ptr, "y1", 0);
749         uiItemR(col, "Down", 0, ptr, "y2", 0);
750 }
751
752 static void node_composit_buts_splitviewer(uiLayout *layout, bContext *C, PointerRNA *ptr)
753 {
754         uiLayout *row, *col;
755         
756         col= uiLayoutColumn(layout, 0);
757         row= uiLayoutRow(col, 0);
758         uiItemR(row, NULL, 0, ptr, "axis", UI_ITEM_R_EXPAND);
759         uiItemR(col, NULL, 0, ptr, "factor", 0);
760 }
761
762 static void node_composit_buts_map_value(uiLayout *layout, bContext *C, PointerRNA *ptr)
763 {
764         uiLayout *sub, *col;
765         
766         col =uiLayoutColumn(layout, 1);
767         uiItemR(col, NULL, 0, ptr, "offset", 0);
768         uiItemR(col, NULL, 0, ptr, "size", 0);
769         
770         col =uiLayoutColumn(layout, 1);
771         uiItemR(col, NULL, 0, ptr, "use_min", 0);
772         sub =uiLayoutColumn(col, 0);
773         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_min"));
774         uiItemR(sub, "", 0, ptr, "min", 0);
775         
776         col =uiLayoutColumn(layout, 1);
777         uiItemR(col, NULL, 0, ptr, "use_max", 0);
778         sub =uiLayoutColumn(col, 0);
779         uiLayoutSetActive(sub, RNA_boolean_get(ptr, "use_max"));
780         uiItemR(sub, "", 0, ptr, "max", 0);
781 }
782
783 static void node_composit_buts_alphaover(uiLayout *layout, bContext *C, PointerRNA *ptr)
784 {       
785         uiLayout *col;
786         
787         col =uiLayoutColumn(layout, 1);
788         uiItemR(col, NULL, 0, ptr, "convert_premul", 0);
789         uiItemR(col, NULL, 0, ptr, "premul", 0);
790 }
791
792 static void node_composit_buts_hue_sat(uiLayout *layout, bContext *C, PointerRNA *ptr)
793 {
794         uiLayout *col;
795         
796         col =uiLayoutColumn(layout, 0);
797         uiItemR(col, NULL, 0, ptr, "hue", UI_ITEM_R_SLIDER);
798         uiItemR(col, NULL, 0, ptr, "sat", UI_ITEM_R_SLIDER);
799         uiItemR(col, NULL, 0, ptr, "val", UI_ITEM_R_SLIDER);
800 }
801
802 static void node_composit_buts_dilateerode(uiLayout *layout, bContext *C, PointerRNA *ptr)
803 {
804         uiItemR(layout, NULL, 0, ptr, "distance", 0);
805 }
806
807 static void node_composit_buts_diff_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
808 {
809         uiLayout *col;
810         
811         col =uiLayoutColumn(layout, 1);
812         uiItemR(col, NULL, 0, ptr, "tolerance", UI_ITEM_R_SLIDER);
813         uiItemR(col, NULL, 0, ptr, "falloff", UI_ITEM_R_SLIDER);
814 }
815
816 static void node_composit_buts_distance_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
817 {
818         uiLayout *col;
819         
820         col =uiLayoutColumn(layout, 1);
821         uiItemR(col, NULL, 0, ptr, "tolerance", UI_ITEM_R_SLIDER);
822         uiItemR(col, NULL, 0, ptr, "falloff", UI_ITEM_R_SLIDER);
823 }
824
825 static void node_composit_buts_color_spill(uiLayout *layout, bContext *C, PointerRNA *ptr)
826 {
827         uiLayout *row, *col;
828         
829         col =uiLayoutColumn(layout, 0);
830         uiItemR(col, NULL, 0, ptr, "factor", 0);
831         row= uiLayoutRow(col, 0);
832         uiItemR(row, NULL, 0, ptr, "channel", UI_ITEM_R_EXPAND);
833 }
834
835 static void node_composit_buts_chroma_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
836 {
837         uiLayout *col;
838         
839         col= uiLayoutColumn(layout, 0);
840         uiItemR(col, NULL, 0, ptr, "acceptance", 0);
841         uiItemR(col, NULL, 0, ptr, "cutoff", 0);
842         
843         col= uiLayoutColumn(layout, 1);
844         uiItemR(col, NULL, 0, ptr, "lift", UI_ITEM_R_SLIDER);
845         uiItemR(col, NULL, 0, ptr, "gain", UI_ITEM_R_SLIDER);
846         uiItemR(col, NULL, 0, ptr, "shadow_adjust", UI_ITEM_R_SLIDER);
847 }
848
849 static void node_composit_buts_color_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
850 {
851         uiLayout *col;
852         
853         col= uiLayoutColumn(layout, 1);
854         uiItemR(col, NULL, 0, ptr, "h", UI_ITEM_R_SLIDER);
855         uiItemR(col, NULL, 0, ptr, "s", UI_ITEM_R_SLIDER);
856         uiItemR(col, NULL, 0, ptr, "v", UI_ITEM_R_SLIDER);
857 }
858
859 static void node_composit_buts_channel_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
860 {       
861         uiLayout *col, *row;
862
863         row= uiLayoutRow(layout, 0);
864         uiItemR(row, NULL, 0, ptr, "color_space", UI_ITEM_R_EXPAND);
865
866         row= uiLayoutRow(layout, 0);
867         uiItemR(row, NULL, 0, ptr, "channel", UI_ITEM_R_EXPAND);
868
869         col =uiLayoutColumn(layout, 1);
870         uiItemR(col, NULL, 0, ptr, "high", UI_ITEM_R_SLIDER);
871         uiItemR(col, NULL, 0, ptr, "low", UI_ITEM_R_SLIDER);
872 }
873
874 static void node_composit_buts_luma_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
875 {
876         uiLayout *col;
877         
878         col= uiLayoutColumn(layout, 1);
879         uiItemR(col, NULL, 0, ptr, "high", UI_ITEM_R_SLIDER);
880         uiItemR(col, NULL, 0, ptr, "low", UI_ITEM_R_SLIDER);
881 }
882
883 static void node_composit_buts_map_uv(uiLayout *layout, bContext *C, PointerRNA *ptr)
884 {
885         uiItemR(layout, NULL, 0, ptr, "alpha", 0);
886 }
887
888 static void node_composit_buts_id_mask(uiLayout *layout, bContext *C, PointerRNA *ptr)
889 {
890         uiItemR(layout, NULL, 0, ptr, "index", 0);
891 }
892
893 static void node_composit_buts_file_output(uiLayout *layout, bContext *C, PointerRNA *ptr)
894 {
895         uiLayout *col, *row;
896
897         col= uiLayoutColumn(layout, 0);
898         uiItemR(col, "", 0, ptr, "filename", 0);
899         uiItemR(col, "", 0, ptr, "image_type", 0);
900         
901         row= uiLayoutRow(layout, 0);
902         if (RNA_enum_get(ptr, "image_type")== R_OPENEXR) {
903                 uiItemR(row, NULL, 0, ptr, "exr_half", 0);
904                 uiItemR(row, "", 0, ptr, "exr_codec", 0);
905         }
906         else if (RNA_enum_get(ptr, "image_type")== R_JPEG90) {
907                 uiItemR(row, NULL, 0, ptr, "quality", UI_ITEM_R_SLIDER);
908         }
909         
910         row= uiLayoutRow(layout, 1);
911         uiItemR(row, "Start", 0, ptr, "start_frame", 0);
912         uiItemR(row, "End", 0, ptr, "end_frame", 0);
913 }
914
915 static void node_composit_buts_scale(uiLayout *layout, bContext *C, PointerRNA *ptr)
916 {
917         uiItemR(layout, "", 0, ptr, "space", 0);
918 }
919
920 static void node_composit_buts_invert(uiLayout *layout, bContext *C, PointerRNA *ptr)
921 {
922         uiLayout *col;
923         
924         col= uiLayoutColumn(layout, 0);
925         uiItemR(col, NULL, 0, ptr, "rgb", 0);
926         uiItemR(col, NULL, 0, ptr, "alpha", 0);
927 }
928
929 static void node_composit_buts_premulkey(uiLayout *layout, bContext *C, PointerRNA *ptr)
930 {
931         uiItemR(layout, "", 0, ptr, "mapping", 0);
932 }
933
934 static void node_composit_buts_view_levels(uiLayout *layout, bContext *C, PointerRNA *ptr)
935 {
936         uiItemR(layout, NULL, 0, ptr, "channel", UI_ITEM_R_EXPAND);
937 }
938
939 /* only once called */
940 static void node_composit_set_butfunc(bNodeType *ntype)
941 {
942         switch(ntype->type) {
943                 /* case NODE_GROUP:      note, typeinfo for group is generated... see "XXX ugly hack" */
944
945                 case CMP_NODE_IMAGE:
946                         ntype->uifunc= node_composit_buts_image;
947                         break;
948                 case CMP_NODE_R_LAYERS:
949                         ntype->uifunc= node_composit_buts_renderlayers;
950                         break;
951                 case CMP_NODE_NORMAL:
952                         ntype->uifunc= node_buts_normal;
953                         break;
954                 case CMP_NODE_CURVE_VEC:
955                         ntype->uifunc= node_buts_curvevec;
956                         break;
957                 case CMP_NODE_CURVE_RGB:
958                         ntype->uifunc= node_buts_curvecol;
959                         break;
960                 case CMP_NODE_VALUE:
961                         ntype->uifunc= node_buts_value;
962                         break;
963                 case CMP_NODE_RGB:
964                         ntype->uifunc= node_buts_rgb;
965                         break;
966                 case CMP_NODE_FLIP:
967                         ntype->uifunc= node_composit_buts_flip;
968                         break;
969                 case CMP_NODE_SPLITVIEWER:
970                         ntype->uifunc= node_composit_buts_splitviewer;
971                         break;
972                 case CMP_NODE_MIX_RGB:
973                         ntype->uifunc= node_buts_mix_rgb;
974                         break;
975                 case CMP_NODE_VALTORGB:
976                         ntype->uifunc= node_buts_colorramp;
977                         break;
978                 case CMP_NODE_CROP:
979                         ntype->uifunc= node_composit_buts_crop;
980                         break;
981                 case CMP_NODE_BLUR:
982                         ntype->uifunc= node_composit_buts_blur;
983                         break;
984                 case CMP_NODE_DBLUR:
985                         ntype->uifunc= node_composit_buts_dblur;
986                         break;
987                 case CMP_NODE_BILATERALBLUR:
988                         ntype->uifunc= node_composit_buts_bilateralblur;
989                         break;
990                 case CMP_NODE_DEFOCUS:
991                         ntype->uifunc = node_composit_buts_defocus;
992                         break;
993                 case CMP_NODE_GLARE:
994                         ntype->uifunc = node_composit_buts_glare;
995                         break;
996                 case CMP_NODE_TONEMAP:
997                         ntype->uifunc = node_composit_buts_tonemap;
998                         break;
999                 case CMP_NODE_LENSDIST:
1000                         ntype->uifunc = node_composit_buts_lensdist;
1001                         break;
1002                 case CMP_NODE_VECBLUR:
1003                         ntype->uifunc= node_composit_buts_vecblur;
1004                         break;
1005                 case CMP_NODE_FILTER:
1006                         ntype->uifunc= node_composit_buts_filter;
1007                         break;
1008                 case CMP_NODE_MAP_VALUE:
1009                         ntype->uifunc= node_composit_buts_map_value;
1010                         break;
1011                 case CMP_NODE_TIME:
1012                         ntype->uifunc= node_buts_time;
1013                         break;
1014                 case CMP_NODE_ALPHAOVER:
1015                         ntype->uifunc= node_composit_buts_alphaover;
1016                         break;
1017                 case CMP_NODE_HUE_SAT:
1018                         ntype->uifunc= node_composit_buts_hue_sat;
1019                         break;
1020                 case CMP_NODE_TEXTURE:
1021                         ntype->uifunc= node_buts_texture;
1022                         break;
1023                 case CMP_NODE_DILATEERODE:
1024                         ntype->uifunc= node_composit_buts_dilateerode;
1025                         break;
1026                 case CMP_NODE_OUTPUT_FILE:
1027                         ntype->uifunc= node_composit_buts_file_output;
1028                         break;  
1029                 case CMP_NODE_DIFF_MATTE:
1030                         ntype->uifunc=node_composit_buts_diff_matte;
1031                         break;
1032                 case CMP_NODE_DIST_MATTE:
1033                         ntype->uifunc=node_composit_buts_distance_matte;
1034                         break;
1035                 case CMP_NODE_COLOR_SPILL:
1036                         ntype->uifunc=node_composit_buts_color_spill;
1037                         break;
1038                 case CMP_NODE_CHROMA_MATTE:
1039                         ntype->uifunc=node_composit_buts_chroma_matte;
1040                         break;
1041                 case CMP_NODE_COLOR_MATTE:
1042                         ntype->uifunc=node_composit_buts_color_matte;
1043                         break;
1044                 case CMP_NODE_SCALE:
1045                         ntype->uifunc= node_composit_buts_scale;
1046                         break;
1047                 case CMP_NODE_CHANNEL_MATTE:
1048                         ntype->uifunc= node_composit_buts_channel_matte;
1049                         break;
1050                 case CMP_NODE_LUMA_MATTE:
1051                         ntype->uifunc= node_composit_buts_luma_matte;
1052                         break;
1053                 case CMP_NODE_MAP_UV:
1054                         ntype->uifunc= node_composit_buts_map_uv;
1055                         break;
1056                 case CMP_NODE_ID_MASK:
1057                         ntype->uifunc= node_composit_buts_id_mask;
1058                         break;
1059                 case CMP_NODE_MATH:
1060                         ntype->uifunc= node_buts_math;
1061                         break;
1062                 case CMP_NODE_INVERT:
1063                         ntype->uifunc= node_composit_buts_invert;
1064                         break;
1065                 case CMP_NODE_PREMULKEY:
1066                         ntype->uifunc= node_composit_buts_premulkey;
1067                         break;
1068       case CMP_NODE_VIEW_LEVELS:
1069                         ntype->uifunc=node_composit_buts_view_levels;
1070                         break;
1071                 default:
1072                         ntype->uifunc= NULL;
1073         }
1074 }
1075
1076 /* ****************** BUTTON CALLBACKS FOR TEXTURE NODES ***************** */
1077
1078 static void node_texture_buts_bricks(uiLayout *layout, bContext *C, PointerRNA *ptr)
1079 {
1080         uiLayout *col;
1081         
1082         col= uiLayoutColumn(layout, 1);
1083         uiItemR(col, "Offset", 0, ptr, "offset", 0);
1084         uiItemR(col, "Frequency", 0, ptr, "offset_frequency", 0);
1085         
1086         col= uiLayoutColumn(layout, 1);
1087         uiItemR(col, "Squash", 0, ptr, "squash", 0);
1088         uiItemR(col, "Frequency", 0, ptr, "squash_frequency", 0);
1089 }
1090
1091 static void node_texture_buts_proc(uiLayout *layout, bContext *C, PointerRNA *ptr)
1092 {
1093         PointerRNA tex_ptr;
1094         bNode *node= ptr->data;
1095         ID *id= ptr->id.data;
1096         Tex *tex = (Tex *)node->storage;
1097         uiLayout *col, *row;
1098         
1099         RNA_pointer_create(id, &RNA_Texture, tex, &tex_ptr);
1100
1101         col= uiLayoutColumn(layout, 0);
1102
1103         switch( tex->type ) {
1104                 case TEX_BLEND:
1105                         uiItemR(col, "", 0, &tex_ptr, "progression", 0);
1106                         row= uiLayoutRow(col, 0);
1107                         uiItemR(row, NULL, 0, &tex_ptr, "flip_axis", UI_ITEM_R_EXPAND);
1108                         break;
1109
1110                 case TEX_MARBLE:
1111                         row= uiLayoutRow(col, 0);
1112                         uiItemR(row, NULL, 0, &tex_ptr, "stype", UI_ITEM_R_EXPAND);
1113                         row= uiLayoutRow(col, 0);
1114                         uiItemR(row, NULL, 0, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND);
1115                         row= uiLayoutRow(col, 0);
1116                         uiItemR(row, NULL, 0, &tex_ptr, "noisebasis2", UI_ITEM_R_EXPAND);
1117                         break;
1118
1119                 case TEX_WOOD:
1120                         uiItemR(col, "", 0, &tex_ptr, "noise_basis", 0);
1121                         uiItemR(col, "", 0, &tex_ptr, "stype", 0);
1122                         row= uiLayoutRow(col, 0);
1123                         uiItemR(row, NULL, 0, &tex_ptr, "noisebasis2", UI_ITEM_R_EXPAND);
1124                         row= uiLayoutRow(col, 0);
1125                         uiLayoutSetActive(row, !(RNA_enum_get(&tex_ptr, "stype")==TEX_BAND || RNA_enum_get(&tex_ptr, "stype")==TEX_RING)); 
1126                         uiItemR(row, NULL, 0, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND);
1127                         break;
1128                         
1129                 case TEX_CLOUDS:
1130                         uiItemR(col, "", 0, &tex_ptr, "noise_basis", 0);
1131                         row= uiLayoutRow(col, 0);
1132                         uiItemR(row, NULL, 0, &tex_ptr, "stype", UI_ITEM_R_EXPAND);
1133                         row= uiLayoutRow(col, 0);
1134                         uiItemR(row, NULL, 0, &tex_ptr, "noise_type", UI_ITEM_R_EXPAND);
1135                         uiItemR(col, "Depth", 0, &tex_ptr, "noise_depth", UI_ITEM_R_EXPAND);
1136                         break;
1137                         
1138                 case TEX_DISTNOISE:
1139                         uiItemR(col, "", 0, &tex_ptr, "noise_basis", 0);
1140                         uiItemR(col, "", 0, &tex_ptr, "noise_distortion", 0);
1141                         break;
1142         }
1143 }
1144
1145 static void node_texture_buts_image(uiLayout *layout, bContext *C, PointerRNA *ptr)
1146 {
1147         uiTemplateID(layout, C, ptr, "image", NULL, "IMAGE_OT_open", NULL);
1148 }
1149
1150 static void node_texture_buts_output(uiLayout *layout, bContext *C, PointerRNA *ptr)
1151 {
1152         uiItemR(layout, "", 0, ptr, "output_name", 0);
1153 }
1154
1155 /* only once called */
1156 static void node_texture_set_butfunc(bNodeType *ntype)
1157 {
1158         if( ntype->type >= TEX_NODE_PROC && ntype->type < TEX_NODE_PROC_MAX ) {
1159                 ntype->uifunc = node_texture_buts_proc;
1160         }
1161         else switch(ntype->type) {
1162                 
1163                 case TEX_NODE_MATH:
1164                         ntype->uifunc = node_buts_math;
1165                         break;
1166                 
1167                 case TEX_NODE_MIX_RGB:
1168                         ntype->uifunc = node_buts_mix_rgb;
1169                         break;
1170                         
1171                 case TEX_NODE_VALTORGB:
1172                         ntype->uifunc = node_buts_colorramp;
1173                         break;
1174                         
1175                 case TEX_NODE_CURVE_RGB:
1176                         ntype->uifunc= node_buts_curvecol;
1177                         break;
1178                         
1179                 case TEX_NODE_CURVE_TIME:
1180                         ntype->uifunc = node_buts_time;
1181                         break;
1182                         
1183                 case TEX_NODE_TEXTURE:
1184                         ntype->uifunc = node_buts_texture;
1185                         break;
1186                         
1187                 case TEX_NODE_BRICKS:
1188                         ntype->uifunc = node_texture_buts_bricks;
1189                         break;
1190                         
1191                 case TEX_NODE_IMAGE:
1192                         ntype->uifunc = node_texture_buts_image;
1193                         break;
1194                         
1195                 case TEX_NODE_OUTPUT:
1196                         ntype->uifunc = node_texture_buts_output;
1197                         break;
1198                         
1199                 default:
1200                         ntype->uifunc= NULL;
1201         }
1202 }
1203
1204 /* ******* init draw callbacks for all tree types, only called in usiblender.c, once ************* */
1205
1206 void ED_init_node_butfuncs(void)
1207 {
1208         bNodeType *ntype;
1209         
1210         /* shader nodes */
1211         ntype= node_all_shaders.first;
1212         while(ntype) {
1213                 node_shader_set_butfunc(ntype);
1214                 ntype= ntype->next;
1215         }
1216         /* composit nodes */
1217         ntype= node_all_composit.first;
1218         while(ntype) {
1219                 node_composit_set_butfunc(ntype);
1220                 ntype= ntype->next;
1221         }
1222         ntype = node_all_textures.first;
1223         while(ntype) {
1224                 node_texture_set_butfunc(ntype);
1225                 ntype= ntype->next;
1226         }
1227 }
1228
1229 /* ************** Generic drawing ************** */
1230
1231 void draw_nodespace_back_pix(ARegion *ar, SpaceNode *snode, int color_manage)
1232 {
1233         
1234         if((snode->flag & SNODE_BACKDRAW) && snode->treetype==NTREE_COMPOSIT) {
1235                 Image *ima= BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
1236                 void *lock;
1237                 ImBuf *ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
1238                 if(ibuf) {
1239                         float x, y; 
1240                         
1241                         wmPushMatrix();
1242                         
1243                         /* somehow the offset has to be calculated inverse */
1244                         
1245                         glaDefine2DArea(&ar->winrct);
1246                         /* ortho at pixel level curarea */
1247                         wmOrtho2(-0.375, ar->winx-0.375, -0.375, ar->winy-0.375);
1248                         
1249                         x = (ar->winx-ibuf->x)/2 + snode->xof;
1250                         y = (ar->winy-ibuf->y)/2 + snode->yof;
1251                         
1252                         if(!ibuf->rect) {
1253                                 if(color_manage)
1254                                         ibuf->profile= IB_PROFILE_SRGB;
1255                                 else
1256                                         ibuf->profile = IB_PROFILE_NONE;
1257                                 IMB_rect_from_float(ibuf);
1258                         }
1259
1260                         if(ibuf->rect)
1261                                 glaDrawPixelsSafe(x, y, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect);
1262                         
1263                         wmPopMatrix();
1264                 }
1265
1266                 BKE_image_release_ibuf(ima, lock);
1267         }
1268 }
1269
1270 #if 0
1271 /* note: needs to be userpref or opengl profile option */
1272 static void draw_nodespace_back_tex(ScrArea *sa, SpaceNode *snode)
1273 {
1274
1275         draw_nodespace_grid(snode);
1276         
1277         if(snode->flag & SNODE_BACKDRAW) {
1278                 Image *ima= BKE_image_verify_viewer(IMA_TYPE_COMPOSITE, "Viewer Node");
1279                 ImBuf *ibuf= BKE_image_get_ibuf(ima, NULL);
1280                 if(ibuf) {
1281                         int x, y;
1282                         float zoom = 1.0;
1283
1284                         glMatrixMode(GL_PROJECTION);
1285                         glPushMatrix();
1286                         glMatrixMode(GL_MODELVIEW);
1287                         glPushMatrix();
1288                         
1289                         glaDefine2DArea(&sa->winrct);
1290
1291                         if(ibuf->x > sa->winx || ibuf->y > sa->winy) {
1292                                 float zoomx, zoomy;
1293                                 zoomx= (float)sa->winx/ibuf->x;
1294                                 zoomy= (float)sa->winy/ibuf->y;
1295                                 zoom = MIN2(zoomx, zoomy);
1296                         }
1297                         
1298                         x = (sa->winx-zoom*ibuf->x)/2 + snode->xof;
1299                         y = (sa->winy-zoom*ibuf->y)/2 + snode->yof;
1300
1301                         glPixelZoom(zoom, zoom);
1302
1303                         glColor4f(1.0, 1.0, 1.0, 1.0);
1304                         if(ibuf->rect)
1305                                 glaDrawPixelsTex(x, y, ibuf->x, ibuf->y, GL_UNSIGNED_BYTE, ibuf->rect);
1306                         else if(ibuf->channels==4)
1307                                 glaDrawPixelsTex(x, y, ibuf->x, ibuf->y, GL_FLOAT, ibuf->rect_float);
1308
1309                         glPixelZoom(1.0, 1.0);
1310
1311                         glMatrixMode(GL_PROJECTION);
1312                         glPopMatrix();
1313                         glMatrixMode(GL_MODELVIEW);
1314                         glPopMatrix();
1315                 }
1316         }
1317 }
1318 #endif
1319
1320 /* if v2d not NULL, it clips and returns 0 if not visible */
1321 int node_link_bezier_points(View2D *v2d, SpaceNode *snode, bNodeLink *link, float coord_array[][2], int resol)
1322 {
1323         float dist, vec[4][2];
1324         
1325         /* in v0 and v3 we put begin/end points */
1326         if(link->fromsock) {
1327                 vec[0][0]= link->fromsock->locx;
1328                 vec[0][1]= link->fromsock->locy;
1329         }
1330         else {
1331                 if(snode==NULL) return 0;
1332                 vec[0][0]= snode->mx;
1333                 vec[0][1]= snode->my;
1334         }
1335         if(link->tosock) {
1336                 vec[3][0]= link->tosock->locx;
1337                 vec[3][1]= link->tosock->locy;
1338         }
1339         else {
1340                 if(snode==NULL) return 0;
1341                 vec[3][0]= snode->mx;
1342                 vec[3][1]= snode->my;
1343         }
1344         
1345         dist= 0.5f*ABS(vec[0][0] - vec[3][0]);
1346         
1347         /* check direction later, for top sockets */
1348         vec[1][0]= vec[0][0]+dist;
1349         vec[1][1]= vec[0][1];
1350         
1351         vec[2][0]= vec[3][0]-dist;
1352         vec[2][1]= vec[3][1];
1353         
1354         if(v2d && MIN4(vec[0][0], vec[1][0], vec[2][0], vec[3][0]) > v2d->cur.xmax); /* clipped */      
1355         else if (v2d && MAX4(vec[0][0], vec[1][0], vec[2][0], vec[3][0]) < v2d->cur.xmin); /* clipped */
1356         else {
1357                 
1358                 /* always do all three, to prevent data hanging around */
1359                 forward_diff_bezier(vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0], resol, sizeof(float)*2);
1360                 forward_diff_bezier(vec[0][1], vec[1][1], vec[2][1], vec[3][1], coord_array[0]+1, resol, sizeof(float)*2);
1361                 
1362                 return 1;
1363         }
1364         return 0;
1365 }
1366
1367 #define LINK_RESOL      24
1368 void node_draw_link_bezier(View2D *v2d, SpaceNode *snode, bNodeLink *link, int th_col1, int th_col2, int do_shaded)
1369 {
1370         float coord_array[LINK_RESOL+1][2];
1371         
1372         if(node_link_bezier_points(v2d, snode, link, coord_array, LINK_RESOL)) {
1373                 float dist, spline_step = 0.0f;
1374                 int i;
1375                 
1376                 /* we can reuse the dist variable here to increment the GL curve eval amount*/
1377                 dist = 1.0f/(float)LINK_RESOL;
1378                 
1379                 glBegin(GL_LINE_STRIP);
1380                 for(i=0; i<=LINK_RESOL; i++) {
1381                         if(do_shaded) {
1382                                 UI_ThemeColorBlend(th_col1, th_col2, spline_step);
1383                                 spline_step += dist;
1384                         }                               
1385                         glVertex2fv(coord_array[i]);
1386                 }
1387                 glEnd();
1388         }
1389 }
1390
1391 /* note; this is used for fake links in groups too */
1392 void node_draw_link(View2D *v2d, SpaceNode *snode, bNodeLink *link)
1393 {
1394         int do_shaded= 1, th_col1= TH_WIRE, th_col2= TH_WIRE;
1395         
1396         if(link->fromnode==NULL && link->tonode==NULL)
1397                 return;
1398         
1399         if(link->fromnode==NULL || link->tonode==NULL) {
1400                 UI_ThemeColor(TH_WIRE);
1401                 do_shaded= 0;
1402         }
1403         else {
1404                 /* going to give issues once... */
1405                 if(link->tosock->flag & SOCK_UNAVAIL)
1406                         return;
1407                 if(link->fromsock->flag & SOCK_UNAVAIL)
1408                         return;
1409                 
1410                 /* a bit ugly... but thats how we detect the internal group links */
1411                 if(link->fromnode==link->tonode) {
1412                         UI_ThemeColorBlend(TH_BACK, TH_WIRE, 0.25f);
1413                         do_shaded= 0;
1414                 }
1415                 else {
1416                         /* check cyclic */
1417                         if(link->fromnode->level >= link->tonode->level && link->tonode->level!=0xFFF) {
1418                                 if(link->fromnode->flag & SELECT)
1419                                         th_col1= TH_EDGE_SELECT;
1420                                 if(link->tonode->flag & SELECT)
1421                                         th_col2= TH_EDGE_SELECT;
1422                         }                               
1423                         else {
1424                                 UI_ThemeColor(TH_REDALERT);
1425                                 do_shaded= 0;
1426                         }
1427                 }
1428         }
1429         
1430         node_draw_link_bezier(v2d, snode, link, th_col1, th_col2, do_shaded);
1431 }
1432
1433