Error in previous commit: the texture filter size should not be scaled
[blender-staging.git] / source / blender / src / buttons_shading.c
1 /**
2  * $Id$ 
3  *
4  * ***** BEGIN GPL 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. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: not all of this file anymore. :)
24  *
25  * Contributor(s):
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <time.h>
31 #include <math.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38
39 #include "IMB_imbuf_types.h"
40 #include "IMB_imbuf.h"
41
42 #include "MEM_guardedalloc.h"
43
44 #include "DNA_brush_types.h"
45 #include "DNA_curve_types.h"
46 #include "DNA_customdata_types.h"
47 #include "DNA_image_types.h"
48 #include "DNA_lamp_types.h"
49 #include "DNA_material_types.h"
50 #include "DNA_mesh_types.h"
51 #include "DNA_meshdata_types.h"
52 #include "DNA_object_types.h"
53 #include "DNA_node_types.h"
54 #include "DNA_packedFile_types.h"
55 #include "DNA_particle_types.h"
56 #include "DNA_radio_types.h"
57 #include "DNA_screen_types.h"
58 #include "DNA_space_types.h"
59 #include "DNA_scene_types.h"
60 #include "DNA_texture_types.h"
61 #include "DNA_userdef_types.h"
62 #include "DNA_view3d_types.h"
63 #include "DNA_world_types.h"
64
65 #include "BKE_colortools.h"
66 #include "BKE_depsgraph.h"
67 #include "BKE_displist.h"
68 #include "BKE_effect.h"
69 #include "BKE_global.h"
70 #include "BKE_library.h"
71 #include "BKE_main.h"
72 #include "BKE_node.h"
73 #include "BKE_material.h"
74 #include "BKE_particle.h"
75 #include "BKE_utildefines.h"
76 #include "BKE_texture.h"
77
78 #include "BKE_packedFile.h"
79 #include "BKE_plugin_types.h"
80 #include "BKE_image.h"
81
82 #include "BLI_blenlib.h"
83 #include "BMF_Api.h"
84
85 #include "BSE_filesel.h"
86 #include "BSE_headerbuttons.h"
87 #include "BSE_node.h"
88
89 #include "BDR_drawmesh.h"
90
91 #include "BIF_drawimage.h"
92 #include "BIF_gl.h"
93 #include "BIF_graphics.h"
94 #include "BIF_keyval.h"
95 #include "BIF_mainqueue.h"
96 #include "BIF_resources.h"
97 #include "BIF_screen.h"
98 #include "BIF_mywindow.h"
99 #include "BIF_space.h"
100 #include "BIF_glutil.h"
101 #include "BIF_imasel.h"
102 #include "BIF_interface.h"
103 #include "BIF_toolbox.h"
104 #include "BIF_space.h"
105 #include "BIF_previewrender.h"
106 #include "BIF_butspace.h"
107 #include "BIF_writeimage.h"
108 #include "BIF_toets.h"
109
110 #include "mydevice.h"
111 #include "blendef.h"
112 #include "radio.h"
113
114 #include "RE_pipeline.h"
115
116 /* -----includes for this file specific----- */
117
118 #include "butspace.h" // own module
119
120
121 static MTex emptytex;
122 static int packdummy = 0;
123
124 static char *mapto_blendtype_pup(void)
125 {
126         static char formatstr[] = "|%s %%x%d";
127         static char string[1024];
128         char *str = string;
129         
130         str += sprintf(str, formatstr, "Mix", MTEX_BLEND);
131
132         str += sprintf(str, formatstr, "Add", MTEX_ADD);
133         str += sprintf(str, formatstr, "Subtract", MTEX_SUB);
134
135         str += sprintf(str, formatstr, "Multiply", MTEX_MUL);
136         str += sprintf(str, formatstr, "Screen", MTEX_SCREEN);
137         str += sprintf(str, formatstr, "Overlay", MTEX_OVERLAY);
138         
139         str += sprintf(str, formatstr, "Difference", MTEX_DIFF);
140         str += sprintf(str, formatstr, "Divide", MTEX_DIV);
141         
142         str += sprintf(str, formatstr, "Darken", MTEX_DARK);
143         str += sprintf(str, formatstr, "Lighten", MTEX_LIGHT);
144
145         return string;
146 }
147
148 void shade_buttons_change_3d(void)
149 {
150         Object *ob= OBACT;
151         ScrArea *sa;
152         
153         if(ob==NULL) return;
154         
155         for(sa= G.curscreen->areabase.first; sa; sa= sa->next) {
156                 if(sa->spacetype==SPACE_VIEW3D) {
157                         View3D *v3d= sa->spacedata.first;
158                         
159                         if(v3d->drawtype >= OB_SOLID) addqueue(sa->win, REDRAW, 0);
160                         if(v3d->drawtype == OB_SHADED) {
161                                 if(ob->type==OB_LAMP) reshadeall_displist();
162                                 else {
163                                         /* all objects using material */
164                                         Base *base= FIRSTBASE;
165                                         Material *ma= give_current_material(ob, ob->actcol);    
166                                         int a;
167                                         
168                                         while(base) {
169                                                 if(base->lay & G.vd->lay) {
170                                                         for(a=1; a<=ob->totcol; a++) {
171                                                                 if(ma == give_current_material(base->object, a)) {
172                                                                         freedisplist(&(base->object->disp));
173                                                                         break;
174                                                                 }
175                                                         }
176                                                 }
177                                                 base= base->next;
178                                         }
179                                 }
180                         }
181                 }
182         }       
183 }
184
185 /* *************************** TEXTURE ******************************** */
186
187 static void load_image_cb(char *str, void *ima_pp_v, void *iuser_v)     /* called from fileselect or button */
188 {
189         Image **ima_pp= (Image **)ima_pp_v;
190         Image *ima= NULL;
191         
192         ima= BKE_add_image_file(str);
193         if(ima) {
194                 if(*ima_pp) {
195                         (*ima_pp)->id.us--;
196                 }
197                 *ima_pp= ima;
198
199                 BKE_image_signal(ima, iuser_v, IMA_SIGNAL_RELOAD);
200                 
201                 /* button event gets lost when it goes via filewindow */
202                 if(G.buts && G.buts->lockpoin) {
203                         Tex *tex= G.buts->lockpoin;
204                         if(GS(tex->id.name)==ID_TE) {
205                                 BIF_preview_changed(ID_TE);
206                                 allqueue(REDRAWBUTSSHADING, 0);
207                                 allqueue(REDRAWOOPS, 0);
208                         }
209                 }
210         }
211
212         BIF_undo_push("Load image");
213 }
214
215 static void load_plugin_tex(char *str, void *tex_v, void *unused)       /* called from fileselect */
216 {
217         Tex *tex= tex_v;
218         
219         if(tex->type!=TEX_PLUGIN) return;
220         
221         if(tex->plugin) free_plugin_tex(tex->plugin);
222         
223         tex->stype= 0;
224         tex->plugin= add_plugin_tex(str);
225
226         allqueue(REDRAWBUTSSHADING, 0);
227         BIF_preview_changed(ID_TE);
228 }
229
230 static void save_env(char *name)
231 {
232         Tex *tex;
233         char str[FILE_MAX];
234         
235         strcpy(str, name);
236         BLI_convertstringcode(str, G.sce, G.scene->r.cfra);
237         tex= G.buts->lockpoin;
238         
239         if(tex && GS(tex->id.name)==ID_TE) {
240                 if(tex->env && tex->env->ok && saveover(str)) {
241                         waitcursor(1);
242                         BIF_save_envmap(tex->env, str);
243                         strcpy(G.ima, name);
244                         waitcursor(0);
245                 }
246         }
247         
248 }
249
250 static int vergcband(const void *a1, const void *a2)
251 {
252         const CBData *x1=a1, *x2=a2;
253         
254         if( x1->pos > x2->pos ) return 1;
255         else if( x1->pos < x2->pos) return -1;
256         return 0;
257 }
258
259 void do_texbuts(unsigned short event)
260 {
261         Tex *tex;
262         ScrArea *sa;
263         char str[FILE_MAX];
264         
265         tex= G.buts->lockpoin;
266         
267         switch(event) {
268         case B_TEXPRV:
269                 BIF_preview_changed(ID_TE);
270                 allqueue(REDRAWBUTSSHADING, 0);
271                 
272                 if(tex && G.scene->nodetree) {
273                         NodeTagIDChanged(G.scene->nodetree, &tex->id);
274                         allqueue(RECALC_COMPOSITE, 0);
275                 }
276                 break;
277         case B_TEXCHANNEL:
278                 scrarea_queue_headredraw(curarea);
279                 BIF_preview_changed(ID_TE);
280                 allqueue(REDRAWBUTSSHADING, 0);
281                 if(G.buts->texfrom == 3) /* brush texture */
282                         allqueue(REDRAWIMAGE, 0);
283                 break;
284         case B_TEXTYPE:
285                 if(tex==NULL) return;
286                 tex->stype= 0;
287                 allqueue(REDRAWBUTSSHADING, 0);
288                 BIF_preview_changed(ID_TE);
289                 
290                 if(tex && G.scene->nodetree) {
291                         NodeTagIDChanged(G.scene->nodetree, &tex->id);
292                         allqueue(RECALC_COMPOSITE, 0);
293                 }
294                 break;
295         case B_DEFTEXVAR:
296                 if(tex==NULL) return;
297                 default_tex(tex);
298                 BIF_undo_push("Default texture vars");
299                 allqueue(REDRAWBUTSSHADING, 0);
300                 BIF_preview_changed(ID_TE);
301                 break;
302                 
303         case B_IMAGECHANGED:
304                 BIF_preview_changed(ID_TE);
305                 allqueue(REDRAWBUTSSHADING, 0);
306                 
307                 if(tex) {
308                         if(G.scene->nodetree) {
309                                 NodeTagIDChanged(G.scene->nodetree, &tex->id);
310                                 allqueue(RECALC_COMPOSITE, 0);
311                         }
312                         if(tex->ima && (tex->imaflag & TEX_MIPMAP) && (tex->ima->flag & IMA_FIELDS)) {
313                                 error("Cannot combine fields and mipmap");
314                                 tex->imaflag -= TEX_MIPMAP;
315                         }
316                         if(tex->env)
317                                 BKE_free_envmapdata(tex->env);
318                 }
319                         
320                 break;
321                 
322         case B_TEXREDR_PRV:
323                 allqueue(REDRAWBUTSSHADING, 0);
324                 BIF_preview_changed(ID_TE);
325                 shade_buttons_change_3d();
326                 break;
327
328
329         case B_LOADPLUGIN:
330                 if(tex==NULL) return;
331                         
332                 sa= closest_bigger_area();
333                 areawinset(sa->win);
334                 if(tex->plugin) strcpy(str, tex->plugin->name);
335                 else {
336                         strcpy(str, U.plugtexdir);
337                 }
338                 activate_fileselect_args(FILE_SPECIAL, "SELECT PLUGIN", str, load_plugin_tex, tex, NULL);
339                 
340                 break;
341
342         case B_NAMEPLUGIN:
343                 if(tex==NULL || tex->plugin==NULL) return;
344                 strcpy(str, tex->plugin->name);
345                 free_plugin_tex(tex->plugin);
346                 tex->stype= 0;
347                 tex->plugin= add_plugin_tex(str);
348                 allqueue(REDRAWBUTSSHADING, 0);
349                 BIF_preview_changed(ID_TE);
350                 break;
351         
352         case B_COLORBAND:
353                 if(tex==NULL) return;
354                 if(tex->coba==NULL) tex->coba= add_colorband(0);
355                 allqueue(REDRAWBUTSSHADING, 0);
356                 BIF_preview_changed(ID_TE); // also ramps, so we do this
357                 break;
358         
359         case B_ENV_DELETE:
360                 if(tex->env) {
361                         BKE_free_envmap(tex->env);
362                         tex->env= 0;
363                         allqueue(REDRAWBUTSSHADING, 0);
364                         BIF_preview_changed(ID_TE);
365                 }
366                 break;
367         case B_ENV_FREE:
368                 if(tex->env) {
369                         BKE_free_envmapdata(tex->env);
370                         allqueue(REDRAWBUTSSHADING, 0);
371                         BIF_preview_changed(ID_TE);
372                 }
373                 break;
374         case B_ENV_FREE_ALL:
375                 tex= G.main->tex.first;
376                 while(tex) {
377                         if(tex->id.us && tex->type==TEX_ENVMAP) {
378                                 if(tex->env) {
379                                         if(tex->env->stype!=ENV_LOAD) BKE_free_envmapdata(tex->env);
380                                 }
381                         }
382                         tex= tex->id.next;
383                 }
384                 allqueue(REDRAWBUTSSHADING, 0);
385                 BIF_preview_changed(ID_TE);
386                 break;
387         case B_ENV_SAVE:
388                 if(tex->env && tex->env->ok) {
389                         if(tex->env->type==ENV_PLANE) {
390                                 notice("Sorry, not implemented yet");
391                         }
392                         else {
393                                 sa= closest_bigger_area();
394                                 areawinset(sa->win);
395                                 save_image_filesel_str(str);
396                                 activate_fileselect(FILE_SPECIAL, str, G.ima, save_env);
397                         }
398                 }
399                 break;  
400         case B_ENV_OB:
401                 if(tex->env && tex->env->object) {
402                         BIF_preview_changed(ID_TE);
403                         if ELEM(tex->env->object->type, OB_CAMERA, OB_LAMP) {
404                                 error("Camera or Lamp not allowed");
405                                 tex->env->object= NULL;
406                         }
407                 }
408                 break;
409                 
410         default:
411                 if(event>=B_PLUGBUT && event<=B_PLUGBUT+23) {
412                         PluginTex *pit= tex->plugin;
413                         if(pit && pit->callback) {
414                                 pit->callback(event - B_PLUGBUT);
415                                 BIF_preview_changed(ID_TE);
416                                 allqueue(REDRAWBUTSSHADING, 0);
417                         }
418                 }
419         }
420 }
421
422 static void texture_panel_plugin(Tex *tex)
423 {
424         uiBlock *block;
425         VarStruct *varstr;
426         PluginTex *pit;
427         short xco, yco, a;
428         
429         block= uiNewBlock(&curarea->uiblocks, "texture_panel_plugin", UI_EMBOSS, UI_HELV, curarea->win);
430         if(uiNewPanel(curarea, block, "Plugin", "Texture", 640, 0, 318, 204)==0) return;
431         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
432
433         if(tex->plugin && tex->plugin->doit) {
434                 
435                 pit= tex->plugin;
436                 
437                 for(a=0; a<pit->stypes; a++) {
438                         uiDefButS(block, ROW, B_TEXREDR_PRV, pit->stnames+16*a, (76*a), 152, 75, 20, &tex->stype, 2.0, (float)a, 0, 0, "");
439                 }
440                 
441                 varstr= pit->varstr;
442                 if(varstr) {
443                         for(a=0; a<pit->vars; a++, varstr++) {
444                                 xco= 140*(a/6)+1;
445                                 yco= 125 - 20*(a % 6)+1;
446                                 uiDefBut(block, varstr->type, B_PLUGBUT+a, varstr->name, xco,yco,137,19, &(pit->data[a]), varstr->min, varstr->max, 100, 0, varstr->tip);
447                         }
448                 }
449                 uiDefBut(block, TEX, B_NAMEPLUGIN, "",          0,180,318,24, pit->name, 0.0, 159.0, 0, 0, "");
450         }
451
452         uiDefBut(block, BUT, B_LOADPLUGIN, "Load Plugin", 0,204,137,24, 0, 0, 0, 0, 0, "");
453                         
454 }
455
456
457 static void texture_panel_magic(Tex *tex)
458 {
459         uiBlock *block;
460         
461         block= uiNewBlock(&curarea->uiblocks, "texture_panel_magic", UI_EMBOSS, UI_HELV, curarea->win);
462         if(uiNewPanel(curarea, block, "Magic", "Texture", 640, 0, 318, 204)==0) return;
463         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
464
465         uiBlockBeginAlign(block);
466         uiDefButS(block, NUM, B_TEXPRV, "Depth:",               10, 90, 150, 19, &tex->noisedepth, 0.0, 10.0, 0, 0, "Sets the depth of the pattern");
467         uiDefButF(block, NUM, B_TEXPRV, "Turbulence:",  10, 70, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Sets the strength of the pattern");
468 }
469
470 static void texture_panel_blend(Tex *tex)
471 {
472         uiBlock *block;
473         
474         block= uiNewBlock(&curarea->uiblocks, "texture_panel_blend", UI_EMBOSS, UI_HELV, curarea->win);
475         if(uiNewPanel(curarea, block, "Blend", "Texture", 640, 0, 318, 204)==0) return;
476         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
477
478         uiBlockBeginAlign(block);
479         uiDefButS(block, ROW, B_TEXPRV, "Lin",          10, 180, 75, 19, &tex->stype, 2.0, (float)TEX_LIN, 0, 0, "Creates a linear progresion"); 
480         uiDefButS(block, ROW, B_TEXPRV, "Quad",         85, 180, 75, 19, &tex->stype, 2.0, (float)TEX_QUAD, 0, 0, "Creates a quadratic progression"); 
481         uiDefButS(block, ROW, B_TEXPRV, "Ease",         160, 180, 75, 19, &tex->stype, 2.0, (float)TEX_EASE, 0, 0, "Creates a progression easing from one step to the next"); 
482         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");
483
484         uiDefButS(block, ROW, B_TEXPRV, "Diag",         10, 160, 75, 19, &tex->stype, 2.0, (float)TEX_DIAG, 0, 0, "Use a diagonal progression");
485         uiDefButS(block, ROW, B_TEXPRV, "Sphere",       85, 160, 75, 19, &tex->stype, 2.0, (float)TEX_SPHERE, 0, 0, "Use progression with the shape of a sphere");
486         uiDefButS(block, ROW, B_TEXPRV, "Halo",         160, 160, 75, 19, &tex->stype, 2.0, (float)TEX_HALO, 0, 0, "Use a quadratic progression with the shape of a sphere");
487         uiDefButS(block, ROW, B_TEXPRV, "Radial",       235, 160, 75, 19, &tex->stype, 2.0, (float)TEX_RAD, 0, 0, "Use a polar progression");
488         
489 }
490
491 /* newnoise: noisebasis menu string */
492 static char* noisebasis_menu()
493 {
494         static char nbmenu[256];
495         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);
496         return nbmenu;
497 }
498
499 static void texture_panel_wood(Tex *tex)
500 {
501         uiBlock *block;
502         
503         block= uiNewBlock(&curarea->uiblocks, "texture_panel_wood", UI_EMBOSS, UI_HELV, curarea->win);
504         if(uiNewPanel(curarea, block, "Wood", "Texture", 640, 0, 318, 204)==0) return;
505         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
506         
507         uiBlockBeginAlign(block);
508         uiDefButS(block, ROW, B_TEXPRV, "Bands",                10, 180, 75, 18, &tex->stype, 2.0, (float)TEX_BAND, 0, 0, "Uses standard wood texture in bands"); 
509         uiDefButS(block, ROW, B_TEXPRV, "Rings",                85, 180, 75, 18, &tex->stype, 2.0, (float)TEX_RING, 0, 0, "Uses wood texture in rings"); 
510         uiDefButS(block, ROW, B_TEXPRV, "BandNoise",    160, 180, 75, 18, &tex->stype, 2.0, (float)TEX_BANDNOISE, 0, 0, "Adds noise to standard wood"); 
511         uiDefButS(block, ROW, B_TEXPRV, "RingNoise",    235, 180, 75, 18, &tex->stype, 2.0, (float)TEX_RINGNOISE, 0, 0, "Adds noise to rings");
512         
513         uiDefButS(block, ROW, B_TEXPRV, "Sin",                  10, 160, 50, 19, &tex->noisebasis2, 8.0, (float)TEX_SIN, 0, 0, "Uses a sine wave to produce bands"); 
514         uiDefButS(block, ROW, B_TEXPRV, "Saw",                  60, 160, 50, 19, &tex->noisebasis2, 8.0, (float)TEX_SAW, 0, 0, "Uses a saw wave to produce bands"); 
515         uiDefButS(block, ROW, B_TEXPRV, "Tri",                  110, 160, 50, 19, &tex->noisebasis2, 8.0, (float)TEX_TRI, 0, 0, "Uses a triangle wave to produce bands");
516         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   160, 160, 75, 19, &tex->noisetype, 12.0, (float)TEX_NOISESOFT, 0, 0, "Generates soft noise");
517         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   235, 160, 75, 19, &tex->noisetype, 12.0, (float)TEX_NOISEPERL, 0, 0, "Generates hard noise");
518         
519         uiBlockBeginAlign(block);
520         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
521         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");
522         uiBlockEndAlign(block);
523         
524         /* newnoise: noisebasis menu */
525         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
526         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
527         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");      
528         
529 }
530
531 static void texture_panel_stucci(Tex *tex)
532 {
533         uiBlock *block;
534         
535         block= uiNewBlock(&curarea->uiblocks, "texture_panel_stucci", UI_EMBOSS, UI_HELV, curarea->win);
536         if(uiNewPanel(curarea, block, "Stucci", "Texture", 640, 0, 318, 204)==0) return;
537         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
538
539         uiBlockBeginAlign(block);
540         uiDefButS(block, ROW, B_TEXPRV, "Plastic",              10, 180, 100, 19, &tex->stype, 2.0, (float)TEX_PLASTIC, 0, 0, "Uses standard stucci");
541         uiDefButS(block, ROW, B_TEXPRV, "Wall In",              110, 180, 100, 19, &tex->stype, 2.0, (float)TEX_WALLIN, 0, 0, "Creates Dimples"); 
542         uiDefButS(block, ROW, B_TEXPRV, "Wall Out",             210, 180, 100, 19, &tex->stype, 2.0, (float)TEX_WALLOUT, 0, 0, "Creates Ridges"); 
543         
544         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   10, 160, 150, 19, &tex->noisetype, 12.0, (float)TEX_NOISESOFT, 0, 0, "Generates soft noise");
545         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   160, 160, 150, 19, &tex->noisetype, 12.0, (float)TEX_NOISEPERL, 0, 0, "Generates hard noise");
546
547         uiBlockBeginAlign(block);
548         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
549         uiDefButF(block, NUM, B_TEXPRV, "Turbulence:",  10, 90, 150, 19, &tex->turbul, 0.0, 200.0, 10, 0, "Sets the depth of the stucci");
550         uiBlockEndAlign(block);
551
552         /* newnoise: noisebasis menu */
553         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
554         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
555         // note, nabla not supported here!
556 //      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");      
557
558 }
559
560 static void texture_panel_marble(Tex *tex)
561 {
562         uiBlock *block;
563         
564         block= uiNewBlock(&curarea->uiblocks, "texture_panel_marble", UI_EMBOSS, UI_HELV, curarea->win);
565         if(uiNewPanel(curarea, block, "Marble", "Texture", 640, 0, 318, 204)==0) return;
566         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
567         
568         uiBlockBeginAlign(block);
569         uiDefButS(block, ROW, B_TEXPRV, "Soft",                 10, 180, 100, 18, &tex->stype, 2.0, (float)TEX_SOFT, 0, 0, "Uses soft marble"); 
570         uiDefButS(block, ROW, B_TEXPRV, "Sharp",                110, 180, 100, 18, &tex->stype, 2.0, (float)TEX_SHARP, 0, 0, "Uses more clearly defined marble"); 
571         uiDefButS(block, ROW, B_TEXPRV, "Sharper",              210, 180, 100, 18, &tex->stype, 2.0, (float)TEX_SHARPER, 0, 0, "Uses very clearly defined marble"); 
572         
573         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   10, 160, 150, 19, &tex->noisetype, 12.0, (float)TEX_NOISESOFT, 0, 0, "Generates soft noise");
574         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   160, 160, 150, 19, &tex->noisetype, 12.0, (float)TEX_NOISEPERL, 0, 0, "Generates hard noise");
575         
576         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."); 
577         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"); 
578         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"); 
579         
580         uiBlockBeginAlign(block);
581         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 110, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
582         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");
583         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");
584         uiBlockEndAlign(block);
585         
586         /* newnoise: noisebasis menu */
587         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
588         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
589         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");      
590         
591 }
592
593 static void texture_panel_clouds(Tex *tex)
594 {
595         uiBlock *block;
596         
597         block= uiNewBlock(&curarea->uiblocks, "texture_panel_clouds", UI_EMBOSS, UI_HELV, curarea->win);
598         if(uiNewPanel(curarea, block, "Clouds", "Texture", 640, 0, 318, 204)==0) return;
599         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
600
601         uiBlockBeginAlign(block);
602         uiDefButS(block, ROW, B_TEXPRV, "Default",              10, 180, 70, 18, &tex->stype, 2.0, (float)TEX_DEFAULT, 0, 0, "Uses standard noise"); 
603         uiDefButS(block, ROW, B_TEXPRV, "Color",                80, 180, 70, 18, &tex->stype, 2.0, (float)TEX_COLOR, 0, 0, "Lets Noise return RGB value"); 
604         uiDefButS(block, ROW, B_TEXPRV, "Soft noise",   155, 180, 75, 18, &tex->noisetype, 12.0, (float)TEX_NOISESOFT, 0, 0, "Generates soft noise");
605         uiDefButS(block, ROW, B_TEXPRV, "Hard noise",   230, 180, 80, 18, &tex->noisetype, 12.0, (float)TEX_NOISEPERL, 0, 0, "Generates hard noise");
606         uiBlockBeginAlign(block);
607         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize :",  10, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
608         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");
609         uiBlockEndAlign(block);
610         
611         /* newnoise: noisebasis menu */
612         uiDefBut(block, LABEL, 0, "Noise Basis",                10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
613         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(),     10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
614         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");      
615
616 }
617
618 /*****************************************/
619 /* newnoise: panel(s) for musgrave types */
620 /*****************************************/
621
622 static void texture_panel_musgrave(Tex *tex)
623 {
624         uiBlock *block;
625         char *str;
626         
627         block= uiNewBlock(&curarea->uiblocks, "texture_panel_musgrave", UI_EMBOSS, UI_HELV, curarea->win);
628         if(uiNewPanel(curarea, block, "Musgrave", "Texture", 640, 0, 318, 204)==0) return;
629         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
630         
631         /* TEX_MFRACTAL, TEX_RIDGEDMF, TEX_HYBRIDMF, TEX_FBM, TEX_HTERRAIN */
632         str= "Multifractal %x0|Ridged Multifractal %x1|Hybrid Multifractal %x2|Hetero Terrain %x4|fBm %x3";
633         uiDefButS(block, MENU, B_TEXREDR_PRV, str, 10, 160, 150, 19, &tex->stype, 0.0, 0.0, 0, 0, "Sets Musgrave type");
634         
635         uiBlockBeginAlign(block);
636         uiDefButF(block, NUMSLI, B_TEXPRV, "H: ", 10, 130, 150, 19, &tex->mg_H, 0.0001, 2.0, 10, 0, "Sets the highest fractal dimension");
637         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");
638         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");
639         if ((tex->stype==TEX_RIDGEDMF) || (tex->stype==TEX_HYBRIDMF) || (tex->stype==TEX_HTERRAIN)) {
640                 uiDefButF(block, NUMSLI, B_TEXPRV, "Ofst: ", 160, 110, 150, 19, &tex->mg_offset, 0.0, 6.0, 10, 0, "Sets the fractal offset");
641                 if ((tex->stype==TEX_RIDGEDMF) || (tex->stype==TEX_HYBRIDMF))
642                         uiDefButF(block, NUMSLI, B_TEXPRV, "Gain: ", 10, 90, 150, 19, &tex->mg_gain, 0.0, 6.0, 10, 0, "Sets the gain multiplier");
643         }
644
645         uiBlockBeginAlign(block);
646         /* noise output scale */
647         uiDefButF(block, NUM, B_TEXPRV, "iScale: ", 10, 60, 150, 19, &tex->ns_outscale, 0.0, 10.0, 10, 0, "Scales intensity output");   
648         /* frequency scale */
649         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize: ",  160, 60, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
650         uiBlockEndAlign(block);
651
652         /* noisebasis menu */
653         uiDefBut(block, LABEL, 0, "Noise Basis", 10, 30, 150, 19, 0, 0.0, 0.0, 0, 0, "");
654         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(), 10, 10, 150, 19, &tex->noisebasis, 0,0,0,0, "Sets the noise basis used for turbulence");
655         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");      
656
657 }
658
659
660 static void texture_panel_distnoise(Tex *tex)
661 {
662         uiBlock *block;
663         block= uiNewBlock(&curarea->uiblocks, "texture_panel_distnoise", UI_EMBOSS, UI_HELV, curarea->win);
664         if(uiNewPanel(curarea, block, "Distorted Noise", "Texture", 640, 0, 318, 204)==0) return;
665         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
666
667         uiBlockBeginAlign(block);
668         /* distortion amount */
669         uiDefButF(block, NUM, B_TEXPRV, "DistAmnt: ", 10, 130, 150, 19, &tex->dist_amount, 0.0, 10.0, 10, 0, "Sets amount of distortion");      
670         /* frequency scale */
671         uiDefButF(block, NUM, B_TEXPRV, "NoiseSize: ",  160, 130, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
672         uiBlockEndAlign(block);
673         
674         uiDefBut(block, LABEL, 0, "Distortion Noise", 10, 100, 150, 19, 0, 0.0, 0.0, 0, 0, "");
675         uiDefBut(block, LABEL, 0, "Noise Basis",        160, 100, 150, 19, 0, 0.0, 0.0, 0, 0, "");
676
677         uiBlockBeginAlign(block);
678         /* noisebasis used for the distortion */        
679         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");
680         /* noisebasis to distort */
681         uiDefButS(block, MENU, B_TEXPRV, noisebasis_menu(), 160, 80, 150, 19, &tex->noisebasis2, 0,0,0,0, "Sets the noise basis to distort");
682         uiBlockEndAlign(block);
683
684         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");       
685 }
686
687
688 static void texture_panel_voronoi(Tex *tex)
689 {
690         char dm_menu[256];
691         uiBlock *block;
692         block= uiNewBlock(&curarea->uiblocks, "texture_panel_voronoi", UI_EMBOSS, UI_HELV, curarea->win);
693         if(uiNewPanel(curarea, block, "Voronoi", "Texture", 640, 0, 318, 204)==0) return;
694         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
695
696         /* color types */
697         uiBlockBeginAlign(block);
698         uiDefButS(block, ROW, B_TEXPRV, "Int", 10, 180, 75, 18, &tex->vn_coltype, 1.0, 0.0, 0, 0, "Only calculate intensity"); 
699         uiDefButS(block, ROW, B_TEXPRV, "Col1", 85, 180, 75, 18, &tex->vn_coltype, 1.0, 1.0, 0, 0, "Color cells by position"); 
700         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"); 
701         uiDefButS(block, ROW, B_TEXPRV, "Col3", 235, 180, 75, 18, &tex->vn_coltype, 1.0, 3.0, 0, 0, "Same as Col2 * intensity"); 
702         uiBlockEndAlign(block);
703
704         /* distance metric */
705         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);
706         uiDefBut(block, LABEL, B_TEXPRV, "Distance Metric", 10, 160, 150, 19, 0, 0, 0, 0, 0, "");
707         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");
708
709         if (tex->vn_distm==TEX_MINKOVSKY)
710                 uiDefButF(block, NUMSLI, B_TEXPRV, "Exp: ", 10, 120, 150, 19, &tex->vn_mexp, 0.01, 10.0, 10, 0, "Sets minkovsky exponent");
711
712         uiBlockBeginAlign(block);
713         uiDefButF(block, NUM, B_TEXPRV, "iScale: ", 160, 140, 150, 19, &tex->ns_outscale, 0.01, 10.0, 10, 0, "Scales intensity output");
714         uiDefButF(block, NUM, B_TEXPRV, "Size: ",       160, 120, 150, 19, &tex->noisesize, 0.0001, 2.0, 10, 0, "Sets scaling for noise input");
715         uiBlockBeginAlign(block);
716         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");      
717
718         /* weights */
719         uiBlockBeginAlign(block);
720         uiDefButF(block, NUMSLI, B_TEXPRV, "W1: ", 10, 70, 150, 19, &tex->vn_w1, -2.0, 2.0, 10, 0, "Sets feature weight 1");
721         uiDefButF(block, NUMSLI, B_TEXPRV, "W2: ", 10, 50, 150, 19, &tex->vn_w2, -2.0, 2.0, 10, 0, "Sets feature weight 2");
722         uiDefButF(block, NUMSLI, B_TEXPRV, "W3: ", 10, 30, 150, 19, &tex->vn_w3, -2.0, 2.0, 10, 0, "Sets feature weight 3");
723         uiDefButF(block, NUMSLI, B_TEXPRV, "W4: ", 10, 10, 150, 19, &tex->vn_w4, -2.0, 2.0, 10, 0, "Sets feature weight 4");
724 }
725
726
727 static char *layer_menu(RenderResult *rr, short *curlay)
728 {
729         RenderLayer *rl;
730         int len= 64 + 32*BLI_countlist(&rr->layers);
731         short a, nr= 0;
732         char *str= MEM_callocN(len, "menu layers");
733         
734         strcpy(str, "Layer %t");
735         a= strlen(str);
736         
737         /* compo result */
738         if(rr->rectf) {
739                 a+= sprintf(str+a, "|Composite %%x0");
740                 nr= 1;
741         }
742         for(rl= rr->layers.first; rl; rl= rl->next, nr++) {
743                 a+= sprintf(str+a, "|%s %%x%d", rl->name, nr);
744         }
745         
746         if(*curlay >= nr)
747                 *curlay= 0;
748         
749         return str;
750 }
751
752 /* rl==NULL means composite result */
753 static char *pass_menu(RenderLayer *rl, short *curpass)
754 {
755         RenderPass *rpass;
756         int len= 64 + 32*(rl?BLI_countlist(&rl->passes):1);
757         short a, nr= 0;
758         char *str= MEM_callocN(len, "menu layers");
759         
760         strcpy(str, "Pass %t");
761         a= strlen(str);
762         
763         /* rendered results don't have a Combined pass */
764         if(rl==NULL || rl->rectf) {
765                 a+= sprintf(str+a, "|Combined %%x0");
766                 nr= 1;
767         }
768         
769         if(rl)
770                 for(rpass= rl->passes.first; rpass; rpass= rpass->next, nr++)
771                         a+= sprintf(str+a, "|%s %%x%d", rpass->name, nr);
772         
773         if(*curpass >= nr)
774                 *curpass= 0;
775         
776         return str;
777 }
778
779 static void set_frames_cb(void *ima_v, void *iuser_v)
780 {
781         Image *ima= ima_v;
782         ImageUser *iuser= iuser_v;
783         
784         if(ima->anim) {
785                 iuser->frames = IMB_anim_get_duration(ima->anim);
786                 BKE_image_user_calc_imanr(iuser, G.scene->r.cfra, 0);
787         }
788 }
789
790 static void image_src_change_cb(void *ima_v, void *iuser_v)
791 {
792         BKE_image_signal(ima_v, iuser_v, IMA_SIGNAL_SRC_CHANGE);
793 }
794
795 /* buttons have 2 arg callbacks, filewindow has 3 args... so thats why the wrapper below */
796 static void image_browse_cb1(char *unused, void *ima_pp_v, void *iuser_v)
797 {
798         Image **ima_pp= (Image **)ima_pp_v;
799         ImageUser *iuser= iuser_v;
800         
801         if(ima_pp) {
802                 Image *ima= *ima_pp;
803                 
804                 if(iuser->menunr== -2) {
805                         activate_databrowse_args(&ima->id, ID_IM, 0, &iuser->menunr, image_browse_cb1, ima_pp, iuser);
806                 } 
807                 else if (iuser->menunr>0) {
808                         Image *newima= (Image*) BLI_findlink(&G.main->image, iuser->menunr-1);
809                         
810                         if (newima && newima!=ima) {
811                                 *ima_pp= newima;
812                                 id_us_plus(&newima->id);
813                                 if(ima) ima->id.us--;
814                                 
815                                 BKE_image_signal(newima, iuser, IMA_SIGNAL_USER_NEW_IMAGE);
816                                 
817                                 BIF_undo_push("Browse image");
818                         }
819                 }
820         }
821 }
822
823 static void image_browse_cb(void *ima_pp_v, void *iuser_v)
824 {
825         image_browse_cb1(NULL, ima_pp_v, iuser_v);
826 }
827
828 static void image_reload_cb(void *ima_v, void *iuser_v)
829 {
830         if(ima_v) {
831                 BKE_image_signal(ima_v, iuser_v, IMA_SIGNAL_RELOAD);
832         }
833 }
834
835 static void image_field_test(void *ima_v, void *iuser_v)
836 {
837         Image *ima= ima_v;
838         
839         if(ima) {
840                 ImBuf *ibuf= BKE_image_get_ibuf(ima, iuser_v);
841                 if(ibuf) {
842                         short nr= 0;
843                         if( !(ima->flag & IMA_FIELDS) && (ibuf->flags & IB_fields) ) nr= 1;
844                         if( (ima->flag & IMA_FIELDS) && !(ibuf->flags & IB_fields) ) nr= 1;
845                         if(nr) {
846                                 BKE_image_signal(ima, iuser_v, IMA_SIGNAL_FREE);
847                         }
848                 }
849         }
850 }
851
852 static void image_unlink_cb(void *ima_pp_v, void *unused)
853 {
854         Image **ima_pp= (Image **)ima_pp_v;
855         
856         if(ima_pp && *ima_pp) {
857                 Image *ima= *ima_pp;
858                 ima->id.us--;
859                 *ima_pp= NULL;
860         }
861 }
862
863 static void image_load_fs_cb(void *ima_pp_v, void *iuser_v)
864 {
865         Image **ima_pp= (Image **)ima_pp_v;
866         ScrArea *sa;
867         char *name;
868         
869         if(ima_pp==NULL) return;
870         
871         sa= closest_bigger_area();
872         areawinset(sa->win);
873         if(*ima_pp) name= (*ima_pp)->name;
874 #ifdef _WIN32
875         else {
876                 if (strcmp (U.textudir, "/") == 0)
877                         name= G.sce;
878                 else
879                         name= U.textudir;
880         }
881 #else
882         else name = U.textudir;
883 #endif
884         if (G.qual & LR_CTRLKEY) {
885                 activate_imageselect_args(FILE_SPECIAL, "SELECT IMAGE", name, load_image_cb, ima_pp_v, iuser_v);
886         }
887         else  {
888                 activate_fileselect_args(FILE_SPECIAL, "SELECT IMAGE", name, load_image_cb, ima_pp_v, iuser_v);
889         }
890 }
891
892 /* 5 layer button callbacks... */
893 static void image_multi_cb(void *rr_v, void *iuser_v) 
894 {
895         BKE_image_multilayer_index(rr_v, iuser_v); 
896 }
897 static void image_multi_inclay_cb(void *rr_v, void *iuser_v) 
898 {
899         RenderResult *rr= rr_v;
900         ImageUser *iuser= iuser_v;
901         int tot= BLI_countlist(&rr->layers) + (rr->rectf?1:0);  /* fake compo result layer */
902         if(iuser->layer<tot-1)
903                 iuser->layer++;
904         BKE_image_multilayer_index(rr, iuser); 
905 }
906 static void image_multi_declay_cb(void *rr_v, void *iuser_v) 
907 {
908         ImageUser *iuser= iuser_v;
909         if(iuser->layer>0)
910                 iuser->layer--;
911         BKE_image_multilayer_index(rr_v, iuser); 
912 }
913 static void image_multi_incpass_cb(void *rr_v, void *iuser_v) 
914 {
915         RenderResult *rr= rr_v;
916         ImageUser *iuser= iuser_v;
917         RenderLayer *rl= BLI_findlink(&rr->layers, iuser->layer);
918         if(rl) {
919                 int tot= BLI_countlist(&rl->passes) + (rl->rectf?1:0);  /* builtin render result has no combined pass in list */
920                 if(iuser->pass<tot-1) {
921                         iuser->pass++;
922                         BKE_image_multilayer_index(rr, iuser); 
923                 }
924         }
925 }
926 static void image_multi_decpass_cb(void *rr_v, void *iuser_v) 
927 {
928         ImageUser *iuser= iuser_v;
929         if(iuser->pass>0) {
930                 iuser->pass--;
931                 BKE_image_multilayer_index(rr_v, iuser); 
932         }
933 }
934
935 static void image_pack_cb(void *ima_v, void *iuser_v) 
936 {
937         if(ima_v) {
938                 Image *ima= ima_v;
939                 if(ima->source!=IMA_SRC_SEQUENCE && ima->source!=IMA_SRC_MOVIE) {
940                         if (ima->packedfile) {
941                                 if (G.fileflags & G_AUTOPACK) {
942                                         if (okee("Disable AutoPack ?")) {
943                                                 G.fileflags &= ~G_AUTOPACK;
944                                         }
945                                 }
946                                 
947                                 if ((G.fileflags & G_AUTOPACK) == 0) {
948                                         unpackImage(ima, PF_ASK);
949                                         BIF_undo_push("Unpack image");
950                                 }
951                         } 
952                         else {
953                                 ImBuf *ibuf= BKE_image_get_ibuf(ima, iuser_v);
954                                 if (ibuf && (ibuf->userflags & IB_BITMAPDIRTY)) {
955                                         error("Can't pack painted image. Save image or use Repack as PNG.");
956                                 } else {
957                                         ima->packedfile = newPackedFile(ima->name);
958                                         BIF_undo_push("Pack image");
959                                 }
960                         }
961                 }
962         }
963 }
964
965 static void image_load_cb(void *ima_pp_v, void *iuser_v)
966 {
967         if(ima_pp_v) {
968                 Image *ima= *((Image **)ima_pp_v);
969                 ImBuf *ibuf= BKE_image_get_ibuf(ima, iuser_v);
970                 char str[FILE_MAX];
971         
972                 /* name in ima has been changed by button! */
973                 BLI_strncpy(str, ima->name, FILE_MAX);
974                 if(ibuf) BLI_strncpy(ima->name, ibuf->name, FILE_MAX);
975                 
976                 load_image_cb(str, ima_pp_v, iuser_v);
977         }
978 }
979
980 static void image_freecache_cb(void *ima_v, void *unused) 
981 {
982         BKE_image_free_anim_ibufs(ima_v, G.scene->r.cfra);
983         allqueue(REDRAWIMAGE, 0);
984 }
985
986 static void image_generated_change_cb(void *ima_v, void *iuser_v)
987 {
988         BKE_image_signal(ima_v, iuser_v, IMA_SIGNAL_FREE);
989 }
990
991 static void image_user_change(void *iuser_v, void *unused)
992 {
993         BKE_image_user_calc_imanr(iuser_v, G.scene->r.cfra, 0);
994 }
995
996 void uiblock_layer_pass_buttons(uiBlock *block, RenderResult *rr, ImageUser *iuser, int event, int x, int y, int w)
997 {
998         uiBut *but;
999         RenderLayer *rl= NULL;
1000         int wmenu1, wmenu2;
1001         char *strp;
1002
1003         /* layer menu is 1/3 larger than pass */
1004         wmenu1= (3*w)/5;
1005         wmenu2= (2*w)/5;
1006         
1007         /* menu buts */
1008         strp= layer_menu(rr, &iuser->layer);
1009         but= uiDefButS(block, MENU, event, strp,                                        x, y, wmenu1, 20, &iuser->layer, 0,0,0,0, "Select Layer");
1010         uiButSetFunc(but, image_multi_cb, rr, iuser);
1011         MEM_freeN(strp);
1012         
1013         rl= BLI_findlink(&rr->layers, iuser->layer - (rr->rectf?1:0)); /* fake compo layer, return NULL is meant to be */
1014         strp= pass_menu(rl, &iuser->pass);
1015         but= uiDefButS(block, MENU, event, strp,                                        x+wmenu1, y, wmenu2, 20, &iuser->pass, 0,0,0,0, "Select Pass");
1016         uiButSetFunc(but, image_multi_cb, rr, iuser);
1017         MEM_freeN(strp);        
1018 }
1019
1020 static void uiblock_layer_pass_arrow_buttons(uiBlock *block, RenderResult *rr, ImageUser *iuser, int imagechanged) 
1021 {
1022         uiBut *but;
1023         
1024         if(rr==NULL || iuser==NULL)
1025                 return;
1026         if(rr->layers.first==NULL) {
1027                 uiDefBut(block, LABEL, 0, "No Layers in Render Result,",        10, 107, 300, 20, NULL, 1, 0, 0, 0, "");
1028                 return;
1029         }
1030         
1031         uiBlockBeginAlign(block);
1032
1033         /* decrease, increase arrows */
1034         but= uiDefIconBut(block, BUT, imagechanged, ICON_TRIA_LEFT,     10,107,17,20, NULL, 0, 0, 0, 0, "Previous Layer");
1035         uiButSetFunc(but, image_multi_declay_cb, rr, iuser);
1036         but= uiDefIconBut(block, BUT, imagechanged, ICON_TRIA_RIGHT,    27,107,18,20, NULL, 0, 0, 0, 0, "Next Layer");
1037         uiButSetFunc(but, image_multi_inclay_cb, rr, iuser);
1038
1039         uiblock_layer_pass_buttons(block, rr, iuser, imagechanged, 45, 107, 230);
1040
1041         /* decrease, increase arrows */
1042         but= uiDefIconBut(block, BUT, imagechanged, ICON_TRIA_LEFT,     275,107,17,20, NULL, 0, 0, 0, 0, "Previous Pass");
1043         uiButSetFunc(but, image_multi_decpass_cb, rr, iuser);
1044         but= uiDefIconBut(block, BUT, imagechanged, ICON_TRIA_RIGHT,    292,107,18,20, NULL, 0, 0, 0, 0, "Next Pass");
1045         uiButSetFunc(but, image_multi_incpass_cb, rr, iuser);
1046
1047         uiBlockEndAlign(block);
1048                          
1049 }
1050
1051 /* The general Image panel with the loadsa callbacks! */
1052 void uiblock_image_panel(uiBlock *block, Image **ima_pp, ImageUser *iuser, 
1053                                                  short redraw, short imagechanged)
1054 {
1055         Image *ima= *ima_pp;
1056         uiBut *but;
1057         char str[128], *strp;
1058         
1059         /* different stuff when we show viewer */
1060         if(ima && ima->source==IMA_SRC_VIEWER) {
1061                 ImBuf *ibuf= BKE_image_get_ibuf(ima, iuser);
1062                 
1063                 image_info(ima, ibuf, str);
1064                 uiDefBut(block, LABEL, 0, ima->id.name+2,       10, 180, 300, 20, NULL, 1, 0, 0, 0, "");
1065                 uiDefBut(block, LABEL, 0, str,                          10, 160, 300, 20, NULL, 1, 0, 0, 0, "");
1066                 
1067                 if(ima->type==IMA_TYPE_COMPOSITE) {
1068                         iuser= ntree_get_active_iuser(G.scene->nodetree);
1069                         if(iuser) {
1070                                 uiBlockBeginAlign(block);
1071                                 uiDefIconTextBut(block, BUT, B_SIMA_RECORD, ICON_REC, "Record", 10,120,100,20, 0, 0, 0, 0, 0, "");
1072                                 uiDefIconTextBut(block, BUT, B_SIMA_PLAY, ICON_PLAY, "Play",    110,120,100,20, 0, 0, 0, 0, 0, "");
1073                                 but= uiDefBut(block, BUT, B_NOP, "Free Cache",  210,120,100,20, 0, 0, 0, 0, 0, "");
1074                                 uiButSetFunc(but, image_freecache_cb, ima, NULL);
1075                                 
1076                                 if(iuser->frames)
1077                                         sprintf(str, "(%d) Frames:", iuser->framenr);
1078                                 else strcpy(str, "Frames:");
1079                                 uiBlockBeginAlign(block);
1080                                 uiDefButI(block, NUM, imagechanged, str,                10, 90,150, 20, &iuser->frames, 0.0, MAXFRAMEF, 0, 0, "Sets the number of images of a movie to use");
1081                                 uiDefButI(block, NUM, imagechanged, "StartFr:", 160,90,150,20, &iuser->sfra, 1.0, MAXFRAMEF, 0, 0, "Sets the global starting frame of the movie");
1082                         }
1083                 }
1084                 else if(ima->type==IMA_TYPE_R_RESULT) {
1085                         /* browse layer/passes */
1086                         uiblock_layer_pass_arrow_buttons(block, RE_GetResult(RE_GetRender(G.scene->id.name)), iuser, imagechanged);
1087                 }
1088                 return;
1089         }
1090         
1091         /* the main ima source types */
1092         if(ima) {
1093                 uiSetButLock(ima->id.lib!=NULL, ERROR_LIBDATA_MESSAGE);
1094                 uiBlockBeginAlign(block);
1095                 uiBlockSetFunc(block, image_src_change_cb, ima, iuser);
1096                 uiDefButS(block, ROW, imagechanged, "Still",            10, 180, 60, 20, &ima->source, 0.0, IMA_SRC_FILE, 0, 0, "Single Image file");
1097                 uiDefButS(block, ROW, imagechanged, "Movie",            70, 180, 60, 20, &ima->source, 0.0, IMA_SRC_MOVIE, 0, 0, "Movie file");
1098                 uiDefButS(block, ROW, imagechanged, "Sequence", 130, 180, 90, 20, &ima->source, 0.0, IMA_SRC_SEQUENCE, 0, 0, "Multiple Image files, as a sequence");
1099                 uiDefButS(block, ROW, imagechanged, "Generated",        220, 180, 90, 20, &ima->source, 0.0, IMA_SRC_GENERATED, 0, 0, "Generated Image");
1100                 uiBlockSetFunc(block, NULL, NULL, NULL);
1101         }
1102         else
1103                 uiDefBut(block, LABEL, 0, " ",                                  10, 180, 300, 20, 0, 0, 0, 0, 0, "");   /* for align in panel */
1104                                  
1105          /* Browse */
1106          IMAnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), NULL, &iuser->menunr);
1107          
1108          uiBlockBeginAlign(block);
1109          but= uiDefButS(block, MENU, imagechanged, strp,                10,155,23,20, &iuser->menunr, 0, 0, 0, 0, "Selects an existing Image or Movie");
1110          uiButSetFunc(but, image_browse_cb, ima_pp, iuser);
1111          
1112          MEM_freeN(strp);
1113          
1114          /* name + options, or only load */
1115          if(ima) {
1116                  int drawpack= (ima->source!=IMA_SRC_SEQUENCE && ima->source!=IMA_SRC_MOVIE && ima->ok);
1117
1118                  but= uiDefBut(block, TEX, B_IDNAME, "IM:",             33, 155, 177, 20, ima->id.name+2, 0.0, 21.0, 0, 0, "Current Image Datablock name.");
1119                  uiButSetFunc(but, test_idbutton_cb, ima->id.name, NULL);
1120                  but= uiDefBut(block, BUT, imagechanged, "Reload",              210, 155, 60, 20, NULL, 0, 0, 0, 0, "Reloads Image or Movie");
1121                  uiButSetFunc(but, image_reload_cb, ima, iuser);
1122                  
1123                  but= uiDefIconBut(block, BUT, imagechanged, ICON_X,    270,155,20,20, 0, 0, 0, 0, 0, "Unlink Image block");
1124                  uiButSetFunc(but, image_unlink_cb, ima_pp, NULL);
1125                  sprintf(str, "%d", ima->id.us);
1126                  uiDefBut(block, BUT, B_NOP, str,                                       290,155,20,20, 0, 0, 0, 0, 0, "Only displays number of users of Image block");
1127                  
1128                  but= uiDefIconBut(block, BUT, imagechanged, ICON_FILESEL,      10, 135, 23, 20, 0, 0, 0, 0, 0, "Open Fileselect to load new Image");
1129                  uiButSetFunc(but, image_load_fs_cb, ima_pp, iuser);
1130                  but= uiDefBut(block, TEX, imagechanged, "",                            33,135,257+(drawpack?0:20),20, ima->name, 0.0, 239.0, 0, 0, "Image/Movie file name, change to load new");
1131                  uiButSetFunc(but, image_load_cb, ima_pp, iuser);
1132                  
1133                  if(drawpack) {
1134                          if (ima->packedfile) packdummy = 1;
1135                          else packdummy = 0;
1136                          but= uiDefIconButBitI(block, TOG, 1, redraw, ICON_PACKAGE, 290,135,20,20, &packdummy, 0, 0, 0, 0, "Toggles Packed status of this Image");
1137                          uiButSetFunc(but, image_pack_cb, ima, iuser);
1138                  }
1139                  
1140          }
1141          else {
1142                  but= uiDefBut(block, BUT, imagechanged, "Load",                33, 155, 100,20, NULL, 0, 0, 0, 0, "Load new Image of Movie");
1143                  uiButSetFunc(but, image_load_fs_cb, ima_pp, iuser);
1144          }
1145          uiBlockEndAlign(block);
1146          
1147          if(ima) {
1148                  ImBuf *ibuf= BKE_image_get_ibuf(ima, iuser);
1149                  
1150                  /* check for re-render, only buttons */
1151                  if(imagechanged==B_IMAGECHANGED) {
1152                          if(iuser->flag & IMA_ANIM_REFRESHED) {
1153                                  iuser->flag &= ~IMA_ANIM_REFRESHED;
1154                                  BIF_preview_changed(ID_TE);
1155                          }
1156                  }
1157                  
1158                  /* multilayer? */
1159                  if(ima->type==IMA_TYPE_MULTILAYER && ima->rr) {
1160                          uiblock_layer_pass_arrow_buttons(block, ima->rr, iuser, imagechanged);
1161                  }
1162                  else {
1163                          image_info(ima, ibuf, str);
1164                          uiDefBut(block, LABEL, 0, str,         10, 112, 300, 20, NULL, 1, 0, 0, 0, "");
1165                  }
1166                  
1167                  /* exception, let's do because we only use this panel 3 times in blender... but not real good code! */
1168                  if( (FACESEL_PAINT_TEST) && G.sima && &G.sima->iuser==iuser)
1169                          return;
1170                  /* left side default per-image options, right half the additional options */
1171                  
1172                  /* fields */
1173                  uiBlockBeginAlign(block);
1174                  but= uiDefButBitS(block, TOG, IMA_FIELDS, imagechanged, "Fields",      10, 90, 65, 20, &ima->flag, 0, 0, 0, 0, "Click to enable use of fields in Image");
1175                  uiButSetFunc(but, image_field_test, ima, iuser);
1176                  uiDefButBitS(block, TOG, IMA_STD_FIELD, B_NOP, "Odd",                  75, 90, 45, 20, &ima->flag, 0, 0, 0, 0, "Standard Field Toggle");
1177                  
1178                  uiBlockSetFunc(block, image_reload_cb, ima, iuser);
1179                  uiDefButBitS(block, TOG, IMA_ANTIALI, B_NOP, "Anti",                   10, 70, 45, 20, &ima->flag, 0, 0, 0, 0, "Toggles Image anti-aliasing, only works with solid colors");
1180                  uiDefButBitS(block, TOG, IMA_DO_PREMUL, imagechanged, "Premul",                55, 70, 65, 20, &ima->flag, 0, 0, 0, 0, "Toggles premultiplying alpha");
1181                  uiBlockEndAlign(block);
1182                  
1183                  if( ELEM(ima->source, IMA_SRC_MOVIE, IMA_SRC_SEQUENCE)) {
1184                          sprintf(str, "(%d) Frames:", iuser->framenr);
1185                          
1186                          uiBlockBeginAlign(block);
1187                          uiBlockSetFunc(block, image_user_change, iuser, NULL);
1188                          uiDefButBitS(block, TOG, IMA_ANIM_ALWAYS, B_NOP, "Auto Refresh",       120, 90, 190, 20, &iuser->flag, 0, 0, 0, 0, "Always refresh Image on frame changes");
1189                          
1190                          if(ima->anim) {
1191                                  uiDefButI(block, NUM, imagechanged, str,               120, 70,170, 20, &iuser->frames, 0.0, MAXFRAMEF, 0, 0, "Sets the number of images of a movie to use");
1192                                  but= uiDefBut(block, BUT, redraw, "<",         290, 70, 20, 20, 0, 0, 0, 0, 0, "Copies number of frames in movie file to Frames: button");
1193                                  uiButSetFunc(but, set_frames_cb, ima, iuser);
1194                          }
1195                          else 
1196                                  uiDefButI(block, NUM, imagechanged, str,               120, 70,190, 20, &iuser->frames, 0.0, MAXFRAMEF, 0, 0, "Sets the number of images of a movie to use");
1197                          
1198                          uiDefButI(block, NUM, imagechanged, "Offs:",   120,50,100,20, &iuser->offset, -MAXFRAMEF, MAXFRAMEF, 0, 0, "Offsets the number of the frame to use in the animation");
1199                          uiDefButS(block, NUM, imagechanged, "Fie/Ima:",        220,50,90,20, &iuser->fie_ima, 1.0, 200.0, 0, 0, "The number of fields per rendered frame (2 fields is 1 image)");
1200                          
1201                          uiDefButI(block, NUM, imagechanged, "StartFr:",        120,30,100,20, &iuser->sfra, 1.0, MAXFRAMEF, 0, 0, "Sets the global starting frame of the movie");
1202                          uiDefButS(block, TOG, imagechanged, "Cyclic",  220,30,90,20, &iuser->cycl, 0.0, 1.0, 0, 0, "Cycle the images in the movie");
1203                          
1204                          uiBlockSetFunc(block, NULL, iuser, NULL);
1205                  }
1206                  else if(ima->source==IMA_SRC_GENERATED) {
1207                          
1208                          uiBlockBeginAlign(block);
1209                          uiBlockSetFunc(block, image_generated_change_cb, ima, iuser);
1210                          uiDefButS(block, NUM, imagechanged, "SizeX:",  120,90,100,20, &ima->gen_x, 1.0, 5000.0, 0, 0, "Image size x");
1211                          uiDefButS(block, NUM, imagechanged, "SizeY:",  220,90,90,20, &ima->gen_y, 1.0, 5000.0, 0, 0, "Image size y");
1212                          uiDefButS(block, TOG, imagechanged, "UV Test grid",120,70,190,20, &ima->gen_type, 0.0, 1.0, 0, 0, "");
1213                          uiBlockSetFunc(block, NULL, NULL, NULL);
1214                  }
1215          }
1216          uiBlockEndAlign(block);
1217 }       
1218
1219 static void texture_panel_image(Image **ima, ImageUser *iuser)
1220 {
1221         uiBlock *block;
1222         
1223         block= uiNewBlock(&curarea->uiblocks, "texture_panel_image", UI_EMBOSS, UI_HELV, curarea->win);
1224         if(uiNewPanel(curarea, block, "Image", "Texture", 960, 0, 318, 204)==0) return;
1225         
1226         uiblock_image_panel(block, ima, iuser, B_REDR, B_IMAGECHANGED);
1227 }       
1228
1229 static void texture_panel_image_map(Tex *tex, MTex *mtex)
1230 {
1231         uiBlock *block;
1232         
1233         block= uiNewBlock(&curarea->uiblocks, "texture_panel_image_map", UI_EMBOSS, UI_HELV, curarea->win);
1234         if(uiNewPanel(curarea, block, "Map Image", "Texture", 640, 0, 318, 204)==0) return;
1235         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
1236
1237         /* types */
1238         uiBlockBeginAlign(block);
1239         uiDefButBitS(block, TOG, TEX_MIPMAP, B_IMAGECHANGED, "MipMap",  10, 180, 75, 20, &tex->imaflag, 0, 0, 0, 0, "Generates and uses mipmaps");
1240         uiDefButBitS(block, TOG, TEX_GAUSS_MIP, 0, "Gauss",                     85, 180, 75, 20, &tex->imaflag, 0, 0, 0, 0, "Enable Gauss filter to sample down mipmaps");
1241         uiDefButBitS(block, TOG, TEX_INTERPOL, 0, "Interpol",           160, 180, 75, 20, &tex->imaflag, 0, 0, 0, 0, "Interpolates pixels using Area filter");
1242         uiDefButBitS(block, TOG, TEX_IMAROT, B_TEXPRV, "Rot90",         235, 180, 75, 20, &tex->imaflag, 0, 0, 0, 0, "Actually flips X and Y for rendering, rotates and mirrors");
1243         
1244         uiDefButBitS(block, TOG, TEX_USEALPHA, B_TEXPRV, "UseAlpha",    10, 160, 100, 20, &tex->imaflag, 0, 0, 0, 0, "Click to use Image's alpha channel");
1245         uiDefButBitS(block, TOG, TEX_CALCALPHA, B_TEXPRV, "CalcAlpha",  110, 160, 100, 20, &tex->imaflag, 0, 0, 0, 0, "Click to calculate an alpha channel based on Image RGB values");
1246         uiDefButBitS(block, TOG, TEX_NEGALPHA, B_TEXPRV, "NegAlpha",    210, 160, 100, 20, &tex->flag, 0, 0, 0, 0, "Click to invert the alpha values");
1247
1248         uiBlockBeginAlign(block);
1249         uiDefButBitS(block, TOG, TEX_FILTER_MIN, B_TEXPRV, "Min",       10, 120, 30, 20, &tex->imaflag, 0, 0, 0, 0, "Use Filtersize as a minimal filter value in pixels");
1250         uiDefButF(block, NUM, B_TEXPRV, "Filter: ",                                     40,120,120,20, &tex->filtersize, 0.1, 50.0, 10, 3, "Multiplies the filter size used by mipmap and interpol");
1251         
1252         uiBlockBeginAlign(block);
1253         uiDefButBitS(block, TOG, TEX_NORMALMAP, B_NOP, "Normal Map",    160,120,(mtex)? 75: 150,20, &tex->imaflag,
1254                                         0, 0, 0, 0, "Use image RGB values for normal mapping");
1255         if(mtex)
1256                 uiDefButS(block, MENU, B_DIFF, "Normal Space %t|Camera %x0|World %x1|Object %x2|Tangent %x3", 
1257                                                 235,120,75,20, &mtex->normapspace, 0, 0, 0, 0, "Sets space of normal map image");
1258         uiBlockEndAlign(block);
1259
1260         /* crop extend clip */
1261         
1262         uiBlockBeginAlign(block);
1263         uiDefButS(block, ROW, B_TEXREDR_PRV, "Extend",                  10,90,63,19, &tex->extend, 4.0, 1.0, 0, 0, "Extends the color of the edge pixels");
1264         uiDefButS(block, ROW, B_TEXREDR_PRV, "Clip",                    73,90,48,19, &tex->extend, 4.0, 2.0, 0, 0, "Sets alpha 0.0 outside Image edges");
1265         uiDefButS(block, ROW, B_TEXREDR_PRV, "ClipCube",                121,90,63,19, &tex->extend, 4.0, 4.0, 0, 0, "Sets alpha to 0.0 outside cubeshaped area around Image");
1266         uiDefButS(block, ROW, B_TEXREDR_PRV, "Repeat",                  184,90,63,19, &tex->extend, 4.0, 3.0, 0, 0, "Causes Image to repeat horizontally and vertically");
1267         uiDefButS(block, ROW, B_TEXREDR_PRV, "Checker",                 247,90,63,19, &tex->extend, 4.0, 5.0, 0, 0, "Causes Image to repeat in checker pattern");
1268
1269         if(tex->extend==TEX_REPEAT) {
1270                 uiBlockBeginAlign(block);
1271                 uiDefButBitS(block, TOG, TEX_REPEAT_XMIR, B_TEXPRV, "Mirr",     10,60,30,19, &tex->flag, 0.0, 0.0, 0, 0, "Mirrors X direction repeat");
1272                 uiDefButS(block, NUM, B_TEXPRV, "Xrepeat:",     40,60,120,19, &tex->xrepeat, 1.0, 512.0, 0, 0, "Sets a repetition multiplier in the X direction");
1273                 uiDefButBitS(block, TOG, TEX_REPEAT_YMIR, B_TEXPRV, "Mirr",     160,60,30,19, &tex->flag, 0.0, 0.0, 0, 0, "Mirrors Y direction repeat");
1274                 uiDefButS(block, NUM, B_TEXPRV, "Yrepeat:",     190,60,120,19, &tex->yrepeat, 1.0, 512.0, 0, 0, "Sets a repetition multiplier in the Y direction");
1275         }
1276         else if(tex->extend==TEX_CHECKER) {
1277                 uiBlockBeginAlign(block);
1278                 uiDefButBitS(block, TOG, TEX_CHECKER_ODD, B_TEXPRV, "Odd",      10,60,100,19, &tex->flag, 0.0, 0.0, 0, 0, "Sets odd checker tiles");
1279                 uiDefButBitS(block, TOG, TEX_CHECKER_EVEN, B_TEXPRV, "Even",    110,60,100,19, &tex->flag, 0.0, 0.0, 0, 0, "Sets even checker tiles");
1280                 uiDefButF(block, NUM, B_TEXPRV, "Mortar:",              210,60,100,19, &tex->checkerdist, 0.0, 0.99, 0, 0, "Set checkers distance (like mortar)");
1281         }
1282         uiBlockBeginAlign(block);
1283         uiDefButF(block, NUM, B_TEXPRV, "MinX ",                10,30,150,19, &tex->cropxmin, -10.0, 10.0, 10, 0, "Sets minimum X value to crop Image");
1284         uiDefButF(block, NUM, B_TEXPRV, "MinY ",                10,10,150,19, &tex->cropymin, -10.0, 10.0, 10, 0, "Sets minimum Y value to crop Image");
1285
1286         uiBlockBeginAlign(block);
1287         uiDefButF(block, NUM, B_TEXPRV, "MaxX ",                160,30,150,19, &tex->cropxmax, -10.0, 10.0, 10, 0, "Sets maximum X value to crop Image");
1288         uiDefButF(block, NUM, B_TEXPRV, "MaxY ",                160,10,150,19, &tex->cropymax, -10.0, 10.0, 10, 0, "Sets maximum Y value to crop Image");
1289         uiBlockEndAlign(block);
1290
1291 }
1292
1293 /***************************************/
1294
1295 static void texture_panel_envmap(Tex *tex)
1296 {
1297         uiBlock *block;
1298         uiBut *but;
1299         EnvMap *env;
1300         ID *id;
1301         short a, xco, yco, dx, dy;
1302         char *strp, str[32];
1303         
1304         block= uiNewBlock(&curarea->uiblocks, "texture_panel_envmap", UI_EMBOSS, UI_HELV, curarea->win);
1305         if(uiNewPanel(curarea, block, "Envmap", "Texture", 640, 0, 318, 204)==0) return;
1306         uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
1307         
1308         if(tex->env==NULL) {
1309                 tex->env= BKE_add_envmap();
1310                 tex->env->object= OBACT;
1311         }
1312         if(tex->env) {
1313                 env= tex->env;
1314                 
1315                 uiBlockBeginAlign(block);
1316                 uiDefButS(block, ROW, B_REDR,   "Static",       10, 180, 100, 19, &env->stype, 2.0, (float)ENV_STATIC, 0, 0, "Calculates environment map only once");
1317                 uiDefButS(block, ROW, B_REDR,   "Anim",         110, 180, 100, 19, &env->stype, 2.0, (float)ENV_ANIM, 0, 0, "Calculates environment map at each rendering");
1318                 uiDefButS(block, ROW, B_ENV_FREE, "Load",       210, 180, 100, 19, &env->stype, 2.0, (float)ENV_LOAD, 0, 0, "Loads saved environment map from disk");
1319                 uiBlockEndAlign(block);
1320                 
1321                 if(env->stype==ENV_LOAD) {
1322                         /* file input */
1323                         id= (ID *)tex->ima;
1324                         IMAnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(G.buts->menunr));
1325                         if(strp[0]) {
1326                                 uiBlockBeginAlign(block);
1327                                 
1328                                 but= uiDefButS(block, MENU, B_TEXPRV, strp,             10,145,23,20, &tex->iuser.menunr, 0, 0, 0, 0, "Selects an existing environment map");
1329                                 uiButSetFunc(but, image_browse_cb, &tex->ima, &tex->iuser);
1330                                 
1331                                 if(tex->ima) {
1332                                         but= 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");
1333                                         uiButSetFunc(but, image_load_cb, &tex->ima, &tex->iuser);
1334                                         
1335                                         sprintf(str, "%d", tex->ima->id.us);
1336                                         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");
1337                                         uiBlockEndAlign(block);
1338                                         
1339                                         but= uiDefBut(block, BUT, B_IMAGECHANGED, "Reload",     230,125,80,20, 0, 0, 0, 0, 0, "Reloads saved environment map");
1340                                         uiButSetFunc(but, image_reload_cb, tex->ima, NULL);
1341                                         
1342                                         if (tex->ima->packedfile) packdummy = 1;
1343                                         else packdummy = 0;
1344                                         but= uiDefIconButBitI(block, TOG, 1, B_REDR, ICON_PACKAGE, 205,125,24,20, &packdummy, 0, 0, 0, 0, "Toggles Packed status of this environment map");
1345                                         uiButSetFunc(but, image_pack_cb, tex->ima, &tex->iuser);
1346                                 }
1347                                 else uiBlockEndAlign(block);
1348                         }
1349                         MEM_freeN(strp);
1350                         
1351                         but= uiDefBut(block, BUT, B_IMAGECHANGED, "Load Image", 10,125,150,20, 0, 0, 0, 0, 0, "Loads saved environment map - file select");
1352                         uiButSetFunc(but, image_load_fs_cb, &tex->ima, &tex->iuser);
1353                 }
1354                 else {
1355                         uiBlockBeginAlign(block);
1356                         uiDefBut(block, BUT, B_ENV_FREE, "Free Data",   10,145,100,20, 0, 0, 0, 0, 0, "Releases all images associated with this environment map");
1357                         uiDefBut(block, BUT, B_ENV_SAVE, "Save EnvMap", 110,145,100,20, 0, 0, 0, 0, 0, "Saves current environment map");
1358                         uiDefBut(block, BUT, B_ENV_FREE_ALL, "Free all EnvMaps", 210,145,100,20, 0, 0, 0, 0, 0, "Frees all rendered environment maps for all materials");
1359                         
1360                         uiBlockBeginAlign(block);
1361                         uiDefButS(block, ROW, B_NOP, "Cube",                    10,120,100,20, &env->type, 3.0f, (float)ENV_CUBE, 0, 0, "Use environment map with six cube sides");
1362                         uiDefButS(block, ROW, B_NOP, "Plane",                   110,120,100,20, &env->type, 3.0f, (float)ENV_PLANE, 0, 0, "Only one side is rendered, with Z axis pointing in direction of image");
1363                         uiDefButF(block, NUM, B_NOP, "Zoom: ",                  210,120,100,20, &env->viewscale, 0.5f, 5.0f, 100, 2, "Zoom factor for planar environment map");
1364                         uiBlockEndAlign(block);
1365                 }
1366                 
1367                 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");
1368                 if(env->stype!=ENV_LOAD) 
1369                         uiDefButS(block, NUM, B_ENV_FREE,       "CubeRes",              160,90,150,20, &env->cuberes, 50, 4096.0, 0, 0, "Sets the pixel resolution of the rendered environment map");
1370                 
1371                 uiBlockBeginAlign(block);
1372                 uiDefButBitS(block, TOG, TEX_FILTER_MIN, B_TEXPRV, "Min",       10, 65, 30, 20, &tex->imaflag, 0, 0, 0, 0, "Use Filtersize as a minimal filter value in pixels");
1373                 uiDefButF(block, NUM, B_TEXPRV, "Filter :",                                     40,65,120,20, &tex->filtersize, 0.1, 25.0, 0, 3, "Adjusts sharpness or blurriness of the reflection"),
1374                         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"),
1375                         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");
1376                 uiDefButF(block, NUM, B_NOP,    "ClipEnd",                                      160,40,150,20, &env->clipend, 0.1, 20000.0, 1000, 0, "Sets end value for clipping beyond which objects are not visible to map");
1377                 uiBlockEndAlign(block);
1378                 
1379                 uiDefBut(block, LABEL, 0, "Don't render layer:",                10,10,140,22, 0, 0.0, 0.0, 0, 0, "");   
1380                 xco= 160;
1381                 yco= 10;
1382                 dx= 28;
1383                 dy= 26;
1384                 
1385                 uiBlockBeginAlign(block);
1386                 for(a=0; a<5; a++) 
1387                         uiDefButBitI(block, TOG, 1<<a, 0, "",   (xco+a*(dx/2)), (yco+dy/2), (dx/2), (1+dy/2), (int *)&env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
1388                 for(a=0; a<5; a++) 
1389                         uiDefButBitI(block, TOG, 1<<(a+10), 0, "",(xco+a*(dx/2)), yco, (dx/2), (dy/2), (int *)&env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
1390                 
1391                 uiBlockBeginAlign(block);
1392                 xco+= 5;
1393                 for(a=5; a<10; a++) 
1394                         uiDefButBitI(block, TOG, 1<<a, 0, "",   (xco+a*(dx/2)), (yco+dy/2), (dx/2), (1+dy/2), (int *)&env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
1395                 for(a=5; a<10; a++) 
1396                         uiDefButBitI(block, TOG, 1<<(a+10), 0, "",(xco+a*(dx/2)), yco, (dx/2), (dy/2), (int *)&env->notlay, 0, 0, 0, 0, "Toggles layer visibility to environment map");
1397                 
1398         }
1399 }
1400
1401 static void colorband_pos_cb(void *coba_v, void *unused_v)
1402 {
1403         ColorBand *coba= coba_v;
1404         int a;
1405         
1406         if(coba->tot<2) return;
1407         
1408         for(a=0; a<coba->tot; a++) coba->data[a].cur= a;
1409         qsort(coba->data, coba->tot, sizeof(CBData), vergcband);
1410         for(a=0; a<coba->tot; a++) {
1411                 if(coba->data[a].cur==coba->cur) {
1412                         if(coba->cur!=a) addqueue(curarea->win, REDRAW, 0);     /* button cur */
1413                         coba->cur= a;
1414                         break;
1415                 }
1416         }
1417 }
1418
1419 static void colorband_add_cb(void *coba_v, void *unused_v)
1420 {
1421         ColorBand *coba= coba_v;
1422         
1423         if(coba->tot < MAXCOLORBAND-1) coba->tot++;
1424         coba->cur= coba->tot-1;
1425         
1426         colorband_pos_cb(coba, NULL);
1427         BIF_undo_push("Add colorband");
1428         
1429 }
1430
1431 static void colorband_del_cb(void *coba_v, void *unused_v)
1432 {
1433         ColorBand *coba= coba_v;
1434         int a;
1435         
1436         if(coba->tot<2) return;
1437         
1438         for(a=coba->cur; a<coba->tot; a++) {
1439                 coba->data[a]= coba->data[a+1];
1440         }
1441         if(coba->cur) coba->cur--;
1442         coba->tot--;
1443         
1444         BIF_undo_push("Delete colorband");
1445         BIF_preview_changed(ID_TE);
1446 }
1447
1448
1449 /* offset aligns from bottom, standard width 300, height 115 */
1450 static void draw_colorband_buts(uiBlock *block, ColorBand *coba, int xoffs, int yoffs, int redraw)
1451 {
1452         CBData *cbd;
1453         uiBut *bt;
1454         
1455         if(coba==NULL) return;
1456         
1457         bt= uiDefBut(block, BUT, redraw,        "Add",          80+xoffs,95+yoffs,37,20, 0, 0, 0, 0, 0, "Adds a new color position to the colorband");
1458         uiButSetFunc(bt, colorband_add_cb, coba, NULL);
1459         uiDefButS(block, NUM, redraw,           "Cur:",         117+xoffs,95+yoffs,81,20, &coba->cur, 0.0, (float)(coba->tot-1), 0, 0, "Displays the active color from the colorband");
1460         bt= uiDefBut(block, BUT, redraw,                "Del",          199+xoffs,95+yoffs,37,20, 0, 0, 0, 0, 0, "Deletes the active position");
1461         uiButSetFunc(bt, colorband_del_cb, coba, NULL);
1462         uiDefButS(block, ROW, redraw,            "E",           236+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 1.0, 0, 0, "Sets interpolation type 'Ease' (quadratic) ");
1463         uiDefButS(block, ROW, redraw,           "C",            252+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 3.0, 0, 0, "Sets interpolation type Cardinal");
1464         uiDefButS(block, ROW, redraw,           "L",            268+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 0.0, 0, 0, "Sets interpolation type Linear");
1465         uiDefButS(block, ROW, redraw,           "S",            284+xoffs,95+yoffs,16,20, &coba->ipotype, 5.0, 2.0, 0, 0, "Sets interpolation type B-Spline");
1466
1467         uiDefBut(block, BUT_COLORBAND, redraw, "",      xoffs,65+yoffs,300,30, coba, 0, 0, 0, 0, "");
1468         
1469         cbd= coba->data + coba->cur;
1470         
1471         uiBlockBeginAlign(block);
1472         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 color");
1473         uiButSetFunc(bt, colorband_pos_cb, coba, NULL);
1474         uiDefButF(block, COL, redraw,           "",             xoffs,20+yoffs,110,20, &(cbd->r), 0, 0, 0, B_BANDCOL, "");
1475         uiDefButF(block, NUMSLI, redraw,        "A ",   xoffs,yoffs,110,20, &cbd->a, 0.0, 1.0, 10, 0, "Sets the alpha value for this position");
1476
1477         uiBlockBeginAlign(block);
1478         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 color");
1479         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 color");
1480         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 color");
1481         uiBlockEndAlign(block);
1482 }
1483
1484 void draw_colorband_buts_small(uiBlock *block, ColorBand *coba, rctf *butr, int event)
1485 {
1486         CBData *cbd;
1487         uiBut *bt;
1488         float unit= (butr->xmax-butr->xmin)/14.0f;
1489         float xs= butr->xmin;
1490         
1491         cbd= coba->data + coba->cur;
1492         
1493         uiBlockBeginAlign(block);
1494         uiDefButF(block, COL, event,            "",                     xs,butr->ymin+20.0f,2.0f*unit,20,                               &(cbd->r), 0, 0, 0, B_BANDCOL, "");
1495         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, "");
1496         bt= uiDefBut(block, BUT, event, "Add",          xs+6.0f*unit,butr->ymin+20.0f,2.0f*unit,20,     NULL, 0, 0, 0, 0, "Adds a new color position to the colorband");
1497         uiButSetFunc(bt, colorband_add_cb, coba, NULL);
1498         bt= uiDefBut(block, BUT, event, "Del",          xs+8.0f*unit,butr->ymin+20.0f,2.0f*unit,20,     NULL, 0, 0, 0, 0, "Deletes the active position");
1499         uiButSetFunc(bt, colorband_del_cb, coba, NULL);
1500         uiDefButS(block, ROW, event,            "E",            xs+10.0f*unit,butr->ymin+20.0f,unit,20,         &coba->ipotype, 5.0, 1.0, 0, 0, "Sets interpolation type 'Ease' (quadratic) ");
1501         uiDefButS(block, ROW, event,            "C",            xs+11.0f*unit,butr->ymin+20.0f,unit,20,         &coba->ipotype, 5.0, 3.0, 0, 0, "Sets interpolation type Cardinal");
1502         uiDefButS(block, ROW, event,            "L",            xs+12.0f*unit,butr->ymin+20.0f,unit,20,         &coba->ipotype, 5.0, 0.0, 0, 0, "Sets interpolation type Linear");
1503         uiDefButS(block, ROW, event,            "S",            xs+13.0f*unit,butr->ymin+20.0f,unit,20,         &coba->ipotype, 5.0, 2.0, 0, 0, "Sets interpolation type B-Spline");
1504         
1505         uiDefBut(block, BUT_COLORBAND, event, "",               xs,butr->ymin,butr->xmax-butr->xmin,20.0f, coba, 0, 0, 0, 0, "");
1506         uiBlockEndAlign(block);
1507         
1508 }
1509
1510 static void texture_panel_colors(Tex *tex)
1511 {
1512         uiBlock *block;
1513         
1514         block= uiNewBlock(&curarea->uiblocks, "texture_panel_colors", UI_EMBOSS, UI_HELV, curarea->win);
1515         uiNewPanelTabbed("Texture", "Texture");
1516         if(uiNewPanel(curarea, block, "Colors", "Texture", 1280, 0, 318, 204)==0) return;
1517
1518
1519         /* COLORBAND */
1520         uiBlockBeginAlign(block);
1521         uiDefButBitS(block, TOG, TEX_COLORBAND, B_COLORBAND, "Colorband",10,180,80,20, &tex->flag, 0, 0, 0, 0, "Toggles colorband operations");
1522
1523         if(tex->flag & TEX_COLORBAND) {
1524                 draw_colorband_buts(block, tex->coba, 10, 85, B_TEXREDR_PRV);
1525         }
1526         
1527         /* RGB-BRICON */
1528         if((tex->flag & TEX_COLORBAND)==0) {
1529                 uiBlockBeginAlign(block);
1530                 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");
1531                 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");
1532                 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");
1533         }
1534
1535         uiBlockBeginAlign(block);
1536         uiDefButF(block, NUMSLI, B_TEXPRV, "Bright",            10,10,150,20, &tex->bright, 0.0, 2.0, 0, 0, "Changes the brightness of the color or intensity of a texture");
1537         uiDefButF(block, NUMSLI, B_TEXPRV, "Contr",                     160,10,150,20, &tex->contrast, 0.01, 5.0, 0, 0, "Changes the contrast of the color or intensity of a texture");
1538 }
1539
1540
1541 static void texture_panel_texture(MTex *mtex, Material *ma, World *wrld, Lamp *la, bNode *node, Brush *br, SculptData *sd)
1542 {
1543         MTex *mt=NULL;
1544         uiBlock *block;
1545         ID *id=NULL, *idfrom;
1546         int a, yco, loos;
1547         char str[32];
1548         
1549
1550         block= uiNewBlock(&curarea->uiblocks, "texture_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
1551         if(uiNewPanel(curarea, block, "Texture", "Texture", 320, 0, 318, 204)==0) return;
1552
1553         /* first do the browse but */
1554         if(mtex)
1555                 id= (ID *)mtex->tex;
1556         else if(node)
1557                 id= node->id;
1558         
1559         if(ma) idfrom= &ma->id;
1560         else if(wrld) idfrom= &wrld->id;
1561         else if(la) idfrom= &la->id;
1562         else if(br) idfrom= &br->id;
1563         else if(sd) idfrom= NULL; /* Not sure what this does */
1564         else idfrom= NULL;
1565         
1566         uiBlockSetCol(block, TH_BUT_SETTING2);
1567         if(ma) {
1568                 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);
1569         }
1570         else if(wrld) {
1571                 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);
1572         }
1573         else if(la) {
1574                 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);
1575         }
1576         else if(br) {
1577                 std_libbuttons(block, 10, 180, 0, NULL, B_BTEXBROWSE, ID_TE, 0, id, idfrom, &(G.buts->menunr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1578         }
1579         else if(sd) {
1580                 std_libbuttons(block, 10, 180, 0, NULL, B_SCULPT_TEXBROWSE, ID_TE, 0, id, idfrom, &(G.buts->texnr), B_TEXALONE, B_TEXLOCAL, B_TEXDELETE, B_AUTOTEXNAME, B_KEEPDATA);
1581         }
1582         else if(node) {
1583
1584         }
1585         uiBlockSetCol(block, TH_BUT_NEUTRAL);
1586
1587         /* From button: removed */
1588
1589         /* CHANNELS */
1590         if(node==NULL) {
1591                 uiBlockBeginAlign(block);
1592                 yco= 150;
1593                 for(a= 0; a<MAX_MTEX; a++) {
1594                         
1595                         if(ma) mt= ma->mtex[a];
1596                         else if(wrld) mt= wrld->mtex[a];
1597                         else if(la) mt= la->mtex[a];
1598                         else if(br) mt= br->mtex[a];
1599                         else if(sd) mt= sd->mtex[a];
1600                         
1601                         if(mt && mt->tex) splitIDname(mt->tex->id.name+2, str, &loos);
1602                         else strcpy(str, "");
1603                         str[14]= 0;
1604
1605                         if(ma) {
1606                                 uiDefButC(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(ma->texact), 0.0, (float)a, 0, 0, "Click to select texture channel");
1607                                 yco-= 20;
1608                         }
1609                         else if(wrld) {
1610                                 uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(wrld->texact), 0.0, (float)a, 0, 0, "");
1611                                 yco-= 20;
1612                         }
1613                         else if(la) {
1614                                 uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(la->texact), 0.0, (float)a, 0, 0, "");
1615                                 yco-= 20;
1616                         }
1617                         else if(br) {
1618                                 uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(br->texact), 0.0, (float)a, 0, 0, "");
1619                                 yco-= 20;
1620                         }
1621                         else if(sd) {
1622                                 uiDefButS(block, ROW, B_TEXCHANNEL, str,        10,yco,140,19, &(sd->texact), 0.0, (float)a, 0, 0, "");
1623                                 yco-= 20;
1624                         }
1625                 }
1626                 uiBlockEndAlign(block);
1627         }       
1628         uiBlockSetCol(block, TH_AUTO);
1629
1630         /* TYPES */
1631         if(id) {
1632                 char textypes[512];
1633                 Tex *tex= (Tex *)id;
1634
1635                 uiSetButLock(tex->id.lib!=0, ERROR_LIBDATA_MESSAGE);
1636                 
1637                 /* newnoise: all texture types as menu, not enough room for more buttons.
1638                  * Can widen panel, but looks ugly when other panels overlap it */
1639                 
1640                 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);
1641                 uiDefBut(block, LABEL, 0, "Texture Type",               160, 150, 140, 20, 0, 0.0, 0.0, 0, 0, "");
1642                 uiDefButS(block, MENU, B_TEXTYPE, textypes,     160, 125, 140, 25, &tex->type, 0,0,0,0, "Select texture type");
1643
1644         }
1645         else {
1646                 // label to avoid centering
1647                 uiDefBut(block, LABEL, 0, " ",  160, 10, 140, 20, 0, 0, 0, 0, 0, "");
1648         }
1649 }
1650
1651 static void texture_panel_preview(MTex *mtex, int preview)
1652 {
1653         uiBlock *block;
1654         
1655         block= uiNewBlock(&curarea->uiblocks, "texture_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
1656         if(uiNewPanel(curarea, block, "Preview", "Texture", 0, 0, 318, 204)==0) return;
1657         
1658         if(preview) uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
1659
1660         // label to force a boundbox for buttons not to be centered
1661         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
1662
1663         uiBlockBeginAlign(block);
1664         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");
1665         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");
1666         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");
1667         uiDefButC(block, ROW, B_TEXREDR_PRV, "Brush",   200,100,80,25, &G.buts->texfrom, 3.0, 3.0, 0, 0, "Displays the textures of the selected brush");
1668         uiBlockEndAlign(block);
1669         
1670         if(mtex && mtex->tex)
1671                 uiDefButBitS(block, TOG, TEX_PRV_ALPHA, B_TEXREDR_PRV, "Alpha", 200,60,80,20, &mtex->tex->flag, 0, 0, 0, 0, "Show alpha in preview");
1672         
1673         uiDefBut(block, BUT, B_DEFTEXVAR, "Default Vars",200,10,80,20, 0, 0, 0, 0, 0, "Sets all values to defaults");
1674
1675 }
1676
1677
1678
1679 /* *************************** RADIO ******************************** */
1680
1681 void do_radiobuts(unsigned short event)
1682 {
1683         Radio *rad;
1684         int phase;
1685         
1686         phase= rad_phase();
1687         rad= G.scene->radio;
1688         
1689         switch(event) {
1690         case B_RAD_ADD:
1691                 add_radio();
1692                 BIF_undo_push("Add radiosity");
1693                 allqueue(REDRAWBUTSSHADING, 0);
1694                 allqueue(REDRAWVIEW3D, 0);
1695                 break;
1696         case B_RAD_DELETE:
1697                 delete_radio();
1698                 BIF_undo_push("Delete radiosity");
1699                 allqueue(REDRAWBUTSSHADING, 0);
1700                 allqueue(REDRAWVIEW3D, 0);
1701                 break;
1702         case B_RAD_FREE:
1703                 freeAllRad();
1704                 allqueue(REDRAWBUTSSHADING, 0);
1705                 allqueue(REDRAWVIEW3D, 0);
1706                 break;
1707         case B_RAD_COLLECT:
1708                 rad_collect_meshes();
1709                 allqueue(REDRAWBUTSSHADING, 0);
1710                 allqueue(REDRAWVIEW3D, 0);
1711                 break;
1712         case B_RAD_INIT:
1713                 if(phase==RAD_PHASE_PATCHES) {
1714                         rad_limit_subdivide();
1715                         allqueue(REDRAWBUTSSHADING, 0);
1716                         allqueue(REDRAWVIEW3D, 0);
1717                 }
1718                 break;
1719         case B_RAD_SHOOTP:
1720                 if(phase==RAD_PHASE_PATCHES) {
1721                         waitcursor(1);
1722                         rad_subdivshootpatch();
1723                         allqueue(REDRAWBUTSSHADING, 0);
1724                         allqueue(REDRAWVIEW3D, 0);
1725                         waitcursor(0);
1726                 }
1727                 break;
1728         case B_RAD_SHOOTE:
1729                 if(phase==RAD_PHASE_PATCHES) {
1730                         waitcursor(1);
1731                         rad_subdivshootelem();
1732                         allqueue(REDRAWBUTSSHADING, 0);
1733                         allqueue(REDRAWVIEW3D, 0);
1734                         waitcursor(0);
1735                 }
1736                 break;
1737         case B_RAD_GO:
1738                 if(phase==RAD_PHASE_PATCHES) {
1739                         waitcursor(1);
1740                         rad_go();
1741                         waitcursor(0);
1742                         allqueue(REDRAWBUTSSHADING, 0);
1743                         allqueue(REDRAWVIEW3D, 0);
1744                 }
1745                 break;
1746         case B_RAD_LIMITS:
1747                 rad_setlimits();
1748                 allqueue(REDRAWVIEW3D, 0);
1749                 allqueue(REDRAWBUTSSHADING, 0);
1750                 break;
1751         case B_RAD_FAC:
1752                 set_radglobal();
1753                 if(phase & RAD_PHASE_FACES) make_face_tab();
1754                 else make_node_display();       /* radio solver also uses nodes, different ones :) */
1755                 allqueue(REDRAWVIEW3D, 0);
1756                 break;
1757         case B_RAD_NODELIM:
1758                 if(phase & RAD_PHASE_FACES) {
1759                         set_radglobal();
1760                         removeEqualNodes(rad->nodelim);
1761                         make_face_tab();
1762                         allqueue(REDRAWVIEW3D, 0);
1763                         allqueue(REDRAWBUTSSHADING, 0);
1764                 }
1765                 break;
1766         case B_RAD_NODEFILT:
1767                 if(phase & RAD_PHASE_FACES) {
1768                         set_radglobal();
1769                         filterNodes();
1770                         make_face_tab();
1771                         allqueue(REDRAWVIEW3D, 0);
1772                 }
1773                 break;
1774         case B_RAD_FACEFILT:
1775                 if(phase & RAD_PHASE_FACES) {
1776                         filterFaces();
1777                         allqueue(REDRAWVIEW3D, 0);
1778                 }
1779                 break;
1780         case B_RAD_DRAW:
1781                 set_radglobal();
1782                 allqueue(REDRAWVIEW3D, 0);
1783                 break;
1784         case B_RAD_ADDMESH:
1785                 if(phase & RAD_PHASE_FACES) rad_addmesh();
1786                 BIF_undo_push("Radiosity add mesh");
1787                 allqueue(REDRAWVIEW3D, 0);
1788                 break;
1789         case B_RAD_REPLACE:
1790                 if(phase & RAD_PHASE_FACES) rad_replacemesh();
1791                 BIF_undo_push("Radiosity replace mesh");
1792                 allqueue(REDRAWVIEW3D, 0);
1793                 break;
1794         }
1795
1796 }
1797
1798
1799 static void radio_panel_calculation(Radio *rad, int flag)
1800 {
1801         uiBlock *block;
1802         
1803         block= uiNewBlock(&curarea->uiblocks, "radio_panel_calculation", UI_EMBOSS, UI_HELV, curarea->win);
1804         if(uiNewPanel(curarea, block, "Calculation", "Radio", 640, 0, 318, 204)==0) return;
1805         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1806
1807         if(flag != RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_NEUTRAL);
1808         uiDefBut(block,  BUT, B_RAD_GO, "GO",                                   0, 0, 10, 15, NULL, 0, 0, 0, 0, "Starts the radiosity simulation");
1809
1810         uiBlockSetCol(block, TH_AUTO);
1811         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");
1812         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");
1813
1814         if(flag != RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_NEUTRAL);
1815         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");
1816         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");
1817
1818         uiBlockSetCol(block, TH_AUTO);
1819         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");
1820         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");
1821
1822         if(flag & RAD_PHASE_FACES);
1823         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1824         uiDefBut(block,  BUT, B_RAD_FACEFILT, "FaceFilter",             4, 0, 10, 10, NULL, 0, 0, 0, 0, "Forces an extra smoothing");
1825         uiDefBut(block,  BUT, B_RAD_NODEFILT, "Element Filter", 4, 0, 10, 10, NULL, 0, 0, 0, 0, "Filters elements to remove aliasing artefacts");
1826
1827         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'");
1828         uiBlockSetCol(block, TH_AUTO);
1829         uiDefButS(block,  NUM, B_NOP, "Lim:",                                           5, 0, 10, 10, &rad->nodelim, 0.0, 50.0, 0, 0, "Sets the range for removing doubles");
1830
1831
1832 }
1833
1834 static void radio_panel_tool(Radio *rad, int flag)
1835 {
1836         uiBlock *block;
1837         
1838         block= uiNewBlock(&curarea->uiblocks, "radio_panel_tool", UI_EMBOSS, UI_HELV, curarea->win);
1839         if(uiNewPanel(curarea, block, "Radio Tool", "Radio", 320, 0, 318, 204)==0) return;
1840         uiAutoBlock(block, 10, 10, 300, 200, UI_BLOCK_ROWS);
1841
1842         if(flag & RAD_PHASE_PATCHES) uiBlockSetCol(block, TH_BUT_SETTING1);
1843         uiDefBut(block,  BUT, B_RAD_COLLECT, "Collect Meshes",  0, 0, 10, 15, NULL, 0, 0, 0, 0, "Converts selected visible meshes to patches");
1844
1845         if(flag & RAD_PHASE_PATCHES)uiBlockSetCol(block, TH_AUTO);
1846         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1847         uiDefBut(block,  BUT, B_RAD_FREE, "Free Radio Data",    0, 0, 10, 15, NULL, 0, 0, 0, 0, "Releases all memory used by Radiosity");       
1848
1849         if(flag & RAD_PHASE_FACES) uiBlockSetCol(block, TH_AUTO);
1850         else uiBlockSetCol(block, TH_BUT_NEUTRAL);
1851         uiDefBut(block,  BUT, B_RAD_REPLACE, "Replace Meshes",  1, 0, 10, 12, NULL, 0, 0, 0, 0, "Converts meshes to Mesh objects with vertex colors, changing input-meshes");
1852         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 colors, unchanging input-meshes");
1853
1854         uiBlockSetCol(block, TH_AUTO);
1855         uiDefButS(block,  ROW, B_RAD_DRAW, "Wire",                      2, 0, 10, 10, &rad->drawtype, 0.0, 0.0, 0, 0, "Enables wireframe drawmode");
1856         uiDefButS(block,  ROW, B_RAD_DRAW, "Solid",                     2, 0, 10, 10, &rad->drawtype, 0.0, 1.0, 0, 0, "Enables solid drawmode");
1857         uiDefButS(block,  ROW, B_RAD_DRAW, "Gour",                      2, 0, 10, 10, &rad->drawtype, 0.0, 2.0, 0, 0, "Enables Gourad drawmode");
1858         uiDefButBitS(block,  TOG, 1, B_RAD_DRAW, "ShowLim", 2, 0, 10, 10, &rad->flag, 0, 0, 0, 0, "Draws patch and element limits");
1859         uiDefButBitS(block,  TOG, 2, B_RAD_DRAW, "Z",           2, 0, 3, 10, &rad->flag, 0, 0, 0, 0, "Draws limits differently");
1860
1861         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");
1862         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");
1863         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");
1864         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");
1865
1866         uiDefBut(block,  BUT, B_RAD_INIT, "Limit Subdivide", 5, 0, 10, 10, NULL, 0, 0, 0, 0, "Subdivides patches");
1867 }
1868
1869
1870 static void radio_panel_render(Radio *rad)
1871 {
1872         uiBlock *block;
1873         
1874         block= uiNewBlock(&curarea->uiblocks, "radio_panel_render", UI_EMBOSS, UI_HELV, curarea->win);
1875         if(uiNewPanel(curarea, block, "Radio Render", "Radio", 0, 0, 318, 204)==0) return;
1876         uiAutoBlock(block, 210, 30, 230, 150, UI_BLOCK_ROWS);
1877
1878         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");
1879         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");
1880         uiDefButF(block,  NUM, B_RAD_FAC, "Mult:",                      3, 0, 10, 15, &rad->radfac, 0.001, 250.0, 100, 0, "Mulitplies the energy values");
1881         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");
1882         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");
1883 }
1884
1885
1886 /* ***************************** WORLD ************************** */
1887
1888 void do_worldbuts(unsigned short event)
1889 {
1890         static short mtexcopied=0;
1891         static MTex mtexcopybuf;
1892         World *wrld;
1893         MTex *mtex;
1894         
1895         switch(event) {
1896         case B_TEXCLEARWORLD:
1897                 wrld= G.buts->lockpoin;
1898                 mtex= wrld->mtex[ wrld->texact ];
1899                 if(mtex) {
1900                         if(mtex->tex) mtex->tex->id.us--;
1901                         MEM_freeN(mtex);
1902                         wrld->mtex[ wrld->texact ]= 0;
1903                         allqueue(REDRAWBUTSSHADING, 0);
1904                         allqueue(REDRAWOOPS, 0);
1905                         BIF_undo_push("Unlink world texture");
1906                         BIF_preview_changed(ID_WO);
1907                 }
1908                 break;
1909         case B_WMTEXCOPY:
1910                 wrld= G.buts->lockpoin;
1911                 if(wrld && wrld->mtex[(int)wrld->texact] ) {
1912                         mtex= wrld->mtex[(int)wrld->texact];
1913                         if(mtex->tex==NULL) {
1914                                 error("No texture available");
1915                         }
1916                         else {
1917                                 memcpy(&mtexcopybuf, wrld->mtex[(int)wrld->texact], sizeof(MTex));
1918                                 mtexcopied= 1;
1919                         }
1920                 }
1921                 break;
1922         case B_WMTEXPASTE:
1923                 wrld= G.buts->lockpoin;
1924                 if(wrld && mtexcopied && mtexcopybuf.tex) {
1925                         if(wrld->mtex[(int)wrld->texact]==NULL ) 
1926                                 wrld->mtex[(int)wrld->texact]= MEM_mallocN(sizeof(MTex), "mtex"); 
1927                         else if(wrld->mtex[(int)wrld->texact]->tex)
1928                                 wrld->mtex[(int)wrld->texact]->tex->id.us--;
1929                         
1930                         memcpy(wrld->mtex[(int)wrld->texact], &mtexcopybuf, sizeof(MTex));
1931                         
1932                         id_us_plus((ID *)mtexcopybuf.tex);
1933                         BIF_undo_push("Paste mapping settings");
1934                         BIF_preview_changed(ID_WO);
1935                         scrarea_queue_winredraw(curarea);
1936                 }
1937                 break;
1938         case B_AO_FALLOFF:
1939                 /* falloff distances option only supports plain */
1940                 wrld= G.buts->lockpoin;
1941                 if(wrld)
1942                         wrld->aocolor= WO_AOPLAIN;
1943                 scrarea_queue_winredraw(curarea);
1944                 break;
1945         }
1946 }
1947
1948 static void world_panel_mapto(World *wrld)
1949 {
1950         uiBlock *block;
1951         MTex *mtex;
1952         
1953         block= uiNewBlock(&curarea->uiblocks, "world_panel_mapto", UI_EMBOSS, UI_HELV, curarea->win);
1954         uiNewPanelTabbed("Texture and Input", "World");
1955         if(uiNewPanel(curarea, block, "Map To", "World", 1280, 0, 318, 204)==0) return;
1956
1957         uiSetButLock(wrld->id.lib!=0, ERROR_LIBDATA_MESSAGE);
1958
1959         mtex= wrld->mtex[ wrld->texact ];
1960         if(mtex==NULL) {
1961                 mtex= &emptytex;
1962                 default_mtex(mtex);
1963                 mtex->texco= TEXCO_VIEW;
1964         }
1965
1966         /* TEXTURE OUTPUT */
1967         uiBlockBeginAlign(block);
1968         uiDefButBitS(block, TOG, MTEX_STENCIL, B_WORLDPRV, "Stencil",   10,125,45,19, &(mtex->texflag), 0, 0, 0, 0, "Use this texture as a blending value on the next texture");
1969         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");
1970         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");
1971         uiBlockEndAlign(block);
1972
1973         uiBlockBeginAlign(block);
1974         uiDefButF(block, COL, B_WORLDPRV, "",                   10,100,135,19, &(mtex->r), 0, 0, 0, B_MTEXCOL, "");
1975         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");
1976         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");
1977         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");
1978         uiBlockEndAlign(block);
1979         uiDefButF(block, NUMSLI, B_WORLDPRV, "DVar ",           10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard");
1980         
1981         /* MAP TO */
1982         uiBlockBeginAlign(block);
1983         uiDefButBitS(block, TOG, WOMAP_BLEND, B_WORLDPRV, "Blend",      10,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the color progression of the background");
1984         uiDefButBitS(block, TOG, WOMAP_HORIZ, B_WORLDPRV, "Hori",               85,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the color of the horizon");
1985         uiDefButBitS(block, TOG, WOMAP_ZENUP, B_WORLDPRV, "ZenUp",      160,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the color of the zenith above");
1986         uiDefButBitS(block, TOG, WOMAP_ZENDOWN, B_WORLDPRV, "ZenDo",    235,180,75,19, &(mtex->mapto), 0, 0, 0, 0, "Causes the texture to affect the color of the zenith below");
1987         uiBlockEndAlign(block);
1988
1989         uiBlockBeginAlign(block);
1990         uiDefButS(block, MENU, B_WORLDPRV, mapto_blendtype_pup(),155,125,155,19, &(mtex->blendtype), 0, 0, 0, 0, "Texture blending mode");
1991         uiBlockEndAlign(block);
1992
1993         uiBlockBeginAlign(block);
1994         uiDefButF(block, NUMSLI, B_WORLDPRV, "Col  ",           155,100,155,19, &(mtex->colfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects color values");
1995         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");
1996         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");
1997         
1998 }
1999
2000 static void world_panel_texture(World *wrld)
2001 {
2002         uiBlock *block;
2003         MTex *mtex;
2004         ID *id;
2005         int a, loos;
2006         char str[64], *strp;
2007         
2008         block= uiNewBlock(&curarea->uiblocks, "world_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
2009         if(uiNewPanel(curarea, block, "Texture and Input", "World", 960, 0, 318, 204)==0) return;
2010
2011         uiSetButLock(wrld->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2012
2013         /* TEX CHANNELS */
2014         uiBlockSetCol(block, TH_BUT_NEUTRAL);
2015         uiBlockBeginAlign(block);
2016         for(a= 0; a<MAX_MTEX; a++) {
2017                 mtex= wrld->mtex[a];
2018                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
2019                 else strcpy(str, "");
2020                 str[10]= 0;
2021                 uiDefButS(block, ROW, REDRAWBUTSSHADING, str,10, 160-18*a, 80, 20, &(wrld->texact), 3.0, (float)a, 0, 0, "Texture channel");
2022         }
2023         uiBlockEndAlign(block);
2024
2025         mtex= wrld->mtex[ wrld->texact ];
2026         if(mtex==NULL) {
2027                 mtex= &emptytex;
2028                 default_mtex(mtex);
2029                 mtex->texco= TEXCO_VIEW;
2030         }
2031         
2032         /* TEXTUREBLOCK SELECT */
2033         uiBlockSetCol(block, TH_BUT_SETTING2);
2034         id= (ID *)mtex->tex;
2035         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
2036         uiDefButS(block, MENU, B_WTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Selects an existing texture or creates new");
2037         MEM_freeN(strp);
2038         
2039         if(id) {
2040                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,200,19, id->name+2, 0.0, 21.0, 0, 0, "Displays name of the texture block: click to change");
2041                 sprintf(str, "%d", id->us);
2042                 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");
2043                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 220,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
2044                 if(id->lib) {
2045                         if(wrld->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,      219,140,21,19, 0, 0, 0, 0, 0, "");
2046                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
2047                 }
2048                 uiBlockSetCol(block, TH_AUTO);
2049                 uiDefBut(block, BUT, B_TEXCLEARWORLD, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erases link to texture");
2050         }
2051         else 
2052                 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");
2053
2054         uiBlockSetCol(block, TH_AUTO);
2055         
2056         /* copy/paste */
2057         uiBlockBeginAlign(block);
2058         uiDefIconBut(block, BUT, B_WMTEXCOPY, ICON_COPYUP,      250,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
2059         uiDefIconBut(block, BUT, B_WMTEXPASTE, ICON_PASTEUP,275,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
2060                 
2061         /* TEXCO */
2062         uiBlockBeginAlign(block);
2063         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");
2064         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)");
2065         
2066         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");
2067         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");
2068         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");
2069         
2070         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");
2071         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_WORLDPRV, "OB:", 170,70,130,20, &(mtex->object), "Object name to use for mapping");
2072
2073         uiBlockBeginAlign(block);
2074         uiDefButF(block, NUM, B_WORLDPRV, "dX",         100,40,100,19, mtex->ofs, -20.0, 20.0, 10, 0, "Fine tunes texture mapping X coordinate");
2075         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");
2076         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");
2077         uiBlockBeginAlign(block);
2078         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");
2079         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");
2080         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");
2081         
2082 }
2083
2084 static void world_panel_mistaph(World *wrld)
2085 {
2086         uiBlock *block;
2087         
2088         block= uiNewBlock(&curarea->uiblocks, "world_panel_mistaph", UI_EMBOSS, UI_HELV, curarea->win);
2089         if(uiNewPanel(curarea, block, "Mist / Stars / Physics", "World", 640, 0, 318, 204)==0) return;
2090
2091         uiSetButLock(wrld->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2092
2093 #if GAMEBLENDER == 1
2094         uiDefButI(block, MENU, 1, 
2095 #ifdef USE_ODE
2096                           "Physics %t|None %x0|Sumo %x2|Ode %x4 |Bullet %x5",
2097 #else
2098                           //"Physics %t|None %x0|Sumo %x2|Bullet %x5", //disable Sumo, until too many people complain ;-)
2099                           "Physics %t|None %x0|Sumo (deprecated) %x2|Bullet %x5",
2100 #endif
2101                           10,180,140,19, &wrld->physicsEngine, 0, 0, 0, 0, 
2102                           "Physics Engine");
2103         
2104         /* Gravitation for the game worlds */
2105         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");
2106 #endif
2107
2108         uiBlockSetCol(block, TH_BUT_SETTING1);
2109         uiDefButBitS(block, TOG, WO_MIST, B_WORLDPRV2,"Mist",   10,120,140,19, &wrld->mode, 0, 0, 0, 0, "Toggles mist simulation");
2110         uiBlockSetCol(block, TH_AUTO);
2111
2112         uiBlockBeginAlign(block);
2113         uiDefButS(block, ROW, B_WORLDPRV2, "Quad", 10, 90, 40, 19, &wrld->mistype, 1.0, 0.0, 0, 0, "Mist uses quadratic progression");
2114         uiDefButS(block, ROW, B_WORLDPRV2, "Lin", 50, 90, 50, 19, &wrld->mistype, 1.0, 1.0, 0, 0, "Mist uses linear progression");
2115         uiDefButS(block, ROW, B_WORLDPRV2, "Sqr", 100, 90, 50, 19, &wrld->mistype, 1.0, 2.0, 0, 0, "Mist uses inverse quadratic progression");
2116         uiBlockBeginAlign(block);
2117         uiDefButF(block, NUM,B_WORLDPRV2, "Start:",10,70,140,19, &wrld->miststa, 0.0, 10000.0, 10, 0, "Specifies the starting distance of the mist");
2118         uiDefButF(block, NUM,B_WORLDPRV2, "Dist:",10,50,140,19, &wrld->mistdist, 0.0,10000.0, 10, 00, "Specifies the depth of the mist");
2119         uiDefButF(block, NUM,B_WORLDPRV2,"Height:",             10,30,140,19, &wrld->misthi,0.0,100.0, 10, 0, "Specifies the factor for a less dense mist with increasing height");
2120         uiDefButF(block, NUMSLI, B_WORLDPRV2, "Misi ",          10,10,140,19,   &(wrld->misi), 0., 1.0, 0, 0, "Sets the mist intensity");
2121         uiBlockEndAlign(block);
2122
2123         uiBlockSetCol(block, TH_BUT_SETTING1);
2124         uiDefButBitS(block, TOG, WO_STARS, B_WORLDPRV2, "Stars",160,120,140,19, &wrld->mode, 0, 0, 0, 0, "Toggles starfield generation");
2125         uiBlockSetCol(block, TH_AUTO);
2126         
2127         uiBlockBeginAlign(block);
2128         uiDefButF(block, NUM,B_WORLDPRV2,"StarDist:",   160,70,140,19, &(wrld->stardist), 2.0, 1000.0, 100, 0, "Specifies the average distance between any two stars");
2129         uiDefButF(block, NUM,B_WORLDPRV2,"MinDist:",            160,50,140,19, &(wrld->starmindist), 0.0, 1000.0, 100, 0, "Specifies the minimum distance to the camera for stars");
2130         uiDefButF(block, NUMSLI,B_WORLDPRV2,"Size:",            160,30,140,19, &(wrld->starsize), 0.0, 10.0, 10, 0, "Specifies the average screen dimension of stars");
2131         uiDefButF(block, NUMSLI,B_WORLDPRV2,"Colnoise:",        160,10,140,19, &(wrld->starcolnoise), 0.0, 1.0, 100, 0, "Randomizes star color");
2132         uiBlockEndAlign(block);
2133
2134 }
2135
2136 static void world_panel_amb_occ(World *wrld)
2137 {
2138         uiBlock *block;
2139         short yco=PANEL_YMAX;
2140         
2141         block= uiNewBlock(&curarea->uiblocks, "world_panel_amb_oc", UI_EMBOSS, UI_HELV, curarea->win);
2142         uiNewPanelTabbed("Mist / Stars / Physics", "World");
2143         if(uiNewPanel(curarea, block, "Amb Occ", "World", PANELX, PANELY, PANELW, PANELH)==0) return;
2144
2145         uiBlockSetCol(block, TH_BUT_SETTING1);
2146         uiDefButBitS(block, TOG, WO_AMB_OCC, B_REDR, "Ambient Occlusion",
2147                 X2CLM1, yco-=BUTH, BUTW1, BUTH, &wrld->mode, 0, 0, 0, 0, "Toggles ambient occlusion (soft shadows)");
2148         uiBlockSetCol(block, TH_AUTO);
2149         
2150         if(!(wrld->mode & WO_AMB_OCC)) return;
2151         
2152         yco -= YSPACE;
2153
2154         uiDefButS(block, NUM, B_REDR, "Samples:",
2155                 X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aosamp, 1.0, 32.0, 100, 0, "Sets the number of samples used for AO  (actual number: squared)");
2156         
2157         yco -= YSPACE;
2158         
2159         uiDefButF(block, NUM, B_REDR, "Max Dist:",
2160                 X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aodist, 0.001, 5000.0, 100, 0, "Sets length of AO rays, defines how far away other faces give occlusion effect");
2161
2162         yco -= YSPACE;
2163         
2164         uiBlockBeginAlign(block);
2165         uiDefButBitS(block, TOG, WO_AODIST, B_AO_FALLOFF, "Use Falloff",
2166                 X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aomode, 0, 0, 0, 0, "When enabled, distances to objects will be used to attenuate shadows. Only for Plain AO.");
2167         if (wrld->aomode & WO_AODIST)
2168                 uiDefButF(block, NUM, B_REDR, "Strength:",
2169                         X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aodistfac, 0.00001, 10.0, 100, 0, "Distance attenuation factor, the higher, the 'shorter' the shadows");
2170         uiBlockEndAlign(block);
2171         
2172         /* column 2 */
2173         yco = PANEL_YMAX - BUTH - YSPACE;
2174         
2175         uiDefButS(block, MENU, B_REDR, "Constant QMC %x2|Adaptive QMC %x1|Constant Jittered %x0",
2176                 X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->ao_samp_method, 0, 0, 0, 0, "Method for generating shadow samples: Constant QMC: best quality, Adaptive QMC: fast in high contrast areas");
2177         
2178         yco -= YSPACE;
2179         
2180         if (wrld->ao_samp_method == WO_AOSAMP_HALTON) { 
2181                 uiBlockBeginAlign(block);
2182                 uiDefButF(block, NUM, B_REDR, "Threshold:",
2183                         X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->ao_adapt_thresh, 0.0, 1.0, 100, 0, "Samples below this threshold will be considered fully shadowed/unshadowed and skipped");
2184                 uiDefButF(block, NUMSLI, B_REDR, "Adapt Vec:",
2185                         X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->ao_adapt_speed_fac, 0.0, 1.0, 100, 0, "Use the speed vector pass to reduce AO samples in fast moving pixels. The higher the value, the more aggressive the sample reduction. Requires Vec pass enabled.");
2186                 uiBlockEndAlign(block);
2187         } else if (wrld->ao_samp_method == WO_AOSAMP_CONSTANT) {
2188                 uiDefButF(block, NUMSLI, B_REDR, "Bias:",
2189                         X2CLM2, yco-=BUTH, BUTW2, BUTH, &wrld->aobias, 0.0, 0.5, 10, 0, "Sets bias to prevent smoothed faces to show banding (in radians)");
2190         }
2191
2192
2193         yco = PANEL_YMAX - (5*BUTH+4*YSPACE);
2194
2195         /* result mix modes */
2196         uiBlockBeginAlign(block);
2197         uiDefButS(block, ROW, B_REDR, "Add",
2198                 X3CLM1, yco-=BUTH, BUTW3, BUTH, &wrld->aomix, 1.0, (float)WO_AOADD, 0, 0, "adds light/shadows");
2199         uiDefButS(block, ROW, B_REDR, "Sub",
2200                 X3CLM2, yco, BUTW3, BUTH, &wrld->aomix, 1.0, (float)WO_AOSUB, 0, 0, "subtracts light/shadows (needs at least one normal light to make anything visible)");
2201         uiDefButS(block, ROW, B_REDR, "Both",
2202                 X3CLM3, yco, BUTW3, BUTH, &wrld->aomix, 1.0, (float)WO_AOADDSUB, 0, 0, "both lightens & darkens");
2203
2204         yco -= YSPACE;
2205
2206         /* color treatment */
2207         uiBlockBeginAlign(block);
2208         uiDefButS(block, ROW, B_REDR, "Plain",
2209                 X3CLM1, yco-=BUTH, BUTW3, BUTH, &wrld->aocolor, 2.0, (float)WO_AOPLAIN, 0, 0, "Plain diffuse energy (white)");
2210         uiDefButS(block, ROW, B_REDR, "Sky Color", 
2211                 X3CLM2, yco, BUTW3, BUTH, &wrld->aocolor, 2.0, (float)WO_AOSKYCOL, 0, 0, "Use horizon and zenith color for diffuse energy");
2212         uiDefButS(block, ROW, B_REDR, "Sky Texture", 
2213                 X3CLM3, yco, BUTW3, BUTH, &wrld->aocolor, 2.0, (float)WO_AOSKYTEX, 0, 0, "Does full Sky texture render for diffuse energy");
2214         uiBlockEndAlign(block);
2215         
2216         yco -= YSPACE;
2217         
2218         uiDefButF(block, NUMSLI, B_REDR, "Energy:",
2219                 X2CLM1, yco-=BUTH, BUTW2, BUTH, &wrld->aoenergy, 0.01, 3.0, 100, 0, "Sets global energy scale for AO");
2220         
2221 }
2222
2223 static void world_panel_world(World *wrld)
2224 {
2225         uiBlock *block;
2226         
2227         block= uiNewBlock(&curarea->uiblocks, "world_panel_world", UI_EMBOSS, UI_HELV, curarea->win);
2228         if(uiNewPanel(curarea, block, "World", "World", 320, 0, 318, 204)==0) return;
2229
2230         uiBlockSetCol(block, TH_BUT_SETTING2);
2231         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);
2232
2233         if(wrld==NULL) return;
2234         
2235         uiSetButLock(wrld->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2236         uiBlockSetCol(block, TH_AUTO);
2237
2238         uiBlockBeginAlign(block);
2239         uiDefButF(block, COL, B_WORLDPRV, "",                   10,150,145,19, &wrld->horr, 0, 0, 0, B_COLHOR, "");
2240         uiDefButF(block, NUMSLI,B_WORLDPRV,"HoR ",      10,130,145,19,  &(wrld->horr), 0.0, 1.0, B_COLHOR,0, "Sets the amount of red color at the horizon");
2241         uiDefButF(block, NUMSLI,B_WORLDPRV,"HoG ",      10,110,145,19,  &(wrld->horg), 0.0, 1.0, B_COLHOR,0, "Sets the amount of green color at the horizon");
2242         uiDefButF(block, NUMSLI,B_WORLDPRV,"HoB ",      10,90,145,19,   &(wrld->horb), 0.0, 1.0, B_COLHOR,0, "Sets the amount of blue color at the horizon");
2243         
2244         uiBlockBeginAlign(block);
2245         uiDefButF(block, COL, B_WORLDPRV, "",                   160,150,145,19, &wrld->zenr, 0, 0, 0, B_COLZEN, "");
2246         uiDefButF(block, NUMSLI,B_WORLDPRV,"ZeR ",      160,130,145,19, &(wrld->zenr), 0.0, 1.0, B_COLZEN,0, "Sets the amount of red color at the zenith");
2247         uiDefButF(block, NUMSLI,B_WORLDPRV,"ZeG ",      160,110,145,19, &(wrld->zeng), 0.0, 1.0, B_COLZEN,0, "Sets the amount of green color at the zenith");
2248         uiDefButF(block, NUMSLI,B_WORLDPRV,"ZeB ",      160,90,145,19,  &(wrld->zenb), 0.0, 1.0, B_COLZEN,0, "Sets the amount of blue color at the zenith");
2249
2250         uiBlockBeginAlign(block);
2251         uiDefButF(block, COL, B_WORLDPRV, "",           10,70,145,19, &wrld->ambr, 0, 0, 0, 0, "");
2252         uiDefButF(block, NUMSLI,B_WORLDPRV,"AmbR ",     10,50,145,19,   &(wrld->ambr), 0.0, 1.0 ,0,0, "Sets the amount of red ambient color");
2253         uiDefButF(block, NUMSLI,B_WORLDPRV,"AmbG ",     10,30,145,19,   &(wrld->ambg), 0.0, 1.0 ,0,0, "Sets the amount of green ambient color");
2254         uiDefButF(block, NUMSLI,B_WORLDPRV,"AmbB ",     10,10,145,19,   &(wrld->ambb), 0.0, 1.0 ,0,0, "Sets the amount of blue ambient color");
2255
2256         uiBlockBeginAlign(block);
2257         uiBlockSetCol(block, TH_BUT_SETTING1);
2258         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");
2259         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");
2260
2261
2262 }
2263
2264 static void world_panel_preview(World *wrld)
2265 {
2266         uiBlock *block;
2267         
2268         /* name "Preview" is abused to detect previewrender offset panel */
2269         block= uiNewBlock(&curarea->uiblocks, "world_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
2270         if(uiNewPanel(curarea, block, "Preview", "World", 0, 0, 318, 204)==0) return;
2271         
2272         if(wrld==NULL) return;
2273
2274         uiSetButLock(wrld->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2275
2276         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
2277
2278         // label to force a boundbox for buttons not to be centered
2279         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
2280
2281         uiBlockBeginAlign(block);
2282         uiDefButBitS(block, TOG, WO_SKYREAL, B_WORLDPRV,"Real", 200,175,80,25, &wrld->skytype, 0, 0, 0, 0, "Renders background with a real horizon");
2283         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");
2284         uiDefButBitS(block, TOG,WO_SKYPAPER, B_WORLDPRV,"Paper",200,125,80,25, &wrld->skytype, 0, 0, 0, 0, "Flattens blend or texture coordinates");
2285         uiBlockEndAlign(block);
2286
2287 }
2288
2289 /* ************************ LAMP *************************** */
2290
2291 void do_lampbuts(unsigned short event)
2292 {
2293         static short mtexcopied=0;
2294         static MTex mtexcopybuf;
2295         Lamp *la;
2296         MTex *mtex;
2297
2298         switch(event) {
2299         case B_LAMPREDRAW:
2300                 BIF_preview_changed(ID_LA);
2301                 allqueue(REDRAWVIEW3D, 0);
2302                 allqueue(REDRAWBUTSSHADING, 0);
2303                 break;
2304         case B_TEXCLEARLAMP:
2305                 la= G.buts->lockpoin;
2306                 mtex= la->mtex[ la->texact ];
2307                 if(mtex) {
2308                         if(mtex->tex) mtex->tex->id.us--;
2309                         MEM_freeN(mtex);
2310                         la->mtex[ la->texact ]= 0;
2311                         BIF_undo_push("Unlink world texture");
2312                         allqueue(REDRAWBUTSSHADING, 0);
2313                         allqueue(REDRAWOOPS, 0);
2314                         BIF_preview_changed(ID_LA);
2315                 }
2316                 break;
2317         case B_SBUFF:
2318                 la= G.buts->lockpoin;
2319                 la->bufsize = la->bufsize&=(~15); 
2320                 allqueue(REDRAWBUTSSHADING, 0); 
2321                 allqueue(REDRAWOOPS, 0); 
2322                 break; 
2323         case B_SHADBUF:
2324                 la= G.buts->lockpoin; 
2325                 la->mode &= ~LA_SHAD_RAY;
2326                 allqueue(REDRAWBUTSSHADING, 0); 
2327                 allqueue(REDRAWVIEW3D, 0);              
2328                 break;
2329         case B_SHADRAY:
2330                 la= G.buts->lockpoin; 
2331                 la->mode &= ~LA_SHAD_BUF;
2332                 /* yafray: 'softlight' uses it's own shadbuf. flag.
2333                    Must be cleared here too when switching from ray shadow */
2334                 la->mode &= ~LA_YF_SOFT;
2335                 allqueue(REDRAWBUTSSHADING, 0);
2336                 allqueue(REDRAWVIEW3D, 0);      
2337                 break;
2338         case B_LMTEXCOPY:
2339                 la= G.buts->lockpoin;
2340                 if(la && la->mtex[(int)la->texact] ) {
2341                         mtex= la->mtex[(int)la->texact];
2342                         if(mtex->tex==NULL) {
2343                                 error("No texture available");
2344                         }
2345                         else {
2346                                 memcpy(&mtexcopybuf, la->mtex[(int)la->texact], sizeof(MTex));
2347                                 mtexcopied= 1;
2348                         }
2349                 }
2350                 break;
2351         case B_LMTEXPASTE:
2352                 la= G.buts->lockpoin;
2353                 if(la && mtexcopied && mtexcopybuf.tex) {
2354                         if(la->mtex[(int)la->texact]==NULL ) 
2355                                 la->mtex[(int)la->texact]= MEM_mallocN(sizeof(MTex), "mtex"); 
2356                         else if(la->mtex[(int)la->texact]->tex)
2357                                 la->mtex[(int)la->texact]->tex->id.us--;
2358
2359                         memcpy(la->mtex[(int)la->texact], &mtexcopybuf, sizeof(MTex));
2360                         
2361                         id_us_plus((ID *)mtexcopybuf.tex);
2362                         BIF_undo_push("Paste mapping settings");
2363                         BIF_preview_changed(ID_LA);
2364                         scrarea_queue_winredraw(curarea);
2365                 }
2366                 break;
2367         case B_LFALLOFFCHANGED:
2368                 la= G.buts->lockpoin;
2369                 curvemapping_changed(la->curfalloff, 1);
2370                 BIF_undo_push("Edit Lamp falloff curve");
2371                 BIF_preview_changed(ID_LA);
2372                 scrarea_queue_winredraw(curarea);
2373                 break;
2374                 
2375         }
2376 }
2377
2378
2379 static void lamp_panel_mapto(Object *ob, Lamp *la)
2380 {
2381         uiBlock *block;
2382         MTex *mtex;
2383         
2384         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_mapto", UI_EMBOSS, UI_HELV, curarea->win);
2385         uiNewPanelTabbed("Texture and Input", "Lamp");
2386         if(uiNewPanel(curarea, block, "Map To", "Lamp", 1280, 0, 318, 204)==0) return;
2387
2388         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2389
2390         mtex= la->mtex[ la->texact ];
2391         if(mtex==NULL) {
2392                 mtex= &emptytex;
2393                 default_mtex(mtex);
2394                 mtex->texco= TEXCO_VIEW;
2395         }
2396
2397         /* TEXTURE OUTPUT */
2398         uiBlockBeginAlign(block);
2399         uiDefButBitS(block, TOG, MTEX_STENCIL, B_LAMPPRV, "Stencil",    10,125,45,19, &(mtex->texflag), 0, 0, 0, 0, "Use this texture as a blending value on the next texture");
2400         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");
2401         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");
2402         uiBlockEndAlign(block);
2403         
2404         uiBlockBeginAlign(block);
2405         uiDefButF(block, COL, B_LAMPPRV, "",                    10,100,135,19, &(mtex->r), 0, 0, 0, B_MTEXCOL, "");
2406         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");
2407         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");
2408         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");
2409         uiBlockEndAlign(block);
2410         uiDefButF(block, NUMSLI, B_LAMPPRV, "DVar ",                    10,10,135,19, &(mtex->def_var), 0.0, 1.0, 0, 0, "Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard");
2411         
2412         /* MAP TO */
2413         uiDefButBitS(block, TOG, MAP_COL, B_LAMPPRV, "Col",             10,180,135,19, &(mtex->mapto), 0, 0, 0, 0, "Lets the texture affect the basic color of the lamp");
2414         
2415         uiBlockBeginAlign(block);
2416         uiDefButS(block, MENU, B_LAMPPRV, mapto_blendtype_pup(),155,125,155,19, &(mtex->blendtype), 0, 0, 0, 0, "Texture blending mode");
2417         uiBlockEndAlign(block);
2418
2419         uiDefButF(block, NUMSLI, B_LAMPPRV, "Col  ",                    155,100,155,19, &(mtex->colfac), 0.0, 1.0, 0, 0, "Sets the amount the texture affects color values");
2420
2421 }
2422
2423
2424 static void lamp_panel_texture(Object *ob, Lamp *la)
2425 {
2426         uiBlock *block;
2427         MTex *mtex;
2428         ID *id;
2429         int a, loos;
2430         char *strp, str[64];
2431         
2432         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_texture", UI_EMBOSS, UI_HELV, curarea->win);
2433         if(uiNewPanel(curarea, block, "Texture and Input", "Lamp", 960, 0, 318, 204)==0) return;
2434
2435         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2436
2437         /* TEX CHANNELS */
2438         uiBlockSetCol(block, TH_BUT_NEUTRAL);
2439         uiBlockBeginAlign(block);
2440         for(a= 0; a<MAX_MTEX; a++) {
2441                 mtex= la->mtex[a];
2442                 if(mtex && mtex->tex) splitIDname(mtex->tex->id.name+2, str, &loos);
2443                 else strcpy(str, "");
2444                 str[10]= 0;
2445                 uiDefButS(block, ROW, B_REDR, str,      10, 160-18*a, 80, 20, &(la->texact), 3.0, (float)a, 0, 0, "");
2446         }
2447         uiBlockEndAlign(block);
2448         
2449         mtex= la->mtex[ la->texact ];
2450         if(mtex==NULL) {
2451                 mtex= &emptytex;
2452                 default_mtex(mtex);
2453                 mtex->texco= TEXCO_VIEW;
2454         }
2455
2456         /* TEXTUREBLOK SELECT */
2457         uiBlockSetCol(block, TH_BUT_SETTING2);
2458         id= (ID *)mtex->tex;
2459         IDnames_to_pupstring(&strp, NULL, "ADD NEW %x 32767", &(G.main->tex), id, &(G.buts->texnr));
2460         
2461         /* doesnt work, because lockpoin points to lamp, not to texture */
2462         uiDefButS(block, MENU, B_LTEXBROWSE, strp, 100,140,20,19, &(G.buts->texnr), 0, 0, 0, 0, "Selects an existing texture or creates new");  
2463         MEM_freeN(strp);
2464         
2465         if(id) {
2466                 uiDefBut(block, TEX, B_IDNAME, "TE:",   100,160,200,19, id->name+2, 0.0, 21.0, 0, 0, "Displays name of the texture block: click to change");
2467                 sprintf(str, "%d", id->us);
2468                 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");
2469                 uiDefIconBut(block, BUT, B_AUTOTEXNAME, ICON_AUTO, 221,140,21,19, 0, 0, 0, 0, 0, "Auto-assigns name to texture");
2470                 if(id->lib) {
2471                         if(la->id.lib) uiDefIconBut(block, BUT, 0, ICON_DATALIB,        219,140,21,19, 0, 0, 0, 0, 0, "");
2472                         else uiDefIconBut(block, BUT, 0, ICON_PARLIB,   219,140,21,19, 0, 0, 0, 0, 0, "");      
2473                 }
2474                 uiBlockSetCol(block, TH_AUTO);
2475                 uiDefBut(block, BUT, B_TEXCLEARLAMP, "Clear", 122, 140, 72, 19, 0, 0, 0, 0, 0, "Erases link to texture");
2476         }
2477         else 
2478                 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");
2479
2480         /* copy/paste */
2481         uiBlockBeginAlign(block);
2482         uiDefIconBut(block, BUT, B_LMTEXCOPY, ICON_COPYUP,      250,140,25,19, 0, 0, 0, 0, 0, "Copies the mapping settings to the buffer");
2483         uiDefIconBut(block, BUT, B_LMTEXPASTE, ICON_PASTEUP,    275,140,25,19, 0, 0, 0, 0, 0, "Pastes the mapping settings from the buffer");
2484         
2485         /* TEXCO */
2486         uiBlockSetCol(block, TH_AUTO);
2487         uiBlockBeginAlign(block);
2488         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");
2489         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");
2490         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");
2491         uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_LAMPPRV, "", 100,90,200,20, &(mtex->object), "");
2492         
2493         uiBlockBeginAlign(block);
2494         uiDefButF(block, NUM, B_LAMPPRV, "dX",          100,50,100,18, mtex->ofs, -20.0, 20.0, 10, 0, "Fine tunes texture mapping X coordinate");
2495         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");
2496         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");
2497         uiBlockBeginAlign(block);
2498         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");
2499         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");
2500         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");
2501         uiBlockEndAlign(block);
2502 }
2503
2504 static void lamp_panel_spot(Object *ob, Lamp *la)
2505 {
2506         uiBlock *block;
2507         float grid=0.0;
2508         
2509         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_spot", UI_EMBOSS, UI_HELV, curarea->win);
2510         if(uiNewPanel(curarea, block, "Shadow and Spot", "Lamp", 640, 0, 318, 204)==0) return;
2511
2512         /* hemis and ray shadow dont work at all... */
2513         /* yafray: ignore photonlight as well */
2514         if ((la->type==LA_HEMI) || (la->type==LA_YF_PHOTON)) return;
2515
2516         if(G.vd) grid= G.vd->grid; 
2517         if(grid<1.0) grid= 1.0;
2518
2519         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2520
2521         uiBlockSetCol(block, TH_BUT_SETTING1);
2522         uiBlockBeginAlign(block);
2523         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");
2524         if(la->type==LA_SPOT) {
2525                 uiDefButBitS(block, TOG, LA_SHAD_BUF, B_SHADBUF, "Buf.Shadow",10,160,80,19,&la->mode, 0, 0, 0, 0, "Lets spotlight produce shadows using shadow buffer");
2526                 if(la->mode & LA_SHAD_BUF) {
2527                         char *tip= "Regular buffer type";
2528                         if(la->buftype==LA_SHADBUF_IRREGULAR)
2529                                 tip= "Irregular buffer produces sharp shadow always, but it doesn't show up for raytracing";
2530                         else if(la->buftype==LA_SHADBUF_HALFWAY)
2531                                 tip= "Regular buffer, averaging the closest and 2nd closest Z value for reducing biasing";
2532                         
2533                         uiDefButC(block, MENU, B_REDR, "Classical %x0|Classic-Halfway %x2|Irregular %x1", 10,140,80,19,&la->buftype, 0, 0, 0, 0, tip);
2534                 }
2535         }
2536         uiBlockEndAlign(block);
2537         
2538         uiDefButBitS(block, TOG, LA_ONLYSHADOW, B_LAMPPRV,"OnlyShadow",         10,110,80,19,&la->mode, 0, 0, 0, 0, "Causes light to cast shadows only without illuminating objects");
2539
2540         if(la->type==LA_SPOT) {
2541                 uiBlockBeginAlign(block);
2542                 uiDefButBitS(block, TOG, LA_SQUARE, B_LAMPREDRAW,"Square",      10,60,80,19,&la->mode, 0, 0, 0, 0, "Sets square spotbundles");
2543                 uiDefButBitS(block, TOG, LA_HALO, B_LAMPREDRAW,"Halo",          10,40,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
2544
2545                 uiBlockBeginAlign(block);
2546                 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");
2547                 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");
2548                 uiBlockEndAlign(block);
2549         
2550                 uiDefButF(block, NUMSLI,B_LAMPREDRAW,"HaloInt ",                        100,135,200,19,&la->haint, 0.0, 5.0, 0, 0, "Sets the intensity of the spotlight halo");
2551                 
2552                 if(la->mode & LA_SHAD_BUF) {
2553                         if(ELEM(la->buftype, LA_SHADBUF_REGULAR, LA_SHADBUF_HALFWAY)) {
2554                                 uiBlockBeginAlign(block);
2555                                 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");
2556                                 uiDefButS(block, ROW,B_NOP,     "Box",                          100,90,65,19, &la->filtertype, 0.0, LA_SHADBUF_BOX, 0, 0, "Apply Box filter for shadowbuffer samples");
2557                                 uiDefButS(block, ROW,B_NOP,     "Tent",                         165,90,65,19, &la->filtertype, 0.0, LA_SHADBUF_TENT, 0, 0, "Apply Tent filter for shadowbuffer samples");
2558                                 uiDefButS(block, ROW,B_NOP,     "Gauss",                        230,90,70,19, &la->filtertype, 0.0, LA_SHADBUF_GAUSS, 0, 0, "Apply Gauss filter for shadowbuffer samples");
2559                                 
2560         //                      uiDefButS(block, ROW,B_NOP,"SubSamples: 1",             100,90,140,19, &la->buffers, 1.0, 1.0, 0, 0, "Amount of lampbuffer subsamples, a value of larger than 1 halves the shadowbuffer size");
2561         //                      uiDefButS(block, ROW,B_NOP,"4",                                 240,90,30,19, &la->buffers, 1.0, 4.0, 0, 0, "Amount of lampbuffer subsamples, this halves the actual shadowbuffer size");
2562         //                      uiDefButS(block, ROW,B_NOP,"9",                                 270,90,30,19, &la->buffers, 1.0, 9.0, 0, 0, "Amount of lampbuffer subsamples, this halves the shadowbuffer size");
2563                         
2564                                 uiBlockBeginAlign(block);
2565                                 uiDefButS(block, NUM,B_LAMPREDRAW,"Samples:",   100,60,100,19,  &la->samp,1.0,16.0, 0, 0, "Sets the number of shadow map samples");
2566                                 uiDefButS(block, NUM,B_NOP,"Halo step:",                200,60,100,19,  &la->shadhalostep, 0.0, 12.0, 0, 0, "Sets the volumetric halo sampling frequency");
2567                                 uiDefButF(block, NUM,B_LAMPREDRAW,"Bias:",              100,40,100,19,  &la->bias, 0.001, 5.0, 1, 0, "Sets the shadow map sampling bias");
2568                                 uiDefButF(block, NUM,B_LAMPREDRAW,"Soft:",              200,40,100,19,  &la->soft,1.0,100.0, 100, 0, "Sets the size of the shadow sample area");
2569                         }
2570                         else {  /* LA_SHADBUF_IRREGULAR */
2571                                 uiDefButF(block, NUM,B_LAMPREDRAW,"Bias:",              100,40,100,19,  &la->bias, 0.01, 5.0, 1, 0, "Sets the shadow map sampling bias");
2572                         }
2573                         
2574                         uiBlockBeginAlign(block);
2575                         uiDefIconButBitC(block, TOG, LA_SHADBUF_AUTO_START, B_REDR, ICON_AUTO,  10, 10, 25, 19, &la->bufflag, 0.0, 0.0, 0, 0, "Automatic calculation of clipping-start, based on visible vertices");
2576                         if(la->bufflag & LA_SHADBUF_AUTO_START)
2577                                 uiDefBut(block, LABEL, B_NOP, "ClipSta: Auto",  35,10,115,19,   NULL, 0, 0, 0, 0, "");
2578                         else
2579                                 uiDefButF(block, NUM,REDRAWVIEW3D,"ClipSta:",   35,10,115,19,   &la->clipsta, 0.1*grid,1000.0*grid, 10, 0, "Sets the shadow map clip start: objects closer will not generate shadows");
2580                         uiDefIconButBitC(block, TOG, LA_SHADBUF_AUTO_END, B_REDR, ICON_AUTO,    160, 10, 25, 19, &la->bufflag, 0.0, 0.0, 0, 0, "Automatic calculation of clipping-end, based on visible vertices");
2581                         if(la->bufflag & LA_SHADBUF_AUTO_END)
2582                                 uiDefBut(block, LABEL,B_NOP, "ClipEnd: Auto",   185,10,115,19,  NULL, 0, 0, 0, 0, "");
2583                         else
2584                                 uiDefButF(block, NUM,REDRAWVIEW3D,"ClipEnd:",   185,10,115,19,&la->clipend, 1.0, 5000.0*grid, 100, 0, "Sets the shadow map clip end beyond which objects will not generate shadows");
2585                         uiBlockEndAlign(block);
2586                         
2587                 }
2588         }
2589         if(ELEM4(la->type, LA_AREA, LA_SPOT, LA_SUN, LA_LOCAL) && (la->mode & LA_SHAD_RAY)) {
2590                 
2591                 if (ELEM3(la->type, LA_SPOT, LA_SUN, LA_LOCAL)) {
2592                         if (la->ray_samp_method == LA_SAMP_CONSTANT) la->ray_samp_method = LA_SAMP_HALTON;
2593                 
2594                         uiDefButS(block, MENU, B_REDR, "Adaptive QMC %x1|Constant QMC %x2",
2595                                 100,110,200,19, &la->ray_samp_method, 0, 0, 0, 0, "Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower");
2596                 
2597                         uiDefButF(block, NUM,B_LAMPREDRAW,"Soft Size",  100,80,200,19, &la->area_size, 0.01, 100.0, 10, 0, "Area light size, doesn't affect energy amount");
2598                         
2599                         uiDefButS(block, NUM,0,"Samples:",      100,60,200,19,  &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of samples taken extra (samp x samp)");
2600                         uiDefButF(block, NUM,0,"Threshold:",    100,40,200,19,  &la->adapt_thresh, 0.0, 1.0, 100, 0, "Threshold for adaptive sampling, to control what level is considered already in shadow");
2601                 }
2602                 else if (la->type == LA_AREA) {
2603                         uiDefButS(block, MENU, B_REDR, "Adaptive QMC %x1|Constant QMC %x2|Constant Jittered %x0",
2604                                 100,180,200,19, &la->ray_samp_method, 0, 0, 0, 0, "Method for generating shadow samples: Adaptive QMC is fastest");
2605                 
2606                         if(la->area_shape==LA_AREA_SQUARE) 
2607                                 uiDefButS(block, NUM,0,"Samples:",      100,150,200,19, &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of samples taken extra (samp x samp)");
2608                         else if(la->area_shape==LA_AREA_CUBE) 
2609                                 uiDefButS(block, NUM,0,"Samples:",      100,130,200,19, &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of samples taken extra (samp x samp x samp)");
2610
2611                         if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_BOX)) {
2612                                 uiDefButS(block, NUM,0,"SamplesX:",     100,150,200,19, &la->ray_samp, 1.0, 16.0, 100, 0, "Sets the amount of X samples taken extra");
2613                                 uiDefButS(block, NUM,0,"SamplesY:",     100,130,200,19, &la->ray_sampy, 1.0, 16.0, 100, 0, "Sets the amount of Y samples taken extra");
2614                                 if(la->area_shape==LA_AREA_BOX)
2615                                         uiDefButS(block, NUM,0,"SamplesZ:",     100,110,200,19, &la->ray_sampz, 1.0, 8.0, 100, 0, "Sets the amount of Z samples taken extra");
2616                         }
2617                         
2618                         if (la->ray_samp_method == LA_SAMP_CONSTANT) {
2619                                 uiBlockBeginAlign(block);
2620                                 uiDefButBitS(block, TOG, LA_SAMP_UMBRA, 0,"Umbra",                      100,90,200,19,&la->ray_samp_type, 0, 0, 0, 0, "Emphasis parts that are fully shadowed");
2621                                 uiDefButBitS(block, TOG, LA_SAMP_DITHER, 0,"Dither",                    100,70,100,19,&la->ray_samp_type, 0, 0, 0, 0, "Use 2x2 dithering for sampling");
2622                                 uiDefButBitS(block, TOG, LA_SAMP_JITTER, 0,"Noise",                     200,70,100,19,&la->ray_samp_type, 0, 0, 0, 0, "Use noise for sampling");
2623                         } else if (la->ray_samp_method == LA_SAMP_HALTON) {
2624                                 uiDefButF(block, NUM,0,"Threshold:",    100,90,200,19,  &la->adapt_thresh, 0.0, 1.0, 100, 0, "Threshold for adaptive sampling, to control what level is considered already in shadow");
2625                         }
2626                 }
2627                 
2628                 
2629         }
2630         else uiDefBut(block, LABEL,0," ",       100,180,200,19,NULL, 0, 0, 0, 0, "");
2631
2632 }
2633
2634 /* yafray: adaptation of lamp_panel_spot above with yafray specific parameters */
2635 static void lamp_panel_yafray(Object *ob, Lamp *la)
2636 {
2637         uiBlock *block;
2638         
2639         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_yafray", UI_EMBOSS, UI_HELV, curarea->win);
2640         if(uiNewPanel(curarea, block, "Yafray: Shadow and Photons", "Lamp", 640, 0, 318, 204)==0) return;
2641
2642         /* hemis not used in yafray */
2643         if(la->type==LA_HEMI) return;
2644         
2645         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2646         
2647                 /* photonlight params */
2648         if (la->type==LA_YF_PHOTON) {
2649                 uiBlockSetCol(block, TH_BUT_SETTING1);
2650                 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)");
2651                 uiBlockSetCol(block, TH_AUTO);
2652                 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");
2653                 uiDefButI(block, NUM,B_DIFF,"photons:", 10,150,290,19,  &la->YF_numphotons, 10000, 100000000, 0, 0, "Maximum number of photons to shoot");
2654                 uiDefButI(block, NUM,B_DIFF,"search:", 10,130,290,19,   &la->YF_numsearch, 100, 1000, 0, 0, "Number of photons to mix (blur)");
2655                 uiDefButS(block, NUM,B_DIFF,"depth:", 10,100,290,19,    &la->YF_phdepth, 1, 100, 0, 0, "Maximum caustic bounce depth");
2656                 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)");
2657                 return;
2658         }
2659
2660         uiBlockSetCol(block, TH_BUT_SETTING1);
2661         
2662         /* in yafray arealights always cast shadows, so ray shadow flag not needed */
2663         /* ray shadow also not used when halo for spot enabled */
2664         if ((la->type!=LA_AREA) && (!((la->type==LA_SPOT) && (la->mode & LA_HALO))))
2665                 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");
2666         
2667         /* in yafray the regular lamp can use shadowbuffers (softlight), used by spot with halo as well */
2668         /* to prevent clash with blender shadowbuf flag, a special flag is used for yafray */
2669         if (la->type==LA_LOCAL) {
2670                 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");
2671                 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");
2672                 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");
2673                 uiDefButS(block, NUM, B_DIFF, "GlowType:", 200,135,100,19, &la->YF_glowtype, 0, 1, 1, 0, "Sets light glow type");
2674         }
2675         
2676         /* shadowbuffers used only for 'softlight' & spotlight with halo */
2677         if (((la->type==LA_LOCAL) && (la->mode & LA_YF_SOFT)) || ((la->type==LA_SPOT) && (la->mode & LA_HALO))) {
2678                 /* Shadow buffer size can be anything in yafray, but reasonable minimum is 128 */
2679                 /* Maximum is 1024, since zbuf in yafray is float, no multiple of 16 restriction */
2680                 uiDefButS(block, NUM,B_DIFF,"ShadowBufferSize:", 100,110,200,19,        &la->YF_bufsize, 128, 1024, 0, 0, "Sets the size of the shadow buffer");
2681
2682                 /* samples & halostep params only used for spotlight with halo */
2683                 if ((la->type==LA_SPOT) && (la->mode & LA_HALO)) {
2684                         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");
2685                         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");
2686                 }
2687                 uiDefButF(block, NUM,B_DIFF,"Bias:",                    100,10,100,19,  &la->bias, 0.01, 5.0, 1, 0, "Sets the shadow map sampling bias");
2688                 /* here can use the Blender soft param, since for yafray it has the same function as in Blender */
2689                 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");
2690         }
2691         else if ((la->type==LA_LOCAL) && (la->mode & LA_SHAD_RAY)) {
2692                 /* for spherelight, light radius */
2693                 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");
2694         }
2695         
2696         if (la->type==LA_SPOT) {
2697
2698                 uiDefButBitS(block, TOG, LA_HALO, B_LAMPREDRAW,"Halo",                          10,50,80,19,&la->mode, 0, 0, 0, 0, "Renders spotlight with a volumetric halo"); 
2699
2700                 uiBlockSetCol(block, TH_AUTO);
2701                 uiBlockBeginAlign(block);
2702                 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");
2703                 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");
2704                 uiBlockEndAlign(block);
2705         
2706                 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");
2707         }
2708         else if ((la->type==LA_AREA) || ((la->type==LA_LOCAL) && (la->mode & LA_SHAD_RAY))) {
2709                 /* area samples param also used for 'spherelight' */
2710                 uiBlockBeginAlign(block);
2711                 uiBlockSetCol(block, TH_AUTO);
2712                 
2713                 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)");
2714
2715                 /* shadow sampling types not used in yafray, removed */
2716         }
2717         else uiDefBut(block, LABEL,0," ",       100,180,200,19,NULL, 0, 0, 0, 0, "");   
2718
2719 }
2720
2721 static void lamp_panel_falloff(Object *ob, Lamp *la)
2722 {
2723         uiBlock *block;
2724         rctf butr;
2725         short yco=PANEL_YMAX;
2726         float grid= 0.0;
2727         
2728         /* name "Preview" is abused to detect previewrender offset panel */
2729         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_falloff", UI_EMBOSS, UI_HELV, curarea->win);
2730         uiNewPanelTabbed("Lamp", "Lamp");
2731         if(uiNewPanel(curarea, block, "Falloff Curve", "Lamp", PANELX, PANELY, PANELW, PANELH)==0) return;
2732         
2733         if(G.vd) grid= G.vd->grid; 
2734         if(grid<1.0) grid= 1.0;
2735         
2736         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2737         
2738         BLI_init_rctf(&butr, 10.0, 310.0, 10.0, (float)yco);
2739         curvemap_buttons(block, la->curfalloff, 's', B_LFALLOFFCHANGED, B_LAMPREDRAW, &butr);
2740         
2741 }
2742
2743 static void lamp_panel_lamp(Object *ob, Lamp *la)
2744 {
2745         uiBlock *block;
2746         float grid= 0.0;
2747         short xco;
2748         
2749         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_lamp", UI_EMBOSS, UI_HELV, curarea->win);
2750         if(uiNewPanel(curarea, block, "Lamp", "Lamp", 320, 0, 318, 204)==0) return;
2751
2752         if(G.vd) grid= G.vd->grid; 
2753         if(grid<1.0) grid= 1.0;
2754
2755         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2756
2757         uiBlockSetCol(block, TH_BUT_SETTING2);
2758         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);  
2759
2760         uiBlockSetCol(block, TH_AUTO);
2761         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");
2762
2763         uiBlockBeginAlign(block);
2764         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2765         if(la->type==LA_AREA) {
2766                 //uiDefButS(block, MENU, B_LAMPREDRAW, "Shape %t|Square %x0|Rect %x1|Cube %x2|Box %x3",
2767                 uiDefButS(block, MENU, B_LAMPREDRAW, "Shape %t|Square %x0|Rect %x1",
2768                                 10, 150, 100, 19, &la->area_shape, 0,0,0,0, "Sets area light shape");   
2769                 if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_BOX)){
2770                         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");
2771                         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");
2772                 }
2773                 if(la->area_shape==LA_AREA_BOX)
2774                         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");
2775                 if (ELEM(la->area_shape, LA_AREA_SQUARE, LA_AREA_CUBE))
2776                         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");
2777         }
2778         else if( ELEM(la->type, LA_LOCAL, LA_SPOT)) {
2779                 uiBlockSetCol(block, TH_BUT_SETTING1);
2780                 uiDefButS(block, MENU, B_LAMPREDRAW,  "Falloff %t|Constant %x0|Inverse Linear %x1|Inverse Square %x2|Custom Curve %x3|Lin/Quad Weighted %x4|",
2781                         10,150,100,19, &la->falloff_type, 0,0,0,0, "Lamp falloff - intensity decay with distance");     
2782                 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");
2783         }
2784
2785         uiBlockBeginAlign(block);
2786         uiBlockSetCol(block, TH_BUT_SETTING1);
2787         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");
2788         uiDefButBitS(block, TOG, LA_NEG, B_LAMPPRV,"Negative",  10,50,100,19,&la->mode, 0, 0, 0, 0, "Sets lamp to cast negative light");
2789         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");
2790         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");
2791         uiBlockEndAlign(block);
2792
2793         uiBlockSetCol(block, TH_AUTO);
2794         uiDefButF(block, NUMSLI,B_LAMPPRV,"Energy ",    120,150,180,20, &(la->energy), 0.0, 10.0, 0, 0, "Sets the intensity of the light");
2795
2796         uiBlockBeginAlign(block);
2797         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");
2798         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");
2799         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");
2800         uiBlockEndAlign(block);
2801         
2802         uiDefButF(block, COL, B_LAMPPRV, "",            120,52,180,24, &la->r, 0, 0, 0, B_COLLAMP, "");
2803         
2804         uiBlockBeginAlign(block);
2805         if (ELEM(la->type, LA_LOCAL, LA_SPOT) && (la->falloff_type == LA_FALLOFF_SLIDERS)) {
2806                 uiDefButF(block, NUMSLI,B_LAMPPRV,"Linear ",    120,30,180,19,&la->att1, 0.0, 1.0, 0, 0, "Set the linear distance attenuatation for a quad lamp");
2807                 uiDefButF(block, NUMSLI,B_LAMPPRV,"Quad ",  120,10,180,19,&la->att2, 0.0, 1.0, 0, 0, "Set the quadratic distance attenuatation for a quad lamp");
2808         }
2809         else if(la->type==LA_AREA) {
2810                 if(la->k==0.0) la->k= 1.0;
2811                 uiDefButF(block, NUMSLI,0,"Gamma ",     120,10,180,19,&la->k, 0.001, 2.0, 100, 0, "Set the light gamma correction value");
2812         }
2813 }
2814
2815
2816 static void lamp_panel_preview(Object *ob, Lamp *la)
2817 {
2818         uiBlock *block;
2819         
2820         /* name "Preview" is abused to detect previewrender offset panel */
2821         block= uiNewBlock(&curarea->uiblocks, "lamp_panel_preview", UI_EMBOSS, UI_HELV, curarea->win);
2822         if(uiNewPanel(curarea, block, "Preview", "Lamp", 0, 0, 318, 204)==0) return;
2823         
2824         uiSetButLock(la->id.lib!=0, ERROR_LIBDATA_MESSAGE);
2825
2826         uiBlockSetDrawExtraFunc(block, BIF_previewdraw);
2827
2828         // label to force a boundbox for buttons not to be centered
2829         uiDefBut(block, LABEL, 0, " ",  20,20,10,10, 0, 0, 0, 0, 0, "");
2830         uiBlockBeginAlign(block);
2831         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");
2832         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");
2833         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");
2834         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");
2835         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");
2836         /* yafray: extra type, photonlight */
2837         if (G.scene->r.renderer==R_YAFRAY)
2838                 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");
2839 }
2840
2841
2842 /* ****************** MATERIAL ***************** */
2843
2844
2845 void do_matbuts(unsigned short event)
2846 {
2847         static short mtexcopied=0;
2848         static MTex mtexcopybuf;
2849         Material *ma;
2850         MTex *mtex;
2851
2852         /* all operations default on active material layer here */
2853         /* but this also gets called for lamp and world... */
2854         ma= G.buts->lockpoin;
2855         if(ma && GS(ma->id.name)==ID_MA)
2856                 ma = editnode_get_active_material(ma);
2857         else
2858                 ma= NULL;
2859         
2860         switch(event) {
2861         case B_MAT_YF_PRESET: {
2862                 switch (ma->YF_preset) {
2863                         case 0:
2864                                 /* normal mode, no reflection/refraction */
2865                                 ma->alpha = 1;
2866                                 ma->mode &= ~(MA_RAYMIRROR+MA_RAYTRANSP+MA_ZTRA);
2867                                 break;
2868                         case 1: {
2869                                 /* clear glass */
2870                                 ma->alpha = 0.001;
2871