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