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