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