Final merge of HEAD (bf-blender) into the orange branch.
[blender.git] / source / blender / src / buttons_shading.c
1 /**
2  * $Id$ 
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 #include <time.h>
34 #include <math.h>
35 #include <stdlib.h>
36 #include <string.h>
37
38 #ifdef HAVE_CONFIG_H
39 #include <config.h>
40 #endif
41
42 #include "IMB_imbuf_types.h"
43 #include "IMB_imbuf.h"
44
45 #include "MEM_guardedalloc.h"
46
47 #include "DNA_curve_types.h"
48 #include "DNA_image_types.h"
49 #include "DNA_lamp_types.h"
50 #include "DNA_material_types.h"
51 #include "DNA_object_types.h"
52 #include "DNA_node_types.h"
53 #include "DNA_packedFile_types.h"
54 #include "DNA_radio_types.h"
55 #include "DNA_screen_types.h"
56 #include "DNA_space_types.h"
57 #include "DNA_scene_types.h"
58 #include "DNA_texture_types.h"
59 #include "DNA_userdef_types.h"
60 #include "DNA_view3d_types.h"
61 #include "DNA_world_types.h"
62
63 #include "BKE_displist.h"
64 #include "BKE_effect.h"
65 #include "BKE_global.h"
66 #include "BKE_library.h"
67 #include "BKE_main.h"
68 #include "BKE_node.h"
69 #include "BKE_material.h"
70 #include "BKE_utildefines.h"
71 #include "BKE_texture.h"
72
73 #include "BKE_packedFile.h"
74 #include "BKE_plugin_types.h"
75 #include "BKE_image.h"
76
77 #include "BLI_blenlib.h"
78 #include "BMF_Api.h"
79
80 #include "BSE_filesel.h"
81 #include "BSE_headerbuttons.h"
82 #include "BSE_node.h"
83
84 #include "BIF_gl.h"
85 #include "BIF_graphics.h"
86 #include "BIF_keyval.h"
87 #include "BIF_mainqueue.h"
88 #include "BIF_resources.h"
89 #include "BIF_screen.h"
90 #include "BIF_mywindow.h"
91 #include "BIF_space.h"
92 #include "BIF_glutil.h"
93 #include "BIF_interface.h"
94 #include "BIF_toolbox.h"
95 #include "BIF_space.h"
96 #include "BIF_previewrender.h"
97 #include "BIF_butspace.h"
98 #include "BIF_writeimage.h"
99 #include "BIF_toets.h"
100
101 #include "mydevice.h"
102 #include "blendef.h"
103 #include "radio.h"
104
105 /* -----includes for this file specific----- */
106
107 #include "butspace.h" // own module
108
109 /* ---------function prototypes ------------- */
110 void load_tex_image(char *);    
111 void load_plugin_tex(char *);
112
113 void save_env(char *);
114
115 static MTex emptytex;
116 static int packdummy = 0;
117
118 static char *mapto_blendtype_pup(void)
119 {
120         static char string[1024];
121         char formatstr[1024];
122         char tempstr[1024];
123         
124         strcpy(string, "Blending Mode: %t");
125         strcpy(formatstr, "|%s %%x%d");
126         
127         sprintf(tempstr, formatstr, "Mix", MTEX_BLEND);
128         strcat(string, tempstr);
129
130         sprintf(tempstr, formatstr, "Add", MTEX_ADD);
131         strcat(string, tempstr);
132         sprintf(tempstr, formatstr, "Subtract", MTEX_SUB);
133         strcat(string, tempstr);
134
135         sprintf(tempstr, formatstr, "Multiply", MTEX_MUL);
136         strcat(string, tempstr);
137         sprintf(tempstr, formatstr, "Screen", MTEX_SCREEN);
138         strcat(string, tempstr);
139         
140         sprintf(tempstr, formatstr, "Difference", MTEX_DIFF);
141         strcat(string, tempstr);
142         sprintf(tempstr, formatstr, "Divide", MTEX_DIV);
143         strcat(string, tempstr);
144         
145         sprintf(tempstr, formatstr, "Darken", MTEX_DARK);
146         strcat(string, tempstr);
147         sprintf(tempstr, formatstr, "Lighten", MTEX_LIGHT);
148         strcat(string, tempstr);
149
150         return (string);
151 }
152
153 void shade_buttons_change_3d(void)
154 {
155         Object *ob= OBACT;
156         ScrArea *sa;
157         
158         if(ob==NULL) return;
159         
160         for(sa= G.curscreen->areabase.first; sa; sa= sa->next) {
161                 if(sa->spacetype==SPACE_VIEW3D) {
162                         View3D *v3d= sa->spacedata.first;
163                         
164                         if(v3d->drawtype >= OB_SOLID) addqueue(sa->win, REDRAW, 0);
165                         if(v3d->drawtype == OB_SHADED) {
166                                 if(ob->type==OB_LAMP) reshadeall_displist();
167                                 else {
168                                         /* all objects using material */
169                                         Base *base= FIRSTBASE;
170                                         Material *ma= give_current_material(ob, ob->actcol);    
171                                         int a;
172                                         
173                                         while(base) {
174                                                 if(base->lay & G.vd->lay) {
175                                                         for(a=1; a<=ob->totcol; a++) {
176                                                                 if(ma == give_current_material(base->object, a)) {
177                                                                         freedisplist(&(base->object->disp));
178                                                                         break;
179                                                                 }
180                                                         }
181                                                 }
182                                                 base= base->next;
183                                         }
184                                 }
185                         }
186                 }
187         }       
188 }
189
190 /* *************************** TEXTURE ******************************** */
191
192 Tex *cur_imatex=0;
193 int prv_win= 0;
194
195 void load_tex_image(char *str)  /* called from fileselect */
196 {
197         Image *ima=0;
198         Tex *tex;
199         
200         tex= cur_imatex;
201         if(tex->type==TEX_IMAGE || tex->type==TEX_ENVMAP) {
202
203                 ima= add_image(str);
204                 if(ima) {
205                         if(tex->ima) {
206                                 tex->ima->id.us--;
207                         }
208                         tex->ima= ima;
209
210                         free_image_buffers(ima);        /* force reading again */
211                         ima->ok= 1;
212                 }
213
214                 BIF_undo_push("Load image");
215                 allqueue(REDRAWBUTSSHADING, 0);
216
217                 BIF_preview_changed(ID_TE);
218         }
219 }
220
221 void load_plugin_tex(char *str) /* called from fileselect */
222 {
223         Tex *tex;
224         
225         tex= cur_imatex;
226         if(tex->type!=TEX_PLUGIN) return;
227         
228         if(tex->plugin) free_plugin_tex(tex->plugin);
229         
230         tex->stype= 0;
231         tex->plugin= add_plugin_tex(str);
232
233         allqueue(REDRAWBUTSSHADING, 0);
234         BIF_preview_changed(ID_TE);
235 }
236
237 void save_env(char *name)
238 {
239         Tex *tex;
240         char str[FILE_MAXDIR+FILE_MAXFILE];
241         
242         strcpy(str, name);
243         BLI_convertstringcode(str, G.sce, G.scene->r.cfra);
244         tex= G.buts->lockpoin;
245         
246         if(tex && GS(tex->id.name)==ID_TE) {
247                 if(tex->env && tex->env->ok && saveover(str)) {
248                         waitcursor(1);
249                         BIF_save_envmap(tex->env, str);
250                         strcpy(G.ima, name);
251                         waitcursor(0);
252                 }
253         }
254         
255 }
256
257 static int vergcband(const void *a1, const void *a2)
258 {
259         const CBData *x1=a1, *x2=a2;
260         
261         if( x1->pos > x2->pos ) return 1;
262         else if( x1->pos < x2->pos) return -1;
263         return 0;
264 }
265
266 void do_texbuts(unsigned short event)
267 {
268         Tex *tex;
269         ImBuf *ibuf;
270         ScrArea *sa;
271         ID *id; 
272         int nr;
273         char *name, str[FILE_MAXDIR+FILE_MAXFILE];
274         
275         tex= G.buts->lockpoin;
276         
277         switch(event) {
278         case B_TEXCHANNEL:
279                 scrarea_queue_headredraw(curarea);
280                 BIF_preview_changed(ID_TE);
281                 allqueue(REDRAWBUTSSHADING, 0);
282                 break;
283         case B_TEXTYPE:
284                 if(tex==0) return;
285                 tex->stype= 0;
286                 allqueue(REDRAWBUTSSHADING, 0);
287                 BIF_preview_changed(ID_TE);
288                 break;
289         case B_DEFTEXVAR:
290                 if(tex==0) return;
291                 default_tex(tex);
292                 BIF_undo_push("Default texture vars");
293                 allqueue(REDRAWBUTSSHADING, 0);
294                 BIF_preview_changed(ID_TE);
295                 break;
296         case B_LOADTEXIMA:
297                 if(tex==0) return;
298                 /* globals: temporal store them: we make another area a fileselect */
299                 cur_imatex= tex;
300                 prv_win= curarea->win;
301                 
302                 sa= closest_bigger_area();
303                 areawinset(sa->win);
304                 if(tex->ima) name= tex->ima->name;
305 #ifdef _WIN32
306                 else {
307                         if (strcmp (U.textudir, "/") == 0)
308                                 name= G.sce;
309                         else
310                                 name= U.textudir;
311                 }
312 #else
313                 else name = U.textudir;
314 #endif
315                 
316                 if(G.qual==LR_CTRLKEY)
317                         activate_imageselect(FILE_SPECIAL, "SELECT IMAGE", name, load_tex_image);
318                 else 
319                         activate_fileselect(FILE_SPECIAL, "SELECT IMAGE", name, load_tex_image);
320                 
321                 break;
322         case B_NAMEIMA:
323                 if(tex==0) return;
324                 if(tex->ima) {
325                         cur_imatex= tex;
326                         prv_win= curarea->win;
327                         
328                         /* name in tex->ima has been changed by button! */
329                         strcpy(str, tex->ima->name);
330                         if(tex->ima->ibuf) strcpy(tex->ima->name, tex->ima->ibuf->name);
331
332                         load_tex_image(str);
333                 }
334                 break;
335         case B_TEXREDR_PRV:
336                 allqueue(REDRAWBUTSSHADING, 0);
337                 BIF_preview_changed(ID_TE);
338                 shade_buttons_change_3d();
339                 break;
340         case B_TEXIMABROWSE:
341                 if(tex) {
342                         id= (ID*) tex->ima;
343                         
344                         if(G.buts->menunr== -2) {
345                                 activate_databrowse(id, ID_IM, 0, B_TEXIMABROWSE, &G.buts->menunr, do_texbuts);
346                         } else if (G.buts->menunr>0) {
347                                 Image *newima= (Image*) BLI_findlink(&G.main->image, G.buts->menunr-1);
348                                 
349                                 if (newima && newima!=(Image*) id) {
350                                         tex->ima= newima;
351                                         id_us_plus((ID*) newima);
352                                         if(id) id->us--;
353                                 
354                                         BIF_undo_push("Browse image");
355                                         allqueue(REDRAWBUTSSHADING, 0);
356                                         BIF_preview_changed(ID_TE);
357                                 }
358                         }
359                 }
360                 break;
361         case B_IMAPTEST:
362                 if(tex) {
363                         if( (tex->imaflag & (TEX_FIELDS+TEX_MIPMAP))== TEX_FIELDS+TEX_MIPMAP ) {
364                                 error("Cannot combine fields and mipmap");
365                                 tex->imaflag -= TEX_MIPMAP;
366                                 allqueue(REDRAWBUTSSHADING, 0);
367                         }
368                         
369                         if(tex->ima && tex->ima->ibuf) {
370                                 ibuf= tex->ima->ibuf;
371                                 nr= 0;
372                                 if( !(tex->imaflag & TEX_FIELDS) && (ibuf->flags & IB_fields) ) nr= 1;
373                                 if( (tex->imaflag & TEX_FIELDS) && !(ibuf->flags & IB_fields) ) nr= 1;
374                                 if(nr) {
375                                         IMB_freeImBuf(ibuf);
376                                         tex->ima->ibuf= 0;
377                                         tex->ima->ok= 1;
378                                         BIF_preview_changed(ID_TE);
379                                 }
380                         }
381                 }
382                 break;
383         case B_RELOADIMA:
384                 if(tex && tex->ima) {
385                         // check if there is a newer packedfile
386
387                         if (tex->ima->packedfile) {
388                                 PackedFile *pf;
389                                 pf = newPackedFile(tex->ima->name);
390                                 if (pf) {
391                                         freePackedFile(tex->ima->packedfile);
392                                         tex->ima->packedfile = pf;
393                                 } else {
394                                         error("Image not available. Keeping packed image.");
395                                 }
396                         }
397
398                         IMB_freeImBuf(tex->ima->ibuf);
399                         tex->ima->ibuf= NULL;
400                         tex->ima->ok= 1;
401                         
402                         if(tex->env)
403                                 BKE_free_envmapdata(tex->env);
404                         
405                         allqueue(REDRAWVIEW3D, 0);
406                         allqueue(REDRAWIMAGE, 0);
407                         BIF_preview_changed(ID_TE);
408                 }
409                 allqueue(REDRAWBUTSSHADING, 0); // redraw buttons
410                 
411                 break;
412         case B_UNLINKIMA:
413                 if(tex && tex->ima) {
414                         tex->ima->id.us--;
415                         tex->ima= NULL;
416                         allqueue(REDRAWBUTSSHADING, 0); // redraw buttons
417                         BIF_preview_changed(ID_TE); 
418                 }
419                 break;
420         case B_TEXSETFRAMES:
421                 if(tex->ima->anim) tex->frames = IMB_anim_get_duration(tex->ima->anim);
422                 allqueue(REDRAWBUTSSHADING, 0);
423                 break;
424
425         case B_PACKIMA:
426                 if(tex && tex->ima) {
427                         if (tex->ima->packedfile) {
428                                 if (G.fileflags & G_AUTOPACK) {
429                                         if (okee("Disable AutoPack ?")) {
430                                                 G.fileflags &= ~G_AUTOPACK;
431                                         }
432                                 }
433                                 
434                                 if ((G.fileflags & G_AUTOPACK) == 0) {
435                                         unpackImage(tex->ima, PF_ASK);
436                                 }
437                         } else {
438                                 if (tex->ima->ibuf && (tex->ima->ibuf->userflags & IB_BITMAPDIRTY)) {
439                                         error("Can't pack painted image. Save image from Image window first.");
440                                 } else {
441                                         tex->ima->packedfile = newPackedFile(tex->ima->name);
442                                 }
443                         }
444                         allqueue(REDRAWBUTSSHADING, 0);
445                         allqueue(REDRAWHEADERS, 0);
446                 }
447                 break;
448         case B_LOADPLUGIN:
449                 if(tex==0) return;
450
451                 /* globals: store temporal: we make another area a fileselect */
452                 cur_imatex= tex;
453                 prv_win= curarea->win;
454                         
455                 sa= closest_bigger_area();
456                 areawinset(sa->win);
457                 if(tex->plugin) strcpy(str, tex->plugin->name);
458                 else {
459                         strcpy(str, U.plugtexdir);
460                 }
461                 activate_fileselect(FILE_SPECIAL, "SELECT PLUGIN", str, load_plugin_tex);
462                 
463                 break;
464
465         case B_NAMEPLUGIN:
466                 if(tex==0 || tex->plugin==0) return;
467                 strcpy(str, tex->plugin->name);
468                 free_plugin_tex(tex->plugin);
469                 tex->stype= 0;
470                 tex->plugin= add_plugin_tex(str);
471                 allqueue(REDRAWBUTSSHADING, 0);
472                 BIF_preview_changed(ID_TE);
473                 break;
474         
475         case B_COLORBAND:
476                 if(tex==0) return;
477                 if(tex->coba==0) tex->coba= add_colorband(0);
478                 allqueue(REDRAWBUTSSHADING, 0);
479                 BIF_preview_changed(ID_TE); // also ramps, so we do this
480                 break;
481         
482         case B_ENV_DELETE:
483                 if(tex->env) {
484                         BKE_free_envmap(tex->env);
485                         tex->env= 0;
486                         allqueue(REDRAWBUTSSHADING, 0);
487                         BIF_preview_changed(ID_TE);
488                 }
489                 break;
490         case B_ENV_FREE:
491                 if(tex->env) {
492                         BKE_free_envmapdata(tex->env);
493                         allqueue(REDRAWBUTSSHADING, 0);
494                         BIF_preview_changed(ID_TE);
495                 }
496                 break;
497         case B_ENV_FREE_ALL:
498                 tex= G.main->tex.first;
499                 while(tex) {
500                         if(tex->id.us && tex->type==TEX_ENVMAP) {
501                                 if(tex->env) {
502                                         if(tex->env->stype!=ENV_LOAD) BKE_free_envmapdata(tex->env);
503                                 }
504                         }
505                         tex= tex->id.next;
506                 }
507                 allqueue(REDRAWBUTSSHADING, 0);
508                 BIF_preview_changed(ID_TE);
509                 break;
510         case B_ENV_SAVE:
511                 if(tex->env && tex->env->ok) {
512                         sa= closest_bigger_area();
513                         areawinset(sa->win);
514                         save_image_filesel_str(str);
515                         activate_fileselect(FILE_SPECIAL, str, G.ima, save_env);
516                 }
517                 break;  
518         case B_ENV_OB:
519                 if(tex->env && tex->env->object) {
520                         BIF_preview_changed(ID_TE);
521                         if ELEM(tex->env->object->type, OB_CAMERA, OB_LAMP) {
522                                 error("Camera or Lamp not allowed");
523                                 tex->env->object= NULL;
524                         }
525                 }
526                 break;
527                 
528         default:
529                 if(event>=B_PLUGBUT && event<=B_PLUGBUT+23) {
530                         PluginTex *pit= tex->plugin;
531                         if(pit && pit->callback) {
532                                 pit->callback(event - B_PLUGBUT);
533                                 BIF_preview_changed(ID_TE);
534                                 allqueue(REDRAWBUTSSHADING, 0);
535                         }
536                 }
537         }
538 }
539
540 static void texture_panel_plugin(Tex *tex)
541 {
542         uiBlock *block;
543         VarStruct *varstr;
544         PluginTex *pit;
545         short xco, yco, a;
546         
547         block= uiNewBlock(&curarea->uiblocks, "texture_panel_plugin", UI_EMBOSS, UI_HELV, curarea->win);
548         if(uiNewPanel(curarea, block, "Plugin", "Texture", 640, 0, 318, 204)==0) return;
549         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
550
551         if(tex->plugin && tex->plugin->doit) {
552                 
553                 pit= tex->plugin;
554                 
555                 for(a=0; a<pit->stypes; a++) {
556                         uiDefButS(block, ROW, B_TEXREDR_PRV, pit->stnames+16*a, (76*a), 152, 75, 20, &tex->stype, 2.0, (float)a, 0, 0, "");
557                 }
558                 
559                 varstr= pit->varstr;
560                 if(varstr) {
561                         for(a=0; a<pit->vars; a++, varstr++) {
562                                 xco= 140*(a/6)+1;
563                                 yco= 125 - 20*(a % 6)+1;
564                                 uiDefBut(block, varstr->type, B_PLUGBUT+a, varstr->name, xco,yco,137,19, &(pit->data[a]), varstr->min, varstr->max, 100, 0, varstr->tip);
565                         }
566                 }
567                 uiDefBut(block, TEX, B_NAMEPLUGIN, "",          0,180,318,24, pit->name, 0.0, 159.0, 0, 0, "");
568         }
569
570         uiDefBut(block, BUT, B_LOADPLUGIN, "Load Plugin", 0,204,137,24, 0, 0, 0, 0, 0, "");
571                         
572 }
573
574
575 static void texture_panel_magic(Tex *tex)
576 {
577         uiBlock *block;
578         
579         block= uiNewBlock(&curarea->uiblocks, "texture_panel_magic", UI_EMBOSS, UI_HELV, curarea->win);
580         if(uiNewPanel(curarea, block, "Magic", "Texture", 640, 0, 318, 204)==0) return;
581         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
582
583         uiBlockBeginAlign(block);
584         uiDefButS(block, NUM, B_TEXPRV, "Depth:",               10, 90, 150, 19, &tex->noisedepth, 0.0, 10.0, 0, 0, "Sets the depth of the pattern");
585         uiDefButF(block, NUM, B_TEXPRV, "Turbulence:",  10, 70, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Sets the strength of the pattern");
586 }
587
588 static void texture_panel_blend(Tex *tex)
589 {
590         uiBlock *block;
591         
592         block= uiNewBlock(&curarea->uiblocks, "texture_panel_blend", UI_EMBOSS, UI_HELV, curarea->win);
593         if(uiNewPanel(curarea, block, "Blend", "Texture", 640, 0, 318, 204)==0) return;
594         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
595
596         uiBlockBeginAlign(block);
597         uiDefButS(block, ROW, B_TEXPRV, "Lin",          10, 180, 75, 19, &tex->stype, 2.0, 0.0, 0, 0, "Creates a linear progresion"); 
598         uiDefButS(block, ROW, B_TEXPRV, "Quad",         85, 180, 75, 19, &tex->stype, 2.0, 1.0, 0, 0, "Creates a quadratic progression"); 
599         uiDefButS(block, ROW, B_TEXPRV, "Ease",         160, 180, 75, 19, &tex->stype, 2.0, 2.0, 0, 0, "Creates a progression easing from one step to the next"); 
600         uiDefButBitS(block, TOG, TEX_FLIPBLEND, B_TEXPRV, "Flip XY",    235, 180, 75, 19, &tex->flag, 0, 0, 0, 0, "Flips the direction of the progression 90 degrees");
601
602         uiDefButS(block, ROW, B_TEXPRV, "Diag",         10, 160, 75, 19, &tex->stype, 2.0, 3.0, 0, 0, "Use a diagonal progression");
603         uiDefButS(block, ROW, B_TEXPRV, "Sphere",       85, 160, 75, 19, &tex->stype, 2.0, 4.0, 0, 0, "Use progression with the shape of a sphere");
604         uiDefButS(block, ROW, B_TEXPRV, "Halo",         160, 160, 75, 19, &tex->stype, 2.0, 5.0, 0, 0, "Use a quadratic progression with the shape of a sphere");
605         uiDefButS(block, ROW, B_TEXPRV, "Radial",       235, 160, 75, 19, &tex->stype, 2.0, 6.0, 0, 0, "Use a polar progression");
606         
607 }
608
609 /* newnoise: noisebasis menu string */
610 static char* noisebasis_menu()
611 {
612         static char nbmenu[256];
613         sprintf(nbmenu, "Noise Basis %%t|Blender Original %%x%d|Original Perlin %%x%d|Improved Perlin %%x%d|Voronoi F1 %%x%d|Voronoi F2 %%x%d|Voronoi F3 %%x%d|Voronoi F4 %%x%d|Voronoi F2-F1 %%x%d|Voronoi Crackle %%x%d|CellNoise %%x%d", TEX_BLENDER, TEX_STDPERLIN, TEX_NEWPERLIN, TEX_VORONOI_F1, TEX_VORONOI_F2, TEX_VORONOI_F3, TEX_VORONOI_F4, TEX_VORONOI_F2F1, TEX_VORONOI_CRACKLE, TEX_CELLNOISE);
614         return nbmenu;
615 }
616
617 static void texture_panel_wood(Tex *tex)
618 {
619         uiBlock *block;
620         
621         block= uiNewBlock(&curarea->uiblocks, "texture_panel_wood", UI_EMBOSS, UI_HELV, curarea->win);
622         if(uiNewPanel(curarea, block, "Wood", "Texture", 640, 0, 318, 204)==0) return;
623         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
624         
625         uiBlockBeginAlign(block);
626         uiDefButS(block, ROW, B_TEXPRV, "Bands",                10, 180, 75, 18, &tex->stype, 2.0, 0.0, 0, 0, "Uses standard wood texture in bands"); 
627         uiDefButS(block, ROW, B_TEXPRV, "Rings",                85, 180, 75, 18, &tex->stype, 2.0, 1.0, 0, 0, "Uses wood texture in rings"); 
628         uiDefButS(block, ROW, B_TEXPRV, "BandNoise",    160, 180, 75, 18, &tex->stype, 2.0, 2.0, 0, 0, "Adds noise to standard wood"); 
629         uiDefButS(block, ROW, B_TEXPRV, "RingNoise",    235, 180, 75, 18, &tex->stype, 2.0, 3.0, 0, 0, "Adds noise to rings");
630         
631         uiDefButS(block, ROW, B_TEXPRV, "Sin",                  10, 160, 50, 19, &tex->noisebasis2, 8.0, 0.0, 0, 0, "Uses a sine wave to produce bands"); 
632         uiDefButS(block, ROW, B_TEXPRV, "Saw",                  60, 160, 50, 19, &tex->noisebasis2, 8.0, 1.0, 0, 0, "Uses a saw wave to produce bands"); 
633         uiDefButS(block, ROW, B_TEXPRV, "Tri",                  110, 160, 50, 19, &tex->noisebasis2, 8.0, 2.0, 0, 0, "Uses a triangle wave to produce bands");
634         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   160, 160, 75, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Generates soft noise");
635         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   235, 160, 75, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Generates hard noise");
636         
637         uiBlockBeginAlign(block);
638         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
639         uiDefButF(block, NUM, B_TEXPRV, "Turbulence:",  160, 130, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Sets the turbulence of the bandnoise and ringnoise types");
640         uiBlockEndAlign(block);
641         
642         /* newnoise: noisebasis menu */
643         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
644         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
645         uiDefButF(block, NUM, B_NOP, "Nabla: ",                 160, 10, 150, 19, &tex->nabla, 0.001, 0.1, 1, 0, "Defines size of derivative offset used for calculating normal");      
646         
647 }
648
649 static void texture_panel_stucci(Tex *tex)
650 {
651         uiBlock *block;
652         
653         block= uiNewBlock(&curarea->uiblocks, "texture_panel_stucci", UI_EMBOSS, UI_HELV, curarea->win);
654         if(uiNewPanel(curarea, block, "Stucci", "Texture", 640, 0, 318, 204)==0) return;
655         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
656
657         uiBlockBeginAlign(block);
658         uiDefButS(block, ROW, B_TEXPRV, "Plastic",              10, 180, 100, 19, &tex->stype, 2.0, 0.0, 0, 0, "Uses standard stucci");
659         uiDefButS(block, ROW, B_TEXPRV, "Wall In",              110, 180, 100, 19, &tex->stype, 2.0, 1.0, 0, 0, "Creates Dimples"); 
660         uiDefButS(block, ROW, B_TEXPRV, "Wall Out",             210, 180, 100, 19, &tex->stype, 2.0, 2.0, 0, 0, "Creates Ridges"); 
661         
662         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   10, 160, 150, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Generates soft noise");
663         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   160, 160, 150, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Generates hard noise");
664
665         uiBlockBeginAlign(block);
666         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
667         uiDefButF(block, NUM, B_TEXPRV, "Turbulence:",  10, 90, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Sets the depth of the stucci");
668         uiBlockEndAlign(block);
669
670         /* newnoise: noisebasis menu */
671         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
672         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
673         // note, nabla not supported here!
674 //      uiDefButF(block, NUM, B_NOP, "Nabla: ",                 160, 10, 150, 19, &tex->nabla, 0.001, 0.1, 1, 0, "Defines size of derivative offset used for calculating normal");      
675
676 }
677
678 static void texture_panel_marble(Tex *tex)
679 {
680         uiBlock *block;
681         
682         block= uiNewBlock(&curarea->uiblocks, "texture_panel_marble", UI_EMBOSS, UI_HELV, curarea->win);
683         if(uiNewPanel(curarea, block, "Marble", "Texture", 640, 0, 318, 204)==0) return;
684         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
685         
686         uiBlockBeginAlign(block);
687         uiDefButS(block, ROW, B_TEXPRV, "Soft",                 10, 180, 100, 18, &tex->stype, 2.0, 0.0, 0, 0, "Uses soft marble"); 
688         uiDefButS(block, ROW, B_TEXPRV, "Sharp",                110, 180, 100, 18, &tex->stype, 2.0, 1.0, 0, 0, "Uses more clearly defined marble"); 
689         uiDefButS(block, ROW, B_TEXPRV, "Sharper",              210, 180, 100, 18, &tex->stype, 2.0, 2.0, 0, 0, "Uses very clearly defined marble"); 
690         
691         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   10, 160, 150, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Generates soft noise");
692         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   160, 160, 150, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Generates hard noise");
693         
694         uiDefButS(block, ROW, B_TEXPRV, "Sin",                  10, 140, 100, 18, &tex->noisebasis2, 8.0, 0.0, 0, 0, "Uses a sine wave to produce bands."); 
695         uiDefButS(block, ROW, B_TEXPRV, "Saw",                  110, 140, 100, 18, &tex->noisebasis2, 8.0, 1.0, 0, 0, "Uses a saw wave to produce bands"); 
696         uiDefButS(block, ROW, B_TEXPRV, "Tri",                  210, 140, 100, 18, &tex->noisebasis2, 8.0, 2.0, 0, 0, "Uses a triangle wave to produce bands"); 
697         
698         uiBlockBeginAlign(block);
699         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
700         uiDefButS(block, NUM, B_TEXPRV, "NoiseDepth:",  10, 90, 150, 19, &tex->noisedepth, 0.0, 6.0, 0, 0, "Sets the depth of the marble calculation");
701         uiDefButF(block, NUM, B_TEXPRV, "Turbulence:",  10, 70, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Sets the turbulence of the sine bands");
702         uiBlockEndAlign(block);
703         
704         /* newnoise: noisebasis menu */
705         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
706         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
707         uiDefButF(block, NUM, B_NOP, "Nabla: ",                 160, 10, 150, 19, &tex->nabla, 0.001, 0.1, 1, 0, "Defines size of derivative offset used for calculating normal");      
708         
709 }
710
711 static void texture_panel_clouds(Tex *tex)
712 {
713         uiBlock *block;
714         
715         block= uiNewBlock(&curarea->uiblocks, "texture_panel_clouds", UI_EMBOSS, UI_HELV, curarea->win);
716         if(uiNewPanel(curarea, block, "Clouds", "Texture", 640, 0, 318, 204)==0) return;
717         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
718
719         uiBlockBeginAlign(block);
720         uiDefButS(block, ROW, B_TEXPRV, "Default",              10, 180, 70, 18, &tex->stype, 2.0, 0.0, 0, 0, "Uses standard noise"); 
721         uiDefButS(block, ROW, B_TEXPRV, "Color",                80, 180, 70, 18, &tex->stype, 2.0, 1.0, 0, 0, "Lets Noise return RGB value"); 
722         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   155, 180, 75, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Generates soft noise");
723         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   230, 180, 80, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Generates hard noise");
724         uiBlockBeginAlign(block);
725         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
726         uiDefButS(block, NUM, B_TEXPRV, "NoiseDepth:",  160, 130, 150, 19, &tex->noisedepth, 0.0, 6.0, 0, 0, "Sets the depth of the cloud calculation");
727         uiBlockEndAlign(block);
728         
729         /* newnoise: noisebasis menu */
730         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
731         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
732         uiDefButF(block, NUM, B_NOP, "Nabla: ",                 160, 10, 150, 19, &tex->nabla, 0.001, 0.1, 1, 0, "Defines size of derivative offset used for calculating normal");      
733
734 }
735
736 /*****************************************/
737 /* newnoise: panel(s) for musgrave types */
738 /*****************************************/
739
740 static void texture_panel_musgrave(Tex *tex)
741 {
742         uiBlock *block;
743         char *str;
744         
745         block= uiNewBlock(&curarea->uiblocks, "texture_panel_musgrave", UI_EMBOSS, UI_HELV, curarea->win);
746         if(uiNewPanel(curarea, block, "Musgrave", "Texture", 640, 0, 318, 204)==0) return;
747         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
748
749         str= "Multifractal %x0|Ridged Multifractal %x1|Hybrid Multifractal %x2|Hetero Terrain %x4|fBm %x3";
750         uiDefButS(block, MENU, B_TEXREDR_PRV, str, 10, 160, 150, 19, &tex->stype, 0.0, 0.0, 0, 0, "Sets Musgrave type");
751         
752         uiBlockBeginAlign(block);
753         uiDefButF(block, NUMSLI, B_TEXPRV, "H: ", 10, 130, 150, 19, &tex->mg_H, 0.0001, 2.0, 10, 0, "Sets the highest fractal dimension");
754         uiDefButF(block, NUMSLI, B_TEXPRV, "Lacu: ", 160, 130, 150, 19, &tex->mg_lacunarity, 0.0, 6.0, 10, 0, "Sets the gap between succesive frequencies");
755         uiDefButF(block, NUMSLI, B_TEXPRV, "Octs: ", 10, 110, 150, 19, &tex->mg_octaves, 0.0, 8.0, 10, 0, "Sets the number of frequencies used");
756         if ((tex->stype==TEX_RIDGEDMF) || (tex->stype==TEX_HYBRIDMF) || (tex->stype==TEX_HTERRAIN)) {
757                 uiDefButF(block, NUMSLI, B_TEXPRV, "Ofst: ", 160, 110, 150, 19, &tex->mg_offset, 0.0, 6.0, 10, 0, "Sets the fractal offset");
758                 if ((tex->stype==TEX_RIDGEDMF) || (tex->stype==TEX_HYBRIDMF))
759                         uiDefButF(block, NUMSLI, B_TEXPRV, "Gain: ", 10, 90, 150, 19, &tex->mg_gain, 0.0, 6.0, 10, 0, "Sets the gain multiplier");
760         }
761
762         uiBlockBeginAlign(block);
763         /* noise output scale */
764         uiDefButF(block, NUM, B_TEXPRV, "iScale: ", 10, 60, 150, 19, &tex->ns_outscale, 0.0, 10.0, 10, 0, "Scales intensity output");   
765         /* frequency scale */
766         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize: ",  160, 60, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
767         uiBlockEndAlign(block);
768
769         /* noisebasis menu */
770         uiDefBut(block, LABEL, 0, "Noise Basis", 10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
771         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(), 10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
772         uiDefButF(block, NUM, B_NOP, "Nabla: ", 160, 10, 150, 19, &tex->nabla, 0.001, 0.1, 1, 0, "Defines size of derivative offset used for calculating normal");      
773
774 }
775
776
777 static void texture_panel_distnoise(Tex *tex)
778 {
779         uiBlock *block;
780         block= uiNewBlock(&curarea->uiblocks, "texture_panel_distnoise", UI_EMBOSS, UI_HELV, curarea->win);
781         if(uiNewPanel(curarea, block, "Distorted Noise", "Texture", 640, 0, 318, 204)==0) return;
782         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
783
784         uiBlockBeginAlign(block);
785         /* distortion amount */
786         uiDefButF(block, NUM, B_TEXPRV, "DistAmnt: ", 10, 130, 150, 19, &tex->dist_amount, 0.0, 10.0, 10, 0, "Sets amount of distortion");      
787         /* frequency scale */
788         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize: ",  160, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
789         uiBlockEndAlign(block);
790         
791         uiDefBut(block, LABEL, 0, "Distortion Noise", 10, 100, 150, 19, 0, 0.0, 0.0, 0, 0, "");
792         uiDefBut(block, LABEL, 0, "Noise Basis",        160, 100, 150, 19, 0, 0.0, 0.0, 0, 0, "");
793
794         uiBlockBeginAlign(block);
795         /* noisebasis used for the distortion */        
796         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(), 10, 80, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis which does the distortion");
797         /* noisebasis to distort */
798         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(), 160, 80, 150, 19, &tex->noisebasis2, 0,0,0,0, "Sets the noise basis to distort");
799         uiBlockEndAlign(block);
800
801         uiDefButF(block, NUM, B_NOP, "Nabla: ", 10, 50, 150, 19, &tex->nabla, 0.001, 0.1, 1, 0, "Defines size of derivative offset used for calculating normal");       
802 }
803
804
805 static void texture_panel_voronoi(Tex *tex)
806 {
807         char dm_menu[256];
808         uiBlock *block;
809         block= uiNewBlock(&curarea->uiblocks, "texture_panel_voronoi", UI_EMBOSS, UI_HELV, curarea->win);
810         if(uiNewPanel(curarea, block, "Voronoi", "Texture", 640, 0, 318, 204)==0) return;
811         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
812
813         /* color types */
814         uiBlockBeginAlign(block);
815         uiDefButS(block, ROW, B_TEXPRV, "Int", 10, 180, 75, 18, &tex->vn_coltype, 1.0, 0.0, 0, 0, "Only calculate intensity"); 
816         uiDefButS(block, ROW, B_TEXPRV, "Col1", 85, 180, 75, 18, &tex->vn_coltype, 1.0, 1.0, 0, 0, "Color cells by position"); 
817         uiDefButS(block, ROW, B_TEXPRV, "Col2", 160, 180, 75, 18, &tex->vn_coltype, 1.0, 2.0, 0, 0, "Same as Col1 + outline based on F2-F1"); 
818         uiDefButS(block, ROW, B_TEXPRV, "Col3", 235, 180, 75, 18, &tex->vn_coltype, 1.0, 3.0, 0, 0, "Same as Col2 * intensity"); 
819         uiBlockEndAlign(block);
820
821         /* distance metric */
822         sprintf(dm_menu, "Distance Metric %%t|Actual Distance %%x%d|Distance Squared %%x%d|Manhattan %%x%d|Chebychev %%x%d|Minkovsky 1/2 %%x%d|Minkovsky 4 %%x%d|Minkovsky %%x%d", TEX_DISTANCE, TEX_DISTANCE_SQUARED, TEX_MANHATTAN, TEX_CHEBYCHEV, TEX_MINKOVSKY_HALF, TEX_MINKOVSKY_FOUR, TEX_MINKOVSKY);
823         uiDefBut(block, LABEL, 0, "Distance Metric", 10, 160, 150, 19, 0, 0, 0, 0, 0, "");
824         uiDefButS(block, MENU, B_TEXPRV, dm_menu, 10, 140, 150, 19, &tex->vn_distm, 0,0,0,0, "Sets the distance metric to be used");
825
826         if (tex->vn_distm==TEX_MINKOVSKY)
827                 uiDefButF(block, NUMSLI, B_TEXPRV, "Exp: ", 10, 120, 150, 19, &tex->vn_mexp, 0.01, 10.0, 10, 0, "Sets minkovsky exponent");
828
829         uiBlockBeginAlign(block);
830         uiDefButF(block, NUM, B_TEXPRV, "iScale: ", 160, 140, 150, 19, &tex->ns_outscale, 0.01, 10.0, 10, 0, "Scales intensity output");
831         uiDefButF(block, NUM, B_TEXPRV, "Size: ",       160, 120, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
832         uiBlockBeginAlign(block);
833         uiDefButF(block, NUM, B_NOP, "Nabla: ",         160, 70, 150, 19, &tex->nabla, 0.001, 0.1, 1, 0, "Defines size of derivative offset used for calculating normal");      
834
835         /* weights */
836         uiBlockBeginAlign(block);
837         uiDefButF(block, NUMSLI, B_TEXPRV, "W1: ", 10, 70, 150, 19, &tex->vn_w1, -2.0, 2.0, 10, 0, "Sets feature weight 1");
838         uiDefButF(block, NUMSLI, B_TEXPRV, "W2: ", 10, 50, 150, 19, &tex->vn_w2, -2.0, 2.0, 10, 0, "Sets feature weight 2");
839         uiDefButF(block, NUMSLI, B_TEXPRV, "W3: ", 10, 30, 150, 19, &tex->vn_w3, -2.0, 2.0, 10, 0, "Sets feature weight 3");
840         uiDefButF(block, NUMSLI, B_TEXPRV, "W4: ", 10, 10, 150, 19, &tex->vn_w4, -2.0, 2.0, 10, 0, "Sets feature weight 4");
841 }
842
843
844 /***************************************/
845
846 static void texture_panel_envmap(Tex *tex)
847 {
848         uiBlock *block;
849         EnvMap *env;
850         ID *id;
851         short a, xco, yco, dx, dy;
852         char *strp, str[32];
853         
854         block= uiNewBlock(&curarea->uiblocks, "texture_panel_envmap", UI_EMBOSS, UI_HELV, curarea->win);
855         if(uiNewPanel(curarea, block, "Envmap", "Texture", 640, 0, 318, 204)==0) return;
856         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
857
858         if(tex->env==NULL) {
859                 tex->env= BKE_add_envmap();
860                 tex->env->object= OBACT;
861         }
862         if(tex->env) {
863                 env= tex->env;
864                 
865                 uiDefButS(block, ROW, B_REDR,   "Static",       10, 180, 100, 19, &env->stype, 2.0, 0.0, 0, 0, "Calculates environment map only once");
866                 uiDefButS(block, ROW, B_REDR,   "Anim",         110, 180, 100, 19, &env->stype, 2.0, 1.0, 0, 0, "Calculates environment map at each rendering");
867                 uiDefButS(block, ROW, B_ENV_FREE, "Load",       210, 180, 100, 19, &env->stype, 2.0, 2.0, 0, 0, "Loads saved environment map from disk");
868
869                 if(env->stype==ENV_LOAD) {
870                         /* file input */
871                         id= (ID *)tex->ima;
872                         IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(G.buts->menunr));
873                         if(strp[0]) {
874                                 uiBlockBeginAlign(block);
875                                 uiDefButS(block, MENU, B_TEXIMABROWSE, strp, 10,145,23,20, &(G.buts->menunr), 0, 0, 0, 0, "Selects an existing environment map or creates new");
876                                 
877                                 if(tex->ima) {
878                                         uiDefBut(block, TEX, B_NAMEIMA, "",                     35,145,255,20, tex->ima->name, 0.0, 79.0, 0, 0, "Displays environment map name: click to change");
879                                         sprintf(str, "%d", tex->ima->id.us);
880                                         uiDefBut(block, BUT, 0, str,                            290,145,20,20, 0, 0, 0, 0, 0, "Displays number of users of environment map: click to make single user");
881                                         uiBlockEndAlign(block);
882                                         
883                                         uiDefBut(block, BUT, B_RELOADIMA, "Reload",     230,125,80,20, 0, 0, 0, 0, 0, "Reloads saved environment map");
884                                 
885                                         if (tex->ima->packedfile) packdummy = 1;
886                                         else packdummy = 0;
887                                         uiDefIconButBitI(block, TOG, 1, B_PACKIMA, ICON_PACKAGE, 205,125,24,20, &packdummy, 0, 0, 0, 0, "Toggles Packed status of this environment map");
888                                 }
889                                 else uiBlockEndAlign(block);
890                         }
891                         MEM_freeN(strp);
892                 
893                         uiDefBut(block, BUT, B_LOADTEXIMA, "Load Image", 10,125,150,20, 0, 0, 0, 0, 0, "Loads saved environment map - file select");
894                 }
895                 else {
896                         uiBlockBeginAlign(block);
897                         uiDefBut(block, BUT, B_ENV_FREE, "Free Data",   10,135,100,20, 0, 0, 0, 0, 0, "Releases all images associated with this environment map");
898                         uiDefBut(block, BUT, B_ENV_SAVE, "Save EnvMap", 110,135,100,20, 0, 0, 0, 0, 0, "Saves current environment map");
899                         uiDefBut(block, BUT, B_ENV_FREE_ALL, "Free all EnvMaps", 210,135,100,20, 0, 0, 0, 0, 0, "Frees all rendered environment maps for all materials");
900                         uiBlockEndAlign(block);
901                 }
902
903                 uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_ENV_OB, "Ob:",  10,90,150,20, &(env->object), "Displays object to use as viewpoint for environment map: click to change");
904                 if(env->stype!=ENV_LOAD) 
905                         uiDefButS(block, NUM, B_ENV_FREE,       "CubeRes",              160,90,150,20, &env->cuberes, 50, 2048.0, 0, 0, "Sets the pixel resolution of the rendered environment map");
906
907                 uiBlockBeginAlign(block);
908                 uiDefButF(block, NUM, B_TEXPRV, "Filter :",                             10,65,150,20, &tex->filtersize, 0.1, 25.0, 0, 3, "Adjusts sharpness or blurriness of the reflection"),
909                 uiDefButS(block, NUM, B_ENV_FREE, "Depth:",                             160,65,150,20, &env->depth, 0, 5.0, 0, 0, "Sets the number of times a map will be rendered recursively mirror effects"),
910                 uiDefButF(block, NUM, REDRAWVIEW3D,     "ClipSta",              10,40,150,20, &env->clipsta, 0.01, 50.0, 100, 0, "Sets start value for clipping: objects nearer than this are not visible to map");
911                 uiDefButF(block, NUM, B_NOP,    "ClipEnd",                                      160,40,150,20, &env->clipend, 0.1, 5000.0, 1000, 0, "Sets end value for clipping beyond which objects are not visible to map");
912                 uiBlockEndAlign(block);
913                 
914                 uiDefBut(block, LABEL, 0, "Don't render layer:",                10,10,140,22, 0, 0.0, 0.0, 0, 0, "");   
915                 xco= 160;
916                 yco= 10;
917                 dx= 28;
918                 dy= 26;
919                 
920                 uiBlockBeginAlign(block);
921                 for(a=0; a<5; a++) 
922                         uiDefButBitI(block, TOG, 1<<a, 0, "",   (xco+a*(dx/2)), (yco+dy/2), (dx/2), (1+dy/2), &env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
923                 for(a=0; a<5; a++) 
924                         uiDefButBitI(block, TOG, 1<<(a+10), 0, "",(xco+a*(dx/2)), yco, (dx/2), (dy/2), &env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
925
926                 uiBlockBeginAlign(block);
927                 xco+= 5;
928                 for(a=5; a<10; a++) 
929                         uiDefButBitI(block, TOG, 1<<a, 0, "",   (xco+a*(dx/2)), (yco+dy/2), (dx/2), (1+dy/2), &env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
930                 for(a=5; a<10; a++) 
931                         uiDefButBitI(block, TOG, 1<<(a+10), 0, "",(xco+a*(dx/2)), yco, (dx/2), (dy/2), &env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
932
933         }
934 }
935
936
937 static void texture_panel_image1(Tex *tex)
938 {
939         uiBlock *block;
940         char str[32];
941         
942         block= uiNewBlock(&curarea->uiblocks, "texture_panel1", UI_EMBOSS, UI_HELV, curarea->win);
943         if(uiNewPanel(curarea, block, "Anim and Movie", "Texture", 960, 0, 318, 204)==0) return;
944         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
945
946         /* print amount of frames anim */
947         if(tex->ima && tex->ima->anim) {
948                 uiDefBut(block, BUT, B_TEXSETFRAMES, "<",      802, 110, 20, 18, 0, 0, 0, 0, 0, "Copies number of frames in movie file to Frames: button");
949                 sprintf(str, "%d frs  ", IMB_anim_get_duration(tex->ima->anim));
950                 uiDefBut(block, LABEL, 0, str,      834, 110, 90, 18, 0, 0, 0, 0, 0, "Number of frames in movie file");
951                 sprintf(str, "%d cur  ", tex->ima->lastframe);
952                 uiDefBut(block, LABEL, 0, str,      834, 90, 90, 18, 0, 0, 0, 0, 0, "");
953         }
954         else uiDefBut(block, LABEL, 0, "<",      802, 110, 20, 18, 0, 0, 0, 0, 0, "");
955                         
956         uiDefButS(block, NUM, B_TEXPRV, "Frames :",     642,110,150,19, &tex->frames, 0.0, MAXFRAMEF, 0, 0, "Sets the number of frames of a movie to use and activates animation options");
957         uiDefButS(block, NUM, B_TEXPRV, "Offset :",     642,90,150,19, &tex->offset, -MAXFRAMEF, MAXFRAMEF, 0, 0, "Offsets the number of the first movie frame to use in the animation");
958         uiDefButS(block, NUM, B_TEXPRV, "Fie/Ima:",     642,60,98,19, &tex->fie_ima, 1.0, 200.0, 0, 0, "Sets the number of fields per rendered frame");
959         uiDefButS(block, NUM, B_TEXPRV, "StartFr:",     642,30,150,19, &tex->sfra, 1.0, MAXFRAMEF, 0, 0, "Sets the starting frame of the movie to use in animation");
960         uiDefButS(block, NUM, B_TEXPRV, "Len:",         642,10,150,19, &tex->len, 0.0, MAXFRAMEF, 0, 0, "Sets the number of movie frames to use in animation: 0=all");
961         
962         uiBlockBeginAlign(block);
963         uiDefButS(block, NUM, B_TEXPRV, "Fra:",         802,70,73,19, &(tex->fradur[0][0]), 0.0, MAXFRAMEF, 0, 0, "Montage mode: frame start");
964         uiDefButS(block, NUM, B_TEXPRV, "Fra:",         802,50,73,19, &(tex->fradur[1][0]), 0.0, MAXFRAMEF, 0, 0, "Montage mode: frame start");
965         uiDefButS(block, NUM, B_TEXPRV, "Fra:",         802,30,73,19, &(tex->fradur[2][0]), 0.0, MAXFRAMEF, 0, 0, "Montage mode: frame start");
966         uiDefButS(block, NUM, B_TEXPRV, "Fra:",         802,10,73,19, &(tex->fradur[3][0]), 0.0, MAXFRAMEF, 0, 0, "Montage mode: frame start");
967         uiBlockBeginAlign(block);
968         uiDefButS(block, NUM, B_TEXPRV, "",                     879,70,37,19, &(tex->fradur[0][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
969         uiDefButS(block, NUM, B_TEXPRV, "",                     879,50,37,19, &(tex->fradur[1][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
970         uiDefButS(block, NUM, B_TEXPRV, "",                     879,30,37,19, &(tex->fradur[2][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
971         uiDefButS(block, NUM, B_TEXPRV, "",                     879,10,37,19, &(tex->fradur[3][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
972         uiBlockEndAlign(block);
973         uiDefButBitS(block, TOG, TEX_ANIMCYCLIC, B_TEXPRV, "Cyclic",            743,60,48,19, &tex->imaflag, 0, 0, 0, 0, "Toggles looping of animated frames");
974 }
975
976
977 static void texture_panel_image(Tex *tex)
978 {
979         uiBlock *block;
980         ID *id;
981         char *strp, str[32];
982         
983         block= uiNewBlock(&curarea->uiblocks, "texture_panel_image", UI_EMBOSS, UI_HELV, curarea->win);
984         if(uiNewPanel(curarea, block, "Image", "Texture", 640, 0, 318, 204)==0) return;
985         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
986
987         /* types */
988         uiBlockBeginAlign(block);
989         uiDefButBitS(block, TOG, TEX_INTERPOL, 0, "InterPol",                   10, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Interpolates pixels of the Image to fit texture mapping");
990         uiDefButBitS(block, TOG, TEX_USEALPHA, B_TEXPRV, "UseAlpha",    85, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Click to use Image's alpha channel");
991         uiDefButBitS(block, TOG, TEX_CALCALPHA, B_TEXPRV, "CalcAlpha",  160, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Click to calculate an alpha channel based on Image RGB values");
992         uiDefButBitS(block, TOG, TEX_NEGALPHA, B_TEXPRV, "NegAlpha",    235, 180, 75, 18, &tex->flag, 0, 0, 0, 0, "Click to invert the alpha values");
993         
994         uiDefButBitS(block, TOG, TEX_MIPMAP, B_IMAPTEST, "MipMap",      10, 160, 60, 18, &tex->imaflag, 0, 0, 0, 0, "Generates a series of pictures to use for mipmapping");
995         uiDefButBitS(block, TOG, TEX_FIELDS, B_IMAPTEST, "Fields",      70, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Click to enable use of fields in Image");
996         uiDefButBitS(block, TOG, TEX_IMAROT, B_TEXPRV, "Rot90",         120, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Actually flips X and Y for rendering, rotates and mirrors");
997         uiDefButBitS(block, TOG, TEX_ANIM5, B_RELOADIMA, "Movie",       170, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Click to enable movie frames as Images");
998         uiDefButBitS(block, TOG, TEX_ANTIALI, 0, "Anti",                                220, 160, 40, 18, &tex->imaflag, 0, 0, 0, 0, "Toggles Image anti-aliasing");
999         uiDefButBitS(block, TOG, TEX_STD_FIELD, 0, "StField",                   260, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Standard Field Toggle");
1000         uiBlockEndAlign(block);
1001         
1002         /* file input */
1003         id= (ID *)tex->ima;
1004         IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(G.buts->menunr));
1005         if(strp[0]) {
1006                 uiBlockBeginAlign(block);
1007                 uiDefButS(block, MENU, B_TEXIMABROWSE, strp, 10,135,23,20, &(G.buts->menunr), 0, 0, 0, 0, "Selects an existing texture or creates new");
1008                 
1009                 if(tex->ima) {
1010                         uiDefBut(block, TEX, B_NAMEIMA, "",                     35,135,235,20, tex->ima->name, 0.0, 79.0, 0, 0, "Displays name of the Image file: click to change");
1011                         uiDefIconBut(block, BUT, B_UNLINKIMA, ICON_X,   270,135,20,20, 0, 0, 0, 0, 0, "Unlink Image block from Texture");
1012                         
1013                         sprintf(str, "%d", tex->ima->id.us);
1014                         uiDefBut(block, BUT, 0, str,                            290,135,20,20, 0, 0, 0, 0, 0, "Displays number of users of texture");
1015                         uiBlockEndAlign(block);
1016                         
1017                         uiDefBut(block, BUT, B_RELOADIMA, "Reload",     230,115,80,19, 0, 0, 0, 0, 0, "Reloads Image");
1018                 
1019                         if (tex->ima->packedfile) packdummy = 1;
1020                         else packdummy = 0;
1021                         
1022                         uiDefIconButBitI(block, TOG, 1, B_PACKIMA, ICON_PACKAGE, 205,115,24,19, &packdummy, 0, 0, 0, 0, "Toggles Packed status of this Image");
1023                 }
1024                 else uiBlockEndAlign(block);
1025         }
1026         MEM_freeN(strp);
1027
1028         uiDefBut(block, BUT, B_LOADTEXIMA, "Load Image", 10,115,150,19, 0, 0, 0, 0, 0, "Click to load an Image");
1029
1030         /* crop extend clip */
1031         
1032         uiDefButF(block, NUM, B_TEXPRV, "Filter :",                     10,92,150,19, &tex->filtersize, 0.1, 25.0, 0, 3, "Sets the filter size used by mipmap and interpol");
1033         uiDefButBitS(block, TOG, TEX_NORMALMAP, B_NOP, "Normal Map",    160,92,150,19, &tex->imaflag, 0.1, 25.0, 0, 0, "Use image RGB values for normal mapping");
1034
1035         uiBlockBeginAlign(block);
1036         uiDefButS(block, ROW, B_TEXREDR_PRV, "Extend",                  10,70,63,19, &tex->extend, 4.0, 1.0, 0, 0, "Extends the colour of the edge pixels");
1037         uiDefButS(block, ROW, B_TEXREDR_PRV, "Clip",                    73,70,48,19, &tex->extend, 4.0, 2.0, 0, 0, "Sets alpha 0.0 outside Image edges");
1038         uiDefButS(block, ROW, B_TEXREDR_PRV, "ClipCube",                121,70,63,19, &tex->extend, 4.0, 4.0, 0, 0, "Sets alpha to 0.0 outside cubeshaped area around Image");
1039         uiDefButS(block, ROW, B_TEXREDR_PRV, "Repeat",                  184,70,63,19, &tex->extend, 4.0, 3.0, 0, 0, "Causes Image to repeat horizontally and vertically");
1040         uiDefButS(block, ROW, B_TEXREDR_PRV, "Checker",                 247,70,63,19, &tex->extend, 4.0, 5.0, 0, 0, "Causes Image to repeat in checker pattern");
1041
1042         if(tex->extend==TEX_REPEAT) {
1043                 uiBlockBeginAlign(block);
1044                 uiDefButS(block, NUM, B_TEXPRV, "Xrepeat:",     10,50,150,19, &tex->xrepeat, 1.0, 512.0, 0, 0, "Sets a repetition multiplier in the X direction");
1045                 uiDefButS(block, NUM, B_TEXPRV, "Yrepeat:",     160,50,150,19, &tex->yrepeat, 1.0, 512.0, 0, 0, "Sets a repetition multiplier in the Y direction");
1046         }
1047         else if(tex->extend==TEX_CHECKER) {
1048                 uiBlockBeginAlign(block);
1049                 uiDefButBitS(block, TOG, TEX_CHECKER_ODD, B_TEXPRV, "Odd",      10,50,100,19, &tex->flag, 0.0, 0.0, 0, 0, "Sets odd checker tiles");
1050                 uiDefButBitS(block, TOG, TEX_CHECKER_EVEN, B_TEXPRV, "Even",    110,50,100,19, &tex->flag, 0.0, 0.0, 0, 0, "Sets even checker tiles");
1051                 uiDefButF(block, NUM, B_TEXPRV, "Mortar:",              210,50,100,19, &tex->checkerdist, 0.0, 0.99, 0, 0, "Set checkers distance (like mortar)");
1052         }
1053         uiBlockBeginAlign(block);
1054         uiDefButF(block, NUM, B_REDR, "MinX ",          10,28,150,19, &tex->cropxmin, -10.0, 10.0, 10, 0, "Sets minimum X value to crop Image");
1055         uiDefButF(block, NUM, B_REDR, "MinY ",          10,8,150,19, &tex->cropymin, -10.0, 10.0, 10, 0, "Sets minimum Y value to crop Image");
1056
1057         uiBlockBeginAlign(block);
1058         uiDefButF(block, NUM, B_REDR, "MaxX ",          160,28,150,19, &tex->cropxmax, -10.0, 10.0, 10, 0, "Sets maximum X value to crop Image");
1059         uiDefButF(block, NUM, B_REDR, "MaxY ",          160,8,150,19, &tex->cropymax, -10.0, 10.0, 10, 0, "Sets maximum Y value to crop Image");
1060         uiBlockEndAlign(block);
1061
1062 }
1063
1064 static void colorband_pos_cb(void *coba_v, void *unused_v)
1065 {
1066         ColorBand *coba= coba_v;
1067         int a;
1068         
1069         if(coba->tot<2) return;
1070         
1071         for(a=0; a<coba->tot; a++) coba->data[a].cur= a;
1072         qsort(coba->data, coba->tot, sizeof(CBData), vergcband);
1073         for(a=0; a<coba->tot; a++) {
1074                 if(coba->data[a].cur==coba->cur) {
1075                         if(coba->cur!=a) addqueue(curarea->win, REDRAW, 0);     /* button cur */
1076                         coba->cur= a;
1077                         break;
1078                 }
1079         }
1080 }
1081
1082 static void colorband_add_cb(void *coba_v, void *unused_v)
1083 {
1084         ColorBand *coba= coba_v;
1085         
1086         if(coba->tot < MAXCOLORBAND-1) coba->tot++;
1087         coba->cur= coba->tot-1;
1088         
1089         colorband_pos_cb(coba, NULL);
1090         BIF_undo_push("Add colorband");
1091         
1092 }
1093
1094 static void colorband_del_cb(void *coba_v, void *unused_v)
1095 {
1096         ColorBand *coba= coba_v;
1097         int a;
1098         
1099         if(coba->tot<2) return;
1100         
1101         for(a=coba->cur; a<coba->tot; a++) {
1102                 coba->data[a]= coba->data[a+1];
1103         }
1104         if(coba->cur) coba->cur--;
1105         coba->tot--;
1106         
1107         BIF_undo_push("Delete colorband");
1108         BIF_preview_changed(ID_TE);
1109 }
1110
1111
1112 /* offset aligns from bottom, standard width 300, height 115 */
1113 static void draw_colorband_buts(uiBlock *block, ColorBand *coba, int xoffs, int yoffs, int redraw)
1114 {
1115         CBData *cbd;
1116         uiBut *bt;
1117         
1118         if(coba==NULL) return;
1119         
1120         bt= uiDefBut(block, BUT, redraw,        "Add",          80+xoffs,95+yoffs,37,20, 0, 0, 0, 0, 0, "Adds a new colour position to the colorband");
1121         uiButSetFunc(bt, colorband_add_cb, coba, NULL);
1122         uiDefButS(block, NUM, redraw,           "Cur:",         117+xoffs,95+yoffs,81,20, &coba->cur, 0.0, (float)(coba->tot-1), 0, 0, "Displays the active colour from the colorband");
1123         bt= uiDefBut(block, BUT, redraw,                "Del",          199+xoffs,95+yoffs,37,20, 0, 0, 0, 0, 0, "Deletes the active position");
1124         uiButSetFunc(bt, colorband_del_cb, coba, NULL);
1125         uiDefButS(block, ROW, redraw,            "E",           236+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 1.0, 0, 0, "Sets interpolation type 'Ease' (quadratic) ");
1126         uiDefButS(block, ROW, redraw,           "C",            252+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 3.0, 0, 0, "Sets interpolation type Cardinal");
1127         uiDefButS(block, ROW, redraw,           "L",            268+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 0.0, 0, 0, "Sets interpolation type Linear");
1128         uiDefButS(block, ROW, redraw,           "S",            284+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 2.0, 0, 0, "Sets interpolation type B-Spline");
1129
1130         uiDefBut(block, BUT_COLORBAND, redraw, "",      xoffs,65+yoffs,300,30, coba, 0, 0, 0, 0, "");
1131         
1132         cbd= coba->data + coba->cur;
1133         
1134         uiBlockBeginAlign(block);
1135         bt= uiDefButF(block, NUM, redraw, "Pos",                xoffs,40+yoffs,110,20, &cbd->pos, 0.0, 1.0, 10, 0, "Sets the position of the active colour");
1136         uiButSetFunc(bt, colorband_pos_cb, coba, NULL);
1137         uiDefButF(block, COL, redraw,           "",             xoffs,20+yoffs,110,20, &(cbd->r), 0, 0, 0, B_BANDCOL, "");
1138         uiDefButF(block, NUMSLI, redraw,        "A ",   xoffs,yoffs,110,20, &cbd->a, 0.0, 1.0, 10, 0, "Sets the alpha value for this position");
1139
1140         uiBlockBeginAlign(block);
1141         uiDefButF(block, NUMSLI, redraw,        "R ",   115+xoffs,40+yoffs,185,20, &cbd->r, 0.0, 1.0, B_BANDCOL, 0, "Sets the red value for the active colour");
1142         uiDefButF(block, NUMSLI, redraw,        "G ",   115+xoffs,20+yoffs,185,20, &cbd->g, 0.0, 1.0, B_BANDCOL, 0, "Sets the green value for the active colour");
1143         uiDefButF(block, NUMSLI, redraw,        "B ",   115+xoffs,yoffs,185,20, &cbd->b, 0.0, 1.0, B_BANDCOL, 0, "Sets the blue value for the active colour");
1144         uiBlockEndAlign(block);
1145 }
1146
1147 void draw_colorband_buts_small(uiBlock *block, ColorBand *coba, rctf *butr, int event)
1148 {
1149         CBData *cbd;
1150         uiBut *bt;
1151         float unit= (butr->xmax-butr->xmin)/12.0f;
1152         float xs= butr->xmin;
1153         
1154         cbd= coba->data + coba->cur;
1155         
1156         uiBlockBeginAlign(block);
1157         uiDefButF(block, COL, event,            "",                     xs,butr->ymin+20.0f,2.0f*unit,20,                               &(cbd->r), 0, 0, 0, B_BANDCOL, "");
1158         uiDefButF(block, NUM, event,            "A:",           xs+2.0f*unit,butr->ymin+20.0f,4.0f*unit,20,     &(cbd->a), 0.0f, 1.0f, 10, 2, "");
1159         bt= uiDefBut(block, BUT, event, "Del",          xs+6.0f*unit,butr->ymin+20.0f,2.0f*unit,20,     NULL, 0, 0, 0, 0, "Deletes the active position");
1160         uiButSetFunc(bt, colorband_del_cb, coba, NULL);
1161         uiDefButS(block, ROW, event,            "E",            xs+8.0f*unit,butr->ymin+20.0f,unit,20,          &coba->ipotype, 5.0, 1.0, 0, 0, "Sets interpolation type 'Ease' (quadratic) ");
1162         uiDefButS(block, ROW, event,            "C",            xs+9.0f*unit,butr->ymin+20.0f,unit,20,          &coba->ipotype, 5.0, 3.0, 0, 0, "Sets interpolation type Cardinal");
1163         uiDefButS(block, ROW, event,            "L",            xs+10.0f*unit,butr->ymin+20.0f,unit,20,         &coba->ipotype, 5.0, 0.0, 0, 0, "Sets interpolation type Linear");
1164         uiDefButS(block, ROW, event,            "S",            xs+11.0f*unit,butr->ymin+20.0f,unit,20,         &coba->ipotype, 5.0, 2.0, 0, 0, "Sets interpolation type B-Spline");
1165         
1166         uiDefBut(block, BUT_COLORBAND, event, "",               xs,butr->ymin,butr->xmax-butr->xmin,20.0f, coba, 0, 0, 0, 0, "");
1167         uiBlockEndAlign(block);
1168         
1169 }
1170
1171 static void texture_panel_colors(Tex *tex)
1172 {
1173         uiBlock *block;
1174         
1175         block= uiNewBlock(&curarea->uiblocks, "texture_panel_colors", UI_EMBOSS, UI_HELV, curarea->win);
1176         uiNewPanelTabbed("Texture", "Texture");
1177         if(uiNewPanel(curarea, block, "Colors", "Texture", 1280, 0, 318, 204)==0) return;
1178
1179
1180         /* COLORBAND */
1181         uiBlockBeginAlign(block);
1182         uiDefButBitS(block, TOG, TEX_COLORBAND, B_COLORBAND, "Colorband",10,180,80,20, &tex->flag, 0, 0, 0, 0, "Toggles colorband operations");
1183
1184         if(tex->flag & TEX_COLORBAND) {
1185                 draw_colorband_buts(block, tex->coba, 10, 85, B_TEXREDR_PRV);
1186         }
1187         
1188         /* RGB-BRICON */
1189         if((tex->flag & TEX_COLORBAND)==0) {
1190                 uiBlockBeginAlign(block);
1191                 uiDefButF(block, NUMSLI, B_TEXPRV, "R ",                60,80,200,20, &tex->rfac, 0.0, 2.0, 0, 0, "Changes the red value of the texture");
1192                 uiDefButF(block, NUMSLI, B_TEXPRV, "G ",                60,60,200,20, &tex->gfac, 0.0, 2.0, 0, 0, "Changes the green value of the texture");
1193                 uiDefButF(block, NUMSLI, B_TEXPRV, "B ",                60,40,200,20, &tex->bfac, 0.0, 2.0, 0, 0, "Changes the blue value of the texture");
1194         }
1195
1196         uiBlockBeginAlign(block);
1197         uiDefButF(block, NUMSLI, B_TEXPRV, "Bright",            10,10,150,20, &tex->bright, 0.0, 2.0, 0, 0, "Changes the brightness of the colour or intensity of a texture");
1198         uiDefButF(block, NUMSLI, B_TEXPRV, "Contr",                     160,10,150,20, &tex->contrast, 0.01, 5.0, 0, 0, "Changes the contrast of the colour or intensity of a texture");
1199 }
1200
1201
1202 static void texture_panel_texture(MTex *mtex, Material *ma, World *wrld, Lamp *la, bNode *node)
1203 {
1204         MTex *mt=NULL;
1205         uiBlock *block;
1206         ID *id=NULL, *idfrom;
1207         int a, yco, loos;
1208         char str[32];
1209         
1210
1211         block= uiNewBlock(&curarea->uiblocks, "texture_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
1212         if(uiNewPanel(curarea, block, "Texture", "Texture", 320, 0, 318, 204)==0) return;
1213
1214         /* first do the browse but */
1215         if(mtex)
1216                 id= (ID *)mtex->tex;
1217         else if(node)
1218                 id= node->id;
1219         
1220         if(ma) idfrom= &ma->id;
1221         else if(wrld) idfrom= &wrld->id;
1222         else if(la) idfrom= &la->id;
1223         else idfrom= NULL;
1224         
1225         uiBlockSetCol(block, TH_BUT_SETTING2);
1226         if(ma) {
1227                 std_libbuttons(block, 10, 180, 0, NULL, B_TEXBROWSE, ID_TE, 0, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1228         }
1229         else if(wrld) {
1230                 std_libbuttons(block, 10, 180, 0, NULL, B_WTEXBROWSE, ID_TE, 0, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1231         }
1232         else if(la) {
1233                 std_libbuttons(block, 10, 180, 0, NULL, B_LTEXBROWSE, ID_TE, 0, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1234         }
1235         else if(node) {
1236                 
1237         }
1238         uiBlockSetCol(block, TH_BUT_NEUTRAL);
1239
1240         /* From button: removed */
1241
1242         /* CHANNELS */
1243         if(node==NULL) {
1244                 uiBlockBeginAlign(block);
1245                 yco= 150;
1246                 for(a= 0; a<MAX_MTEX; a++) {
1247                         
1248                         if(ma) mt= ma->mtex[a];
1249                         else if(wrld)  mt= wrld->mtex[a];
1250                         else if(la)  mt= la->mtex[a];
1251                         
1252                         if(mt && mt->tex) splitIDname(mt->tex->id.name+2, str, &loos);
1253                         else strcpy(str, "");
1254                         str[14]= 0;
1255
1256                         if(ma) {
1257                                 uiDefButC(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(ma->texact), 0.0, (float)a, 0, 0, "Click to select texture channel");
1258                                 yco-= 20;
1259                         }
1260                         else if(wrld) {
1261                                 uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(wrld->texact), 0.0, (float)a, 0, 0, "");
1262                                 yco-= 20;
1263                         }
1264                         else if(la) {
1265                                 uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(la->texact), 0.0, (float)a, 0, 0, "");
1266                                 yco-= 20;
1267                         }
1268                 }
1269                 uiBlockEndAlign(block);
1270         }       
1271         uiBlockSetCol(block, TH_AUTO);
1272
1273         /* TYPES */
1274         if(id) {
1275                 char textypes[512];
1276                 Tex *tex= (Tex *)id;
1277
1278                 uiSetButLock(tex->id.lib!=0, "Can't edit library data");
1279                 
1280                 /* newnoise: all texture types as menu, not enough room for more buttons.
1281                  * Can widen panel, but looks ugly when other panels overlap it */
1282                 
1283                 sprintf(textypes, "Texture Type %%t|None %%x%d|Image %%x%d|EnvMap %%x%d|Clouds %%x%d|Marble %%x%d|Stucci %%x%d|Wood %%x%d|Magic %%x%d|Blend %%x%d|Noise %%x%d|Plugin %%x%d|Musgrave %%x%d|Voronoi %%x%d|DistortedNoise %%x%d", 0, TEX_IMAGE, TEX_ENVMAP, TEX_CLOUDS, TEX_MARBLE, TEX_STUCCI, TEX_WOOD, TEX_MAGIC, TEX_BLEND, TEX_NOISE, TEX_PLUGIN, TEX_MUSGRAVE, TEX_VORONOI, TEX_DISTNOISE);
1284                 uiDefBut(block, LABEL, 0, "Texture Type",               160, 150, 140, 20, 0, 0.0, 0.0, 0, 0, "");
1285                 uiDefButS(block, MENU, B_TEXTYPE, textypes,     160, 125, 140, 25, &tex->type, 0,0,0,0, "Select texture type");
1286
1287         }
1288         else {
1289                 // label to avoid centering
1290                 uiDefBut(block, LABEL, 0, " ",  160, 10, 140, 20, 0, 0, 0, 0, 0, "");
1291         }
1292 }
1293
1294 static void texture_panel_preview(int preview)
1295 {
1296         uiBlock *block;
1297         
1298         block= uiNewBlock(&curarea->uiblocks, "texture_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
1299         if(uiNewPanel(curarea, block, "Preview", "Texture", 0, 0, 318, 204)==0) return;
1300         
1301         if(preview) uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1302
1303         // label to force a boundbox for buttons not to be centered
1304         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1305
1306         uiBlockBeginAlign(block);
1307         uiDefButC(block, ROW, B_TEXREDR_PRV, "Mat",             200,175,80,25, &G.buts->texfrom, 3.0, 0.0, 0, 0, "Displays the textures of the active material");
1308         uiDefButC(block, ROW, B_TEXREDR_PRV, "World",   200,150,80,25, &G.buts->texfrom, 3.0, 1.0, 0, 0, "Displays the textures of the world block");
1309         uiDefButC(block, ROW, B_TEXREDR_PRV, "Lamp",    200,125,80,25, &G.buts->texfrom, 3.0, 2.0, 0, 0, "Displays the textures of the selected lamp");
1310         uiBlockEndAlign(block);
1311         uiDefBut(block, BUT, B_DEFTEXVAR, "Default Vars",200,10,80,20, 0, 0, 0, 0, 0, "Sets all values to defaults");
1312
1313 }
1314
1315
1316
1317 /* *************************** RADIO ******************************** */
1318
1319 void do_radiobuts(unsigned short event)
1320 {
1321         Radio *rad;
1322         int phase;
1323         
1324         phase= rad_phase();
1325         rad= G.scene->radio;
1326         
1327         switch(event) {
1328         case B_RAD_ADD:
1329                 add_radio();
1330                 BIF_undo_push("Add radiosity");
1331                 allqueue(REDRAWBUTSSHADING, 0);
1332                 allqueue(REDRAWVIEW3D, 0);
1333                 break;
1334         case B_RAD_DELETE:
1335                 delete_radio();
1336                 BIF_undo_push("Delete radiosity");
1337                 allqueue(REDRAWBUTSSHADING, 0);
1338                 allqueue(REDRAWVIEW3D, 0);
1339                 break;
1340         case B_RAD_FREE:
1341                 freeAllRad();
1342                 allqueue(REDRAWBUTSSHADING, 0);
1343                 allqueue(REDRAWVIEW3D, 0);
1344                 break;
1345         case B_RAD_COLLECT:
1346                 rad_collect_meshes();
1347                 allqueue(REDRAWBUTSSHADING, 0);
1348                 allqueue(REDRAWVIEW3D, 0);
1349                 break;
1350         case B_RAD_INIT:
1351                 if(phase==RAD_PHASE_PATCHES) {
1352                         rad_limit_subdivide();
1353                         allqueue(REDRAWBUTSSHADING, 0);
1354                         allqueue(REDRAWVIEW3D, 0);
1355                 }
1356                 break;
1357         case B_RAD_SHOOTP:
1358                 if(phase==RAD_PHASE_PATCHES) {
1359                         waitcursor(1);
1360                         rad_subdivshootpatch();
1361                         allqueue(REDRAWBUTSSHADING, 0);
1362                         allqueue(REDRAWVIEW3D, 0);
1363                         waitcursor(0);
1364                 }
1365                 break;
1366         case B_RAD_SHOOTE:
1367                 if(phase==RAD_PHASE_PATCHES) {
1368                         waitcursor(1);
1369                         rad_subdivshootelem();
1370                         allqueue(REDRAWBUTSSHADING, 0);
1371                         allqueue(REDRAWVIEW3D, 0);
1372                         waitcursor(0);
1373                 }
1374                 break;
1375         case B_RAD_GO:
1376                 if(phase==RAD_PHASE_PATCHES) {
1377                         waitcursor(1);
1378                         rad_go();
1379                         waitcursor(0);
1380                         allqueue(REDRAWBUTSSHADING, 0);
1381                         allqueue(REDRAWVIEW3D, 0);
1382                 }
1383                 break;
1384         case B_RAD_LIMITS:
1385                 rad_setlimits();
1386                 allqueue(REDRAWVIEW3D, 0);
1387                 allqueue(REDRAWBUTSSHADING, 0);
1388                 break;
1389         case B_RAD_FAC:
1390                 set_radglobal();
1391                 if(phase & RAD_PHASE_FACES) make_face_tab();
1392                 else make_node_display();       /* radio solver also uses nodes, different ones :) */
1393                 allqueue(REDRAWVIEW3D, 0);
1394                 break;
1395         case B_RAD_NODELIM:
1396                 if(phase & RAD_PHASE_FACES) {
1397                         set_radglobal();
1398                         removeEqualNodes(rad->nodelim);
1399                         make_face_tab();
1400                         allqueue(REDRAWVIEW3D, 0);
1401                         allqueue(REDRAWBUTSSHADING, 0);
1402                 }
1403                 break;
1404         case B_RAD_NODEFILT:
1405                 if(phase & RAD_PHASE_FACES) {
1406                         set_radglobal();
1407                         filterNodes();
1408                         make_face_tab();
1409                         allqueue(REDRAWVIEW3D, 0);
1410                 }
1411                 break;
1412         case B_RAD_FACEFILT:
1413                 if(phase & RAD_PHASE_FACES) {
1414                         filterFaces();
1415                         allqueue(REDRAWVIEW3D, 0);
1416                 }
1417                 break;
1418         case B_RAD_DRAW:
1419                 set_radglobal();
1420                 allqueue(REDRAWVIEW3D, 0);
1421                 break;
1422         case B_RAD_ADDMESH:
1423                 if(phase & RAD_PHASE_FACES) rad_addmesh();
1424                 BIF_undo_push("Radiosity add mesh");
1425                 allqueue(REDRAWVIEW3D, 0);
1426                 break;
1427         case B_RAD_REPLACE:
1428                 if(phase & RAD_PHASE_FACES) rad_replacemesh();
1429                 BIF_undo_push("Radiosity replace mesh");
1430                 allqueue(REDRAWVIEW3D, 0);
1431                 break;
1432         }
1433
1434 }
1435
1436
1437 static void radio_panel_calculation(Radio *rad, int flag)
1438 {
1439         uiBlock *block;
1440         
1441         block= uiNewBlock(&curarea->uiblocks, "radio_panel_calculation", UI_EMBOSS, UI_HELV, curarea->win);
1442         if(uiNewPanel(curarea, block, "Calculation", "Radio", 640, 0, 318, 204)==0) return;
1443         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1444
1445         if(flag != RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_NEUTRAL);
1446         uiDefBut(block,  BUT, B_RAD_GO, "GO",                                   0, 0, 10, 15, NULL, 0, 0, 0, 0, "Starts the radiosity simulation");
1447
1448         uiBlockSetCol(block, TH_AUTO);
1449         uiDefButS(block,  NUM, B_NOP, "SubSh Patch:",                           1, 0, 10, 10, &rad->subshootp, 0.0, 10.0, 0, 0, "Sets the number of times the environment is tested to detect pathes");
1450         uiDefButS(block,  NUM, B_NOP, "SubSh Element:",                         1, 0, 10, 10, &rad->subshoote, 0.0, 10.0, 0, 0, "Sets the number of times the environment is tested to detect elements");
1451
1452         if(flag != RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_NEUTRAL);
1453         uiDefBut(block,  BUT, B_RAD_SHOOTE, "Subdiv Shoot Element", 2, 0, 10, 10, NULL, 0, 0, 0, 0, "For pre-subdivision, Detects high energy changes and subdivide Elements");
1454         uiDefBut(block,  BUT, B_RAD_SHOOTP, "Subdiv Shoot Patch",       2, 0, 10, 10, NULL, 0, 0, 0, 0, "For pre-subdivision, Detects high energy changes and subdivide Patches");
1455
1456         uiBlockSetCol(block, TH_AUTO);
1457         uiDefButI(block,  NUM, B_NOP, "MaxEl:",                                         3, 0, 10, 10, &rad->maxnode, 1.0, 250000.0, 0, 0, "Sets the maximum allowed number of elements");
1458         uiDefButS(block,  NUM, B_NOP, "Max Subdiv Shoot:",                      3, 0, 10, 10, &rad->maxsublamp, 1.0, 250.0, 0, 0, "Sets the maximum number of initial shoot patches that are evaluated");
1459
1460         if(flag & RAD_PHASE_FACES);
1461         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1462         uiDefBut(block,  BUT, B_RAD_FACEFILT, "FaceFilter",             4, 0, 10, 10, NULL, 0, 0, 0, 0, "Forces an extra smoothing");
1463         uiDefBut(block,  BUT, B_RAD_NODEFILT, "Element Filter", 4, 0, 10, 10, NULL, 0, 0, 0, 0, "Filters elements to remove aliasing artefacts");
1464
1465         uiDefBut(block,  BUT, B_RAD_NODELIM, "RemoveDoubles",   5, 0, 30, 10, NULL, 0.0, 50.0, 0, 0, "Joins elements which differ less than 'Lim'");
1466         uiBlockSetCol(block, TH_AUTO);
1467         uiDefButS(block,  NUM, B_NOP, "Lim:",                                           5, 0, 10, 10, &rad->nodelim, 0.0, 50.0, 0, 0, "Sets the range for removing doubles");
1468
1469
1470 }
1471
1472 static void radio_panel_tool(Radio *rad, int flag)
1473 {
1474         uiBlock *block;
1475         
1476         block= uiNewBlock(&curarea->uiblocks, "radio_panel_tool", UI_EMBOSS, UI_HELV, curarea->win);
1477         if(uiNewPanel(curarea, block, "Radio Tool", "Radio", 320, 0, 318, 204)==0) return;
1478         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1479
1480         if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_SETTING1);
1481         uiDefBut(block,  BUT, B_RAD_COLLECT, "Collect Meshes",  0, 0, 10, 15, NULL, 0, 0, 0, 0, "Converts selected visible meshes to patches");
1482
1483         if(flag & RAD_PHASE_PATCHES)uiBlockSetCol(block, TH_AUTO);
1484         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1485         uiDefBut(block,  BUT, B_RAD_FREE, "Free Radio Data",    0, 0, 10, 15, NULL, 0, 0, 0, 0, "Releases all memory used by Radiosity");       
1486
1487         if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, TH_AUTO);
1488         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1489         uiDefBut(block,  BUT, B_RAD_REPLACE, "Replace Meshes",  1, 0, 10, 12, NULL, 0, 0, 0, 0, "Converts meshes to Mesh objects with vertex colours, changing input-meshes");
1490         uiDefBut(block,  BUT, B_RAD_ADDMESH, "Add new Meshes",  1, 0, 10, 12, NULL, 0, 0, 0, 0, "Converts meshes to Mesh objects with vertex colours, unchanging input-meshes");
1491
1492         uiBlockSetCol(block, TH_AUTO);
1493         uiDefButS(block,  ROW, B_RAD_DRAW, "Wire",                      2, 0, 10, 10, &rad->drawtype, 0.0, 0.0, 0, 0, "Enables wireframe drawmode");
1494         uiDefButS(block,  ROW, B_RAD_DRAW, "Solid",                     2, 0, 10, 10, &rad->drawtype, 0.0, 1.0, 0, 0, "Enables solid drawmode");
1495         uiDefButS(block,  ROW, B_RAD_DRAW, "Gour",                      2, 0, 10, 10, &rad->drawtype, 0.0, 2.0, 0, 0, "Enables Gourad drawmode");
1496         uiDefButBitS(block,  TOG, 1, B_RAD_DRAW, "ShowLim", 2, 0, 10, 10, &rad->flag, 0, 0, 0, 0, "Draws patch and element limits");
1497         uiDefButBitS(block,  TOG, 2, B_RAD_DRAW, "Z",           2, 0, 3, 10, &rad->flag, 0, 0, 0, 0, "Draws limits differently");
1498
1499         uiDefButS(block,  NUM, B_RAD_LIMITS, "ElMax:",          3, 0, 10, 10, &rad->elma, 1.0, 500.0, 0, 0, "Sets maximum size of an element");
1500         uiDefButS(block,  NUM, B_RAD_LIMITS, "ElMin:",          3, 0, 10, 10, &rad->elmi, 1.0, 100.0, 0, 0, "Sets minimum size of an element");
1501         uiDefButS(block,  NUM, B_RAD_LIMITS, "PaMax:",          3, 0, 10, 10, &rad->pama, 10.0, 1000.0, 0, 0, "Sets maximum size of a patch");
1502         uiDefButS(block,  NUM, B_RAD_LIMITS, "PaMin:",          3, 0, 10, 10, &rad->pami, 10.0, 1000.0, 0, 0, "Sets minimum size of a patch");
1503
1504         uiDefBut(block,  BUT, B_RAD_INIT, "Limit Subdivide", 5, 0, 10, 10, NULL, 0, 0, 0, 0, "Subdivides patches");
1505 }
1506
1507
1508 static void radio_panel_render(Radio *rad)
1509 {
1510         uiBlock *block;
1511         
1512         block= uiNewBlock(&curarea->uiblocks, "radio_panel_render", UI_EMBOSS, UI_HELV, curarea->win);
1513         if(uiNewPanel(curarea, block, "Radio Render", "Radio", 0, 0, 318, 204)==0) return;
1514         uiAutoBlock(block, 210, 30, 230, 150, UI_BLOCK_ROWS);
1515
1516         uiDefButS(block,  NUMSLI, B_RAD_LIMITS, "Hemires:", 0, 0, 10, 10, &rad->hemires, 100.0, 1000.0, 100, 0, "Sets the size of a hemicube");
1517         uiDefButS(block,  NUM, B_NOP, "Max Iterations:",                2, 0, 10, 15, &rad->maxiter, 0.0, 10000.0, 0, 0, "Limits the maximum number of radiosity rounds");
1518         uiDefButF(block,  NUM, B_RAD_FAC, "Mult:",                      3, 0, 10, 15, &rad->radfac, 0.001, 250.0, 100, 0, "Mulitplies the energy values");
1519         uiDefButF(block,  NUM, B_RAD_FAC, "Gamma:",                     3, 0, 10, 15, &rad->gamma, 0.2, 10.0, 10, 0, "Changes the contrast of the energy values");
1520         uiDefButF(block,  NUMSLI, B_NOP, "Convergence:",                5, 0, 10, 10, &rad->convergence, 0.0, 1.0, 10, 0, "Sets the lower threshold of unshot energy");
1521 }
1522
1523
1524 /* ***************************** WORLD ************************** */
1525
1526 void do_worldbuts(unsigned short event)
1527 {
1528         static short mtexcopied=0;
1529         static MTex mtexcopybuf;
1530         World *wrld;
1531         MTex *mtex;
1532         
1533         switch(event) {
1534         case B_TEXCLEARWORLD:
1535                 wrld= G.buts->lockpoin;
1536                 mtex= wrld->mtex[ wrld->texact ];
1537                 if(mtex) {
1538                         if(mtex->tex) mtex->tex->id.us--;
1539                         MEM_freeN(mtex);
1540                         wrld->mtex[ wrld->texact ]= 0;
1541                         allqueue(REDRAWBUTSSHADING, 0);
1542                         allqueue(REDRAWOOPS, 0);
1543                         BIF_undo_push("Unlink world texture");
1544                         BIF_preview_changed(ID_WO);
1545                 }
1546                 break;
1547         case B_WMTEXCOPY:
1548                 wrld= G.buts->lockpoin;
1549                 if(wrld && wrld->mtex[(int)wrld->texact] ) {
1550                         mtex= wrld->mtex[(int)wrld->texact];
1551                         if(mtex->tex==0) {
1552                                 error("No texture available");
1553                         }
1554                         else {
1555                                 memcpy(&mtexcopybuf, wrld->mtex[(int)wrld->texact], sizeof(MTex));
1556                                 mtexcopied= 1;
1557                         }
1558                 }
1559                 break;
1560         case B_WMTEXPASTE:
1561                 wrld= G.buts->lockpoin;
1562                 if(wrld && mtexcopied && mtexcopybuf.tex) {
1563                         if(wrld->mtex[(int)wrld->texact]==0 ) 
1564                                 wrld->mtex[(int)wrld->texact]= MEM_mallocN(sizeof(MTex), "mtex"); 
1565                         else if(wrld->mtex[(int)wrld->texact]->tex)
1566                                 wrld->mtex[(int)wrld->texact]->tex->id.us--;
1567                         
1568                         memcpy(wrld->mtex[(int)wrld->texact], &mtexcopybuf, sizeof(MTex));
1569                         
1570                         id_us_plus((ID *)mtexcopybuf.tex);
1571                         BIF_undo_push("Paste mapping settings");
1572                         BIF_preview_changed(ID_WO);
1573                         scrarea_queue_winredraw(curarea);
1574                 }
1575                 break;
1576         }
1577 }
1578
1579 static void world_panel_mapto(World *wrld)
1580 {
1581         uiBlock *block;
1582         MTex *mtex;
1583         
1584         block= uiNewBlock(&curarea->uiblocks, "world_panel_mapto", UI_EMBOSS, UI_HELV, curarea->win);
1585         uiNewPanelTabbed("Texture and Input", "World");
1586         if(uiNewPanel(curarea, block, "Map To", "World", 1280, 0, 318, 204)==0) return;
1587
1588         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1589
1590         mtex= wrld->mtex[ wrld->texact ];
1591         if(mtex==0) {
1592                 mtex= &emptytex;
1593                 default_mtex(mtex);
1594                 mtex->texco= TEXCO_VIEW;
1595         }
1596
1597         /* TEXTURE OUTPUT */
1598         uiBlockBeginAlign(block);
1599         uiDefButBitS(block, TOG, MTEX_STENCIL, B_WORLDPRV, "Stencil",   10,125,45,19, &(mtex->texflag), 0, 0, 0, 0, "Sets the texture mapping to stencil mode");
1600         uiDefButBitS(block, TOG, MTEX_NEGATIVE, B_WORLDPRV, "Neg",              55,125,30,19, &(mtex->texflag), 0, 0, 0, 0, "Inverts the values of the texture to reverse its effect");
1601         uiDefButBitS(block, TOG, MTEX_RGBTOINT, B_WORLDPRV, "No RGB",           85,125,60,19, &(mtex->texflag), 0, 0, 0, 0, "Converts texture RGB values to intensity (gray) values");
1602         uiBlockEndAlign(block);
1603
1604         uiBlockBeginAlign(block);
1605         uiDefButF(block, COL, B_WORLDPRV, "",                   10,100,135,19, &(mtex->r), 0, 0, 0, B_MTEXCOL, "");
1606         uiDefButF(block, NUMSLI, B_WORLDPRV, "R ",                      10,80,135,19, &(mtex->r), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
1607         uiDefButF(block, NUMSLI, B_WORLDPRV, "G ",                      10,60,135,19, &(mtex->g), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
1608         uiDefButF(block, NUMSLI, B_WORLDPRV, "B ",                      10,40,135,19, &(mtex->b), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
1609         uiBlockEndAlign(block);
1610         uiDefButF(block, NUMSLI, B_WORLDPRV, "DVar ",           10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "The default value for textures to mix with values (not RGB)");
1611         
1612         /* MAP TO */
1613         uiBlockBeginAlign(block);
1614         uiDefButBitS(block, TOG, WOMAP_BLEND, B_WORLDPRV, "Blend",      10,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the colour progression of the background");
1615         uiDefButBitS(block, TOG, WOMAP_HORIZ, B_WORLDPRV, "Hori",               85,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the colour of the horizon");
1616         uiDefButBitS(block, TOG, WOMAP_ZENUP, B_WORLDPRV, "ZenUp",      160,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the colour of the zenith above");
1617         uiDefButBitS(block, TOG, WOMAP_ZENDOWN, B_WORLDPRV, "ZenDo",    235,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the colour of the zenith below");
1618         uiBlockEndAlign(block);
1619
1620         uiBlockBeginAlign(block);
1621         uiDefButS(block, MENU, B_WORLDPRV, mapto_blendtype_pup(),155,125,155,19, &(mtex->blendtype), 0, 0, 0, 0, "Texture blending mode");
1622         uiBlockEndAlign(block);
1623
1624         uiBlockBeginAlign(block);
1625         uiDefButF(block, NUMSLI, B_WORLDPRV, "Col  ",           155,100,155,19, &(mtex->colfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects colour values");
1626         uiDefButF(block, NUMSLI, B_WORLDPRV, "Nor  ",           155,80,155,19, &(mtex->norfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects normal values");
1627         uiDefButF(block, NUMSLI, B_WORLDPRV, "Var  ",           155,60,155,19, &(mtex->varfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects other values");
1628         
1629 }
1630
1631 static void world_panel_texture(World *wrld)
1632 {
1633         uiBlock *block;
1634         MTex *mtex;
1635         ID *id;
1636         int a, loos;
1637         char str[64], *strp;
1638         
1639         block= uiNewBlock(&curarea->uiblocks, "world_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
1640         if(uiNewPanel(curarea, block, "Texture and Input", "World", 960, 0, 318, 204)==0) return;
1641
1642         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1643
1644         /* TEX CHANNELS */
1645         uiBlockSetCol(block, TH_BUT_NEUTRAL);
1646         uiBlockBeginAlign(block);
1647         for(a= 0; a<MAX_MTEX; a++) {
1648                 mtex= wrld->mtex[a];
1649                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
1650                 else strcpy(str, "");
1651                 str[10]= 0;
1652                 uiDefButS(block, ROW, REDRAWBUTSSHADING, str,10, 160-18*a, 80, 20, &(wrld->texact), 3.0, (float)a, 0, 0, "Texture channel");
1653         }
1654         uiBlockEndAlign(block);
1655
1656         mtex= wrld->mtex[ wrld->texact ];
1657         if(mtex==0) {
1658                 mtex= &emptytex;
1659                 default_mtex(mtex);
1660                 mtex->texco= TEXCO_VIEW;
1661         }
1662         
1663         /* TEXTUREBLOCK SELECT */
1664         uiBlockSetCol(block, TH_BUT_SETTING2);
1665         id= (ID *)mtex->tex;
1666         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
1667         uiDefButS(block, MENU, B_WTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Selects an existing texture or creates new");
1668         MEM_freeN(strp);
1669         
1670         if(id) {
1671                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,200,19, id->name+2, 0.0, 18.0, 0, 0, "Displays name of the texture block: click to change");
1672                 sprintf(str, "%d", id->us);
1673                 uiDefBut(block, BUT, 0, str,                    196,140,21,19, 0, 0, 0, 0, 0, "Displays number of users of texture: click to make single user");
1674                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 220,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
1675                 if(id->lib) {
1676                         if(wrld->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,      219,140,21,19, 0, 0, 0, 0, 0, "");
1677                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
1678                 }
1679                 uiBlockSetCol(block, TH_AUTO);
1680                 uiDefBut(block, BUT, B_TEXCLEARWORLD, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erases link to texture");
1681         }
1682         else 
1683                 uiDefButS(block, TOG, B_WTEXBROWSE, "Add New" ,100, 160, 200, 19, &(G.buts->texnr), -1.0, 32767.0, 0, 0, "Adds a new texture datablock");
1684
1685         uiBlockSetCol(block, TH_AUTO);
1686         
1687         /* copy/paste */
1688         uiBlockBeginAlign(block);
1689         uiDefIconBut(block, BUT, B_WMTEXCOPY, ICON_COPYUP,      250,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
1690         uiDefIconBut(block, BUT, B_WMTEXPASTE, ICON_PASTEUP,275,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
1691                 
1692         /* TEXCO */
1693         uiBlockBeginAlign(block);
1694         uiDefButS(block, ROW, B_WORLDPRV, "View",               100,110,100,20, &(mtex->texco), 4.0, (float)TEXCO_VIEW, 0, 0, "Uses view vector for the texture coordinates");
1695         uiDefButS(block, ROW, B_WORLDPRV, "Global",     200,110,100,20, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Uses global coordinates for the texture coordinates (interior mist)");
1696         
1697         uiDefButS(block, ROW, B_WORLDPRV, "AngMap",     100,90,70,20, &(mtex->texco), 4.0, (float)TEXCO_ANGMAP, 0, 0, "Uses 360 degree angular coordinates, e.g. for spherical light probes");
1698         uiDefButS(block, ROW, B_WORLDPRV, "Sphere",     170,90,65,20, &(mtex->texco), 4.0, (float)TEXCO_H_SPHEREMAP, 0, 0, "For 360 degree panorama sky, spherical mapped, only top half");
1699         uiDefButS(block, ROW, B_WORLDPRV, "Tube",               235,90,65,20, &(mtex->texco), 4.0, (float)TEXCO_H_TUBEMAP, 0, 0, "For 360 degree panorama sky, cylindrical mapped, only top half");
1700         
1701         uiDefButS(block, ROW, B_WORLDPRV, "Object",     100,70,70,20, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Uses linked object's coordinates for texture coordinates");
1702         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_WORLDPRV, "", 170,70,130,20, &(mtex->object), "");
1703
1704         uiBlockBeginAlign(block);
1705         uiDefButF(block, NUM, B_WORLDPRV, "dX",         100,40,100,19, mtex->ofs, -20.0, 20.0, 10, 0, "Fine tunes texture mapping X coordinate");
1706         uiDefButF(block, NUM, B_WORLDPRV, "dY",         100,20,100,19, mtex->ofs+1, -20.0, 20.0, 10, 0, "Fine tunes texture mapping Y coordinate");
1707         uiDefButF(block, NUM, B_WORLDPRV, "dZ",         100, 0,100,19, mtex->ofs+2, -20.0, 20.0, 10, 0, "Fine tunes texture mapping Z coordinate");
1708         uiBlockBeginAlign(block);
1709         uiDefButF(block, NUM, B_WORLDPRV, "sizeX",      200,40,100,19, mtex->size, -10.0, 10.0, 10, 0, "Sets scaling for the texture's X size");
1710         uiDefButF(block, NUM, B_WORLDPRV, "sizeY",      200,20,100,19, mtex->size+1, -10.0, 10.0, 10, 0, "Sets scaling for the texture's Y size");
1711         uiDefButF(block, NUM, B_WORLDPRV, "sizeZ",      200, 0,100,19, mtex->size+2, -10.0, 10.0, 10, 0, "Sets scaling for the texture's Z size");
1712         
1713 }
1714
1715 static void world_panel_mistaph(World *wrld)
1716 {
1717         uiBlock *block;
1718         
1719         block= uiNewBlock(&curarea->uiblocks, "world_panel_mistaph", UI_EMBOSS, UI_HELV, curarea->win);
1720         if(uiNewPanel(curarea, block, "Mist / Stars / Physics", "World", 640, 0, 318, 204)==0) return;
1721
1722         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1723
1724 #if GAMEBLENDER == 1
1725         uiDefButI(block, MENU, 1, 
1726 #ifdef USE_ODE
1727                           "Physics %t|None %x0|Sumo %x2|Ode %x4 |Bullet %x5",
1728 #else
1729                           "Physics %t|None %x0|Sumo %x2|Bullet %x5",
1730 #endif
1731                           10,180,140,19, &wrld->physicsEngine, 0, 0, 0, 0, 
1732                           "Physics Engine");
1733         
1734         /* Gravitation for the game worlds */
1735         uiDefButF(block, NUMSLI,0, "Grav ", 150,180,150,19,     &(wrld->gravity), 0.0, 25.0, 0, 0,  "Sets the gravitation constant of the game world");
1736 #endif
1737
1738         uiBlockSetCol(block, TH_BUT_SETTING1);
1739         uiDefButBitS(block, TOG, WO_MIST, REDRAWVIEW3D,"Mist",  10,120,140,19, &wrld->mode, 0, 0, 0, 0, "Toggles mist simulation");
1740         uiBlockSetCol(block, TH_AUTO);
1741
1742         uiBlockBeginAlign(block);
1743         uiDefButS(block, ROW, B_DIFF, "Qua", 10, 90, 40, 19, &wrld->mistype, 1.0, 0.0, 0, 0, "Mist uses quadratic progression");
1744         uiDefButS(block, ROW, B_DIFF, "Lin", 50, 90, 50, 19, &wrld->mistype, 1.0, 1.0, 0, 0, "Mist uses linear progression");
1745         uiDefButS(block, ROW, B_DIFF, "Sqr", 100, 90, 50, 19, &wrld->mistype, 1.0, 2.0, 0, 0, "Mist uses inverse quadratic progression");
1746         uiBlockBeginAlign(block);
1747         uiDefButF(block, NUM,REDRAWVIEW3D, "Sta:",10,70,140,19, &wrld->miststa, 0.0, 1000.0, 10, 0, "Specifies the starting distance of the mist");
1748         uiDefButF(block, NUM,REDRAWVIEW3D, "Di:",10,50,140,19, &wrld->mistdist, 0.0,1000.0, 10, 00, "Specifies the depth of the mist");
1749         uiDefButF(block, NUM,B_DIFF,"Hi:",              10,30,140,19, &wrld->misthi,0.0,100.0, 10, 0, "Specifies the factor for a less dense mist with increasing height");
1750         uiDefButF(block, NUMSLI, B_DIFF, "Misi ",               10,10,140,19,   &(wrld->misi), 0., 1.0, 0, 0, "Sets the mist intensity");
1751         uiBlockEndAlign(block);
1752
1753         uiBlockSetCol(block, TH_BUT_SETTING1);
1754         uiDefButBitS(block, TOG, WO_STARS, REDRAWVIEW3D,        "Stars",160,120,140,19, &wrld->mode, 0, 0, 0, 0, "Toggles starfield generation");
1755         uiBlockSetCol(block, TH_AUTO);
1756         
1757         uiBlockBeginAlign(block);
1758         uiDefButF(block, NUM,B_DIFF,"StarDist:",        160,70,140,19, &(wrld->stardist), 2.0, 1000.0, 100, 0, "Specifies the average distance between any two stars");
1759         uiDefButF(block, NUM,B_DIFF,"MinDist:",         160,50,140,19, &(wrld->starmindist), 0.0, 1000.0, 100, 0, "Specifies the minimum distance to the camera for stars");
1760         uiDefButF(block, NUMSLI,B_DIFF,"Size:",         160,30,140,19, &(wrld->starsize), 0.0, 10.0, 10, 0, "Specifies the average screen dimension of stars");
1761         uiDefButF(block, NUMSLI,B_DIFF,"Colnoise:",     160,10,140,19, &(wrld->starcolnoise), 0.0, 1.0, 100, 0, "Randomizes starcolour");
1762         uiBlockEndAlign(block);
1763
1764 }
1765
1766 static void world_panel_amb_occ(World *wrld)
1767 {
1768         uiBlock *block;
1769         
1770         block= uiNewBlock(&curarea->uiblocks, "world_panel_amb_oc", UI_EMBOSS, UI_HELV, curarea->win);
1771         uiNewPanelTabbed("Mist / Stars / Physics", "World");
1772         if(uiNewPanel(curarea, block, "Amb Occ", "World", 320, 0, 318, 204)==0) return;
1773
1774         uiBlockSetCol(block, TH_BUT_SETTING1);
1775         uiDefButBitS(block, TOG, WO_AMB_OCC, B_REDR,    "Ambient Occlusion",10,150,300,19, &wrld->mode, 0, 0, 0, 0, "Toggles ambient occlusion");
1776         uiBlockSetCol(block, TH_AUTO);
1777
1778         if(wrld->mode & WO_AMB_OCC) {
1779
1780                 /* aolight: samples */
1781                 uiBlockBeginAlign(block);
1782                 uiDefButS(block, NUM, B_REDR, "Samples:", 10, 120, 150, 19, &wrld->aosamp, 1.0, 16.0, 100, 0, "Sets the number of samples used for AO  (actual number: squared)");
1783                 /* enable/disable total random sampling */
1784                 uiDefButBitS(block, TOG, WO_AORNDSMP, 0, "Random Sampling", 160, 120, 150, 19, &wrld->aomode, 0, 0, 0, 0, "When enabled, total random sampling will be used for an even noisier effect");
1785                 uiBlockEndAlign(block);
1786
1787                 uiDefButF(block, NUM, B_REDR, "Dist:", 10, 95, 150, 19, &wrld->aodist, 0.001, 5000.0, 100, 0, "Sets length of AO rays, defines how far away other faces give occlusion effect");
1788
1789                 uiBlockBeginAlign(block);
1790                 uiDefButBitS(block, TOG, WO_AODIST, B_REDR, "Use Distances", 10, 70, 150, 19, &wrld->aomode, 0, 0, 0, 0, "When enabled, distances to objects will be used to attenuate shadows");
1791                 /* distance attenuation factor */
1792                 if (wrld->aomode & WO_AODIST)
1793                         uiDefButF(block, NUM, B_REDR, "DistF:", 160, 70, 150, 19, &wrld->aodistfac, 0.00001, 10.0, 100, 0, "Distance factor, the higher, the 'shorter' the shadows");
1794
1795                 /* result mix modes */
1796                 uiBlockBeginAlign(block);
1797                 uiDefButS(block, ROW, B_REDR, "Add", 10, 45, 100, 20, &wrld->aomix, 1.0, (float)WO_AOADD, 0, 0, "adds light/shadows");
1798                 uiDefButS(block, ROW, B_REDR, "Sub", 110, 45, 100, 20, &wrld->aomix, 1.0, (float)WO_AOSUB, 0, 0, "subtracts light/shadows (needs at least one normal light to make anything visible)");
1799                 uiDefButS(block, ROW, B_REDR, "Both", 210, 45, 100, 20, &wrld->aomix, 1.0, (float)WO_AOADDSUB, 0, 0, "both lightens & darkens");
1800
1801                 /* color treatment */
1802                 uiBlockBeginAlign(block);
1803                 uiDefButS(block, ROW, B_REDR, "Plain", 10, 25, 100, 20, &wrld->aocolor, 2.0, (float)WO_AOPLAIN, 0, 0, "Plain diffuse energy (white)");
1804                 uiDefButS(block, ROW, B_REDR, "Sky Color", 110, 25, 100, 20, &wrld->aocolor, 2.0, (float)WO_AOSKYCOL, 0, 0, "Use horizon and zenith color for diffuse energy");
1805                 uiDefButS(block, ROW, B_REDR, "Sky Texture", 210, 25, 100, 20, &wrld->aocolor, 2.0, (float)WO_AOSKYTEX, 0, 0, "Does full Sky texture render for diffuse energy");
1806                 
1807                 uiBlockBeginAlign(block);
1808                 uiDefButF(block, NUMSLI, B_REDR, "Energy:", 10, 0, 150, 19, &wrld->aoenergy, 0.01, 3.0, 100, 0, "Sets global energy scale for AO");
1809                 uiDefButF(block, NUMSLI, B_REDR, "Bias:", 160, 0, 150, 19, &wrld->aobias, 0.0, 0.5, 10, 0, "Sets bias to prevent smoothed faces to show banding (in radians)");
1810         }
1811
1812 }
1813
1814 static void world_panel_world(World *wrld)
1815 {
1816         uiBlock *block;
1817         
1818         block= uiNewBlock(&curarea->uiblocks, "world_panel_world", UI_EMBOSS, UI_HELV, curarea->win);
1819         if(uiNewPanel(curarea, block, "World", "World", 320, 0, 318, 204)==0) return;
1820
1821         uiBlockSetCol(block, TH_BUT_SETTING2);
1822         std_libbuttons(block, 10, 180, 0, NULL, B_WORLDBROWSE, ID_WO, 0, (ID *)wrld, (ID *)G.scene, &(G.buts->menunr), B_WORLDALONE, B_WORLDLOCAL, B_WORLDDELETE, 0, B_KEEPDATA);
1823
1824         if(wrld==NULL) return;
1825         
1826         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1827         uiBlockSetCol(block, TH_AUTO);
1828
1829         uiDefButF(block, COL, B_WORLDPRV, "",                   10,150,145,19, &wrld->horr, 0, 0, 0, B_COLHOR, "");
1830         uiDefButF(block, COL, B_WORLDPRV, "",                   160,150,145,19, &wrld->zenr, 0, 0, 0, B_COLZEN, "");
1831
1832         uiBlockBeginAlign(block);
1833         uiDefButF(block, NUMSLI,B_WORLDPRV,"HoR ",      10,130,145,19,  &(wrld->horr), 0.0, 1.0, B_COLHOR,0, "Sets the amount of red colour at the horizon");
1834         uiDefButF(block, NUMSLI,B_WORLDPRV,"HoG ",      10,110,145,19,  &(wrld->horg), 0.0, 1.0, B_COLHOR,0, "Sets the amount of green colour at the horizon");
1835         uiDefButF(block, NUMSLI,B_WORLDPRV,"HoB ",      10,90,145,19,   &(wrld->horb), 0.0, 1.0, B_COLHOR,0, "Sets the amount of blue colour at the horizon");
1836         
1837         uiBlockBeginAlign(block);
1838         uiDefButF(block, NUMSLI,B_WORLDPRV,"ZeR ",      160,130,145,19, &(wrld->zenr), 0.0, 1.0, B_COLZEN,0, "Sets the amount of red colour at the zenith");
1839         uiDefButF(block, NUMSLI,B_WORLDPRV,"ZeG ",      160,110,145,19, &(wrld->zeng), 0.0, 1.0, B_COLZEN,0, "Sets the amount of green colour at the zenith");
1840         uiDefButF(block, NUMSLI,B_WORLDPRV,"ZeB ",      160,90,145,19,  &(wrld->zenb), 0.0, 1.0, B_COLZEN,0, "Sets the amount of blue colour at the zenith");
1841
1842         uiBlockBeginAlign(block);
1843         uiDefButF(block, NUMSLI,B_WORLDPRV,"AmbR ",     10,50,145,19,   &(wrld->ambr), 0.0, 1.0 ,0,0, "Sets the amount of red ambient colour");
1844         uiDefButF(block, NUMSLI,B_WORLDPRV,"AmbG ",     10,30,145,19,   &(wrld->ambg), 0.0, 1.0 ,0,0, "Sets the amount of green ambient colour");
1845         uiDefButF(block, NUMSLI,B_WORLDPRV,"AmbB ",     10,10,145,19,   &(wrld->ambb), 0.0, 1.0 ,0,0, "Sets the amount of blue ambient colour");
1846
1847         uiBlockBeginAlign(block);
1848         uiBlockSetCol(block, TH_BUT_SETTING1);
1849         uiDefButF(block, NUMSLI,B_WORLDPRV, "Exp ",                     160,30,145,19,  &(wrld->exp), 0.0, 1.0, 0, 2, "Sets amount of exponential color correction for light");
1850         uiDefButF(block, NUMSLI,B_WORLDPRV, "Range ",           160,10,145,19,  &(wrld->range), 0.2, 5.0, 0, 2, "Sets the color amount that will be mapped on color 1.0");
1851
1852
1853 }
1854
1855 static void world_panel_preview(World *wrld)
1856 {
1857         uiBlock *block;
1858         
1859         /* name "Preview" is abused to detect previewrender offset panel */
1860         block= uiNewBlock(&curarea->uiblocks, "world_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
1861         if(uiNewPanel(curarea, block, "Preview", "World", 0, 0, 318, 204)==0) return;
1862         
1863         if(wrld==NULL) return;
1864
1865         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1866
1867         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1868
1869         // label to force a boundbox for buttons not to be centered
1870         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1871
1872         uiBlockBeginAlign(block);
1873         uiDefButBitS(block, TOG, WO_SKYREAL, B_WORLDPRV,"Real", 200,175,80,25, &wrld->skytype, 0, 0, 0, 0, "Renders background with a real horizon");
1874         uiDefButBitS(block, TOG, WO_SKYBLEND, B_WORLDPRV,"Blend",200,150,80,25, &wrld->skytype, 0, 0, 0, 0, "Renders background with natural progression from horizon to zenith");
1875         uiDefButBitS(block, TOG,WO_SKYPAPER, B_WORLDPRV,"Paper",200,125,80,25, &wrld->skytype, 0, 0, 0, 0, "Flattens blend or texture coordinates");
1876         uiBlockEndAlign(block);
1877
1878 }
1879
1880 /* ************************ LAMP *************************** */
1881
1882 void do_lampbuts(unsigned short event)
1883 {
1884         static short mtexcopied=0;
1885         static MTex mtexcopybuf;
1886         Lamp *la;
1887         MTex *mtex;
1888
1889         switch(event) {
1890         case B_LAMPREDRAW:
1891                 BIF_preview_changed(ID_LA);
1892                 allqueue(REDRAWVIEW3D, 0);
1893                 allqueue(REDRAWBUTSSHADING, 0);
1894                 break;
1895         case B_TEXCLEARLAMP:
1896                 la= G.buts->lockpoin;
1897                 mtex= la->mtex[ la->texact ];
1898                 if(mtex) {
1899                         if(mtex->tex) mtex->tex->id.us--;
1900                         MEM_freeN(mtex);
1901                         la->mtex[ la->texact ]= 0;
1902                         BIF_undo_push("Unlink world texture");
1903                         allqueue(REDRAWBUTSSHADING, 0);
1904                         allqueue(REDRAWOOPS, 0);
1905                         BIF_preview_changed(ID_LA);
1906                 }
1907                 break;
1908         case B_SBUFF:
1909                 la= G.buts->lockpoin;
1910                 la->bufsize = la->bufsize&=(~15); 
1911                 allqueue(REDRAWBUTSSHADING, 0); 
1912                 allqueue(REDRAWOOPS, 0); 
1913                 break; 
1914         case B_SHADBUF:
1915                 la= G.buts->lockpoin; 
1916                 la->mode &= ~LA_SHAD_RAY;
1917                 allqueue(REDRAWBUTSSHADING, 0); 
1918                 allqueue(REDRAWVIEW3D, 0);              
1919                 break;
1920         case B_SHADRAY:
1921                 la= G.buts->lockpoin; 
1922                 la->mode &= ~LA_SHAD;
1923                 /* yafray: 'softlight' uses it's own shadbuf. flag.
1924                    Must be cleared here too when switching from ray shadow */
1925                 la->mode &= ~LA_YF_SOFT;
1926                 allqueue(REDRAWBUTSSHADING, 0);
1927                 allqueue(REDRAWVIEW3D, 0);      
1928                 break;
1929         case B_LMTEXCOPY:
1930                 la= G.buts->lockpoin;
1931                 if(la && la->mtex[(int)la->texact] ) {
1932                         mtex= la->mtex[(int)la->texact];
1933                         if(mtex->tex==0) {
1934                                 error("No texture available");
1935                         }
1936                         else {
1937                                 memcpy(&mtexcopybuf, la->mtex[(int)la->texact], sizeof(MTex));
1938                                 mtexcopied= 1;
1939                         }
1940                 }
1941                 break;
1942         case B_LMTEXPASTE:
1943                 la= G.buts->lockpoin;
1944                 if(la && mtexcopied && mtexcopybuf.tex) {
1945                         if(la->mtex[(int)la->texact]==0 ) 
1946                                 la->mtex[(int)la->texact]= MEM_mallocN(sizeof(MTex), "mtex"); 
1947                         else if(la->mtex[(int)la->texact]->tex)
1948                                 la->mtex[(int)la->texact]->tex->id.us--;
1949
1950                         memcpy(la->mtex[(int)la->texact], &mtexcopybuf, sizeof(MTex));
1951                         
1952                         id_us_plus((ID *)mtexcopybuf.tex);
1953                         BIF_undo_push("Paste mapping settings");
1954                         BIF_preview_changed(ID_LA);
1955                         scrarea_queue_winredraw(curarea);
1956                 }
1957                 break;
1958                 
1959         }
1960         
1961         if(event) freefastshade();
1962 }
1963
1964
1965 static void lamp_panel_mapto(Object *ob, Lamp *la)
1966 {
1967         uiBlock *block;
1968         MTex *mtex;
1969         
1970         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_mapto", UI_EMBOSS, UI_HELV, curarea->win);
1971         uiNewPanelTabbed("Texture and Input", "Lamp");
1972         if(uiNewPanel(curarea, block, "Map To", "Lamp", 1280, 0, 318, 204)==0) return;
1973
1974         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1975
1976         mtex= la->mtex[ la->texact ];
1977         if(mtex==0) {
1978                 mtex= &emptytex;
1979                 default_mtex(mtex);
1980                 mtex->texco= TEXCO_VIEW;
1981         }
1982
1983         /* TEXTURE OUTPUT */
1984         uiBlockBeginAlign(block);
1985         uiDefButBitS(block, TOG, MTEX_STENCIL, B_LAMPPRV, "Stencil",    10,125,45,19, &(mtex->texflag), 0, 0, 0, 0, "Sets the texture mapping to stencil mode");
1986         uiDefButBitS(block, TOG, MTEX_NEGATIVE, B_LAMPPRV, "Neg",               55,125,30,19, &(mtex->texflag), 0, 0, 0, 0, "Inverts the values of the texture to reverse its effect");
1987         uiDefButBitS(block, TOG, MTEX_RGBTOINT, B_LAMPPRV, "No RGB",            85,125,60,19, &(mtex->texflag), 0, 0, 0, 0, "Converts texture RGB values to intensity (gray) values");
1988         uiBlockEndAlign(block);
1989         
1990         uiBlockBeginAlign(block);
1991         uiDefButF(block, COL, B_LAMPPRV, "",                    10,100,135,19, &(mtex->r), 0, 0, 0, B_MTEXCOL, "");
1992         uiDefButF(block, NUMSLI, B_LAMPPRV, "R ",                       10,80,135,19, &(mtex->r), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
1993         uiDefButF(block, NUMSLI, B_LAMPPRV, "G ",                       10,60,135,19, &(mtex->g), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
1994         uiDefButF(block, NUMSLI, B_LAMPPRV, "B ",                       10,40,135,19, &(mtex->b), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
1995         uiBlockEndAlign(block);
1996         uiDefButF(block, NUMSLI, B_LAMPPRV, "DVar ",                    10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "The default value the textures uses to mix with");
1997         
1998         /* MAP TO */
1999         uiDefButBitS(block, TOG, MAP_COL, B_LAMPPRV, "Col",             10,180,135,19, &(mtex->mapto), 0, 0, 0, 0, "Lets the texture affect the basic colour of the lamp");
2000         
2001         uiBlockBeginAlign(block);
2002         uiDefButS(block, MENU, B_LAMPPRV, mapto_blendtype_pup(),155,125,155,19, &(mtex->blendtype), 0, 0, 0, 0, "Texture blending mode");
2003         uiBlockEndAlign(block);
2004
2005         uiDefButF(block, NUMSLI, B_LAMPPRV, "Col  ",                    155,100,155,19, &(mtex->colfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects colour values");
2006
2007 }
2008
2009
2010 static void lamp_panel_texture(Object *ob, Lamp *la)
2011 {
2012         uiBlock *block;
2013         MTex *mtex;
2014         ID *id;
2015         int a, loos;
2016         char *strp, str[64];
2017         
2018         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
2019         if(uiNewPanel(curarea, block, "Texture and Input", "Lamp", 960, 0, 318, 204)==0) return;
2020
2021         uiSetButLock(la->id.lib!=0, "Can't edit library data");
2022
2023         /* TEX CHANNELS */
2024         uiBlockSetCol(block, TH_BUT_NEUTRAL);
2025         uiBlockBeginAlign(block);
2026         for(a= 0; a<MAX_MTEX; a++) {
2027                 mtex= la->mtex[a];
2028                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
2029                 else strcpy(str, "");
2030                 str[10]= 0;
2031                 uiDefButS(block, ROW, B_REDR, str,      10, 160-18*a, 80, 20, &(la->texact), 3.0, (float)a, 0, 0, "");
2032         }
2033         uiBlockEndAlign(block);
2034         
2035         mtex= la->mtex[ la->texact ];
2036         if(mtex==0) {
2037                 mtex= &emptytex;
2038                 default_mtex(mtex);
2039                 mtex->texco= TEXCO_VIEW;
2040         }
2041
2042         /* TEXTUREBLOK SELECT */
2043         uiBlockSetCol(block, TH_BUT_SETTING2);
2044         id= (ID *)mtex->tex;
2045         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
2046         
2047         /* doesnt work, because lockpoin points to lamp, not to texture */
2048         uiDefButS(block, MENU, B_LTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Selects an existing texture or creates new");  
2049         MEM_freeN(strp);
2050         
2051         if(id) {
2052                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,200,19, id->name+2, 0.0, 18.0, 0, 0, "Displays name of the texture block: click to change");
2053                 sprintf(str, "%d", id->us);
2054                 uiDefBut(block, BUT, 0, str,                    196,140,21,19, 0, 0, 0, 0, 0, "Displays number of users of texture: click to make single user");
2055                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 221,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
2056                 if(id->lib) {
2057                         if(la->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,140,21,19, 0, 0, 0, 0, 0, "");
2058                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
2059                 }
2060                 uiBlockSetCol(block, TH_AUTO);
2061                 uiDefBut(block, BUT, B_TEXCLEARLAMP, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erases link to texture");
2062         }
2063         else 
2064                 uiDefButS(block, TOG, B_LTEXBROWSE, "Add New" ,100, 160, 200, 19, &(G.buts->texnr), -1.0, 32767.0, 0, 0, "Adds a new texture datablock");
2065
2066         /* copy/paste */
2067         uiBlockBeginAlign(block);
2068         uiDefIconBut(block, BUT, B_LMTEXCOPY, ICON_COPYUP,      250,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
2069         uiDefIconBut(block, BUT, B_LMTEXPASTE, ICON_PASTEUP,    275,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
2070         
2071         /* TEXCO */
2072         uiBlockSetCol(block, TH_AUTO);
2073         uiBlockBeginAlign(block);
2074         uiDefButS(block, ROW, B_LAMPPRV, "Glob",                        100,110,60,20, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Uses global coordinates for the texture coordinates");
2075         uiDefButS(block, ROW, B_LAMPPRV, "View",                        160,110,70,20, &(mtex->texco), 4.0, (float)TEXCO_VIEW, 0, 0, "Uses view coordinates for the texture coordinates");
2076         uiDefButS(block, ROW, B_LAMPPRV, "Object",              230,110,70,20, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Uses linked object's coordinates for texture coordinates");
2077         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_LAMPPRV, "", 100,90,200,20, &(mtex->object), "");
2078         
2079         uiBlockBeginAlign(block);
2080         uiDefButF(block, NUM, B_LAMPPRV, "dX",          100,50,100,18, mtex->ofs, -20.0, 20.0, 10, 0, "Fine tunes texture mapping X coordinate");
2081         uiDefButF(block, NUM, B_LAMPPRV, "dY",          100,30,100,18, mtex->ofs+1, -20.0, 20.0, 10, 0, "Fine tunes texture mapping Y coordinate");
2082         uiDefButF(block, NUM, B_LAMPPRV, "dZ",          100,10,100,18, mtex->ofs+2, -20.0, 20.0, 10, 0, "Fine tunes texture mapping Z coordinate");
2083         uiBlockBeginAlign(block);
2084         uiDefButF(block, NUM, B_LAMPPRV, "sizeX",       200,50,100,18, mtex->size, -10.0, 10.0, 10, 0, "Sets scaling for the texture's X size");
2085         uiDefButF(block, NUM, B_LAMPPRV, "sizeY",       200,30,100,18, mtex->size+1, -10.0, 10.0, 10, 0, "Sets scaling for the texture's Y size");
2086         uiDefButF(block, NUM, B_LAMPPRV, "sizeZ",       200,10,100,18, mtex->size+2, -10.0, 10.0, 10, 0, "Sets scaling for the texture's Z size");
2087         uiBlockEndAlign(block);
2088 }
2089
2090 static void lamp_panel_spot(Object *ob, Lamp *la)
2091 {
2092         uiBlock *block;
2093         float grid=0.0;
2094         
2095         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_spot", UI_EMBOSS, UI_HELV, curarea->win);
2096         if(uiNewPanel(curarea, block, "Shadow and Spot", "Lamp", 640, 0, 318, 204)==0) return;
2097
2098         /* hemis and ray shadow dont work at all... */
2099         /* yafray: ignore photonlight as well */
2100         if ((la->type==LA_HEMI) || (la->type==LA_YF_PHOTON)) return;
2101
2102         if(G.vd) grid= G.vd->grid; 
2103         if(grid<1.0) grid= 1.0;
2104
2105         uiSetButLock(la->id.lib!=0, "Can't edit library data");
2106
2107         uiBlockSetCol(block, TH_BUT_SETTING1);
2108         uiBlockBeginAlign(block);
2109         uiDefButBitS(block, TOG, LA_SHAD_RAY, B_SHADRAY,"Ray Shadow",10,180,80,19,&la->mode, 0, 0, 0, 0, "Use ray tracing for shadow");
2110         if(la->type==LA_SPOT) 
2111                 uiDefButBitS(block, TOG, LA_SHAD, B_SHADBUF, "Buf.Shadow",10,160,80,19,&la->mode, 0, 0, 0, 0, "Lets spotlight produce shadows using shadow buffer");
2112         uiBlockEndAlign(block);
2113         
2114         uiDefButBitS(block, TOG, LA_ONLYSHADOW, 0,"OnlyShadow",                 10,110,80,19,&la->mode, 0, 0, 0, 0, "Causes light to cast shadows only without illuminating objects");
2115
2116         if(la->type==LA_SPOT) {
2117                 uiDefButBitS(block, TOG, LA_SQUARE, B_LAMPREDRAW,"Square",      10,70,80,19,&la->mode, 0, 0, 0, 0, "Sets square spotbundles");
2118                 uiDefButBitS(block, TOG, LA_HALO, 0,"Halo",                             10,50,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
2119
2120                 uiBlockSetCol(block, TH_AUTO);
2121                 uiBlockBeginAlign(block);
2122                 uiDefButF(block, NUMSLI,B_LAMPREDRAW,"SpotSi ", 100,180,200,19,&la->spotsize, 1.0, 180.0, 0, 0, "Sets the angle of the spotlight beam in degrees");
2123                 uiDefButF(block, NUMSLI,B_LAMPREDRAW,"SpotBl ",         100,160,200,19,&la->spotblend, 0.0, 1.0, 0, 0, "Sets the softness of the spotlight edge");
2124                 uiBlockEndAlign(block);
2125         
2126                 uiDefButF(block, NUMSLI,0,"HaloInt ",                   100,135,200,19,&la->haint, 0.0, 5.0, 0, 0, "Sets the intensity of the spotlight halo");
2127                 
2128                 if(la->mode & LA_SHAD) {
2129                         uiDefButS(block, NUM,B_SBUFF,"ShadowBufferSize:", 100,110,200,19,       &la->bufsize,512,10240, 0, 0, "Sets the size of the shadow buffer to nearest multiple of 16");
2130                 
2131                         uiBlockBeginAlign(block);
2132                         uiDefButF(block, NUM,REDRAWVIEW3D,"ClipSta:",   100,70,100,19,  &la->clipsta, 0.1*grid,1000.0*grid, 10, 0, "Sets the shadow map clip start: objects closer will not generate shadows");
2133                         uiDefButF(block, NUM,REDRAWVIEW3D,"ClipEnd:",   200,70,100,19,&la->clipend, 1.0, 5000.0*grid, 100, 0, "Sets the shadow map clip end beyond which objects will not generate shadows");
2134                         uiBlockEndAlign(block);
2135                         
2136                         uiDefButS(block, NUM,0,"Samples:",              100,30,100,19,  &la->samp,1.0,16.0, 0, 0, "Sets the number of shadow map samples");
2137                         uiDefButS(block, NUM,0,"Halo step:",    200,30,100,19,  &la->shadhalostep, 0.0, 12.0, 0, 0, "Sets the volumetric halo sampling frequency");
2138                         uiDefButF(block, NUM,0,"Bias:",                 100,10,100,19,  &la->bias, 0.01, 5.0, 1, 0, "Sets the shadow map sampling bias");
2139                         uiDefButF(block, NUM,0,"Soft:",                 200,10,100,19,  &la->soft,1.0,100.0, 100, 0, "Sets the size of the shadow sample area");
2140                 }
2141         }
2142         else if(la->type==LA_AREA && (la->mode & LA_SHAD_RAY)) {
2143                 uiBlockBeginAlign(block);
2144                 uiBlockSetCol(block, TH_AUTO);
2145                 if(la->area_shape==LA_AREA_SQUARE) 
2146                         uiDefButS(block, NUM,0,"Samples:",      100,180,200,19, &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of samples taken extra (samp x samp)");
2147                 if(la->area_shape==LA_AREA_CUBE) 
2148                         uiDefButS(block, NUM,0,"Samples:",      100,160,200,19, &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of samples taken extra (samp x samp x samp)");
2149
2150                 if ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_BOX) {
2151                         uiDefButS(block, NUM,0,"SamplesX:",     100,180,200,19, &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of X samples taken extra");
2152                         uiDefButS(block, NUM,0,"SamplesY:",     100,160,200,19, &la->ray_sampy, 1.0, 16.0, 100, 0, "Sets the amount of Y samples taken extra");
2153                         if(la->area_shape==LA_AREA_BOX)
2154                                 uiDefButS(block, NUM,0,"SamplesZ:",     100,140,200,19, &la->ray_sampz, 1.0, 8.0, 100, 0, "Sets the amount of Z samples taken extra");
2155                 }
2156                 
2157                 uiBlockBeginAlign(block);
2158                 uiDefButBitS(block, TOG, LA_SAMP_UMBRA, 0,"Umbra",                      100,110,200,19,&la->ray_samp_type, 0, 0, 0, 0, "Emphasis parts that are fully shadowed");
2159                 uiDefButBitS(block, TOG, LA_SAMP_DITHER, 0,"Dither",                    100,90,100,19,&la->ray_samp_type, 0, 0, 0, 0, "Use 2x2 dithering for sampling");
2160                 uiDefButBitS(block, TOG, LA_SAMP_JITTER, 0,"Noise",                     200,90,100,19,&la->ray_samp_type, 0, 0, 0, 0, "Use noise for sampling");
2161         }
2162         else uiDefBut(block, LABEL,0," ",       100,180,200,19,NULL, 0, 0, 0, 0, "");
2163
2164 }
2165
2166 /* yafray: adaptation of lamp_panel_spot above with yafray specific parameters */
2167 static void lamp_panel_yafray(Object *ob, Lamp *la)
2168 {
2169         uiBlock *block;
2170         
2171         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_yafray", UI_EMBOSS, UI_HELV, curarea->win);
2172         if(uiNewPanel(curarea, block, "Yafray: Shadow and Photons", "Lamp", 640, 0, 318, 204)==0) return;
2173
2174         /* hemis not used in yafray */
2175         if(la->type==LA_HEMI) return;
2176         
2177         uiSetButLock(la->id.lib!=0, "Can't edit library data");
2178         
2179                 /* photonlight params */
2180         if (la->type==LA_YF_PHOTON) {
2181                 uiBlockSetCol(block, TH_BUT_SETTING1);
2182                 uiDefButBitS(block, TOG, 1, B_DIFF,"Use QMC",10,180,80,19,&la->YF_useqmc, 0, 0, 0, 0, "Use QMC sampling (sometimes visible patterns)");
2183                 uiBlockSetCol(block, TH_AUTO);
2184                 uiDefButF(block, NUMSLI,B_LAMPREDRAW,"Angle ",  100,180,200,19,&la->spotsize, 1.0, 180.0, 0, 0, "Sets the angle of the photonlight beam in degrees");
2185                 uiDefButI(block, NUM,B_DIFF,"photons:", 10,150,290,19,  &la->YF_numphotons, 10000, 100000000, 0, 0, "Maximum number of photons to shoot");
2186                 uiDefButI(block, NUM,B_DIFF,"search:", 10,130,290,19,   &la->YF_numsearch, 100, 1000, 0, 0, "Number of photons to mix (blur)");
2187                 uiDefButS(block, NUM,B_DIFF,"depth:", 10,100,290,19,    &la->YF_phdepth, 1, 100, 0, 0, "Maximum caustic bounce depth");
2188                 uiDefButF(block, NUM,B_DIFF,"Blur:", 10,70,290,19,      &la->YF_causticblur, 0.01, 1.0, 1, 0, "Amount of caustics blurring (also depends on search)");
2189                 return;
2190         }
2191
2192         uiBlockSetCol(block, TH_BUT_SETTING1);
2193         
2194         /* in yafray arealights always cast shadows, so ray shadow flag not needed */
2195         /* ray shadow also not used when halo for spot enabled */
2196         if ((la->type!=LA_AREA) && (!((la->type==LA_SPOT) && (la->mode & LA_HALO))))
2197                 uiDefButBitS(block, TOG, LA_SHAD_RAY, B_SHADRAY,"Ray Shadow",10,180,80,19,&la->mode, 0, 0, 0, 0, "Use ray tracing for shadow");
2198         
2199         /* in yafray the regular lamp can use shadowbuffers (softlight), used by spot with halo as well */
2200         /* to prevent clash with blender shadowbuf flag, a special flag is used for yafray */
2201         if (la->type==LA_LOCAL) {
2202                 uiDefButBitS(block, TOG, LA_YF_SOFT, B_SHADBUF, "Buf.Shadow",10,160,80,19,&la->mode, 0, 0, 0, 0, "Lets light produce shadows using shadow buffer");
2203                 uiDefButF(block, NUM, B_DIFF, "GloInt:", 100,155,200,19, &la->YF_glowint, 0.0, 1.0, 1, 0, "Sets light glow intensity, 0 is off");
2204                 uiDefButF(block, NUM, B_DIFF, "GloOfs:", 100,135,100,19, &la->YF_glowofs, 0.0, 2.0, 1, 0, "Sets light glow offset, the higher, the less 'peaked' the glow");
2205                 uiDefButS(block, NUM, B_DIFF, "GlowType:", 200,135,100,19, &la->YF_glowtype, 0, 1, 1, 0, "Sets light glow type");
2206         }
2207         
2208         /* shadowbuffers used only for 'softlight' & spotlight with halo */
2209         if (((la->type==LA_LOCAL) && (la->mode & LA_YF_SOFT)) || ((la->type==LA_SPOT) && (la->mode & LA_HALO))) {
2210                 /* Shadow buffer size can be anything in yafray, but reasonable minimum is 128 */
2211                 /* Maximum is 1024, since zbuf in yafray is float, no multiple of 16 restriction */
2212                 uiDefButS(block, NUM,B_DIFF,"ShadowBufferSize:", 100,110,200,19,        &la->YF_bufsize, 128, 1024, 0, 0, "Sets the size of the shadow buffer");
2213
2214                 /* samples & halostep params only used for spotlight with halo */
2215                 if ((la->type==LA_SPOT) && (la->mode & LA_HALO)) {
2216                         uiDefButS(block, NUM,B_DIFF,"Samples:",         100,30,100,19,  &la->samp,1.0,16.0, 0, 0, "Sets the number of shadow map samples");
2217                         uiDefButS(block, NUM,B_DIFF,"Halo step:",       200,30,100,19,  &la->shadhalostep, 0.0, 12.0, 0, 0, "Sets the volumetric halo sampling frequency");
2218                 }
2219                 uiDefButF(block, NUM,B_DIFF,"Bias:",                    100,10,100,19,  &la->bias, 0.01, 5.0, 1, 0, "Sets the shadow map sampling bias");
2220                 /* here can use the Blender soft param, since for yafray it has the same function as in Blender */
2221                 uiDefButF(block, NUM,B_DIFF,"Soft:",                    200,10,100,19,  &la->soft,1.0,100.0, 100, 0, "Sets the size of the shadow sample area");
2222         }
2223         else if ((la->type==LA_LOCAL) && (la->mode & LA_SHAD_RAY)) {
2224                 /* for spherelight, light radius */
2225                 uiDefButF(block, NUM,B_DIFF,"Radius:",                  200,10,100,19,  &la->YF_ltradius, 0.0,100.0, 100, 0, "Sets the radius of the lightsource, 0 is same as pointlight");
2226         }
2227         
2228         if (la->type==LA_SPOT) {
2229
2230                 uiDefButBitS(block, TOG, LA_HALO, B_LAMPREDRAW,"Halo",                          10,50,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
2231
2232                 uiBlockSetCol(block, TH_AUTO);
2233                 uiBlockBeginAlign(block);
2234                 uiDefButF(block, NUMSLI,B_LAMPREDRAW,"SpotSi ", 100,180,200,19,&la->spotsize, 1.0, 180.0, 0, 0, "Sets the angle of the spotlight beam in degrees");
2235                 uiDefButF(block, NUMSLI,B_LAMPREDRAW,"SpotBl ",         100,160,200,19,&la->spotblend, 0.0, 1.0, 0, 0, "Sets the softness of the spotlight edge");
2236                 uiBlockEndAlign(block);
2237         
2238                 if (la->mode & LA_HALO) uiDefButF(block, NUMSLI,0,"HaloInt ",                   100,135,200,19,&la->haint, 0.0, 5.0, 0, 0, "Sets the intensity of the spotlight halo");
2239         }
2240         else if ((la->type==LA_AREA) || ((la->type==LA_LOCAL) && (la->mode & LA_SHAD_RAY))) {
2241                 /* area samples param also used for 'spherelight' */
2242                 uiBlockBeginAlign(block);
2243                 uiBlockSetCol(block, TH_AUTO);
2244                 
2245                 uiDefButS(block, NUM,B_DIFF,"Samples:", 100,180,200,19, &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of samples taken extra (samp x samp)");
2246
2247                 /* shadow sampling types not used in yafray, removed */
2248         }
2249         else uiDefBut(block, LABEL,0," ",       100,180,200,19,NULL, 0, 0, 0, 0, "");   
2250
2251 }
2252
2253 static void lamp_panel_lamp(Object *ob, Lamp *la)
2254 {
2255         uiBlock *block;
2256         float grid= 0.0;
2257         short xco;
2258         
2259         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_lamp", UI_EMBOSS, UI_HELV, curarea->win);
2260         if(uiNewPanel(curarea, block, "Lamp", "Lamp", 320, 0, 318, 204)==0) return;
2261
2262         if(G.vd) grid= G.vd->grid; 
2263         if(grid<1.0) grid= 1.0;
2264
2265         uiSetButLock(la->id.lib!=0, "Can't edit library data");
2266
2267         uiBlockSetCol(block, TH_BUT_SETTING2);
2268         xco= std_libbuttons(block, 8, 180, 0, NULL, B_LAMPBROWSE, ID_LA, 0, (ID *)la, (ID *)ob, &(G.buts->menunr), B_LAMPALONE, B_LAMPLOCAL, 0, 0, 0);  
2269
2270         uiBlockSetCol(block, TH_AUTO);
2271         uiDefButF(block, NUM,B_LAMPREDRAW,"Dist:", xco,180,300-xco,20,&la->dist, 0.01, 5000.0*grid, 100, 0, "Sets the distance value at which light intensity is half");
2272
2273         uiBlockBeginAlign(block);
2274         if(la->type==LA_AREA) {
2275                 //uiDefButS(block, MENU, B_LAMPREDRAW, "Shape %t|Square %x0|Rect %x1|Cube %x2|Box %x3",
2276                 uiDefButS(block, MENU, B_LAMPREDRAW, "Shape %t|Square %x0|Rect %x1",
2277                                 10, 150, 100, 19, &la->area_shape, 0,0,0,0, "Sets area light shape");   
2278                 if ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_BOX){
2279                         uiDefButF(block, NUM,B_LAMPREDRAW,"SizeX ",     10,130,100,19, &la->area_size, 0.01, 100.0, 10, 0, "Area light size X, doesn't affect energy amount");
2280                         uiDefButF(block, NUM,B_LAMPREDRAW,"SizeY ",     10,110,100,19, &la->area_sizey, 0.01, 100.0, 10, 0, "Area light size Y, doesn't affect energy amount");
2281                 }
2282                 if(la->area_shape==LA_AREA_BOX)
2283                         uiDefButF(block, NUM,B_LAMPREDRAW,"SizeZ ",     10,90,100,19, &la->area_sizez, 0.01, 100.0, 10, 0, "Area light size Z, doesn't affect energy amount");
2284                 if ELEM(la->area_shape, LA_AREA_SQUARE, LA_AREA_CUBE) 
2285                         uiDefButF(block, NUM,B_LAMPREDRAW,"Size ",      10,130,100,19, &la->area_size, 0.01, 100.0, 10, 0, "Area light size, doesn't affect energy amount");
2286         }
2287         else if ELEM(la->type, LA_LOCAL, LA_SPOT) {
2288                 uiBlockSetCol(block, TH_BUT_SETTING1);
2289                 uiDefButBitS(block, TOG, LA_QUAD, B_LAMPPRV,"Quad",             10,150,100,19,&la->mode, 0, 0, 0, 0, "Uses inverse quadratic proportion for light attenuation");
2290                 uiDefButBitS(block, TOG, LA_SPHERE, REDRAWVIEW3D,"Sphere",      10,130,100,19,&la->mode, 0, 0, 0, 0, "Sets light intensity to zero for objects beyond the distance value");
2291         }
2292
2293         uiBlockBeginAlign(block);
2294         uiBlockSetCol(block, TH_BUT_SETTING1);
2295         uiDefButBitS(block, TOG, LA_LAYER, 0,"Layer",                           10,70,100,19,&la->mode, 0, 0, 0, 0, "Illuminates objects in the same layer as the lamp only");
2296         uiDefButBitS(block, TOG, LA_NEG, B_LAMPPRV,"Negative",  10,50,100,19,&la->mode, 0, 0, 0, 0, "Sets lamp to cast negative light");
2297         uiDefButBitS(block, TOG, LA_NO_DIFF, 0,"No Diffuse",            10,30,100,19,&la->mode, 0, 0, 0, 0, "Disables diffuse shading of material illuminated by this lamp");
2298         uiDefButBitS(block, TOG, LA_NO_SPEC, 0,"No Specular",           10,10,100,19,&la->mode, 0, 0, 0, 0, "Disables specular shading of material illuminated by this lamp");
2299         uiBlockEndAlign(block);
2300
2301         uiBlockSetCol(block, TH_AUTO);
2302         uiDefButF(block, NUMSLI,B_LAMPPRV,"Energy ",    120,150,180,20, &(la->energy), 0.0, 10.0, 0, 0, "Sets the intensity of the light");
2303
2304         uiBlockBeginAlign(block);
2305         uiDefButF(block, NUMSLI,B_LAMPPRV,"R ",         120,120,180,20,&la->r, 0.0, 1.0, B_COLLAMP, 0, "Sets the red component of the light");
2306         uiDefButF(block, NUMSLI,B_LAMPPRV,"G ",         120,100,180,20,&la->g, 0.0, 1.0, B_COLLAMP, 0, "Sets the green component of the light");
2307         uiDefButF(block, NUMSLI,B_LAMPPRV,"B ",         120,80,180,20,&la->b, 0.0, 1.0, B_COLLAMP, 0, "Sets the blue component of the light");
2308         uiBlockEndAlign(block);
2309         
2310         uiDefButF(block, COL, B_LAMPPRV, "",            120,52,180,24, &la->r, 0, 0, 0, B_COLLAMP, "");
2311         
2312         uiBlockBeginAlign(block);
2313         if ELEM(la->type, LA_LOCAL, LA_SPOT) {
2314                 uiDefButF(block, NUMSLI,B_LAMPPRV,"Quad1 ",     120,30,180,19,&la->att1, 0.0, 1.0, 0, 0, "Set the linear distance attenuatation for a quad lamp");
2315                 uiDefButF(block, NUMSLI,B_LAMPPRV,"Quad2 ",  120,10,180,19,&la->att2, 0.0, 1.0, 0, 0, "Set the quadratic distance attenuatation for a quad lamp");
2316         }
2317         else if(la->type==LA_AREA) {
2318                 if(la->k==0.0) la->k= 1.0;
2319                 uiDefButF(block, NUMSLI,0,"Gamma ",     120,10,180,19,&la->k, 0.001, 2.0, 100, 0, "Set the light gamma correction value");
2320         }
2321 }
2322
2323
2324 static void lamp_panel_preview(Object *ob, Lamp *la)
2325 {
2326         uiBlock *block;
2327         
2328         /* name "Preview" is abused to detect previewrender offset panel */
2329         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
2330         if(uiNewPanel(curarea, block, "Preview", "Lamp", 0, 0, 318, 204)==0) return;
2331         
2332         uiSetButLock(la->id.lib!=0, "Can't edit library data");
2333
2334         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
2335
2336         // label to force a boundbox for buttons not to be centered
2337         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
2338         uiBlockBeginAlign(block);
2339         uiDefButS(block, ROW,B_LAMPREDRAW,"Lamp",       200,175,80,25,&la->type,1.0,(float)LA_LOCAL, 0, 0, "Creates an omnidirectional point light source");
2340         uiDefButS(block, ROW,B_LAMPREDRAW,"Area",       200,150,80,25,&la->type,1.0,(float)LA_AREA, 0, 0, "Creates a directional area light source");
2341         uiDefButS(block, ROW,B_LAMPREDRAW,"Spot",       200,125,80,25,&la->type,1.0,(float)LA_SPOT, 0, 0, "Creates a directional cone light source");
2342         uiDefButS(block, ROW,B_LAMPREDRAW,"Sun",        200,100,80,25,&la->type,1.0,(float)LA_SUN, 0, 0, "Creates a constant direction parallel ray light source");
2343         uiDefButS(block, ROW,B_LAMPREDRAW,"Hemi",       200,75,80,25,&la->type,1.0,(float)LA_HEMI, 0, 0, "Creates a 180 degree constant light source");
2344         /* yafray: extra type, photonlight */
2345         if (G.scene->r.renderer==R_YAFRAY)
2346                 uiDefButS(block, ROW,B_LAMPREDRAW,"Photon",     200,50,80,25,&la->type,1.0,(float)LA_YF_PHOTON, 0, 0, "Creates a special caustics photon 'light', not a real lightsource, use with other lights");
2347 }
2348
2349
2350 /* ****************** MATERIAL ***************** */
2351
2352
2353 void do_matbuts(unsigned short event)
2354 {
2355         static short mtexcopied=0;
2356         static MTex mtexcopybuf;
2357         Material *ma;
2358         MTex *mtex;
2359
2360         /* all operations default on active material layer here */
2361         /* but this also gets called for lamp and world... */
2362         ma= G.buts->lockpoin;
2363         if(ma && GS(ma->id.name)==ID_MA)
2364                 ma = editnode_get_active_material(ma);
2365         else
2366                 ma= NULL;
2367         
2368         switch(event) {
2369         case B_MAT_YF_PRESET: {
2370                 switch (ma->YF_preset) {
2371                         case 0:
2372                                 /* normal mode, no reflection/refraction */
2373                                 ma->alpha = 1;
2374                                 ma->mode &= ~(MA_RAYMIRROR+MA_RAYTRANSP+MA_ZTRA);
2375                                 break;
2376                         case 1: {
2377                                 /* clear glass */
2378                                 ma->alpha = 0.001;
2379                                 ma->ray_mirror = 1;
2380                                 ma->fresnel_mir_i = 5;
2381                                 ma->mode |= (MA_RAYMIRROR+MA_RAYTRANSP);
2382                                 ma->mode &= ~MA_ZTRA;
2383                                 ma->filter = 0;
2384                                 ma->ang = 1.5;
2385                                 break;
2386                         }
2387                         case 2: {
2388                                 /* color glass */
2389                                 ma->alpha = 0.001;
2390                                 ma->ray_mirror = 1;
2391                                 ma->fresnel_mir_i = 5;
2392                                 ma->mode |= (MA_RAYMIRROR+MA_RAYTRANSP);
2393                                 ma->mode &= ~MA_ZTRA;
2394                                 ma->filter = 1;
2395                                 ma->ang = 1.5;
2396                                 break;
2397                         }
2398                         case 3: {
2399                                 /* uniform reflect */
2400                                 ma->alpha = 1;
2401                                 ma->ray_mirror = 1;
2402                                 ma->fresnel_mir_i = 1;
2403                                 ma->mode |= MA_RAYMIRROR;
2404                                 ma->mode &= ~(MA_RAYTRANSP+MA_ZTRA);
2405                                 break;
2406                         }
2407                         case 4: {
2408                                 /* fresnel reflect */
2409                                 ma->alpha = 1;
2410                                 ma->ray_mirror = 1;
2411                                 ma->fresnel_mir_i = 5;
2412                                 ma->mode |= MA_RAYMIRROR;
2413                                 ma->mode &= ~(MA_RAYTRANSP+MA_ZTRA);
2414                                 ma->ang = 3;
2415                                 break;
2416                         }
2417                 }
2418                 BIF_preview_changed(ID_MA);
2419                 allqueue(REDRAWBUTSSHADING, 0);
2420                 shade_buttons_change_3d();
2421                 break;
2422         }
2423         case B_ACTCOL:
2424                 scrarea_queue_headredraw(curarea);
2425                 allqueue(REDRAWBUTSSHADING, 0);
2426                 allqueue(REDRAWIPO, 0);
2427                 allqueue(REDRAWOOPS, 0);
2428                 BIF_preview_changed(ID_MA);
2429                 break;
2430         case B_MATFROM:
2431                 scrarea_queue_headredraw(curarea);
2432                 allqueue(REDRAWBUTSSHADING, 0);
2433                 allqueue(REDRAWOOPS, 0);
2434                 // BIF_previewdraw();  push/pop!
2435                 break;
2436         case B_MATPRV:
2437                 if(ma) end_render_material(ma); /// temporal... 3d preview
2438                 BIF_preview_changed(ID_MA);
2439                 allqueue(REDRAWBUTSSHADING, 0);
2440                 shade_buttons_change_3d();
2441                 break;
2442         case B_TEXPRV:
2443                 BIF_preview_changed(ID_TE);
2444                 allqueue(REDRAWBUTSSHADING, 0);
2445                 break;
2446         case B_LAMPPRV:
2447                 BIF_preview_changed(ID_LA);
2448                 allqueue(REDRAWBUTSSHADING, 0);
2449                 break;
2450         case B_WORLDPRV:
2451                 BIF_preview_changed(ID_WO);
2452                 allqueue(REDRAWBUTSSHADING, 0);
2453                 break;
2454         case B_MATHALO:
2455                 /* when halo is disabled, clear star flag, this is the same as MA_FACETEXTURE <blush> */
2456                 /* same for 'xtreme alpha' which is 'only shadow' */
2457                 if((ma->mode & MA_HALO)==0) {
2458                         ma->mode &= ~(MA_STAR|MA_HALO_XALPHA|MA_ZINV);
2459                 }
2460                 BIF_preview_changed(ID_MA);
2461                 allqueue(REDRAWBUTSSHADING, 0);
2462                 shade_buttons_change_3d();
2463                 break;
2464         case B_TEXCLEAR:
2465                 mtex= ma->mtex[(int) ma->texact ];
2466                 if(mtex) {
2467                         if(mtex->tex) mtex->tex->id.us--;
2468                         MEM_freeN(mtex);
2469                         ma->mtex[ (int) ma->texact ]= 0;
2470                         BIF_undo_push("Unlink material texture");
2471                         if(ma) end_render_material(ma); /// temporal... 3d preview
2472                         allqueue(REDRAWBUTSSHADING, 0);
2473                         allqueue(REDRAWOOPS, 0);
2474                         BIF_preview_changed(ID_MA);
2475                 }
2476                 break;
2477         case B_MTEXCOPY:
2478                 if(ma && ma->mtex[(int)ma->texact] ) {
2479                         mtex= ma->mtex[(int)ma->texact];
2480                         if(mtex->tex==0) {
2481                                 error("No texture available");
2482                         }
2483                         else {
2484                                 memcpy(&mtexcopybuf, ma->mtex[(int)ma->texact], sizeof(MTex));
2485                                 mtexcopied= 1;
2486                         }
2487                 }
2488                 break;
2489         case B_MTEXPASTE:
2490                 if(ma && mtexcopied && mtexcopybuf.tex) {
2491                         if(ma->mtex[(int)ma->texact]==0 ) 
2492                                 ma->mtex[(int)ma->texact]= MEM_mallocN(sizeof(MTex), "mtex"); 
2493                         else if(ma->mtex[(int)ma->texact]->tex)
2494                                 ma->mtex[(int)ma->texact]->tex->id.us--;
2495
2496                         memcpy(ma->mtex[(int)ma->texact], &mtexcopybuf, sizeof(MTex));
2497                         
2498                         id_us_plus((ID *)mtexcopybuf.tex);
2499                         BIF_undo_push("Paste mapping settings");
2500                         BIF_preview_changed(ID_MA);
2501                         scrarea_queue_winredraw(curarea);
2502                 }
2503                 break;
2504         case B_MATLAY:
2505                 if(ma && ma->lay==0) {
2506                         ma->lay= 1;
2507                         scrarea_queue_winredraw(curarea);
2508                 }
2509                 break;
2510         case B_MATZTRANSP:
2511                 if(ma) {
2512                         ma->mode &= ~MA_RAYTRANSP;
2513                         BIF_view3d_previewrender_signal(curarea, PR_DBASE|PR_DISPRECT); /// temporal... 3d preview
2514                         allqueue(REDRAWBUTSSHADING, 0);
2515                         BIF_preview_changed(ID_MA);
2516                 }
2517                 break;
2518         case B_MATRAYTRANSP:
2519                 if(ma) {
2520                         ma->mode &= ~MA_ZTRA;
2521                         if(ma) end_render_material(ma); /// temporal... 3d preview
2522                         allqueue(REDRAWBUTSSHADING, 0);
2523                         BIF_preview_changed(ID_MA);
2524                 }
2525                 break;
2526         case B_MATCOLORBAND:
2527                 if(ma) {
2528                         if(ma->mode & MA_RAMP_COL)
2529                                 if(ma->ramp_col==NULL) ma->ramp_col= add_colorband(0);
2530                         if(ma->mode & MA_RAMP_SPEC)
2531                                 if(ma->ramp_spec==NULL) ma->ramp_spec= add_colorband(0);
2532
2533                         if(ma) end_render_material(ma); /// temporal... 3d preview
2534                         allqueue(REDRAWBUTSSHADING, 0);
2535                         BIF_preview_changed(ID_MA);
2536                         shade_buttons_change_3d();
2537                 }
2538                 break;
2539         case B_MAT_USENODES:
2540                 ma= G.buts->lockpoin;   /* use base material instead */
2541                 if(ma) {
2542                         if(ma->use_nodes && ma->nodetree==NULL) {
2543                                 node_shader_default(ma);
2544                         }
2545                         if(ma) end_render_material(ma); /// temporal... 3d preview
2546                         BIF_preview_changed(ID_MA);
2547                         allqueue(REDRAWNODE, 0);
2548                         allqueue(REDRAWBUTSSHADING, 0);
2549                 }               
2550                 break;
2551         }
2552 }
2553
2554
2555
2556 static void material_panel_map_to(Material *ma)
2557 {
2558         uiBlock *block;
2559         MTex *mtex;
2560         
2561         block= uiNewBlock(&curarea->uiblocks, "material_panel_map_to", UI_EMBOSS, UI_HELV, curarea->win);
2562         uiNewPanelTabbed("Texture", "Material");
2563         if(uiNewPanel(curarea, block, "Map To", "Material", 1600, 0, 318, 204)==0) return;
2564
2565         mtex= ma->mtex[ ma->texact ];
2566         if(mtex==0) {
2567                 mtex= &emptytex;
2568                 default_mtex(mtex);
2569         }
2570
2571         /* TEXTURE OUTPUT */
2572         uiBlockBeginAlign(block);
2573         uiDefButBitS(block, TOG, MTEX_STENCIL, B_MATPRV, "Stencil",     10,125,45,19, &(mtex->texflag), 0, 0, 0, 0, "Sets the texture mapping to stencil mode");
2574         uiDefButBitS(block, TOG, MTEX_NEGATIVE, B_MATPRV, "Neg",                55,125,30,19, &(mtex->texflag), 0, 0, 0, 0, "Inverts the values of the texture to reverse its effect");
2575         uiDefButBitS(block, TOG,MTEX_RGBTOINT, B_MATPRV, "No RGB",              85,125,60,19, &(mtex->texflag), 0, 0, 0, 0, "Converts texture RGB values to intensity (gray) values");
2576         uiBlockEndAlign(block);
2577
2578         uiBlockBeginAlign(block);
2579         uiDefButF(block, COL, B_MATPRV, "",                     10,100,135,19, &(mtex->r), 0, 0, 0, B_MTEXCOL, "");
2580         
2581         if(ma->colormodel==MA_HSV) {
2582                 uiBlockSetCol(block, TH_BUT_SETTING1);
2583                 uiDefButF(block, HSVSLI, B_MATPRV, "H ",                10,80,135,19, &(mtex->r), 0.0, 0.9999, B_MTEXCOL, 0, "");
2584                 uiDefButF(block, HSVSLI, B_MATPRV, "S ",                10,60,135,19, &(mtex->r), 0.0001, 1.0, B_MTEXCOL, 0, "");
2585                 uiDefButF(block, HSVSLI, B_MATPRV, "V ",                10,40,135,19, &(mtex->r), 0.0001, 1.0, B_MTEXCOL, 0, "");
2586                 uiBlockSetCol(block, TH_AUTO);
2587         }
2588         else {
2589                 uiDefButF(block, NUMSLI, B_MATPRV, "R ",                10,80,135,19, &(mtex->r), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
2590                 uiDefButF(block, NUMSLI, B_MATPRV, "G ",                10,60,135,19, &(mtex->g), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
2591                 uiDefButF(block, NUMSLI, B_MATPRV, "B ",                10,40,135,19, &(mtex->b), 0.0, 1.0, B_MTEXCOL, 0, "The default color for textures that don't return RGB");
2592         }
2593         uiBlockEndAlign(block);
2594         
2595         uiDefButF(block, NUMSLI, B_MATPRV, "DVar ",                     10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "The default value the texture uses to mix with (not RGB)");
2596         
2597         /* MAP TO */
2598         uiBlockBeginAlign(block);
2599         uiDefButBitS(block, TOG, MAP_COL, B_MATPRV, "Col",              10,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect basic colour of the material");
2600         uiDefButBitS(block, TOG3, MAP_NORM, B_MATPRV, "Nor",            50,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the rendered normal");
2601         uiDefButBitS(block, TOG, MAP_COLSPEC, B_MATPRV, "Csp",          90,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the specularity colour");
2602         uiDefButBitS(block, TOG, MAP_COLMIR, B_MATPRV, "Cmir",          130,180,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the mirror colour");
2603         uiDefButBitS(block, TOG3, MAP_REF, B_MATPRV, "Ref",             180,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of the materials reflectivity");
2604         uiDefButBitS(block, TOG3, MAP_SPEC, B_MATPRV, "Spec",           220,180,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of specularity");
2605         uiDefButBitS(block, TOG3, MAP_AMB, B_MATPRV, "Amb",             270,180,40,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the value of ambient");
2606         
2607         uiDefButBitS(block, TOG3, MAP_HAR, B_MATPRV, "Hard",            10,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the hardness value");
2608         uiDefButBitS(block, TOG3, MAP_RAYMIRR, B_MATPRV, "RayMir",      60,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the ray-mirror value");
2609         uiDefButBitS(block, TOG3, MAP_ALPHA, B_MATPRV, "Alpha",         110,160,50,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the alpha value");
2610         uiDefButBitS(block, TOG3, MAP_EMIT, B_MATPRV, "Emit",           160,160,45,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the emit value");
2611         uiDefButBitS(block, TOG3, MAP_LAYER, B_MATPRV, "Layer",         205,160,60,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the layer blending value");
2612         uiDefButBitS(block, TOG3, MAP_DISPLACE, B_MATPRV, "Disp",               265,160,45,19, &(mtex->mapto), 0, 0, 0, 0, "Let the texture displace the surface");
2613         uiBlockEndAlign(block);
2614         
2615         uiBlockBeginAlign(block);
2616         uiDefButS(block, MENU, B_MATPRV, mapto_blendtype_pup(),155,125,155,19, &(mtex->blendtype), 0, 0, 0, 0, "Texture blending mode");
2617         uiBlockEndAlign(block);
2618
2619         uiBlockBeginAlign(block);
2620         uiDefButF(block, NUMSLI, B_MATPRV, "Col ",                      155,100,155,19, &(mtex->colfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects colour values");
2621         /* newnoise: increased range to 25, the constant offset for bumpmapping quite often needs a higher nor setting */
2622         uiDefButF(block, NUMSLI, B_MATPRV, "Nor ",                      155,80,155,19, &(mtex->norfac), 0.0, 25.0, 0, 0, "Sets the amount the texture affects normal values");
2623         uiDefButF(block, NUMSLI, B_MATPRV, "Var ",                      155,60,155,19, &(mtex->varfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects other values");
2624         uiDefButF(block, NUMSLI, B_MATPRV, "Disp ",                     155,40,155,19, &(mtex->dispfac), 0.0, 1.0, 0, 0, "Sets the amount the texture displaces the surface");
2625
2626         uiBlockBeginAlign(block);
2627         uiDefButBitS(block, TOG, MAP_WARP, B_MATPRV, "Warp",            155,10,40,19, &(mtex->mapto), 0, 0, 0, 0, "Let the texture warp texture coordinates of next channels");
2628         uiDefButF(block, NUMSLI, B_MATPRV, "fac ",                      195,10,115,19, &(mtex->warpfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects texture coordinates of next channels");
2629 }
2630
2631
2632 static void material_panel_map_input(Object *ob, Material *ma)
2633 {
2634         uiBlock *block;
2635         MTex *mtex;
2636         int b;
2637         
2638         block= uiNewBlock(&curarea->uiblocks, "material_panel_map_input", UI_EMBOSS, UI_HELV, curarea->win);
2639         uiNewPanelTabbed("Texture", "Material");
2640         if(uiNewPanel(curarea, block, "Map Input", "Material", 1280, 0, 318, 204)==0) return;
2641
2642         mtex= ma->mtex[ ma->texact ];
2643         if(mtex==0) {
2644                 mtex= &emptytex;
2645                 default_mtex(mtex);
2646         }
2647         
2648         /* TEXCO */
2649         uiBlockBeginAlign(block);
2650         uiDefButS(block, ROW, B_MATPRV, "Glob",                 630,180,45,18, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Uses global coordinates for the texture coordinates");
2651         uiDefButS(block, ROW, B_MATPRV, "Object",               675,180,75,18, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Uses linked object's coordinates for texture coordinates");
2652         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_MATPRV, "",750,180,158,18, &(mtex->object), "");
2653         
2654         uiDefButS(block, ROW, B_MATPRV, "UV",                   630,160,40,18, &(mtex->texco), 4.0, (float)TEXCO_UV, 0, 0, "Uses UV coordinates for texture coordinates");
2655         uiDefButS(block, ROW, B_MATPRV, "Orco",                 670,160,55,18, &(mtex->texco), 4.0, (float)TEXCO_ORCO, 0, 0, "Uses the original undeformed coordinates of the object");
2656         if( give_parteff(ob) )
2657                 uiDefButS(block, ROW, B_MATPRV, "Strand",       725,160,50,18, &(mtex->texco), 4.0, (float)TEXCO_STRAND, 0, 0, "Uses normalized strand texture coordinate (1D)");
2658         else
2659                 uiDefButS(block, ROW, B_MATPRV, "Stick",        725,160,50,18, &(mtex->texco), 4.0, (float)TEXCO_STICKY, 0, 0, "Uses mesh's sticky coordinates for the texture coordinates");
2660         uiDefButS(block, ROW, B_MATPRV, "Win",                  775,160,45,18, &(mtex->texco), 4.0, (float)TEXCO_WINDOW, 0, 0, "Uses screen coordinates as texture coordinates");
2661         uiDefButS(block, ROW, B_MATPRV, "Nor",                  820,160,44,18, &(mtex->texco), 4.0, (float)TEXCO_NORM, 0, 0, "Uses normal vector as texture coordinates");
2662         uiDefButS(block, ROW, B_MATPRV, "Refl",                 864,160,44,18, &(mtex->texco), 4.0, (float)TEXCO_REFL, 0, 0, "Uses reflection vector as texture coordinates");
2663         
2664         uiDefButS(block, ROW, B_MATPRV, "Stress",               630,140,70,18, &(mtex->texco), 4.0, (float)TEXCO_STRESS, 0, 0, "Uses the difference of edge lengths compared to original coordinates of the mesh");
2665         uiDefButS(block, ROW, B_MATPRV, "Tangent",              700,140,70,18, &(mtex->texco), 4.0, (float)TEXCO_TANGENT, 0, 0, "Uses the optional tangent vector as texture coordinates");
2666
2667         /* COORDS */
2668         uiBlockBeginAlign(block);
2669         uiDefButC(block, ROW, B_MATPRV, "Flat",                 630,115,48,19, &(mtex->mapping), 5.0, (float)MTEX_FLAT, 0, 0, "Maps X and Y coordinates directly");
2670         uiDefButC(block, ROW, B_MATPRV, "Cube",                 681,115,50,19, &(mtex->mapping), 5.0, (float)MTEX_CUBE, 0, 0, "Maps using the normal vector");
2671         uiDefButC(block, ROW, B_MATPRV, "Tube",                 630,95,48,19, &(mtex->mapping), 5.0, (float)MTEX_TUBE, 0, 0, "Maps with Z as central axis (tube-like)");
2672         uiDefButC(block, ROW, B_MATPRV, "Sphe",                 681,95,50,19, &(mtex->mapping), 5.0, (float)MTEX_SPHERE, 0, 0, "Maps with Z as central axis (sphere-like)");
2673
2674         uiBlockBeginAlign(block);
2675         for(b=0; b<3; b++) {
2676                 char *cp;
2677                 if(b==0) cp= &(mtex->projx);
2678                 else if(b==1) cp= &(mtex->projy);
2679                 else cp= &(mtex->projz);
2680                 
2681                 uiDefButC(block, ROW, B_MATPRV, "",                     630, 50-20*b, 24, 18, cp, 6.0+b, 0.0, 0, 0, "");
2682                 uiDefButC(block, ROW, B_MATPRV, "X",            656, 50-20*b, 24, 18, cp, 6.0+b, 1.0, 0, 0, "");
2683                 uiDefButC(block, ROW, B_MATPRV, "Y",            682, 50-20*b, 24, 18, cp, 6.0+b, 2.0, 0, 0, "");
2684                 uiDefButC(block, ROW, B_MATPRV, "Z",            708, 50-20*b, 24, 18, cp, 6.0+b, 3.0, 0, 0, "");
2685         }
2686         
2687         uiBlockBeginAlign(block);
2688         uiDefButF(block, NUM, B_MATPRV, "ofsX",         778,115,130,19, mtex->ofs, -10.0, 10.0, 10, 0, "Fine tunes texture mapping X coordinate");
2689         uiDefButF(block, NUM, B_MATPRV, "ofsY",         778,95,130,19, mtex->ofs+1, -10.0, 10.0, 10, 0, "Fine tunes texture mapping Y coordinate");
2690         uiDefButF(block, NUM, B_MATPRV, "ofsZ",         778,75,130,19, mtex->ofs+2, -10.0, 10.0, 10, 0, "Fine tunes texture mapping Z coordinate");
2691         uiBlockBeginAlign(block);
2692         uiDefButF(block, NUM, B_MATPRV, "sizeX",        778,50,130,19, mtex->size, -100.0, 100.0, 10, 0, "Sets scaling for the texture's X size");
2693         uiDefButF(block, NUM, B_MATPRV, "sizeY",        778,30,130,19, mtex->size+1, -100.0, 100.0, 10, 0, "Sets scaling for the texture's Y size");
2694         uiDefButF(block, NUM, B_MATPRV, "sizeZ",        778,10,130,19, mtex->size+2, -100.0, 100.0, 10, 0, "Sets scaling for the texture's Z size");
2695         uiBlockEndAlign(block);
2696
2697 }
2698
2699
2700 static void material_panel_texture(Material *ma)
2701 {
2702         uiBlock *block;
2703         MTex *mtex;
2704         ID *id;
2705         int loos;
2706         int a;
2707         char str[64], *strp;
2708         
2709         block= uiNewBlock(&curarea->uiblocks, "material_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
2710         if(uiNewPanel(curarea, block, "Texture", "Material", 960, 0, 318, 204)==0) return;
2711
2712         /* TEX CHANNELS */
2713         uiBlockSetCol(block, TH_BUT_NEUTRAL);
2714         
2715         uiBlockBeginAlign(block);
2716         for(a= 0; a<MAX_MTEX; a++) {
2717                 mtex= ma->mtex[a];
2718                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
2719                 else strcpy(str, "");
2720                 str[10]= 0;
2721                 uiDefButC(block, ROW, B_MATPRV, str,    10, 180-18*a, 70, 20, &(ma->texact), 3.0, (float)a, 0, 0, "");
2722         }
2723         uiBlockEndAlign(block);
2724         
2725         /* SEPTEX */
2726         uiBlockSetCol(block, TH_AUTO);
2727         
2728         for(a= 0; a<MAX_MTEX; a++) {
2729                 mtex= ma->mtex[a];
2730                 if(mtex && mtex->tex) {
2731                         if(ma->septex & (1<<a)) 
2732                                 uiDefButBitS(block, TOG, 1<<a, B_MATPRV, " ",   -20, 180-18*a, 28, 20, &ma->septex, 0.0, 0.0, 0, 0, "Click to disable or enable this texture channel");
2733                         else uiDefIconButBitS(block, TOG, 1<<a, B_MATPRV, ICON_CHECKBOX_HLT,    -20, 180-18*a, 28, 20, &ma->septex, 0.0, 0.0, 0, 0, "Click to disable or enable this texture channel");
2734                 }
2735         }
2736         
2737         uiDefIconBut(block, BUT, B_MTEXCOPY, ICON_COPYUP,       100,180,23,21, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
2738         uiDefIconBut(block, BUT, B_MTEXPASTE, ICON_PASTEUP,     125,180,23,21, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
2739
2740         uiBlockSetCol(block, TH_AUTO);
2741         
2742         mtex= ma->mtex[ ma->texact ];
2743         if(mtex==0) {
2744                 mtex= &emptytex;
2745                 default_mtex(mtex);
2746         }
2747
2748         /* TEXTUREBLOK SELECT */
2749         uiBlockSetCol(block, TH_BUT_SETTING2);
2750         if(G.main->tex.first==0)
2751                 id= NULL;
2752         else
2753                 id= (ID*) mtex->tex;
2754         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x32767", &(G.main->tex), id, &(G.buts->texnr));
2755         uiDefButS(block, MENU, B_EXTEXBROWSE, strp, 100,130,20,20, &(G.buts->texnr), 0, 0, 0, 0, "Selects an existing texture or creates new");
2756         MEM_freeN(strp);
2757
2758         if(id) {
2759                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,150,163,20, id->name+2, 0.0, 18.0, 0, 0, "Displays name of the texture block: click to change");
2760                 sprintf(str, "%d", id->us);
2761                 uiDefBut(block, BUT, 0, str,                            196,130,21,20, 0, 0, 0, 0, 0, "Displays number of users of texture");
2762                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 241,130,21,20, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
2763                 if(id->lib) {
2764                         if(ma->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,130,21,20, 0, 0, 0, 0, 0, "");
2765                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,130,21,20, 0, 0, 0, 0, 0, "");              
2766                 }
2767                 uiBlockSetCol(block, TH_AUTO);
2768                 uiDefBut(block, BUT, B_TEXCLEAR, "Clear",                       122, 130, 72, 20, 0, 0, 0, 0, 0, "Erases link to texture");
2769                 
2770         }
2771         else 
2772                 uiDefButS(block, TOG, B_EXTEXBROWSE, "Add New" ,100, 150, 163, 20, &(G.buts->texnr), -1.0, 32767.0, 0, 0, "Adds a new texture datablock");
2773         
2774         // force no centering
2775         uiDefBut(block, LABEL, 0, " ", 250, 10, 25, 20, 0, 0, 0, 0, 0, "");
2776         
2777         uiBlockSetCol(block, TH_AUTO);
2778 }
2779
2780 static void material_panel_tramir(Material *ma)
2781 {
2782         uiBlock *block;
2783         
2784         block= uiNewBlock(&curarea->uiblocks, "material_panel_tramir", UI_EMBOSS, UI_HELV, curarea->win);
2785         uiNewPanelTabbed("Shaders", "Material");
2786         if(uiNewPanel(curarea, block, "Mirror Transp", "Material", 640, 0, 318, 204)==0) return;
2787
2788         uiDefButBitI(block, TOG, MA_RAYMIRROR, B_MATPRV,"Ray Mirror",210,180,100,20, &(ma->mode), 0, 0, 0, 0, "Enables raytracing for mirror reflection rendering");
2789
2790         uiBlockBeginAlign(block);
2791         uiDefButF(block, NUMSLI, B_MATPRV, "RayMir ",   10,160,200,20, &(ma->ray_mirror), 0.0, 1.0, 100, 2, "Sets the amount mirror reflection for raytrace");
2792         uiDefButS(block, NUM, B_MATPRV, "Depth:",               210,160,100,20, &(ma->ray_depth), 0.0, 10.0, 100, 0, "Amount of inter-reflections calculated maximal ");
2793
2794         uiDefButF(block, NUMSLI, B_MATPRV, "Fresnel ",  10,140,160,20, &(ma->fresnel_mir), 0.0, 5.0, 10, 2, "Power of Fresnel for mirror reflection");
2795         uiDefButF(block, NUMSLI, B_MATPRV, "Fac ",              170,140,140,20, &(ma->fresnel_mir_i), 1.0, 5.0, 10, 2, "Blending factor for Fresnel");
2796
2797         uiBlockBeginAlign(block);
2798         uiDefButF(block, NUM, B_MATPRV, "Filt:",                10,110,150,20, &(ma->filter), 0.0, 1.0, 10, 0, "Amount of filtering for transparent raytrace");
2799         uiDefButBitI(block, TOG, MA_RAYTRANSP, B_MATRAYTRANSP,"Ray Transp",160,110,150,20, &(ma->mode), 0, 0, 0, 0, "Enables raytracing for transparency rendering");
2800
2801         uiBlockBeginAlign(block);
2802         uiDefButF(block, NUMSLI, B_MATPRV, "IOR ",      10,90,200,20, &(ma->ang), 1.0, 3.0, 100, 2, "Sets the angular index of refraction for raytrace");
2803         uiDefButS(block, NUM, B_MATPRV, "Depth:",       210,90,100,20, &(ma->ray_depth_tra), 0.0, 10.0, 100, 0, "Amount of refractions calculated maximal ");
2804
2805         uiDefButF(block, NUMSLI, B_MATPRV, "Fresnel ",  10,70,160,20, &(ma->fresnel_tra), 0.0, 5.0, 10, 2, "Power of Fresnel for transparency");
2806         uiDefButF(block, NUMSLI, B_MATPRV, "Fac ",              170,70,140,20, &(ma->fresnel_tra_i), 1.0, 5.0, 10, 2, "Blending factor for Fresnel");
2807
2808         uiBlockBeginAlign(block);
2809         uiDefButF(block, NUMSLI, B_MATPRV, "SpecTra ",  10,40,150,20, &(ma->spectra), 0.0, 1.0, 0, 0, "Makes specular areas opaque on transparent materials");
2810         uiDefButF(block, NUMSLI, B_MATPRV, "Add ",              160,40,150,20, &(ma->add), 0.0, 1.0, 0, 0, "Sets a glow factor for transparant materials");
2811
2812         uiBlockBeginAlign(block);
2813         uiDefButBitI(block, TOG, MA_NOMIST, 0,  "No Mist",      10,10,150,20, &(ma->mode), 0, 0, 0, 0, "Sets the material to ignore mist values");
2814         uiDefButBitI(block, TOG, MA_ENV, 0,     "Env",                  160,10,150,20, &(ma->mode), 0, 0, 0, 0, "Causes faces to render with alpha zero: allows sky/backdrop to show through");
2815         uiBlockEndAlign(block);
2816
2817
2818 }
2819
2820
2821 /* yafray: adapted version of Blender's tramir panel.
2822  * Only removed the buttons not needed, so only the ones that are important for yafray are left.
2823  * Also re-arranged buttons for more room for extra parameters.
2824  * With the exception of the material preset menu and the new parameters,
2825  * most of blender's parameters are re-used without interfering with them.
2826  */
2827 static void material_panel_tramir_yafray(Material *ma)
2828 {
2829         uiBlock *block;
2830         char *mstr = "Material presets %t|No Reflect/Transmit %x0|Clear Glass %x1|Color Glass %x2|Uniform Reflect %x3|Fresnel Reflect %x4";
2831
2832         /* better to use same name as original panel */
2833         block= uiNewBlock(&curarea->uiblocks, "material_panel_tramir", UI_EMBOSS, UI_HELV, curarea->win);
2834         uiNewPanelTabbed("Shaders", "Material");
2835         if(uiNewPanel(curarea, block, "Mirror Transp", "Material", 640, 0, 318, 204)==0) return;
2836
2837         /* material preset menu */
2838         uiDefBut(block, LABEL, 0, "Mat.Preset", 20, 182, 100, 20, 0, 0.0, 0.0, 0, 0, "");
2839         uiDefButI(block, MENU, B_MAT_YF_PRESET, mstr, 110, 182, 200, 20, &ma->YF_preset, 0.0, 0.0, 0, 0, "Basic material presets to start with");
2840
2841         uiDefButBitI(block, TOG, MA_RAYMIRROR, B_MATPRV,"Ray Mirror", 10,160,100,20, &(ma->mode), 0, 0, 0, 0, "Enables raytracing for mirror reflection rendering");
2842         uiDefButBitI(block, TOG, MA_RAYTRANSP, B_MATRAYTRANSP,"Ray Transp", 110,160,100,20, &(ma->mode), 0, 0, 0, 0, "Enables raytracing for transparency rendering");
2843         uiDefButBitI(block, TOG, MA_ZTRA, B_MATZTRANSP,"ZTransp", 210,160,100,20, &(ma->mode), 0, 0, 0, 0, "Use for objects with alphamap textures");
2844
2845         uiDefButF(block, NUMSLI, B_MATPRV, "rayMir ", 10,140,150,20, &(ma->ray_mirror), 0.0, 1.0, 100, 2, "Sets the amount mirror reflection for raytrace");
2846         uiDefButF(block, NUMSLI, B_MATPRV, "frsOfs ", 160,140,150,20, &(ma->fresnel_mir_i), 1.0, 5.0, 10, 2, "Fresnel offset, 1 is uniform mirror, 5 is fresnel mirror (IOR>1)");
2847
2848         /* ior has extended range up to 30, for use with total fresnel reflection */
2849         uiDefButF(block, NUMSLI, B_MATPRV, "IOR ", 10,115,150,20, &(ma->ang), 1.0, 30.0, 100, 2, "Sets the angular index of refraction for raytrace");
2850
2851         // parameters only used in ray_transp mode
2852         if(ma->mode & MA_RAYTRANSP) {
2853                 // Filter
2854                 uiDefButF(block, NUM, B_MATPRV, "Filt:", 160,115,150,20, &(ma->filter), 0.0, 1.0, 10, 0, "Amount of filtering for transparent raytrace");
2855
2856                 /* absorption color */
2857                 uiDefBut(block, LABEL, 0, "Absorption Color", 10, 98, 150, 18, 0, 0.0, 0.0, 0, 0, "");
2858                 uiDefButF(block, COL, B_MATPRV, "", 10, 38, 30, 58, &ma->YF_ar, 0, 0, 0, B_MATCOL, "transmit absorption color, white is no absorption");
2859                 uiDefButF(block, NUMSLI, B_MATPRV, "aR ", 40, 78, 120, 18, &ma->YF_ar, 1e-7f, 1.0, B_MATCOL, 0, "");
2860                 uiDefButF(block, NUMSLI, B_MATPRV, "aG ", 40, 58, 120, 18, &ma->YF_ag, 1e-7f, 1.0, B_MATCOL, 0, "");
2861                 uiDefButF(block, NUMSLI, B_MATPRV, "aB ", 40, 38, 120, 18, &ma->YF_ab, 1e-7f, 1.0, B_MATCOL, 0, "");
2862                 uiDefButF(block, NUM, B_MATPRV, "Ds", 10, 18, 150, 18, &ma->YF_dscale, 1e-7f, 100.0, 10.0, 0, "absorption distance scale, 1 is one blender (world) unit of distance");
2863
2864                 /* disperions parameters */
2865                 uiDefBut(block, LABEL, 0, "Dispersion", 160, 98, 150, 18, 0, 0.0, 0.0, 0, 0, "");
2866                 uiDefButF(block, NUM, B_MATPRV, "Pwr ", 160, 78, 150, 18, &ma->YF_dpwr, 0.0, 1.0, 0.25, 0, "Dispersion power, the higher, the more dispersion, 0 is no dispersion");
2867                 uiDefButI(block, NUM, B_MATPRV, "Samples ", 160, 58, 150, 18, &ma->YF_dsmp, 1.0, 100.0, 0, 0, "Dispersion samples, minimum at least 10, unless using jitter ");
2868                 uiDefButBitI(block, TOG, 1, B_MATPRV, "Jitter", 160, 38, 150, 18, &ma->YF_djit, 0.0, 1.0, 0, 0, "Enable jittering of wavelenghts, adds noise");
2869         }
2870
2871 }
2872
2873
2874 static void material_panel_shading(Material *ma)
2875 {
2876         uiBlock *block;
2877         
2878         block= uiNewBlock(&curarea->uiblocks, "material_panel_shading", UI_EMBOSS, UI_HELV, curarea->win);
2879         if(uiNewPanel(curarea, block, "Shaders", "Material", 640, 0, 318, 204)==0) return;
2880
2881         if(ma->mode & MA_HALO) {
2882                 uiDefButF(block, NUM, B_MATPRV, "HaloSize: ",           10,155,190,18, &(ma->hasize), 0.0, 100.0, 10, 3, "Sets the dimension of the halo");
2883                 uiDefButS(block, NUMSLI, B_MATPRV, "Hard ",                     10,135,190,18, &(ma->har), 1.0, 127.0, 0, 0, "Sets the hardness of the halo");
2884                 uiDefButF(block, NUMSLI, B_MATPRV, "Add  ",                     10,115,190,18, &(ma->add), 0.0, 1.0, 0, 0, "Sets the strength of the add effect");
2885                 
2886                 uiDefButS(block, NUM, B_MATPRV, "Rings: ",                      10,90,90,18, &(ma->ringc), 0.0, 24.0, 0, 0, "Sets the number of rings rendered over the halo");
2887                 uiDefButS(block, NUM, B_MATPRV, "Lines: ",                      100,90,100,18, &(ma->linec), 0.0, 250.0, 0, 0, "Sets the number of star shaped lines rendered over the halo");
2888                 uiDefButS(block, NUM, B_MATPRV, "Star: ",                       10,70,90,18, &(ma->starc), 3.0, 50.0, 0, 0, "Sets the number of points on the star shaped halo");
2889                 uiDefButC(block, NUM, B_MATPRV, "Seed: ",                       100,70,100,18, &(ma->seed1), 0.0, 255.0, 0, 0, "Randomizes ring dimension and line location");
2890                 if(ma->mode & MA_HALO_FLARE) {
2891                         uiDefButF(block, NUM, B_MATPRV, "FlareSize: ",          10,50,95,18, &(ma->flaresize), 0.1, 25.0, 10, 3, "Sets the factor by which the flare is larger than the halo");
2892                         uiDefButF(block, NUM, B_MATPRV, "Sub Size: ",           100,50,100,18, &(ma->subsize), 0.1, 25.0, 10, 3, "Sets the dimension of the subflares, dots and circles");
2893                         uiDefButF(block, NUMSLI, B_MATPRV, "Boost: ",           10,30,190,18, &(ma->flareboost), 0.1, 10.0, 10, 3, "Gives the flare extra strength");
2894                         uiDefButC(block, NUM, B_MATPRV, "Fl.seed: ",            10,10,90,18, &(ma->seed2), 0.0, 255.0, 0, 0, "Specifies an offset in the flare seed table");
2895                         uiDefButS(block, NUM, B_MATPRV, "Flares: ",                     100,10,100,18, &(ma->flarec), 1.0, 32.0, 0, 0, "Sets the number of subflares");
2896                &nbs