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