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