Another mega commit... loadsof restructure, and a pretty good one! :)
[blender-staging.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_preview_changed(G.buts);
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_preview_changed(G.buts);
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_preview_changed(G.buts);
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_preview_changed(G.buts);
309                 break;
310         case B_DEFTEXVAR:
311                 if(tex==0) return;
312                 default_tex(tex);
313                 allqueue(REDRAWBUTSSHADING, 0);
314                 BIF_preview_changed(G.buts);
315                 break;
316         case B_LOADTEXIMA:
317         case B_LOADTEXIMA1:
318                 if(tex==0) return;
319                 /* globals: temporal store them: we make another area a fileselect */
320                 cur_imatex= tex;
321                 prv_win= curarea->win;
322                 
323                 sa= closest_bigger_area();
324                 areawinset(sa->win);
325                 if(tex->ima) name= tex->ima->name;
326 #ifdef _WIN32
327                 else {
328                         if (strcmp (U.textudir, "/") == 0)
329                                 name= G.sce;
330                         else
331                                 name= U.textudir;
332                 }
333 #else
334                 else name = U.textudir;
335 #endif
336                 
337                 if(event==B_LOADTEXIMA)
338                         activate_imageselect(FILE_SPECIAL, "SELECT IMAGE", name, load_tex_image);
339                 else 
340                         activate_fileselect(FILE_SPECIAL, "SELECT IMAGE", name, load_tex_image);
341                 
342                 break;
343         case B_NAMEIMA:
344                 if(tex==0) return;
345                 if(tex->ima) {
346                         cur_imatex= tex;
347                         prv_win= curarea->win;
348                         
349                         /* name in tex->ima has been changed by button! */
350                         strcpy(str, tex->ima->name);
351                         if(tex->ima->ibuf) strcpy(tex->ima->name, tex->ima->ibuf->name);
352
353                         load_tex_image(str);
354                 }
355                 break;
356         case B_TEXREDR_PRV:
357                 allqueue(REDRAWBUTSSHADING, 0);
358                 BIF_preview_changed(G.buts);
359                 break;
360         case B_TEXIMABROWSE:
361                 if(tex) {
362                         id= (ID*) tex->ima;
363                         
364                         if(G.buts->menunr== -2) {
365                                 activate_databrowse(id, ID_IM, 0, B_TEXIMABROWSE, &G.buts->menunr, do_texbuts);
366                         } else if (G.buts->menunr>0) {
367                                 Image *newima= (Image*) BLI_findlink(&G.main->image, G.buts->menunr-1);
368                                 
369                                 if (newima && newima!=(Image*) id) {
370                                         tex->ima= newima;
371                                         id_us_plus((ID*) newima);
372                                         if(id) id->us--;
373                                 
374                                         allqueue(REDRAWBUTSSHADING, 0);
375                                         BIF_preview_changed(G.buts);
376                                 }
377                         }
378                 }
379                 break;
380         case B_IMAPTEST:
381                 if(tex) {
382                         if( (tex->imaflag & (TEX_FIELDS+TEX_MIPMAP))== TEX_FIELDS+TEX_MIPMAP ) {
383                                 error("Cannot combine fields and mipmap");
384                                 tex->imaflag -= TEX_MIPMAP;
385                                 allqueue(REDRAWBUTSSHADING, 0);
386                         }
387                         
388                         if(tex->ima && tex->ima->ibuf) {
389                                 ibuf= tex->ima->ibuf;
390                                 nr= 0;
391                                 if( !(tex->imaflag & TEX_FIELDS) && (ibuf->flags & IB_fields) ) nr= 1;
392                                 if( (tex->imaflag & TEX_FIELDS) && !(ibuf->flags & IB_fields) ) nr= 1;
393                                 if(nr) {
394                                         IMB_freeImBuf(ibuf);
395                                         tex->ima->ibuf= 0;
396                                         tex->ima->ok= 1;
397                                         BIF_preview_changed(G.buts);
398                                 }
399                         }
400                 }
401                 break;
402         case B_RELOADIMA:
403                 if(tex && tex->ima) {
404                         // check if there is a newer packedfile
405
406                         if (tex->ima->packedfile) {
407                                 PackedFile *pf;
408                                 pf = newPackedFile(tex->ima->name);
409                                 if (pf) {
410                                         freePackedFile(tex->ima->packedfile);
411                                         tex->ima->packedfile = pf;
412                                 } else {
413                                         error("Image not available. Keeping packed image.");
414                                 }
415                         }
416
417                         IMB_freeImBuf(tex->ima->ibuf);
418                         tex->ima->ibuf= 0;
419                         tex->ima->ok= 1;
420                         allqueue(REDRAWVIEW3D, 0);
421                         allqueue(REDRAWIMAGE, 0);
422                         BIF_preview_changed(G.buts);
423                 }
424                 allqueue(REDRAWBUTSSHADING, 0); // redraw buttons
425                 
426                 break;
427
428         case B_TEXSETFRAMES:
429                 if(tex->ima->anim) tex->frames = IMB_anim_get_duration(tex->ima->anim);
430                 allqueue(REDRAWBUTSSHADING, 0);
431                 break;
432
433         case B_PACKIMA:
434                 if(tex && tex->ima) {
435                         if (tex->ima->packedfile) {
436                                 if (G.fileflags & G_AUTOPACK) {
437                                         if (okee("Disable AutoPack ?")) {
438                                                 G.fileflags &= ~G_AUTOPACK;
439                                         }
440                                 }
441                                 
442                                 if ((G.fileflags & G_AUTOPACK) == 0) {
443                                         unpackImage(tex->ima, PF_ASK);
444                                 }
445                         } else {
446                                 if (tex->ima->ibuf && (tex->ima->ibuf->userflags & IB_BITMAPDIRTY)) {
447                                         error("Can't pack painted image. Save image from Image window first.");
448                                 } else {
449                                         tex->ima->packedfile = newPackedFile(tex->ima->name);
450                                 }
451                         }
452                         allqueue(REDRAWBUTSSHADING, 0);
453                         allqueue(REDRAWHEADERS, 0);
454                 }
455                 break;
456         case B_LOADPLUGIN:
457                 if(tex==0) return;
458
459                 /* globals: store temporal: we make another area a fileselect */
460                 cur_imatex= tex;
461                 prv_win= curarea->win;
462                         
463                 sa= closest_bigger_area();
464                 areawinset(sa->win);
465                 if(tex->plugin) strcpy(str, tex->plugin->name);
466                 else {
467                         strcpy(str, U.plugtexdir);
468                 }
469                 activate_fileselect(FILE_SPECIAL, "SELECT PLUGIN", str, load_plugin_tex);
470                 
471                 break;
472
473         case B_NAMEPLUGIN:
474                 if(tex==0 || tex->plugin==0) return;
475                 strcpy(str, tex->plugin->name);
476                 free_plugin_tex(tex->plugin);
477                 tex->stype= 0;
478                 tex->plugin= add_plugin_tex(str);
479                 allqueue(REDRAWBUTSSHADING, 0);
480                 BIF_preview_changed(G.buts);
481                 break;
482         
483         case B_COLORBAND:
484                 if(tex==0) return;
485                 if(tex->coba==0) tex->coba= add_colorband();
486                 allqueue(REDRAWBUTSSHADING, 0);
487                 BIF_preview_changed(G.buts);
488                 break;
489         
490         case B_ADDCOLORBAND:
491                 if(tex==0 || tex->coba==0) return;
492                 
493                 if(tex->coba->tot < MAXCOLORBAND-1) tex->coba->tot++;
494                 tex->coba->cur= tex->coba->tot-1;
495                 
496                 do_texbuts(B_CALCCBAND);
497                 
498                 break;
499
500         case B_DELCOLORBAND:
501                 if(tex==0 || tex->coba==0 || tex->coba->tot<2) return;
502                 
503                 for(a=tex->coba->cur; a<tex->coba->tot; a++) {
504                         tex->coba->data[a]= tex->coba->data[a+1];
505                 }
506                 if(tex->coba->cur) tex->coba->cur--;
507                 tex->coba->tot--;
508
509                 allqueue(REDRAWBUTSSHADING, 0);
510                 BIF_preview_changed(G.buts);
511                 break;
512
513         case B_CALCCBAND:
514         case B_CALCCBAND2:
515                 if(tex==0 || tex->coba==0 || tex->coba->tot<2) return;
516                 
517                 for(a=0; a<tex->coba->tot; a++) tex->coba->data[a].cur= a;
518                 qsort(tex->coba->data, tex->coba->tot, sizeof(CBData), vergcband);
519                 for(a=0; a<tex->coba->tot; a++) {
520                         if(tex->coba->data[a].cur==tex->coba->cur) {
521                                 if(tex->coba->cur!=a) addqueue(curarea->win, REDRAW, 0);        /* button cur */
522                                 tex->coba->cur= a;
523                                 break;
524                         }
525                 }
526                 if(event==B_CALCCBAND2) return;
527                 
528                 allqueue(REDRAWBUTSSHADING, 0);
529                 BIF_preview_changed(G.buts);
530                 
531                 break;
532                 
533         case B_DOCOLORBAND:
534                 if(tex==0 || tex->coba==0) return;
535                 
536                 block= uiFindOpenPanelBlockName(&curarea->uiblocks, "Colors");
537                 if(block) {
538                         cbd= tex->coba->data + tex->coba->cur;
539                         uiGetMouse(mywinget(), mvalo);
540         
541                         while(get_mbut() & L_MOUSE) {
542                                 uiGetMouse(mywinget(), mval);
543                                 if(mval[0]!=mvalo[0]) {
544                                         dx= mval[0]-mvalo[0];
545                                         dx/= 345.0;
546                                         cbd->pos+= dx;
547                                         CLAMP(cbd->pos, 0.0, 1.0);
548         
549                                         glDrawBuffer(GL_FRONT);
550                                         uiPanelPush(block);
551                                         drawcolorband(tex->coba, 10,150,300,20);
552                                         uiPanelPop(block);
553                                         glDrawBuffer(GL_BACK);
554                                         
555                                         do_texbuts(B_CALCCBAND2);
556                                         cbd= tex->coba->data + tex->coba->cur;  /* because qsort */
557                                         
558                                         mvalo[0]= mval[0];
559                                 }
560                                 BIF_wait_for_statechange();
561                         }
562                         allqueue(REDRAWBUTSSHADING, 0);
563                         BIF_preview_changed(G.buts);
564                 }
565                 break;
566                 
567         case B_ENV_DELETE:
568                 if(tex->env) {
569                         RE_free_envmap(tex->env);
570                         tex->env= 0;
571                         allqueue(REDRAWBUTSSHADING, 0);
572                         BIF_preview_changed(G.buts);
573                 }
574                 break;
575         case B_ENV_FREE:
576                 if(tex->env) {
577                         RE_free_envmapdata(tex->env);
578                         allqueue(REDRAWBUTSSHADING, 0);
579                         BIF_preview_changed(G.buts);
580                 }
581                 break;
582         case B_ENV_FREE_ALL:
583                 tex= G.main->tex.first;
584                 while(tex) {
585                         if(tex->id.us && tex->type==TEX_ENVMAP) {
586                                 if(tex->env) {
587                                         if(tex->env->stype!=ENV_LOAD) RE_free_envmapdata(tex->env);
588                                 }
589                         }
590                         tex= tex->id.next;
591                 }
592                 allqueue(REDRAWBUTSSHADING, 0);
593                 BIF_preview_changed(G.buts);
594                 break;
595         case B_ENV_SAVE:
596                 if(tex->env && tex->env->ok) {
597                         sa= closest_bigger_area();
598                         areawinset(sa->win);
599                         save_image_filesel_str(str);
600                         activate_fileselect(FILE_SPECIAL, str, G.ima, save_env);
601                 }
602                 break;  
603         case B_ENV_OB:
604                 if(tex->env && tex->env->object) {
605                         BIF_preview_changed(G.buts);
606                         if ELEM(tex->env->object->type, OB_CAMERA, OB_LAMP) {
607                                 error("Camera or Lamp not allowed");
608                                 tex->env->object= 0;
609                         }
610                 }
611                 break;
612                 
613         default:
614                 if(event>=B_PLUGBUT && event<=B_PLUGBUT+23) {
615                         PluginTex *pit= tex->plugin;
616                         if(pit && pit->callback) {
617                                 pit->callback(event - B_PLUGBUT);
618                                 BIF_preview_changed(G.buts);
619                         }
620                 }
621         }
622 }
623
624 static void texture_panel_plugin(Tex *tex)
625 {
626         uiBlock *block;
627         VarStruct *varstr;
628         PluginTex *pit;
629         short xco, yco, a;
630         
631         block= uiNewBlock(&curarea->uiblocks, "texture_panel_plugin", UI_EMBOSS, UI_HELV, curarea->win);
632         if(uiNewPanel(curarea, block, "Plugin", "Texture", 640, 0, 318, 204)==0) return;
633         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
634
635         if(tex->plugin && tex->plugin->doit) {
636                 
637                 pit= tex->plugin;
638
639                 for(a=0; a<pit->stypes; a++) {
640                         uiDefButS(block, ROW, B_MATPRV, pit->stnames+16*a, (350+75*a), 170, 75, 18, &tex->stype, 2.0, (float)a, 0, 0, "");
641                 }
642                 
643                 varstr= pit->varstr;
644                 if(varstr) {
645                         for(a=0; a<pit->vars; a++, varstr++) {
646                                 xco= 350 + 140*(a/6);
647                                 yco= 110 - 20*(a % 6);
648                                 pit->data[a] = varstr->def;
649                                 uiDefBut(block, varstr->type, B_PLUGBUT+a, varstr->name, xco,yco,137,19, &(pit->data[a]), varstr->min, varstr->max, 100, 0, varstr->tip);
650                         }
651                 }
652                 uiDefBut(block, TEX, B_NAMEPLUGIN, "",          350,130,290,24, pit->name, 0.0, 159.0, 0, 0, "");
653         }
654
655         uiDefBut(block, BUT, B_LOADPLUGIN, "Load Plugin", 350,150,137,24, 0, 0, 0, 0, 0, "");
656                         
657 }
658
659
660 static void texture_panel_magic(Tex *tex)
661 {
662         uiBlock *block;
663         
664         block= uiNewBlock(&curarea->uiblocks, "texture_panel_magic", UI_EMBOSS, UI_HELV, curarea->win);
665         if(uiNewPanel(curarea, block, "Magic", "Texture", 640, 0, 318, 204)==0) return;
666         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
667
668         uiDefButF(block, NUM, B_MATPRV, "Size :",               10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Set the dimension of the pattern");
669         uiDefButS(block, NUM, B_MATPRV, "Depth:",               10, 90, 150, 19, &tex->noisedepth, 0.0, 10.0, 0, 0, "Set the depth of the pattern");
670         uiDefButF(block, NUM, B_MATPRV, "Turbulence:",  10, 70, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Set the strength of the pattern");
671 }
672
673 static void texture_panel_blend(Tex *tex)
674 {
675         uiBlock *block;
676         
677         block= uiNewBlock(&curarea->uiblocks, "texture_panel_blend", UI_EMBOSS, UI_HELV, curarea->win);
678         if(uiNewPanel(curarea, block, "Blend", "Texture", 640, 0, 318, 204)==0) return;
679         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
680
681         uiDefButS(block, ROW, B_MATPRV, "Lin",          10, 180, 75, 19, &tex->stype, 2.0, 0.0, 0, 0, "Use a linear progresion"); 
682         uiDefButS(block, ROW, B_MATPRV, "Quad",         85, 180, 75, 19, &tex->stype, 2.0, 1.0, 0, 0, "Use a quadratic progression"); 
683         uiDefButS(block, ROW, B_MATPRV, "Ease",         160, 180, 75, 19, &tex->stype, 2.0, 2.0, 0, 0, ""); 
684         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Flip XY",        235, 180, 75, 19, &tex->flag, 0, 0, 0, 0, "Flip the direction of the progression a quarter turn");
685
686         uiDefButS(block, ROW, B_MATPRV, "Diag",         10, 160, 75, 19, &tex->stype, 2.0, 3.0, 0, 0, "Use a diagonal progression");
687         uiDefButS(block, ROW, B_MATPRV, "Sphere",       85, 160, 75, 19, &tex->stype, 2.0, 4.0, 0, 0, "Use progression with the shape of a sphere");
688         uiDefButS(block, ROW, B_MATPRV, "Halo",         160, 160, 75, 19, &tex->stype, 2.0, 5.0, 0, 0, "Use a quadratic progression with the shape of a sphere");
689         
690 }
691
692
693
694 static void texture_panel_wood(Tex *tex)
695 {
696         uiBlock *block;
697         
698         block= uiNewBlock(&curarea->uiblocks, "texture_panel_wood", UI_EMBOSS, UI_HELV, curarea->win);
699         if(uiNewPanel(curarea, block, "Wood", "Texture", 640, 0, 318, 204)==0) return;
700         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
701
702         uiDefButS(block, ROW, B_MATPRV, "Bands",                10, 180, 75, 18, &tex->stype, 2.0, 0.0, 0, 0, "Use standard wood texture"); 
703         uiDefButS(block, ROW, B_MATPRV, "Rings",                85, 180, 75, 18, &tex->stype, 2.0, 1.0, 0, 0, "Use wood rings"); 
704         uiDefButS(block, ROW, B_MATPRV, "BandNoise",    160, 180, 75, 18, &tex->stype, 2.0, 2.0, 0, 0, "Add noise to standard wood"); 
705         uiDefButS(block, ROW, B_MATPRV, "RingNoise",    235, 180, 75, 18, &tex->stype, 2.0, 3.0, 0, 0, "Add noise to rings"); 
706
707         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   10, 160, 75, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
708         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   85, 160, 75, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
709
710         uiDefButF(block, NUM, B_MATPRV, "NoiseSize :",  10, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Set the dimension of the noise table");
711         uiDefButF(block, NUM, B_MATPRV, "Turbulence:",  160, 130, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Set the turbulence of the bandnoise and ringnoise types");
712
713
714 }
715
716 static void texture_panel_stucci(Tex *tex)
717 {
718         uiBlock *block;
719         
720         block= uiNewBlock(&curarea->uiblocks, "texture_panel_stucci", UI_EMBOSS, UI_HELV, curarea->win);
721         if(uiNewPanel(curarea, block, "Stucci", "Texture", 640, 0, 318, 204)==0) return;
722         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
723
724         uiDefButS(block, ROW, B_MATPRV, "Plastic",              10, 180, 100, 19, &tex->stype, 2.0, 0.0, 0, 0, "Use standard stucci");
725         uiDefButS(block, ROW, B_MATPRV, "Wall In",              110, 180, 100, 19, &tex->stype, 2.0, 1.0, 0, 0, "Set start value"); 
726         uiDefButS(block, ROW, B_MATPRV, "Wall Out",             210, 180, 100, 19, &tex->stype, 2.0, 2.0, 0, 0, "Set end value"); 
727         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   10, 160, 100, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
728         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   110, 160, 100, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
729
730         uiDefButF(block, NUM, B_MATPRV, "NoiseSize :",  10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Set the dimension of the noise table");
731         uiDefButF(block, NUM, B_MATPRV, "Turbulence:",  10, 90, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Set the depth of the stucci");
732 }
733
734 static void texture_panel_marble(Tex *tex)
735 {
736         uiBlock *block;
737         
738         block= uiNewBlock(&curarea->uiblocks, "texture_panel_marble", UI_EMBOSS, UI_HELV, curarea->win);
739         if(uiNewPanel(curarea, block, "Marble", "Texture", 640, 0, 318, 204)==0) return;
740         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
741
742         uiDefButS(block, ROW, B_MATPRV, "Soft",                 10, 180, 75, 18, &tex->stype, 2.0, 0.0, 0, 0, "Use soft marble"); 
743         uiDefButS(block, ROW, B_MATPRV, "Sharp",                85, 180, 75, 18, &tex->stype, 2.0, 1.0, 0, 0, "Use more clearly defined marble"); 
744         uiDefButS(block, ROW, B_MATPRV, "Sharper",              160, 180, 75, 18, &tex->stype, 2.0, 2.0, 0, 0, "Use very clear defined marble"); 
745
746         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   10, 160, 100, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
747         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   110, 160, 100, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
748
749         uiDefButF(block, NUM, B_MATPRV, "NoiseSize :",  10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Set the dimension of the noise table");
750         uiDefButS(block, NUM, B_MATPRV, "NoiseDepth:",  10, 90, 150, 19, &tex->noisedepth, 0.0, 6.0, 0, 0, "Set the depth of the marble calculation");
751         uiDefButF(block, NUM, B_MATPRV, "Turbulence:",  10, 70, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Set the turbulence of the sine bands");
752
753
754 }
755
756 static void texture_panel_clouds(Tex *tex)
757 {
758         uiBlock *block;
759         
760         block= uiNewBlock(&curarea->uiblocks, "texture_panel_clouds", UI_EMBOSS, UI_HELV, curarea->win);
761         if(uiNewPanel(curarea, block, "Clouds", "Texture", 640, 0, 318, 204)==0) return;
762         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
763
764         uiDefButS(block, ROW, B_MATPRV, "Default",              10, 180, 70, 18, &tex->stype, 2.0, 0.0, 0, 0, "Use standard noise"); 
765         uiDefButS(block, ROW, B_MATPRV, "Color",                80, 180, 70, 18, &tex->stype, 2.0, 1.0, 0, 0, "Let Noise give RGB value"); 
766         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   155, 180, 75, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
767         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   230, 180, 80, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
768
769         uiDefButF(block, NUM, B_MATPRV, "NoiseSize :",  10, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Set the dimension of the noise table");
770         uiDefButS(block, NUM, B_MATPRV, "NoiseDepth:",  160, 130, 150, 19, &tex->noisedepth, 0.0, 6.0, 0, 0, "Set the depth of the cloud calculation");
771
772 }
773
774
775 static void texture_panel_envmap(Tex *tex)
776 {
777         uiBlock *block;
778         EnvMap *env;
779         ID *id;
780         short a, xco, yco, dx, dy;
781         char *strp, str[32];
782         
783         block= uiNewBlock(&curarea->uiblocks, "texture_panel_envmap", UI_EMBOSS, UI_HELV, curarea->win);
784         if(uiNewPanel(curarea, block, "Envmap", "Texture", 640, 0, 318, 204)==0) return;
785         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
786
787         if(tex->env==0) {
788                 tex->env= RE_add_envmap();
789                 tex->env->object= OBACT;
790         }
791         if(tex->env) {
792                 env= tex->env;
793                 
794                 uiDefButS(block, ROW, B_REDR,   "Static",       10, 180, 100, 19, &env->stype, 2.0, 0.0, 0, 0, "Calculate map only once");
795                 uiDefButS(block, ROW, B_REDR,   "Anim",         110, 180, 100, 19, &env->stype, 2.0, 1.0, 0, 0, "Calculate map each rendering");
796                 uiDefButS(block, ROW, B_ENV_FREE, "Load",       210, 180, 100, 19, &env->stype, 2.0, 2.0, 0, 0, "Load map from disk");
797                 
798                 if(env->stype==ENV_LOAD) {
799                         /* file input */
800                         id= (ID *)tex->ima;
801                         IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(G.buts->menunr));
802                         if(strp[0])
803                                 uiDefButS(block, MENU, B_TEXIMABROWSE, strp, 10,135,23,20, &(G.buts->menunr), 0, 0, 0, 0, "Browse");
804                         MEM_freeN(strp);
805                 
806                         uiDefBut(block, BUT, B_LOADTEXIMA1, "Load Image", 10,115,130,20, 0, 0, 0, 0, 0, "Load image - file view");
807                         uiBlockSetCol(block, TH_BUT_SETTING2);
808                         uiDefBut(block, BUT, B_LOADTEXIMA, "",          140,115,20,20, 0, 0, 0, 0, 0, "Load image - thumb view");
809                         uiBlockSetCol(block, TH_AUTO);
810                 
811                         if(tex->ima) {
812                                 uiDefBut(block, TEX, B_NAMEIMA, "",                     35,135,255,20, tex->ima->name, 0.0, 79.0, 0, 0, "Texture name");
813                                 sprintf(str, "%d", tex->ima->id.us);
814                                 uiDefBut(block, BUT, 0, str,                            290,135,20,20, 0, 0, 0, 0, 0, "Number of users");
815                                 uiDefBut(block, BUT, B_RELOADIMA, "Reload",     230,115,80,20, 0, 0, 0, 0, 0, "Reload");
816                         
817                                 if (tex->ima->packedfile) packdummy = 1;
818                                 else packdummy = 0;
819                                 
820                                 uiDefIconButI(block, TOG|BIT|0, B_PACKIMA, ICON_PACKAGE, 205,115,24,20, &packdummy, 0, 0, 0, 0, "Pack/Unpack this Image");
821                         }
822                 }
823                 else {
824                         uiDefBut(block, BUT, B_ENV_FREE, "Free Data",   10,135,100,20, 0, 0, 0, 0, 0, "Release all images associated with environment map");
825                         uiDefBut(block, BUT, B_ENV_SAVE, "Save EnvMap", 110,135,100,20, 0, 0, 0, 0, 0, "Save environment map");
826                         uiDefBut(block, BUT, B_ENV_FREE_ALL, "Free all EnvMaps", 210,135,100,20, 0, 0, 0, 0, 0, "Frees all rendered environment maps");
827                 }
828
829                 uiDefIDPoinBut(block, test_obpoin_but, B_ENV_OB, "Ob:", 10,90,150,20, &(env->object), "Object name");
830                 if(env->stype!=ENV_LOAD) 
831                         uiDefButS(block, NUM, B_ENV_FREE,       "CubeRes",              160,90,150,20, &env->cuberes, 50, 2048.0, 0, 0, "Set the resolution in pixels");
832
833                 uiDefButF(block, NUM, B_MATPRV, "Filter :",                             10,65,150,20, &tex->filtersize, 0.1, 25.0, 0, 0, "Adjust sharpness or blurriness of the reflection"),
834                 uiDefButS(block, NUM, B_ENV_FREE, "Depth:",                             160,65,150,20, &env->depth, 0, 5.0, 0, 0, "Number of times a map gets rendered again, for recursive mirror effect"),
835
836                 uiDefButF(block, NUM, REDRAWVIEW3D,     "ClipSta",              10,40,150,20, &env->clipsta, 0.01, 50.0, 100, 0, "Set start value for clipping");
837                 uiDefButF(block, NUM, 0,        "ClipEnd",                                      160,40,150,20, &env->clipend, 0.1, 5000.0, 1000, 0, "Set end value for clipping");
838
839                 uiDefBut(block, LABEL, 0, "Don't render layer:",                10,10,140,22, 0, 0.0, 0.0, 0, 0, "");   
840                 xco= 160;
841                 yco= 10;
842                 dx= 28;
843                 dy= 26;
844                 for(a=0; a<10; a++) {
845                         uiDefButI(block, TOG|BIT|(a+10), 0, "",(xco+a*(dx/2)), yco, (dx/2), (dy/2), &env->notlay, 0, 0, 0, 0, "Render this layer");
846                         uiDefButI(block, TOG|BIT|a, 0, "",      (xco+a*(dx/2)), (yco+dy/2), (dx/2), (1+dy/2), &env->notlay, 0, 0, 0, 0, "Render this layer");
847                         if(a==4) xco+= 5;
848                 }
849
850         }
851 }
852
853
854 static void texture_panel_image1(Tex *tex)
855 {
856         uiBlock *block;
857         char str[32];
858         
859         block= uiNewBlock(&curarea->uiblocks, "texture_panel1", UI_EMBOSS, UI_HELV, curarea->win);
860         if(uiNewPanel(curarea, block, "Crop and Anim", "Texture", 960, 0, 318, 204)==0) return;
861         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
862
863         if(tex->imaflag & TEX_ANIM5) {
864
865                 /* print amount of frames anim */
866                 if(tex->ima && tex->ima->anim) {
867                         uiDefBut(block, BUT, B_TEXSETFRAMES, "<",      802, 110, 20, 18, 0, 0, 0, 0, 0, "Paste number of frames in Frames: button");
868                         sprintf(str, "%d frs  ", IMB_anim_get_duration(tex->ima->anim));
869                         uiDefBut(block, LABEL, 0, str,      834, 110, 90, 18, 0, 0, 0, 0, 0, "");
870                         sprintf(str, "%d cur  ", tex->ima->lastframe);
871                         uiDefBut(block, LABEL, 0, str,      834, 90, 90, 18, 0, 0, 0, 0, 0, "");
872                 }
873                 else uiDefBut(block, LABEL, 0, "<",      802, 110, 20, 18, 0, 0, 0, 0, 0, "");
874                                 
875                 uiDefButS(block, NUM, B_MATPRV, "Frames :",     642,110,150,19, &tex->frames, 0.0, 18000.0, 0, 0, "Activate animation option");
876                 uiDefButS(block, NUM, B_MATPRV, "Offset :",     642,90,150,19, &tex->offset, -9000.0, 9000.0, 0, 0, "Set the number of the first picture of the animation");
877                 uiDefButS(block, NUM, B_MATPRV, "Fie/Ima:",     642,60,98,19, &tex->fie_ima, 1.0, 200.0, 0, 0, "Set the number of fields per rendered frame");
878                 uiDefButS(block, NUM, B_MATPRV, "StartFr:",     642,30,150,19, &tex->sfra, 1.0, 9000.0, 0, 0, "Set the start frame of the animation");
879                 uiDefButS(block, NUM, B_MATPRV, "Len:",         642,10,150,19, &tex->len, 0.0, 9000.0, 0, 0, "Set the length of the animation");
880         
881                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,70,73,19, &(tex->fradur[0][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
882                 uiDefButS(block, NUM, B_MATPRV, "",                     879,70,37,19, &(tex->fradur[0][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
883                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,50,73,19, &(tex->fradur[1][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
884                 uiDefButS(block, NUM, B_MATPRV, "",                     879,50,37,19, &(tex->fradur[1][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
885                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,30,73,19, &(tex->fradur[2][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
886                 uiDefButS(block, NUM, B_MATPRV, "",                     879,30,37,19, &(tex->fradur[2][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
887                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,10,73,19, &(tex->fradur[3][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
888                 uiDefButS(block, NUM, B_MATPRV, "",                     879,10,37,19, &(tex->fradur[3][1]), 0.0, 250.0, 0, 0, "Montage mode: amount of displayed frames");
889         
890                 uiDefButS(block, TOG|BIT|6, 0, "Cyclic",                743,60,48,19, &tex->imaflag, 0, 0, 0, 0, "Repeat animation image");
891         }
892 }
893
894
895 static void texture_panel_image(Tex *tex)
896 {
897         uiBlock *block;
898         ID *id;
899         char *strp, str[32];
900         
901         block= uiNewBlock(&curarea->uiblocks, "texture_panel_image", UI_EMBOSS, UI_HELV, curarea->win);
902         if(uiNewPanel(curarea, block, "Image", "Texture", 640, 0, 318, 204)==0) return;
903         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
904
905         /* types */
906         uiDefButS(block, TOG|BIT|0, 0, "InterPol",                      10, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Interpolate pixels of the image");
907         uiDefButS(block, TOG|BIT|1, B_MATPRV, "UseAlpha",       85, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Use the alpha layer");
908         uiDefButS(block, TOG|BIT|5, B_MATPRV, "CalcAlpha",      160, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Calculate an alpha based on the RGB");
909         uiDefButS(block, TOG|BIT|2, B_MATPRV, "NegAlpha",       235, 180, 75, 18, &tex->flag, 0, 0, 0, 0, "Reverse the alpha value");
910
911         uiDefButS(block, TOG|BIT|2, B_IMAPTEST, "MipMap",       10, 160, 60, 18, &tex->imaflag, 0, 0, 0, 0, "Generate a series of pictures used for mipmapping");
912         uiDefButS(block, TOG|BIT|3, B_IMAPTEST, "Fields",       70, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Work with field images");
913         uiDefButS(block, TOG|BIT|4, B_MATPRV, "Rot90",          120, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Rotate image 90 degrees when rendered");
914         uiDefButS(block, TOG|BIT|7, B_RELOADIMA, "Movie",       170, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Use a movie for an image");
915         uiDefButS(block, TOG|BIT|8, 0, "Anti",                          220, 160, 40, 18, &tex->imaflag, 0, 0, 0, 0, "Use anti-aliasing");
916         uiDefButS(block, TOG|BIT|10, 0, "StField",                      260, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "");
917
918         /* file input */
919         id= (ID *)tex->ima;
920         IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(G.buts->menunr));
921         if(strp[0])
922                 uiDefButS(block, MENU, B_TEXIMABROWSE, strp, 10,135,23,20, &(G.buts->menunr), 0, 0, 0, 0, "Browse");
923         MEM_freeN(strp);
924
925         uiDefBut(block, BUT, B_LOADTEXIMA1, "Load Image", 10,115,130,20, 0, 0, 0, 0, 0, "Load image - file view");
926         uiBlockSetCol(block, TH_BUT_SETTING1);
927         uiDefBut(block, BUT, B_LOADTEXIMA, "",          140,115,20,20, 0, 0, 0, 0, 0, "Load image - thumb view");
928         uiBlockSetCol(block, TH_AUTO);
929
930         if(tex->ima) {
931                 uiDefBut(block, TEX, B_NAMEIMA, "",                     35,135,255,20, tex->ima->name, 0.0, 79.0, 0, 0, "Texture name");
932                 sprintf(str, "%d", tex->ima->id.us);
933                 uiDefBut(block, BUT, 0, str,                            290,135,20,20, 0, 0, 0, 0, 0, "Number of users");
934                 uiDefBut(block, BUT, B_RELOADIMA, "Reload",     230,115,80,20, 0, 0, 0, 0, 0, "Reload");
935         
936                 if (tex->ima->packedfile) packdummy = 1;
937                 else packdummy = 0;
938                 
939                 uiDefIconButI(block, TOG|BIT|0, B_PACKIMA, ICON_PACKAGE, 205,115,24,20, &packdummy, 0, 0, 0, 0, "Pack/Unpack this Image");
940         }
941
942         /* crop extend clip */
943         
944         uiDefButF(block, NUM, B_MATPRV, "Filter :",     10,92,135,19, &tex->filtersize, 0.1, 25.0, 0, 0, "Set the filter size used by mipmap and interpol");
945         
946         uiDefButS(block, ROW, 0, "Extend",                      10,70,75,19, &tex->extend, 4.0, 1.0, 0, 0, "Extend the colour of the edge");
947         uiDefButS(block, ROW, 0, "Clip",                        85,70,75,19, &tex->extend, 4.0, 2.0, 0, 0, "Return alpha 0.0 outside image");
948         uiDefButS(block, ROW, 0, "ClipCube",            160,70,75,19, &tex->extend, 4.0, 4.0, 0, 0, "Return alpha 0.0 outside cubeshaped area around image");
949         uiDefButS(block, ROW, 0, "Repeat",                      235,70,75,19, &tex->extend, 4.0, 3.0, 0, 0, "Repeat image horizontally and vertically");
950
951         uiDefButS(block, NUM, B_MATPRV, "Xrepeat:",     10,50,150,19, &tex->xrepeat, 1.0, 512.0, 0, 0, "Set the degree of repetition in the X direction");
952         uiDefButS(block, NUM, B_MATPRV, "Yrepeat:",     160,50,150,19, &tex->yrepeat, 1.0, 512.0, 0, 0, "Set the degree of repetition in the Y direction");
953
954         uiDefButF(block, NUM, B_REDR, "MinX ",          10,28,150,19, &tex->cropxmin, -10.0, 10.0, 10, 0, "Set minimum X value for cropping");
955         uiDefButF(block, NUM, B_REDR, "MaxX ",          160,28,150,19, &tex->cropxmax, -10.0, 10.0, 10, 0, "Set maximum X value for cropping");
956         uiDefButF(block, NUM, B_REDR, "MinY ",          10,8,150,19, &tex->cropymin, -10.0, 10.0, 10, 0, "Set minimum Y value for cropping");
957         uiDefButF(block, NUM, B_REDR, "MaxY ",          160,8,150,19, &tex->cropymax, -10.0, 10.0, 10, 0, "Set maximum Y value for cropping");
958
959 }
960
961 static void drawcolorband_cb(void)
962 {
963         ID *id, *idfrom;
964         
965         buttons_active_id(&id, &idfrom);
966         if( GS(id->name)==ID_TE) {
967                 Tex *tex= (Tex *)id;
968                 drawcolorband(tex->coba, 10,150,300,20);
969         }
970 }
971
972 static void texture_panel_colors(Tex *tex)
973 {
974         uiBlock *block;
975         CBData *cbd;
976         
977         block= uiNewBlock(&curarea->uiblocks, "texture_panel_colors", UI_EMBOSS, UI_HELV, curarea->win);
978         uiNewPanelTabbed("Texture", "Texture");
979         if(uiNewPanel(curarea, block, "Colors", "Texture", 1280, 0, 318, 204)==0) return;
980                 
981         
982         /* COLORBAND */
983         uiDefButS(block, TOG|BIT|0, B_COLORBAND, "Colorband",10,180,100,20, &tex->flag, 0, 0, 0, 0, "Use colorband");
984
985         if(tex->flag & TEX_COLORBAND) {
986                 uiDefBut(block, BUT, B_ADDCOLORBAND, "Add",             110,180,50,20, 0, 0, 0, 0, 0, "Add new colour to the colorband");
987                 uiDefButS(block, NUM, B_REDR,           "Cur:",         160,180,100,20, &tex->coba->cur, 0.0, (float)(tex->coba->tot-1), 0, 0, "The active colour from the colorband");
988                 uiDefBut(block, BUT, B_DELCOLORBAND, "Del",             260,180,50,20, 0, 0, 0, 0, 0, "Delete the active colour");
989                 uiDefBut(block, LABEL, B_DOCOLORBAND, "",               10,150,300,20, 0, 0, 0, 0, 0, "Colorband"); /* only for event! */
990                 
991                 uiBlockSetDrawExtraFunc(block, drawcolorband_cb);
992                 cbd= tex->coba->data + tex->coba->cur;
993                 
994                 uiDefButF(block, NUM, B_CALCCBAND, "Pos",       10,120,80,20, &cbd->pos, 0.0, 1.0, 10, 0, "Set the position of the active colour");
995                 uiDefButS(block, ROW, B_MATPRV, "E",            90,120,20,20, &tex->coba->ipotype, 5.0, 1.0, 0, 0, "Interpolation type Ease");
996                 uiDefButS(block, ROW, B_MATPRV, "L",            110,120,20,20, &tex->coba->ipotype, 5.0, 0.0, 0, 0, "Interpolation type Linear");
997                 uiDefButS(block, ROW, B_MATPRV, "S",            130,120,20,20, &tex->coba->ipotype, 5.0, 2.0, 0, 0, "Interpolation type Spline");
998                 uiDefButF(block, COL, B_BANDCOL, "",            150,120,30,20, &(cbd->r), 0, 0, 0, 0, "");
999                 uiDefButF(block, NUMSLI, B_MATPRV, "A ",        180,120,130,20, &cbd->a, 0.0, 1.0, 0, 0, "Set the alpha value");
1000                 
1001                 uiDefButF(block, NUMSLI, B_MATPRV, "R ",        10,100,100,20, &cbd->r, 0.0, 1.0, B_BANDCOL, 0, "Set the red value");
1002                 uiDefButF(block, NUMSLI, B_MATPRV, "G ",        110,100,100,20, &cbd->g, 0.0, 1.0, B_BANDCOL, 0, "Set the green value");
1003                 uiDefButF(block, NUMSLI, B_MATPRV, "B ",        210,100,100,20, &cbd->b, 0.0, 1.0, B_BANDCOL, 0, "Set the blue value");
1004                 
1005         }
1006
1007         /* RGB-BRICON */
1008         if((tex->flag & TEX_COLORBAND)==0) {
1009                 uiDefButF(block, NUMSLI, B_MATPRV, "R ",                60,80,200,20, &tex->rfac, 0.0, 2.0, 0, 0, "Set the red value");
1010                 uiDefButF(block, NUMSLI, B_MATPRV, "G ",                60,60,200,20, &tex->gfac, 0.0, 2.0, 0, 0, "Set the green value");
1011                 uiDefButF(block, NUMSLI, B_MATPRV, "B ",                60,40,200,20, &tex->bfac, 0.0, 2.0, 0, 0, "Set the blue value");
1012         }
1013         uiDefButF(block, NUMSLI, B_MATPRV, "Bright",            10,10,150,20, &tex->bright, 0.0, 2.0, 0, 0, "Set the brightness of the colour or intensity of a texture");
1014         uiDefButF(block, NUMSLI, B_MATPRV, "Contr",                     160,10,150,20, &tex->contrast, 0.01, 2.0, 0, 0, "Set the contrast of the colour or intensity of a texture");
1015
1016 }
1017
1018
1019 static void texture_panel_texture(MTex *mtex, Material *ma, World *wrld, Lamp *la)
1020 {
1021         extern char texstr[15][8]; // butspace.c
1022         MTex *mt=NULL;
1023         uiBlock *block;
1024         ID *id, *idfrom;
1025         int a, yco, loos;
1026         char str[32], *strp;
1027         
1028
1029         block= uiNewBlock(&curarea->uiblocks, "texture_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
1030         if(uiNewPanel(curarea, block, "Texture", "Texture", 320, 0, 318, 204)==0) return;
1031
1032         /* first do the browse but */
1033         buttons_active_id(&id, &idfrom);
1034
1035         uiBlockSetCol(block, TH_BUT_SETTING1);
1036         if(ma) {
1037                 std_libbuttons(block, 10, 180, 0, NULL, B_TEXBROWSE, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1038         }
1039         else if(wrld) {
1040                 std_libbuttons(block, 10, 180, 0, NULL, B_WTEXBROWSE, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1041         }
1042         else if(la) {
1043                 std_libbuttons(block, 10, 180, 0, NULL, B_LTEXBROWSE, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1044         }
1045         uiBlockSetCol(block, TH_AUTO);
1046
1047         /* From button: removed */
1048
1049         /* CHANNELS */
1050         yco= 10;
1051         for(a= 7; a>=0; a--) {
1052                 
1053                 if(ma) mt= ma->mtex[a];
1054                 else if(wrld && a<6)  mt= wrld->mtex[a];
1055                 else if(la && a<6)  mt= la->mtex[a];
1056                 
1057                 if(mt && mt->tex) splitIDname(mt->tex->id.name+2, str, &loos);
1058                 else strcpy(str, "");
1059                 str[14]= 0;
1060
1061                 if(ma) {
1062                         uiDefButC(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(ma->texact), 0.0, (float)a, 0, 0, "Linked channel");
1063                         yco+= 20;
1064                 }
1065                 else if(wrld && a<6) {
1066                         uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(wrld->texact), 0.0, (float)a, 0, 0, "");
1067                         yco+= 20;
1068                 }
1069                 else if(la && a<6) {
1070                         uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(la->texact), 0.0, (float)a, 0, 0, "");
1071                         yco+= 20;
1072                 }
1073                 
1074         }
1075
1076         /* TYPES */
1077         if(mtex && mtex->tex) {
1078                 Tex *tex= mtex->tex;
1079                 int xco;
1080
1081                 uiSetButLock(tex->id.lib!=0, "Can't edit library data");
1082                 xco= 275;
1083                 uiDefButS(block, ROW, B_TEXTYPE, texstr[0],                     160, 110, 70, 20, &tex->type, 1.0, 0.0, 0, 0, "Default");
1084
1085                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_IMAGE],     160, 90, 70, 20, &tex->type, 1.0, (float)TEX_IMAGE, 0, 0, "Use image texture");
1086                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_ENVMAP],240, 90, 70, 20, &tex->type, 1.0, (float)TEX_ENVMAP, 0, 0, "Use environment maps");
1087
1088                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_CLOUDS],160, 70, 70, 20, &tex->type, 1.0, (float)TEX_CLOUDS, 0, 0, "Use clouds texture");
1089                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_MARBLE],240, 70, 70, 20, &tex->type, 1.0, (float)TEX_MARBLE, 0, 0, "Use marble texture");
1090
1091                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_STUCCI],160, 50, 70, 20, &tex->type, 1.0, (float)TEX_STUCCI, 0, 0, "Use strucci texture");
1092                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_WOOD],      240, 50, 70, 20, &tex->type, 1.0, (float)TEX_WOOD, 0, 0, "Use wood texture");
1093
1094                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_MAGIC],     160, 30, 70, 20, &tex->type, 1.0, (float)TEX_MAGIC, 0, 0, "Use magic texture");
1095                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_BLEND],     240, 30, 70, 20, &tex->type, 1.0, (float)TEX_BLEND, 0, 0, "Use blend texture");
1096
1097                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_NOISE],     160, 10, 70, 20, &tex->type, 1.0, (float)TEX_NOISE, 0, 0, "Use noise texture");
1098                 if(tex->plugin && tex->plugin->doit) strp= tex->plugin->pname; else strp= texstr[TEX_PLUGIN];
1099                 uiDefButS(block, ROW, B_TEXTYPE, strp,                          240, 10, 70, 20, &tex->type, 1.0, (float)TEX_PLUGIN, 0, 0, "Use plugin");
1100         }
1101         else {
1102                 // label to avoid centering
1103                 uiDefBut(block, LABEL, 0, " ",  240, 10, 70, 20, 0, 0, 0, 0, 0, "");
1104         }
1105 }
1106
1107 static void texture_panel_preview(int preview)
1108 {
1109         uiBlock *block;
1110         
1111         block= uiNewBlock(&curarea->uiblocks, "texture_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
1112         if(uiNewPanel(curarea, block, "Preview", "Texture", 0, 0, 318, 204)==0) return;
1113         
1114         if(preview) uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1115
1116         // label to force a boundbox for buttons not to be centered
1117         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1118         
1119         uiDefButC(block, ROW, B_TEXREDR_PRV, "Mat",             200,175,80,25, &G.buts->texfrom, 3.0, 0.0, 0, 0, "Display the texture of the active material");
1120         uiDefButC(block, ROW, B_TEXREDR_PRV, "World",   200,150,80,25, &G.buts->texfrom, 3.0, 1.0, 0, 0, "Display the texture of the world block");
1121         uiDefButC(block, ROW, B_TEXREDR_PRV, "Lamp",    200,125,80,25, &G.buts->texfrom, 3.0, 2.0, 0, 0, "Display the texture of the lamp");
1122
1123         uiDefBut(block, BUT, B_DEFTEXVAR, "Default Vars",200,10,80,20, 0, 0, 0, 0, 0, "Return to standard values");
1124
1125 }
1126
1127
1128
1129 /* *************************** RADIO ******************************** */
1130
1131 void do_radiobuts(unsigned short event)
1132 {
1133         Radio *rad;
1134         int phase;
1135         
1136         phase= rad_phase();
1137         rad= G.scene->radio;
1138         
1139         switch(event) {
1140         case B_RAD_ADD:
1141                 add_radio();
1142                 allqueue(REDRAWBUTSSHADING, 0);
1143                 allqueue(REDRAWVIEW3D, 0);
1144                 break;
1145         case B_RAD_DELETE:
1146                 delete_radio();
1147                 allqueue(REDRAWBUTSSHADING, 0);
1148                 allqueue(REDRAWVIEW3D, 0);
1149                 break;
1150         case B_RAD_FREE:
1151                 freeAllRad();
1152                 allqueue(REDRAWBUTSSHADING, 0);
1153                 allqueue(REDRAWVIEW3D, 0);
1154                 break;
1155         case B_RAD_COLLECT:
1156                 rad_collect_meshes();
1157                 allqueue(REDRAWBUTSSHADING, 0);
1158                 allqueue(REDRAWVIEW3D, 0);
1159                 break;
1160         case B_RAD_INIT:
1161                 if(phase==RAD_PHASE_PATCHES) {
1162                         rad_limit_subdivide();
1163                         allqueue(REDRAWBUTSSHADING, 0);
1164                         allqueue(REDRAWVIEW3D, 0);
1165                 }
1166                 break;
1167         case B_RAD_SHOOTP:
1168                 if(phase==RAD_PHASE_PATCHES) {
1169                         waitcursor(1);
1170                         rad_subdivshootpatch();
1171                         allqueue(REDRAWBUTSSHADING, 0);
1172                         allqueue(REDRAWVIEW3D, 0);
1173                         waitcursor(0);
1174                 }
1175                 break;
1176         case B_RAD_SHOOTE:
1177                 if(phase==RAD_PHASE_PATCHES) {
1178                         waitcursor(1);
1179                         rad_subdivshootelem();
1180                         allqueue(REDRAWBUTSSHADING, 0);
1181                         allqueue(REDRAWVIEW3D, 0);
1182                         waitcursor(0);
1183                 }
1184                 break;
1185         case B_RAD_GO:
1186                 if(phase==RAD_PHASE_PATCHES) {
1187                         waitcursor(1);
1188                         rad_go();
1189                         waitcursor(0);
1190                         allqueue(REDRAWBUTSSHADING, 0);
1191                         allqueue(REDRAWVIEW3D, 0);
1192                 }
1193                 break;
1194         case B_RAD_LIMITS:
1195                 rad_setlimits();
1196                 allqueue(REDRAWVIEW3D, 0);
1197                 allqueue(REDRAWBUTSSHADING, 0);
1198                 break;
1199         case B_RAD_FAC:
1200                 set_radglobal();
1201                 if(phase & RAD_PHASE_FACES) make_face_tab();
1202                 else make_node_display();
1203                 allqueue(REDRAWVIEW3D, 0);
1204                 break;
1205         case B_RAD_NODELIM:
1206                 if(phase & RAD_PHASE_FACES) {
1207                         set_radglobal();
1208                         removeEqualNodes(rad->nodelim);
1209                         make_face_tab();
1210                         allqueue(REDRAWVIEW3D, 0);
1211                         allqueue(REDRAWBUTSSHADING, 0);
1212                 }
1213                 break;
1214         case B_RAD_NODEFILT:
1215                 if(phase & RAD_PHASE_FACES) {
1216                         set_radglobal();
1217                         filterNodes();
1218                         make_face_tab();
1219                         allqueue(REDRAWVIEW3D, 0);
1220                 }
1221                 break;
1222         case B_RAD_FACEFILT:
1223                 if(phase & RAD_PHASE_FACES) {
1224                         filterFaces();
1225                         allqueue(REDRAWVIEW3D, 0);
1226                 }
1227                 break;
1228         case B_RAD_DRAW:
1229                 set_radglobal();
1230                 allqueue(REDRAWVIEW3D, 0);
1231                 break;
1232         case B_RAD_ADDMESH:
1233                 if(phase & RAD_PHASE_FACES) rad_addmesh();
1234                 allqueue(REDRAWVIEW3D, 0);
1235                 break;
1236         case B_RAD_REPLACE:
1237                 if(phase & RAD_PHASE_FACES) rad_replacemesh();
1238                 allqueue(REDRAWVIEW3D, 0);
1239                 break;
1240         }
1241
1242 }
1243
1244
1245 #if 0
1246         char str[128];
1247                 
1248                 rad_status_str(str);
1249                 cpack(0);
1250                 glRasterPos2i(210, 189);
1251                 BMF_DrawString(uiBlockGetCurFont(block), str);
1252
1253 #endif
1254
1255 static void radio_panel_calculation(Radio *rad, int flag)
1256 {
1257         uiBlock *block;
1258         
1259         block= uiNewBlock(&curarea->uiblocks, "radio_panel_calculation", UI_EMBOSS, UI_HELV, curarea->win);
1260         if(uiNewPanel(curarea, block, "Calculation", "Radio", 640, 0, 318, 204)==0) return;
1261         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1262
1263         if(flag != RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_NEUTRAL);
1264         uiDefBut(block,  BUT, B_RAD_GO, "GO",                                   0, 0, 10, 15, NULL, 0, 0, 0, 0, "Start the radiosity simulation");
1265
1266         uiBlockSetCol(block, TH_AUTO);
1267         uiDefButS(block,  NUM, 0, "SubSh Patch:",                               1, 0, 10, 10, &rad->subshootp, 0.0, 10.0, 0, 0, "Set the number of times the environment is tested to detect pathes");
1268         uiDefButS(block,  NUM, 0, "SubSh Element:",                     1, 0, 10, 10, &rad->subshoote, 0.0, 10.0, 0, 0, "Set the number of times the environment is tested to detect elements");
1269
1270         if(flag != RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_NEUTRAL);
1271         uiDefBut(block,  BUT, B_RAD_SHOOTE, "Subdiv Shoot Element", 2, 0, 10, 10, NULL, 0, 0, 0, 0, "For pre-subdivision, detect high energy changes and subdivide Elements");
1272         uiDefBut(block,  BUT, B_RAD_SHOOTP, "Subdiv Shoot Patch",       2, 0, 10, 10, NULL, 0, 0, 0, 0, "For pre-subdivision, Detect high energy changes and subdivide Patches");
1273
1274         uiBlockSetCol(block, TH_AUTO);
1275         uiDefButI(block,  NUM, 0, "MaxEl:",                                             3, 0, 10, 10, &rad->maxnode, 1.0, 250000.0, 0, 0, "Set the maximum allowed number of elements");
1276         uiDefButS(block,  NUM, 0, "Max Subdiv Shoot:",                  3, 0, 10, 10, &rad->maxsublamp, 1.0, 250.0, 0, 0, "Set the maximum number of initial shoot patches that are evaluated");
1277
1278         if(flag & RAD_PHASE_FACES);
1279         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1280         uiDefBut(block,  BUT, B_RAD_FACEFILT, "FaceFilter",             4, 0, 10, 10, NULL, 0, 0, 0, 0, "Force an extra smoothing");
1281         uiDefBut(block,  BUT, B_RAD_NODEFILT, "Element Filter", 4, 0, 10, 10, NULL, 0, 0, 0, 0, "Filter elements to remove aliasing artefacts");
1282
1283         uiDefBut(block,  BUT, B_RAD_NODELIM, "RemoveDoubles",   5, 0, 30, 10, NULL, 0.0, 50.0, 0, 0, "Join elements which differ less than 'Lim'");
1284         uiBlockSetCol(block, TH_AUTO);
1285         uiDefButS(block,  NUM, 0, "Lim:",                                               5, 0, 10, 10, &rad->nodelim, 0.0, 50.0, 0, 0, "Set the range for removing doubles");
1286
1287
1288 }
1289
1290 static void radio_panel_tool(Radio *rad, int flag)
1291 {
1292         uiBlock *block;
1293         
1294         block= uiNewBlock(&curarea->uiblocks, "radio_panel_tool", UI_EMBOSS, UI_HELV, curarea->win);
1295         if(uiNewPanel(curarea, block, "Radio Tool", "Radio", 320, 0, 318, 204)==0) return;
1296         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1297
1298         if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_SETTING2);
1299         uiDefBut(block,  BUT, B_RAD_COLLECT, "Collect Meshes",  0, 0, 10, 15, NULL, 0, 0, 0, 0, "Convert selected and visible meshes to patches");
1300
1301         if(flag & RAD_PHASE_PATCHES)uiBlockSetCol(block, TH_AUTO);
1302         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1303         uiDefBut(block,  BUT, B_RAD_FREE, "Free Radio Data",    0, 0, 10, 15, NULL, 0, 0, 0, 0, "Release all memory used by Radiosity");        
1304
1305         if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, TH_AUTO);
1306         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1307         uiDefBut(block,  BUT, B_RAD_REPLACE, "Replace Meshes",  1, 0, 10, 12, NULL, 0, 0, 0, 0, "Convert meshes to Mesh objects with vertex colours, changing input-meshes");
1308         uiDefBut(block,  BUT, B_RAD_ADDMESH, "Add new Meshes",  1, 0, 10, 12, NULL, 0, 0, 0, 0, "Convert meshes to Mesh objects with vertex colours, unchanging input-meshes");
1309
1310         uiBlockSetCol(block, TH_AUTO);
1311         uiDefButS(block,  ROW, B_RAD_DRAW, "Wire",                      2, 0, 10, 10, &rad->drawtype, 0.0, 0.0, 0, 0, "Enable wireframe drawmode");
1312         uiDefButS(block,  ROW, B_RAD_DRAW, "Solid",                     2, 0, 10, 10, &rad->drawtype, 0.0, 1.0, 0, 0, "Enable solid drawmode");
1313         uiDefButS(block,  ROW, B_RAD_DRAW, "Gour",                      2, 0, 10, 10, &rad->drawtype, 0.0, 2.0, 0, 0, "Enable Gourad drawmode");
1314         uiDefButS(block,  TOG|BIT|0, B_RAD_DRAW, "ShowLim", 2, 0, 10, 10, &rad->flag, 0, 0, 0, 0, "Visualize patch and element limits");
1315         uiDefButS(block,  TOG|BIT|1, B_RAD_DRAW, "Z",           2, 0, 3, 10, &rad->flag, 0, 0, 0, 0, "Draw limits different");
1316
1317         uiDefButS(block,  NUM, B_RAD_LIMITS, "ElMax:",          3, 0, 10, 10, &rad->elma, 1.0, 500.0, 0, 0, "Set maximum size of an element");
1318         uiDefButS(block,  NUM, B_RAD_LIMITS, "ElMin:",          3, 0, 10, 10, &rad->elmi, 1.0, 100.0, 0, 0, "Set minimum size of an element");
1319         uiDefButS(block,  NUM, B_RAD_LIMITS, "PaMax:",          3, 0, 10, 10, &rad->pama, 10.0, 1000.0, 0, 0, "Set maximum size of a patch");
1320         uiDefButS(block,  NUM, B_RAD_LIMITS, "PaMin:",          3, 0, 10, 10, &rad->pami, 10.0, 1000.0, 0, 0, "Set minimum size of a patch");
1321
1322         uiDefBut(block,  BUT, B_RAD_INIT, "Limit Subdivide", 5, 0, 10, 10, NULL, 0, 0, 0, 0, "Subdivide patches");
1323 }
1324
1325
1326 static void radio_panel_render(Radio *rad)
1327 {
1328         uiBlock *block;
1329         
1330         block= uiNewBlock(&curarea->uiblocks, "radio_panel_render", UI_EMBOSS, UI_HELV, curarea->win);
1331         if(uiNewPanel(curarea, block, "Radio Render", "Radio", 0, 0, 318, 204)==0) return;
1332         uiAutoBlock(block, 210, 30, 230, 150, UI_BLOCK_ROWS);
1333
1334         uiDefButS(block,  NUMSLI, B_RAD_LIMITS, "Hemires:", 0, 0, 10, 10, &rad->hemires, 100.0, 1000.0, 100, 0, "Set the size of a hemicube");
1335         uiDefButS(block,  NUM, 0, "Max Iterations:",            2, 0, 10, 15, &rad->maxiter, 0.0, 10000.0, 0, 0, "Maximum number of radiosity rounds");
1336         uiDefButF(block,  NUM, B_RAD_FAC, "Mult:",                      3, 0, 10, 15, &rad->radfac, 0.001, 250.0, 100, 0, "Mulitply the energy values");
1337         uiDefButF(block,  NUM, B_RAD_FAC, "Gamma:",                     3, 0, 10, 15, &rad->gamma, 0.2, 10.0, 10, 0, "Change the contrast of the energy values");
1338         uiDefButF(block,  NUMSLI, 0, "Convergence:",            5, 0, 10, 10, &rad->convergence, 0.0, 1.0, 10, 0, "Set the lower threshold of unshot energy");
1339 }
1340
1341
1342 /* ***************************** WORLD ************************** */
1343
1344 void do_worldbuts(unsigned short event)
1345 {
1346         World *wrld;
1347         MTex *mtex;
1348         
1349         switch(event) {
1350         case B_TEXCLEARWORLD:
1351                 wrld= G.buts->lockpoin;
1352                 mtex= wrld->mtex[ wrld->texact ];
1353                 if(mtex) {
1354                         if(mtex->tex) mtex->tex->id.us--;
1355                         MEM_freeN(mtex);
1356                         wrld->mtex[ wrld->texact ]= 0;
1357                         allqueue(REDRAWBUTSSHADING, 0);
1358                         allqueue(REDRAWOOPS, 0);
1359                         BIF_preview_changed(G.buts);
1360                 }
1361                 break;
1362         }
1363 }
1364
1365 static void world_panel_mapto(World *wrld)
1366 {
1367         uiBlock *block;
1368         MTex *mtex;
1369         
1370         block= uiNewBlock(&curarea->uiblocks, "world_panel_mapto", UI_EMBOSS, UI_HELV, curarea->win);
1371         uiNewPanelTabbed("Texture and Input", "World");
1372         if(uiNewPanel(curarea, block, "Map To", "World", 1280, 0, 318, 204)==0) return;
1373
1374         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1375
1376         mtex= wrld->mtex[ wrld->texact ];
1377         if(mtex==0) {
1378                 mtex= &emptytex;
1379                 default_mtex(mtex);
1380                 mtex->texco= TEXCO_VIEW;
1381         }
1382
1383         /* TEXTURE OUTPUT */
1384         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Stencil",        920,114,52,18, &(mtex->texflag), 0, 0, 0, 0, "Use stencil mode");
1385         uiDefButS(block, TOG|BIT|2, B_MATPRV, "Neg",            974,114,38,18, &(mtex->texflag), 0, 0, 0, 0, "Inverse texture operation");
1386         uiDefButS(block, TOG|BIT|0, B_MATPRV, "RGBtoInt",       1014,114,69,18, &(mtex->texflag), 0, 0, 0, 0, "Use RGB values for intensity texure");
1387         
1388         uiDefButF(block, COL, B_MTEXCOL, "",                            920,100,163,12, &(mtex->r), 0, 0, 0, 0, "");
1389         uiDefButF(block, NUMSLI, B_MATPRV, "R ",                        920,80,163,18, &(mtex->r), 0.0, 1.0, B_MTEXCOL, 0, "The amount of red that blends with the intensity colour");
1390         uiDefButF(block, NUMSLI, B_MATPRV, "G ",                        920,60,163,18, &(mtex->g), 0.0, 1.0, B_MTEXCOL, 0, "The amount of green that blends with the intensity colour");
1391         uiDefButF(block, NUMSLI, B_MATPRV, "B ",                        920,40,163,18, &(mtex->b), 0.0, 1.0, B_MTEXCOL, 0, "The amount of blue that blends with the intensity colour");
1392         uiDefButF(block, NUMSLI, B_MATPRV, "DVar ",             920,10,163,18, &(mtex->def_var), 0.0, 1.0, 0, 0, "The value that an intensity texture blends with the current value");
1393         
1394         /* MAP TO */
1395         uiDefButS(block, TOG|BIT|0, B_MATPRV, "Blend",          1087,166,81,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture work on the colour progression in the sky");
1396         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Hori",           1172,166,81,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture work on the colour of the horizon");
1397         uiDefButS(block, TOG|BIT|2, B_MATPRV, "ZenUp",          1087,147,81,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture work on the colour of the zenith above");
1398         uiDefButS(block, TOG|BIT|3, B_MATPRV, "ZenDo",          1172,147,81,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture work on the colour of the zenith below");
1399         
1400         uiDefButS(block, ROW, B_MATPRV, "Blend",                        1087,114,48,18, &(mtex->blendtype), 9.0, (float)MTEX_BLEND, 0, 0, "The texture blends the values");
1401         uiDefButS(block, ROW, B_MATPRV, "Mul",                  1136,114,44,18, &(mtex->blendtype), 9.0, (float)MTEX_MUL, 0, 0, "The texture multiplies the values");
1402         uiDefButS(block, ROW, B_MATPRV, "Add",                  1182,114,41,18, &(mtex->blendtype), 9.0, (float)MTEX_ADD, 0, 0, "The texture adds the values");
1403         uiDefButS(block, ROW, B_MATPRV, "Sub",                  1226,114,40,18, &(mtex->blendtype), 9.0, (float)MTEX_SUB, 0, 0, "The texture subtracts the values");
1404         
1405         uiDefButF(block, NUMSLI, B_MATPRV, "Col ",              1087,50,179,18, &(mtex->colfac), 0.0, 1.0, 0, 0, "Specify the extent to which the texture works on colour");
1406         uiDefButF(block, NUMSLI, B_MATPRV, "Nor ",              1087,30,179,18, &(mtex->norfac), 0.0, 1.0, 0, 0, "Specify the extent to which the texture works on the normal");
1407         uiDefButF(block, NUMSLI, B_MATPRV, "Var ",              1087,10,179,18, &(mtex->varfac), 0.0, 1.0, 0, 0, "Specify the extent to which the texture works on a value");
1408
1409 }
1410
1411 static void world_panel_texture(World *wrld)
1412 {
1413         uiBlock *block;
1414         MTex *mtex;
1415         ID *id;
1416         int a, loos;
1417         char str[64], *strp;
1418         
1419         block= uiNewBlock(&curarea->uiblocks, "world_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
1420         if(uiNewPanel(curarea, block, "Texture and Input", "World", 960, 0, 318, 204)==0) return;
1421
1422         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1423
1424         /* TEX CHANNELS */
1425         uiBlockSetCol(block, TH_BUT_NEUTRAL);
1426         
1427         for(a= 0; a<6; a++) {
1428                 mtex= wrld->mtex[a];
1429                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
1430                 else strcpy(str, "");
1431                 str[10]= 0;
1432                 uiDefButS(block, ROW, REDRAWBUTSSHADING, str,10, 140-20*a, 80, 20, &(wrld->texact), 3.0, (float)a, 0, 0, "Texture channel");
1433         }
1434         
1435         mtex= wrld->mtex[ wrld->texact ];
1436         if(mtex==0) {
1437                 mtex= &emptytex;
1438                 default_mtex(mtex);
1439                 mtex->texco= TEXCO_VIEW;
1440         }
1441         
1442         /* TEXTUREBLOCK SELECT */
1443         uiBlockSetCol(block, TH_BUT_SETTING2);
1444         id= (ID *)mtex->tex;
1445         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
1446         uiDefButS(block, MENU, B_WTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Browse");
1447         MEM_freeN(strp);
1448         
1449         if(id) {
1450                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,163,19, id->name+2, 0.0, 18.0, 0, 0, "Specify the texture name");
1451                 sprintf(str, "%d", id->us);
1452                 uiDefBut(block, BUT, 0, str,                            196,140,21,19, 0, 0, 0, 0, 0, "Number of users");
1453                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 241,140,21,19, 0, 0, 0, 0, 0, "Auto assign name to texture");
1454                 if(id->lib) {
1455                         if(wrld->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,      1019,146,21,19, 0, 0, 0, 0, 0, "");
1456                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
1457                 }
1458                 uiBlockSetCol(block, TH_AUTO);
1459                 uiDefBut(block, BUT, B_TEXCLEARWORLD, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erase link to texture");
1460         }
1461         uiBlockSetCol(block, TH_AUTO);
1462         
1463
1464         /* TEXCO */
1465         uiDefButS(block, ROW, B_MATPRV, "View",                 100,110,50,19, &(mtex->texco), 4.0, (float)TEXCO_VIEW, 0, 0, "Pass camera view vector on to the texture");
1466         uiDefButS(block, ROW, B_MATPRV, "Object",               150,110,50,19, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "The name of the object used as a source for texture coordinates");
1467         uiDefIDPoinBut(block, test_obpoin_but, B_MATPRV, "", 100,110,100,19, &(mtex->object), "");
1468         
1469         uiDefButF(block, NUM, B_MATPRV, "dX",           100,50,100,18, mtex->ofs, -20.0, 20.0, 10, 0, "Set the extra translation of the texture coordinate");
1470         uiDefButF(block, NUM, B_MATPRV, "dY",           100,30,100,18, mtex->ofs+1, -20.0, 20.0, 10, 0, "Set the extra translation of the texture coordinate");
1471         uiDefButF(block, NUM, B_MATPRV, "dZ",           100,10,100,18, mtex->ofs+2, -20.0, 20.0, 10, 0, "Set the extra translation of the texture coordinate");
1472         uiDefButF(block, NUM, B_MATPRV, "sizeX",        200,50,100,18, mtex->size, -10.0, 10.0, 10, 0, "Set the extra scaling of the texture coordinate");
1473         uiDefButF(block, NUM, B_MATPRV, "sizeY",        200,30,100,18, mtex->size+1, -10.0, 10.0, 10, 0, "Set the extra scaling of the texture coordinate");
1474         uiDefButF(block, NUM, B_MATPRV, "sizeZ",        200,10,100,18, mtex->size+2, -10.0, 10.0, 10, 0, "Set the extra scaling of the texture coordinate");    
1475
1476
1477 }
1478
1479 static void world_panel_mistaph(World *wrld)
1480 {
1481         uiBlock *block;
1482         
1483         block= uiNewBlock(&curarea->uiblocks, "world_panel_mistaph", UI_EMBOSS, UI_HELV, curarea->win);
1484         if(uiNewPanel(curarea, block, "Mist Stars Physics", "World", 640, 0, 318, 204)==0) return;
1485
1486         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1487
1488         uiDefBut(block, MENU|SHO, 1, "Physics %t|None %x1|Sumo %x2|ODE %x3 |Dynamo %x4|",       
1489                         10,180,140,19, &wrld->pad1, 0, 0, 0, 0, "Physics Engine");
1490         
1491         /* Gravitation for the game worlds */
1492         uiDefButF(block, NUMSLI,0, "Grav ", 150,180,150,19,     &(wrld->gravity), 0.0, 25.0, 0, 0,  "Gravitation constant of the game world.");
1493
1494
1495         uiBlockSetCol(block, TH_BUT_SETTING1);
1496         uiDefButS(block, TOG|BIT|0,REDRAWVIEW3D,"Mist", 10,110,140,19, &wrld->mode, 0, 0, 0, 0, "Enable mist");
1497         uiBlockSetCol(block, TH_AUTO);
1498
1499         uiDefButS(block, ROW, B_DIFF, "Qua", 10, 90, 40, 19, &wrld->mistype, 1.0, 0.0, 0, 0, "Use quadratic progression");
1500         uiDefButS(block, ROW, B_DIFF, "Lin", 50, 90, 50, 19, &wrld->mistype, 1.0, 1.0, 0, 0, "Use linear progression");
1501         uiDefButS(block, ROW, B_DIFF, "Sqr", 100, 90, 50, 19, &wrld->mistype, 1.0, 2.0, 0, 0, "Use inverse quadratic progression");
1502         
1503         uiDefButF(block, NUM,REDRAWVIEW3D, "Sta:",10,70,140,19, &wrld->miststa, 0.0, 1000.0, 10, 0, "Specify the starting distance of the mist");
1504         uiDefButF(block, NUM,REDRAWVIEW3D, "Di:",10,50,140,19, &wrld->mistdist, 0.0,1000.0, 10, 00, "Specify the depth of the mist");
1505         uiDefButF(block, NUM,B_DIFF,"Hi:",              10,30,140,19, &wrld->misthi,0.0,100.0, 10, 0, "Specify the factor for a less dense mist with increasing height");
1506         uiDefButF(block, NUMSLI, 0, "Misi",             10,10,140,19,   &(wrld->misi), 0., 1.0, 0, 0, "Set the mist intensity");
1507
1508         uiBlockSetCol(block, TH_BUT_SETTING1);
1509         uiDefButS(block, TOG|BIT|1,B_DIFF,      "Stars",160,110,140,19, &wrld->mode, 0, 0, 0, 0, "Enable stars");
1510         uiBlockSetCol(block, TH_AUTO);
1511         
1512         uiDefButF(block, NUM,B_DIFF,"StarDist:",        160,70,140,19, &(wrld->stardist), 2.0, 1000.0, 100, 0, "Specify the average distance between two stars");
1513         uiDefButF(block, NUM,B_DIFF,"MinDist:",         160,50,140,19, &(wrld->starmindist), 0.0, 1000.0, 100, 0, "Specify the minimum distance to the camera");
1514         uiDefButF(block, NUMSLI,B_DIFF,"Size:",         160,30,140,19, &(wrld->starsize), 0.0, 10.0, 10, 0, "Specify the average screen dimension");
1515         uiDefButF(block, NUMSLI,B_DIFF,"Colnoise:",     160,10,140,19, &(wrld->starcolnoise), 0.0, 1.0, 100, 0, "Randomize starcolour");
1516
1517
1518 }
1519
1520 static void world_panel_world(World *wrld)
1521 {
1522         uiBlock *block;
1523         ID *id, *idfrom;
1524         short xco;
1525         
1526         block= uiNewBlock(&curarea->uiblocks, "world_panel_world", UI_EMBOSS, UI_HELV, curarea->win);
1527         if(uiNewPanel(curarea, block, "World", "World", 320, 0, 318, 204)==0) return;
1528
1529         /* first do the browse but */
1530         buttons_active_id(&id, &idfrom);
1531
1532         uiBlockSetCol(block, TH_BUT_SETTING2);
1533         xco= std_libbuttons(block, 10, 180, 0, NULL, B_WORLDBROWSE, id, idfrom, &(G.buts->menunr), B_WORLDALONE, B_WORLDLOCAL, B_WORLDDELETE, 0, B_KEEPDATA);
1534
1535         if(wrld==NULL) return;
1536         
1537         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1538         uiBlockSetCol(block, TH_AUTO);
1539
1540         uiDefButF(block, COL, B_COLHOR, "",                     10,150,150,19, &wrld->horr, 0, 0, 0, 0, "");
1541         uiDefButF(block, NUMSLI,B_MATPRV,"HoR ",        10,130,150,19,  &(wrld->horr), 0.0, 1.0, B_COLHOR,0, "The amount of red of the horizon colour");
1542         uiDefButF(block, NUMSLI,B_MATPRV,"HoG ",        10,110,150,19,  &(wrld->horg), 0.0, 1.0, B_COLHOR,0, "The amount of green of the horizon colour");
1543         uiDefButF(block, NUMSLI,B_MATPRV,"HoB ",        10,90,150,19,   &(wrld->horb), 0.0, 1.0, B_COLHOR,0, "The amount of blue of the horizon colour");
1544
1545         uiDefButF(block, COL, B_COLZEN, "",                     160,150,150,19, &wrld->zenr, 0, 0, 0, 0, "");
1546         uiDefButF(block, NUMSLI,B_MATPRV,"ZeR ",        160,130,150,19, &(wrld->zenr), 0.0, 1.0, B_COLZEN,0, "The amount of red of the zenith colour");
1547         uiDefButF(block, NUMSLI,B_MATPRV,"ZeG ",        160,110,150,19, &(wrld->zeng), 0.0, 1.0, B_COLZEN,0, "The amount of green of the zenith colour");
1548         uiDefButF(block, NUMSLI,B_MATPRV,"ZeB ",        160,90,150,19,  &(wrld->zenb), 0.0, 1.0, B_COLZEN,0, "The amount of blue of the zenith colour");
1549
1550         uiDefButF(block, NUMSLI,B_MATPRV,"AmbR ",       10,50,150,19,   &(wrld->ambr), 0.0, 1.0 ,0,0, "The amount of red of the ambient colour");
1551         uiDefButF(block, NUMSLI,B_MATPRV,"AmbG ",       10,30,150,19,   &(wrld->ambg), 0.0, 1.0 ,0,0, "The amount of red of the ambient colour");
1552         uiDefButF(block, NUMSLI,B_MATPRV,"AmbB ",       10,10,150,19,   &(wrld->ambb), 0.0, 1.0 ,0,0, "The amount of red of the ambient colour");
1553         uiDefButF(block, NUMSLI,0, "Expos ",            160,10,155,19,  &(wrld->exposure), 0.2, 5.0, 0, 0, "Set the lighting time, exposure");
1554
1555
1556 }
1557
1558 static void world_panel_preview(World *wrld)
1559 {
1560         uiBlock *block;
1561         
1562         /* name "Preview" is abused to detect previewrender offset panel */
1563         block= uiNewBlock(&curarea->uiblocks, "world_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
1564         if(uiNewPanel(curarea, block, "Preview", "World", 0, 0, 318, 204)==0) return;
1565         
1566         if(wrld==NULL) return;
1567
1568         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1569
1570         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1571
1572         // label to force a boundbox for buttons not to be centered
1573         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1574
1575         uiDefButS(block, TOG|BIT|1,B_MATPRV,"Real",     200,175,80,25, &wrld->skytype, 0, 0, 0, 0, "Render background with real horizon");
1576         uiDefButS(block, TOG|BIT|0,B_MATPRV,"Blend",200,150,80,19, &wrld->skytype, 0, 0, 0, 0, "Render background with natural progression");
1577         uiDefButS(block, TOG|BIT|2,B_MATPRV,"Paper",200,125,80,19, &wrld->skytype, 0, 0, 0, 0, "Flatten blend or texture coordinates");
1578         
1579 }
1580
1581
1582
1583 /* ************************ LAMP *************************** */
1584
1585 void do_lampbuts(unsigned short event)
1586 {
1587         Lamp *la;
1588         MTex *mtex;
1589                 
1590         switch(event) {
1591         case B_LAMPREDRAW:
1592                 BIF_preview_changed(G.buts);
1593                 allqueue(REDRAWVIEW3D, 0);
1594                 break;
1595         case B_TEXCLEARLAMP:
1596                 la= G.buts->lockpoin;
1597                 mtex= la->mtex[ la->texact ];
1598                 if(mtex) {
1599                         if(mtex->tex) mtex->tex->id.us--;
1600                         MEM_freeN(mtex);
1601                         la->mtex[ la->texact ]= 0;
1602                         allqueue(REDRAWBUTSSHADING, 0);
1603                         allqueue(REDRAWOOPS, 0);
1604                         BIF_preview_changed(G.buts);
1605                 }
1606                 break;
1607       case B_SBUFF: 
1608                 { 
1609                         la= G.buts->lockpoin; 
1610                         la->bufsize = la->bufsize&=(~15); 
1611                         allqueue(REDRAWBUTSSHADING, 0); 
1612                         allqueue(REDRAWOOPS, 0); 
1613                         /*la->bufsize = la->bufsize % 64;*/ 
1614                 } 
1615                 break; 
1616         }
1617         
1618         if(event) freefastshade();
1619 }
1620
1621
1622 static void lamp_panel_mapto(Object *ob, Lamp *la)
1623 {
1624         uiBlock *block;
1625         MTex *mtex;
1626         
1627         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_mapto", UI_EMBOSS, UI_HELV, curarea->win);
1628         uiNewPanelTabbed("Texture and Input", "Lamp");
1629         if(uiNewPanel(curarea, block, "Map To", "Lamp", 1280, 0, 318, 204)==0) return;
1630
1631         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1632
1633         mtex= la->mtex[ la->texact ];
1634         if(mtex==0) {
1635                 mtex= &emptytex;
1636                 default_mtex(mtex);
1637                 mtex->texco= TEXCO_VIEW;
1638         }
1639
1640         /* TEXTURE OUTPUT */
1641         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Stencil",        920,114,52,18, &(mtex->texflag), 0, 0, 0, 0, "Set the mapping to stencil mode");
1642         uiDefButS(block, TOG|BIT|2, B_MATPRV, "Neg",            974,114,38,18, &(mtex->texflag), 0, 0, 0, 0, "Apply the inverse of the texture");
1643         uiDefButS(block, TOG|BIT|0, B_MATPRV, "RGBtoInt",       1014,114,69,18, &(mtex->texflag), 0, 0, 0, 0, "Use an RGB texture as an intensity texture");
1644         
1645         uiDefButF(block, COL, B_MTEXCOL, "",                            920,100,163,12, &(mtex->r), 0, 0, 0, 0, "");
1646         uiDefButF(block, NUMSLI, B_MATPRV, "R ",                        920,80,163,18, &(mtex->r), 0.0, 1.0, B_MTEXCOL, 0, "Set the red component of the intensity texture to blend with");
1647         uiDefButF(block, NUMSLI, B_MATPRV, "G ",                        920,60,163,18, &(mtex->g), 0.0, 1.0, B_MTEXCOL, 0, "Set the green component of the intensity texture to blend with");
1648         uiDefButF(block, NUMSLI, B_MATPRV, "B ",                        920,40,163,18, &(mtex->b), 0.0, 1.0, B_MTEXCOL, 0, "Set the blue component of the intensity texture to blend with");
1649         uiDefButF(block, NUMSLI, B_MATPRV, "DVar ",             920,10,163,18, &(mtex->def_var), 0.0, 1.0, 0, 0, "Set the value the texture blends with");
1650         
1651         /* MAP TO */
1652         uiDefButS(block, TOG|BIT|0, B_MATPRV, "Col",            1107,166,81,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the colour of the lamp");
1653         
1654         uiDefButS(block, ROW, B_MATPRV, "Blend",                        1087,114,48,18, &(mtex->blendtype), 9.0, (float)MTEX_BLEND, 0, 0, "Mix the values");
1655         uiDefButS(block, ROW, B_MATPRV, "Mul",                  1136,114,44,18, &(mtex->blendtype), 9.0, (float)MTEX_MUL, 0, 0, "Multiply the values");
1656         uiDefButS(block, ROW, B_MATPRV, "Add",                  1182,114,41,18, &(mtex->blendtype), 9.0, (float)MTEX_ADD, 0, 0, "Add the values");
1657         uiDefButS(block, ROW, B_MATPRV, "Sub",                  1226,114,40,18, &(mtex->blendtype), 9.0, (float)MTEX_SUB, 0, 0, "Subtract the values");
1658         
1659         uiDefButF(block, NUMSLI, B_MATPRV, "Col ",              1087,50,179,18, &(mtex->colfac), 0.0, 1.0, 0, 0, "Set the amount the texture affects the colour");
1660         uiDefButF(block, NUMSLI, B_MATPRV, "Nor ",              1087,30,179,18, &(mtex->norfac), 0.0, 1.0, 0, 0, "Set the amount the texture affects the normal");
1661         uiDefButF(block, NUMSLI, B_MATPRV, "Var ",              1087,10,179,18, &(mtex->varfac), 0.0, 1.0, 0, 0, "Set the amount the texture affects the value");
1662
1663 }
1664
1665
1666 static void lamp_panel_texture(Object *ob, Lamp *la)
1667 {
1668         uiBlock *block;
1669         MTex *mtex;
1670         ID *id;
1671         int a, loos;
1672         char *strp, str[64];
1673         
1674         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
1675         if(uiNewPanel(curarea, block, "Texture and Input", "Lamp", 960, 0, 318, 204)==0) return;
1676
1677         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1678
1679         /* TEX CHANNELS */
1680         uiBlockSetCol(block, TH_BUT_NEUTRAL);
1681         for(a= 0; a<6; a++) {
1682                 mtex= la->mtex[a];
1683                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
1684                 else strcpy(str, "");
1685                 str[10]= 0;
1686                 uiDefButS(block, ROW, B_REDR, str,      10, 140-20*a, 80, 20, &(la->texact), 3.0, (float)a, 0, 0, "");
1687         }
1688         
1689         mtex= la->mtex[ la->texact ];
1690         if(mtex==0) {
1691                 mtex= &emptytex;
1692                 default_mtex(mtex);
1693                 mtex->texco= TEXCO_VIEW;
1694         }
1695
1696         /* TEXTUREBLOK SELECT */
1697         uiBlockSetCol(block, TH_BUT_SETTING2);
1698         id= (ID *)mtex->tex;
1699         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
1700         
1701         /* doesnt work, because lockpoin points to lamp, not to texture */
1702         uiDefButS(block, MENU, B_LTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Select an existing texture, or create new");   
1703         MEM_freeN(strp);
1704         
1705         if(id) {
1706                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,163,19, id->name+2, 0.0, 18.0, 0, 0, "Name of the texture block");
1707                 sprintf(str, "%d", id->us);
1708                 uiDefBut(block, BUT, 0, str,                    196,140,21,19, 0, 0, 0, 0, 0, "Select an existing texture, or create new");
1709                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 241,140,21,19, 0, 0, 0, 0, 0, "Auto assign a name to the texture");
1710                 if(id->lib) {
1711                         if(la->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,140,21,19, 0, 0, 0, 0, 0, "");
1712                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
1713                 }
1714                 uiBlockSetCol(block, TH_AUTO);
1715                 uiDefBut(block, BUT, B_TEXCLEARLAMP, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erase link to texture");
1716         }
1717
1718         /* TEXCO */
1719         uiBlockSetCol(block, TH_AUTO);
1720         uiDefButS(block, ROW, B_MATPRV, "Glob",                 100,110,60,20, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Generate texture coordinates from global coordinates");
1721         uiDefButS(block, ROW, B_MATPRV, "View",                 160,110,70,20, &(mtex->texco), 4.0, (float)TEXCO_VIEW, 0, 0, "Generate texture coordinates from view coordinates");
1722         uiDefButS(block, ROW, B_MATPRV, "Object",               230,110,70,20, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Use linked object's coordinates for texture coordinates");
1723         uiDefIDPoinBut(block, test_obpoin_but, B_MATPRV, "", 100,90,200,20, &(mtex->object), "");
1724         
1725         uiDefButF(block, NUM, B_MATPRV, "dX",           100,50,100,18, mtex->ofs, -20.0, 20.0, 10, 0, "Set the extra translation of the texture coordinate");
1726         uiDefButF(block, NUM, B_MATPRV, "dY",           100,30,100,18, mtex->ofs+1, -20.0, 20.0, 10, 0, "Set the extra translation of the texture coordinate");
1727         uiDefButF(block, NUM, B_MATPRV, "dZ",           100,10,100,18, mtex->ofs+2, -20.0, 20.0, 10, 0, "Set the extra translation of the texture coordinate");
1728         uiDefButF(block, NUM, B_MATPRV, "sizeX",        200,50,100,18, mtex->size, -10.0, 10.0, 10, 0, "Set the extra scaling of the texture coordinate");
1729         uiDefButF(block, NUM, B_MATPRV, "sizeY",        200,30,100,18, mtex->size+1, -10.0, 10.0, 10, 0, "Set the extra scaling of the texture coordinate");
1730         uiDefButF(block, NUM, B_MATPRV, "sizeZ",        200,10,100,18, mtex->size+2, -10.0, 10.0, 10, 0, "Set the extra scaling of the texture coordinate");
1731
1732 }
1733
1734 static void lamp_panel_spot(Object *ob, Lamp *la)
1735 {
1736         uiBlock *block;
1737         float grid=0.0;
1738         
1739         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_spot", UI_EMBOSS, UI_HELV, curarea->win);
1740         if(uiNewPanel(curarea, block, "Spot", "Lamp", 640, 0, 318, 204)==0) return;
1741
1742         if(G.vd) grid= G.vd->grid; 
1743         if(grid<1.0) grid= 1.0;
1744
1745         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1746
1747         uiBlockSetCol(block, TH_BUT_SETTING1);
1748         uiDefButS(block, TOG|BIT|0, REDRAWVIEW3D, "Shadows",10,150,80,19,&la->mode, 0, 0, 0, 0, "Let lamp produce shadows");
1749         uiDefButS(block, TOG|BIT|5, 0,"OnlyShadow",                     10,130,80,19,&la->mode, 0, 0, 0, 0, "Render shadow only");
1750         uiDefButS(block, TOG|BIT|7, B_LAMPREDRAW,"Square",      10,90,80,19,&la->mode, 0, 0, 0, 0, "Use square spotbundles");
1751         uiDefButS(block, TOG|BIT|1, 0,"Halo",                           10,50,80,19,&la->mode, 0, 0, 0, 0, "Render spotlights with a volumetric halo"); 
1752
1753         uiBlockSetCol(block, TH_AUTO);
1754         uiDefButF(block, NUMSLI,B_LAMPREDRAW,"SpotSi ", 100,180,200,19,&la->spotsize, 1.0, 180.0, 0, 0, "Set the angle of the spot beam in degrees");
1755         uiDefButF(block, NUMSLI,B_MATPRV,"SpotBl ",             100,160,200,19,&la->spotblend, 0.0, 1.0, 0, 0, "Set the softness of the spot edge");
1756         uiDefButF(block, NUMSLI,0,"HaloInt ",                   100,130,200,19,&la->haint, 0.0, 5.0, 0, 0, "Set the intensity of the spot halo");
1757
1758
1759         uiDefButS(block, NUMSLI,B_SBUFF,"ShadowBuffSize:", 100,110,200,19,      &la->bufsize,512,5120, 0, 0, "Set the size of the shadow buffer");
1760
1761         uiDefButF(block, NUM,REDRAWVIEW3D,"ClipSta:",   100,70,100,19,  &la->clipsta, 0.1*grid,1000.0*grid, 10, 0, "Set the shadow map clip start");
1762         uiDefButF(block, NUM,REDRAWVIEW3D,"ClipEnd:",   200,70,100,19,&la->clipend, 1.0, 5000.0*grid, 100, 0, "Set the shadow map clip end");
1763
1764         uiDefButS(block, NUM,0,"Samples:",              100,30,100,19,  &la->samp,1.0,16.0, 0, 0, "Number of shadow map samples");
1765         uiDefButS(block, NUM,0,"Halo step:",    200,30,100,19,  &la->shadhalostep, 0.0, 12.0, 0, 0, "Volumetric halo sampling frequency");
1766         uiDefButF(block, NUM,0,"Bias:",                 100,10,100,19,  &la->bias, 0.01, 5.0, 1, 0, "Shadow map sampling bias");
1767         uiDefButF(block, NUM,0,"Soft:",                 200,10,100,19,  &la->soft,1.0,100.0, 100, 0, "Set the size of the shadow sample area");
1768         
1769         
1770 }
1771
1772
1773 static void lamp_panel_lamp(Object *ob, Lamp *la)
1774 {
1775         uiBlock *block;
1776         ID *id, *idfrom;
1777         float grid= 0.0;
1778         short xco;
1779         
1780         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_lamp", UI_EMBOSS, UI_HELV, curarea->win);
1781         if(uiNewPanel(curarea, block, "Lamp", "Lamp", 320, 0, 318, 204)==0) return;
1782
1783         if(G.vd) grid= G.vd->grid; 
1784         if(grid<1.0) grid= 1.0;
1785
1786         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1787
1788         /* first do the browse but */
1789         buttons_active_id(&id, &idfrom);
1790
1791         uiBlockSetCol(block, TH_BUT_SETTING2);
1792         xco= std_libbuttons(block, 8, 180, 0, NULL, B_LAMPBROWSE, id, (ID *)ob, &(G.buts->menunr), B_LAMPALONE, B_LAMPLOCAL, 0, 0, 0);  
1793
1794         uiBlockSetCol(block, TH_AUTO);
1795         uiDefButF(block, NUM,B_LAMPREDRAW,"Dist:",xco+10,180,104,20,&la->dist, 0.01, 5000.0, 100, 0, "Set the distance value");
1796
1797         uiBlockSetCol(block, TH_BUT_SETTING1);
1798         uiDefButS(block, TOG|BIT|3, B_MATPRV,"Quad",            10,150,100,19,&la->mode, 0, 0, 0, 0, "Use inverse quadratic proportion");
1799         uiDefButS(block, TOG|BIT|6, REDRAWVIEW3D,"Sphere",      10,130,100,19,&la->mode, 0, 0, 0, 0, "Lamp only shines inside a sphere");
1800         uiDefButS(block, TOG|BIT|2, 0,"Layer",                          10,90,100,19,&la->mode, 0, 0, 0, 0, "Illuminate objects in the same layer only");
1801         uiDefButS(block, TOG|BIT|4, B_MATPRV,"Negative",        10,70,100,19,&la->mode, 0, 0, 0, 0, "Cast negative light");
1802         uiDefButS(block, TOG|BIT|11, 0,"No Diffuse",            10,30,100,19,&la->mode, 0, 0, 0, 0, "No diffuse shading of material");
1803         uiDefButS(block, TOG|BIT|12, 0,"No Specular",           10,10,100,19,&la->mode, 0, 0, 0, 0, "No specular shading of material");
1804
1805
1806         uiBlockSetCol(block, TH_AUTO);
1807         uiDefButF(block, NUMSLI,B_MATPRV,"Energy ",     120,150,180,20, &(la->energy), 0.0, 10.0, 0, 0, "Set the intensity of the light");
1808
1809         uiDefButF(block, NUMSLI,B_MATPRV,"R ",          120,120,180,20,&la->r, 0.0, 1.0, B_COLLAMP, 0, "Set the red component of the light");
1810         uiDefButF(block, NUMSLI,B_MATPRV,"G ",          120,100,180,20,&la->g, 0.0, 1.0, B_COLLAMP, 0, "Set the green component of the light");
1811         uiDefButF(block, NUMSLI,B_MATPRV,"B ",          120,80,180,20,&la->b, 0.0, 1.0, B_COLLAMP, 0, "Set the blue component of the light");
1812         uiDefButF(block, COL, B_COLLAMP, "",            120,55,180,24, &la->r, 0, 0, 0, 0, "");
1813         
1814         uiDefButF(block, NUMSLI,B_MATPRV,"Quad1 ",      120,30,180,19,&la->att1, 0.0, 1.0, 0, 0, "Set the light intensity value 1 for a quad lamp");
1815         uiDefButF(block, NUMSLI,B_MATPRV,"Quad2 ",  120,10,180,19,&la->att2, 0.0, 1.0, 0, 0, "Set the light intensity value 2 for a quad lamp");
1816
1817 }
1818
1819
1820 static void lamp_panel_preview(Object *ob, Lamp *la)
1821 {
1822         uiBlock *block;
1823         
1824         /* name "Preview" is abused to detect previewrender offset panel */
1825         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
1826         if(uiNewPanel(curarea, block, "Preview", "Lamp", 0, 0, 318, 204)==0) return;
1827         
1828         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1829
1830         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1831
1832         // label to force a boundbox for buttons not to be centered
1833         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1834
1835         uiDefButS(block, ROW,B_LAMPREDRAW,"Lamp",       200,175,80,25,&la->type,1.0,(float)LA_LOCAL, 0, 0, "Use a point light source");
1836         uiDefButS(block, ROW,B_LAMPREDRAW,"Spot",       200,150,80,25,&la->type,1.0,(float)LA_SPOT, 0, 0, "Restrict lamp to conical space");
1837         uiDefButS(block, ROW,B_LAMPREDRAW,"Sun",        200,125,80,25,&la->type,1.0,(float)LA_SUN, 0, 0, "Light shines from constant direction");
1838         uiDefButS(block, ROW,B_LAMPREDRAW,"Hemi",       200,100,80,25,&la->type,1.0,(float)LA_HEMI, 0, 0, "Light shines as half a sphere");
1839         
1840 }
1841
1842
1843 /* ****************** MATERIAL ***************** */
1844
1845 void do_matbuts(unsigned short event)
1846 {
1847         static short mtexcopied=0;
1848         Material *ma;
1849         MTex *mtex;
1850
1851         switch(event) {         
1852         case B_ACTCOL:
1853                 scrarea_queue_headredraw(curarea);
1854                 allqueue(REDRAWBUTSSHADING, 0);
1855                 allqueue(REDRAWIPO, 0);
1856                 BIF_preview_changed(G.buts);
1857                 break;
1858         case B_MATFROM:
1859                 scrarea_queue_headredraw(curarea);
1860                 allqueue(REDRAWBUTSSHADING, 0);
1861                 // BIF_previewdraw();  push/pop!
1862                 break;
1863         case B_MATPRV:
1864                 /* this event also used by lamp, tex and sky */
1865                 BIF_preview_changed(G.buts);
1866                 break;
1867         case B_MATPRV_DRAW:
1868                 BIF_preview_changed(G.buts);
1869                 allqueue(REDRAWBUTSSHADING, 0);
1870                 break;
1871         case B_TEXCLEAR:
1872                 ma= G.buts->lockpoin;
1873                 mtex= ma->mtex[(int) ma->texact ];
1874                 if(mtex) {
1875                         if(mtex->tex) mtex->tex->id.us--;
1876                         MEM_freeN(mtex);
1877                         ma->mtex[ (int) ma->texact ]= 0;
1878                         allqueue(REDRAWBUTSSHADING, 0);
1879                         allqueue(REDRAWOOPS, 0);
1880                         BIF_preview_changed(G.buts);
1881                 }
1882                 break;
1883         case B_MTEXCOPY:
1884                 ma= G.buts->lockpoin;
1885                 if(ma && ma->mtex[(int)ma->texact] ) {
1886                         mtex= ma->mtex[(int)ma->texact];
1887                         if(mtex->tex==0) {
1888                                 error("No texture available");
1889                         }
1890                         else {
1891                                 memcpy(&mtexcopybuf, ma->mtex[(int)ma->texact], sizeof(MTex));
1892                                 mtexcopied= 1;
1893                         }
1894                 }
1895                 break;
1896         case B_MTEXPASTE:
1897                 ma= G.buts->lockpoin;
1898                 if(ma && mtexcopied && mtexcopybuf.tex) {
1899                         if(ma->mtex[(int)ma->texact]==0 ) ma->mtex[(int)ma->texact]= MEM_mallocN(sizeof(MTex), "mtex"); 
1900                         memcpy(ma->mtex[(int)ma->texact], &mtexcopybuf, sizeof(MTex));
1901                         
1902                         id_us_plus((ID *)mtexcopybuf.tex);
1903                         BIF_preview_changed(G.buts);
1904                         scrarea_queue_winredraw(curarea);
1905                 }
1906                 break;
1907         case B_MATLAY:
1908                 ma= G.buts->lockpoin;
1909                 if(ma && ma->lay==0) {
1910                         ma->lay= 1;
1911                         scrarea_queue_winredraw(curarea);
1912                 }
1913         }
1914 }
1915
1916 static void material_panel_map_to(Material *ma)
1917 {
1918         uiBlock *block;
1919         MTex *mtex;
1920         
1921         block= uiNewBlock(&curarea->uiblocks, "material_panel_map_to", UI_EMBOSS, UI_HELV, curarea->win);
1922         uiNewPanelTabbed("Texture", "Material");
1923         if(uiNewPanel(curarea, block, "Map To", "Material", 1600, 0, 318, 204)==0) return;
1924
1925         mtex= ma->mtex[ ma->texact ];
1926         if(mtex==0) {
1927                 mtex= &emptytex;
1928                 default_mtex(mtex);
1929         }
1930
1931         /* TEXTURE OUTPUT */
1932         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Stencil",        900,114,52,18, &(mtex->texflag), 0, 0, 0, 0, "Set the mapping to stencil mode");
1933         uiDefButS(block, TOG|BIT|2, B_MATPRV, "Neg",            954,114,38,18, &(mtex->texflag), 0, 0, 0, 0, "Reverse the effect of the texture");
1934         uiDefButS(block, TOG|BIT|0, B_MATPRV, "No RGB", 994,114,69,18, &(mtex->texflag), 0, 0, 0, 0, "Use an RGB texture as an intensity texture");
1935         
1936         uiDefButF(block, COL, B_MTEXCOL, "",                            900,100,163,12, &(mtex->r), 0, 0, 0, 0, "Browse datablocks");
1937
1938         if(ma->colormodel==MA_HSV) {
1939                 uiBlockSetCol(block, TH_BUT_SETTING1);
1940                 uiDefButF(block, HSVSLI, B_MATPRV, "H ",                        900,80,163,18, &(mtex->r), 0.0, 0.9999, B_MTEXCOL, 0, "");
1941                 uiDefButF(block, HSVSLI, B_MATPRV, "S ",                        900,60,163,18, &(mtex->r), 0.0001, 1.0, B_MTEXCOL, 0, "");
1942                 uiDefButF(block, HSVSLI, B_MATPRV, "V ",                        900,40,163,18, &(mtex->r), 0.0001, 1.0, B_MTEXCOL, 0, "");
1943                 uiBlockSetCol(block, TH_AUTO);
1944         }
1945         else {
1946                 uiDefButF(block, NUMSLI, B_MATPRV, "R ",                        900,80,163,18, &(mtex->r), 0.0, 1.0, B_MTEXCOL, 0, "Set the amount of red the intensity texture blends with");
1947                 uiDefButF(block, NUMSLI, B_MATPRV, "G ",                        900,60,163,18, &(mtex->g), 0.0, 1.0, B_MTEXCOL, 0, "Set the amount of green the intensity texture blends with");
1948                 uiDefButF(block, NUMSLI, B_MATPRV, "B ",                        900,40,163,18, &(mtex->b), 0.0, 1.0, B_MTEXCOL, 0, "Set the amount of blue the intensity texture blends with");
1949         }
1950         
1951         uiDefButF(block, NUMSLI, B_MATPRV, "DVar ",             900,10,163,18, &(mtex->def_var), 0.0, 1.0, 0, 0, "Set the value the texture blends with the current value");
1952         
1953         /* MAP TO */
1954         uiDefButS(block, TOG|BIT|0, B_MATPRV, "Col",    900,166,35,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect basic colour of the material");
1955         uiDefButS(block, TOG3|BIT|1, B_MATPRV, "Nor",   935,166,35,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the rendered normal");
1956         uiDefButS(block, TOG|BIT|2, B_MATPRV, "Csp",    970,166,40,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the specularity colour");
1957         uiDefButS(block, TOG|BIT|3, B_MATPRV, "Cmir",   1010,166,42,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affext the mirror colour");
1958         uiDefButS(block, TOG3|BIT|4, B_MATPRV, "Ref",   1052,166,35,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the value of the materials reflectivity");
1959         uiDefButS(block, TOG3|BIT|5, B_MATPRV, "Spec",  1087,166,36,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the value of specularity");
1960         uiDefButS(block, TOG3|BIT|8, B_MATPRV, "Hard",  1126,166,44,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the hardness value");
1961         uiDefButS(block, TOG3|BIT|7, B_MATPRV, "Alpha", 1172,166,45,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the alpha value");
1962         uiDefButS(block, TOG3|BIT|6, B_MATPRV, "Emit",  1220,166,45,18, &(mtex->mapto), 0, 0, 0, 0, "Let the texture affect the emit value");
1963         
1964 /*      uiDefButS(block, TOG|BIT|3, B_MATPRV, "Alpha Mix",1087,114,100,18, &(mtex->texflag), 0, 0, 0, 0); ,""*/
1965
1966         uiDefButS(block, ROW, B_MATPRV, "Mix",                  1087,94,48,18, &(mtex->blendtype), 9.0, (float)MTEX_BLEND, 0, 0, "The texture blends the values or colour");
1967         uiDefButS(block, ROW, B_MATPRV, "Mul",                  1136,94,44,18, &(mtex->blendtype), 9.0, (float)MTEX_MUL, 0, 0, "The texture multiplies the values or colour");
1968         uiDefButS(block, ROW, B_MATPRV, "Add",                  1182,94,41,18, &(mtex->blendtype), 9.0, (float)MTEX_ADD, 0, 0, "The texture adds the values or colour");
1969         uiDefButS(block, ROW, B_MATPRV, "Sub",                  1226,94,40,18, &(mtex->blendtype), 9.0, (float)MTEX_SUB, 0, 0, "The texture subtracts the values or colour");
1970         
1971         uiDefButF(block, NUMSLI, B_MATPRV, "Col ",              1087,50,179,18, &(mtex->colfac), 0.0, 1.0, 0, 0, "Set the amount the texture affects colour");
1972         uiDefButF(block, NUMSLI, B_MATPRV, "Nor ",              1087,30,179,18, &(mtex->norfac), 0.0, 5.0, 0, 0, "Set the amount the texture affects the normal");
1973         uiDefButF(block, NUMSLI, B_MATPRV, "Var ",              1087,10,179,18, &(mtex->varfac), 0.0, 1.0, 0, 0, "Set the amount the texture affects a value");
1974
1975 }
1976
1977
1978 static void material_panel_map_input(Material *ma)
1979 {
1980         uiBlock *block;
1981         MTex *mtex;
1982         int a, xco;
1983         char str[32];
1984         
1985         block= uiNewBlock(&curarea->uiblocks, "material_panel_map_input", UI_EMBOSS, UI_HELV, curarea->win);
1986         uiNewPanelTabbed("Texture", "Material");
1987         if(uiNewPanel(curarea, block, "Map Input", "Material", 1280, 0, 318, 204)==0) return;
1988
1989         mtex= ma->mtex[ ma->texact ];
1990         if(mtex==0) {
1991                 mtex= &emptytex;
1992                 default_mtex(mtex);
1993         }
1994         
1995         /* TEXCO */
1996         uiDefButS(block, ROW, B_MATPRV, "UV",                   630,166,40,18, &(mtex->texco), 4.0, (float)TEXCO_UV, 0, 0, "Use UV coordinates for texture coordinates");
1997         uiDefButS(block, ROW, B_MATPRV, "Object",               670,166,75,18, &(mtex->texco), 4.0, (float)TEXCO_OBJECT, 0, 0, "Use linked object's coordinates for texture coordinates");
1998         uiDefIDPoinBut(block, test_obpoin_but, B_MATPRV, "",745,166,163,18, &(mtex->object), "");
1999
2000         uiDefButS(block, ROW, B_MATPRV, "Glob",                 630,146,45,18, &(mtex->texco), 4.0, (float)TEXCO_GLOB, 0, 0, "Use global coordinates for the texture coordinates");
2001         uiDefButS(block, ROW, B_MATPRV, "Orco",                 675,146,50,18, &(mtex->texco), 4.0, (float)TEXCO_ORCO, 0, 0, "Use the original coordinates of the mesh");
2002         uiDefButS(block, ROW, B_MATPRV, "Stick",                725,146,50,18, &(mtex->texco), 4.0, (float)TEXCO_STICKY, 0, 0, "Use mesh sticky coordaintes for the texture coordinates");
2003         uiDefButS(block, ROW, B_MATPRV, "Win",                  775,146,45,18, &(mtex->texco), 4.0, (float)TEXCO_WINDOW, 0, 0, "Use screen coordinates as texture coordinates");
2004         uiDefButS(block, ROW, B_MATPRV, "Nor",                  820,146,44,18, &(mtex->texco), 4.0, (float)TEXCO_NORM, 0, 0, "Use normal vector as texture coordinates");
2005         uiDefButS(block, ROW, B_MATPRV, "Refl",                 864,146,44,18, &(mtex->texco), 4.0, (float)TEXCO_REFL, 0, 0, "Use reflection vector as texture coordinates");
2006         
2007         /* COORDS */
2008         uiDefButC(block, ROW, B_MATPRV, "Flat",                 666,114,48,18, &(mtex->mapping), 5.0, (float)MTEX_FLAT, 0, 0, "Map X and Y coordinates directly");
2009         uiDefButC(block, ROW, B_MATPRV, "Cube",                 717,114,50,18, &(mtex->mapping), 5.0, (float)MTEX_CUBE, 0, 0, "Map using the normal vector");
2010         uiDefButC(block, ROW, B_MATPRV, "Tube",                 666,94,48,18, &(mtex->mapping), 5.0, (float)MTEX_TUBE, 0, 0, "Map with Z as central axis (tube-like)");
2011         uiDefButC(block, ROW, B_MATPRV, "Sphe",                 716,94,50,18, &(mtex->mapping), 5.0, (float)MTEX_SPHERE, 0, 0, "Map with Z as central axis (sphere-like)");
2012
2013         xco= 665;
2014         for(a=0; a<4; a++) {
2015                 if(a==0) strcpy(str, "");
2016                 else if(a==1) strcpy(str, "X");
2017                 else if(a==2) strcpy(str, "Y");
2018                 else strcpy(str, "Z");
2019                 
2020                 uiDefButC(block, ROW, B_MATPRV, str,                    xco, 50, 24, 18, &(mtex->projx), 6.0, (float)a, 0, 0, "");
2021                 uiDefButC(block, ROW, B_MATPRV, str,                    xco, 30, 24, 18, &(mtex->projy), 7.0, (float)a, 0, 0, "");
2022                 uiDefButC(block, ROW, B_MATPRV, str,                    xco, 10, 24, 18, &(mtex->projz), 8.0, (float)a, 0, 0, "");
2023                 xco+= 26;
2024         }
2025         
2026         uiDefButF(block, NUM, B_MATPRV, "ofsX",         778,114,130,18, mtex->ofs, -10.0, 10.0, 10, 0, "Fine tune X coordinate");
2027         uiDefButF(block, NUM, B_MATPRV, "ofsY",         778,94,130,18, mtex->ofs+1, -10.0, 10.0, 10, 0, "Fine tune Y coordinate");
2028         uiDefButF(block, NUM, B_MATPRV, "ofsZ",         778,74,130,18, mtex->ofs+2, -10.0, 10.0, 10, 0, "Fine tune Z coordinate");
2029         uiDefButF(block, NUM, B_MATPRV, "sizeX",        778,50,130,18, mtex->size, -100.0, 100.0, 10, 0, "Set an extra scaling for the texture coordinate");
2030         uiDefButF(block, NUM, B_MATPRV, "sizeY",        778,30,130,18, mtex->size+1, -100.0, 100.0, 10, 0, "Set an extra scaling for the texture coordinate");
2031         uiDefButF(block, NUM, B_MATPRV, "sizeZ",        778,10,130,18, mtex->size+2, -100.0, 100.0, 10, 0, "Set an extra scaling for the texture coordinate");
2032
2033
2034 }
2035
2036
2037 static void material_panel_texture(Material *ma)
2038 {
2039         uiBlock *block;
2040         MTex *mtex;
2041         ID *id;
2042         int loos;
2043         int a, xco;
2044         char str[64], *strp;
2045         
2046         block= uiNewBlock(&curarea->uiblocks, "material_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
2047         if(uiNewPanel(curarea, block, "Texture", "Material", 960, 0, 318, 204)==0) return;
2048
2049         /* TEX CHANNELS */
2050         uiBlockSetCol(block, TH_BUT_NEUTRAL);
2051         xco= 665;
2052         for(a= 0; a<8; a++) {
2053                 mtex= ma->mtex[a];
2054                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
2055                 else strcpy(str, "");
2056                 str[10]= 0;
2057                 uiDefButC(block, ROW, B_MATPRV_DRAW, str,       10, 180-22*a, 70, 20, &(ma->texact), 3.0, (float)a, 0, 0, "");
2058                 xco+= 65;
2059         }
2060         
2061         
2062         uiDefIconBut(block, BUT, B_MTEXCOPY, ICON_COPYUP,       100,180,23,21, 0, 0, 0, 0, 0, "Copy the mapping settings to the buffer");
2063         uiDefIconBut(block, BUT, B_MTEXPASTE, ICON_PASTEUP,     125,180,23,21, 0, 0, 0, 0, 0, "Paste the mapping settings from the buffer");
2064
2065         uiBlockSetCol(block, TH_AUTO);
2066         uiDefButC(block, TOG, B_MATPRV, "SepTex",               160, 180, 100, 20, &(ma->septex), 0, 0, 0, 0, "Render only use active texture channel");
2067         
2068         mtex= ma->mtex[ ma->texact ];
2069         if(mtex==0) {
2070                 mtex= &emptytex;
2071                 default_mtex(mtex);
2072         }
2073
2074         /* TEXTUREBLOK SELECT */
2075         uiBlockSetCol(block, TH_BUT_SETTING2);
2076         if(G.main->tex.first==0)
2077                 id= NULL;
2078         else
2079                 id= (ID*) mtex->tex;
2080         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x32767", &(G.main->tex), id, &(G.buts->texnr));
2081         uiDefButS(block, MENU, B_EXTEXBROWSE, strp, 100,130,20,20, &(G.buts->texnr), 0, 0, 0, 0, "The name of the texture");
2082         MEM_freeN(strp);
2083
2084         if(id) {
2085                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,150,163,20, id->name+2, 0.0, 18.0, 0, 0, "The name of the texture block");
2086                 sprintf(str, "%d", id->us);
2087                 uiDefBut(block, BUT, 0, str,                            196,130,21,20, 0, 0, 0, 0, 0, "");
2088                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 241,130,21,20, 0, 0, 0, 0, 0, "Auto-assign name to texture");
2089                 if(id->lib) {
2090                         if(ma->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,130,21,20, 0, 0, 0, 0, 0, "");
2091                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,130,21,20, 0, 0, 0, 0, 0, "");              
2092                 }
2093                 uiBlockSetCol(block, TH_AUTO);
2094                 uiDefBut(block, BUT, B_TEXCLEAR, "Clear", 122, 130, 72, 20, 0, 0, 0, 0, 0, "Erase link to datablock");
2095         }
2096         
2097         uiBlockSetCol(block, TH_AUTO);
2098 }
2099
2100 static void material_panel_shading(Material *ma)
2101 {
2102         uiBlock *block;
2103         
2104         block= uiNewBlock(&curarea->uiblocks, "material_panel_shading", UI_EMBOSS, UI_HELV, curarea->win);
2105         if(uiNewPanel(curarea, block, "Shaders", "Material", 640, 0, 318, 204)==0) return;
2106
2107         uiBlockSetCol(block, TH_BUT_SETTING1);
2108         uiDefButI(block, TOG|BIT|5, B_MATPRV_DRAW, "Halo",      245,180,65,18, &(ma->mode), 0, 0, 0, 0, "Render as a halo");
2109         uiBlockSetCol(block, TH_AUTO);
2110
2111         if(ma->mode & MA_HALO) {
2112                 uiDefButF(block, NUM, B_MATPRV, "HaloSize: ",           10,155,190,18, &(ma->hasize), 0.0, 100.0, 10, 0, "Set the dimension of the halo");
2113                 uiDefButS(block, NUMSLI, B_MATPRV, "Hard ",                     10,135,190,18, &(ma->har), 1.0, 127.0, 0, 0, "Set the hardness of the halo");
2114                 uiDefButF(block, NUMSLI, B_MATPRV, "Add  ",                     10,115,190,18, &(ma->add), 0.0, 1.0, 0, 0, "Strength of the add effect");
2115                 
2116                 uiDefButS(block, NUM, B_MATPRV, "Rings: ",                      10,90,90,18, &(ma->ringc), 0.0, 24.0, 0, 0, "Set the number of rings rendered over the basic halo");
2117                 uiDefButS(block, NUM, B_MATPRV, "Lines: ",                      100,90,100,18, &(ma->linec), 0.0, 250.0, 0, 0, "Set the number of star shaped lines rendered over the halo");
2118                 uiDefButS(block, NUM, B_MATPRV, "Star: ",                       10,70,90,18, &(ma->starc), 3.0, 50.0, 0, 0, "Set the number of points on the star shaped halo");
2119                 uiDefButC(block, NUM, B_MATPRV, "Seed: ",                       100,70,100,18, &(ma->seed1), 0.0, 255.0, 0, 0, "Use random values for ring dimension and line location");
2120                 if(ma->mode & MA_HALO_FLARE) {
2121                         uiDefButF(block, NUM, B_MATPRV, "FlareSize: ",          10,50,95,18, &(ma->flaresize), 0.1, 25.0, 10, 0, "Set the factor the flare is larger than the halo");
2122                         uiDefButF(block, NUM, B_MATPRV, "Sub Size: ",           100,50,100,18, &(ma->subsize), 0.1, 25.0, 10, 0, "Set the dimension of the subflares, dots and circles");
2123                         uiDefButF(block, NUMSLI, B_MATPRV, "Boost: ",           10,30,190,18, &(ma->flareboost), 0.1, 10.0, 10, 0, "Give the flare extra strength");
2124                         uiDefButC(block, NUM, B_MATPRV, "Fl.seed: ",            10,10,90,18, &(ma->seed2), 0.0, 255.0, 0, 0, "Specify an offset in the seed table");
2125                         uiDefButS(block, NUM, B_MATPRV, "Flares: ",                     100,10,100,18, &(ma->flarec), 1.0, 32.0, 0, 0, "Set the nuber of subflares");
2126                 }
2127                 uiBlockSetCol(block, TH_BUT_SETTING1);
2128                 
2129                 uiDefButI(block, TOG|BIT|15, B_MATPRV_DRAW, "Flare",            245,142,65,28, &(ma->mode), 0, 0, 0, 0, "Render halo as a lensflare");
2130                 uiDefButI(block, TOG|BIT|8, B_MATPRV, "Rings",          245,123,65, 18, &(ma->mode), 0, 0, 0, 0, "Render rings over basic halo");
2131                 uiDefButI(block, TOG|BIT|9, B_MATPRV, "Lines",          245,104,65, 18, &(ma->mode), 0, 0, 0, 0, "Render star shaped lines over the basic halo");
2132                 uiDefButI(block, TOG|BIT|11, B_MATPRV, "Star",          245,85,65, 18, &(ma->mode), 0, 0, 0, 0, "Render halo as a star");
2133                 uiDefButI(block, TOG|BIT|12, B_MATPRV, "HaloTex",       245,66,65, 18, &(ma->mode), 0, 0, 0, 0, "Give halo a texture");
2134                 uiDefButI(block, TOG|BIT|13, B_MATPRV, "HaloPuno",      245,47,65, 18, &(ma->mode), 0, 0, 0, 0, "Use the vertex normal to specify the dimension of the halo");
2135                 uiDefButI(block, TOG|BIT|10, B_MATPRV, "X Alpha",       245,28,65, 18, &(ma->mode), 0, 0, 0, 0, "Use extreme alpha");
2136                 uiDefButI(block, TOG|BIT|14, B_MATPRV, "Shaded",        245,9,65, 18, &(ma->mode), 0, 0, 0, 0, "Let halo receive light");
2137         }
2138         else {
2139                 char *str1= "Diffuse Shader%t|Lambert %x0|Oren-Nayar %x1|Toon %x2";
2140                 char *str2= "Specular Shader%t|CookTorr %x0|Phong %x1|Blinn %x2|Toon %x3";
2141                 
2142                 /* diff shader buttons */
2143                 uiDefButS(block, MENU, B_MATPRV_DRAW, str1,             9, 155,78,19, &(ma->diff_shader), 0.0, 0.0, 0, 0, "Set a diffuse shader");
2144                 uiDefButF(block, NUMSLI, B_MATPRV, "Ref   ",    90,155,150,19, &(ma->ref), 0.0, 1.0, 0, 0, "Set the amount of reflection");
2145
2146                 if(ma->diff_shader==MA_DIFF_ORENNAYAR)
2147                         uiDefButF(block, NUMSLI, B_MATPRV, "Rough:",90,135, 150,19, &(ma->roughness), 0.0, 3.14, 0, 0, "Oren Nayar Roughness");
2148                 else if(ma->diff_shader==MA_DIFF_TOON) {
2149                         uiDefButF(block, NUMSLI, B_MATPRV, "Size:",     90, 135,150,19, &(ma->param[0]), 0.0, 3.14, 0, 0, "Size of diffuse toon area");
2150                         uiDefButF(block, NUMSLI, B_MATPRV, "Smooth:",90,115,150,19, &(ma->param[1]), 0.0, 1.0, 0, 0, "Smoothness of diffuse toon area");
2151                 }
2152                 
2153                 /* spec shader buttons */
2154                 uiDefButS(block, MENU, B_MATPRV_DRAW, str2,             9,95,77,19, &(ma->spec_shader), 0.0, 0.0, 0, 0, "Set a specular shader");
2155                 uiDefButF(block, NUMSLI, B_MATPRV, "Spec ",             90,95,150,19, &(ma->spec), 0.0, 2.0, 0, 0, "Set the degree of specularity");
2156
2157                 if ELEM3(ma->spec_shader, MA_SPEC_COOKTORR, MA_SPEC_PHONG, MA_SPEC_BLINN) {
2158                         uiDefButS(block, NUMSLI, B_MATPRV, "Hard:",     90, 75, 150,19, &(ma->har), 1.0, 255, 0, 0, "Set the hardness of the specularity");
2159                 }
2160                 if(ma->spec_shader==MA_SPEC_BLINN)
2161                         uiDefButF(block, NUMSLI, B_MATPRV, "Refr:",     90, 55,150,19, &(ma->refrac), 1.0, 10.0, 0, 0, "Refraction index");
2162                 if(ma->spec_shader==MA_SPEC_TOON) {
2163                         uiDefButF(block, NUMSLI, B_MATPRV, "Size:",     90, 75,150,19, &(ma->param[2]), 0.0, 1.53, 0, 0, "Size of specular toon area");
2164                         uiDefButF(block, NUMSLI, B_MATPRV, "Smooth:",90, 55,150,19, &(ma->param[3]), 0.0, 1.0, 0, 0, "Smoothness of specular toon area");
2165                 }
2166
2167                 /* default shading variables */
2168                 uiDefButF(block, NUMSLI, B_MATPRV, "Amb ",              9,30,117,19, &(ma->amb), 0.0, 1.0, 0, 0, "Set the amount of global ambient color");
2169                 uiDefButF(block, NUMSLI, B_MATPRV, "Emit ",             133,30,110,19, &(ma->emit), 0.0, 1.0, 0, 0, "Set the amount of emitting light");
2170                 uiDefButF(block, NUMSLI, B_MATPRV, "Add ",              9,10,117,19, &(ma->add), 0.0, 1.0, 0, 0, "Glow factor for transparant");
2171                 uiDefButF(block, NUM, 0, "Zoffs:",                              133,10,110,19, &(ma->zoffs), 0.0, 10.0, 0, 0, "Give face an artificial offset");
2172         
2173                 uiBlockSetCol(block, TH_BUT_SETTING1);
2174         
2175                 uiDefButI(block, TOG|BIT|0, 0,  "Traceable",            245,161,65,18, &(ma->mode), 0, 0, 0, 0, "Make material visible for shadow lamps");
2176                 uiDefButI(block, TOG|BIT|1, 0,  "Shadow",                       245,142,65,18, &(ma->mode), 0, 0, 0, 0, "Enable material for shadows");
2177                 uiDefButI(block, TOG|BIT|16, 0, "Radio",                        245,123,65,18, &(ma->mode), 0, 0, 0, 0, "Enable radiosty render");
2178                 uiDefButI(block, TOG|BIT|3, 0,  "Wire",                         245,104,65,18, &(ma->mode), 0, 0, 0, 0, "Render only the edges of faces");
2179                 uiDefButI(block, TOG|BIT|6, 0,  "ZTransp",                      245,85, 65,18, &(ma->mode), 0, 0, 0, 0, "Z-Buffer transparent faces");
2180                 uiDefButI(block, TOG|BIT|9, 0,  "Env",                          245,66, 65,18, &(ma->mode), 0, 0, 0, 0, "Do not render material");
2181                 uiDefButI(block, TOG|BIT|10, 0, "OnlyShadow",           245,47, 65,18, &(ma->mode), 0, 0, 0, 0, "Let alpha be determined on the degree of shadow");
2182                 uiDefButI(block, TOG|BIT|14, 0, "No Mist",                      245,28, 65,18, &(ma->mode), 0, 0, 0, 0, "Set the material insensitive to mist");
2183                 uiDefButI(block, TOG|BIT|8, 0,  "ZInvert",                      245,9, 65,18, &(ma->mode), 0, 0, 0, 0, "Render with inverted Z Buffer");
2184         }
2185
2186 }
2187
2188
2189 static void material_panel_material(Object *ob, Material *ma)
2190 {
2191         uiBlock *block;
2192         ID *id, *idn, *idfrom;
2193         uiBut *but;
2194         float *colpoin = NULL, min;
2195         int rgbsel = 0, xco= 0;
2196         char str[30];
2197         
2198         block= uiNewBlock(&curarea->uiblocks, "material_panel_material", UI_EMBOSS, UI_HELV, curarea->win);
2199         if(uiNewPanel(curarea, block, "Material", "Material", 320, 0, 318, 204)==0) return;
2200
2201         /* first do the browse but */
2202         buttons_active_id(&id, &idfrom);
2203
2204         uiBlockSetCol(block, TH_BUT_SETTING2);
2205         xco= std_libbuttons(block, 8, 200, 0, NULL, B_MATBROWSE, id, idfrom, &(G.buts->menunr), B_MATALONE, B_MATLOCAL, B_MATDELETE, B_AUTOMATNAME, B_KEEPDATA);
2206
2207         uiDefIconBut(block, BUT, B_MATCOPY, ICON_COPYUP,        xco+=XIC,198,XIC,YIC, 0, 0, 0, 0, 0, "Copies Material to the buffer");
2208         uiSetButLock(id && id->lib, "Can't edit library data");
2209         uiDefIconBut(block, BUT, B_MATPASTE, ICON_PASTEUP,      xco+=XIC,198,XIC,YIC, 0, 0, 0, 0, 0, "Pastes Material from the buffer");
2210         
2211         if(ob->actcol==0) ob->actcol= 1;        /* because of TOG|BIT button */
2212         
2213         /* indicate which one is linking a material */
2214         uiBlockSetCol(block, TH_BUT_ACTION);
2215         uiDefButS(block, TOG|BIT|(ob->actcol-1), B_MATFROM, "OB",       125,174,32,20, &ob->colbits, 0, 0, 0, 0, "Link material to object");
2216         idn= ob->data;
2217         strncpy(str, idn->name, 2);
2218         str[2]= 0;
2219         uiBlockSetCol(block, TH_BUT_SETTING);
2220         uiDefButS(block, TOGN|BIT|(ob->actcol-1), B_MATFROM, str,       158,174,32,20, &ob->colbits, 0, 0, 0, 0, "Show the block the material is linked to");
2221         uiBlockSetCol(block, TH_AUTO);
2222         
2223         /* id is the block from which the material is used */
2224         if( BTST(ob->colbits, ob->actcol-1) ) id= (ID *)ob;
2225         else id= ob->data;
2226
2227         sprintf(str, "%d Mat", ob->totcol);
2228         if(ob->totcol) min= 1.0; else min= 0.0;
2229         uiDefButC(block, NUM, B_ACTCOL, str,                    191,174,114,20, &(ob->actcol), min, (float)ob->totcol, 0, 0, "Number of materials on object / Active material");
2230         
2231         uiSetButLock(id->lib!=0, "Can't edit library data");
2232         
2233         strncpy(str, id->name, 2);
2234         str[2]= ':'; str[3]= 0;
2235         but= uiDefBut(block, TEX, B_IDNAME, str,                8,174,115,20, id->name+2, 0.0, 18.0, 0, 0, "Show the block the material is linked to");
2236         uiButSetFunc(but, test_idbutton_cb, id->name, NULL);
2237
2238         if(ob->totcol==0) return;
2239
2240         ma= give_current_material(ob, ob->actcol);      
2241         if(ma==0) return;
2242         
2243         uiSetButLock(ma->id.lib!=0, "Can't edit library data");
2244         
2245         
2246         if(ma->dynamode & MA_DRAW_DYNABUTS) {
2247                 uiDefButF(block, NUMSLI, 0, "Restitut ",                128,120,175,20, &ma->reflect, 0.0, 1.0, 0, 0, "Elasticity of collisions");
2248                 uiDefButF(block, NUMSLI, 0, "Friction ",                128,98 ,175,20, &ma->friction, 0.0, 100.0, 0, 0,   "Coulomb friction coefficient");
2249                 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");
2250
2251                 uiDefButF(block, NUM, 0,         "Fh Damp ",            8,120,100,20, &ma->xyfrict, 0.0, 1.0, 10, 0, "Damping of the Fh spring force");
2252                 uiDefButF(block, NUM, 0, "Fh Dist ",                    8,98 ,100,20, &ma->fhdist, 0.0, 20.0, 10, 0, "Height of the Fh area");
2253                 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");
2254         }
2255         else {
2256                 if(!(ma->mode & MA_HALO)) {
2257                         uiBlockSetCol(block, TH_BUT_SETTING1);
2258                         uiDefButI(block, TOG|BIT|4, B_REDR,     "VCol Light",   8,146,75,20, &(ma->mode), 0, 0, 0, 0, "Add vertex colours as extra light");
2259                         uiDefButI(block, TOG|BIT|7, B_REDR, "VCol Paint",       85,146,72,20, &(ma->mode), 0, 0, 0, 0, "Replace basic colours with vertex colours");
2260                         uiDefButI(block, TOG|BIT|11, B_REDR, "TexFace",         160,146,62,20, &(ma->mode), 0, 0, 0, 0, "UV-Editor assigned texture gives color and texture info for the faces");
2261                         uiDefButI(block, TOG|BIT|2, B_MATPRV, "Shadeless",      223,146,80,20, &(ma->mode), 0, 0, 0, 0, "Make material insensitive to light or shadow");
2262                 }
2263                 uiBlockSetCol(block, TH_AUTO);
2264                 uiDefButF(block, COL, B_MATCOL, "",             8,115,72,24, &(ma->r), 0, 0, 0, 0, "");
2265                 uiDefButF(block, COL, B_SPECCOL, "",    8,88,72,24, &(ma->specr), 0, 0, 0, 0, "");
2266                 uiDefButF(block, COL, B_MIRCOL, "",             8,61,72,24, &(ma->mirr), 0, 0, 0, 0, "");
2267         
2268                 if(ma->mode & MA_HALO) {
2269                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Halo",                83,115,40,25, &(ma->rgbsel), 2.0, 0.0, 0, 0, "Mix the colour of the halo with the RGB sliders");
2270                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Line",                83,88,40,25, &(ma->rgbsel), 2.0, 1.0, 0, 0, "Mix the colour of the lines with the RGB sliders");
2271                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Ring",                83,61,40,25, &(ma->rgbsel), 2.0, 2.0, 0, 0, "Mix the colour of the rings with the RGB sliders");
2272                 }
2273                 else {
2274                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Col",                 83,115,40,25, &(ma->rgbsel), 2.0, 0.0, 0, 0, "Set the basic colour of the material");
2275                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Spe",                 83,88,40,25, &(ma->rgbsel), 2.0, 1.0, 0, 0, "Set the colour of the specularity");
2276                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Mir",                 83,61,40,25, &(ma->rgbsel), 2.0, 2.0, 0, 0, "Use mirror colour");
2277                 }
2278                 
2279                 if(ma->rgbsel==0) {colpoin= &(ma->r); rgbsel= B_MATCOL;}
2280                 else if(ma->rgbsel==1) {colpoin= &(ma->specr); rgbsel= B_SPECCOL;}
2281                 else if(ma->rgbsel==2) {colpoin= &(ma->mirr); rgbsel= B_MIRCOL;}
2282                 
2283                 if(ma->rgbsel==0 && (ma->mode & (MA_VERTEXCOLP|MA_FACETEXTURE) && !(ma->mode & MA_HALO)));
2284                 else if(ma->colormodel==MA_HSV) {
2285                         uiBlockSetCol(block, TH_BUT_SETTING1);
2286                         uiDefButF(block, HSVSLI, B_MATPRV, "H ",                128,120,175,20, colpoin, 0.0, 0.9999, rgbsel, 0, "");
2287                         uiDefButF(block, HSVSLI, B_MATPRV, "S ",                128,98,175,20, colpoin, 0.0001, 1.0, rgbsel, 0, "");
2288                         uiDefButF(block, HSVSLI, B_MATPRV, "V ",                128,76,175,20, colpoin, 0.0001, 1.0, rgbsel, 0, "");
2289                         uiBlockSetCol(block, TH_AUTO);
2290                 }
2291                 else {
2292                         uiDefButF(block, NUMSLI, B_MATPRV, "R ",                128,120,175,20, colpoin, 0.0, 1.0, rgbsel, 0, "");
2293                         uiDefButF(block, NUMSLI, B_MATPRV, "G ",                128,98,175,20, colpoin+1, 0.0, 1.0, rgbsel, 0, "");
2294                         uiDefButF(block, NUMSLI, B_MATPRV, "B ",                128,76,175,20, colpoin+2, 0.0, 1.0, rgbsel, 0, "");
2295                 }
2296                 
2297                 uiDefButF(block, NUMSLI, B_MATPRV, "Alpha ",            128,54,175,20, &(ma->alpha), 0.0, 1.0, 0, 0, "Set the amount of coverage, to make materials transparent");
2298                 uiDefButF(block, NUMSLI, B_MATPRV, "SpecTra ",          128,32,175,20, &(ma->spectra), 0.0, 1.0, 0, 0, "Make specular areas opaque");
2299                 
2300         }
2301         uiDefButS(block, ROW, REDRAWBUTSSHADING, "RGB",                 8,32,35,20, &(ma->colormodel), 1.0, (float)MA_RGB, 0, 0, "Create colour by red, green and blue");
2302         uiDefButS(block, ROW, REDRAWBUTSSHADING, "HSV",                 43,32,35,20, &(ma->colormodel), 1.0, (float)MA_HSV, 0, 0, "Mix colour with hue, saturation and value");
2303         uiDefButS(block, TOG|BIT|0, REDRAWBUTSSHADING, "DYN",   78,32,45,20, &(ma->dynamode), 0.0, 0.0, 0, 0, "Adjust parameters for dynamics options");
2304
2305 }
2306
2307 static void material_panel_preview(Material *ma)
2308 {
2309         uiBlock *block;
2310         
2311         /* name "Preview" is abused to detect previewrender offset panel */
2312         block= uiNewBlock(&curarea->uiblocks, "material_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
2313         if(uiNewPanel(curarea, block, "Preview", "Material", 0, 0, 318, 204)==0) return;
2314         
2315         if(ma) {
2316                 uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
2317         
2318                 // label to force a boundbox for buttons not to be centered
2319                 uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
2320                 uiBlockSetCol(block, TH_BUT_NEUTRAL);
2321                 uiDefIconButC(block, ROW, B_MATPRV, ICON_MATPLANE,              210,180,25,22, &(ma->pr_type), 10, 0, 0, 0, "");
2322                 uiDefIconButC(block, ROW, B_MATPRV, ICON_MATSPHERE,             210,150,25,22, &(ma->pr_type), 10, 1, 0, 0, "");
2323                 uiDefIconButC(block, ROW, B_MATPRV, ICON_MATCUBE,               210,120,25,22, &(ma->pr_type), 10, 2, 0, 0, "");
2324                 uiDefIconButS(block, ICONTOG|BIT|0, B_MATPRV, ICON_TRANSP_HLT,  210,80,25,22, &(ma->pr_back), 0, 0, 0, 0, "");
2325                 uiDefIconBut(block, BUT, B_MATPRV, ICON_EYE,                    210,10, 25,22, 0, 0, 0, 0, 0, "");
2326         }
2327 }
2328
2329 void material_panels()
2330 {
2331         Material *ma;
2332         MTex *mtex;
2333         Object *ob= OBACT;
2334         
2335         if(ob==0) return;
2336         
2337         // type numbers are ordered
2338         if((ob->type<OB_LAMP) && ob->type) {
2339                 ma= give_current_material(ob, ob->actcol);
2340
2341                 // always draw first 2 panels
2342                 material_panel_preview(ma);
2343                 material_panel_material(ob, ma);
2344                 
2345                 if(ma) {
2346                         material_panel_shading(ma);
2347                         material_panel_texture(ma);
2348                         
2349                         mtex= ma->mtex[ ma->texact ];
2350                         if(mtex && mtex->tex) {
2351                                 material_panel_map_input(ma);
2352                                 material_panel_map_to(ma);
2353                         }
2354                 }
2355         }
2356 }
2357
2358 void lamp_panels()
2359 {
2360         Object *ob= OBACT;
2361         
2362         if(ob==NULL || ob->type!= OB_LAMP) return;
2363
2364         lamp_panel_preview(ob, ob->data);
2365         lamp_panel_lamp(ob, ob->data);
2366         lamp_panel_spot(ob, ob->data);
2367         lamp_panel_texture(ob, ob->data);
2368         lamp_panel_mapto(ob, ob->data);
2369
2370 }
2371
2372 void world_panels()
2373 {
2374         World *wrld;
2375
2376         wrld= G.scene->world;
2377
2378         world_panel_preview(wrld);
2379         world_panel_world(wrld);
2380
2381         if(wrld) {
2382                 world_panel_mistaph(wrld);
2383                 world_panel_texture(wrld);
2384                 world_panel_mapto(wrld);
2385         }
2386 }
2387
2388 void texture_panels()
2389 {
2390         Material *ma=NULL;
2391         Lamp *la=NULL;
2392         World *wrld=NULL;
2393         Object *ob= OBACT;
2394         MTex *mtex= NULL;
2395         
2396         if(G.buts->texfrom==0) {
2397                 if(ob) {
2398                         ma= give_current_material(ob, ob->actcol);
2399                         if(ma) mtex= ma->mtex[ ma->texact ];
2400                 }
2401         }
2402         else if(G.buts->texfrom==1) {
2403                 wrld= G.scene->world;
2404                 if(wrld) mtex= wrld->mtex[ wrld->texact ];
2405         }
2406         else if(G.buts->texfrom==2) {
2407                 if(ob && ob->type==OB_LAMP) {
2408                         la= ob->data;
2409                         mtex= la->mtex[ la->texact ];
2410                 }
2411         }
2412         
2413         texture_panel_preview(ma || wrld || la);        // for 'from' buttons
2414         
2415         if(ma || wrld || la) {
2416         
2417                 texture_panel_texture(mtex, ma, wrld, la);
2418                 
2419                 if(mtex && mtex->tex) {
2420                         texture_panel_colors(mtex->tex);
2421                         
2422                         switch(mtex->tex->type) {
2423                         case TEX_IMAGE:
2424                                 texture_panel_image(mtex->tex);
2425                                 texture_panel_image1(mtex->tex);
2426                                 break;
2427                         case TEX_ENVMAP:
2428                                 texture_panel_envmap(mtex->tex);
2429                                 break;
2430                         case TEX_CLOUDS:
2431                                 texture_panel_clouds(mtex->tex);
2432                                 break;
2433                         case TEX_MARBLE:
2434                                 texture_panel_marble(mtex->tex);
2435                                 break;
2436                         case TEX_STUCCI:
2437                                 texture_panel_stucci(mtex->tex);
2438                                 break;
2439                         case TEX_WOOD:
2440                                 texture_panel_wood(mtex->tex);
2441                                 break;
2442                         case TEX_BLEND:
2443                                 texture_panel_blend(mtex->tex);
2444                                 break;
2445                         case TEX_MAGIC:
2446                                 texture_panel_magic(mtex->tex);
2447                                 break;
2448                         case TEX_PLUGIN:
2449                                 texture_panel_plugin(mtex->tex);
2450                                 break;
2451                         case TEX_NOISE:
2452                                 // no panel!
2453                                 break;
2454                         }
2455                 }
2456         }
2457 }
2458
2459 void radio_panels()
2460 {
2461         Radio *rad;
2462         int flag;
2463         
2464         rad= G.scene->radio;
2465         if(rad==0) {
2466                 add_radio();
2467                 rad= G.scene->radio;
2468         }
2469
2470         radio_panel_render(rad);
2471         
2472         flag= rad_phase();
2473         
2474         radio_panel_tool(rad, flag);
2475         if(flag) radio_panel_calculation(rad, flag);
2476
2477         
2478 }