a07663832214a95842251ddc8c67b30aae3b5bcd
[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_EMBOSSX, 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                 uiBlockSetCol(block, BUTGREEN);
640                 for(a=0; a<pit->stypes; a++) {
641                         uiDefButS(block, ROW, B_MATPRV, pit->stnames+16*a, (350+75*a), 170, 75, 18, &tex->stype, 2.0, (float)a, 0, 0, "");
642                 }
643                 
644                 uiBlockSetCol(block, BUTGREY);
645                 varstr= pit->varstr;
646                 if(varstr) {
647                         for(a=0; a<pit->vars; a++, varstr++) {
648                                 xco= 350 + 140*(a/6);
649                                 yco= 110 - 20*(a % 6);
650                                 pit->data[a] = varstr->def;
651                                 uiDefBut(block, varstr->type, B_PLUGBUT+a, varstr->name, xco,yco,137,19, &(pit->data[a]), varstr->min, varstr->max, 100, 0, varstr->tip);
652                         }
653                 }
654                 uiDefBut(block, TEX, B_NAMEPLUGIN, "",          350,130,290,24, pit->name, 0.0, 159.0, 0, 0, "");
655         }
656
657         uiBlockSetCol(block, BUTSALMON);
658         uiDefBut(block, BUT, B_LOADPLUGIN, "Load Plugin", 350,150,137,24, 0, 0, 0, 0, 0, "");
659                         
660 }
661
662
663 static void texture_panel_magic(Tex *tex)
664 {
665         uiBlock *block;
666         
667         block= uiNewBlock(&curarea->uiblocks, "texture_panel_magic", UI_EMBOSSX, UI_HELV, curarea->win);
668         if(uiNewPanel(curarea, block, "Magic", "Texture", 640, 0, 318, 204)==0) return;
669         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
670
671         uiBlockSetCol(block, BUTGREY);
672         uiDefButF(block, NUM, B_MATPRV, "Size :",               10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Set the dimension of the pattern");
673         uiDefButS(block, NUM, B_MATPRV, "Depth:",               10, 90, 150, 19, &tex->noisedepth, 0.0, 10.0, 0, 0, "Set the depth of the pattern");
674         uiDefButF(block, NUM, B_MATPRV, "Turbulence:",  10, 70, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Set the strength of the pattern");
675 }
676
677 static void texture_panel_blend(Tex *tex)
678 {
679         uiBlock *block;
680         
681         block= uiNewBlock(&curarea->uiblocks, "texture_panel_blend", UI_EMBOSSX, UI_HELV, curarea->win);
682         if(uiNewPanel(curarea, block, "Blend", "Texture", 640, 0, 318, 204)==0) return;
683         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
684
685         uiBlockSetCol(block, BUTGREEN); 
686         uiDefButS(block, ROW, B_MATPRV, "Lin",          10, 180, 75, 19, &tex->stype, 2.0, 0.0, 0, 0, "Use a linear progresion"); 
687         uiDefButS(block, ROW, B_MATPRV, "Quad",         85, 180, 75, 19, &tex->stype, 2.0, 1.0, 0, 0, "Use a quadratic progression"); 
688         uiDefButS(block, ROW, B_MATPRV, "Ease",         160, 180, 75, 19, &tex->stype, 2.0, 2.0, 0, 0, ""); 
689         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");
690
691         uiDefButS(block, ROW, B_MATPRV, "Diag",         10, 160, 75, 19, &tex->stype, 2.0, 3.0, 0, 0, "Use a diagonal progression");
692         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");
693         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");
694         
695 }
696
697
698
699 static void texture_panel_wood(Tex *tex)
700 {
701         uiBlock *block;
702         
703         block= uiNewBlock(&curarea->uiblocks, "texture_panel_wood", UI_EMBOSSX, UI_HELV, curarea->win);
704         if(uiNewPanel(curarea, block, "Wood", "Texture", 640, 0, 318, 204)==0) return;
705         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
706
707         uiBlockSetCol(block, BUTGREEN); 
708         uiDefButS(block, ROW, B_MATPRV, "Bands",                10, 180, 75, 18, &tex->stype, 2.0, 0.0, 0, 0, "Use standard wood texture"); 
709         uiDefButS(block, ROW, B_MATPRV, "Rings",                85, 180, 75, 18, &tex->stype, 2.0, 1.0, 0, 0, "Use wood rings"); 
710         uiDefButS(block, ROW, B_MATPRV, "BandNoise",    160, 180, 75, 18, &tex->stype, 2.0, 2.0, 0, 0, "Add noise to standard wood"); 
711         uiDefButS(block, ROW, B_MATPRV, "RingNoise",    235, 180, 75, 18, &tex->stype, 2.0, 3.0, 0, 0, "Add noise to rings"); 
712
713         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   10, 160, 75, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
714         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   85, 160, 75, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
715
716         uiBlockSetCol(block, BUTGREY);  
717         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");
718         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");
719
720
721 }
722
723 static void texture_panel_stucci(Tex *tex)
724 {
725         uiBlock *block;
726         
727         block= uiNewBlock(&curarea->uiblocks, "texture_panel_stucci", UI_EMBOSSX, UI_HELV, curarea->win);
728         if(uiNewPanel(curarea, block, "Stucci", "Texture", 640, 0, 318, 204)==0) return;
729         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
730
731         uiBlockSetCol(block, BUTGREEN);
732         uiDefButS(block, ROW, B_MATPRV, "Plastic",              10, 180, 100, 19, &tex->stype, 2.0, 0.0, 0, 0, "Use standard stucci");
733         uiDefButS(block, ROW, B_MATPRV, "Wall In",              110, 180, 100, 19, &tex->stype, 2.0, 1.0, 0, 0, "Set start value"); 
734         uiDefButS(block, ROW, B_MATPRV, "Wall Out",             210, 180, 100, 19, &tex->stype, 2.0, 2.0, 0, 0, "Set end value"); 
735         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   10, 160, 100, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
736         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   110, 160, 100, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
737
738         uiBlockSetCol(block, BUTGREY);  
739         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");
740         uiDefButF(block, NUM, B_MATPRV, "Turbulence:",  10, 90, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Set the depth of the stucci");
741 }
742
743 static void texture_panel_marble(Tex *tex)
744 {
745         uiBlock *block;
746         
747         block= uiNewBlock(&curarea->uiblocks, "texture_panel_marble", UI_EMBOSSX, UI_HELV, curarea->win);
748         if(uiNewPanel(curarea, block, "Marble", "Texture", 640, 0, 318, 204)==0) return;
749         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
750
751         uiBlockSetCol(block, BUTGREEN); 
752         uiDefButS(block, ROW, B_MATPRV, "Soft",                 10, 180, 75, 18, &tex->stype, 2.0, 0.0, 0, 0, "Use soft marble"); 
753         uiDefButS(block, ROW, B_MATPRV, "Sharp",                85, 180, 75, 18, &tex->stype, 2.0, 1.0, 0, 0, "Use more clearly defined marble"); 
754         uiDefButS(block, ROW, B_MATPRV, "Sharper",              160, 180, 75, 18, &tex->stype, 2.0, 2.0, 0, 0, "Use very clear defined marble"); 
755
756         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   10, 160, 100, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
757         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   110, 160, 100, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
758
759         uiBlockSetCol(block, BUTGREY);  
760         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");
761         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");
762         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");
763
764
765 }
766
767 static void texture_panel_clouds(Tex *tex)
768 {
769         uiBlock *block;
770         
771         block= uiNewBlock(&curarea->uiblocks, "texture_panel_clouds", UI_EMBOSSX, UI_HELV, curarea->win);
772         if(uiNewPanel(curarea, block, "Clouds", "Texture", 640, 0, 318, 204)==0) return;
773         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
774
775         uiBlockSetCol(block, BUTGREEN); 
776         uiDefButS(block, ROW, B_MATPRV, "Default",              10, 180, 70, 18, &tex->stype, 2.0, 0.0, 0, 0, "Use standard noise"); 
777         uiDefButS(block, ROW, B_MATPRV, "Color",                80, 180, 70, 18, &tex->stype, 2.0, 1.0, 0, 0, "Let Noise give RGB value"); 
778         uiDefButS(block, ROW, B_MATPRV, "Soft noise",   155, 180, 75, 19, &tex->noisetype, 12.0, 0.0, 0, 0, "Use soft noise");
779         uiDefButS(block, ROW, B_MATPRV, "Hard noise",   230, 180, 80, 19, &tex->noisetype, 12.0, 1.0, 0, 0, "Use hard noise");
780
781         uiBlockSetCol(block, BUTGREY);  
782         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");
783         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");
784
785 }
786
787
788 static void texture_panel_envmap(Tex *tex)
789 {
790         uiBlock *block;
791         EnvMap *env;
792         ID *id;
793         short a, xco, yco, dx, dy;
794         char *strp, str[32];
795         
796         block= uiNewBlock(&curarea->uiblocks, "texture_panel_envmap", UI_EMBOSSX, UI_HELV, curarea->win);
797         if(uiNewPanel(curarea, block, "Envmap", "Texture", 640, 0, 318, 204)==0) return;
798         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
799
800         if(tex->env==0) {
801                 tex->env= RE_add_envmap();
802                 tex->env->object= OBACT;
803         }
804         if(tex->env) {
805                 env= tex->env;
806                 
807                 uiBlockSetCol(block, BUTGREEN);
808                 uiDefButS(block, ROW, B_REDR,   "Static",       10, 180, 100, 19, &env->stype, 2.0, 0.0, 0, 0, "Calculate map only once");
809                 uiDefButS(block, ROW, B_REDR,   "Anim",         110, 180, 100, 19, &env->stype, 2.0, 1.0, 0, 0, "Calculate map each rendering");
810                 uiDefButS(block, ROW, B_ENV_FREE, "Load",       210, 180, 100, 19, &env->stype, 2.0, 2.0, 0, 0, "Load map from disk");
811                 
812                 if(env->stype==ENV_LOAD) {
813                         /* file input */
814                         uiBlockSetCol(block, BUTGREY);
815                         id= (ID *)tex->ima;
816                         IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(G.buts->menunr));
817                         if(strp[0])
818                                 uiDefButS(block, MENU, B_TEXIMABROWSE, strp, 10,135,23,20, &(G.buts->menunr), 0, 0, 0, 0, "Browse");
819                         MEM_freeN(strp);
820                 
821                         uiBlockSetCol(block, BUTSALMON);
822                         uiDefBut(block, BUT, B_LOADTEXIMA1, "Load Image", 10,115,130,20, 0, 0, 0, 0, 0, "Load image - file view");
823                         uiBlockSetCol(block, BUTPURPLE);
824                         uiDefBut(block, BUT, B_LOADTEXIMA, "",          140,115,20,20, 0, 0, 0, 0, 0, "Load image - thumb view");
825                 
826                         if(tex->ima) {
827                                 uiDefBut(block, TEX, B_NAMEIMA, "",                     35,135,255,20, tex->ima->name, 0.0, 79.0, 0, 0, "Texture name");
828                                 sprintf(str, "%d", tex->ima->id.us);
829                                 uiDefBut(block, BUT, 0, str,                            290,135,20,20, 0, 0, 0, 0, 0, "Number of users");
830                                 uiBlockSetCol(block, BUTSALMON);
831                                 uiDefBut(block, BUT, B_RELOADIMA, "Reload",     230,115,80,20, 0, 0, 0, 0, 0, "Reload");
832                         
833                                 if (tex->ima->packedfile) packdummy = 1;
834                                 else packdummy = 0;
835                                 
836                                 uiBlockSetCol(block, BUTGREY);
837                                 uiDefIconButI(block, TOG|BIT|0, B_PACKIMA, ICON_PACKAGE, 205,115,24,20, &packdummy, 0, 0, 0, 0, "Pack/Unpack this Image");
838                         }
839                 }
840                 else {
841                         uiBlockSetCol(block, BUTSALMON);
842                         uiDefBut(block, BUT, B_ENV_FREE, "Free Data",   10,135,100,20, 0, 0, 0, 0, 0, "Release all images associated with environment map");
843                         uiBlockSetCol(block, BUTGREY);
844                         uiDefBut(block, BUT, B_ENV_SAVE, "Save EnvMap", 110,135,100,20, 0, 0, 0, 0, 0, "Save environment map");
845                         uiBlockSetCol(block, BUTSALMON);
846                         uiDefBut(block, BUT, B_ENV_FREE_ALL, "Free all EnvMaps", 210,135,100,20, 0, 0, 0, 0, 0, "Frees all rendered environment maps");
847                 }
848
849                 uiBlockSetCol(block, BUTGREY);
850                 uiDefIDPoinBut(block, test_obpoin_but, B_ENV_OB, "Ob:", 10,90,150,20, &(env->object), "Object name");
851                 if(env->stype!=ENV_LOAD) 
852                         uiDefButS(block, NUM, B_ENV_FREE,       "CubeRes",              160,90,150,20, &env->cuberes, 50, 2048.0, 0, 0, "Set the resolution in pixels");
853
854                 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"),
855                 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"),
856
857                 uiDefButF(block, NUM, REDRAWVIEW3D,     "ClipSta",              10,40,150,20, &env->clipsta, 0.01, 50.0, 100, 0, "Set start value for clipping");
858                 uiDefButF(block, NUM, 0,        "ClipEnd",                                      160,40,150,20, &env->clipend, 0.1, 5000.0, 1000, 0, "Set end value for clipping");
859
860                 uiDefBut(block, LABEL, 0, "Don't render layer:",                10,10,140,22, 0, 0.0, 0.0, 0, 0, "");   
861                 xco= 160;
862                 yco= 10;
863                 dx= 28;
864                 dy= 26;
865                 for(a=0; a<10; a++) {
866                         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");
867                         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");
868                         if(a==4) xco+= 5;
869                 }
870
871         }
872 }
873
874
875 static void texture_panel_image1(Tex *tex)
876 {
877         uiBlock *block;
878         char str[32];
879         
880         block= uiNewBlock(&curarea->uiblocks, "texture_panel1", UI_EMBOSSX, UI_HELV, curarea->win);
881         if(uiNewPanel(curarea, block, "Crop and Anim", "Texture", 960, 0, 318, 204)==0) return;
882         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
883
884         if(tex->imaflag & TEX_ANIM5) {
885
886                 /* print amount of frames anim */
887                 if(tex->ima && tex->ima->anim) {
888                         uiDefBut(block, BUT, B_TEXSETFRAMES, "<",      802, 110, 20, 18, 0, 0, 0, 0, 0, "Paste number of frames in Frames: button");
889                         sprintf(str, "%d frs  ", IMB_anim_get_duration(tex->ima->anim));
890                         uiDefBut(block, LABEL, 0, str,      834, 110, 90, 18, 0, 0, 0, 0, 0, "");
891                         sprintf(str, "%d cur  ", tex->ima->lastframe);
892                         uiDefBut(block, LABEL, 0, str,      834, 90, 90, 18, 0, 0, 0, 0, 0, "");
893                 }
894                 else uiDefBut(block, LABEL, 0, "<",      802, 110, 20, 18, 0, 0, 0, 0, 0, "");
895                                 
896                 uiDefButS(block, NUM, B_MATPRV, "Frames :",     642,110,150,19, &tex->frames, 0.0, 18000.0, 0, 0, "Activate animation option");
897                 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");
898                 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");
899                 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");
900                 uiDefButS(block, NUM, B_MATPRV, "Len:",         642,10,150,19, &tex->len, 0.0, 9000.0, 0, 0, "Set the length of the animation");
901         
902                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,70,73,19, &(tex->fradur[0][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
903                 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");
904                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,50,73,19, &(tex->fradur[1][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
905                 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");
906                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,30,73,19, &(tex->fradur[2][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
907                 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");
908                 uiDefButS(block, NUM, B_MATPRV, "Fra:",         802,10,73,19, &(tex->fradur[3][0]), 0.0, 18000.0, 0, 0, "Montage mode: frame start");
909                 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");
910         
911                 uiBlockSetCol(block, BUTGREEN);
912                 uiDefButS(block, TOG|BIT|6, 0, "Cyclic",                743,60,48,19, &tex->imaflag, 0, 0, 0, 0, "Repeat animation image");
913         }
914 }
915
916
917 static void texture_panel_image(Tex *tex)
918 {
919         uiBlock *block;
920         ID *id;
921         char *strp, str[32];
922         
923         block= uiNewBlock(&curarea->uiblocks, "texture_panel_image", UI_EMBOSSX, UI_HELV, curarea->win);
924         if(uiNewPanel(curarea, block, "Image", "Texture", 640, 0, 318, 204)==0) return;
925         uiSetButLock(tex->id.lib!=0, "Can't edit library data");
926
927         /* types */
928         uiBlockSetCol(block, BUTGREEN);
929         
930         uiDefButS(block, TOG|BIT|0, 0, "InterPol",                      10, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Interpolate pixels of the image");
931         uiDefButS(block, TOG|BIT|1, B_MATPRV, "UseAlpha",       85, 180, 75, 18, &tex->imaflag, 0, 0, 0, 0, "Use the alpha layer");
932         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");
933         uiDefButS(block, TOG|BIT|2, B_MATPRV, "NegAlpha",       235, 180, 75, 18, &tex->flag, 0, 0, 0, 0, "Reverse the alpha value");
934
935         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");
936         uiDefButS(block, TOG|BIT|3, B_IMAPTEST, "Fields",       70, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Work with field images");
937         uiDefButS(block, TOG|BIT|4, B_MATPRV, "Rot90",          120, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Rotate image 90 degrees when rendered");
938         uiDefButS(block, TOG|BIT|7, B_RELOADIMA, "Movie",       170, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "Use a movie for an image");
939         uiDefButS(block, TOG|BIT|8, 0, "Anti",                          220, 160, 40, 18, &tex->imaflag, 0, 0, 0, 0, "Use anti-aliasing");
940         uiDefButS(block, TOG|BIT|10, 0, "StField",                      260, 160, 50, 18, &tex->imaflag, 0, 0, 0, 0, "");
941
942         /* file input */
943         uiBlockSetCol(block, BUTGREY);
944         id= (ID *)tex->ima;
945         IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(G.buts->menunr));
946         if(strp[0])
947                 uiDefButS(block, MENU, B_TEXIMABROWSE, strp, 10,135,23,20, &(G.buts->menunr), 0, 0, 0, 0, "Browse");
948         MEM_freeN(strp);
949
950         uiBlockSetCol(block, BUTSALMON);
951         uiDefBut(block, BUT, B_LOADTEXIMA1, "Load Image", 10,115,130,20, 0, 0, 0, 0, 0, "Load image - file view");
952         uiBlockSetCol(block, BUTPURPLE);
953         uiDefBut(block, BUT, B_LOADTEXIMA, "",          140,115,20,20, 0, 0, 0, 0, 0, "Load image - thumb view");
954
955         uiBlockSetCol(block, BUTGREY);
956
957         if(tex->ima) {
958                 uiDefBut(block, TEX, B_NAMEIMA, "",                     35,135,255,20, tex->ima->name, 0.0, 79.0, 0, 0, "Texture name");
959                 sprintf(str, "%d", tex->ima->id.us);
960                 uiDefBut(block, BUT, 0, str,                            290,135,20,20, 0, 0, 0, 0, 0, "Number of users");
961                 uiBlockSetCol(block, BUTSALMON);
962                 uiDefBut(block, BUT, B_RELOADIMA, "Reload",     230,115,80,20, 0, 0, 0, 0, 0, "Reload");
963         
964                 if (tex->ima->packedfile) packdummy = 1;
965                 else packdummy = 0;
966                 
967                 uiBlockSetCol(block, BUTGREY);
968                 uiDefIconButI(block, TOG|BIT|0, B_PACKIMA, ICON_PACKAGE, 205,115,24,20, &packdummy, 0, 0, 0, 0, "Pack/Unpack this Image");
969         }
970
971         /* crop extend clip */
972         
973         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");
974         
975         uiBlockSetCol(block, BUTGREEN);
976         uiDefButS(block, ROW, 0, "Extend",                      10,70,75,19, &tex->extend, 4.0, 1.0, 0, 0, "Extend the colour of the edge");
977         uiDefButS(block, ROW, 0, "Clip",                        85,70,75,19, &tex->extend, 4.0, 2.0, 0, 0, "Return alpha 0.0 outside image");
978         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");
979         uiDefButS(block, ROW, 0, "Repeat",                      235,70,75,19, &tex->extend, 4.0, 3.0, 0, 0, "Repeat image horizontally and vertically");
980
981         uiBlockSetCol(block, BUTGREY);
982         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");
983         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");
984
985         uiDefButF(block, NUM, B_REDR, "MinX ",          10,28,150,19, &tex->cropxmin, -10.0, 10.0, 10, 0, "Set minimum X value for cropping");
986         uiDefButF(block, NUM, B_REDR, "MaxX ",          160,28,150,19, &tex->cropxmax, -10.0, 10.0, 10, 0, "Set maximum X value for cropping");
987         uiDefButF(block, NUM, B_REDR, "MinY ",          10,8,150,19, &tex->cropymin, -10.0, 10.0, 10, 0, "Set minimum Y value for cropping");
988         uiDefButF(block, NUM, B_REDR, "MaxY ",          160,8,150,19, &tex->cropymax, -10.0, 10.0, 10, 0, "Set maximum Y value for cropping");
989
990 }
991
992 static void drawcolorband_cb(void)
993 {
994         ID *id, *idfrom;
995         
996         buttons_active_id(&id, &idfrom);
997         if( GS(id->name)==ID_TE) {
998                 Tex *tex= (Tex *)id;
999                 drawcolorband(tex->coba, 10,150,300,20);
1000         }
1001 }
1002
1003 static void texture_panel_colors(Tex *tex)
1004 {
1005         uiBlock *block;
1006         CBData *cbd;
1007         
1008         block= uiNewBlock(&curarea->uiblocks, "texture_panel_colors", UI_EMBOSSX, UI_HELV, curarea->win);
1009         uiNewPanelTabbed("Texture", "Texture");
1010         if(uiNewPanel(curarea, block, "Colors", "Texture", 1280, 0, 318, 204)==0) return;
1011                 
1012         
1013         /* COLORBAND */
1014         uiBlockSetCol(block, BUTSALMON);
1015         uiDefButS(block, TOG|BIT|0, B_COLORBAND, "Colorband",10,180,100,20, &tex->flag, 0, 0, 0, 0, "Use colorband");
1016
1017         if(tex->flag & TEX_COLORBAND) {
1018                 uiDefBut(block, BUT, B_ADDCOLORBAND, "Add",             110,180,50,20, 0, 0, 0, 0, 0, "Add new colour to the colorband");
1019                 uiBlockSetCol(block, BUTGREY);
1020                 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");
1021                 uiBlockSetCol(block, BUTSALMON);
1022                 uiDefBut(block, BUT, B_DELCOLORBAND, "Del",             260,180,50,20, 0, 0, 0, 0, 0, "Delete the active colour");
1023                 uiBlockSetCol(block, BUTGREY);
1024                 uiDefBut(block, LABEL, B_DOCOLORBAND, "",               10,150,300,20, 0, 0, 0, 0, 0, "Colorband"); /* only for event! */
1025                 
1026                 uiBlockSetDrawExtraFunc(block, drawcolorband_cb);
1027                 cbd= tex->coba->data + tex->coba->cur;
1028                 
1029                 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");
1030                 uiBlockSetCol(block, BUTGREEN);
1031                 uiDefButS(block, ROW, B_MATPRV, "E",            90,120,20,20, &tex->coba->ipotype, 5.0, 1.0, 0, 0, "Interpolation type Ease");
1032                 uiDefButS(block, ROW, B_MATPRV, "L",            110,120,20,20, &tex->coba->ipotype, 5.0, 0.0, 0, 0, "Interpolation type Linear");
1033                 uiDefButS(block, ROW, B_MATPRV, "S",            130,120,20,20, &tex->coba->ipotype, 5.0, 2.0, 0, 0, "Interpolation type Spline");
1034                 uiBlockSetCol(block, BUTGREY);
1035                 uiDefButF(block, COL, B_BANDCOL, "",            150,120,30,20, &(cbd->r), 0, 0, 0, 0, "");
1036                 uiDefButF(block, NUMSLI, B_MATPRV, "A ",        180,120,130,20, &cbd->a, 0.0, 1.0, 0, 0, "Set the alpha value");
1037                 
1038                 uiDefButF(block, NUMSLI, B_MATPRV, "R ",        10,100,100,20, &cbd->r, 0.0, 1.0, B_BANDCOL, 0, "Set the red value");
1039                 uiDefButF(block, NUMSLI, B_MATPRV, "G ",        110,100,100,20, &cbd->g, 0.0, 1.0, B_BANDCOL, 0, "Set the green value");
1040                 uiDefButF(block, NUMSLI, B_MATPRV, "B ",        210,100,100,20, &cbd->b, 0.0, 1.0, B_BANDCOL, 0, "Set the blue value");
1041                 
1042         }
1043
1044         /* RGB-BRICON */
1045         uiBlockSetCol(block, BUTGREY);
1046         if((tex->flag & TEX_COLORBAND)==0) {
1047                 uiDefButF(block, NUMSLI, B_MATPRV, "R ",                60,80,200,20, &tex->rfac, 0.0, 2.0, 0, 0, "Set the red value");
1048                 uiDefButF(block, NUMSLI, B_MATPRV, "G ",                60,60,200,20, &tex->gfac, 0.0, 2.0, 0, 0, "Set the green value");
1049                 uiDefButF(block, NUMSLI, B_MATPRV, "B ",                60,40,200,20, &tex->bfac, 0.0, 2.0, 0, 0, "Set the blue value");
1050         }
1051         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");
1052         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");
1053
1054 }
1055
1056
1057 static void texture_panel_texture(MTex *mtex, Material *ma, World *wrld, Lamp *la)
1058 {
1059         extern char texstr[15][8]; // butspace.c
1060         MTex *mt=NULL;
1061         uiBlock *block;
1062         ID *id, *idfrom;
1063         int a, yco, loos;
1064         char str[32], *strp;
1065         
1066
1067         block= uiNewBlock(&curarea->uiblocks, "texture_panel_texture", UI_EMBOSSX, UI_HELV, curarea->win);
1068         if(uiNewPanel(curarea, block, "Texture", "Texture", 320, 0, 318, 204)==0) return;
1069
1070         /* first do the browse but */
1071         buttons_active_id(&id, &idfrom);
1072
1073         uiBlockSetCol(block, BUTPURPLE);
1074         if(ma) {
1075                 std_libbuttons(block, 10, 180, 0, NULL, B_TEXBROWSE, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1076         }
1077         else if(wrld) {
1078                 std_libbuttons(block, 10, 180, 0, NULL, B_WTEXBROWSE, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1079         }
1080         else if(la) {
1081                 std_libbuttons(block, 10, 180, 0, NULL, B_LTEXBROWSE, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1082         }
1083
1084
1085         /* From button: removed */
1086
1087         /* CHANNELS */
1088         yco= 10;
1089         for(a= 7; a>=0; a--) {
1090                 
1091                 if(ma) mt= ma->mtex[a];
1092                 else if(wrld && a<6)  mt= wrld->mtex[a];
1093                 else if(la && a<6)  mt= la->mtex[a];
1094                 
1095                 if(mt && mt->tex) splitIDname(mt->tex->id.name+2, str, &loos);
1096                 else strcpy(str, "");
1097                 str[14]= 0;
1098
1099                 if(ma) {
1100                         uiDefButC(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(ma->texact), 0.0, (float)a, 0, 0, "Linked channel");
1101                         yco+= 20;
1102                 }
1103                 else if(wrld && a<6) {
1104                         uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(wrld->texact), 0.0, (float)a, 0, 0, "");
1105                         yco+= 20;
1106                 }
1107                 else if(la && a<6) {
1108                         uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(la->texact), 0.0, (float)a, 0, 0, "");
1109                         yco+= 20;
1110                 }
1111                 
1112         }
1113
1114         /* TYPES */
1115         if(mtex && mtex->tex) {
1116                 Tex *tex= mtex->tex;
1117                 int xco;
1118
1119                 uiBlockSetCol(block, BUTGREEN);
1120                 
1121                 uiSetButLock(tex->id.lib!=0, "Can't edit library data");
1122                 xco= 275;
1123                 uiDefButS(block, ROW, B_TEXTYPE, texstr[0],                     160, 110, 70, 20, &tex->type, 1.0, 0.0, 0, 0, "Default");
1124
1125                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_IMAGE],     160, 90, 70, 20, &tex->type, 1.0, (float)TEX_IMAGE, 0, 0, "Use image texture");
1126                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_ENVMAP],240, 90, 70, 20, &tex->type, 1.0, (float)TEX_ENVMAP, 0, 0, "Use environment maps");
1127
1128                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_CLOUDS],160, 70, 70, 20, &tex->type, 1.0, (float)TEX_CLOUDS, 0, 0, "Use clouds texture");
1129                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_MARBLE],240, 70, 70, 20, &tex->type, 1.0, (float)TEX_MARBLE, 0, 0, "Use marble texture");
1130
1131                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_STUCCI],160, 50, 70, 20, &tex->type, 1.0, (float)TEX_STUCCI, 0, 0, "Use strucci texture");
1132                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_WOOD],      240, 50, 70, 20, &tex->type, 1.0, (float)TEX_WOOD, 0, 0, "Use wood texture");
1133
1134                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_MAGIC],     160, 30, 70, 20, &tex->type, 1.0, (float)TEX_MAGIC, 0, 0, "Use magic texture");
1135                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_BLEND],     240, 30, 70, 20, &tex->type, 1.0, (float)TEX_BLEND, 0, 0, "Use blend texture");
1136
1137                 uiDefButS(block, ROW, B_TEXTYPE, texstr[TEX_NOISE],     160, 10, 70, 20, &tex->type, 1.0, (float)TEX_NOISE, 0, 0, "Use noise texture");
1138                 if(tex->plugin && tex->plugin->doit) strp= tex->plugin->pname; else strp= texstr[TEX_PLUGIN];
1139                 uiDefButS(block, ROW, B_TEXTYPE, strp,                          240, 10, 70, 20, &tex->type, 1.0, (float)TEX_PLUGIN, 0, 0, "Use plugin");
1140         }
1141         else {
1142                 // label to avoid centering
1143                 uiDefBut(block, LABEL, 0, " ",  240, 10, 70, 20, 0, 0, 0, 0, 0, "");
1144         }
1145 }
1146
1147 static void texture_panel_preview(int preview)
1148 {
1149         uiBlock *block;
1150         
1151         block= uiNewBlock(&curarea->uiblocks, "texture_panel_preview", UI_EMBOSSX, UI_HELV, curarea->win);
1152         if(uiNewPanel(curarea, block, "Preview", "Texture", 0, 0, 318, 204)==0) return;
1153         
1154         if(preview) uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1155
1156         // label to force a boundbox for buttons not to be centered
1157         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1158         
1159         uiBlockSetCol(block, BUTGREEN);
1160
1161         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");
1162         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");
1163         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");
1164
1165         uiDefBut(block, BUT, B_DEFTEXVAR, "Default Vars",200,10,80,20, 0, 0, 0, 0, 0, "Return to standard values");
1166
1167 }
1168
1169
1170
1171 /* *************************** RADIO ******************************** */
1172
1173 void do_radiobuts(unsigned short event)
1174 {
1175         Radio *rad;
1176         int phase;
1177         
1178         phase= rad_phase();
1179         rad= G.scene->radio;
1180         
1181         switch(event) {
1182         case B_RAD_ADD:
1183                 add_radio();
1184                 allqueue(REDRAWBUTSSHADING, 0);
1185                 allqueue(REDRAWVIEW3D, 0);
1186                 break;
1187         case B_RAD_DELETE:
1188                 delete_radio();
1189                 allqueue(REDRAWBUTSSHADING, 0);
1190                 allqueue(REDRAWVIEW3D, 0);
1191                 break;
1192         case B_RAD_FREE:
1193                 freeAllRad();
1194                 allqueue(REDRAWBUTSSHADING, 0);
1195                 allqueue(REDRAWVIEW3D, 0);
1196                 break;
1197         case B_RAD_COLLECT:
1198                 rad_collect_meshes();
1199                 allqueue(REDRAWBUTSSHADING, 0);
1200                 allqueue(REDRAWVIEW3D, 0);
1201                 break;
1202         case B_RAD_INIT:
1203                 if(phase==RAD_PHASE_PATCHES) {
1204                         rad_limit_subdivide();
1205                         allqueue(REDRAWBUTSSHADING, 0);
1206                         allqueue(REDRAWVIEW3D, 0);
1207                 }
1208                 break;
1209         case B_RAD_SHOOTP:
1210                 if(phase==RAD_PHASE_PATCHES) {
1211                         waitcursor(1);
1212                         rad_subdivshootpatch();
1213                         allqueue(REDRAWBUTSSHADING, 0);
1214                         allqueue(REDRAWVIEW3D, 0);
1215                         waitcursor(0);
1216                 }
1217                 break;
1218         case B_RAD_SHOOTE:
1219                 if(phase==RAD_PHASE_PATCHES) {
1220                         waitcursor(1);
1221                         rad_subdivshootelem();
1222                         allqueue(REDRAWBUTSSHADING, 0);
1223                         allqueue(REDRAWVIEW3D, 0);
1224                         waitcursor(0);
1225                 }
1226                 break;
1227         case B_RAD_GO:
1228                 if(phase==RAD_PHASE_PATCHES) {
1229                         waitcursor(1);
1230                         rad_go();
1231                         waitcursor(0);
1232                         allqueue(REDRAWBUTSSHADING, 0);
1233                         allqueue(REDRAWVIEW3D, 0);
1234                 }
1235                 break;
1236         case B_RAD_LIMITS:
1237                 rad_setlimits();
1238                 allqueue(REDRAWVIEW3D, 0);
1239                 allqueue(REDRAWBUTSSHADING, 0);
1240                 break;
1241         case B_RAD_FAC:
1242                 set_radglobal();
1243                 if(phase & RAD_PHASE_FACES) make_face_tab();
1244                 else make_node_display();
1245                 allqueue(REDRAWVIEW3D, 0);
1246                 break;
1247         case B_RAD_NODELIM:
1248                 if(phase & RAD_PHASE_FACES) {
1249                         set_radglobal();
1250                         removeEqualNodes(rad->nodelim);
1251                         make_face_tab();
1252                         allqueue(REDRAWVIEW3D, 0);
1253                         allqueue(REDRAWBUTSSHADING, 0);
1254                 }
1255                 break;
1256         case B_RAD_NODEFILT:
1257                 if(phase & RAD_PHASE_FACES) {
1258                         set_radglobal();
1259                         filterNodes();
1260                         make_face_tab();
1261                         allqueue(REDRAWVIEW3D, 0);
1262                 }
1263                 break;
1264         case B_RAD_FACEFILT:
1265                 if(phase & RAD_PHASE_FACES) {
1266                         filterFaces();
1267                         allqueue(REDRAWVIEW3D, 0);
1268                 }
1269                 break;
1270         case B_RAD_DRAW:
1271                 set_radglobal();
1272                 allqueue(REDRAWVIEW3D, 0);
1273                 break;
1274         case B_RAD_ADDMESH:
1275                 if(phase & RAD_PHASE_FACES) rad_addmesh();
1276                 allqueue(REDRAWVIEW3D, 0);
1277                 break;
1278         case B_RAD_REPLACE:
1279                 if(phase & RAD_PHASE_FACES) rad_replacemesh();
1280                 allqueue(REDRAWVIEW3D, 0);
1281                 break;
1282         }
1283
1284 }
1285
1286
1287 #if 0
1288         char str[128];
1289                 
1290                 rad_status_str(str);
1291                 cpack(0);
1292                 glRasterPos2i(210, 189);
1293                 BMF_DrawString(uiBlockGetCurFont(block), str);
1294
1295 #endif
1296
1297 static void radio_panel_calculation(Radio *rad, int flag)
1298 {
1299         uiBlock *block;
1300         
1301         block= uiNewBlock(&curarea->uiblocks, "radio_panel_calculation", UI_EMBOSSX, UI_HELV, curarea->win);
1302         if(uiNewPanel(curarea, block, "Calculation", "Radio", 640, 0, 318, 204)==0) return;
1303         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1304
1305         if(flag == RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
1306         uiDefBut(block,  BUT, B_RAD_GO, "GO",                                   0, 0, 10, 15, NULL, 0, 0, 0, 0, "Start the radiosity simulation");
1307
1308         uiBlockSetCol(block, BUTGREY);
1309         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");
1310         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");
1311
1312         if(flag == RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
1313         else uiBlockSetCol(block, BUTGREY);
1314         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");
1315         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");
1316
1317         uiBlockSetCol(block, BUTGREY);
1318         uiDefButI(block,  NUM, 0, "MaxEl:",                                             3, 0, 10, 10, &rad->maxnode, 1.0, 250000.0, 0, 0, "Set the maximum allowed number of elements");
1319         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");
1320
1321         if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
1322         else uiBlockSetCol(block, BUTGREY);
1323         uiDefBut(block,  BUT, B_RAD_FACEFILT, "FaceFilter",             4, 0, 10, 10, NULL, 0, 0, 0, 0, "Force an extra smoothing");
1324         uiDefBut(block,  BUT, B_RAD_NODEFILT, "Element Filter", 4, 0, 10, 10, NULL, 0, 0, 0, 0, "Filter elements to remove aliasing artefacts");
1325
1326         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'");
1327         uiBlockSetCol(block, BUTGREY);
1328         uiDefButS(block,  NUM, 0, "Lim:",                                               5, 0, 10, 10, &rad->nodelim, 0.0, 50.0, 0, 0, "Set the range for removing doubles");
1329
1330
1331 }
1332
1333 static void radio_panel_tool(Radio *rad, int flag)
1334 {
1335         uiBlock *block;
1336         
1337         block= uiNewBlock(&curarea->uiblocks, "radio_panel_tool", UI_EMBOSSX, UI_HELV, curarea->win);
1338         if(uiNewPanel(curarea, block, "Radio Tool", "Radio", 320, 0, 318, 204)==0) return;
1339         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1340
1341         if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTPURPLE);
1342         else uiBlockSetCol(block, BUTSALMON);
1343         uiDefBut(block,  BUT, B_RAD_COLLECT, "Collect Meshes",  0, 0, 10, 15, NULL, 0, 0, 0, 0, "Convert selected and visible meshes to patches");
1344
1345         if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, BUTSALMON);
1346         else uiBlockSetCol(block, BUTGREY);
1347         uiDefBut(block,  BUT, B_RAD_FREE, "Free Radio Data",    0, 0, 10, 15, NULL, 0, 0, 0, 0, "Release all memory used by Radiosity");        
1348
1349         if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, BUTSALMON);
1350         else uiBlockSetCol(block, BUTGREY);
1351         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");
1352         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");
1353
1354         uiBlockSetCol(block, BUTGREEN);
1355         uiDefButS(block,  ROW, B_RAD_DRAW, "Wire",                      2, 0, 10, 10, &rad->drawtype, 0.0, 0.0, 0, 0, "Enable wireframe drawmode");
1356         uiDefButS(block,  ROW, B_RAD_DRAW, "Solid",                     2, 0, 10, 10, &rad->drawtype, 0.0, 1.0, 0, 0, "Enable solid drawmode");
1357         uiDefButS(block,  ROW, B_RAD_DRAW, "Gour",                      2, 0, 10, 10, &rad->drawtype, 0.0, 2.0, 0, 0, "Enable Gourad drawmode");
1358         uiBlockSetCol(block, BUTGREY);
1359         uiDefButS(block,  TOG|BIT|0, B_RAD_DRAW, "ShowLim", 2, 0, 10, 10, &rad->flag, 0, 0, 0, 0, "Visualize patch and element limits");
1360         uiDefButS(block,  TOG|BIT|1, B_RAD_DRAW, "Z",           2, 0, 3, 10, &rad->flag, 0, 0, 0, 0, "Draw limits different");
1361
1362         uiBlockSetCol(block, BUTGREY);
1363         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");
1364         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");
1365         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");
1366         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");
1367
1368
1369
1370         uiBlockSetCol(block, BUTSALMON);
1371         uiDefBut(block,  BUT, B_RAD_INIT, "Limit Subdivide", 5, 0, 10, 10, NULL, 0, 0, 0, 0, "Subdivide patches");
1372 }
1373
1374
1375 static void radio_panel_render(Radio *rad)
1376 {
1377         uiBlock *block;
1378         
1379         block= uiNewBlock(&curarea->uiblocks, "radio_panel_render", UI_EMBOSSX, UI_HELV, curarea->win);
1380         if(uiNewPanel(curarea, block, "Radio Render", "Radio", 0, 0, 318, 204)==0) return;
1381         uiAutoBlock(block, 210, 30, 230, 150, UI_BLOCK_ROWS);
1382
1383         uiBlockSetCol(block, BUTGREY);
1384         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");
1385         uiDefButS(block,  NUM, 0, "Max Iterations:",            2, 0, 10, 15, &rad->maxiter, 0.0, 10000.0, 0, 0, "Maximum number of radiosity rounds");
1386         uiDefButF(block,  NUM, B_RAD_FAC, "Mult:",                      3, 0, 10, 15, &rad->radfac, 0.001, 250.0, 100, 0, "Mulitply the energy values");
1387         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");
1388         uiDefButF(block,  NUMSLI, 0, "Convergence:",            5, 0, 10, 10, &rad->convergence, 0.0, 1.0, 10, 0, "Set the lower threshold of unshot energy");
1389 }
1390
1391
1392 /* ***************************** WORLD ************************** */
1393
1394 void do_worldbuts(unsigned short event)
1395 {
1396         World *wrld;
1397         MTex *mtex;
1398         
1399         switch(event) {
1400         case B_TEXCLEARWORLD:
1401                 wrld= G.buts->lockpoin;
1402                 mtex= wrld->mtex[ wrld->texact ];
1403                 if(mtex) {
1404                         if(mtex->tex) mtex->tex->id.us--;
1405                         MEM_freeN(mtex);
1406                         wrld->mtex[ wrld->texact ]= 0;
1407                         allqueue(REDRAWBUTSSHADING, 0);
1408                         allqueue(REDRAWOOPS, 0);
1409                         BIF_preview_changed(G.buts);
1410                 }
1411                 break;
1412         }
1413 }
1414
1415 static void world_panel_mapto(World *wrld)
1416 {
1417         uiBlock *block;
1418         MTex *mtex;
1419         
1420         block= uiNewBlock(&curarea->uiblocks, "world_panel_mapto", UI_EMBOSSX, UI_HELV, curarea->win);
1421         uiNewPanelTabbed("Texture and Input", "World");
1422         if(uiNewPanel(curarea, block, "Map To", "World", 1280, 0, 318, 204)==0) return;
1423
1424         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1425
1426         mtex= wrld->mtex[ wrld->texact ];
1427         if(mtex==0) {
1428                 mtex= &emptytex;
1429                 default_mtex(mtex);
1430                 mtex->texco= TEXCO_VIEW;
1431         }
1432
1433         /* TEXTURE OUTPUT */
1434         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Stencil",        920,114,52,18, &(mtex->texflag), 0, 0, 0, 0, "Use stencil mode");
1435         uiDefButS(block, TOG|BIT|2, B_MATPRV, "Neg",            974,114,38,18, &(mtex->texflag), 0, 0, 0, 0, "Inverse texture operation");
1436         uiDefButS(block, TOG|BIT|0, B_MATPRV, "RGBtoInt",       1014,114,69,18, &(mtex->texflag), 0, 0, 0, 0, "Use RGB values for intensity texure");
1437         
1438         uiDefButF(block, COL, B_MTEXCOL, "",                            920,100,163,12, &(mtex->r), 0, 0, 0, 0, "");
1439         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");
1440         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");
1441         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");
1442         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");
1443         
1444         /* MAP TO */
1445         uiBlockSetCol(block, BUTGREEN);
1446         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");
1447         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");
1448         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");
1449         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");
1450         
1451         uiBlockSetCol(block, BUTGREY);
1452         uiDefButS(block, ROW, B_MATPRV, "Blend",                        1087,114,48,18, &(mtex->blendtype), 9.0, (float)MTEX_BLEND, 0, 0, "The texture blends the values");
1453         uiDefButS(block, ROW, B_MATPRV, "Mul",                  1136,114,44,18, &(mtex->blendtype), 9.0, (float)MTEX_MUL, 0, 0, "The texture multiplies the values");
1454         uiDefButS(block, ROW, B_MATPRV, "Add",                  1182,114,41,18, &(mtex->blendtype), 9.0, (float)MTEX_ADD, 0, 0, "The texture adds the values");
1455         uiDefButS(block, ROW, B_MATPRV, "Sub",                  1226,114,40,18, &(mtex->blendtype), 9.0, (float)MTEX_SUB, 0, 0, "The texture subtracts the values");
1456         
1457         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");
1458         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");
1459         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");
1460
1461 }
1462
1463 static void world_panel_texture(World *wrld)
1464 {
1465         uiBlock *block;
1466         MTex *mtex;
1467         ID *id;
1468         int a, loos;
1469         char str[64], *strp;
1470         
1471         block= uiNewBlock(&curarea->uiblocks, "world_panel_texture", UI_EMBOSSX, UI_HELV, curarea->win);
1472         if(uiNewPanel(curarea, block, "Texture and Input", "World", 960, 0, 318, 204)==0) return;
1473
1474         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1475
1476         /* TEX CHANNELS */
1477         uiBlockSetCol(block, BUTGREY);
1478         
1479         for(a= 0; a<6; a++) {
1480                 mtex= wrld->mtex[a];
1481                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
1482                 else strcpy(str, "");
1483                 str[10]= 0;
1484                 uiDefButS(block, ROW, REDRAWBUTSSHADING, str,10, 140-20*a, 80, 20, &(wrld->texact), 3.0, (float)a, 0, 0, "Texture channel");
1485         }
1486         
1487         mtex= wrld->mtex[ wrld->texact ];
1488         if(mtex==0) {
1489                 mtex= &emptytex;
1490                 default_mtex(mtex);
1491                 mtex->texco= TEXCO_VIEW;
1492         }
1493         
1494         /* TEXTUREBLOCK SELECT */
1495         id= (ID *)mtex->tex;
1496         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
1497         uiDefButS(block, MENU, B_WTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Browse");
1498         MEM_freeN(strp);
1499         
1500         if(id) {
1501                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,163,19, id->name+2, 0.0, 18.0, 0, 0, "Specify the texture name");
1502                 sprintf(str, "%d", id->us);
1503                 uiDefBut(block, BUT, 0, str,                            196,140,21,19, 0, 0, 0, 0, 0, "Number of users");
1504                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 241,140,21,19, 0, 0, 0, 0, 0, "Auto assign name to texture");
1505                 if(id->lib) {
1506                         if(wrld->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,      1019,146,21,19, 0, 0, 0, 0, 0, "");
1507                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
1508                 }
1509                 uiBlockSetCol(block, BUTSALMON);
1510                 uiDefBut(block, BUT, B_TEXCLEARWORLD, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erase link to texture");
1511                 uiBlockSetCol(block, BUTGREY);
1512         }
1513         
1514
1515         /* TEXCO */
1516         uiBlockSetCol(block, BUTGREEN);
1517         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");
1518         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");
1519         uiDefIDPoinBut(block, test_obpoin_but, B_MATPRV, "", 100,110,100,19, &(mtex->object), "");
1520         
1521         uiBlockSetCol(block, BUTGREY);  
1522         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");
1523         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");
1524         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");
1525         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");
1526         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");
1527         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");    
1528
1529
1530 }
1531
1532 static void world_panel_mistaph(World *wrld)
1533 {
1534         uiBlock *block;
1535         
1536         block= uiNewBlock(&curarea->uiblocks, "world_panel_mistaph", UI_EMBOSSX, UI_HELV, curarea->win);
1537         if(uiNewPanel(curarea, block, "Mist Stars Physics", "World", 640, 0, 318, 204)==0) return;
1538
1539         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1540
1541         uiDefBut(block, MENU|SHO, 1, "Physics %t|None %x1|Sumo %x2|ODE %x3 |Dynamo %x4|",       
1542                         10,180,140,19, &wrld->pad1, 0, 0, 0, 0, "Physics Engine");
1543         
1544         /* Gravitation for the game worlds */
1545         uiDefButF(block, NUMSLI,0, "Grav ", 150,180,150,19,     &(wrld->gravity), 0.0, 25.0, 0, 0,  "Gravitation constant of the game world.");
1546
1547
1548         uiBlockSetCol(block, BUTBLUE);
1549         uiDefButS(block, TOG|BIT|0,REDRAWVIEW3D,"Mist", 10,110,140,19, &wrld->mode, 0, 0, 0, 0, "Enable mist");
1550
1551         uiBlockSetCol(block, BUTGREEN);
1552         uiDefButS(block, ROW, B_DIFF, "Qua", 10, 90, 40, 19, &wrld->mistype, 1.0, 0.0, 0, 0, "Use quadratic progression");
1553         uiDefButS(block, ROW, B_DIFF, "Lin", 50, 90, 50, 19, &wrld->mistype, 1.0, 1.0, 0, 0, "Use linear progression");
1554         uiDefButS(block, ROW, B_DIFF, "Sqr", 100, 90, 50, 19, &wrld->mistype, 1.0, 2.0, 0, 0, "Use inverse quadratic progression");
1555         
1556         uiBlockSetCol(block, BUTGREY);
1557         uiDefButF(block, NUM,REDRAWVIEW3D, "Sta:",10,70,140,19, &wrld->miststa, 0.0, 1000.0, 10, 0, "Specify the starting distance of the mist");
1558         uiDefButF(block, NUM,REDRAWVIEW3D, "Di:",10,50,140,19, &wrld->mistdist, 0.0,1000.0, 10, 00, "Specify the depth of the mist");
1559         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");
1560         uiDefButF(block, NUMSLI, 0, "Misi",             10,10,140,19,   &(wrld->misi), 0., 1.0, 0, 0, "Set the mist intensity");
1561
1562         uiBlockSetCol(block, BUTBLUE);
1563         uiDefButS(block, TOG|BIT|1,B_DIFF,      "Stars",160,110,140,19, &wrld->mode, 0, 0, 0, 0, "Enable stars");
1564         uiBlockSetCol(block, BUTGREY);
1565         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");
1566         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");
1567         uiDefButF(block, NUMSLI,B_DIFF,"Size:",         160,30,140,19, &(wrld->starsize), 0.0, 10.0, 10, 0, "Specify the average screen dimension");
1568         uiDefButF(block, NUMSLI,B_DIFF,"Colnoise:",     160,10,140,19, &(wrld->starcolnoise), 0.0, 1.0, 100, 0, "Randomize starcolour");
1569
1570
1571 }
1572
1573 static void world_panel_world(World *wrld)
1574 {
1575         uiBlock *block;
1576         ID *id, *idfrom;
1577         short xco;
1578         
1579         block= uiNewBlock(&curarea->uiblocks, "world_panel_world", UI_EMBOSSX, UI_HELV, curarea->win);
1580         if(uiNewPanel(curarea, block, "World", "World", 320, 0, 318, 204)==0) return;
1581
1582         /* first do the browse but */
1583         buttons_active_id(&id, &idfrom);
1584
1585         uiBlockSetCol(block, BUTPURPLE);
1586         xco= std_libbuttons(block, 10, 180, 0, NULL, B_WORLDBROWSE, id, idfrom, &(G.buts->menunr), B_WORLDALONE, B_WORLDLOCAL, B_WORLDDELETE, 0, B_KEEPDATA);
1587
1588         if(wrld==NULL) return;
1589         
1590         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1591         uiBlockSetCol(block, BUTGREY);
1592
1593         uiDefButF(block, COL, B_COLHOR, "",                     10,150,150,19, &wrld->horr, 0, 0, 0, 0, "");
1594         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");
1595         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");
1596         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");
1597
1598         uiDefButF(block, COL, B_COLZEN, "",                     160,150,150,19, &wrld->zenr, 0, 0, 0, 0, "");
1599         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");
1600         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");
1601         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");
1602
1603         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");
1604         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");
1605         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");
1606         uiDefButF(block, NUMSLI,0, "Expos ",            160,10,155,19,  &(wrld->exposure), 0.2, 5.0, 0, 0, "Set the lighting time, exposure");
1607
1608
1609 }
1610
1611 static void world_panel_preview(World *wrld)
1612 {
1613         uiBlock *block;
1614         
1615         /* name "Preview" is abused to detect previewrender offset panel */
1616         block= uiNewBlock(&curarea->uiblocks, "world_panel_preview", UI_EMBOSSX, UI_HELV, curarea->win);
1617         if(uiNewPanel(curarea, block, "Preview", "World", 0, 0, 318, 204)==0) return;
1618         
1619         if(wrld==NULL) return;
1620
1621         uiSetButLock(wrld->id.lib!=0, "Can't edit library data");
1622
1623         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1624
1625         // label to force a boundbox for buttons not to be centered
1626         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1627
1628         uiBlockSetCol(block, BUTGREEN);
1629
1630         uiDefButS(block, TOG|BIT|1,B_MATPRV,"Real",     200,175,80,25, &wrld->skytype, 0, 0, 0, 0, "Render background with real horizon");
1631         uiDefButS(block, TOG|BIT|0,B_MATPRV,"Blend",200,150,80,19, &wrld->skytype, 0, 0, 0, 0, "Render background with natural progression");
1632         uiDefButS(block, TOG|BIT|2,B_MATPRV,"Paper",200,125,80,19, &wrld->skytype, 0, 0, 0, 0, "Flatten blend or texture coordinates");
1633         
1634 }
1635
1636
1637
1638 /* ************************ LAMP *************************** */
1639
1640 void do_lampbuts(unsigned short event)
1641 {
1642         Lamp *la;
1643         MTex *mtex;
1644                 
1645         switch(event) {
1646         case B_LAMPREDRAW:
1647                 BIF_preview_changed(G.buts);
1648                 allqueue(REDRAWVIEW3D, 0);
1649                 break;
1650         case B_TEXCLEARLAMP:
1651                 la= G.buts->lockpoin;
1652                 mtex= la->mtex[ la->texact ];
1653                 if(mtex) {
1654                         if(mtex->tex) mtex->tex->id.us--;
1655                         MEM_freeN(mtex);
1656                         la->mtex[ la->texact ]= 0;
1657                         allqueue(REDRAWBUTSSHADING, 0);
1658                         allqueue(REDRAWOOPS, 0);
1659                         BIF_preview_changed(G.buts);
1660                 }
1661                 break;
1662       case B_SBUFF: 
1663                 { 
1664                         la= G.buts->lockpoin; 
1665                         la->bufsize = la->bufsize&=(~15); 
1666                         allqueue(REDRAWBUTSSHADING, 0); 
1667                         allqueue(REDRAWOOPS, 0); 
1668                         /*la->bufsize = la->bufsize % 64;*/ 
1669                 } 
1670                 break; 
1671         }
1672         
1673         if(event) freefastshade();
1674 }
1675
1676
1677 static void lamp_panel_mapto(Object *ob, Lamp *la)
1678 {
1679         uiBlock *block;
1680         MTex *mtex;
1681         
1682         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_mapto", UI_EMBOSSX, UI_HELV, curarea->win);
1683         uiNewPanelTabbed("Texture and Input", "Lamp");
1684         if(uiNewPanel(curarea, block, "Map To", "Lamp", 1280, 0, 318, 204)==0) return;
1685
1686         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1687
1688         mtex= la->mtex[ la->texact ];
1689         if(mtex==0) {
1690                 mtex= &emptytex;
1691                 default_mtex(mtex);
1692                 mtex->texco= TEXCO_VIEW;
1693         }
1694
1695         /* TEXTURE OUTPUT */
1696         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Stencil",        920,114,52,18, &(mtex->texflag), 0, 0, 0, 0, "Set the mapping to stencil mode");
1697         uiDefButS(block, TOG|BIT|2, B_MATPRV, "Neg",            974,114,38,18, &(mtex->texflag), 0, 0, 0, 0, "Apply the inverse of the texture");
1698         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");
1699         
1700         uiDefButF(block, COL, B_MTEXCOL, "",                            920,100,163,12, &(mtex->r), 0, 0, 0, 0, "");
1701         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");
1702         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");
1703         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");
1704         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");
1705         
1706         /* MAP TO */
1707         uiBlockSetCol(block, BUTGREEN);
1708         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");
1709         
1710         uiBlockSetCol(block, BUTGREY);
1711         uiDefButS(block, ROW, B_MATPRV, "Blend",                        1087,114,48,18, &(mtex->blendtype), 9.0, (float)MTEX_BLEND, 0, 0, "Mix the values");
1712         uiDefButS(block, ROW, B_MATPRV, "Mul",                  1136,114,44,18, &(mtex->blendtype), 9.0, (float)MTEX_MUL, 0, 0, "Multiply the values");
1713         uiDefButS(block, ROW, B_MATPRV, "Add",                  1182,114,41,18, &(mtex->blendtype), 9.0, (float)MTEX_ADD, 0, 0, "Add the values");
1714         uiDefButS(block, ROW, B_MATPRV, "Sub",                  1226,114,40,18, &(mtex->blendtype), 9.0, (float)MTEX_SUB, 0, 0, "Subtract the values");
1715         
1716         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");
1717         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");
1718         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");
1719
1720 }
1721
1722
1723 static void lamp_panel_texture(Object *ob, Lamp *la)
1724 {
1725         uiBlock *block;
1726         MTex *mtex;
1727         ID *id;
1728         int a, loos;
1729         char *strp, str[64];
1730         
1731         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_texture", UI_EMBOSSX, UI_HELV, curarea->win);
1732         if(uiNewPanel(curarea, block, "Texture and Input", "Lamp", 960, 0, 318, 204)==0) return;
1733
1734         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1735
1736         /* TEX CHANNELS */
1737         uiBlockSetCol(block, BUTGREY);
1738         for(a= 0; a<6; a++) {
1739                 mtex= la->mtex[a];
1740                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
1741                 else strcpy(str, "");
1742                 str[10]= 0;
1743                 uiDefButS(block, ROW, B_REDR, str,      10, 140-20*a, 80, 20, &(la->texact), 3.0, (float)a, 0, 0, "");
1744         }
1745         
1746         mtex= la->mtex[ la->texact ];
1747         if(mtex==0) {
1748                 mtex= &emptytex;
1749                 default_mtex(mtex);
1750                 mtex->texco= TEXCO_VIEW;
1751         }
1752
1753         /* TEXTUREBLOK SELECT */
1754         id= (ID *)mtex->tex;
1755         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
1756         
1757         /* doesnt work, because lockpoin points to lamp, not to texture */
1758         uiDefButS(block, MENU, B_LTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Select an existing texture, or create new");   
1759         MEM_freeN(strp);
1760         
1761         if(id) {
1762                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,163,19, id->name+2, 0.0, 18.0, 0, 0, "Name of the texture block");
1763                 sprintf(str, "%d", id->us);
1764                 uiDefBut(block, BUT, 0, str,                    196,140,21,19, 0, 0, 0, 0, 0, "Select an existing texture, or create new");
1765                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 241,140,21,19, 0, 0, 0, 0, 0, "Auto assign a name to the texture");
1766                 if(id->lib) {
1767                         if(la->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,140,21,19, 0, 0, 0, 0, 0, "");
1768                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
1769                 }
1770                 uiBlockSetCol(block, BUTSALMON);
1771                 uiDefBut(block, BUT, B_TEXCLEARLAMP, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erase link to texture");
1772                 uiBlockSetCol(block, BUTGREY);
1773         }
1774
1775         /* TEXCO */
1776         uiBlockSetCol(block, BUTGREEN);
1777         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");
1778         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");
1779         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");
1780         uiDefIDPoinBut(block, test_obpoin_but, B_MATPRV, "", 100,90,200,20, &(mtex->object), "");
1781         
1782         uiBlockSetCol(block, BUTGREY);  
1783         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");
1784         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");
1785         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");
1786         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");
1787         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");
1788         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");
1789
1790 }
1791
1792 static void lamp_panel_spot(Object *ob, Lamp *la)
1793 {
1794         uiBlock *block;
1795         float grid=0.0;
1796         
1797         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_spot", UI_EMBOSSX, UI_HELV, curarea->win);
1798         if(uiNewPanel(curarea, block, "Spot", "Lamp", 640, 0, 318, 204)==0) return;
1799
1800         if(G.vd) grid= G.vd->grid; 
1801         if(grid<1.0) grid= 1.0;
1802
1803         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1804
1805         uiBlockSetCol(block, BUTBLUE);
1806         uiDefButS(block, TOG|BIT|0, REDRAWVIEW3D, "Shadows",10,150,80,19,&la->mode, 0, 0, 0, 0, "Let lamp produce shadows");
1807         uiDefButS(block, TOG|BIT|5, 0,"OnlyShadow",                     10,130,80,19,&la->mode, 0, 0, 0, 0, "Render shadow only");
1808         uiDefButS(block, TOG|BIT|7, B_LAMPREDRAW,"Square",      10,90,80,19,&la->mode, 0, 0, 0, 0, "Use square spotbundles");
1809         uiDefButS(block, TOG|BIT|1, 0,"Halo",                           10,50,80,19,&la->mode, 0, 0, 0, 0, "Render spotlights with a volumetric halo"); 
1810
1811         uiBlockSetCol(block, BUTGREY);
1812         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");
1813         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");
1814         uiDefButF(block, NUMSLI,0,"HaloInt ",                   100,130,200,19,&la->haint, 0.0, 5.0, 0, 0, "Set the intensity of the spot halo");
1815
1816
1817         uiDefButS(block, NUMSLI,B_SBUFF,"ShadowBuffSize:", 100,110,200,19,      &la->bufsize,512,5120, 0, 0, "Set the size of the shadow buffer");
1818
1819         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");
1820         uiDefButF(block, NUM,REDRAWVIEW3D,"ClipEnd:",   200,70,100,19,&la->clipend, 1.0, 5000.0*grid, 100, 0, "Set the shadow map clip end");
1821
1822         uiDefButS(block, NUM,0,"Samples:",              100,30,100,19,  &la->samp,1.0,16.0, 0, 0, "Number of shadow map samples");
1823         uiDefButS(block, NUM,0,"Halo step:",    200,30,100,19,  &la->shadhalostep, 0.0, 12.0, 0, 0, "Volumetric halo sampling frequency");
1824         uiDefButF(block, NUM,0,"Bias:",                 100,10,100,19,  &la->bias, 0.01, 5.0, 1, 0, "Shadow map sampling bias");
1825         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");
1826         
1827         
1828 }
1829
1830
1831 static void lamp_panel_lamp(Object *ob, Lamp *la)
1832 {
1833         uiBlock *block;
1834         ID *id, *idfrom;
1835         float grid= 0.0;
1836         short xco;
1837         
1838         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_lamp", UI_EMBOSSX, UI_HELV, curarea->win);
1839         if(uiNewPanel(curarea, block, "Lamp", "Lamp", 320, 0, 318, 204)==0) return;
1840
1841         if(G.vd) grid= G.vd->grid; 
1842         if(grid<1.0) grid= 1.0;
1843
1844         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1845
1846         /* first do the browse but */
1847         buttons_active_id(&id, &idfrom);
1848
1849         uiBlockSetCol(block, BUTPURPLE);
1850         xco= std_libbuttons(block, 8, 180, 0, NULL, B_LAMPBROWSE, id, (ID *)ob, &(G.buts->menunr), B_LAMPALONE, B_LAMPLOCAL, 0, 0, 0);  
1851
1852         uiBlockSetCol(block, BUTGREY);
1853         uiDefButF(block, NUM,B_LAMPREDRAW,"Dist:",xco+10,180,104,20,&la->dist, 0.01, 5000.0, 100, 0, "Set the distance value");
1854
1855         uiBlockSetCol(block, BUTBLUE);
1856         uiDefButS(block, TOG|BIT|3, B_MATPRV,"Quad",            10,150,100,19,&la->mode, 0, 0, 0, 0, "Use inverse quadratic proportion");
1857         uiDefButS(block, TOG|BIT|6, REDRAWVIEW3D,"Sphere",      10,130,100,19,&la->mode, 0, 0, 0, 0, "Lamp only shines inside a sphere");
1858         uiDefButS(block, TOG|BIT|2, 0,"Layer",                          10,90,100,19,&la->mode, 0, 0, 0, 0, "Illuminate objects in the same layer only");
1859         uiDefButS(block, TOG|BIT|4, B_MATPRV,"Negative",        10,70,100,19,&la->mode, 0, 0, 0, 0, "Cast negative light");
1860         uiDefButS(block, TOG|BIT|11, 0,"No Diffuse",            10,30,100,19,&la->mode, 0, 0, 0, 0, "No diffuse shading of material");
1861         uiDefButS(block, TOG|BIT|12, 0,"No Specular",           10,10,100,19,&la->mode, 0, 0, 0, 0, "No specular shading of material");
1862
1863
1864         uiBlockSetCol(block, BUTGREY);
1865         uiDefButF(block, NUMSLI,B_MATPRV,"Energy ",     120,150,180,20, &(la->energy), 0.0, 10.0, 0, 0, "Set the intensity of the light");
1866
1867         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");
1868         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");
1869         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");
1870         uiDefButF(block, COL, B_COLLAMP, "",            120,55,180,24, &la->r, 0, 0, 0, 0, "");
1871         
1872         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");
1873         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");
1874
1875 }
1876
1877
1878 static void lamp_panel_preview(Object *ob, Lamp *la)
1879 {
1880         uiBlock *block;
1881         
1882         /* name "Preview" is abused to detect previewrender offset panel */
1883         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_preview", UI_EMBOSSX, UI_HELV, curarea->win);
1884         if(uiNewPanel(curarea, block, "Preview", "Lamp", 0, 0, 318, 204)==0) return;
1885         
1886         uiSetButLock(la->id.lib!=0, "Can't edit library data");
1887
1888         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1889
1890         // label to force a boundbox for buttons not to be centered
1891         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1892
1893         uiBlockSetCol(block, BUTGREEN);
1894         uiDefButS(block, ROW,B_LAMPREDRAW,"Lamp",       200,175,80,25,&la->type,1.0,(float)LA_LOCAL, 0, 0, "Use a point light source");
1895         uiDefButS(block, ROW,B_LAMPREDRAW,"Spot",       200,150,80,25,&la->type,1.0,(float)LA_SPOT, 0, 0, "Restrict lamp to conical space");
1896         uiDefButS(block, ROW,B_LAMPREDRAW,"Sun",        200,125,80,25,&la->type,1.0,(float)LA_SUN, 0, 0, "Light shines from constant direction");
1897         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");
1898         
1899 }
1900
1901
1902 /* ****************** MATERIAL ***************** */
1903
1904 void do_matbuts(unsigned short event)
1905 {
1906         static short mtexcopied=0;
1907         Material *ma;
1908         MTex *mtex;
1909
1910         switch(event) {         
1911         case B_ACTCOL:
1912                 scrarea_queue_headredraw(curarea);
1913                 allqueue(REDRAWBUTSSHADING, 0);
1914                 allqueue(REDRAWIPO, 0);
1915                 BIF_preview_changed(G.buts);
1916                 break;
1917         case B_MATFROM:
1918                 scrarea_queue_headredraw(curarea);
1919                 allqueue(REDRAWBUTSSHADING, 0);
1920                 // BIF_previewdraw();  push/pop!
1921                 break;
1922         case B_MATPRV:
1923                 /* this event also used by lamp, tex and sky */
1924                 BIF_preview_changed(G.buts);
1925                 break;
1926         case B_MATPRV_DRAW:
1927                 BIF_preview_changed(G.buts);
1928                 allqueue(REDRAWBUTSSHADING, 0);
1929                 break;
1930         case B_TEXCLEAR:
1931                 ma= G.buts->lockpoin;
1932                 mtex= ma->mtex[(int) ma->texact ];
1933                 if(mtex) {
1934                         if(mtex->tex) mtex->tex->id.us--;
1935                         MEM_freeN(mtex);
1936                         ma->mtex[ (int) ma->texact ]= 0;
1937                         allqueue(REDRAWBUTSSHADING, 0);
1938                         allqueue(REDRAWOOPS, 0);
1939                         BIF_preview_changed(G.buts);
1940                 }
1941                 break;
1942         case B_MTEXCOPY:
1943                 ma= G.buts->lockpoin;
1944                 if(ma && ma->mtex[(int)ma->texact] ) {
1945                         mtex= ma->mtex[(int)ma->texact];
1946                         if(mtex->tex==0) {
1947                                 error("No texture available");
1948                         }
1949                         else {
1950                                 memcpy(&mtexcopybuf, ma->mtex[(int)ma->texact], sizeof(MTex));
1951                                 mtexcopied= 1;
1952                         }
1953                 }
1954                 break;
1955         case B_MTEXPASTE:
1956                 ma= G.buts->lockpoin;
1957                 if(ma && mtexcopied && mtexcopybuf.tex) {
1958                         if(ma->mtex[(int)ma->texact]==0 ) ma->mtex[(int)ma->texact]= MEM_mallocN(sizeof(MTex), "mtex"); 
1959                         memcpy(ma->mtex[(int)ma->texact], &mtexcopybuf, sizeof(MTex));
1960                         
1961                         id_us_plus((ID *)mtexcopybuf.tex);
1962                         BIF_preview_changed(G.buts);
1963                         scrarea_queue_winredraw(curarea);
1964                 }
1965                 break;
1966         case B_MATLAY:
1967                 ma= G.buts->lockpoin;
1968                 if(ma && ma->lay==0) {
1969                         ma->lay= 1;
1970                         scrarea_queue_winredraw(curarea);
1971                 }
1972         }
1973 }
1974
1975 static void material_panel_map_to(Material *ma)
1976 {
1977         uiBlock *block;
1978         MTex *mtex;
1979         
1980         block= uiNewBlock(&curarea->uiblocks, "material_panel_map_to", UI_EMBOSSX, UI_HELV, curarea->win);
1981         uiNewPanelTabbed("Texture", "Material");
1982         if(uiNewPanel(curarea, block, "Map To", "Material", 1600, 0, 318, 204)==0) return;
1983
1984         mtex= ma->mtex[ ma->texact ];
1985         if(mtex==0) {
1986                 mtex= &emptytex;
1987                 default_mtex(mtex);
1988         }
1989
1990         /* TEXTURE OUTPUT */
1991         uiDefButS(block, TOG|BIT|1, B_MATPRV, "Stencil",        900,114,52,18, &(mtex->texflag), 0, 0, 0, 0, "Set the mapping to stencil mode");
1992         uiDefButS(block, TOG|BIT|2, B_MATPRV, "Neg",            954,114,38,18, &(mtex->texflag), 0, 0, 0, 0, "Reverse the effect of the texture");
1993         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");
1994         
1995         uiDefButF(block, COL, B_MTEXCOL, "",                            900,100,163,12, &(mtex->r), 0, 0, 0, 0, "Browse datablocks");
1996
1997         if(ma->colormodel==MA_HSV) {
1998                 uiBlockSetCol(block, BUTPURPLE);
1999                 uiDefButF(block, HSVSLI, B_MATPRV, "H ",                        900,80,163,18, &(mtex->r), 0.0, 0.9999, B_MTEXCOL, 0, "");
2000                 uiBlockSetCol(block, BUTPURPLE);
2001                 uiDefButF(block, HSVSLI, B_MATPRV, "S ",                        900,60,163,18, &(mtex->r), 0.0001, 1.0, B_MTEXCOL, 0, "");
2002                 uiBlockSetCol(block, BUTPURPLE);
2003                 uiDefButF(block, HSVSLI, B_MATPRV, "V ",                        900,40,163,18, &(mtex->r), 0.0001, 1.0, B_MTEXCOL, 0, "");
2004                 uiBlockSetCol(block, BUTGREY);
2005         }
2006         else {
2007                 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");
2008                 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");
2009                 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");
2010         }
2011         
2012         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");
2013         
2014         /* MAP TO */
2015         uiBlockSetCol(block, BUTGREEN);
2016         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");
2017         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");
2018         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");
2019         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");
2020         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");
2021         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");
2022         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");
2023         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");
2024         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");
2025         
2026 /*      uiDefButS(block, TOG|BIT|3, B_MATPRV, "Alpha Mix",1087,114,100,18, &(mtex->texflag), 0, 0, 0, 0); ,""*/
2027
2028         uiBlockSetCol(block, BUTGREY);
2029         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");
2030         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");
2031         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");
2032         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");
2033         
2034         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");
2035         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");
2036         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");
2037
2038 }
2039
2040
2041 static void material_panel_map_input(Material *ma)
2042 {
2043         uiBlock *block;
2044         MTex *mtex;
2045         int a, xco;
2046         char str[32];
2047         
2048         block= uiNewBlock(&curarea->uiblocks, "material_panel_map_input", UI_EMBOSSX, UI_HELV, curarea->win);
2049         uiNewPanelTabbed("Texture", "Material");
2050         if(uiNewPanel(curarea, block, "Map Input", "Material", 1280, 0, 318, 204)==0) return;
2051
2052         mtex= ma->mtex[ ma->texact ];
2053         if(mtex==0) {
2054                 mtex= &emptytex;
2055                 default_mtex(mtex);
2056         }
2057         
2058         /* TEXCO */
2059         uiBlockSetCol(block, BUTGREEN);
2060         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");
2061         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");
2062         uiDefIDPoinBut(block, test_obpoin_but, B_MATPRV, "",745,166,163,18, &(mtex->object), "");
2063
2064         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");
2065         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");
2066         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");
2067         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");
2068         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");
2069         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");
2070         
2071         uiBlockSetCol(block, BUTGREY);
2072         
2073         /* COORDS */
2074         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");
2075         uiDefButC(block, ROW, B_MATPRV, "Cube",                 717,114,50,18, &(mtex->mapping), 5.0, (float)MTEX_CUBE, 0, 0, "Map using the normal vector");
2076         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)");
2077         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)");
2078
2079         xco= 665;
2080         for(a=0; a<4; a++) {
2081                 if(a==0) strcpy(str, "");
2082                 else if(a==1) strcpy(str, "X");
2083                 else if(a==2) strcpy(str, "Y");
2084                 else strcpy(str, "Z");
2085                 
2086                 uiDefButC(block, ROW, B_MATPRV, str,                    xco, 50, 24, 18, &(mtex->projx), 6.0, (float)a, 0, 0, "");
2087                 uiDefButC(block, ROW, B_MATPRV, str,                    xco, 30, 24, 18, &(mtex->projy), 7.0, (float)a, 0, 0, "");
2088                 uiDefButC(block, ROW, B_MATPRV, str,                    xco, 10, 24, 18, &(mtex->projz), 8.0, (float)a, 0, 0, "");
2089                 xco+= 26;
2090         }
2091         
2092         uiDefButF(block, NUM, B_MATPRV, "ofsX",         778,114,130,18, mtex->ofs, -10.0, 10.0, 10, 0, "Fine tune X coordinate");
2093         uiDefButF(block, NUM, B_MATPRV, "ofsY",         778,94,130,18, mtex->ofs+1, -10.0, 10.0, 10, 0, "Fine tune Y coordinate");
2094         uiDefButF(block, NUM, B_MATPRV, "ofsZ",         778,74,130,18, mtex->ofs+2, -10.0, 10.0, 10, 0, "Fine tune Z coordinate");
2095         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");
2096         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");
2097         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");
2098
2099
2100 }
2101
2102
2103 static void material_panel_texture(Material *ma)
2104 {
2105         uiBlock *block;
2106         MTex *mtex;
2107         ID *id;
2108         int loos;
2109         int a, xco;
2110         char str[64], *strp;
2111         
2112         block= uiNewBlock(&curarea->uiblocks, "material_panel_texture", UI_EMBOSSX, UI_HELV, curarea->win);
2113         if(uiNewPanel(curarea, block, "Texture", "Material", 960, 0, 318, 204)==0) return;
2114
2115         /* TEX CHANNELS */
2116         uiBlockSetCol(block, BUTGREY);
2117         xco= 665;
2118         for(a= 0; a<8; a++) {
2119                 mtex= ma->mtex[a];
2120                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
2121                 else strcpy(str, "");
2122                 str[10]= 0;
2123                 uiDefButC(block, ROW, B_MATPRV_DRAW, str,       10, 180-22*a, 70, 20, &(ma->texact), 3.0, (float)a, 0, 0, "");
2124                 xco+= 65;
2125         }
2126         
2127         uiDefIconBut(block, BUT, B_MTEXCOPY, ICON_COPYUP,       100,180,23,21, 0, 0, 0, 0, 0, "Copy the mapping settings to the buffer");
2128         uiDefIconBut(block, BUT, B_MTEXPASTE, ICON_PASTEUP,     125,180,23,21, 0, 0, 0, 0, 0, "Paste the mapping settings from the buffer");
2129
2130         uiBlockSetCol(block, BUTGREEN);
2131         uiDefButC(block, TOG, B_MATPRV, "SepTex",               160, 180, 100, 20, &(ma->septex), 0, 0, 0, 0, "Render only use active texture channel");
2132         uiBlockSetCol(block, BUTGREY);
2133         
2134         mtex= ma->mtex[ ma->texact ];
2135         if(mtex==0) {
2136                 mtex= &emptytex;
2137                 default_mtex(mtex);
2138         }
2139
2140         /* TEXTUREBLOK SELECT */
2141         if(G.main->tex.first==0)
2142                 id= NULL;
2143         else
2144                 id= (ID*) mtex->tex;
2145         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x32767", &(G.main->tex), id, &(G.buts->texnr));
2146         uiDefButS(block, MENU, B_EXTEXBROWSE, strp, 100,130,20,20, &(G.buts->texnr), 0, 0, 0, 0, "The name of the texture");
2147         MEM_freeN(strp);
2148
2149         if(id) {
2150                 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");
2151                 sprintf(str, "%d", id->us);
2152                 uiDefBut(block, BUT, 0, str,                            196,130,21,20, 0, 0, 0, 0, 0, "");
2153                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 241,130,21,20, 0, 0, 0, 0, 0, "Auto-assign name to texture");
2154                 if(id->lib) {
2155                         if(ma->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,130,21,20, 0, 0, 0, 0, 0, "");
2156                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,130,21,20, 0, 0, 0, 0, 0, "");              
2157                 }
2158                 uiBlockSetCol(block, BUTSALMON);
2159                 uiDefBut(block, BUT, B_TEXCLEAR, "Clear", 122, 130, 72, 20, 0, 0, 0, 0, 0, "Erase link to datablock");
2160                 uiBlockSetCol(block, BUTGREY);
2161         }
2162         
2163 }
2164
2165 static void material_panel_shading(Material *ma)
2166 {
2167         uiBlock *block;
2168         
2169         block= uiNewBlock(&curarea->uiblocks, "material_panel_shading", UI_EMBOSSX, UI_HELV, curarea->win);
2170         if(uiNewPanel(curarea, block, "Shaders", "Material", 640, 0, 318, 204)==0) return;
2171
2172         uiBlockSetCol(block, BUTPURPLE);
2173         uiDefButI(block, TOG|BIT|5, B_MATPRV_DRAW, "Halo",      245,180,65,18, &(ma->mode), 0, 0, 0, 0, "Render as a halo");
2174
2175         if(ma->mode & MA_HALO) {
2176                 uiBlockSetCol(block, BUTGREY);
2177                 uiDefButF(block, NUM, B_MATPRV, "HaloSize: ",           10,155,190,18, &(ma->hasize), 0.0, 100.0, 10, 0, "Set the dimension of the halo");
2178                 uiDefButS(block, NUMSLI, B_MATPRV, "Hard ",                     10,135,190,18, &(ma->har), 1.0, 127.0, 0, 0, "Set the hardness of the halo");
2179                 uiDefButF(block, NUMSLI, B_MATPRV, "Add  ",                     10,115,190,18, &(ma->add), 0.0, 1.0, 0, 0, "Strength of the add effect");
2180                 
2181                 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");
2182                 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");
2183                 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");
2184                 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");
2185                 if(ma->mode & MA_HALO_FLARE) {
2186                         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");
2187                         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");
2188                         uiDefButF(block, NUMSLI, B_MATPRV, "Boost: ",           10,30,190,18, &(ma->flareboost), 0.1, 10.0, 10, 0, "Give the flare extra strength");
2189                         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");
2190                         uiDefButS(block, NUM, B_MATPRV, "Flares: ",                     100,10,100,18, &(ma->flarec), 1.0, 32.0, 0, 0, "Set the nuber of subflares");
2191                 }
2192                 uiBlockSetCol(block, BUTBLUE);
2193                 
2194                 uiDefButI(block, TOG|BIT|15, B_MATPRV_DRAW, "Flare",            245,142,65,28, &(ma->mode), 0, 0, 0, 0, "Render halo as a lensflare");
2195                 uiDefButI(block, TOG|BIT|8, B_MATPRV, "Rings",          245,123,65, 18, &(ma->mode), 0, 0, 0, 0, "Render rings over basic halo");
2196                 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");
2197                 uiDefButI(block, TOG|BIT|11, B_MATPRV, "Star",          245,85,65, 18, &(ma->mode), 0, 0, 0, 0, "Render halo as a star");
2198                 uiDefButI(block, TOG|BIT|12, B_MATPRV, "HaloTex",       245,66,65, 18, &(ma->mode), 0, 0, 0, 0, "Give halo a texture");
2199                 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");
2200                 uiDefButI(block, TOG|BIT|10, B_MATPRV, "X Alpha",       245,28,65, 18, &(ma->mode), 0, 0, 0, 0, "Use extreme alpha");
2201                 uiDefButI(block, TOG|BIT|14, B_MATPRV, "Shaded",        245,9,65, 18, &(ma->mode), 0, 0, 0, 0, "Let halo receive light");
2202         }
2203         else {
2204                 char *str1= "Diffuse Shader%t|Lambert %x0|Oren-Nayar %x1|Toon %x2";
2205                 char *str2= "Specular Shader%t|CookTorr %x0|Phong %x1|Blinn %x2|Toon %x3";
2206                 
2207                 /* diff shader buttons */
2208                 uiBlockSetCol(block, BUTGREY);
2209                 uiDefButS(block, MENU, B_MATPRV_DRAW, str1,             9, 155,78,19, &(ma->diff_shader), 0.0, 0.0, 0, 0, "Set a diffuse shader");
2210                 uiDefButF(block, NUMSLI, B_MATPRV, "Ref   ",    90,155,150,19, &(ma->ref), 0.0, 1.0, 0, 0, "Set the amount of reflection");
2211
2212                 if(ma->diff_shader==MA_DIFF_ORENNAYAR)
2213                         uiDefButF(block, NUMSLI, B_MATPRV, "Rough:",90,135, 150,19, &(ma->roughness), 0.0, 3.14, 0, 0, "Oren Nayar Roughness");
2214                 else if(ma->diff_shader==MA_DIFF_TOON) {
2215                         uiDefButF(block, NUMSLI, B_MATPRV, "Size:",     90, 135,150,19, &(ma->param[0]), 0.0, 3.14, 0, 0, "Size of diffuse toon area");
2216                         uiDefButF(block, NUMSLI, B_MATPRV, "Smooth:",90,115,150,19, &(ma->param[1]), 0.0, 1.0, 0, 0, "Smoothness of diffuse toon area");
2217                 }
2218                 
2219                 /* spec shader buttons */
2220                 uiDefButS(block, MENU, B_MATPRV_DRAW, str2,             9,95,77,19, &(ma->spec_shader), 0.0, 0.0, 0, 0, "Set a specular shader");
2221                 uiDefButF(block, NUMSLI, B_MATPRV, "Spec ",             90,95,150,19, &(ma->spec), 0.0, 2.0, 0, 0, "Set the degree of specularity");
2222
2223                 if ELEM3(ma->spec_shader, MA_SPEC_COOKTORR, MA_SPEC_PHONG, MA_SPEC_BLINN) {
2224                         uiDefButS(block, NUMSLI, B_MATPRV, "Hard:",     90, 75, 150,19, &(ma->har), 1.0, 255, 0, 0, "Set the hardness of the specularity");
2225                 }
2226                 if(ma->spec_shader==MA_SPEC_BLINN)
2227                         uiDefButF(block, NUMSLI, B_MATPRV, "Refr:",     90, 55,150,19, &(ma->refrac), 1.0, 10.0, 0, 0, "Refraction index");
2228                 if(ma->spec_shader==MA_SPEC_TOON) {
2229                         uiDefButF(block, NUMSLI, B_MATPRV, "Size:",     90, 75,150,19, &(ma->param[2]), 0.0, 1.53, 0, 0, "Size of specular toon area");
2230                         uiDefButF(block, NUMSLI, B_MATPRV, "Smooth:",90, 55,150,19, &(ma->param[3]), 0.0, 1.0, 0, 0, "Smoothness of specular toon area");
2231                 }
2232
2233                 /* default shading variables */
2234                 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");
2235                 uiDefButF(block, NUMSLI, B_MATPRV, "Emit ",             133,30,110,19, &(ma->emit), 0.0, 1.0, 0, 0, "Set the amount of emitting light");
2236                 uiDefButF(block, NUMSLI, B_MATPRV, "Add ",              9,10,117,19, &(ma->add), 0.0, 1.0, 0, 0, "Glow factor for transparant");
2237                 uiDefButF(block, NUM, 0, "Zoffs:",                              133,10,110,19, &(ma->zoffs), 0.0, 10.0, 0, 0, "Give face an artificial offset");
2238         
2239                 uiBlockSetCol(block, BUTBLUE);
2240         
2241                 uiDefButI(block, TOG|BIT|0, 0,  "Traceable",            245,161,65,18, &(ma->mode), 0, 0, 0, 0, "Make material visible for shadow lamps");
2242                 uiDefButI(block, TOG|BIT|1, 0,  "Shadow",                       245,142,65,18, &(ma->mode), 0, 0, 0, 0, "Enable material for shadows");
2243                 uiDefButI(block, TOG|BIT|16, 0, "Radio",                        245,123,65,18, &(ma->mode), 0, 0, 0, 0, "Enable radiosty render");
2244                 uiDefButI(block, TOG|BIT|3, 0,  "Wire",                         245,104,65,18, &(ma->mode), 0, 0, 0, 0, "Render only the edges of faces");
2245                 uiDefButI(block, TOG|BIT|6, 0,  "ZTransp",                      245,85, 65,18, &(ma->mode), 0, 0, 0, 0, "Z-Buffer transparent faces");
2246                 uiDefButI(block, TOG|BIT|9, 0,  "Env",                          245,66, 65,18, &(ma->mode), 0, 0, 0, 0, "Do not render material");
2247                 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");
2248                 uiDefButI(block, TOG|BIT|14, 0, "No Mist",                      245,28, 65,18, &(ma->mode), 0, 0, 0, 0, "Set the material insensitive to mist");
2249                 uiDefButI(block, TOG|BIT|8, 0,  "ZInvert",                      245,9, 65,18, &(ma->mode), 0, 0, 0, 0, "Render with inverted Z Buffer");
2250         }
2251
2252 }
2253
2254
2255 static void material_panel_material(Object *ob, Material *ma)
2256 {
2257         uiBlock *block;
2258         ID *id, *idn, *idfrom;
2259         uiBut *but;
2260         float *colpoin = NULL, min;
2261         int rgbsel = 0, xco= 0;
2262         char str[30];
2263         
2264         block= uiNewBlock(&curarea->uiblocks, "material_panel_material", UI_EMBOSSX, UI_HELV, curarea->win);
2265         if(uiNewPanel(curarea, block, "Material", "Material", 320, 0, 318, 204)==0) return;
2266
2267         /* first do the browse but */
2268         buttons_active_id(&id, &idfrom);
2269
2270         uiBlockSetCol(block, BUTPURPLE);
2271         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);
2272
2273         uiDefIconBut(block, BUT, B_MATCOPY, ICON_COPYUP,        xco+=XIC,198,XIC,YIC, 0, 0, 0, 0, 0, "Copies Material to the buffer");
2274         uiSetButLock(id && id->lib, "Can't edit library data");
2275         uiDefIconBut(block, BUT, B_MATPASTE, ICON_PASTEUP,      xco+=XIC,198,XIC,YIC, 0, 0, 0, 0, 0, "Pastes Material from the buffer");
2276         
2277         if(ob->actcol==0) ob->actcol= 1;        /* because of TOG|BIT button */
2278         
2279         /* indicate which one is linking a material */
2280         uiBlockSetCol(block, BUTSALMON);
2281         uiDefButS(block, TOG|BIT|(ob->actcol-1), B_MATFROM, "OB",       125,174,32,20, &ob->colbits, 0, 0, 0, 0, "Link material to object");
2282         idn= ob->data;
2283         strncpy(str, idn->name, 2);
2284         str[2]= 0;
2285         uiBlockSetCol(block, BUTGREEN);
2286         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");
2287         uiBlockSetCol(block, BUTGREY);
2288         
2289         /* id is the block from which the material is used */
2290         if( BTST(ob->colbits, ob->actcol-1) ) id= (ID *)ob;
2291         else id= ob->data;
2292
2293         sprintf(str, "%d Mat", ob->totcol);
2294         if(ob->totcol) min= 1.0; else min= 0.0;
2295         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");
2296         
2297         uiSetButLock(id->lib!=0, "Can't edit library data");
2298         
2299         strncpy(str, id->name, 2);
2300         str[2]= ':'; str[3]= 0;
2301         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");
2302         uiButSetFunc(but, test_idbutton_cb, id->name, NULL);
2303
2304         if(ob->totcol==0) return;
2305
2306         ma= give_current_material(ob, ob->actcol);      
2307         if(ma==0) return;
2308         
2309         uiSetButLock(ma->id.lib!=0, "Can't edit library data");
2310         
2311         
2312         if(ma->dynamode & MA_DRAW_DYNABUTS) {
2313                 uiDefButF(block, NUMSLI, 0, "Restitut ",                128,120,175,20, &ma->reflect, 0.0, 1.0, 0, 0, "Elasticity of collisions");
2314                 uiDefButF(block, NUMSLI, 0, "Friction ",                128,98 ,175,20, &ma->friction, 0.0, 100.0, 0, 0,   "Coulomb friction coefficient");
2315                 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");
2316
2317                 uiDefButF(block, NUM, 0,         "Fh Damp ",            8,120,100,20, &ma->xyfrict, 0.0, 1.0, 10, 0, "Damping of the Fh spring force");
2318                 uiDefButF(block, NUM, 0, "Fh Dist ",                    8,98 ,100,20, &ma->fhdist, 0.0, 20.0, 10, 0, "Height of the Fh area");
2319                 uiBlockSetCol(block, BUTGREEN);
2320                 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");
2321                 uiBlockSetCol(block, BUTGREY);
2322         }
2323         else {
2324                 if(!(ma->mode & MA_HALO)) {
2325                         uiBlockSetCol(block, BUTBLUE);
2326                         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");
2327                         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");
2328                         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");
2329                         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");
2330                 }
2331                 uiBlockSetCol(block, BUTGREY);
2332                 uiDefButF(block, COL, B_MATCOL, "",             8,115,72,24, &(ma->r), 0, 0, 0, 0, "");
2333                 uiDefButF(block, COL, B_SPECCOL, "",    8,88,72,24, &(ma->specr), 0, 0, 0, 0, "");
2334                 uiDefButF(block, COL, B_MIRCOL, "",             8,61,72,24, &(ma->mirr), 0, 0, 0, 0, "");
2335         
2336                 uiBlockSetCol(block, BUTGREEN);
2337                 if(ma->mode & MA_HALO) {
2338                         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");
2339                         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");
2340                         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");
2341                 }
2342                 else {
2343                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Col",                 83,115,40,25, &(ma->rgbsel), 2.0, 0.0, 0, 0, "Set the basic colour of the material");
2344                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Spe",                 83,88,40,25, &(ma->rgbsel), 2.0, 1.0, 0, 0, "Set the colour of the specularity");
2345                         uiDefButC(block, ROW, REDRAWBUTSSHADING, "Mir",                 83,61,40,25, &(ma->rgbsel), 2.0, 2.0, 0, 0, "Use mirror colour");
2346                 }
2347                 uiBlockSetCol(block, BUTGREY);
2348                 
2349                 if(ma->rgbsel==0) {colpoin= &(ma->r); rgbsel= B_MATCOL;}
2350                 else if(ma->rgbsel==1) {colpoin= &(ma->specr); rgbsel= B_SPECCOL;}
2351                 else if(ma->rgbsel==2) {colpoin= &(ma->mirr); rgbsel= B_MIRCOL;}
2352                 
2353                 if(ma->rgbsel==0 && (ma->mode & (MA_VERTEXCOLP|MA_FACETEXTURE) && !(ma->mode & MA_HALO)));
2354                 else if(ma->colormodel==MA_HSV) {
2355                         uiBlockSetCol(block, BUTPURPLE);
2356                         uiDefButF(block, HSVSLI, B_MATPRV, "H ",                128,120,175,20, colpoin, 0.0, 0.9999, rgbsel, 0, "");
2357                         uiDefButF(block, HSVSLI, B_MATPRV, "S ",                128,98,175,20, colpoin, 0.0001, 1.0, rgbsel, 0, "");
2358                         uiDefButF(block, HSVSLI, B_MATPRV, "V ",                128,76,175,20, colpoin, 0.0001, 1.0, rgbsel, 0, "");
2359                         uiBlockSetCol(block, BUTGREY);
2360                 }
2361                 else {
2362                         uiDefButF(block, NUMSLI, B_MATPRV, "R ",                128,120,175,20, colpoin, 0.0, 1.0, rgbsel, 0, "");
2363                         uiDefButF(block, NUMSLI, B_MATPRV, "G ",                128,98,175,20, colpoin+1, 0.0, 1.0, rgbsel, 0, "");
2364                         uiDefButF(block, NUMSLI, B_MATPRV, "B ",                128,76,175,20, colpoin+2, 0.0, 1.0, rgbsel, 0, "");
2365                 }
2366                 
2367                 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");
2368                 uiDefButF(block, NUMSLI, B_MATPRV, "SpecTra ",          128,32,175,20, &(ma->spectra), 0.0, 1.0, 0, 0, "Make specular areas opaque");
2369                 
2370         }
2371         uiBlockSetCol(block, BUTGREEN);
2372         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");
2373         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");
2374         uiDefButS(block, TOG|BIT|0, REDRAWBUTSSHADING, "DYN",   78,32,45,20, &(ma->dynamode), 0.0, 0.0, 0, 0, "Adjust parameters for dynamics options");
2375
2376 }
2377
2378 static void material_panel_preview(Material *ma)
2379 {
2380         uiBlock *block;
2381         
2382         /* name "Preview" is abused to detect previewrender offset panel */
2383         block= uiNewBlock(&curarea->uiblocks, "material_panel_preview", UI_EMBOSSX, UI_HELV, curarea->win);
2384         if(uiNewPanel(curarea, block, "Preview", "Material", 0, 0, 318, 204)==0) return;
2385         
2386         if(ma) {
2387                 uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
2388         
2389                 // label to force a boundbox for buttons not to be centered
2390                 uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
2391         
2392                 uiDefIconButC(block, ROW, B_MATPRV, ICON_MATPLANE,              210,180,25,22, &(ma->pr_type), 10, 0, 0, 0, "");
2393                 uiDefIconButC(block, ROW, B_MATPRV, ICON_MATSPHERE,             210,150,25,22, &(ma->pr_type), 10, 1, 0, 0, "");
2394                 uiDefIconButC(block, ROW, B_MATPRV, ICON_MATCUBE,               210,120,25,22, &(ma->pr_type), 10, 2, 0, 0, "");
2395                 uiDefIconButS(block, ICONTOG|BIT|0, B_MATPRV, ICON_TRANSP_HLT,  210,80,25,22, &(ma->pr_back), 0, 0, 0, 0, "");
2396                 uiDefIconBut(block, BUT, B_MATPRV, ICON_EYE,                    210,10, 25,22, 0, 0, 0, 0, 0, "");
2397         }
2398 }
2399
2400 void material_panels()
2401 {
2402         Material *ma;
2403         MTex *mtex;
2404         Object *ob= OBACT;
2405         
2406         if(ob==0) return;
2407         
2408         // type numbers are ordered
2409         if((ob->type<OB_LAMP) && ob->type) {
2410                 ma= give_current_material(ob, ob->actcol);
2411
2412                 // always draw first 2 panels
2413                 material_panel_preview(ma);
2414                 material_panel_material(ob, ma);
2415                 
2416                 if(ma) {
2417                         material_panel_shading(ma);
2418                         material_panel_texture(ma);
2419                         
2420                         mtex= ma->mtex[ ma->texact ];
2421                         if(mtex && mtex->tex) {
2422                                 material_panel_map_input(ma);
2423                                 material_panel_map_to(ma);
2424                         }
2425                 }
2426         }
2427 }
2428
2429 void lamp_panels()
2430 {
2431         Object *ob= OBACT;
2432         
2433         if(ob==NULL || ob->type!= OB_LAMP) return;
2434
2435         lamp_panel_preview(ob, ob->data);
2436         lamp_panel_lamp(ob, ob->data);
2437         lamp_panel_spot(ob, ob->data);
2438         lamp_panel_texture(ob, ob->data);
2439         lamp_panel_mapto(ob, ob->data);
2440
2441 }
2442
2443 void world_panels()
2444 {
2445         World *wrld;
2446
2447         wrld= G.scene->world;
2448
2449         world_panel_preview(wrld);
2450         world_panel_world(wrld);
2451
2452         if(wrld) {
2453                 world_panel_mistaph(wrld);
2454                 world_panel_texture(wrld);
2455                 world_panel_mapto(wrld);
2456         }
2457 }
2458
2459 void texture_panels()
2460 {
2461         Material *ma=NULL;
2462         Lamp *la=NULL;
2463         World *wrld=NULL;
2464         Object *ob= OBACT;
2465         MTex *mtex= NULL;
2466         
2467         if(G.buts->texfrom==0) {
2468                 if(ob) {
2469                         ma= give_current_material(ob, ob->actcol);
2470                         if(ma) mtex= ma->mtex[ ma->texact ];
2471                 }
2472         }
2473         else if(G.buts->texfrom==1) {
2474                 wrld= G.scene->world;
2475                 if(wrld) mtex= wrld->mtex[ wrld->texact ];
2476         }
2477         else if(G.buts->texfrom==2) {
2478                 if(ob && ob->type==OB_LAMP) {
2479                         la= ob->data;
2480                         mtex= la->mtex[ la->texact ];
2481                 }
2482         }
2483         
2484         texture_panel_preview(ma || wrld || la);        // for 'from' buttons
2485         
2486         if(ma || wrld || la) {
2487         
2488                 texture_panel_texture(mtex, ma, wrld, la);
2489                 
2490                 if(mtex && mtex->tex) {
2491                         texture_panel_colors(mtex->tex);
2492                         
2493                         switch(mtex->tex->type) {
2494                         case TEX_IMAGE:
2495                                 texture_panel_image(mtex->tex);
2496                                 texture_panel_image1(mtex->tex);
2497                                 break;
2498                         case TEX_ENVMAP:
2499                                 texture_panel_envmap(mtex->tex);
2500                                 break;
2501                         case TEX_CLOUDS:
2502                                 texture_panel_clouds(mtex->tex);
2503                                 break;
2504                         case TEX_MARBLE:
2505                                 texture_panel_marble(mtex->tex);
2506                                 break;
2507                         case TEX_STUCCI:
2508                                 texture_panel_stucci(mtex->tex);
2509                                 break;
2510                         case TEX_WOOD:
2511                                 texture_panel_wood(mtex->tex);
2512                                 break;
2513                         case TEX_BLEND:
2514                                 texture_panel_blend(mtex->tex);
2515                                 break;
2516                         case TEX_MAGIC:
2517                                 texture_panel_magic(mtex->tex);
2518                                 break;
2519                         case TEX_PLUGIN:
2520                                 texture_panel_plugin(mtex->tex);
2521                                 break;
2522                         case TEX_NOISE:
2523                                 // no panel!
2524                                 break;
2525                         }
2526                 }
2527         }
2528 }
2529
2530 void radio_panels()
2531 {
2532         Radio *rad;
2533         int flag;
2534         
2535         rad= G.scene->radio;
2536         if(rad==0) {
2537                 add_radio();
2538                 rad= G.scene->radio;
2539         }
2540
2541         radio_panel_render(rad);
2542         
2543         flag= rad_phase();
2544         
2545         radio_panel_tool(rad, flag);
2546         if(flag) radio_panel_calculation(rad, flag);
2547
2548         
2549 }